JetBrains/kotlin

Choose this fork only if you specifically want a long-lived, heavily diverged Kotlin snapshot or custom test/baseline workflows. If you want current Kotlin language, tooling, or multiplatform support, upstream is the safer choice.

Prefer this fork only if you need its historical 2012-era Kotlin changes or are maintaining legacy code built against it. For almost everyone else, upstream JetBrains/kotlin is the better choice because this fork is extremely stale and lacks modern platform, tooling, and compatibility work.

Prefer this fork if you specifically need Kotlin-to-Python backend experimentation. Prefer upstream Kotlin if you want current language/compiler work, supported multiplatform targets, or low-maintenance adoption.

Choose this fork only if you want an old, highly experimental Kotlin codebase for compiler/tooling research. For any production, multiplatform, or current plugin use case, upstream JetBrains/kotlin is the better choice.

Prefer this fork only if you specifically need its older customizations, build hardening, or workflow additions. For most adopters, upstream is the better base because this fork is stale and significantly diverged.

Choose this fork only if you specifically need its older custom compiler/runtime changes. For most adopters, upstream JetBrains/kotlin is the better choice because this fork is stale and materially behind current Kotlin development.

Prefer upstream unless you specifically need this fork's older JS IR/FIR/compiler experiments. The fork looks materially stale and highly diverged, so adoption is only sensible for users who want to preserve or continue its custom compiler/test changes and are prepared to maintain a large upstream gap.

Prefer this fork if you want verification-oriented Kotlin semantics and are willing to accept heavy divergence from upstream. Prefer upstream if you need current Kotlin language/platform support, normal tooling parity, and lower maintenance risk.

Choose this fork if you want a research-friendly Kotlin compiler base with custom compiler, Native, and test-infrastructure changes. Avoid it if you need a current, low-maintenance fork close to upstream Kotlin.

Prefer this fork only if you need its older compiler/test-focused snapshot or are continuing an existing internal experiment. For most adopters, upstream Kotlin is the better choice because this fork is stale and materially behind current development.

Choose this fork if you need extended compiler/test coverage across Native, JS, Wasm, and plugin-sandbox workflows and can absorb significant merge overhead. Choose upstream if you want the most current, lower-risk baseline.

Choose this fork only if you specifically need its KLIB and compiler-internals work. For most users, upstream Kotlin is the safer choice because it is far more current and actively maintained.

Prefer this fork only if you specifically need its K2/FIR, analysis API, or generated-test changes. For most adopters, upstream is the better base because this fork is stale and highly divergent.

Choose this fork only if you specifically need its December 2024-era compiler/test changes. For most adopters, upstream JetBrains/kotlin is a better fit because it is far more current, actively maintained, and much less risky to integrate.

Prefer this fork only if you need its specific downstream test and Native/Swift-export work or a frozen Kotlin snapshot. If you want current Kotlin behavior, active fixes, or an easy merge path, upstream is the better choice.

Prefer this fork only if you specifically need its customized test and Native/compiler behavior. If you want a general-purpose Kotlin base, upstream is the better choice because this fork is stale and materially diverged.

Prefer this fork only if you specifically need its 2022 compiler/diagnostics state and its local fixes. For most adopters, upstream Kotlin is the better choice because this fork is too stale and too far behind to serve as a modern base.

Prefer upstream unless you specifically need this fork’s historical compiler/build changes. Choose the fork only if you need its older cinterop or frontend behavior and can accept substantial maintenance debt and missing modern Kotlin capabilities.

Prefer upstream unless you specifically need this fork's older FIR/compiler test work or want a historical branch to study. For production or long-term maintenance, the fork is too stale and too far from current Kotlin to be an efficient base.