What’s Fixed in IntelliJ IDEA 2025.2

Dmitriy Smirnov

Welcome to the first-ever standalone What’s Fixed overview of an IntelliJ IDEA release!

We are always working hard to make the IDE even more stable, reliable, and enjoyable to use. In previous releases, information about this work was blended into the What’s New content, making it very long and sometimes hard to grasp. To address this issue, we’ve decided to focus the What’s New only on the most impactful and noticeable changes and to introduce a dedicated What’s Fixed article that focuses on the stability and quality improvements.

The key areas we have been working on in this release are:

• Spring support
  • Kotlin support in Spring projects
  • Spring Security and Spring Web
• Remote development
• Support for WSL
• Kotlin K2 mode
• Kotlin Notebook
• Maven execution
• Cloud tooling
• Performance

But that’s not everything. For the full list of fixes and improvements, please refer to the release notes. 

Improved Kotlin support for Spring projects

With Kotlin proving itself as a good fit for the Spring Framework, more and more people are using it in Spring projects. To deliver the best developer experience, we formed a partnership between Kotlin and Spring, and we are actively improving IntelliJ IDEA’s Kotlin-Spring support. Version 2025.2 brings:

• Live templates and context menu actions for creating Spring beans quickly, along with improvements to the Logical structure view to make understanding the relations between application components easier.
• Smarter bean support: No more false injection points for constructor parameters for @SpringBootTest or for parameters with defaults, and improved handling of @ConditionalOnProperty beans.
• Configuration made clear: The ability to go from @ConfigurationProperties to YAML or properties with a click, default values in code completion, and full support for nested properties.
• Spring MVC improvements: An easier experience with path variables in request handlers, thanks to clear feedback when something doesn’t match.
• Spring Data fixes: Better repository method completion for is properties, as well as cleaner support for varargs, projections, and named queries.

Spring Framework support

Spring Framework support is a key focus area for IntelliJ IDEA. In addition to new functionality such as Spring Debugger, we continue to enhance existing features.

In this release, we’ve resolved a couple of minor but frustrating issues related to rule parsing in Spring Security:

• Custom login and logout URLs are now processed correctly. 
• Complex security configurations involving multiple role assignments for a single endpoint are now properly parsed.

We’ve also enhanced support for the widely used Spring Web library. URL references – especially in MockMvc tests – are now properly recognized and autocompleted.

Remote development

Remote development – connecting to a powerful remote host where the IDE runs from a thin frontend client – is becoming the norm, with many enterprises relying on it.

We are fully committed to making the remote development experience in IntelliJ IDEA equal to the local one. While it has proven to be a hard endeavor for such a complex product as IntelliJ IDEA, and achieving this goal is taking time, version 2025.2 marks a huge step in this direction:

• The editor is now as responsive when working remotely as it is in a local setup.
• This is also true for the Search Everywhere, Find in Files, and Git Branches popups.
• The debugger has been reworked so that its backend is isolated from its frontend, making debugging work natively.
• Plugins and settings are properly synchronized between the client and host.

Last but not least – remote development connections are now available directly in the Toolbox app, with support for all OS and OpenSSH connections. And you know what? They are at least 1.5x faster!

For more details, refer to this blog post.

Support for WSL

The majority of our users are on Windows, which is known to have some performance limitations and specific toolchains. That is where WSL comes in handy, and roughly one out of every five Windows users works with WSL eventually.

IntelliJ IDEA has offered WSL support for some time. However, the way we chose to provide the integration proved unscalable and did not work well for large projects – with issues ranging from performance problems to the inability to run or even open projects.

To ensure you can stay productive regardless of where your project is, we started a rework of the WSL integration from the ground up. The IntelliJ Platform team created a new API that dramatically reduces communication overhead between the IDE and WSL and allows you to work with WSL projects natively as though they were in the same system as the host IntelliJ IDEA – without needing to spin up a full backend inside WSL.

While this is still a work in progress, we have migrated significant parts of the integration to this new API. As a result, in 2025.2:

• Maven and Gradle projects can be reliably built and tested, with proper JDK detection and better overall performance.
• You now have a consistent experience with application servers, whether you’re running Tomcat or WildFly servers locally or on WSL.

Further improvements to Kotlin K2 mode

K2 mode, the new default implementation of Kotlin support that improves Kotlin code analysis stability and overall performance, continues to evolve. In this release, we’ve:

• Provided support for Kotlin 2.2 features.
• Improved the performance of code completion.
• Added type-smart completion support. 
• Added new inspections with corresponding coroutine-specific quick-fixes and refactorings, like Convert Enum to Sealed Class, Extract Interface, Rearrange Code, and Create Test and Navigate for files and functions.
• Resolved several false-positive errors in inspections.
• Improved the reliability of Kotlin script execution. 

Learn more about the state of K2 mode in our recent blog post.

Quality upgrades for Kotlin Notebook

Kotlin Notebook is a go-to tool for performing ad hoc and prototyping tasks, presenting, writing documentation, and visualizing data, all while enjoying access to your project context and easy dependency management. Since its recent release, interest in it has been growing, and we’ve received a lot of feedback that we are now addressing, focusing on stability and the editing experience.

• AI Assistant cells now allow you to choose a model, view the prompt history, and get automatic suggestions.
• Incorrect syntax highlighting has been fixed.
• Dependency management has been improved.
• Kotlin intentions and inspections have been added to make the editing experience close to what you get in a regular .kt file. 

Maven execution

Maven integration is used by half of our users. Historically, IntelliJ IDEA has additional configuration layers on top of Maven, and while they bring speed and control, some differences between execution from the IDE and from the CLI could occur. 

One of the common reasons for such problems was that the specific environment configuration – the .m2/settings file, .mavenrc, or environment variables – was not properly inherited. Starting from 2025.2, IntelliJ IDEA starts Maven goals in such a way that the environment is fully respected.

Thanks to this change, it is now possible to use the Maven Daemon for goal execution. If you have one installed, specify it as a Maven home path in File | Settings | Build, Execution, Deployment | Build Tools | Maven, and all goals will be run using it, speeding things up a bit and reducing resource usage.

Project sync and goal execution now also support plugins that supply custom M2E lifecycles, for example, Byte Buddy. When such plugins are present, the required pre-build and post-build steps will be configured and executed as necessary.

Cloud tooling

Interaction with cloud services is now a major part of software development workflows. This includes the building, deployment, and sometimes managing remote environments. Terraform and Kubernetes are key tools in these scenarios, which is why they are our focus areas.

For Terraform, the 2025.2 update brings: 

• Better support for provider-defined functions:
  • Correct syntax highlighting.
  • Quick navigation to provider definitions. 
  • On-hover documentation.
  • Default code formatter.
  • Auto-completion for object variables. 
  • Specific support for the Keycloak provider.
  • Support for resources in Google Cloud Beta.
• Ability to use for_each in import blocks.
• Accurate binary detection on Windows.
• Terraform file recognition.

For Kubernetes, there are: 

• Improved port-forwarding with automatic suggestions for ports and real-time checks for availability.
• Better performance when working with large log files.
• More information about pods.
• Auto-marking of the active cluster.

On top of that, this update improves the GitLab CI integration with: 

• Smarter support for CI language variable expressions.
• Rich code completion. 
• On-hover documentation. 
• Support for injecting shell code directly into your pipelines.

Debugger

Debugging and profiling are essential tools for developing high-quality software, and we strive to make sure that IntelliJ IDEA’s debugger remains best in class. On top of the huge rework to provide a native debugging experience when working remotely, we’ve also fixed issues and provided additional capabilities for existing use cases.

• You can now evaluate code on any application pause during execution, not just at breakpoints.
• The Analyze Stack Trace or Thread Dump action can now analyze outputs from the jstack and jcmd tools, including in the new JSON format.
• The Collect Thread Dump action now works with the Eclipse OpenJ9 JVM.

GraalVM debugger

Compiling JVM applications to native code significantly reduces CPU and memory usage, but debugging native images remains challenging. In this release, we’ve improved the native image debugger:

• Variable rendering provides richer information, for example, full object content and details about proxy objects.
• Expression evaluation has been enhanced, making reflection calls such as clazz.getMethod(“myMethod”).invoke(instance) work correctly. 

Profiler 

The profiling experience depends on the Java version, and there used to be cases when it didn’t work with Java 24 and the upcoming Java 25. We fixed the failures and implemented support for new language features. You can now reliably profile your application on any Java version and also easily integrate Async-Profiler 4 into your workflow.

Performance

Terminal

In 2025.2, we’ve enabled the reworked terminal for all users. This change brings significant improvements in rendering and overall terminal performance. For bash and zsh, it also brings some minor visual changes, but without compromising the shells’ behavior. 

Working with data sources

When working with large databases, the IDE used to load the entire schema, which produced overhead and was rather slow. Now, PostgreSQL and Microsoft SQL Server are introspected by levels, so only specific parts of the schema are loaded, reducing this overhead.

PostgreSQL users also benefit from smart refresh, which updates only the objects affected by DDL changes.

Developer experience

We have also invested effort into small UX improvements, especially in areas related to reading code. For example, we’ve reworked the Parameter Info popup to make it cleaner, more readable, and easier to use across all supported languages.

That’s it for now 

Let us know what you think about the fixes and priorities in this release. Your feedback helps us steer the product so it works best for you.

Update to IntelliJ IDEA 2025.2 now and see how it has improved. Don’t forget to join us on X, Bluesky, or LinkedIn and share your favorite updates. 

Thank you for using IntelliJ IDEA!

Subscribe to IntelliJ IDEA Blog updates

Subscribe form

By submitting this form, I agree to the JetBrains Privacy Policy Notification icon

By submitting this form, I agree that JetBrains s.r.o. ("JetBrains") may use my name, email address, and location data to send me newsletters, including commercial communications, and to process my personal data for this purpose. I agree that JetBrains may process said data using third-party services for this purpose in accordance with the JetBrains Privacy Policy. I understand that I can revoke this consent at any time in my profile. In addition, an unsubscribe link is included in each email.

Submit

Thanks, we've got you!