IntelliJ IDEA Releases

• Markdown shell scripts now execute in the correct order.
• Undo now works correctly after applying Optimize imports on the fly.
• Dragging a terminal tab after using the Move to Editor action no longer restarts the terminal session.
• The IDE no longer throws exceptions caused by the new Resolve Conflicts mechanism for Mercurial projects.
• Java code formatting now correctly respects the Smart tabs setting.

• IDE 2026.2 EAP 8 breaks compatibility with BigData plugin.
• Disable vfs.windows.use.buffered.directory.stream in platform.

AI

• Agent skills - Skills give your agents reusable domain knowledge and instructions, making them more accurate and efficient when working with a given tech stack or topic. To help you get started quickly, IntelliJ IDEA now allows you to discover, install, and manage custom agent skills directly in the IDE. Some of the most useful skills are already bundled in the IDE and marked accordingly in the skills manager.
• Debugger - The ij-debugger skill allows the agent to use the debug run configuration, logpoints, and other suitable tools to debug issues. It uses runtime information to identify the root causes of problems, eliminating guesswork. As an open platform for AI, IntelliJ IDEA allows you to install skills not only from the built-in library, but also from local projects and directories, public GitHub repositories, or projects you have configured in other editors. Codex and Claude Code projects are currently supported.
• Support for third-party providers in AI-based code completion - AI-based code completion is an in-editor code suggestion experience that combines inline completion and next edit suggestions that go beyond the cursor. Available to all JetBrains AI users out of the box, it's powered by JetBrains-trained models and does not consume AI credits. With the latest update, you can now connect your own OpenAI-compatible model providers for AI completion.
• GitHub Copilot, natively integrated - As the result of a direct partnership between JetBrains and Microsoft, GitHub Copilot is now a natively integrated agent in IntelliJ IDEA. Expanding the previous ACP Registry setup, Copilot is available out of the box and provides a more cohesive experience.
• You can access Copilot directly from the agent picker in the AI chat. Authentication is handled through OAuth with your GitHub account, and an active GitHub Copilot subscription is required.

Productivity enhancements

• Logpoints and extended debugging experience - Every developer has used println for debugging at least once. But sometimes it is not the best approach. It can pollute the code, fail to get enough context from the print, and make identifying where it came from difficult. On top of all that, it doesn't work inside libraries. Logpoints offer a clean alternative and deliver dramatic UX and performance improvements. Built on top of non-suspending breakpoints, logpoints allow you to inspect internal application states and execution context, as well as send custom messages at runtime without modifying the source code. This approach also makes it possible to diagnose code behavior inside compiled third-party libraries. Additionally, when you run a debugger, you will always be able to navigate from the output to the place in the code that produced it - no matter whether it comes from a logpoint, a regular logger, or a simple println.
• Dependency completion - Adding a proper dependency usually requires looking up the exact library name and available versions on an external resource - but not anymore. IntelliJ IDEA 2026.2 simplifies this process with cloud-based dependency search. Just start typing the name of the library in the relevant section of a Maven or Gradle build script, and you'll have all the matching artifacts, their versions, and their recommended scopes right at your fingertips.
• Early Gradle 10 support and migration assistance - Allowing you to take advantage of the latest versions of relevant JVM technologies is one of the core commitments. JetBrains are working to ensure that IntelliJ IDEA supports Gradle 10 ahead of its release, expected in the second half of 2026. To help with early adoption and simplify migration to the new version, JetBrains has partnered with Gradle Technologies. As a result of this collaboration, IntelliJ IDEA 2026.2 can properly sync projects with Gradle 9.7 or later, even when build scripts contain errors. It also provides proper code assistance based on the new Gradle version API to help you fix those issues.

JVM and language support

• Java 27 - IntelliJ IDEA continues to provide support for the latest Java releases from day one, as well as early support for upcoming Java releases, for example, by allowing you to install early access builds directly from the IDE.
• Kotlin support: 2.4 Stable features - IntelliJ IDEA 2026.2 brings support for the latest language features in Kotlin 2.4.0, most notably explicit backing fields and explicit context parameters.
• Scala - The new release of the Scala plugin brings support for Scala 3's clause interleaving, introduces command completion for Scala code, and improves support for BSP⁠-⁠based build tools in WSL and Docker.

Spring

• Updated DB migration workflows - Flyway and Liquibase migrations are often seen as just SQL scripts, but they are actually a history of DB evolution. The main pain point is that developers often lack the context to understand this evolution. IntelliJ IDEA 2026.2 addresses this by bringing the migration context to SQL symbol resolution, displaying visual indicators that show whether schema changes have been successfully applied or failed, and allowing you to execute Flyway configurations directly from the IDE. No false-positive error highlighting, and easier to troubleshoot.
• Spring Security insights - With the Spring Debugger plugin in IntelliJ IDEA, it is now easier to verify endpoint behavior without changing your Spring Security configuration or restarting the application. You can see Spring Security inlays near Spring MVC endpoints. They show how a route is protected, allow you to inspect where the effective rule comes from, and let you navigate to the corresponding security configuration. During a debug session, you can also test an endpoint with custom user details and roles or temporarily unlock it in the running debug context.
• Streamlined Git conflict resolution flow - In large projects, merges often result in dozens of file conflicts, many of which are simple import mismatches or formatting differences. IntelliJ IDEA 2026.2 improves the conflict resolution flow, allowing you to invoke the Resolve All Simple Conflicts action, which automatically resolves standard conflicts across the entire changeset instead of opening each file one by one. You can also see a complete overview of resolved and unresolved files, reopen files at any time, and reapply conflict chunks in any order.

Docker Compose improvements

• IntelliJ IDEA 2026.2 provides deeper environmental control in Docker Compose configurations, reducing the friction of managing external dependencies and runtime container states during local development. Now, from a Docker Compose configuration file, you can see the execution status of individual containers in real time, jump to the corresponding runtime output, quickly create database connections, and use completion templates for widely used services like Kafka and PostgreSQL.

Terraform test framework support

• This release extends IntelliJ IDEA's infrastructure-as-code capabilities by introducing native support for the Terraform test framework. This integration rounds out the IDE's ecosystem support, allowing you to validate module behavior and enforce configuration policies early in the development life cycle.
• These additions help ensure your deployment configurations remain highly maintainable, predictable, and clean.

TypeScript 7 support for faster workflows with large codebases

• Large TypeScript codebases don't have to feel slow. TypeScript 7 rewrites the compiler and language server in Go, and the difference is noticeable immediately. In testing, project load time on the Kibana codebase dropped from ~12 seconds to ~3 seconds, which means editor responsiveness has improved roughly fourfold.
• IntelliJ IDEA 2026.2 supports TypeScript 7 as the default for projects already using it, with an opt-in upgrade path for those still on earlier versions. You get the full speed benefit immediately - no full project migration required on day one.
• For teams on large TypeScript monorepos, this is a day-one upgrade.

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

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

• Projects can now be opened correctly via .ipr files generated by the Gradle idea task.
• The indentation for Java ternary expressions with chained method calls has been fixed.
• Pressing the Alt+Enter key combination on Windows no longer opens the context menu unexpectedly.
• Live templates with groovyScript now work as expected again.
• Dragging and dropping selected code with the mouse onto its original position no longer causes the code to disappear.
• It is once again possible to open a diff in an external tool by double-clicking a file in the Commit tool window.
• The MCP Server no longer reports illegal character errors for projects with spaces in their paths.
• Workspaces once again function as expected.
• Several IDE freezes have been resolved.

• It's once again possible to set up a WSL Python SDK.
• Emmet in remote development now works as expected.
• Gradle sync no longer fails due to a class cast error involving InternalIdeaModule and org.gradle.tooling.model.ProjectModel.
• The IDE now correctly connects to the WildFly admin process after server startup, restoring deployment and the Open browser after launch option.
• The IDE no longer fails to locate the WSL 2 JDK.
• Double-clicking an Ant target in the Ant tool window now runs the target and shows the build output in the Messages tool window.
• Search for context actions and code completion in large Spring projects are now more responsive and faster.
• The IDE now correctly supports creating a run configuration for a local WebLogic server.
• The Find and Replace action now works as expected when pressing Enter.

AI

• In addition to Junie and Claude Agent, you can now choose more agents in the AI chat, including Codex. Also, Cursor and GitHub Copilot, along with dozens of external agents, are now supported via the Agent Client Protocol. With the new ACP Registry, you can discover available agents and install them in just one click.
• Next edit suggestions are now available without consuming the AI quota of your JetBrains AI Pro subscription. These suggestions go beyond traditional code completion for Java, Kotlin, and now Scala. Instead of updating only what's at your cursor, they intelligently apply related changes across the entire file, helping you keep your code consistent and up to date with minimal effort.

JVM language support

• Java 26 - IntelliJ IDEA continues to provide support for the latest Java releases from day one, as well as early support for upcoming Java releases, for example, by allowing you to install early access builds directly from the IDE.
• Improvements for Kotlin development with JPA - The combination of Kotlin and Jakarta Persistence is popular for server-side development, but since Jakarta Persistence was originally designed for Java, some Kotlin features - like null safety, as well as val and data class semantics - can behave unexpectedly in entities. IntelliJ IDEA 2026.1 addresses these pitfalls with more Kotlin-aware JPA support.
• Kotlin 2.3.20 support - IntelliJ IDEA 2026.1 has improved support for the latest language features in Kotlin 2.3.0, as well as those in 2.3.20. The new versions promote nested type aliases and data-flow exhaustiveness checks for when expressions to stable, and also bring several experimental features that you can already try in IntelliJ IDEA:
  • Name-based destructuring destructures by property name rather than position, so changing the order of properties doesn't break the code (version 2.3.20).
  • Explicit backing fields cut boilerplate when you want a property that's writable internally but read-only to callers (version 2.3.0).
  • The unused return value checker warns you when you call something that returns a meaningful result and that result is silently ignored, helping you catch bugs (version 2.3.0).
• Scala - This release brings full Scaladoc support for Scala 3, which means you can now use modern Markdown syntax directly in your doc comments. Additionally, working with sbt projects inside WSL and Docker containers is now as smooth as working in local projects.

Spring

• Runtime insight for Spring applications
  • Spring Debugger now allows you to see the state of your Spring application directly in your code, without pausing its execution. This means no more guessing and no more jumping to the project tree to understand wiring, profile configuration, and the environment. You can detect wrong bean injections, test secured endpoints, and review the application configuration in the running code, saving you time and money on static code analysis.
  • Injected beans in code: See the exact bean class that is injected into your Spring component - the bean's definition, related beans, and navigation to the bean definition class or factory method are now just one-click away.
  • Endpoint security inlays [coming 2026.1.X]: See how each Spring MVC endpoint is secured and which rules are in effect and where they come from, view the current user context, and temporarily unlock an endpoint while debugging to verify behavior without editing the configuration - right from the HTTP Client.
  • Actual property values [coming 2026.1.X]: View the actual property value used at runtime in the @Value annotation, so you can spot overrides from the environment, run config, or config server faster.

Sources and documentation for dependencies out of the box

• Starting with 2026.1, sources for all your dependencies are automatically downloaded in a non-intrusive manner. Now, you have the full context needed to inspect, debug, and navigate dependency code with ease.

C/C++ support in IntelliJ IDEA

• When working with Java, you sometimes need to benefit from the performance of C++ in individual cases, like optimized microservices or native libraries. New C++ plugins for IntelliJ IDEA allow you to stay in your flow without switching tools. The C/C++ Language Support plugin provides first-class coding assistance for modern C and C++ development in IntelliJ IDEA. It equips you with advanced code insight, real-time quality checks, and powerful refactorings to ensure your native code is as maintainable and high-quality as your JVM projects. To enable this support, simply install the CLion plugin. This serves as the core infrastructure, connecting your projects to essential toolchains, debuggers, build systems such as CMake and Meson, the compilation database, vcpkg, and test framework plugins.

Productivity-enhancing features

• Expanded Java and Kotlin support for command completion
  • New AI-powered actions are available via command completion. You can quickly ask the IDE to explain code, generate documentation, or make code changes directly through an integrated prompt dialog - all in context, without leaving the editor.
  • All postfix templates can now be discovered and invoked via .., making it easier to use both mechanisms together in a single, consistent flow.
  • Command completion is now also available in configuration .properties files. This improves productivity in framework-based projects where configuration and code are closely connected.
• Gradle best practices for humans and agents
  • Gradle offers multiple ways to configure builds, and not all of them are optimal. This might lead to confusion both for developers and AI agents. To provide guidance, JetBrains joined forces with Gradle and Google to create a set of official best practices, covering the complex options for users and helping AI agents improve as well. New practices are authored regularly, and over 30 have already been published. To make this resource even more accessible, IntelliJ IDEA 2026.1 brings the first batch directly to your fingertips as inspections and quick-fixes, with more to come.
• Editor caret and selection updates
  • Smooth caret animation and updated selection behavior provide improved comfort, a cleaner look, and a more enjoyable coding experience. Read more.
  • Ability to work on multiple branches at once with Git worktrees - With the evolution of AI agents, running multiple tasks in parallel has become a major time-saver, and this is precisely where Git worktrees are extremely handy. To support cutting-edge workflows for AI-boosted software development, IntelliJ IDEA now provides first-class support for Git worktrees. Create a separate worktree for an urgent hotfix, hand off another one to an AI agent, and keep working in your main branch - all at the same time, without interruption. Even if you don't use agents, worktrees will save you time on branch switching, especially in big projects.
• Native Wayland support
  • IntelliJ-based IDEs now run natively on Wayland by default. This transition provides Linux professionals with ultimate comfort through sharper HiDPI and better input handling, and it paves the way for future enhancements like Vulkan support. The IDE will automatically fall back to X11 in unsupported environments to keep your workflow uninterrupted.
• In-terminal completion
  • Stop memorizing commands. Start discovering them. In-terminal completion helps you instantly explore available subcommands and parameters as you type. Whether you're working with complex CLI tools like Git, Docker, or kubectl or using your own custom scripts, this feature intelligently suggests valid options in real time. Previously introduced for Bash and Zsh shells, it is now also available in PowerShell.
• Ability to work with projects from Dev Containers as with local ones
  • Modern software development increasingly relies on Dev Containers for defining consistent, professional-grade environments. While IntelliJ IDEA has long supported these via Remote Development mode, a more streamlined approach is now available to keep you in the flow.
  • Starting with IntelliJ IDEA 2026.1, you can open projects from a Dev Container natively in your local IDE. Unlike previous methods that required a full IDE backend inside the Dev Container, this new agent-based architecture provides a high-performance connection to the file system without draining system resources. This reduces cognitive load and setup time, ensuring you stay focused on your most important tasks.
• Databases
  • The AI chat integration for Codex and Claude Agent now offers full, native support for your connected databases. With that, you can now query, analyze, and modify your database state using natural language right from the IDE. The same functionality is available for external agents via an MCP server.
  • Data source settings can now be stored in your JetBrains Account via data source templates. Especially helpful for All Products Pack users or anyone who uses multiple instances of JetBrains IDEs, this upgrade allows you to access data source templates and settings in every JetBrains IDE with database functionality.
• Support for Terraform Stacks
  • You can now manage your Terraform infrastructure with more clarity and control by working with Terraform Stacks directly in the IDE. Benefit from code completion, get a better understanding of the structure, create new components and deployments, and jump between them with ease. Stay oriented in complex infrastructure setups.
  • Streamlined Kubernetes experience - Working with Kubernetes in IntelliJ IDEA is now more straightforward than ever before. A new dedicated welcome screen guides you to get the most out of your cluster workflow. You can study features, connect to clusters, select context with ease, apply configs, view the resource tree, examine logs, and debug - all without leaving your IDE.

JavaScript and TypeScript

• Experience a smoother, more reliable workflow with TypeScript support now running on the service-powered type engine by default. Optimized for professional-grade development, this update delivers more accurate type inference and significantly lower CPU usage, even in large-scale enterprise projects. The TypeScript support is further improved with better auto-import handling for path aliases and project references, as well as the integration of inlay hints from the Go-based TypeScript language server. JavaScript parsing now also correctly handles string-literal import / export specifiers.
• The IDE now highlights React's new use memo and use no memo directives.
• The Vue integration uses the updated 3.1.8 version of vue/typescript-plugin.
• Astro settings accept JSON-based configuration for language server integration.
• Angular 21.x template syntax is supported.
• Support for JavaScript and TypeScript without an Ultimate subscription - In version 2026.1, IntelliJ IDEA provides support for JavaScript without requiring an Ultimate subscription, though you will still need one to use advanced productivity features for JavaScript.

• Added full support for Java 26.

• Resolved an issue where running an HTTP request could trigger a different request in the same file.
• Local changes refresh in large Perforce projects now works as expected.
• The Dependencies tab now opens correctly when using the Analyze Cyclic Dependencies feature.

• MCP server output schema now correctly handles default properties in the schema, preventing invalid schema errors during structured output.
• Downloading the IDE backend now works as intended with a configured proxy.
• Resolved an issue that prevented successful proxy authentication.
• Package annotations referenced through JAR dependencies are now correctly reflected in the PSI model.

• The Terminal tool window no longer flickers when you use CLI tools with synchronized output, such as Claude Code.
• Several issues related to credential storage and settings synchronization in remote development have been resolved.
• Run configuration handling in the Services tool window has received multiple improvements.

• Build. Maven
  • Memory leak at MavenProjectsTree.
  • IDEA 2025.3.1 freezes when opening big Maven project (at org.jetbrains.idea.maven.project.MavenProject$Companion.read).
  • High memory usage and freezing opening large Maven projects in 2025.2.6+ (at MavenProjectsManager#initProjectsTree).
• Core. Eel
  • WSL project settings are reset once after updating from 2025.3 or earlier versions.
• Core. WSL
  • WSL2 project settings are reset after restart.