This version brings updates designed to streamline your workflows and help you confidently adopt the latest innovations across the Java ecosystem. 

You can download this latest release from our website or update to it directly from inside the IDE, via the free Toolbox App, or using snap packages for Ubuntu.

Explore the What’s New page for a complete overview of the key new features, including detailed explanations and demos.

Explore the What’s New page

In addition, our developer advocates have recorded a walkthrough video covering all the release highlights. Check it out!

IntelliJ IDEA 2026.2 adds day-one support for Java 27 and the latest Kotlin 2.4 language features, helping you stay up to date with the newest JVM technologies. This release also streamlines Spring development with improved database migration workflows and richer Spring Security insights, while making debugging more powerful with new logpoints and enhanced navigation from runtime output to source code.

Here are the key highlights of this release:

AI upgrades:

• Native GitHub Copilot integration
• Agent skills
• AI completion support for third-party providers

Productivity-enhancing features:

• Logpoints
• Dependency completion
• Early Gradle 10 support and migration assistance
• Streamlined Git conflict resolution flow
• Docker Compose improvements

Support for new technologies:

• Java 27
• Kotlin 2.4 Stable features
• Spring support improvements 
• Terraform testing framework 
• TypeScript 7.0 

Version 2026.2 also delivers numerous stability, performance, and usability improvements across the platform. These are described in a separate What’s Fixed blog post.

Let us know what you think about the new features in this release, as your feedback helps us shape the product so it works even better for you.

Update to IntelliJ IDEA 2026.2 now to try out these new features. Don’t forget to join us on X, Bluesky, or LinkedIn, and be sure to share your favorite updates.

Thank you for using IntelliJ IDEA!

This release brings more than 1,300 bug fixes and usability improvements, and it addresses 140 freezes and other performance issues identified through internal diagnostics and user reports. Below is a recap of the most impactful updates.

Performance

Responsiveness remains a top priority. IntelliJ IDEA 2026.2 includes fixes for more than 140 freezes and other performance issues.

When editing Markdown files, the IDE is now much more responsive, improving the experience of writing specifications for agents

Projects opened natively in WSL or Docker environments should stall less often.

Editor file saves are now asynchronous. Writing a file to disk no longer blocks the UI thread, reducing the likelihood of freezes during save operations. If you develop IDE plugins, please refer to this dedicated blog post for migration guidance.

The custom file chooser now loads directories using asynchronous I/O and lazily expandable nodes, reducing UI freezes and making navigation more responsive in large or remote directory structures. The custom file chooser is primarily used in WSL, Dev Containers, and remote development environments, but you can also use it more broadly by disabling the Use native file chooser dialog option in Advanced Settings on Windows or macOS.

The loading of Spring configuration metadata is also faster and more stable. We resolved issues that could cause excessive memory consumption, endless metadata collection loops, and exceptions during Spring Boot configuration analysis.

Spring

To ensure readability and help you better understand code written by others, whether humans or agents, we are doubling down on fixes related to code resolution, navigation, and usage detection.

Note that some of these improvements are planned for the IntelliJ IDEA 2026.2.1 update.

Spring Boot configuration properties

IntelliJ IDEA now handles more configuration patterns correctly in application.properties files, YAML files, annotations, test configurations, Kotlin classes, Java records, nested objects, maps, lists, and custom configuration classes. Resolution, highlighting, completion, navigation, and @ConfigurationProperties mapping have all been improved.

See YouTrack issue IDEA-370087 for the full list of fixes.

Spring Security 2026.2.1

IntelliJ IDEA recognizes more ways to define request matchers, including paths supplied as arrays, the requestMatchers(RequestMatcher...) overload, and matchers created with PathPatternRequestMatcher.pathPattern(...). For example, the IDE will recognize and highlight new RegexRequestMatcher(pattern, method) as a regular expression. SpEL expressions in @PreAuthorize and other security annotations will correctly understand all usages of this.

New inspections will help identify ordering problems in a SecurityFilterChain, warning you, for example, when requestMatchers() are placed after anyRequest().

See YouTrack issue IDEA-391028 for the complete list of improvements.

Spring Cache 2026.2.1

Support for Spring Cache annotations, including @Cacheable, @CachePut, @CacheEvict, and @Caching, is becoming more accurate, with better SpEL expression validation and proper usage detection for methods referenced only through a #root.target expression

Additionally, inspections for conflicting @Cacheable and @CachePut, for # prefixes missing from root or result, and others no longer produce false positives.

See YouTrack issue IDEA-390707 for the full list of fixes.

Spring Events 2026.2.1

Improvements to the Spring Events support provide more reliable navigation between event publishers and listeners, including ApplicationListener implementations that listen for a base event type, events published through generic methods, custom generic events implementing ResolvableTypeProvider, and publishEvent calls made through method references

New inspections warn you when an @EventListener method listens for an early Spring Boot lifecycle and detect potentially incorrect combinations of @TransactionalEventListener and @Transactional that can otherwise fail only at runtime.

See YouTrack issue IDEA-390826 for the full list of improvements.

Thymeleaf

IntelliJ IDEA’s Thymeleaf support is now more reliable across expressions, tags, attributes, JavaScript inlining, completion, and property resolution. The IDE recognizes more expression forms, including inline output, bracket-based map access, nested selections, and T() references, while eliminating false warnings for common Thymeleaf and Layout dialect constructs. JavaScript expressions inside <script th:inline="javascript"> are handled correctly, numeric property keys now resolve as expected, and the Empty tag inspection can be disabled for Thymeleaf templates.

See YouTrack issue IDEA-370051 for the complete list of updates.

Kotlin

Server-side

We’re continuing to close the gaps between the Java and Kotlin support in Spring-based server-side projects.

IntelliJ IDEA can now configure Kotlin support for Lombok and other annotation processors through kapt automatically, reducing the amount of manual project setup required. These changes should make mixed Java and Kotlin projects more predictable.

Kotlin completion in Java code

IntelliJ IDEA’s Java code completion now also suggest Kotlin extension functions and companion object members. More complete and better sorted suggestions make working in mix-language codebases easier.

Removal of K1

With K2 adoption now above 99% across IntelliJ IDEA and Android Studio, we have removed the remaining K1-mode options and relevant code from the product.

Editor and navigation

The Markdown integration now supports standard footnotes, allowing the proper use of [^label] syntax. This resolves a long-standing feature request and makes it easier to work with technical documentation, articles, and other reference-heavy content directly in the IDE.

The IDE now knows how to keep your bookmarks when you switch Git branches. If you want to have your bookmarks preserved, disable the Enable bookmark context restoration on branch switching option in Settings | Advanced Settings.

When searching for classes, files, or symbols in Search Everywhere, IntelliJ IDEA now remembers the scope you selected, such as Project Files, Project and Libraries, or a custom scope. The same selection is restored automatically the next time you start a search.

Double-press shortcuts, such as Shift+Shift for Search Everywhere and Ctrl+Ctrl for Run Anything, are now fully customizable in Settings | Keymap.

User interface

Islands theme color coding

Colors assigned to scopes, such as test files or non-project files, remain visible when the tab is active, making it easier to identify the type of file you are currently editing at a glance.

Bundled plugins

Deprecation of the Machine Learning Code Completion (Ranking) plugin

The Machine Learning Code Completion plugin, which improved ranking, is being deprecated and will no longer be bundled with IntelliJ IDEA.

As AI completion, next edit suggestions, and coding agents have become the main forms of intelligent development assistance, the benefits of ML-based completion ranking have declined significantly.

The plugin remains available from JetBrains Marketplace, so you can install it separately and continue using it where needed.

Unbundling of the Task Management and Time Tracking plugins

The Task Management and Time Tracking plugins have also been removed from the default IntelliJ IDEA distribution.

Both plugins saw relatively low usage, and unbundling them helps keep the standard installation leaner. Their functionality has not changed, and both plugins can still be installed directly from JetBrains Marketplace.

More relevant plugin search results

Plugins will be easier to find, as searching for them in Settings | Plugins now produces better-ranked results.

Previously, all plugins containing the search text in either their name or description could appear in an arbitrary order, but now name matches are prioritized.

Conclusion

Let us know which fixes make the biggest difference in your workflow and where you still encounter friction. Your reports, feedback, and sample projects help us understand which issues have the greatest impact and what we should prioritize next.

Try IntelliJ IDEA 2026.2 and share your favorite improvements with us on X, Bluesky, or LinkedIn.

Thank you for using IntelliJ IDEA!

Hello everyone,

The new release of IntelliJ IDEA introduces a few new features for Scala developers that we’ve been working on for some time, as well as a number of fixes and improvements. We hope that they will make your Scala experience even better than before.

Build tool support

The logic behind sbt tasks in run/debug configurations has been reworked and now allows for a wider range of sbt commands. This enabled us to fix an issue where passing multiple parameters to an sbt command was either interpreted as a single parameter or caused the command name to be treated as an additional parameter. To work around this, developers had to run the task in the sbt shell instead. The new logic is much simpler: We no longer modify the user input. Instead, the input is expected to be a valid sbt command, e.g. tasks must be separated with semicolons, and we do not unquote the input.

Additionally, we’ve fixed a bug in the sbt shell where sync failed after waiting for user input. Also, previously, sbt import would not work if the .jvmopts file contained key-value pairs separated by a whitespace, such as --add-exports java.base/sun.nio.ch=ALL-UNNAMED – we’ve fixed this, too.

Separate ScalaTest tests can now be run through Bazel. Previously, this functionality was implemented on the Bazel side, but with the introduction of the new official JetBrains Bazel plugin, it made more sense to move it to the Scala plugin. And, by the way, this is an external contribution from one of our users!

WSL and Docker

Starting with IntelliJ IDEA 2026.2, WSL and Docker support covers not only sbt projects, but also BSP projects and projects built with other BSP-based tools, such as Mill, Scala CLI, and Bloop. On top of that, we’ve stabilized WSL support and fixed several bugs where sbt imports and re-running tests used to fail in WSL.

Scala 3

The new release includes full support for Clause Interleaving (SIP-47), which is a standard feature as of Scala 3.6. This allows IntelliJ IDEA to support previously impossible combinations of type parameters and regular parameters. This is illustrated in the getOrElse method declaration below, where it is necessary to know the instance of the key parameter to properly calculate the type bound of the default parameter:

The update method in that code example also shows that we now support dependent parameter types belonging to the same clause. Previously, the example would have worked only if key and value had been placed in separate, single-parameter clauses.

On the error-highlighting front, we’re working on improving support for match types in the built-in highlighting. This new release supports type-level operations, as shown in the code example below. We’re working on expanding this support to cover some missing corner cases.

We’ve also fixed a bug where calling a synthetic companion object could not be resolved, and another one where a wrong number of indents could lead to changed semantics.

Code completion

In v2026.2, we introduce support for Scala in a recently added IntelliJ IDEA feature, command completion. You are likely already familiar with the behavior where, if you type a dot (.) after a symbol (be it a class, a method, or a value name), IntelliJ IDEA opens a code completion window. Now, if you type two dots quickly one after another, another popup will appear with suggestions for commands that might be useful in the situation. You can learn more from our blog post dedicated to command completion or watch the screen recording below.

Other improvements

Additionally, we’ve improved the handling of @throws directives and of link references in ScalaDoc. The @Language injection annotation is now recognized on apply methods in case classes and implicit classes, and we’ve fixed an issue with how single tests are discovered in mUnit. Further improvements include a new version of the quick-fix for using scala.compiletime.uninitialized instead of null in null-initialized variables, as well as improved handling of nullable variables.

As always, we welcome your feedback. Please report any issues you find in YouTrack. If you have any questions, feel free to ask us on Discord.

Happy developing!

The Scala team at JetBrains

This month’s lineup spans the usual favorites: fresh finds from the Java and Kotlin worlds, a healthy dose of AI developments worth your attention, and a few detours into other technologies that caught our eye. 

We’re also delighted that Tom Cools is sharing his content highlight of the month with us!

As always, we’ve found the upcoming events you’ll want on your calendar, plus a handful of topics worth debating or quietly thinking about on your next coffee break.

So grab a coffee, give your AI agents a moment to finish coding, and dig in – there’s a lot of good stuff below!

Featured Content 

Tom Cools 

Tom Cools 

Tom regularly presents at conferences and organizes the Belgian Java User Group (BeJUG). He works for Timefold, a Java-rooted planning optimization company solving complex problems like employee shift scheduling, vehicle routing, and task assignment. The team recently shipped Timefold Solver 2.0, its first major version in three years.

June kicked off with J-Spring, the international Java conference organized by NLJUG, which took place on June 4 in Utrecht. I gave a talk there, LLMs Can’t Optimize Schedules, but AI Can, but the real highlights of the day for me were other people’s sessions.

At the top of that list was the keynote from Felienne Hermans, one of my favorite people in our field and the author of one of my favorite books, The Programmer’s Brain (Manning). If you haven’t read it yet, go do it.

Another session that stuck with me was Holly Cummins’s talk on benchmarking, When benchmarks go bad: what I learned from measuring performance wrong. It was a great reality check that you can’t have it all in life, and that “benchmarking” can mean wildly different things depending on what you’re trying to measure and who’s doing the measuring. Well worth a click through the slides.

June was also a big month for the Java platform itself – Valhalla is finally coming. On June 15, JEP 401 (Value Classes and Objects) was confirmed for integration into mainline OpenJDK, targeting JDK 28. Artur Skowroński wrote an excellent deep-dive in JVM Weekly, Project Valhalla, Explained: How a Decade of Work Arrives in JDK 28. Go read it! 

Looking ahead, I’m excited to spend the summer really experimenting with agentic frameworks, Koog, Pi, and others to see how we can deliver better software…faster is a nice extra.

Java News

Let’s kick things off with the latest from the Java world: 

• Java News Roundup 1, 2, 3, 4, 5
• JEP targeted to JDK 27: 538: PEM Encodings of Cryptographic Objects (3rd Preview)
• JavaNext Language Features
• Performance Improvements in JDK 26

Java Tutorials and Tips

Next up, a handful of tutorials and tips to sharpen your skills and maybe teach an old codebase a few new tricks: 

• Intelligent JVM Monitoring: Combining JDK Flight Recorder with AI
• Episode 59 “Java *is* Memory Efficient” [AtA] 
• Ternary, Predicate, and Pattern Matching for FizzBuzz with Java 26
• GeeCON 2026: Discussion panel – Java 27 and Beyond: What Excites You, and Which Myths Need to Die
• Nulls are dead – Moritz Halbritter | IntelliJ IDEA Tech Talks
• Building AI-Powered Java Applications With Jakarta EE and LangChain4j
• Getting Started With Agentic Workflows in Java and Quarkus
• Why You Should Tune Code Before Your Garbage Collector
• Jakarta EE is Ready for AI – But Don’t Just Take My Word for It!
• Tiberius: A Security Testing Framework for LLM Applications in Java
• Practical Performance Tuning for Serverless Java on AWS 
• Episode 60 “How JEPs Drive Java’s Evolution” [AtA]
• Modern Java at Stripe: Language upgrades as a service

Kotlin Corner

Here’s what’s been keeping the Kotlin community busy this month:

• Kotlin turns 15 
• Kotlin comes to BlueJ 
• Apply for the 2026 Kotlin Foundation Grant Program for Library Authors
• Kotlin Toolchain 0.11: The Next Step for Amper

AI 

In AI, this month brought plenty of new tools, ideas, and developments worth a closer look: 

• Customizing Antigravity CLI: Title and Status Line
• Guidelines for Respectful Use of AI
• AI enthusiasts are in a race against time, AI skeptics are in a race against entropy
• AI gateways: why and how 
• Junie, IntelliJ, and Spec-Driven Development
• Vibe Coder vs Software Engineer
• Building an AI-Powered Operations Assistant with Spring AI and MongoDB Atlas — Part 2: 
• Conversational Memory
• Stop Pasting Tokens: OAuth2 for JetBrains IDE Plugins
• With Claude: Less Coding, More Testing
• Anthropic Explains How Claude Builds Its Own Execution Harnesses
• Building an autonomous ML researcher with Claude Code dynamic workflows
• AI Coding Agents Get a Stack Overflow of Their Own
• Foundations of AI Coding
• Did AI Just Break Software Security For Ever?
• Oracle’s OpenJDK Bans Generative AI Contributions While Oracle’s GraalVM Allows Them
• Systematic AI Coding: My Takeaways from the Eclipse Foundation Workshop in Brussels
• Rules for Understanding Language Models
• I Stopped Coding and Started Architecting Agents (And Why You Should Too)

Languages, Frameworks, Libraries, and Technologies

Beyond Java and Kotlin, here’s a roundup of the languages, frameworks, libraries, and technologies that caught our eye this month: 

• This Week in Spring 1, 2, 3, 4, 5
• Spring and Security In The Times Of AI
• What is Sharding in MongoDB and When Should You Use It?
• How Gradle Is Javamaxxing
• Two Hibernate Annotations That Cut Our JSON Processing Time in Half
• A Bootiful Podcast: JetBrains’ Marit van Dijk
• Snake in 10 Lines: Learning More by Coding Less by Guus de Wit – JNation 2026
• Empower your AI migrations to Quarkus with Skills
• Spring Boot Migration and the CRA: When Good Enough Isn’t
• Why Spring Teams Don’t Need a Second Runtime for AI Agents
• Can Java Microservices Be As Fast As Go? A 2026 Benchmark Update 
• A Bootiful Podcast: Spring Security lead Rob Winch answers some security questions for me
• Codename One: On-Device Debugging And JUnit 5
• Moving Mountains: Migrating Legacy Code in Weeks instead of Years
• Spring vs Quarkus vs Jooby vs Vert.x: Pick Your Next Java Framework
• Relocation of Maven Package in Maven Central
• Quarkus Unpacked: Insights from the Foojay Podcast
• Unknown JSON fields in Java REST clients: JSON-B, Jackson, Quarkus, and Spring Boot
• AI-Assisted Unused & Dead Code Removal
• Sebastien Deleuze on Spring AI 2.0, Kotlin, and more
• Spring Boot team member Moritz Halbritter

Conferences and Events

Here’s what’s coming up on the calendar: the conferences and events worth marking down in the months ahead.

• WeAreDevelopers – Berlin, Germany, July 8-10
• Java Forum Stuttgart – Stuttgart, Germany, July 9
• ÜberConf – Denver, USA, July 14-17
• JConf Dominicana – Santiago, Dominican Republic, July 17-18
• JCRETE – Crete, Greece, July 27-31; Come meet Marit van Dijk and Anton Arhipov from JetBrains. 

Culture and Community

The people, conversations, and ideas that make our corner of tech worth being part of: 

• The Human Toll of Incidents & Ways To Mitigate It
• Humans In The Way
• How a Culture of Data-Driven Conversations Can Support Platform Engineering
• The Technology Adoption Curve, Twenty Years On
• Context Is Code: A Tour of APM and AgentRC
• From MCP and Vibe Coding to Harness Engineering: How Did AI Native Engineering Evolve in One Year
• A Bootiful Podcast: My friend Francesco Ciulla on developer advocacy and more
• Craig McLuckie on Culture as a Team’s Operating System in the AI Era
• Ask a Lille Dev: What Java Developers Really Think About Quality, Frameworks, Communities, and Careers
• General and Surprising 

And Finally…

A few fresh posts from the IntelliJ IDEA and JetBrains blogs to close out this month’s edition:

• Your JetBrains IDE Expertise, Now on LinkedIn
• Hibernate 7.4 New Features
• Stop Pasting Tokens: OAuth2 Login for JetBrains IDE Plugins
• Kotlin Notebook Sunset

That’s it for today! We’re always collecting ideas for the next Java Annotated Monthly – send us your suggestions via email or X by July 20. Don’t forget to check out our archive of past JAM issues for any articles you might have missed!

You can update to this version from inside the IDE, using the Toolbox App, or using snaps if you are a Ubuntu user. You can also download it from our website.

The latest update brings the following improvements:

• The active Git branch now updates correctly. [IJPL-240184]
• Fixed an issue where using pull_policy in Docker Compose files prevented the PHP interpreter from being created. [IJPL-189121]
• The IDE no longer erroneously marks successful Gradle syncs as failed when running Gradle 9.5.0 on WSL. [IDEA-388949]
• Fixed an error that caused Dev Container connections to fail with an Unknown Docker endpoint schema message. [IJPL-240184]

For a comprehensive overview of the fixes, see the release notes. If you spot any issues, let us know via the issue tracker.

Happy developing!

The plugin will remain available on an open-source model so the community can continue its development. 

Below, we explain why we’re making this change, how it affects current Kotlin Notebook users, what comes next, and how Kotlin DataFrame will continue to exist beyond Kotlin Notebook.

Why we’re making this change

Demand for built-in interactive tooling has shifted since we launched the plugin, and Kotlin Notebook didn’t reach the level of adoption we expected. AI tools have changed how developers explore code, prototype, and iterate, and many of the workflows that originally drove notebook adoption have evolved along with that shift.

After reviewing usage trends, we’ve decided to move Kotlin Notebook out of our internal roadmap and into the open. Going forward, our team will devote its time to projects with a broader impact on Kotlin developers.

Timeline and what to expect

Here’s what to expect during the transition:

v2026.1 and earlier:

• Kotlin Notebook remains bundled with IntelliJ IDEA.

v2026.2:

• Kotlin Notebook will be unbundled from IntelliJ IDEA.
• JetBrains will no longer develop new features for Kotlin Notebook.
• The Kotlin Notebook plugin will still be available for installation from the marketplace. It is compatible with v2026.2. However, we do not maintain it anymore. Future development will happen in the open-source repository only. 
• The plugin source will be published on GitHub under the Apache License 2.0. Users can build the plugin from GitHub and install it manually. The README walks you through the steps.

V2026.3 and further:

• JetBrains won’t publish a compatible plugin for v2026.3 and beyond.

During the transition to community ownership:

• We plan to continue maintaining the Kotlin Jupyter kernel on a best-effort basis, as capacity allows.
• If you’re interested in maintaining or contributing to Kotlin Notebook, please share your interest in the Kotlin Slack #notebooks channel. 
• Our Support team will be available during the transition for compatibility questions.

Kotlin DataFrame beyond notebooks

If you’re using Kotlin DataFrame, recent releases have made it much easier to bring notebook-style, type-safe data transformations into regular Kotlin projects. With the Kotlin DataFrame compiler plugin, schema-aware APIs and generated column accessors are now available directly in Gradle and Maven projects and can be used in ordinary .kt files.

To get started, see the setup guides for Gradle and Maven:

• Gradle: https://kotlin.github.io/dataframe/setupgradle.html
• Maven: https://kotlin.github.io/dataframe/setupmaven.html

We also recently released Kotlin DataFrame 1.0.0-Beta5, with numerous improvements across the library. See the release notes here.

If you have questions about migrating existing workflows or adopting Kotlin DataFrame in your projects, feel free to reach out in the Kotlin Slack #datascience channel.

Thank you note

We’re grateful to everyone who used Kotlin Notebook, filed issues, and shared feedback over the years. Thank you!

The JetBrains team

That common protocol is only a part of the IDE integration. The IDE still has to decide how to start the server, handle the code, and assist in development. That is where plugin authors spend their time.
Product availability is one of the areas they struggle with, and the author of the Azure DevOps Pipeline plugin recently faced it. Even though the plugin registered platform.lsp.serverSupportProvider, opening the azure-pipelines.yml file should have started the language server through the IntelliJ Platform LSP client. In Android Studio, it didn’t happen because the LSP integration is a commercial IDE extension, not part of the open-source IntelliJ Platform used by Android Studio. No visible error, no fallback, users are left all alone.

Another plugin author took the more drastic route. For Noctule, a Swift plugin, they wrote their own LSP client from scratch because the available options did not fit the plugin they wanted to ship. They needed control over where the plugin worked, how it behaved across IDE versions, and how deeply it integrated with the editor. At that point, a custom client was not over-engineering, but it was the only way to make the plugin behave consistently.

That is the gap we want to close.

With the 2026.2 release cycle, we are open-sourcing the LSP client API, making the stable and battle-tested platform client available to JetBrains IDEs, Android Studio, and other products based on the public IntelliJ Open Source project.

What comes next?

The public API is being renamed before it becomes widely available. The old names made the IDE side sound like the server side. That gets confusing once the code is open and used outside JetBrains IDEs. The platform owns the LSP client and the IDE integration; the language server is the external process. So LspServer becomes LspClient, and the provider moves to LspIntegrationProvider.

If your plugin already uses the JetBrains LSP API, watch both updates and adjust to the new names.

If your plugin uses LSP4IJ or a custom client, do not migrate just for the sake of it. Check minimum IDE version, Android Studio support, feature coverage, customization hooks, and remote or split-mode needs. Make sure to share your feedback on the JetBrains Platform forum.

For a new language integration, start with the LSP article in the IntelliJ Platform SDK Docs, if a good language server already exists. To bootstrap a plugin, use the IntelliJ Platform Plugin generator or the reworked Project wizard inside IntelliJ IDEA with the Plugin DevKit plugin installed.

We’re collaborating with LinkedIn to make it easier for you to showcase your expertise with JetBrains IDEs on the world’s largest professional network. You can now connect your IDE to LinkedIn and let your real tool usage speak for itself.

Connect your IDE

IntelliJ IDEA, PyCharm, WebStorm, PhpStorm, Rider, GoLand, CLion, RustRover, and RubyMine are already supported via a free plugin, while support for DataGrip is coming soon.

In this blog post, we’ll explain what LinkedIn connected apps are, what they mean for your profile, and how to get started.

What this is about

Building on early collaboration with Descript, Duolingo, Lovable, Relay.app, and Replit, LinkedIn is expanding the range of apps you can feature on your LinkedIn profile, turning real-world product usage into a credible, visible signal of practical tool experience. We’re glad to join forces with them to bring this to JetBrains IDE users.

“We’re building new ways for members to show real, credible proof of what they’re capable of, right on their LinkedIn profile. And for the brands behind these tools, there’s no better endorsement than a customer who’s actively using and loving your product.”
– Dan Shapero, CEO of LinkedIn

Connected apps let you link the tools you use in your daily work directly to your LinkedIn profile, where they appear prominently, helping you stand out to your professional network. Once connected, each app generates a simple statement based on how you actually use it. Unlike manually added skills, this is based on real usage and updates automatically as your experience evolves.

How to get started

Open your JetBrains IDE, go to Settings | Plugins, search for the LinkedIn Connected Apps plugin under the Marketplace tab, and install it. 

Once installed, the plugin starts collecting data locally about how you use your IDE. Depending on your usage history, you may receive an initial statement right away, which will then be updated once the plugin has collected enough data to better reflect your real IDE expertise.

Your IDE usage data stays on your machine. When you are ready, you can connect your LinkedIn account and share your IDE expertise badge there. If you keep the plugin installed, your badge will update automatically as your IDE usage evolves.

The plugin is free for all JetBrains IDE users.

What’s included in this release

This is the first version of the integration, delivered as a standalone plugin rather than being built directly into the IDE. It covers IntelliJ IDEA, PyCharm, WebStorm, GoLand, PhpStorm, Rider, CLion, RustRover, and RubyMine; DataGrip is not yet supported. 

Usage is detected within the IDE itself, so if you use AI features via an external tool or terminal, those won’t be reflected yet.

How your IDE expertise is determined

The model is intentionally simple for now. It is designed to represent your practical use of JetBrains tools, not to rank developers or certify skill levels. Our goal was to provide a solid starting point, but we know there’s more to capture about how developers work with their IDEs.

Statements map to different levels of experience and are generated based on how you interact with your IDE – from writing and editing code using basic features to working with debugging tools, version control, and AI-assisted workflows. For more information, see our documentation.

What’s coming next

We’re already working on the next version, planned for later this year. We’ll focus on improving how IDE usage, including AI feature usage, is represented, expanding support to DataGrip, and making the overall experience feel more integrated.

FAQ

Which JetBrains IDEs are supported?

IntelliJ IDEA, PyCharm, WebStorm, GoLand, PhpStorm, Rider, CLion, RustRover, and RubyMine. Support for DataGrip is coming soon.

Why isn’t DataGrip supported yet?

DataGrip is designed for working with databases and includes workflows that differ from our other IDEs. We plan to support it soon.

Can I connect multiple IDEs?

Yes, if you use multiple supported JetBrains IDEs, you can connect each of them. You’ll get a badge for all connected IDEs.

Note: If you use multiple JetBrains accounts across different IDE instances but link them all to the same LinkedIn profile, IDE usage statements from each account will be displayed on that LinkedIn profile.

Do I need to keep the plugin installed after connecting? 

You can share your IDE usage statement once and then remove the plugin, but note that it must remain installed if you want to track your ongoing progress and have any changes reflected on LinkedIn.

Is this feature free?

Yes, it’s available to all JetBrains IDE users at no cost.

Is this a certification?

Connected apps reflect real IDE usage and are designed to showcase applied experience, not to act as a formal certification or skill ranking. Certifications, degrees, and licenses remain important markers of professional achievement. Connected apps on LinkedIn add a different kind of signal: partner-validated tool usage that reflects practical work and can update over time.

What data is shared with LinkedIn and JetBrains?

Only the information required to represent your connected account and IDE usage statement. 

Will this help me get hired?

Having connected apps on your LinkedIn profile is extra proof of your practical experience with leading tools. While connected apps make your expertise visible, they are just one part of your profile. Think of it as a way to let your tooling speak for itself.

Give it a try and let us know what you think in the comments below. We’re continuing to develop this integration, and your feedback will help shape what comes next.

The world of software development keeps moving at full speed, and this month’s selection helps you keep up without drowning in tabs. Inside, you’ll find hand-picked articles, podcasts, videos, and thought-provoking reads covering Java, Kotlin, AI, and the technologies shaping the next generation of development.

Grab a coffee, pick a topic that catches your eye, and get ready to discover what’s new in the world of software development.

Let’s go!

Java News

The latest from the Java world is here. Let’s see what’s new, what’s changing, and what’s next: 

• Java News Roundup 1, 2, 3, 4 
• JEP targeted to JDK 27: 532: Primitive Types in Patterns, instanceof, and switch (5th Preview)
• JEP targeted to JDK 27: 533: Structured Concurrency (7th Preview)
• JEP 533 Tightens Exception Handling in Java’s Structured Concurrency for JDK 27
• Quality Outreach Heads-up – JDK 27: Removal of Deprecated Java Launcher Options
• Java 26: Better Language, Better APIs, Better Runtime
• Quality Outreach Heads-Up – JDK 27: Numeric Fields in JSON Thread Dumps
• Skills, Java 17, and Theme Accents With Codename One

Java Tutorials and Tips

From quick tips to deep dives, here are some Java tutorials worth adding to your reading list:

• Genie Tarpit
• The JDK Client Desktop: 2026 and Still Swinging
• Java is Not the Dark Side: Why Learning Java Is Easier Than You Think
• Comparing Top Gen AI Frameworks for Java in 2026
• Foojay Podcast #95: Is Your Java App Actually Secure, Or Does It Just Look That Way?
• Native Interoperability With JDK 25 and the FFM API
• Episode 59 “Java Is Memory Efficient” [AtA]
• The Legendary Marit van Dijk
• “Fat-Free” Lambdas in Java

Kotlin Corner

From ecosystem updates to productivity-boosting tricks, here’s what’s happening in the world of Kotlin:

• KotlinConf’26 Keynote Highlights 
• Koog 1.0 Is Out! 
• Official Kotlin Support for Visual Studio 
• The Road to Name-Based Destructuring 

AI 

Here’s what caught our eye in the world of AI this month:

• Compressed Cognition: The Cost of Faster Coding
• The Next Generation of AI Products
• Teaching an AI Agent to Debug Flaky Tests
• Agentic AI Workflows for OpenJDK Development
• Why Enterprise Java Teams Need Quality Gates Even More in the Age of AI
• Using AI to Write Better Code More Slowly

Languages, Frameworks, Libraries, and Technologies

The tech world is bigger than just Java and Kotlin. Explore the latest updates and happenings across technologies: 

• This Week in Spring 1, 2, 3, 4
• How a Group of Developers Took Back Control from Enterprise Java | Spring: The Documentary
• Micronaut Framework 5.0.0 Released!
• Kubernetes Made Easy. Deploy. Monitor. Debug. All From IntelliJ IDEA
• Three Pillars of Platform Engineering: A Virtuous Cycle
• The Code Was Always the Door
• When Should You Use a Cache With MongoDB?
• Building an AI-Powered Operations Assistant With Spring AI and MongoDB Atlas – Part 1: RAG Foundation
• Five (and a Half) Cool Things You Can Do With Quarkus
• A Bootiful Podcast: The Legendary Adib Saikali
• Benchmarking AI Agents on Kubernetes
• Product Thinking for Cloud Native Engineers
• A Bootiful Podcast: Hadi Hariri, JetBrains Legend
• A Bootiful Podcast: Microsoft’s Martijn Verburg

Conferences and Events

Mark your calendar: 

• JPrime – Sofia, Bulgaria, June 3–4
• JSpring – Utrecht, Netherlands, June 4
• JSail Unconference – Hemelum, Netherlands, June 8–12
• DevBcn – Barcelona, Spain, June 16–17
• Devoxx Poland – Kraków, Poland, June 17–19
• Voxxed Days Luxembourg – Mondorf-les-Bains, Luxembourg, June 18–19

Culture and Community

Code is only part of the story. Explore the ideas, conversations, and people shaping the developer community:

• The AI Joy Gap: Why Some Developers Thrive While Others Struggle
• Leadership in AI-Assisted Engineering
• AI Native Engineering

And Finally…

Check out the latest blog posts from IntelliJ IDEA: 

• Improving Accessibility in JetBrains IDEs: What’s New and What’s Next in 2026
• Hibernate 7.4 New Features
• Teaching an AI Agent to Debug Flaky Tests

That’s it for today! We’re always collecting ideas for the next Java Annotated Monthly – send us your suggestions via email or X by June 20. Don’t forget to check out our archive of past JAM issues for any articles you might have missed!

The latest update brings the following improvements:

• In tmux, the terminal cursor is no longer rendered above the current line. [IJPL-102697]
• The Markdown preview now correctly displays images when referencing files outside the project directory. [IJPL-171896]
• Custom colors are rendered correctly in various UI components in the Database tool window. [DBE-25711]
• Launching WSL via wsl.exe -d <distribution> no longer causes shell integration and process detection issues. [IJPL-236576]

For a comprehensive overview of the fixes, see the release notes. If you spot any issues, let us know via the issue tracker.

Happy developing!

You can update to this version from inside the IDE, using the Toolbox App, or using snaps if you are a Ubuntu user. You can also download it from our website.

For a comprehensive overview of the fixes, see the release notes. If you spot any issues, let us know via the issue tracker.

Happy developing!

The article will focus on the following features:

• Limits and Fetch Joins: How Hibernate 7.4 improves working with paginated queries that include fetched associations.
• History and Audit Tables: How the new capabilities support querying entity state across time and working with historical data.

You can check out the sample code for this article in this GitHub repository.

Limits and Fetch Joins

One common requirement in data-driven applications is loading a page of parent entities along with an associated child entity collection. For example, suppose an application has an Order entity with a Set<OrderItem> collection, and we want to load the first few orders together with their order items.

List<Order> orders = session
        .createSelectionQuery(
            "select o from Order o join fetch o.items order by o.id",
            Order.class
        )
        .setMaxResults(10)
        .getResultList();

In Hibernate versions before 7.4, applying a limit to a query that used a collection fetch join could not be safely pushed down to the database. Because each Order may have multiple OrderItem rows, limiting the SQL result directly could cut off part of an order’s item collection. To avoid returning incomplete collections, Hibernate loaded all matching rows from the database and applied pagination in memory at the application layer.

That behavior was correct, but it could be expensive. A query intended to load only 10 orders might still read many more rows if the table contained a large number of orders and order items.

Before Hibernate 7.4, the generated SQL would look like the following:

select
    o1_0.id, i1_0.order_id, i1_0.id, i1_0.product_code,
    i1_0.quantity, o1_0.order_number, o1_0.status
from
    orders o1_0
        join
    order_items i1_0
    on o1_0.id=i1_0.order_id

As you can see, the limit(pagination) is not applied at the SQL query level. So, it will load all the orders and their associated order_items, which could be a very expensive operation and may result in OutOfMemoryException.

You can see a WARNING logged by Hibernate as follows:

[WARN] HHH90003004: firstResult/maxResults specified with collection fetch; applying in memory

One option to prevent Hibernate performing pagination in memory is by setting the following property:

hibernate.query.fail_on_pagination_over_collection_fetch=true

By configuring this property, Hibernate throws an exception instead of performing pagination in memory.

Hibernate 7.4 fixes this problem by using nested queries. Instead of applying the limit directly to the joined result set, Hibernate first determines the limited set of parent entity identifiers and then fetches the associated collection for only those parent rows. 

This allows pagination to happen in the database while still returning complete items collections for each selected Order.

With Hibernate 7.4, the SQL will be generated as follows:

select
        o1_0.id, i1_0.order_id, i1_0.id, i1_0.product_code,
        i1_0.quantity, o1_0.order_number,o1_0.status 
    from
        (select
            o1_0.id, o1_0.order_number, o1_0.status 
        from
            orders o1_0 
        where
            exists(select
                1 from order_items i1_0 
            where
                o1_0.id=i1_0.order_id) 
        offset
            ? rows 
        fetch
            first ? rows only) o1_0(id, order_number, status) 
    join
        order_items i1_0 
            on o1_0.id=i1_0.order_id

This improvement makes fetch joins more practical for paginated screens, such as an order listing page that displays each order with its line items, without forcing the application to load the full result set first.

History and Audit Tables

Hibernate 7.4 adds built-in support for temporal history tables and audit tables. Both features help track changes to entity data, but they serve slightly different use cases: history tables let us query the state of an entity at a point in time, while audit tables record the sequence of changes that happened to an entity.

Consider the following Product entity:

@Entity
@Table(name = "products")
class Product {
    //fields id, code, name, price
}

History Tables

To enable temporal history for Product, annotate the entity with @Temporal and optionally specify the history table name using @Temporal.HistoryTable.

@Entity
@Table(name = "products")
@Temporal
@Temporal.HistoryTable(name="products_history")
class Product {
    //fields id, code, name, price
}

With this mapping, Hibernate stores previous versions of product rows in the products_history table. The table includes the entity columns plus two temporal columns: effective, which marks when a version became active, and superseded, which marks when that version was replaced.

products_history table:

We can get the Product entity data at a given point of time as follows:

Instant someTime = ...
try (var session = sessionFactory.withOptions().asOf(someTime).open()) {
    var product = session.find(Product.class, productId);
    
}

This makes temporal queries feel like normal entity lookups while Hibernate resolves the correct historical row behind the scenes.

Hibernate offers several different strategies(NATIVE, SINGLE_TABLE, HISTORY_TABLE) for mapping temporal entities. For more info check out the Temporal data section.

Audit Tables

Previously, Hibernate-based applications typically used the separate Hibernate Envers library for auditing entity changes. Hibernate 7.4 brings audit table support into Hibernate ORM itself, so applications can use auditing features natively without adding Envers for this use case.

Audit support is enabled by adding @Audited and can be mapped to a custom table using @Audited.Table.

@Entity
@Table(name = "products")
@Audited
@Audited.Table(name="products_aud_log")
class Product {
    //fields id, code, name, price
}

When auditing is enabled, Hibernate writes one row per change into the audit table. Unlike the history table, the audit table focuses on recording what operation happened and when.

The rev values are the timestamps at which the change happened. The revtype values are represented using ModificationType enum as follows:

public enum ModificationType {
    /**
    * Creation, encoded as 0
    */
    ADD,
    /**
    * Modification, encoded as 1
    */
    MOD,
    /**
    * Deletion, encoded as 2
    */
    DEL
}

For more info check out the Audit logs section.

Summary

Most of the applications use pagination to show a list of resources, and we used to write custom logic to load paginated data along with the associated child collection. Now this is being handled at the framework level itself. Also, we used to rely on external libraries like Envers to implement auditing, which is now provided by Hibernate itself.

Hibernate 7.4 brings practical improvements that address real problems in JPA/ Hibernate-based applications. Whether we are optimizing pagination query behavior or tracking historical data, Hibernate 7.4 reduces the amount of custom infrastructure needed and provides better support out of the box without requiring additional libraries.

Go ahead and explore these new features using this GitHub repository.