IntelliJ IDEA
IntelliJ IDEA – the Leading IDE for Professional Development in Java and Kotlin
The Deprecation of K1 Mode
As the next step in the evolution of K2 mode, we are officially deprecating its predecessor, K1 mode. In this post, we’ll give some background about K2 mode and discuss its current state, including adoption numbers, performance test results, and feature parity and stability.
As always, we recommend updating to the latest version of IntelliJ IDEA for the best possible experience.
What is K2 mode, and why was it necessary?
For years, IntelliJ IDEA relied on the internals of the old Kotlin compiler, which made it harder to improve performance and maintain stability as the language evolved. For us, it was a structural bottleneck that limited our ability to make advancements with Kotlin, both from a language perspective and in terms of tooling.
With K2 mode, we rebuilt the analysis engine to make it faster and more scalable. It also includes the Kotlin Analysis API, which provides a clear and stable way to access code information without depending on compiler internals. K2 mode serves as a new foundation for Kotlin support in IntelliJ IDEA, making it possible to support future Kotlin language features, evolve faster, and improve the reliability of code analysis.
This took a ton of architectural rework. A lot of functionalities were rewritten and redesigned. Almost every migrated feature or inspection required some level of updates and optimization.
Check out this blog post for an in-depth look at K2 mode’s development.
Adoption
Almost everyone working with IntelliJ IDEA today is already on K2 mode. Among those using version 2025.2, K2 mode has been adopted by:
- 98.6% of Ultimate users.
- 99.5% of Community Edition users.
That leaves only 1.4% (Ultimate) and 0.5% (Community) still on K1 mode. These remaining cases typically fall into niche categories, for example those who:
- Work with internal plugins that still depend on K1 mode.
- Are missing functionality in rare workflows.
- Disabled K2 mode earlier and haven’t switched back.
For these users, we’ve kept a VM option to re-enable K1 mode: -Didea.kotlin.plugin.use.k1 = true.
You can find instructions for configuring VM options in the IntelliJ IDEA documentation.
If you rely on K1 mode because K2 mode isn’t suitable for your current setup or workflow, please get in touch with us.
Performance
The following performance measurements are based on a mix of internal and open-source projects, including IntelliJ-based IDEs, the Kotlin language repo, the Ktor framework, JetBrains Toolbox, kotlinx.coroutines, the Anki Android app, LeakCanary library, SQLiter, Arrow, jOOQ, and others.
The numbers are not precise, as many factors within the release could influence performance, so we are taking the average measurements to compare K2 mode vs K1 mode over time. But these results help paint the general picture.
Code analysis
For code analysis, our K2 mode performance tests show an improvement of approximately 39% (with an average range of 27-51%).
K2 mode sometimes shows to be slower for very small/empty files K2 mode is slower (90ms vs 200ms in some cases), but for big files it’s much faster (50s+ vs 10s).
Find Usages
For Find Usages, our tests show an improvement of approximately 34% compared to K1 mode(47-57% on average).
Code completion
In the previous release, some users reported issues with the performance and quality of code completion, so we made this a priority for 2025.3.
For this release, we delivered an updated completion implementation that now runs in parallel, leveraging the multi-threaded nature of the Analysis API.
Based on our performance test data and EAP feedback, we achieved a speed improvement of approximately 26% compared to the previous release. Completion is now more responsive and the first results show up faster than before.
The completion performance gains vary depending on the scenario. Some show significant improvement, while others – such as projects using jOOQ – do not yet benefit from the K2 mode completion updates and for now may even be slower than before. We are aiming to address this in future releases.
Parallel completion remains an ongoing effort, and additional optimizations are planned for future releases.
IntelliJ IDEA 2025.3 also includes several completion quality improvements, for example:
- Argument completion now respects parameter names more accurately.
- Expected types are taken into account in a broader range of contexts.
These changes improve the overall relevance and reliability of completion suggestions.
We do not consider this the final step of our performance improvement journey. The K2 architecture continues to unlock further optimization opportunities, and we’re actively pursuing them.
Stability
Measuring stability is always challenging, as many factors influence the overall experience. However, we’ve clearly observed several positive trends.
From the telemetry side, we are receiving fewer support requests related to Kotlin overall, and our EAP builds show a noticeable decrease in exception reports. While we can’t attribute all of these improvements solely to K2 mode, the new architecture has undeniably helped us address entire categories of long-standing issues.
Stability is also reflected in user feedback. Over the past months, we’ve spoken with numerous teams and company leaders to understand how K2 mode behaves in real production environments. The responses have been positive:
- “IDE is much more stable now, which is really nice. I’m on the latest version, and it’s indeed noticeable!”
- “I have the feeling that the indexing of the project is way faster. And there is no longer the reindexing that used to take 30 minutes each time.”
- “I can’t pinpoint when it happened, but after the release that enabled K2 by default, all my problems disappeared! No more IDE errors.”
- “K2 mode has been working great for everyone inside our company.”
While those are good indicators, stability work is never finished. We will continue improving reliability, addressing edge cases, and tightening the feedback loop with teams that work with large or complex Kotlin projects.
Feature parity
K2 mode has reached near-complete feature parity with K1 mode, with only a few remaining exceptions.
Inspections, intention actions, quick-fixes, and refactorings
Not all inspections and refactorings made it into K2 mode, as we have a list of items that are triggered by less than 0.5% of users.
For certain rarely-used features, the low usage rate is by design, as they are intended to be used only in rare cases. These features were migrated to K2 mode.
But for other features, rare usage indicates a need to redesign or even retire them, as they are not delivering the value they were originally supposed to provide.
In upcoming release cycles, as part of our regular development process, we will revisit these features and re-work them or migrate them as appropriate.
And we’re not stopping there – we’ll continue to add new features, inspections, and quick-fixes in future releases.
Type matching completion
We’ve also received requests to improve type matching completion, a feature currently used by less than 2% of developers. In this release cycle, smart type completion has not been our primary focus, as we’ve been dedicating our efforts to improving overall completion performance and quality.
Smart type completion remains on our roadmap, and we will continue enhancing its quality and reliability in upcoming releases, but overall completion performance is more important.
Thank you for your feedback
Your feedback is the driving force behind all the improvements we make!
We began developing K2 mode as a bold, long-term solution to problems that could not be solved through incremental fixes. Throughout this journey, we’ve received invaluable input through YouTrack issues, Slack discussions, threads, conference conversations, and in-person meetings. All of this has shaped K2 mode into what it is today.
Your feedback doesn’t just help us fix issues – it helps us define the future of Kotlin tooling. Thank you for continuing to share your thoughts.
As of IntelliJ IDEA 2025.3, Kotlin support in the IDE is now fully powered by K2 mode, and this officially concludes the project of implementing K2 mode. The architectural foundations we built will continue driving improvements across performance, stability, and ecosystem support, as well as new features
Stay tuned – there’s much more to come.
Subscribe to IntelliJ IDEA Blog updates
