Last 7 days
0
Features: 0
Changes: 0
Fixes: 0
Deprecations: 0
Kotlin
Modern multiplatform programming language maintained by JetBrains.
Latest Kotlin changelog updates, official release notes, breaking changes, security patches, pricing changes, and developer reactions in one product feed.
Follow this Kotlin release-notes page to spot useful features, risky migrations, noisy announcements, and source links before they hit your backlog.
Where Kotlin updates are checked
Changes.Watch links back to official changelog and release-note sources so summaries stay easy to verify.
Related changelog channels
Use channels to follow groups of tools around a stack, workflow, or topic.
Kotlin updates by type
Rolling windows show how many product updates landed in the last 7, 30, 90, and 365 days, grouped by existing changelog semantics.
0
0
2
8
Latest Kotlin changelog updates
Fixed multiple compiler backend issues: missing WASM files in multimodule builds, JVM annotation parameter error, wrong sourcePsi for SymbolPsiLiteral, and reified type inference in inline lambdas
Expanded the Analysis API with KDoc support, KMP handling, dumb‑mode analysis, streaming diagnostics, automatic mode detection, and extensive test infrastructure updates.
Fixed numerous compiler and platform bugs (e.g., Wasm compilation, JVM @JvmRecord issue, native ObjC type casts, JS incremental plugin support, scripting internal errors)
Added extensive new capabilities to the Analysis API, including stubs support, contracts for property accessors, context parameters, KDoc extraction, collection literals, and numerous API clarifications and deprecations.
Multiple compiler and reflection bugs fixed, including data races in kotlinx.serialization plugin registration, ClassCastException with UInt, unstable enhanced nullability resolution, flaky overload resolution, @NoInfer regression, NoWhe...
Added extensive Analysis API enhancements, including cross‑file redeclaration checks, call candidate deduplication, session logging, memory optimizations, and IntelliJ Bazel build support
Fixed Wasm and Kotlin/JS runtime bugs, including JavaScriptCore exception handling, interface export with ES modules, and BigInt engine requirements.
Extensive Analysis API and K2 improvements: added lazy resolution, performance boosts, support for context parameters, exposed boxed inline value classes, and numerous FIR/visibility bug fixes.
Fixed numerous compiler crashes and IR lowering errors across JVM, JS, Native, and K2, including null pointer, assertion, and missing diagnostics issues.
Migrated analysis sources to a new IR parameter API, renamed key symbols (classIdIfNonLocal → classId, callableIdIfNonLocal → callableId) and added full context‑parameter support in the Analysis API and K2.
Fixed multiple backend and native bugs, including lldb stepping, simulator stacktrace symbolication, native crashes (GC.collect, generic value classes), redundant unboxing, and IR lowering errors.
Extensive fixes and performance upgrades for the Analysis API, including optimized FIR caching, session invalidation, and support for application service registration in plugins.
Compiler and K2 fixes: corrected type‑alias mapping, inner constructor references, visibility checks, generic field casts, and added missing diagnostics.
Extensive Analysis API enhancements: new KotlinDirectInheritorsProvider option, support for Wasm target, weak‑reference session caches, stop‑the‑world invalidation, abbreviated type tests, and expanded symbol/pointer APIs.
Added Xcode 16 support for Apple ecosystem with updated LLVM 11 clang headers, Float16 fixes on macOS, and rebuilt platform libraries.
Refactored the Analysis API extensively: renamed Kt symbols to Ka, introduced new KaSymbol interfaces, stabilized scopes, added PSI validity checks, and integrated project‑structure modules while limiting exposure to abstract interfaces.
- Fixed a wide range of K2 compiler crashes, incorrect diagnostics, annotation handling and performance regressions across JVM, JS, Wasm and Native.
Added generation of lookups in dumb mode to maintain compatibility with the reference index.
Introduced new Analysis API features such as klib content reading, virtual file inputs, type annotation support, KtCodeFragment handling, concurrent session invalidation, and multi‑threaded resolve.
Fixed Wasm compiler crash, false positive unresolved references, and native ProtoBuf array issue.
Fix cinterop task failures on Xcode 15.3 and resolve multiple compiler bugs including JDK 21 collection mutability, data races in cache creation, and type inference issues.
Fixed multiple Kotlin/JS and Kotlin/Native compilation issues, including ES module test handling, coroutine loop bugs, and incremental compilation problems with compose and native caches
Introduce expect/actual class language feature for simpler MPP configuration
Added source shadowing feature to the Analysis API and expanded support for scripts and Kotlin/Wasm (e.g., K2 enablement, new WASM examples, and annotation instance creation).
- Fixed numerous compiler regressions: false positives on abstract members, unresolved reference errors with JDK 21, native allocator linking issues, and static cache bugs on Linux.
Expanded the Kotlin Analysis API with new functions for expect/actual symbol queries, disabled error logging on failed resolves, and added return types to the K2 reference shortener.
Gradle Kotlin JVM plugin now contributes build directories to the test compile classpath
Fix native compilation failures (dynamic/static libs, suspend function lowering, commonizer CInterop) and KJS errors (StackOverflow, module resolution with useEsModules).
Improved Analysis API and K2 internals: new symbol‑pointer API, fixes for crashes, incorrect diagnostics, raw‑type handling, and context‑receiver issues;
Fixed multiple compiler crashes and regressions across K2, KJS, IR, and serialization plugins (e.g., Fir initialization, illegal IR type arguments, serialization NPEs, Kapt illegal stubs)
Added a standalone mode to the Analysis API with fixes for constructor symbols, constant value computation, and light classes.
Technical release 1.7.22 includes no new fixes beyond 1.7.21
Fixed multiple JVM/IR runtime errors (NoSuchFieldError, VerifyError, NoClassDefFoundError, NPE) caused by delegation, inline functions, and type inference issues.
Added full support for the `until` operator in the parser, resolver and back‑ends.
Fixes multiple compiler bugs including invalid locals info, inference ambiguities, and receiver type mismatches in Kotlin 1.7.0/1.7.10
Expanded Analysis API and FIR with new module resolve states, improved diagnostics, and plugin‑compatibility checks.
Fixed multiple compiler crashes and incorrect behavior across JVM, JS IR, and native (e.g., AssertionError on Java overrides, IR deserialization errors, inline class mangling, and functional interface constructor misuse).
Added new compiler features: @JvmDefaultWithCompatibility annotation, programmatic annotation creation, experimental parallel compilation for the JVM backend, and SAM conversion support for serializable interfaces.
Fixed numerous compiler crashes and regressions (NPEs, IllegalStateExceptions, IndexOutOfBounds) across JVM, JS, Native, MPP and Gradle builds.
Fixed Android target publications leak of the 'AgpVersionAttr' attribute for AGP 7.1.0+ in Multiplatform projects.
Introduced several compiler features: in‑place arguments inlining for @InlineOnly, runtime‑retention repeatable annotations, annotation support on type parameters, conversion from regular to suspending functional types, and synthetic pro...
JVM IR backend promoted to beta, enabled by default for Kotlin 1.5, with added no‑arg plugin support, inline class constants, and improved Java annotation handling.
Fix Gradle integration errors: unknown 'sourceSets' property, missing MainKt.main() task, and library resolution issues.
Deprecate Kotlin Android Extensions and add Jetpack Compose support in the JVM IR backend, plus new JEP 280 string concatenation and script import access.
Compiler performance improvements and fixes for regressions introduced in 1.4.0, including memory, type inference, and stack overflow issues
Added JVM default method bodies generation, KotlinNothingValueException, and suspend conversion support for callable references.
Compiler now allows invoking the default constructor of classes that have no explicit constructors.
Fixed multiple false positives and errors in compiler and IDE, including overload resolution ambiguity, visibility reporting, lazy property handling, and hint/inspection glitches.
Added new compiler features including custom @RequiresOptIn messages, trailing commas, function reference vararg support, and extensive type inference improvements
Fixed compiler regressions: AssertionError on unsigned type range checks and native modifier detection for external functions.
Ships JVM and platform‑specific native Kotlin compiler binaries for Linux, macOS, and Windows.
Introduces the JVM version of the Kotlin compiler and native binaries for Linux, macOS, and Windows.
Fixed numerous regressions introduced by the new type inference engine (e.g., errors with nullable checks, callable references, lambda Unit coercion, HashMap inference, RxJava combineLatest, and reified generics on JS).
New compiler and IDE features – typeOf support, script‑to‑JAR saving, external nullability annotations, copy‑diagnostics action, and a new type‑inference engine enabled in the IDE.
Fixed JVM backend crashes and coroutine bugs related to decorated suspend inline functions, noinline lambda state machines, and Java interop
Added JVM and native Kotlin compiler binaries built with Excelsior JET AOT for faster startup on Linux, macOS, and Windows.
Compiler stability fixes: resolve IllegalArgumentException with deeply nested expressions, JDK 11 class reading warnings, and marker‑function elimination issues.
Added JVM compiler distribution and native binaries for Linux, macOS, and Windows, built with Excelsior JET AOT for faster startup.
Added JVM and platform‑specific native Kotlin compiler binaries built with Excelsior JET AOT for faster startup
Added JVM and native binaries built with Excelsior JET AOT for faster startup on Linux, macOS, and Windows.
Updated IDE plugin to use a new update channel (KT‑25429).
Fixed compiler constant definition issue with kotlin.math and resolved Kotlin migration NPEs in the IDE
Extensive compiler and IDE bugfixes and performance tweaks: lazy import handling, correct smart casts, improved MPP debugging, resolution of annotation warnings, and fixes to code generation, refactorings, and project model synchronization.
Added IDE support for RecentlyNullable/RecentlyNonNull annotations and enhanced LightAnnotations/Lombok handling.
Added native Kotlin compiler binaries for Linux, macOS, and Windows, built with Excelsior JET AOT for faster startup and new "args" usage syntax.
Fixed multiple runtime bugs: wrong autoboxing in inline classes, EnumConstantNotPresentExceptionProxy on JVM <8, and crashes with ProGuard in Android release builds.
Added support for argument files (Xargfile), extended compiler flags (XXLanguage) and introduced experimental "progressive" mode for the compiler backend
Fixed compiler crashes affecting incremental compilation on Java 9, eternal loops, nested arrays, and complex suspend hierarchies
Added new compiler capabilities such as default values for expect/actual annotation constructors, crossinline suspend lambdas, default arguments for expected declarations, @JvmDefault annotation, and warnings for outdated stdlib artifacts.
Added compiler support for nullability annotations in androidx packages.
Added coroutine intrinsic `suspendCoroutineUninterceptedOrReturn` and several compiler optimizations (e.g., for‑loop withIndex, better tail‑suspend detection, language version settings cache).
Fixed Android Basic Activity creation crash (KT-22349) caused by inconsistent file tree in SingleRootFileViewProvider.
Fixed a large set of compiler crashes and verification errors (ClassCastException, VerifyError, NPE, ISE) affecting Android, JVM, JS, and multiplatform projects.
Fixed compiler, IDE, Gradle sync, and JavaScript bugs such as inline function inlining errors, JDK classpath ordering, and lambda loss after incremental recompilation.
Fixed Android Gradle refresh crashes (NSME and missing extension point) and corrected new project button behavior when Kotlin plugin is enabled without Gradle.
Fixed compiler backend crashes for inline reified suspend functions and enums with complex self‑closures, and corrected IDE navigation for inline calls with Gradle delegation.
Added experimental Kotlin/JS incremental compilation support and new JSR‑305 nullability annotation features.
KotlinLanguageInjector getLanguagesToInject may cancel ongoing progress (KT-19901).
Extensive Kotlin compiler bug fixes and performance tweaks, addressing annotation handling, code generation, boxing, smart casts, and verification errors.
Fixed multiple compiler and IDE integration issues: SamWithReceiver plugin usage, Gradle Kotlin plugin compatibility with the Java library plugin, console spam, and kapt3/Parcelize compilation errors.
Fix CompilationException for inline methods and resolve ClassFormatError caused by lazy fields in interface default methods.
Android Extensions get multiple upgrades: improved view‑cache handling, correct synthetic property generation across flavors, enhanced lint checks, and clearer diagnostics for ambiguous IDs.
Compiler now errors on Java default method calls to Kotlin interface members when targeting JVM 1.6, requiring JVM target 1.8 (breaking change).
Noarg compiler plugin default reverted to not run initializer code; enabling it now requires an explicit option (documented).
Added Android Studio lint/intention features such as quick‑fix for missing Parcelable CREATOR, gutter icons for resources, and manifest‑creation intentions;
Fixed multiple regressions: coroutine support, DataBinding kapt timing, compilation error display, Android Extensions IDE support, and method reference overload resolution.
Fixed Pattern::compile resolution to correctly call the public method instead of a private instance method.
Extensive bug fixes across the compiler front‑end/backend, Kapt, Gradle plugin, Android Extensions, and Kotlin Lint to eliminate crashes and incorrect diagnostics.
Improved overall stability
Addressed high memory consumption to lower RAM usage
Fixed multiple compiler crashes and warning inaccuracies (e.g., IAE on anonymous objects, nullability smart‑cast issues, spurious Elvis warnings, SAM constructor errors).
Fixed numerous compiler crashes and runtime VerifyErrors across generics, inlined lambdas, enum classes, and other edge cases.
Fixed numerous compiler analysis and diagnostic bugs, including wrong error messages, assertion failures, and missing deprecation warnings.
IDE J2K now permits write access only from the Event Dispatch Thread, preventing unsafe background writes.
Improved IDE "Show implementation" to display inherited classes via typealiases and added Gradle support with incremental compilation enabled by default
- Fixed many compiler and IDE bugs (e.g., @JvmOverloads handling, vararg generation, inner class resolution, NullPointerExceptions, StackOverflow errors).
Fixed compatibility with Android Studio 2.3 Canary (KT‑14751)
Compiler updates: fixed annotation scope, enhanced type inference and delegation checks, added API version flag, property reference inlining, collection stub optimizations, and hidden‑deprecation error reporting.
Fixed a wide range of compiler diagnostic and code generation bugs, including type inference errors, overload resolution ambiguities, verification errors, and incorrect nullability warnings.
Compiler diagnostics updated: several former warnings are now errors or removed, and many analysis bugs are fixed (e.g., open/override, invisible setter, sealed class exhaustiveness).
Enhanced compiler diagnostics and smart‑cast handling, fixed numerous crashes and bytecode generation bugs, and added performance optimizations (e.g., reduced library method count, smarter annotation handling).
Fixed issue KT-11584
Fixed issue KT-11468
Extensive bug fixes across the compiler (diagnostics, overload resolution, JVM bytecode, JS translator) and IDE features (refactoring, navigation, debugger stepping).
Reissued version 1.0.1 with an updated GitHub URL.
Introduced Kotlin 1.0.0 with HALF_EVEN rounding as the default for BigDecimal division and an 8 KB default buffer size for IO operations.