News

JetBrains Kotlin 2.4.0 Release Advances JVM, WebAssembly, and JavaScript Support

• By John K. Waters
• June 24, 2026

JetBrains has released Kotlin 2.4.0, adding support for Java 26 on Kotlin/JVM, enabling annotations in metadata by default, and expanding the language's support for WebAssembly, JavaScript, and native development.

The release, announced by JetBrains earlier this month, is not built around a single large language change. Instead, it continues Kotlin's gradual evolution from a JVM and Android language into a broader multiplatform development environment spanning server-side applications, mobile projects, browser-based code, WebAssembly modules, and native targets.

For Application Development Trends readers, the most immediate change is likely the JVM update. Kotlin/JVM now supports Java 26, helping Kotlin developers keep pace with newer Java platform releases. JetBrains also enabled annotations in metadata by default, a change that could matter to frameworks, libraries, and build tools that depend on annotation processing, reflection, serialization, dependency injection, validation, or code generation.

Annotations play a central role in much of the enterprise Java and Kotlin ecosystem. By preserving annotation information more consistently in Kotlin metadata, JetBrains is improving the information available to tools that analyze Kotlin code across compilation, runtime, and framework boundaries.

Kotlin 2.4.0 also stabilizes several language features, including context parameters, explicit backing fields, and multiple features related to annotation use-site targets. The changes are not likely to reshape day-to-day Kotlin programming for all developers immediately, but they are important for framework authors and library maintainers who need more precise control over APIs, generated code, and compiler behavior.

The release also includes standard library updates, including a stabilized UUID API in the common Kotlin standard library and support for checking sorted order. Those additions are incremental, but they support JetBrains' larger goal of making shared Kotlin code more useful across multiple platforms.

The most strategically significant part of the release may be Kotlin/Wasm.

JetBrains said incremental compilation is now enabled by default for Kotlin/Wasm. That should improve developer feedback loops by allowing the compiler to rebuild only the parts of a project that changed, rather than recompiling the entire project. Faster incremental builds can be especially important as WebAssembly projects grow beyond experiments into larger applications and reusable components.

Kotlin 2.4.0 also adds support for the WebAssembly Component Model, an emerging architecture for building interoperable WebAssembly libraries, applications, and environments.

That support matters because WebAssembly is increasingly being discussed as more than a browser technology. Developers and platform teams are using Wasm as a portable runtime for plugins, edge workloads, sandboxed execution, server-side components, and polyglot application modules. The Component Model is intended to make those modules easier to compose across languages and runtimes.

For Kotlin developers, Component Model support could eventually make it easier to use Kotlin in environments where WebAssembly components need to interact with code written in other languages. The practical impact will depend on runtime support, tooling maturity, and adoption by platform vendors, but the direction is notable.

Kotlin/JavaScript also received updates aimed at modern web development. Kotlin 2.4.0 adds support for exporting value classes to JavaScript and TypeScript, and for inlining ECMAScript 2015 features in JavaScript. Those changes should make it easier for Kotlin code to interoperate with modern JavaScript tooling and APIs.

The Kotlin/Native side of the release adds support for Swift packages as dependencies, updates Swift export, and enables the CMS garbage collector by default. Those changes are relevant to teams using Kotlin Multiplatform to share business logic between Android, iOS, server-side, and web applications while still integrating with native platform ecosystems.

JetBrains also included build-tool updates. Kotlin 2.4.0 is compatible with Gradle 9.5.0, and Maven now supports automatic alignment between Java and JVM target versions. That kind of tooling work is less visible than language features, but it can be important in enterprise environments where inconsistent build configuration can cause compatibility problems, deployment issues, or hard-to-diagnose runtime behavior.

The release also includes compatibility changes that teams should review before upgrading. Kotlin's documentation notes that some previous warnings are now treated as errors, and Kotlin 2.4.0 changes default annotation use-site target selection rules. Those changes may affect annotation processing, reflection, and binary metadata after recompilation.

For enterprise development teams, the main takeaway is that Kotlin 2.4.0 is a platform release rather than a feature showcase.

The JVM support keeps Kotlin aligned with Java's ongoing release cadence. The WebAssembly work points to a future in which Kotlin could participate more directly in portable, component-based software architectures. The JavaScript and Native updates improve Kotlin's integration with existing web and mobile ecosystems.

That combination reflects where Kotlin appears to be headed: not away from Java, but beyond the JVM alone.

For organizations already using Kotlin on the server or in Android development, Kotlin 2.4.0 is likely to be an incremental upgrade that improves compatibility, tooling, and cross-platform reach. For teams evaluating Kotlin Multiplatform, the release provides evidence that JetBrains continues to invest in the infrastructure needed to make shared Kotlin code practical across more application targets.