Amper -> https://kotlin-toolchain.org/

Mellum2

Now open source on Hugging Face, Mellum2 is a 12B-parameter LLM built for:

• Routing and orchestration
• RAG pipelines
• Sub-agents
• Natural language and coding tasks

Powered by a new mixture-of-experts (MoE) architecture and optimized for ultra-low-latency inference.

Kotlin Toolchain 0.11: The Next Step for Amper

Released with a lot of new features and fixes

Kotlin 2.4.20-Beta1

https://github.com/JetBrains/kotlin/releases/tag/v2.4.20-Beta1

Major changes:

1. Context parameters going Stable. Explicit context arguments move to Stable — the headline of the release. KT-86089

2. Companion blocks & extensions. A new language capability landing across the whole toolchain: resolution, reflection (call/callBy), light classes, REPL/scripts, metadata. Enable it with the new (off-by-default) flag -Xcompanion-blocks-and-extensions. KT-84289 KT-85187

3. Native: incremental compilation on by default. K/N builds are finally faster out of the box. KT-86657

4. when via invokedynamic on JVM 21+ by default. More compact bytecode, fewer synthetic classes. KT-78079

5. PowerAssert heading to initial release. Runtime ABI stabilized, runtime dependency added automatically. KT-86170 KT-85250

6. Lombok-style logging on Kotlin classes: @Slf4j, @Log4j2, @JBossLog, @Flogger, @CommonsLog, @XSlf4j, plus @Log and @ToString. KT-81622 KT-85762

7. Collection literals moving forward. Under -Xcollection-literals: type inference in delegate expressions, support in annotations, of operator via companion block. KT-84295

8. Name-based destructuring. Stabilization of the only-syntax variant (targeting 2.5). KT-86201

9. Kotlin/JS catches up. ES2015 syntax in the js() function, KDoc export to .d.ts, @JsExport for annotation classes. KT-21626 KT-56493

10. Stdlib. Common atomic types and a new StackTraceRecoverable interface. KT-62423 KT-86595

Bonus: official deprecation of the K1 compiler has begun (KT-75372), and experimental language version 2.6 was added (KT-85667).

Kotlin 2.4.10-RC

https://github.com/JetBrains/kotlin/releases/tag/v2.4.10-RC

As usual, a bug-fix release – but there's one interesting change I noticed:

Since the Kotlin Toolchain uses kotlin as its command name, the current kotlin command (which is the compiler) is being renamed to kotlinr. 2.4.10 is the first release that ships both: kotlin and kotlinr.
The package itself (e.g. brew install kotlin, sdk install kotlin) will be renamed to kotlinc. So the future end state for the ecosystem:

sdk install kotlin # install kotlin toolchain, command: kotlin
sdk install kotlinc # install kotlin compiler, command: kotlinr

A kotlinc package but a kotlinr executable – confusing, right?

Some updates to new features timelines:

KEEP-0449: Companion extensions and blocks - experimental 2.5.0, stable 2.6.0 (preliminary)
KEEP-0462: Rich Errors, aka Error Union Types - experimental 2.5.0
KEEP-0450: Typed Delegate Access - experimental 2.5.20

Kotlin 2.4.10-RC2

https://github.com/JetBrains/kotlin/releases/tag/v2.4.10-RC2

Kotlin 2.4.10 has been released 🎉️️️️️️

https://github.com/JetBrains/kotlin/releases/tag/v2.4.10

What's new https://telegram.me/TheDailyKotlin/621

KEEP-0466: Expect with fallback

TL;DR
• Expect declarations may define a fallback implementation.
• The fallback implementation implementation is used when there's no corresponding actual declaration in a platform for an expect.
• Fallback implementation must define the declaration completely ("all-or-nothing" rule); leaving some parts unspecified is not allowed.

Kotlin 2.4.20-Beta2

https://github.com/JetBrains/kotlin/releases/tag/v2.4.20-Beta2

Major changes:

1. Swift Export: cross-language inheritance is here. The umbrella ticket for cross-language subtyping is closed: Swift types can subclass Kotlin classes — with supercalls, properties, async members, default interface methods. Sealed classes are supported too. KT-66888 KT-80000

2. Full value classes (KEEP-0453) take shape. Short-form name-based destructuring, abstract value classes, and the old @JvmInline multi-field prototype is removed. Still experimental: builds using them are deliberately poisoned. KT-84904 KT-86018 KT-86849

3. KMP: fragment-aware incremental compilation on JVM. The OSIP-75 push: commonMain will no longer accidentally see jvmMain declarations during IC, removing the need for the non-incremental fallback. Landed behind a feature flag while the rollout continues. KT-87490 KT-86410

4. Wasm on all fronts. Three compilation modes (monolith / multimodule open & closed world), wasmtime as a WASI runtime in Gradle, index range checks on by default, and a prototype of suspend functions on top of the stack-switching proposal. KT-86919 KT-86633 KT-73452 KT-76207

5. Native: release builds with compiler caches. First step towards fast release builds: opt-in caches + module-local optimizations instead of full LTO. KT-80373

6. Browser tests move to Playwright. New JS browser-test DSL: webpack + mocha + playwright, configurable dev-server URL and custom browser executables. KT-86260 KT-87484

7. kotlin-reflect stops slowing you down. typeOf() and friends no longer degrade when kotlin-reflect appears on the classpath — the thing that used to bite Ktor and kotlinx.serialization. KT-73657

8. stdlib & kotlin-test. allDistinct()/allDistinctBy{} (a 2019 request!), JUnit5-style lazy assertion messages, and the new @EqualityBound annotation. KT-30270 KT-31305 KT-86766

9. Xcode 27 support, new floors. Minimum deployment targets bump: iOS 15, macOS 12, watchOS 9 (armv7k is gone), tvOS 15. KT-87187

10. The great cleanup continues. Legacy JS backend sources are deleted, and @K1Deprecation now covers all public declarations of K1 modules. KT-70223 KT-86046

Bonus: the Eager Lambda Analysis language features got postponed (Unit conversions on arbitrary expressions — indefinitely, KT-86877 KT-87439), and OPERATOR_RENAMED_ON_IMPORT was downgraded from error to warning (KT-83880).

KotlinLLM: LLM-generated bodies, committed as Kotlin source

JetBrains Research has open-sourced KotlinLLM under Apache 2.0 — a research prototype for delegating runtime logic to an LLM from Kotlin code, without keeping the model in the request path.

The unit is a Smart macro: an ordinary Kotlin call whose body is generated source code. Two are exposed — asLlm<F, T>(from, hint) turns unstructured input into typed Kotlin values, and mockLlm<T>() builds stateful interface implementations to use as test doubles.

val issuesApiUrl: String = asLlm(repoInput, hint = "GitHub API URL: get all issues, including closed")

val issues: List<Issue> = asLlm(response, hint = "Return all beginner-friendly issues for this repository")

The argument against the obvious alternative is stated plainly: calling the model on every invocation is slow, non-deterministic and costly, and it makes the application depend on an LLM service at runtime. So KotlinLLM commits to three properties instead. The call site is explicit, so an LLM-backed feature is visible in review. The behaviour is persistent — saved as ordinary Kotlin source under com.jetbrains.kotlinllm.generated, so it can be committed, reviewed, tested and shipped like any other code. And it is portable: once generated, the code runs as plain Kotlin without the plugin, with no extra latency or cost.

The evolution loop is the interesting part. The app runs under JDI with regenerate hooks registered as breakpoints. When the generated logic meets a scenario it cannot handle, it is required to fall through to a hook rather than silently return something wrong. Execution suspends, the plugin captures runtime values and type information from the frame, an LLM agent inspects the code, writes a narrow update into the generated source, compiles it, redefines the class in the running VM, and the original call is retried against the new implementation.

Two evaluations. Spring Petclinic Kotlin, adapted with 18 asLlm call sites: 24/24 application scenarios completed after Smart macro evolution, a 100% hot-reload success rate, and roughly 1% runtime overhead. A GitHub Beginner Issue Radar reached ~0.89 recall on ground-truth beginner labels across 30,000+ issues from 20 repositories.

The constraints are honest. Kotlin/JVM only, because the evolution loop depends on JVM class redefinition through JDI. IntelliJ IDEA 2025.2.x, JDK 21, an OpenAI key in .kotlinllm. Generated updates are deliberately narrow — the agent does not get to rewrite arbitrary project files.

It is a research prototype, not a production tool. But it inverts the usual pattern in a way worth thinking about: the model writes the function once, and the JVM runs it forever.

GitHub · KotlinConf 2026 talk · Recording · Write-up

Kotlin 2.4.20-RC

The release candidate is out. Its changelog is the delta since Beta2 — 30 entries, at least 24 of them fixes — so this is the shape 2.4.20 will ship in.

Major changes:

1. Kotlin/Native incremental compilation is off again. Switched on by default for Beta1 and Beta2 as a stabilization experiment, it is turned back off for the RC — the only carry-over ticket in this changelog. Still opt-in via kotlin.incremental.native=true — KT-86657

2. The 2.4.0 Gradle sync regression is fixed: a 400+ module KMP project reported sync at 74.8s → 105.4s (+41%), Gradle execution alone up 76%. Dependency maps and host-specific metadata are now cached per source set — KT-87790

3. ClassCastException: Float cannot be cast to Unit when a suspend call's result is discarded in a when branch, seen in a plain LaunchedEffect. A Unit-returning suspend function can be resumed with a non-Unit value; the RC restores the defensive discard an earlier soundness fix removed — KT-87499

4. Compose compiler: cross-module getter and setter calls miscompiled into spurious runtime errors, a composable-singleton bug with type parameters, and a crash on a super call to a defaulted @Composable function in another module — b/537617330, b/543684938, KT-88028

5. NoWhenBranchMatchedException on Native for an exhaustive when over a sealed interface; a CCE on a member extension property delegated to a property reference; and scripts can again use a type from an @file:Import-ed script — KT-85403, KT-87983, KT-87958

6. J2KLIB, the klib-producing compiler that emits no bytecode, gets its own changelog section: dependency deserialization drops from ALL to WITH_INLINE_BODIES, and Beta2's unbound SuspendFunctionN symbols, which broke all suspend code, are fixed — KT-88176, KT-88306

7. Build tooling. The compiler measured user and CPU time around every class file read, a large Linux penalty; that now needs -Xdetailed-perf. KGP reverted the Beta1 task-path logging prefix IntelliJ's parser could not handle, and the per-build BuildMetricsService leak that grew daemon memory is gone — KT-87868, KT-87256, KT-88084

8. Wasm tooling setup no longer fails on the outdated bundled yarn.lock that broke offline builds, and the Swift PM lock file is no longer ignored when a dependency moves from exact() to from() — KT-88115, KT-88154

Bonus: 2.4.20 learns to complain about .kar files on the compilation classpath. Kotlin Archive is a proposed format bundling KMP metadata and non-JVM klibs into one artifact, an answer to Maven Central's limits. The format isn't here — only the diagnostic, so consumers get a message instead of silence once dependencies start publishing archives — KT-87911

Michail Zarečenskij: Every language with generics has intersection types

Resilient sync: Gradle stops taking the IDE down with it

Until now one broken subproject or convention plugin aborted the entire sync — a 100-project build lost completion and highlighting exactly when you needed them to fix the build. Resilient sync changes the contract: the new BuildController.fetch(...) in the Tooling API returns the models that did resolve alongside structured failure info instead of throwing, so the IDE keeps working code fully usable and marks only what's actually broken. Nothing to enable — Gradle 9.7 plus IntelliJ IDEA 2026.2 switch it on by themselves.

Gradle blog

Kotlin Toolchain 0.12.0 — build, run, publish (1/2)

Kotlin Toolchain 0.12.0 is the project's biggest release yet. First, the headline capabilities: KMP publishing, incremental JVM builds, a runnable Wasm target and IDE-free Hot Reload.

Major changes:

1. KMP library publication lands in preview. The toolchain compiles KMP metadata, generates kotlin-project-structure-metadata.json, assembles the all-metadata JAR and emits Gradle .module metadata. Native interop is covered too: cinterop KLIBs are commonized and published. Compose resources are not included yet — KTC-719, KTC-5437, KTC-5698

2. Kotlin incremental compilation for JVM targets, through the Build Tools API that the toolchain already used for non-incremental compiler calls. It is on by default with Kotlin 2.4 and newer. Compiler warnings are replayed when a compilation is served from the cache, instead of disappearing after the first run — KTC-4511, KTC-4491

3. wasm-js/app can be built and run. Build output contains the Wasm binary, JS loaders, resources and an import map; kotlin run starts a Ktor static server and opens the browser. Transitive NPM dependencies are installed with pnpm, making libraries such as kotlinx-datetime work, and the Compose Multiplatform template now includes a Wasm app — KTC-5569, KTC-5570, KTC-5572, KTC-5683

4. Compose Hot Reload works without the IDE. The standalone CLI watches the filesystem and reloads even after build-model changes. A Compose Hot Reload MCP server ships too, so agents can drive the reload loop — KTC-5475, KTC-5486

5. JVM libraries work in JVM+Android shared fragments. Ordinary JVM dependencies — including local jvm/lib modules — are now visible directly from code shared by the two targets — KTC-4474, KTC-5502

6. Project-root-relative // paths. No more ../../foo in dependency blocks: paths are copy-pasteable and template-friendly, and moving a module no longer rewrites its own references to other modules — KTC-2139

7. DataFrame and Power Assert are one line of config. settings.kotlin.dataframe: enabled switches on the experimental DataFrame compiler plugin, and Power Assert no longer needs its runtime library declared by hand — KTC-4881, KTC-5500

The CLI got friendlier. Completion knows kotlin do commands and -m/--module values; run offers an interactive module picker and inherits terminal I/O, so TUI apps work — KTC-5608, KTC-5610, KTC-4691, KTC-5596

Kotlin Toolchain 0.12.0 — migration, compatibility, IDE (2/2)

Part one covered the headline capabilities of Kotlin Toolchain 0.12.0. Part two: new baselines and platform defaults, broader dependency compatibility, safer publishing and a much better IDE plugin.

Major changes:

1. The baseline moves forward. The default JDK is 25 and the CLI now requires JDK 17; minimum Kotlin is 2.2.20, default 2.4.10. Android minSdk becomes 24, with new defaults for Ktor 3.5.2, Compose 1.11.1 and Spring Boot 4.1.0 — KTC-5708, KTC-5712

2. Platform and CLI cleanup. ios/app no longer supports iosX64; macosX64 leaves the defaults for macos/app, and watchosArm32 is deprecated. The old --root, --build-output and --shared-caches-root options are gone; publish standardizes on -m/--module and asks for --transitive or --non-transitive when the selected modules depend on other local ones — KTC-5462, KTC-5702

3. Android SDK configuration becomes forward-compatible. API levels are integers instead of a closed enum, API 37 works, minor compile SDK versions are supported, and the Android Build Tools version is configurable — KTC-5623, KTC-5626

4. Migrating from Maven gets smoother. convert-project gained --enable-compatibility-plugins, so Maven plugins come out ready to run instead of enabled: false one by one. Profile activation is fixed too: the unix family now matches macOS, and all activation criteria must hold, not just one — KTC-5200, KTC-5642

5. Maven and AAR resolution handles more real-world metadata. Dependency groups with type=pom, classified artifacts published beside packaging=pom, nested BOMs and AARs without classes.jar now resolve — KTC-5270, KTC-5583

6. Publishing is harder to break. KLIB checksums and signatures now pass Maven Central, published checksum algorithms are configurable, and publishing to Maven Local is incrementally cached and quieter — KTC-5680, KTC-5483

7. The IDE closes major gaps. Android and common-fragment Compose previews, Compose resources completion and navigation, and code insight for the DataFrame compiler plugin land in the Kotlin Toolchain plugin for IntelliJ IDEA 2026.2.1 — KTC-5394, KTC-4449, KTC-5440, KTC-5530

Diagnostics got sharper. They point to precise source ranges, catch incompatible JDK/Kotlin combinations earlier and render task errors cleanly; tests get a real progress widget — KTC-4846, KTC-5006, KTC-5515, KTC-4233