K2 Mode Takes Off: High Adoption, Fewer Bugs, and Major Improvements in 2025.1

We want to share how things are going with K2 mode, which became the default in IntelliJ IDEA 2025.1. In this post, we’ll give an overview of the current state of K2 mode, share its adoption metrics, highlight the improvements delivered in 2025.1, and preview what’s coming next. We recommend updating to the latest IntelliJ […]

Jun 19, 2025 - 16:50

K2 Mode Takes Off: High Adoption, Fewer Bugs, and Major Improvements in 2025.1

We want to share how things are going with K2 mode, which became the default in IntelliJ IDEA 2025.1. In this post, we’ll give an overview of the current state of K2 mode, share its adoption metrics, highlight the improvements delivered in 2025.1, and preview what’s coming next.

We recommend updating to the latest IntelliJ IDEA version to enjoy the best K2 mode experience.

Adoption

The number of users who have now adopted K2 mode is already very high and continues to grow. Indeed, among IntelliJ IDEA 2025.1 users, 95% of Ultimate and 9% of Community Edition developers use K2 mode.

Most users update their IDEs within the first few months after a release, so we also track combined usage across versions 2024.3 and 2025.1. Even with 2024.3 users included, K2 mode has already reached over 76% adoption – and the number continues to grow steadily every week.

Thank you for your feedback

Your feedback is the driving force behind all the improvements and enhancements we make.

We’ve received valuable input through YouTrack issues, Slack messages, threads, and countless conversations in person at different conferences and meetups – all of which has directly shaped the evolution of Kotlin support.

Our dedicated support team reviews and monitors YouTrack reports daily, ensuring that the issues you raise are heard and addressed.

Your feedback doesn’t just help us fix problems – it helps us shape the future of Kotlin tooling. Thanks for continuing to share it!

Bug reports

The number of bug reports submitted in the first 3–4 weeks after this latest release is on par with what we saw following the 2024.3 release.

Other feedback channels also show a significant drop in negative mentions, and overall sentiment is more positive than expected.

Some users are using K2 mode in the 2024.3 and 2024.2 versions. We strongly recommend that you update to the latest version of IntelliJ IDEA, as the 2025.1 release has brought huge improvements to K2 mode, both in terms of quality and feature completeness.

Let’s take a look at what has been updated.

Fixes and improvements in 2025.1:

Stability has been improved, meaning there are fewer crashes and freezes.
More than 100 inspections and intentions have been improved and migrated from K1 to K2 mode.
Better support is now available for scratch files and scripting (.kts).
False positives in error reporting (e.g. Constructor expected and Unknown symbol) have been fixed.
Expected String?, got String-type errors no longer appear incorrectly.
There is now an inspection for unused functions or properties.
Highlighting is now supported for .serializer().
The Create member from usage quick-fix now works as expected.
Frequent reindexing triggers have been reduced.
Project-switch caching issues have been resolved.
All external and internal major plugins now support K2 mode.
JetBrains Academy integration is fully functioning.
Various Spring support improvements have been implemented.
The K2 mode debugger has reached parity with its K1 mode counterpart.

We’ve improved many other aspects of K2 mode. Check out our release notes for a comprehensive list.

Move refactoring

In K2 mode, we rewrote how the Move refactoring works. It’s now far more reliable and predictable. Edge cases are handled correctly, and the resulting code is cleaner and more accurate.

What’s coming in 2025.2:

General code completion improvements.
Type-matching smart completion support.
Spring support is on par with K1 mode.
Refactorings like Convert Enum to Sealed Class, Extract Interface, Create test / Navigate to test for files and for functions, Rearrange Code.
Fixes for regression highlighting, including the consistent behavior of DSLs, annotations, and Kotlin-specific syntax.
Fixes for false-positive errors like Constructor expected and Unknown symbol.
More reliable execution of Kotlin scripts, including standalone and Gradle .kts files.
Correct loading of script definitions and resolution of project-specific symbols.
Correct recognition and highlighting of functions annotated with @DslMarker.
A more reliable Extract Interface refactoring across all project configurations.

There’s much more to come, so stay tuned!

Coroutines inspections

Coroutines are one of our most loved and frequently mentioned features, but they can be tricky to get right, especially for those just starting out.

We’re working to make them easier to use and have already introduced a growing set of coroutine inspections. These are designed to catch common issues, offer helpful suggestions, and guide you toward writing correct and idiomatic coroutine code more smoothly and with more confidence. Here are some of the tickets we’ve addressed with this initiative:

Warning about calling runBlocking in a suspend function.
Inspection to replace `kotlin.coroutine.coroutineContext` access with `kotlinx.coroutines.currentCoroutineContext` call where possible.
Inspection when a Flow from kotlin.coroutines is not used.
Inspection to replace ‘map { it.await() }’ with ‘awaitAll()’ on collections of ‘Deferred’ objects.
Inspection to replace ‘forEach { it.join() }’ with ‘joinAll()’ on collections of ‘Job’ objects.

Support for Kotlin 2.2 feature previews

Kotlin 2.2 will bring a variety of interesting new features that have IDE support in K2 mode, including:

Guard conditions in when, multi-dollar interpolation, and non-local break and continue.
Nested type aliases.
Improvements to use-site defaulting for annotations in Kotlin.
Context parameters (non-stable).
Exposing functions with inline classes to Java (non-stable).
Prototype of context-sensitive resolution (non-stable).

Performance

Version 2025.1 brought noticeable performance improvements, and 2025.2 is building upon that work.

In 2025.1, highlighting and actions like Find Usages became faster and more responsive. In preparation for the 2025.2 release, we’ve also improved completion speed and memory usage, making everyday editing smoother and more efficient.

These updates are part of our ongoing effort to make K2 mode more powerful. We’re continuing to track the impact of these changes and will share more detailed metrics later this year.

What’s next?

We’re continuing our efforts to refine and enhance K2’s architecture, address remaining limitations, and ensure a stable, reliable experience for all developers. Your feedback is key to helping us prioritize and improve where it matters most.

If you have ideas, suggestions, or issues to report, we’d love to hear from you via Slack, YouTrack, or email.

Happy coding!