IntelliJ IDEA 2025.1 EAP 6: Interactive Scratch Files in K2 Mode, Enhanced Dependency Resolution in Kotlin Script Files, and More

Maria Kosukhina

IntelliJ IDEA 2025.1 EAP 6 is here! As we continue shaping the first major release of the year, you can get an early look at what’s coming by trying out the latest EAP build.

You can download it from our website, update directly from within the IDE, use the free Toolbox App, or install it via snap packages on Ubuntu.

Download IntelliJ IDEA 2025.1 EAP 6

If you haven’t explored the previous EAP builds yet, now’s the perfect time to catch up – visit the 2025.1 EAP section of our blog to see everything we’ve introduced so far.

Now, let’s dive into this week’s updates!

Kotlin 

Enhanced dependency resolution in main.kts

IntelliJ IDEA 2025.1 EAP 6 enhances the user experience for dependency resolution in Kotlin build scripts. Previously, main.kts dependency resolution ran in parallel with code highlighting, causing the code to appear red and then turn green as dependencies loaded. This process sometimes caused freezes and lacked clear feedback and control. 

Now, the resolution is more stable and predictable. You can track its progress using the Load script dependencies button. Scripts with no dependencies open immediately, ready for highlighting without unnecessary processing.

This is not the final design, and we are still gathering feedback – you are welcome to share your thoughts!

Interactive scratch files in K2 mode

Scratch files are now available in Kotlin K2 mode, allowing you to create and run code drafts within the same IDE window as your project. With interactive execution, you can see results immediately, reducing the feedback loop and making experimentation smoother.

Hints on code alterations caused by Kotlin compiler plugins

With this update, IntelliJ IDEA now provides clearer insights into modifications introduced by compiler plugins, making their behavior more transparent. Kotlin features several powerful compiler plugins used across various domains, such as kotlinx.serialization and all-open, which can alter how Kotlin code behaves.

Some key modifications that compiler plugins can make include:

• Changing declaration modality – Compiler plugins can modify the modality of declarations, meaning a `final` declaration may become open. The all-open plugin does exactly this. To clarify that a declaration’s modality has been changed, IntelliJ IDEA now displays this information.

• Adding new supertypes to existing classes – Some plugins introduce new supertypes. For example, kotlinx.serialization adds a KSerializer supertype to declarations annotated with @Serializable. These supertypes are now visible in IntelliJ IDEA.

That’s it for this week! For the complete list of changes, refer to the release notes.

Try out the latest build, share your feedback on X or in the comments below, and stay tuned for more exciting updates in the coming weeks. If you spot a bug, please report it to our issue tracker. 

Happy developing!

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!