JetBrains All Products Pack Releases

• Jupyter notebook skill for AI agents - Let AI agents such as Claude Code and Codex create, edit, and run .ipynb notebooks via PyCharm’s notebook model and a live kernel, so variables, models, and data persist across cells instead of disappearing when the agent shells out. For you, this means more reliable notebook and ML work - with fewer tokens used. To start, just open the AI chat and ask the agent to work in your notebook.
• Agent environment coordinator - Tired of AI agents installing packages into the wrong Python environment? This new skill gives the agent your project’s configured interpreter and tool - uv, Poetry, pip in a venv, or conda - so commands target the right environment, not a system one. If none exists, it can set one up via PyCharm, and the agent decides how to use the information. To start, ask the agent to run or install something in your project.
• marimo notebooks in PyCharm [third-party plugin] - You can now open, edit, and run marimo notebooks directly in PyCharm with the new plugin developed by the marimo team. Work with reactive cells and interactive UI elements in a dedicated notebook without leaving your IDE. Because marimo notebooks are stored as Python files, they are Git-friendly, executable as scripts, and easy to integrate into your existing Python projects.
• Changes to bundled plugins in 2026.2 - As part of ongoing maintenance, JetBrains are unbundling and deprecating low-usage plugins, including Data Wrangler, Hugging Face, and Google Colab support. You can continue to install compatible versions from JetBrains Marketplace, but these plugins are no longer bundled or actively maintained by the PyCharm team.
• Redesigned Python Packages tool window
  • Packages now appear in a collapsible tree alongside their dependencies so you can see what’s installed and why - with new icons, right-aligned versions, and inline Install/Update links.
  • A new floating search popup (think “Search Everywhere” but for packages) makes finding and installing fast. It also shows you which environment will be used and lets you pick a module and dependency group.
  • You can install a package into specific uv/Poetry dependency groups like dev or test per workspace member, change versions inline or through the new Change Version dialog, and install from VCS via Custom Installation.
  • Package repositories can be enabled or disabled, with state remembered across sessions. In addition, unreachable URLs show a clear error, and Remote Development support is substantially improved.
• Clearer type checking
  • Richer type-mismatch errors, now with a breakdown of why the types don’t match.
  • A type diff for callables and other composite types, so both sides read the same way.
  • Fully rendered names and types in inspection tooltips, with clickable links.

• Virtual environments for end-of-life Python: PyCharm no longer creates venvs for Python 2.7, 3.6, and 3.7. You can still create a new env from a command line and add it to the IDE manually.
• SQLAlchemy 2.0 Session.get() inference: Session.get(Entity, id) (and SQLModel) is now inferred as a model instance rather than the class.

• Ruby. Code Insight
  • [Model v2] Highlighting of paramdef references in a single string literal do not refresh properly.
• Ruby. Debugger
  • Debugger skips breakpoints when project path contains non-ASCII (non-English) characters.
  • Ignore non-project files: Connected is shown during stepping.
• Ruby. Inspections
  • Incorrect "Method definition with parameters has no parentheses " when there is a comment on the first line.
• Ruby. Parsing
  • Project analyzing doesn't finish, stalls for minutes on large RSpec files with deeply recursive COMMAND.parse / PAREN_ARGS / PRIMARY in the Ruby parser.
• Ruby. Refactorings
  • In place rename with the Symbol API does not restore the document content for prefixes from the live template.

• 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.

• PHP
  • Find usages shows inconsistent results.
• PHP Refactorings: Rename
  • Error with '#[FileReference]' support for anonymous functions.
  • Rename refactoring unavailable in context menu for FileReference file.
• PHP Templates
  • Smarty Filetype and Syntax Highlighting missing.
• PHP Test
  • Codeception tests fail with Serialization of 'Closure' is not allowed.
  • Coverage directory wrong for docker interpreter.

• IDE
• Go SDK notification: changed wording.
• Inspections
• Add Go fix to the pre-commit check.
• Cosmetics
• Go Fix - Small visual 'underlying' of Go Fix suggestion.
• No preview is available for the fixed issue.
• Profilers
• Escape Analysis Tool compilation fails if contains <autogenerated> entries on Windows/WSL2.
• No subsystem
• Go fixes with no quick fixes show no preview.

• Code insight stops working: IllegalStateException "Can't find definition for macro CfgDisabled".
• Cannot resolve vulkano crate's include macro when using vulkano from gitSelecting. An excluded member in the Attach Project dialog deselects the root project.

• You can now specify environment variables to GDB Remote Debug.
• You can now configure the debugger on per run configuration basis and you have a list of available debugger configurations.
• Added a "Working Directory" option for the debugger.
• Added support for multiple profiles for West project like CMake support provides.
• Added Remdev skills for writing/refactoring code for split mode.
• A breakdown is now explained/shown when type mismatch is reported.
• You can now solve a parameter type from generic decorator type.
• A "type diff" is now shown in the error for callables and other types with components.
• Added support for authentication and authorization with OIDC/OAuth 2.0 for MongoDB.
• Figma Connect: Added the ability to set up a Figma skill.
• Figma Layers panel: Added the ability to drag a node to the terminal which then inserts its node id.
• Added a "Restart Tailwind CSS Service" action to "Search Everywhere".
• TypeScript GO: You can now use getSignatureHelp to provide parameter info.

• Figma Connect: Added the ability to set up a Figma skill.
• Figma Layers panel: Added the ability to drag a node to the terminal which then inserts its node id.
• Added a "Restart Tailwind CSS Service" action to "Search Everywhere".
• TypeScript GO: You can now use getSignatureHelp to provide parameter info.
• Added Remdev skills for writing/refactoring code for split mode.

• Disabling 'Show the Welcome screen in non-modal mode' has no effect in DataGrip.

• Gameplay Tag in Blueprints usage counter in Code Vision breaks after referencing this tag in more places.
• UE_DECLARE_GAMEPLAY_TAG/UE_DEFINE_GAMEPLAY_TAG_COMMENT usage is not counted.
• Debugger stepping and Watches/Threads refresh take seconds after upgrade to 2026.2.
• Updating multiple NuGet packages via new UI Update button fails: NullReferenceException.
• Fixed RiderLink compatibility with UE <= 5.5.
• .NET Framework + NRT: "Return type can be made non-nullable" warning.
• IDE 2026.2 EAP 8 breaks compatibility with BigData plugin.
• Disabled vfs.windows.use.buffered.directory.stream in platform

• Switching to Database Explorer by Cmd+1/Alt+1 doesn't focus on the Tree.
• The Search path drop-down doesn't expand.
• Quick Documentation shows nothing for built-in SQL functions.

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

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

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

Preview of ACP agent support in ReSharper starts with Junie

• JetBrains is building an ecosystem where .NET developers control their AI experience in Visual Studio - no vendor lock-in, no forced choices, just the freedom to use the agents and models that work best for you. The goal is to let you connect agents through the Agent Client Protocol (ACP) and pair them with JetBrains' deep code intelligence without being locked into a single vendor.
• ReSharper 2026.2 takes the first step in that direction with preview support for Junie, JetBrains' own LLM-agnostic agent, now available via ACP in Microsoft Visual Studio. You can switch from AI Chat to Agent mode in the AI Assistant tool window and ask Junie to generate and edit code, refactor complex implementations, run terminal commands, manage Git workflows, explain legacy code, and suggest architectural improvements.
• To bring Junie to Visual Studio, be sure to select the AI Assistant plugin for installation when updating ReSharper. A free trial is available if you don't have a JetBrains AI subscription yet.
• Regional restrictions on the availability of AI features in Mainland China apply.

Debugging for VS Code-compatible editors

• The most requested feature for ReSharper in VS Code is here. The latest update introduces the initial version of debugging for VS Code-compatible editors, including VS Code, Cursor, Google Antigravity, Devin Desktop, and Kiro. Built on the same core engine that powers JetBrains Rider, it brings breakpoint management (including conditional, hit-count, dependent, and tracepoints), real-time variable and expression inspection, full step navigation, and launch-and-attach support directly to your editor.
• This makes ReSharper the most complete .NET option available on Cursor, Antigravity, Devin Desktop, and Kiro, as well as other VS Code-compatible editors.

Code analysis and refactoring

• C# support updates - ReSharper 2026.2 improves its C# code analysis with more cases where collection expressions can be used. The new inspections help you keep code concise and, in some scenarios, avoid creating intermediate collections. Support for upcoming C# 15 language features is also being actively developed as the compiler evolves, with complete language understanding planned for the next major release.
• Enhanced Extract Method refactoring - Extract Method now detects exact and parameterized duplicates of the selected code within a file and lets you choose which occurrences to replace as part of the refactoring. This makes it easier to consolidate repeated logic into a single, well-named method without cleaning up each duplicate manually.
• '.editorconfig' and Roslyn analyzer integration - You can now adjust .editorconfig settings for compiler warnings directly from the Alt+Enter menu as warnings appear in the editor. ReSharper's code analysis also follows Roslyn analyzer configuration more accurately, including settings defined in .editorconfig files and suppression rules applied with #pragma directives.
• Enhanced Import missing references popup experience - The Import missing references popup has been revamped for a smoother experience. JetBrains have optimized its placement, got rid of flickering, and ensured it stays out of the way while you type, so it no longer interrupts your workflow.

C++ updates

• C⁠+⁠+⁠26 reflection: Initial support for C⁠+⁠+⁠26 reflection, laying the groundwork for next-generation compile-time metaprogramming.
• 'constexpr' evaluation updates: Support for memory allocations and exceptions during evaluation of compile-time code.
• ISPC support: Syntax highlighting, code analysis, and navigation for files using the ISPC language.
• Code analysis: New inspections for applying internal linkage, using designated initializers in aggregate initialization, and detecting qualified calls to overridden virtual functions.

Performance

• Processing of .cshtml and .razor files is now faster and more memory-efficient, thanks to cached parsed syntax trees, improving the performance of features such as Find Usages and refactorings. Memory allocations have been significantly reduced in multiple areas, speeding up indexing during startup.

Improved tool support in Out-of-Process mode

• dotTrace, dotMemory, and the Monitoring tool now work when ReSharper runs in Out-of-Process mode.
• With Monitoring available in OOP mode, the transition announced in the previous release is complete: Dynamic Program Analysis (DPA) has been retired in 2026.2, and its core capabilities continue through the new Monitoring experience.

ReSharper now includes integrated profiling and coverage tools

• Starting with ReSharper 2026.2, the tools for performance and memory profiling, and code coverage are installed automatically as part of your ReSharper installation. There's nothing extra to select or download; the tools are set up for you and ready to use inside Visual Studio from the moment you install. You can profile performance, track memory, and check coverage without ever leaving your workflow.

Updated dotUltimate offline installer for Windows

• The dotUltimate offline installer for Windows is intended for administrators who deploy ReSharper and other dotUltimate tools across teams, managed environments, or machines with limited internet access. In 2026.2, this offline installer is distributed as a .ZIP archive instead of a standalone .EXE file. The lightweight online installer remains available for users who do not need the offline package.
• After downloading the offline package, extract the archive and run the included dotUltimate installer. The .ZIP archive contains two files: the dotUltimate installer executable and a companion .dat file. The installer executable contains the product binaries except Rider; Rider binaries are stored in the .dat file. The installation flow and supported scenarios remain the same, but deployment scripts or internal instructions may need to include the extraction step and keep both files together before running the installer.

C++ support

• C⁠+⁠+⁠26 reflection - ReSharper C⁠+⁠+ 2026.2 introduces initial support for C⁠+⁠+⁠26 reflection. Reflection is widely considered one of the most transformative features coming to C⁠+⁠+, enabling compile-time introspection and code generation. With this update, ReSharper C⁠+⁠+ recognizes the core reflection primitives:
  • The ^^ (reflect) operator, which produces a std::meta::info value representing the reflected entity.
  • The [: ... :] (splice) syntax, which converts a reflection value back into a language construct.
  • Compile-time queries on reflected types, members, enumerators, and other entities.
  • Note: Of the major C⁠+⁠+ compilers, currently only GCC 16 supports C⁠+⁠+⁠26 reflection.
• Related C⁠+⁠+26 features - Support for reflection is complemented by two related C⁠+⁠+26 language features:
  • ReSharper C⁠+⁠+ now supports consteval { ... } blocks, which are evaluated at compile time and can inject declarations into the enclosing scope. consteval blocks provide a clean way to trigger compile-time side effects, making them particularly useful for practical metaprogramming with reflection.
  • User-defined annotations can now be attached to declarations and queried through the reflection API, enabling custom metadata-driven code generation.
• 'constexpr' evaluation - ReSharper C⁠+⁠+ 2026.2 extends its constexpr evaluator with two important capabilities:
  • The evaluator now supports dynamic memory allocation during constant evaluation - a feature introduced in C⁠+⁠+20. This enables correct evaluation of constexpr code that uses new/delete or standard containers like std::vector and std::string.
  • The evaluator now supports C⁠+⁠+26 constexpr exceptions and handles try/catch and throw expressions during constant evaluation.

ISPC language support

• ReSharper C⁠+⁠+ 2026.2 adds support for ISPC (Intel SPMD Program Compiler), a language designed for high-performance parallel programming on CPUs. ISPC is widely used in game engines, rendering systems, and scientific computing, including Unreal Engine projects.
• ReSharper C⁠+⁠+ now provides syntax highlighting, code analysis, navigation, and coding assistance for ISPC files, bringing the same quality of editor support you expect for C⁠+⁠+ to your ISPC code.

Unreal Engine

• Performance - This release brings major performance improvements during startup in Unreal Engine projects. ReSharper C⁠+⁠+ now uses the project information from UnrealBuildTool to speed up initial indexing by analyzing only files included in the Unreal Engine project model. Combined with other optimizations, including improvements in multithreaded indexing, this results in a significant speedup. According to the measurements on the Lyra sample solution, initial indexing of C⁠+⁠+ code is up to 55% faster, and loading C⁠+⁠+ caches from serialized data during a warm IDE startup is up to 35% faster. You can disable the new indexing behavior by unchecking the Index only files in Unreal Engine project model option on the Code Editing | C/C⁠+⁠+ | Unreal Engine settings page.
• Blueprint support - ReSharper C⁠+⁠+ now also discovers usages of gameplay tags inside Blueprint assets and shows them in Code Vision and Find usages results, giving you a complete picture of where your gameplay tags are used across the project.

Code analysis

• Internal linkage - The new Entity can have internal linkage inspection detects functions, variables, and classes that are not used outside their translation unit. You can use the provided fixes to mark such entities static or move them into an anonymous namespace, which helps the compiler optimize and prevents unintended linkage conflicts.
• Designated initializers in aggregate initialization - ReSharper C⁠+⁠+ now suggests adding designators to braced initializer lists in aggregate initialization. Designated initializers, available since C⁠+⁠+⁠20 and C99, make it explicit which member each initializer corresponds to, improving code readability and reducing the chance of errors when members are reordered. A corresponding context action is also available and can be used even when the inspection is disabled.
• Calls to overridden base functions - Another new inspection detects qualified calls to base virtual functions that are overridden in a derived class. Calling a base-class virtual function directly rather than through virtual dispatch can be a source of subtle bugs, and this inspection helps catch such cases.
• [[jetbrains::used_implicitly]] attribute - ReSharper C⁠+⁠+ now recognizes the [[jetbrains::used_implicitly]] attribute, which can be applied to symbols to suppress inspections that would otherwise suggest changing their signature or linkage. This is useful for symbols that are used through reflection, code generation, or other mechanisms not visible to static analysis.

Coding assistance

• Refactoring improvements
  • Invoking Inline Function on a function declaration now inlines all usages of the function throughout the codebase, not just the usage under the cursor.
  • The Extract Method refactoring is now available inside lambda bodies, letting you factor out parts of a lambda into a separate function.
• Context actions
  • A new context action lets you easily toggle the const qualifier on a member function.
  • You can now quickly insert a #pragma clang diagnostic ignored directive to suppress a specific Clang diagnostic on the current line.
  • In Unreal Engine projects, you can now copy the include path for the currently opened header file from the Copy Code Reference menu, making it easy to paste the correct #include directive.

AI integrations

• GitHub Copilot now built into Rider - GitHub Copilot is now a natively integrated agent in JetBrains IDEs, as the result of a direct partnership between JetBrains and Microsoft. Unlike 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.
• AI completion now supports third-party providers - AI completion is an in-editor code suggestion experience that combines inline completion and edits that go beyond the cursor. Available to all JetBrains AI users out of the box, it's powered by JetBrains-trained models, without spending AI credits. With the recent update, you can now connect your own AI completion model, configured independently from your agent provider. Supported providers include OpenAI-compatible endpoints, such as LM Studio or llama.cpp with models like Zeta or SweepAI, and Mercury by Inception Labs.

Agent skills

• Rider 2026.2 deepens what your AI agents know about your stack. Bundled skills ship with the IDE as built-in workflows, helping agents handle specific tasks without working out every step themselves. Other skills you add through the agent skills manager, so you stay in control of what your agents can do. Both give agents reusable, IDE-grade knowledge for more relevant suggestions and more reliable results.
• Support for .NET Agent Skills - Rider now makes it easy to discover and install official Microsoft Agent Skills directly from the IDE. In 2026.2, Rider includes three Microsoft-maintained skill repositories:
  • .NET Skills for common .NET and C# development tasks.
  • Aspire Skills for cloud-native application development with .NET Aspire.
  • Azure Skills for working with Azure services and infrastructure.
• Code quality check hooks for Claude Code - Rider now ships quality-check hooks for Claude Code in any language supported by Rider. Enable the skill in the Settings, and Rider will validate every change an agent makes before it's allowed to continue, catching code issues, inspection findings, and even formatting inconsistencies. Errors will block the task from being marked complete, while warnings come back as feedback the agent can act on. You and your IDE set the quality bar, not the agent.
• Safer refactoring skills - Agents can now drive Rider's refactoring engine for renaming symbols, moving types, extracting methods, and reorganizing namespaces, working from Rider's understanding of symbols and usages instead of brittle text search. Broad changes become safer to make and easier to review.
• Game-aware skills for Unreal Engine - Rider 2026.2 adds three Unreal Engine skills to the agent skills manager, so your agent approaches Unreal projects as Unreal projects, not just large C++ codebases:
  • ue-code-authoring handles UE C++ changes. The agent inspects existing project patterns, edits your .h and .cpp files, and uses Rider's diagnostics, linting, build checks, and formatting to catch Unreal-specific traps around reflection macros, generated headers, module dependencies, includes, API macros, and UObject conventions.
  • ue-live-debugging tackles crashes and runtime issues, using Rider's symbol search, call hierarchy, breakpoints, stack and frame inspection, and expression evaluation to investigate what actually happened.
  • ue-test-authoring picks the right testing approach, whether Automation, CQTest, Functional, Gauntlet, or LowLevel, and writes tests that follow your project's conventions.

Performance

• Starting up and launching the debugger - Rider 2026.2 makes the early moments of a session quicker on Windows, from opening a solution to hitting the debugger for the first time. JetBrains have optimized how Rider enumerates project files at startup, so the IDE discovers directories and filesystem changes faster. Project model updates become available sooner, and opening large solutions feels smoother. Launching the debugger is quicker, too. In the benchmarks, Rider cuts about 2.8 seconds from debugger launch time for .NET applications on Windows. The difference is especially noticeable in smaller projects, where app startup should feel nearly immediate.
• Switching branches and recovering from big file changes - Once you're working on a project, the slowest moments tend to come when a lot changes at once, such as switching Git branches. Rider 2026.2 improves these in two independent ways. First, branch switching itself is considerably faster thanks to improvements in Rider's Roslyn integration. In tests, it's generally 2-3x faster, with one previously problematic case improving from 8 minutes down to 5 seconds. Second, whenever Rider has a lot of files to take stock of at once, whether after a branch switch or when opening a large project for the first time, it needs to see what's on disk before its project view, search, and navigation are fully reliable again. JetBrains have made file discovery faster, so you spend less time waiting for Rider to sync up. In internal testing on a large solution of around 300 projects, simulating a Git branch switch, this step ran roughly a third faster. File discovery is just one part of the catch-up process, so how much you feel it depends on the workflow. You're most likely to notice it on projects with deeply nested folder structures.
• Lower memory use on the backend - Rider's backend now holds onto less memory, freeing it up for the rest of your work. In internal tests, backend processes used around 7%-8% less, with the relief most noticeable on larger solutions where memory pressure is highest.
• Performance enhancement for Unreal Engine - If you open an Unreal Engine project using the generated .sln, you will see much faster initial indexing times, in line with opening the project through .uproject. In this scenario, Rider now uses the project information from UnrealBuildTool to speed up initial indexing by analyzing only files included in the Unreal Engine project model. Initial indexing of C++ code is twice as fast in 2026.2 compared to 2026.1 when opening the .sln from the Lyra sample solution, with a similar speedup when loading C++ caches from serialized data during a warm IDE startup.

UX/UI

• The ability to preview suggested code changes - Rider now gives you a clearer way to evaluate quick-fixes and context actions before applying them. The new intention previews show what the selected action will change directly from the code actions menu, helping you understand the result at a glance and choose the right fix with more confidence. The preview supports diff-based output with syntax and identifier highlighting, so you can quickly compare the before and after states without interrupting your flow. This is especially helpful for broader changes, including fixes that affect multiple files, where seeing the exact impact upfront makes code actions feel safer and easier to trust.
• Improved NuGet tool window - Rider's NuGet tool window has been redesigned to make dependency management clearer in larger solutions. Browsing for new packages, scrolling and loading them, managing installed dependencies, and reviewing available updates now have separate, more focused paths, so it's easier to see what needs attention and update packages when you're ready.

.NET development

• File-based C# app templates - Rider 2026.2 adds a dedicated C# file-based app template, making it easier to create, edit, and run file-based C# apps directly from the IDE. It's a lightweight workflow for scripts, repo utilities, CI helpers, and quick tasks that don't need a full project setup.
• Hot Reload for WPF projects - Rider 2026.2 introduces WPF Hot Reload, letting you edit XAML while your WPF app is running under the Rider debugger and see saved changes applied in place. You can tweak layouts, styles, templates, and resources without rebuilding, restarting, or navigating back to the same screen.

Code analysis and refactoring

• C# support - Rider's C# code intelligence is powered by ReSharper. Rider 2026.2 includes the latest ReSharper updates for .NET code analysis, refactoring, analyzer configuration, and language support. For the full breakdown, see the What's New in ReSharper 2026.2 page.
• C++ support - Rider 2026.2 introduces initial support for C++26 reflection, the most anticipated addition to the C++ language in recent years. The reflect operator (^^), splicing ([: ... :]), and consteval blocks are now recognized by the editor, providing syntax highlighting, code analysis, and coding assistance for reflection-based metaprogramming. Additionally, Rider extends its constexpr evaluator with support for dynamic memory allocations and exceptions during constant evaluation. Other updates to C++ support include new code inspections and refactoring enhancements. Rider's C++ intelligence is powered by JetBrains ReSharper C++.
• F# support - Rider 2026.2 brings several F# improvements. A new action lets you quickly disable and restore compiler warnings; importing types and other symbols from errors is more reliable; C# 14 interop is smoother; and F# debugging has received additional fixes.

Game development

• Performance breakthroughs: Large Unreal Engine projects should open and become ready to work with faster. Opening a generated .sln now benefits from the UnrealBuildTool project model, with C++ indexing running roughly twice as fast in the benchmarks. See the Performance section.
• Game-aware AI agent skills: Code quality hooks can validate agent-generated changes in game projects, while Unreal Engine-specific skills help agents with UE C++ code authoring, live debugging, and test authoring. See the Agent skills section.
• First-class debugging: Natvis support arrives on Linux and macOS, so inspecting native data structures works consistently across platforms, alongside expression evaluator enhancements. See the Debugging section.
• Better navigation for UInterface - Tracking Unreal Engine UInterface implementations is now more direct. Usage information is shown for the I-prefixed implementation interface, where Unreal interface functions are declared and implemented by gameplay classes. Find Usages also now includes Blueprint usages for Unreal interfaces, not just C++ references, making it easier to track where an interface is used across code and assets.
• Find Unreal Engine Gameplay Tag usages in Blueprints - Gameplay Tags are easier to follow across both C++ and Blueprints. Usages inside Blueprint assets now appear in Code Vision and Find Usages results, so you can see where a tag is used across the project without leaving Rider. This is especially useful for projects built around the Gameplay Ability System, where tags often drive ability activation, blocking, cancellation, effects, and gameplay events. Rider detects tag usages in key Gameplay Ability System Blueprint nodes and GameplayAbility asset properties, and now shows Code Vision for both Gameplay Tag declarations and definitions in C++.
• ISPC support - High-performance CPU code gets first-class editor support with ISPC (Intel SPMD Program Compiler), a language used in game engines, rendering systems, and scientific computing, including Unreal Engine projects. ISPC files now get syntax highlighting, code analysis, navigation, and coding assistance, bringing the same quality of editor support you expect for C++ to your ISPC code.
• Professional Godot support - Godot development in Rider feels more complete, polished, and reliable in 2026.2. The release adds new project templates, better GDScript support and formatting, improvements for working with scenes, and many fixes based on direct feedback from the Godot community.
• New configurable GDScript formatter - Keeping GDScript code consistent is now easier with one of the most capable and configurable GDScript formatters available today. Built directly into the IDE, it handles spacing, indentation, wrapping, tabs, and common GDScript layout rules, with language-specific code style settings available in Rider's standard settings UI. Unlike many external formatters, Rider lets you reformat exactly what you need: a selected fragment, a single file, or the whole project. The formatter also powers smarter editing behavior as you type, including indentation on Enter, smart outdent after control-flow statements, and splitting long string literals across lines. The result is a native GDScript formatting experience that feels consistent, flexible, and ready for real Godot projects.
• Drag Godot scene nodes into code - Referencing Godot scene nodes from GDScript takes less manual wiring. Drag nodes from the Scene Preview tree directly into the editor, and Rider will insert the right node path or variable declaration for you. The behavior follows Godot Editor conventions: drag a node normally to insert its path, hold Ctrl to generate an @onready variable, or hold Alt to generate an @export variable. Multi-selection is supported too, including nested nodes, with paths resolved relative to the script you are editing.
• JetBrains Rider Integration add-on on the Godot Asset Store - The official JetBrains Rider Integration add-on is now available on the brand-new Godot Asset Store. It simplifies setting up Rider as an external editor for Godot projects, giving you direct access to Rider's code insight, navigation, inspections, and debugging support while working on Godot games and add-ons.
• Support for Godot Autoloads and UID references - Godot project-wide APIs and resources are easier to navigate from GDScript. Autoloads and uid:// resource references are now resolved more accurately, with proper highlighting, documentation, and navigation for globals configured in the Godot project settings, so singleton-style project APIs feel like first-class symbols in the editor. Rider also resolves uid:// references in load and preload calls, making resource links created by Godot work more naturally in code insight and navigation.
• Project templates for game development - Getting started with a new game project is now easier in Rider. The New Project dialog features a dedicated Game Development category that brings game-engine-specific templates directly into the IDE. Godot projects and add-ons now have ready-made starting points in the IDE, including templates for Godot Asset Store add-ons such as script-based assets, editor plugins, and native C++ GDExtensions. Each template comes with a preconfigured project structure, build settings, and run configurations, helping you get up and running faster. JetBrains have also added a new CMake game project template for native game development workflows, laying the foundation for a growing collection of game development project templates in future releases.
• CMake support is now out of Beta - Native game development workflows get a more complete CMake experience now that Rider's CMake support is out of Beta. CMake projects benefit from fixes across the workflow and convenient gutter actions for running and debugging targets directly from the editor. JetBrains have also added support for project files that are not explicitly listed in CMakeLists.txt, helping Rider understand more of the code that belongs to your project. Because enabling this for very large projects can increase indexing scope and affect performance, the option is turned off by default and can be enabled manually in settings.

Debugging

• Improved source generator debugging - Debugging source generators should now work more reliably with newer SDKs on Linux and macOS. Starting a debugging session no longer requires a successful build of the target project, and target project files are no longer compiled before startup, which should make the workflow faster.
• Basic Natvis support on Linux and macOS - Rider 2026.2 brings basic Natvis type visualization to the C++ debugger on Linux and macOS, expanding its availability beyond Windows. Existing Natvis files, including visualizers that ship with popular C++ libraries, can now be used with LLDB on Linux and macOS systems. This also improves Godot C++ debugging: Rider now supports the godot-cpp.natvis, making Natvis the recommended visualization path for Godot types in Rider across supported platforms. If you previously registered GodotFormatter manually in .lldbinit, remove that registration and use the Natvis visualizers instead.
• Improved C++ expression evaluation on Windows - Rider 2026.2 improves C++ expression evaluation when debugging on Windows. The update makes more expressions work reliably with watches, conditional breakpoints, and Evaluate Expression operations, including function calls (with parameters) from Natvis visualizers and a number of fixes around comparisons, persistent variables, intrinsics, and function calls. One practical improvement is smoother string comparison during debugging. Unreal Engine string types such as FString and FName, as well as standard library string types, now handle common comparison scenarios (e.g. myFString == "Hello"), including comparisons in conditional breakpoints.
• Debugger stepping improvements - Stepping is more predictable in Rider 2026.2. Step Into now lands where you expect, instead of dropping you into runtime or standard-library code, and clearer highlight ranges make it easier to pick which method to step into. When a statement has several method calls, already-visited ones stay highlighted as you step out, so you can always see where you are in the statement. Return values shown after stepping over or out are cleaner and more accurate, and debugger hints now keep a stable, consistent order instead of reshuffling on each step, so the ones you care about no longer get pushed off the right edge of the screen.

Cloud-based development

• Built-in Azure Functions support - Azure Functions support for local development is moving from the separate Azure Toolkit plugin directly into Rider. You can now work with Azure Functions projects without installing any additional plugins, including creating projects and triggers, running and debugging functions, using Azurite integration, and more. Rider 2026.2 also adds the ability to create an Azure Functions trigger from the project creation dialog. In addition, Azure Functions projects can now be debugged inside a Docker container, extending the Docker debugging workflow that was previously available only for regular .NET projects.
• New in Azure DevOps support: Pull requests - Rider 2026.2 expands Azure DevOps support with the introduction of pull requests. The new Azure DevOps tool window lets you list and filter pull requests, review changed files, vote, complete existing PRs, and create new ones without having to switch to any external tools. You can review PRs in the context of your project with full access to Rider's code insight, navigation, and editing features.

Web development

• 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. Rider 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.

Key highlights

• Faster navigation for axum and reqwest - In axum projects, route strings are the entry points to your service, but tracing them back to handlers or related client calls often still requires manually searching through the code. RustRover 2026.2 introduces support for the axum and reqwest libraries. The IDE now understands routes in your project, enabling URL resolution, endpoint discovery, and navigation between routes and handlers. Route calls include references and inlay hints that make endpoint relationships easier to understand at a glance. This release also adds reqwest generation and navigation, helping you create client calls with less manual setup.
• Code insight for Ferrocene toolchains - Developers using Ferrocene can now benefit from RustRover's code insight features, including completion, navigation, inspections, and code analysis. RustRover now supports a Ferrocene toolchain managed by criticalup and linked to rustup. The IDE also provides setup guidance and clearer error messages to help you configure the toolchain correctly and resolve issues.
• Interactive declarative macro tester - Declarative macros are among Rust's most powerful tools, but their syntax is different from that of regular Rust. When the output is not what you expected, it can be hard to see how the input matches the macro definition and what code the macro produced. The new interactive declarative macro tester shows you the code your macro input expands into, as well as how the input and output correspond, directly in the IDE. Provide macro input, inspect the expanded output, and see how the input is transformed. This makes matching errors easier to understand when developing macro_rules! macros.

Productivity improvements

• Criterion benchmark run configurations - Benchmarking is easier when you stay close to the code you are measuring. That's exactly why JetBrains have made it possible to run Criterion benchmarks from the IDE. You can now create run configurations for Criterion benchmarks, launch them from the gutter icon next to criterion_main!(), and view the results in the Run tool window.
• Smarter import cleanup for Rust code - Import cleanup should remove noise without making you worry that something important might disappear. In Rust code with macros, external linter results, or large files, however, unused imports can be harder to clean up reliably. In this version, import cleanup delivers fewer false positives. Additionally, JetBrains have added support for imports reported by external linters and optimized how cleanup works inside macro calls. The Optimize Imports action is also faster and more conservative in larger files, removing only imports that are marked as unused.
• Local variable completion for struct literals - When building a struct from values already available in scope, you often have to retype local variable names or fix missing fields manually. RustRover now suggests local variables inside struct literals when the Create field quick-fix can be applied. You can insert a value that's already in scope and then create the matching field, making it faster to build up struct literals as you code.
• .env file support for Rust - Environment variables are easy to mistype and hard to track when your Rust code and .env files are disconnected. This release adds support for .env files. You can complete available environment variables when writing runtime env calls, jump from Rust code to a related variable declaration, find usages from the .env file, and rename keys across both code and the configuration.
• Ability to copy fully qualified Rust paths faster - Some Rust workflows require a ::-delimited path to a function, method, or item, for example, when you're working with tools like cargo asm, selecting targets, or adding rustdoc links. Rebuilding that path manually can break your flow. RustRover 2026.2 makes the Copy Reference action smarter for Rust. In supported contexts, you can copy the fully qualified module path for the item under the cursor with one shortcut, eliminating the need to manually piece the path together.
• Improved editor experience in split mode - In split mode, the IDE frontend and backend run separately, which can make everyday editor interactions feel less smooth in some remote development setups. Editing in split mode now feels smoother, and the improvements are especially pronounced when you're typing or making regular code changes. This makes remote workflows feel closer to the experience of working in the standard local IDE, particularly when the backend runs on another machine or in a company-managed environment.

AI updates

• Agent skills manager - AI agents are only as useful as the context they have. When they don't have knowledge of your frameworks, conventions, and tooling, you end up re-explaining the same setup in every new chat window. Agent skills fix that. Install them once in RustRover and your agents carry that domain knowledge across every project and session - automatically. Browse and manage skills directly from the IDE, expand the built-in library with external registries like public GitHub repositories, or let RustRover import skills you've already set up for Claude Code or Codex.
• Support for third-party providers in AI completion - AI 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 doesn't use up your AI credits. With the latest update, you can now connect your own OpenAI-compatible model providers for AI completion.
• GitHub Copilot built into RustRover - As the result of a direct partnership between JetBrains and Microsoft, GitHub Copilot is now a natively integrated agent in JetBrains IDEs. Unlike in 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.

Platform and IDE improvements

• Git and version control - Git workflows are now smoother with faster conflict resolution and improved worktree management. This release adds automatic handling of simple conflicts across an entire changeset and enhances Git worktree management, making it easier to clean up and manage worktrees directly from the IDE.
• Accessibility - RustRover is now more accessible with keyboard navigation in the main toolbar and status bar and expanded Orca screen reader support on Linux.
• Performance and UX - Performance and usability improvements help keep the IDE responsive during everyday work, with asynchronous file saving, a faster custom file chooser, and an updated Sync Plugins dialog.
• Everyday productivity - Common IDE interactions are smoother. Markdown now supports footnotes, Search Everywhere remembers selected scopes, bookmarks persist when switching branches, and tab colors in the Islands theme have been improved.

• Added support for authentication and authorization with OIDC/OAuth 2.0 for MongoDB.

• Query Console
  • Backspace stops working in MongoDB JS console after typing '${'.
• Quick Documentation
  • Quick Documentation shows nothing for built-in SQL functions.

Key highlights

• Python extension development with the Rust plugin (Beta):
  • Work seamlessly with Python projects that leverage Rust modules to speed up performance-critical components.
  • Jump between Python and Rust with bidirectional navigation from .pyi stubs to their underlying pyo3 code and vice versa.
  • Automatically rebuild Rust extensions during development whenever you run or test the Python application.
  • Debug compiled Rust extensions natively alongside your standard Python debugging workflows.
• 'debugpy' as the default debugger - Following its introduction as an optional backend in 2026.1, debugpy is now enabled by default for all Python projects and Jupyter notebooks, using the Debug Adapter Protocol (DAP).
• Support for uv-backed tools and uvx - PyCharm now leverages the uv toolchain to streamline how you run your external development utilities, eliminating manual package setups that clutter your local environment. The settings interface for external tools and linters - such as ruff and black - has been completely redesigned. Additionally, you can now configure these utilities to run via uvx when they are not installed in your local project environment. This allows you to manage tool integrations at the project level or establish defaults for all new projects, while executing the underlying packages globally on your machine. You can now run uv commands directly within the built-in terminal inside your project environment.
• Support for uv, Poetry, and Hatch multi-projects and uv workspaces (Beta) - Previously available as an optional feature in PyCharm 2026.1.1, this functionality is enabled by default in version 2026.2. It streamlines your subproject management and provides richer dependency insights directly within your configuration files. See the exact installed version of a package as a gray inline hint displayed directly next to its requirement definition in pyproject.toml or requirements.txt. Hover over a package name or press Ctrl+Q to view information about the package, including current version, license, and upstream repository links. Hold Ctrl and click on a package name to open its specification in an editor tab, or navigate directly to the source module in the Project tool window for internal workspace dependencies.
• Editor minimap - Navigate complex source files and notebooks more efficiently with the official editor minimap. It provides a high-level visual overview of your document structure across all supported file types - while offering a dedicated layout built just for Jupyter notebooks. Quickly jump to specific cells or sections in long notebooks by clicking directly on the minimap, reducing scrolling time. Hovering over the minimap automatically highlights the corresponding code block, making it easier to track your position in large files. Position the minimap on either side of the editor, or choose between the Fit and Fill scaling modes to optimize how the document view is displayed. Toggle the minimap by searching for it via Search Everywhere (Shift+Shift) or use the three-dot menu in the upper-right corner of the editor.
• Pyrefly type engine integration - Use Pyrefly as an external type engine to significantly accelerate code insight features for large-scale Python codebases. Leverage Pyrefly's Rust-based architecture for faster type inference and diagnostic resolution compared to the built-in engine. Improve the precision of type-related diagnostics, inlay hints, and quick documentation by delegating analysis to the Pyrefly language server. Switch to the Pyrefly engine via the Type widget in the status bar at the bottom of the IDE. PyCharm will automatically handle the installation if it's not already configured. Note: This integration is currently optimized for local interpreter configurations. Support for Docker, WSL, SSH, Jupyter Notebooks, and multi-module projects is planned for upcoming releases.

AI in PyCharm

• Start new projects with AI - If you have a JetBrains AI license, you can now generate fully configured, runnable projects from scratch using natural language prompts directly from the Welcome screen. Generate entire codebases from natural language, including boilerplate code, configuration files, and database connections based on a plain-text description. Skip manual environment setup as the IDE automatically configures the correct SDK, installs required dependencies, and creates functional run configurations. Refine code iteratively through a persistent chat thread that lets you add features or modify the generated artifacts on the fly.
• Agent skills manager - AI agents are only as useful as the context they have. When they don't have knowledge of your frameworks, conventions, and tooling, you end up re-explaining the same setup in every new chat window. Agent skills fix that. Install them once in PyCharm, and your agents carry that domain knowledge across every project and session - automatically. Browse and manage skills directly from the IDE, expand the built-in library with external registries like public GitHub repositories, or let PyCharm import skills you've already set up for Claude Code or Codex.
• Deprecation of the Machine Learning Code Completion (Ranking) plugin - JetBrains are deprecating the Machine Learning Code Completion (Ranking) plugin. As AI completion, next edit suggestions, and agents have become the primary ways developers get intelligent assistance, demand for ML-based completion ranking has significantly declined. The plugin will no longer be bundled, but it remains available for installation from JetBrains Marketplace if you'd like to continue using it.

Code insight

• Improved literal type narrowing ensures that the IDE correctly infers Literal types when assigning values to variables, preventing unnecessary type warnings.
• Enhanced Pydantic code insight and inspections deliver a more reliable experience when working with Pydantic models. Available in PyCharm Pro.
• Support for PEP 561 partial stubs ensures you get seamless code completion and accurate import suggestions. You can now effortlessly discover and import modules that aren't explicitly declared in a library's stubs, as PyCharm automatically falls back to the underlying source implementation or typeshed to find them.

New Welcome screen available for more users

• The non-modal Welcome screen is now being rolled out to a wider audience, providing a smoother start to your workflow by reducing visual clutter. It now appears as a dedicated tab inside the IDE, keeping your most common actions within easy reach.

Platform

• 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. PyCharm 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 instantly, instead of having to open each file one by one. With the new flow, you can also see a complete overview of resolved and unresolved files, reopen files at any time, and revert and reapply conflict chunks in any order.
• Easier file and image sharing in terminal sessions - No more copying and pasting paths from your project or external applications when working in the terminal or with CLI agents. You can now drag and drop a file or folder directly into the terminal to insert its path into the current command. To quickly start working from a specific location, drop a file or folder onto the terminal tab area to open a new tab with its root path already set. You can now also paste images directly from the clipboard into supported CLI agent sessions, which makes it easier to share visual information with your agent.

Web

• 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. PyCharm 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.

Cloud

• Docker Compose statuses right in the editor - Docker Compose files are now more informative and interactive. You can view the status of running containers directly inside your Docker Compose file and quickly access common actions without leaving the editor. With the ability to jump straight to logs for a specific service, create a database connection, or open a service in your browser directly from the corresponding entry in the Compose file, it is easier to monitor and work with your application stack.
• Terraform testing framework support - Version 2026.2 extends PyCharm'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 lifecycle. These additions build on out-of-the-box infrastructure tooling, ensuring your deployment configurations remain highly maintainable, predictable, and clean.

AI

• Agentic debugging with a bundled skill - Introduced in this release, bundled skills help AI agents use IDE tools more effectively by providing predefined workflows instead of forcing the agent to figure out the correct sequence of actions on its own. RubyMine 2026.2 includes the rubymine-debugger skill, which enables compatible AI agents to use the IDE's debugging capabilities autonomously. Instead of manually stepping through code and inspecting runtime state yourself, you can describe the problem in natural language and let the agent perform much of the investigation for you. Using the RubyMine debugger, agents can launch or continue debug sessions, set breakpoints, inspect variables and call stacks, evaluate expressions, and analyze application behavior at runtime. This helps them identify issues that are difficult to understand from source code and logs alone.
• AI completion now supports third-party providers - AI-based code completion is an in-editor code suggestion experience that combines inline completion and edits that go beyond the cursor. Available to all JetBrains AI users out of the box, it's powered by JetBrains-trained models, without spending 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 RubyMine. 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.

Symbol-based code insight

• Now enabled by default, with further improvements - Introduced in RubyMine 2026.1, the symbol-based code insight engine is now enabled by default. The new engine provides more accurate navigation, documentation, and symbol resolution for Ruby classes, modules, and constants, while also serving as a more scalable foundation for future improvements. In RubyMine 2026.2, JetBrains have expanded support for symbol-based modeling across the IDE and further improved its efficiency. These improvements are reflected not only in new functionality but also in resource usage. For example, internal benchmarks show that Find Usages in large projects now uses less than half the memory it previously required.
• Richer Quick Documentation and Ctrl/Cmd+Hover information - Quick Documentation now presents definitions more clearly and displays additional type information where available. Ctrl/Cmd+Hover hints now provide type information for more Ruby symbols, including constants and global variables.
• Better handling of unresolved classes, modules, and constants - You can now navigate and work with partially resolved code more effectively. Even when RubyMine cannot fully resolve a class, module, or constant, features like Go to Declaration, Find Usages, Rename, and Quick Documentation continue to provide useful results, reducing interruptions when working with dynamic Ruby code.
• Symbol-based modeling for parameter definitions - Parameter definitions now utilize symbol-based modeling for classes, modules, and constants. This brings all of the aforementioned benefits, such as improved performance, fuzzy find completion, and reduced resource usage, into your daily workflow. JetBrains have additionally refined their behavior, such as by separating complex names in string literals into multiple references, and customizing how rename works for more fine-grained control.

Ruby ecosystem improvements

• Improved RBS experience:
  • Type parameter hints display variance modifiers, upper bounds, and default values.
  • RubyMine shows module self-types directly in Ruby code.
  • Managing RBS hints is now smoother thanks to editor actions available directly from the code.
• Expanded RSpec 4 support - Support for RSpec 4 has been expanded to help simplify migration from older versions. RubyMine detects deprecated syntax, highlights compatibility issues, and provides quick-fixes for common upgrade scenarios. The IDE includes inspections for top-level DSL declarations, deprecated should expectations, and other RSpec 4 compatibility changes. These tools help identify migration issues early and make upgrading existing test suites more straightforward.
• Skipping non-project code while debugging - The Ignore non-project sources option now works more reliably when stepping through code. When enabled, RubyMine skips framework internals, Ruby standard library code, third-party gems, and directories marked as excluded, helping keep debugging sessions focused on the code you're actually investigating. This reduces the amount of manual stepping required to reach application code and makes debugging workflows easier to follow.

User experience improvements

• Smoother gem environment updates - RubyMine 2026.2 performs gem environment updates in the background, reducing UI freezes during gem refreshes and helping keep the IDE responsive while dependencies and SDK information are updated.
• Streamlined project opening - RubyMine now reduces setup friction when opening projects. The IDE can automatically select a Ruby interpreter based on project configuration files and shows fewer setup notifications, helping you get started with less manual configuration and fewer distractions.
• More efficient RuboCop analysis - JetBrains have optimized background RuboCop processing to reduce unnecessary CPU usage during everyday development, helping RubyMine stay responsive and consume fewer system resources.

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.

Go performance optimization

• 'pprof' profiling without additional setup - Previously, profiling in GoLand required using a test as the entry point. GoLand 2026.2 extends pprof profiling beyond tests and now supports profiling regular Go applications. You can collect CPU, memory, mutex, block, and goroutine profiles using standard run configurations. You can also import and export pprof profiles. This lets you capture performance data from production environments and analyze it in GoLand.
• Support for the Goroutine leak profile - GoLand 2026.2 adds support for the new Goroutine leak profile introduced in Go 1.27. It helps you find goroutines that are permanently blocked and can never resume execution because the synchronization primitive they are waiting on, such as a channel, sync.Mutex, or sync.Cond, has become unreachable.
• Redesigned profile viewer - GoLand 2026.2 introduces a redesigned profile viewer that makes performance data easier to explore and understand. Switch between multiple visualizations, including flame graphs, call trees, top functions, and graph views. The graph visualization helps you quickly understand relationships between callers and callees, identify hot paths, and navigate directly to the relevant source code.
• Profiling data in the editor gutter - You no longer need to switch between profile views and source code to understand where your application spends execution time. GoLand now visualizes profiling results directly in the editor gutter, showing how much time was spent at specific lines and call sites. You can quickly identify hotspots, navigate to expensive operations, and understand performance bottlenecks in the context of your code.
• Live CPU and memory charts - The new live performance charts show CPU and memory consumption directly in the IDE while your application runs. You can observe resource usage as it changes, verify the impact of optimizations, and quickly spot suspicious spikes without switching to external monitoring tools.
• Struct optimization tool - The order of fields in a struct can affect how much memory it uses. Even small inefficiencies can add up when a struct is created thousands or millions of times. The new memory alignment tool detects opportunities to reduce memory usage by rearranging struct fields without changing your code's behavior. You can apply the suggested optimization with a single quick-fix. This is especially useful for applications that process large amounts of data or keep many objects in memory. You can run the analysis manually or enable the inspection in the editor.
• Escape analysis support - When you need to investigate unexpected memory usage, performance issues, high allocation activity, or increased garbage collection pressure, compiler allocation decisions can provide valuable clues. GoLand now visualizes Go compiler escape analysis directly in the editor, helping you understand why certain values are allocated on the stack or the heap. Instead of parsing compiler output, you can inspect allocation decisions alongside your code.

Modernize your code with confidence

• Support of go fix - GoLand 2026.2 now integrates with the official go fix tool and surfaces its recommendations directly in the editor. When the Go team introduces a new language or standard library migration, GoLand highlights affected code and offers the same quick-fixes provided by the Go toolchain. Apply updates directly in the editor to ensure your codebase stays up to date as new fixes become available. You can review and apply updates without leaving the IDE, making it easier to adopt new Go versions across large projects.

AI

• Agent skills manager - The new skills manager gives you a dedicated place to view and manage agent skills. Skills provide reusable workflow knowledge that helps AI agents understand how to perform specific tasks and interact with available tools. This makes agent behavior more predictable and easier to customize.
• Configurable AI completion models - AI 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 doesn't use up your AI credits. With the latest update, you can now connect your own OpenAI-compatible model providers for AI completion.
• GitHub Copilot built into GoLand - You can now access GitHub Copilot directly from the JetBrains AI chat. Sign in with your GitHub account, select a Copilot model, and use Copilot-powered chat capabilities alongside other supported agents from a unified interface. This removes the need to switch between separate AI integrations inside the IDE.

Application and infrastructure workflows

• Inline service actions in Docker Compose - Working with multicontainer applications often requires switching between configuration files, logs, browsers, and terminal windows. GoLand now provides inline actions directly inside Docker Compose files. You can view service status, access logs, open exposed endpoints, and perform common actions directly from docker-compose.yaml.
• Service templates for Docker Compose - When building a Docker Compose configuration from scratch, you usually have to search documentation and copy service definitions. GoLand now provides smart service templates for common technologies such as PostgreSQL, Kafka, Redis, and others. Start typing a service name and the IDE generates a ready-to-use configuration that you can customize for your environment.
• Terraform testing framework support - GoLand 2026.2 adds support for the Terraform testing framework, bringing code insight, navigation, completion, and validation to Terraform test files. You can now work with infrastructure tests using the same IDE assistance available throughout the rest of your Terraform workflow.

IDE performance and workflows

• Automatic creation of run/debug configurations - GoLand 2026.2 can now automatically detect main packages in your project and create run configurations for them. Instead of manually configuring each application entry point, you can start running, debugging, or profiling your code right away from the gutter or the Run/Debug Configurations menu.
• Faster code analysis for large projects - GoLand 2026.2 improves the performance of inspections, highlighting, and project-wide analysis, reducing the time spent processing large files and complex codebases. These optimizations help keep the IDE responsive while you edit, navigate, and analyze code.
• Improved performance when saving files - GoLand now performs file writes asynchronously, reducing UI freezes when working with large projects, WSL environments, Docker containers, and remote file systems. The result is a smoother editing experience, especially in environments where file operations are slower.
• Git worktree improvements - In GoLand 2026.2, you can use worktrees in WSL environments, remove pruned worktrees directly from the IDE, and benefit from improved cleanup and deletion handling. These improvements make parallel development workflows easier to manage.
• Deprecation of the Machine Learning Code Completion plugin - The Machine Learning Code Completion plugin is now deprecated and no longer bundled with GoLand. As AI completion, next edit suggestions, and AI agents have become the primary ways developers receive coding assistance, usage of ML-based completion ranking has declined. If you still rely on the plugin, you can continue to install and use it from JetBrains Marketplace.

Key highlights

• 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. WebStorm 2026.2 supports TypeScript 7 as the default for projects already using it, with an opt-in upgrade path for earlier versions - no full project migration required.
• Agent skills manager - Agents are only as useful as the context they have. Without knowledge of your frameworks, conventions, and tooling, you may end up needing to re-explain the same setup in every new chat window. Agent skills fix that. Install them once in WebStorm, and your agents carry that domain knowledge across every project and session. WebStorm 2026.2 features the new skills manager, a dedicated place to view and manage your agent skills. You can also expand the built-in library with external registries like public GitHub repositories, or let WebStorm import skills you've already set up for Claude Code or Codex.
• Native GitHub Copilot integration - If your team already uses GitHub Copilot, you no longer need a separate plugin or registry setup to bring it into WebStorm. Copilot is now a natively integrated agent. This is the result of a direct partnership between JetBrains and Microsoft. You can access Copilot from the AI chat's agent picker after signing in with your GitHub account. It's tested alongside the IDE and avoids configuration drift and version mismatches. A separate GitHub Copilot subscription is required.

Framework and ecosystem updates

• React Buddy: Full support for React 19 - React Buddy is a WebStorm plugin (available on JetBrains Marketplace) that brings visual component tooling to your React workflow in the IDE: component palettes, interactive previews, and Storybook story creation. If you migrated to React 19 early, you probably noticed the plugin didn't keep up. In WebStorm 2026.2, React Buddy fully supports React 19.
• Vue - Vue support has been updated with Vue language server 3.0 integration, improving compatibility with the latest tooling and fixing reliability issues, including incorrect hover types, stack overflows, and plugin-loading problems.
• Svelte - WebStorm now bundles an updated Svelte language server and TypeScript plugin, adds support for SvelteKit shared hooks (reroute, init, and transport), and improves Svelte 5 named snippet handling. Multiple parsing, highlighting, and CSS selector issues have also been resolved.
• Astro, Prisma, and Angular - 2026.2 bundles updated language servers for Astro and Prisma. Angular workflows have been improved thanks to fixes for slow or missing TypeScript/Angular error updates, as well as more efficient dependency processing.
• CSS, Sass, SCSS, and Less - Style sheet refactoring is now more reliable. SCSS and Sass glob imports and absolute import paths no longer rewrite unexpectedly. Color previews for modern CSS functions like color() and color-mix() now work across Sass, SCSS, and Less. CSS syntax data has been updated, and a false positive around nested selectors has been fixed.
• Debugging, test runners, and Node.js - In WebStorm 2026.2, debugging is more predictable. You can now disable source maps, Ctrl+Shift+Click starts a debug session correctly, and fixes are available for JavaScript debug errors. Additionally, Cypress and Playwright run more reliably, and Playwright no longer freezes in affected scenarios. Node.js handling has also improved. WebStorm now reads environment variables from login interactive shells, detects runtimes in native Dev Containers, and fixes empty dependency data and cases where node_modules was incorrectly skipped as a content root.

Performance and quality improvements

• Performance and stability - This release addresses a broad set of freezes and regressions affecting NPM run configuration checks, package.json completion, Node.js interpreter detection, Tailwind server startup and web-types processing. It also fixes typing, indexing, reduces memory usage in JavaScript handling, and speeds up test framework search.
• User experience - WebStorm 2026.2 also adds notable UX improvements. Search Everywhere now preserves its scope across restarts, Markdown support includes footnotes and Mermaid diagrams, and you can customize double-key shortcuts in the keymap. The IDE now detects prunable Git worktrees and improves worktree support in WSL environments, bookmarks persist when switching branches, and you can drag and drop a file into the terminal to insert its path.

Key updates

• Debugger skill for AI agents - CLion 2026.2 introduces a bundled skill that gives AI agents direct access to the debugger. Agents can use stack traces, breakpoints, and variable values to investigate root causes without interrupting their autonomous workflow. The skill works with GDB, LLDB, and DAP-based debuggers and is available for agents compatible with the ACP (Agent Client Protocol). To invoke it, use /clion-debugger in Claude Code or $clion-debugger in Codex.
• Simplified debugger configuration with debug profiles - Previously, configuring the debugger meant dealing with different IDE settings. This became even more complicated for embedded projects, which add extra layers like hardware interfaces and probes. In 2026.2, there's a new settings section that provides a single, unified place to configure all your debugging setups - local, remote, and embedded. Whether you're using GDB, LLDB, SEGGER J-Link, or ST-LINK, everything now lives in Settings | Debugger | Debug Profiles.
• Support for C++26 reflection - Compile-time reflection in C++26 is one of the most significant additions to the language in years. Previously, you might've had to write tedious boilerplate where code needed to inspect or iterate over types, functions, or members during compilation - for example, to list struct members or convert enum values to strings. C++26 reflection reduces this repetitive code by giving programs a standard way to access information about types, functions, variables, and other declarations at compile time. CLion 2026.2 adds highlighting and code analysis for reflection, available when using GCC 16.1 or newer. With this addition, the IDE now supports most C++26 features.

Embedded development

• Support for the STM32 bundle manager - Setting up an STM32 embedded development environment currently requires installing the all-in-one STM32CubeCLT package, even if you only need specific tools or a particular bundle version. CLion 2026.2 adds support for STM32 Cube CLI, a new STM32 bundle manager that lets you download only the tools you need - such as CMake, ST-LINK GDB server, or GNU tools - and manage your development bundles directly in the IDE. You can use STM32 Cube CLI in the terminal or via Tools | STM32 Cube CLI. The IDE also supports installing project bundles to all environments at once when working with toolchains over WSL or SSH. When required bundles are missing, CLion shows a notification in the CMake output with a one-click action to install them.
• Support for structs and arrays in live watches - With live watches, you can monitor global variables in real time - no need to stop the debugger or interrupt a program's execution. In this release, JetBrains have extended the support for variable types, making it possible to inspect arrays and structs. A new button also lets you clear the variable value history to keep the view focused on the current data.

Debugger

• Easier inspection of fields and global variables - When debugging, CLion automatically tracks local variables in the Threads & Variables pane. To inspect fields and global variables, you previously had to set up watches manually, which added friction when they were just as relevant to the current context. CLion 2026.2 introduces a new debugger setting that automatically displays fields and global variables alongside locals, while keeping them visually distinct. This feature is enabled by default. You can disable it in Settings | Build, Execution, Deployment | Debugger | Data Views | C/C++ | Variables.
• Configuration-specific breakpoints - When debugging multi-process systems or working with different target platforms, managing breakpoints across configurations can be cumbersome. Breakpoints set for one process or target may be triggered unexpectedly in another. CLion 2026.2 introduces a feature that makes it easier to isolate and diagnose issues in these cases. You can now assign breakpoints to a specific debug configuration in the Breakpoints dialog (Run | View Breakpoints). When that configuration is active, the debugger stops only at its assigned breakpoints and ignores the rest.

Build tools and project formats

• Improvements to Bazel support - When starting a debug session, CLion now checks whether your project is built with debug symbols instead of automatically injecting debug flags. If debug symbols are missing, the IDE shows a warning, from which you can inject debug flags directly. The debug session will then continue. You can now switch configurations when multiple exist for the same file. Before, this was only possible for users of the legacy CLion Classic engine. The plugin automatically selects the correct configuration when you debug or run a target, ensuring your code insight always reflects the active target.
• Easier CMake target renaming - CMake targets are executables, libraries, and utilities created with commands such as add_executable or add_library. Previously, renaming a target in CLion required manually editing all its occurrences. Now, you can rename targets in your CMakeLists.txt files automatically using the Rename refactoring action (Shift+F6). It updates all definitions and usages of the target name across your project.
• Bundled toolchain updates
  • CMake updated to v4.3.
  • GCC updated to v15.2.0.
  • GDB updated to v17.1.
  • Mingw-w64 updated to v13.

Other updates

• Removing the CLion Classic engine - CLion Classic, the legacy C and C++ engine, has been removed from the IDE and is now available only as a plugin on JetBrains Marketplace. This completes the transition to CLion Nova, which is now the default engine for everyone. To continue using CLion Classic, install the C/C++ Language Support via Classic Engine plugin from Settings | Plugins | Marketplace. Note that CLion Classic is no longer in development - all new language features are developed exclusively for CLion Nova.
• Git improvements
  • Streamlined Git conflict resolution: In large projects, merges often result in dozens of conflicts. Resolve All Simple Conflicts is a new action that automatically resolves standard conflicts across the entire changeset at once, rather than opening each file individually. The new flow also provides an overview of resolved and unresolved files.
  • Enhanced Git worktree support: You can now use worktrees in WSL environments, clean up pruned worktrees directly from the IDE, and take advantage of more reliable worktree deletion scenarios.
  • Username autocomplete in code reviews: Type @ in a code review comment to get autocomplete suggestions for usernames from your GitHub or GitLab repository.
• Terminal improvements
  • Drag-and-drop file and folder support: You can now drag a file or folder directly into the terminal to insert its path into the current command, or drop it onto a terminal tab to open a new tab rooted at that location. You can also paste images from the clipboard directly into supported CLI agent sessions.
  • Faster MCP setup: When you start a new AI session in the terminal without an MCP server configured, CLion now prompts you automatically to set one up and takes you directly to the relevant settings.

AI

• AI agent skills for working with databases - DataGrip 2026.2 introduces three agent skills for working with databases: database-connection-management, database-text-to-sql, and database-tools. Skills define reusable procedures for AI agents. They provide step-by-step instructions for completing complex tasks using existing DataGrip features, including MCP tools. Following these instructions helps agents generate higher-quality results with lower token usage.
• Data source management with MCP tools - JetBrains have expanded the list of MCP tools that help AI agents work with databases. This release adds two new tools to the list: create_database_connection and edit_database_connection. The database-connection-management skill includes instructions that help agents use these tools correctly. To have an agent create a new data source, ask it to do so and provide the connection details. The agent will create the data source and run a test connection.
• Other improvements
  • AI in DataGrip now remembers query results from previous interactions, allowing you to fetch additional rows without rerunning the query. This also works for statements that return data with RETURNING.
  • When an AI agent creates a table, a column, or any other database object, DataGrip automatically introspects the database or schema you're working with. The newly created object will appear in the database explorer right away.
  • Previously, when an AI agent couldn't find a referenced database object, it couldn't tell whether the object didn't exist or simply hadn't been introspected. Now, the agent can identify missing objects, suggest similarly named objects in case of typos, and recognize objects that haven't been introspected.
  • Queries run by AI agents are now also tracked and logged in the data source query history. To check them, open the data source's query console by pressing Shift+Ctrl+F10 and selecting any query console. In the query console tab, click Browse Query History.
  • Previously, AI agents received a generic Not done error when an SQL query failed. Now, the agent receives an actual database message with an SQL error.
  • The list_database_connections MCP tool now returns database connection information correctly. Previously, incorrect handling of parameters with default values caused an output schema error.
  • The database schema attachment UI in the AI chat has been redesigned.
  • Database-specific MCP tools no longer require the AI Assistant plugin.

A smoother start

• Non-modal Welcome screen - The Welcome screen, which appears when you start DataGrip for the first time or after you close all projects, is now non-modal. It appears as a regular IDE tab instead of a modal dialog, so you can continue working in the IDE while using it. This new Welcome to DataGrip tab opens in the automatically created default project. It provides quick actions and useful links to help you get more familiar with the IDE and configure it to suit your needs.
• Interactive onboarding tour - JetBrains have introduced an interactive onboarding tour that guides you through DataGrip's core features. It covers basics such as key actions in the Database Explorer tool window, the data source settings dialog, query execution in a query console, viewing and working with query result sets, and submitting changes to a database.

Command-line interface

• CLI commands for data sources - Power users often need to automate environment setups. To support this, JetBrains have introduced a command-line interface that lets you programmatically manage your database connections and drivers.

Connectivity

• Two-session mode - Before this release, session control was handled through the IDE's default behavior, with the optional Single shared session mode. By default, each new client, such as a query console or data editor, created a separate connection to the database. If Single shared session mode was enabled, DataGrip used one shared connection whenever you worked with a data source. Single shared session mode supports scenarios where you want to share one connection across multiple clients. However, it can be inconvenient because the same session is also used for database introspection - the process of retrieving metadata. DataGrip 2026.2 introduces the new Two sessions: shared and introspection mode, which creates two sessions: one for introspection and one for everything else. This new mode keeps metadata retrieval separate from your working session. If introspection takes longer, query consoles, data editors, and other clients continue using the shared session instead of waiting for it to finish.
• Bundled JDBC drivers - Previously, DataGrip didn't include any JDBC drivers. Each driver you wanted to use had to be downloaded separately when creating a data source. Now, the following JDBC drivers are bundled in DataGrip:
  • Microsoft SQL Server 13.2.1.
  • MongoDB 1.21.
  • MySQL Connector/J 9.5.0.
  • PostgreSQL 42.7.3.
  • Redis 1.6.
• Role and warehouse switcher Snowflake - Switching between database roles and warehouses is now much faster. If you work with Snowflake, you no longer need to manually execute SET ROLE commands or search through connection settings to change your permissions for the current session. A new drop-down menu in the query console toolbar lets you switch between available roles and warehouses instantly.

Working with data

• SQL expressions in the data editor - You can now set cell values using SQL expressions instead of being limited to literal values. Previously, when editing data in the grid, you could only enter static values or use the context menu to set a cell to NULL or its DEFAULT value. If you wanted to use a database function like NOW() or gen_random_uuid(), or perform a calculation, you had to manually write and execute an UPDATE statement in the console. This update introduces the new SQL Expression mode in the data editor. When editing a cell, you can now right-click it and choose Edit as SQL Expression, or enable SQL Expression mode using the fx button in the value editor.

Database explorer

• Redesigned empty state in the database explorer - The Database Explorer tool window now features a redesigned empty state that offers quick actions for creating data sources in a new project. It also provides PostgreSQL, MySQL, and SQLite demo databases used in the quick start guide, so you can connect to them and get familiar with basic DataGrip features.
• Database colors: v2.0 - Database colors now have a fresh, consistent UI, and custom colors work differently. Previously, the fixed #RRGGBB hex code looked the same across all IDE themes, so it usually looked right in either the light or the dark theme, but not both. Now, you can simply set the hue, and the system handles the shades automatically.
• Schema object grouping by prefix - The database explorer now allows grouping schema objects by prefix in the tree. The following characters are treated as prefix delimiters: _, -, and $. For example, my_table01 and my_table02 are grouped under my_, and their names are displayed as table01 and table02 within the group.
• Deletion of folders and their contents - Previously, you were unable to delete non-empty folders. Now, you can delete folders that contain other folders or data sources. Before deleting a folder, DataGrip will ask for confirmation and display the list of items to be deleted.

Explain Plan menu and actions

• Return of the Explain Plan raw format actions - In the previous release, JetBrains simplified the Explain Plan drop-down by removing the Explain Plan (Raw) and Explain Analyse (Raw) actions. This affected workflows that regularly require these actions. In this release, JetBrains have addressed your feedback by bringing back these actions and making them accessible from the toolbar. There's now a Raw button on the left-hand toolbar of the Query Plan tab. For the plan tree, the button opens the raw execution plan in the Raw inner tab. The plan tree also remains available in the Operation Tree inner tab.

Query files and consoles

• Custom query console names in editor tab headers - Different workflows and tasks require different information to be available at a glance. This is why JetBrains have added the ability to customize how query console names are displayed in editor tab headers - the first place you look when identifying an open file. Previously, only the data source name was displayed next to the file name. Now, you can use variables to add more details, such as the attached data source, database, schema, or search path.

Code editor

• Execution time display near queries - Previously, you could find timestamps for a query execution only in the Services tool window. Now, once DataGrip has executed a query, it shows the query execution time next to the query in the code editor.
• Improved support for ClickHouse and Snowflake SQL - Expanded ClickHouse SQL support with the following additions:
  • Query parameter syntax.
  • Additional SYSTEM statements.
  • The FIRST clause in ALTER TABLE ADD COLUMN statements.
• Other enhancements include:
  • Improved support for ORDER BY... WITH FILL STEP.
  • Fixes for false syntax errors related to projection indexes.
• For Snowflake, JetBrains have added support for:
  • Flow operations.
  • DATABASE ROLE syntax.
  • HASH functions, including HASH(*).
  • INTERSECT, UNION BY NAME, and DISTINCT in SELECT statements.
  • Object, session, and user parameters in ALTER USER statements.

AI in PhpStorm

• Agent skills manager - AI agents are only as useful as the context they have. When they don't have knowledge of your frameworks, conventions, and tooling, you end up re-explaining the same setup in every new chat window. Agent skills fix that. Install them once in PhpStorm, and your agents carry that domain knowledge across every project and session - automatically. Browse and manage skills directly from the IDE, expand the built-in library with external registries like public GitHub repositories, or let PhpStorm import skills you've already set up for Claude Code or Codex.
• Support for third-party providers in AI-based code completion - AI 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 doesn't use up your AI credits. With the latest update, you can now connect your own OpenAI-compatible model providers for AI completion.
• GitHub Copilot built into PhpStorm - As the result of a direct partnership between JetBrains and Microsoft, GitHub Copilot is now a natively integrated agent in JetBrains IDEs. Unlike in 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.
• Faster PhpStorm MCP server setup for terminal AI sessions - To help you get more out of AI agent workflows in the terminal, the IDE can now prompt you to configure the PhpStorm MCP server when starting a new session with your preferred coding agent. If no MCP server is configured, a notification appears automatically and takes you directly to the relevant settings.

PHP

• #[FileReference] attribute for persistent file references - PhpStorm now lets you mark string literals as file or directory paths using the #[FileReference] attribute on parameters in functions, methods, and constructors. When a path is passed as a string to such a parameter, it gets first-class PhpStorm support for navigation and refactoring. Annotated file references apply project-wide and persist across IDE restarts, making them a better alternative to manual reference injections. In addition to simple references, PhpStorm supports relative paths defined with basePath, as well as paths constructed dynamically or using variables and constants.
• Trigger options for code quality tools - To further optimize the IDE's performance, PhpStorm now allows you to configure how often third-party code quality tools like PHPStan or Laravel Pint are triggered: on the fly as you type, on idle, or on file save. You can set the Run mode setting in Settings | PHP | Quality Tools | {quality_tool_name}.

Laravel

• Laravel tool window - The new Laravel tool window lets you manage Laravel projects without leaving PhpStorm. Use the Dashboard tab for general project information and quick access to Artisan commands, the Errors tab to browse local or Sentry-hosted log files and explore or fix errors with AI without copy-pasting logs, and the Laravel Cloud tab to manage deployments and env variables.
• Other improvements for Laravel developers include:
  • Support for laravel/passport and stancl/tenancy packages.
  • Support for PHP 8.5's pipe operator.
  • ide.json options for pointing to database schema files, explicit mapping of Eloquent model classes to database tables, custom paths to Laravel Livewire locations, and new viteAsset, passportScopeId, and staticStrings (with file links) completion types.

Web

• IDE support for TypeScript 7 - 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. PhpStorm 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.

Version control

• Enhanced Git worktree support - Version 2026.2 simplifies the management of Git worktrees in various development environments, such as WSL. Additionally, you can easily remove and clean up worktrees directly from the IDE. These updates help streamline day-to-day worktree management while reducing the need to switch to external Git tooling.
• 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. PhpStorm 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 instantly, instead of having to open each file one by one. With the new flow, you can also see a complete overview of resolved and unresolved files, reopen files at any time, and revert and reapply conflict chunks in any order.
• Username autocompletion in code reviews - Mentioning teammates in code review comments is now easier. Simply type @ in a comment to open a list of users from the current GitHub or GitLab repository and select the person you want to mention.

Terminal

• Easier file and image sharing in terminal sessions - No more copying and pasting paths from your project or external applications when working in the terminal or with CLI agents. You can now drag and drop a file or folder directly into the terminal to insert its path into the current command. To quickly start working from a specific location, drop a file or folder onto the terminal tab area to open a new tab with its root path already set. You can now also paste images directly from the clipboard into supported CLI agent sessions, which makes it easier to share visual information with your agent.

UI

• Non-modal Settings dialog - When the Settings dialog is open, you no longer have to close it to interact with the IDE window. This makes it easy to copy project paths to set up scopes, insert values from configuration files into the settings, view code appearance adjustments immediately, or even switch to another project in the middle of the configuration process. By default, the Settings window stays visible above the project where it was invoked. Unpin it to send it to the background.

Databases

• Redesigned empty state: A faster way to begin projects - To streamline your initial setup and provide a ready-to-code experience right from the start, JetBrains have redesigned the empty state in the Database Explorer tool window. When you open a new project, the tool window now displays quick actions for creating data sources. Additionally, to help you familiarize yourself with basic database features without the distraction of configuration steps, the empty state provides one-click access to PostgreSQL, MySQL, and SQLite demo databases from the Quick Start Guide. You can now customize how query console names are displayed in editor tab headers, making it easier to identify open consoles and files. You can also apply the same template to query files by enabling Use this template for query files.
• Database colors: v2.0 - The database color system offers a refreshed, more consistent user experience and several usability improvements. This release introduces an adaptive color engine alongside several structural usability improvements:
  • Theme-aware custom colors. Previously, static #RRGGBB hex codes remained identical across light and dark themes, often destroying visual contrast when you switched. Now you only need to choose a hue, and the IDE automatically adjusts the shades for the active theme.
  • Folder color support. You can now apply custom colors to folders as well as individual database objects.
  • Easier access to color settings. The color submenu has been moved up a level to make it easier to find, and all color settings are now available directly in the main Settings window instead of a separate dialog.

Performance

• PhpStorm 2026.2 focuses heavily on overall IDE stability and performance. While not yet showing immediate results beyond an up to 10% faster project indexing time, the latest changes lay the foundation for reduced startup time, indexing time, and freezes for both local and remote development scenarios in upcoming releases.

Cloud

• Docker Compose statuses right in the editor - Docker Compose files are now more informative and interactive. You can view the status of running containers directly inside your Docker Compose file and quickly access common actions without leaving the editor. With the ability to jump straight to logs for a specific service, create a database connection, or open a service in your browser directly from the corresponding entry in the Compose file, it is easier to monitor and work with your application stack.
• Faster Docker Compose setup with service templates - Creating dependent services in Docker Compose is now easier with ready-to-use templates for popular technologies such as PostgreSQL and Kafka. Simply start typing the name of a service or select one from the completion list, and the IDE will generate the corresponding Docker Compose configuration for you. This helps you get common services up and running faster while reducing manual configuration work.
• Terraform testing framework support - Version 2026.2 extends the IDE's support for Terraform 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 lifecycle. These additions build on out-of-the-box infrastructure tooling, ensuring your deployment configurations remain highly maintainable, predictable, and clean.

• AI Assistant
• Added the ability to extract DB consent classes from 'llm.sql' module to a separate module.
• Added the ability extract business logic from MCP modules into dbe/database.

• AI Assistant
  • MCP: AI agent receives generic 'not done' error instead of actual SQL error message.
• Data Editor/Viewer
  • Clear icon no longer refreshes table after clearing WHERE or ORDER BY fields.
• Database Explorer
  • Custom data source color not applied to sessions in Services tool window.
• Query Console
  • Can't execute statement in PyCharm dbt project.

• Code Editor
• Added the ability to get module path string for items.

• Code Insight
  • Fixed issue with: Evaluate 'cfg(feature = &quot;foo&quot;)' in Rust stdlib.
• UI
  • In "Attach Cargo projects" popup, Cargo.toml files should be sorted before directories.

• 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.

• AI Licensing
  • Error message "AI Free license cannot be used when AI Pro Trial is available".
• Installation
  • Provide feedback button does nothing.
• IntelliSense (Code Completion)
  • Completion window width is not collapsing back if it was scrolled by mouse wheel.
• Licensing and Evaluation
  • ReSharper attempts to refresh License Vault ticket offline and shows an error before 48 hours.
  • License Vault: Only one VS instance receives a valid offline ticket when starting two instances offline.
  • License Vault: Offline ticket from one VS version is not reused by another VS version.
  • License Vault: ReSharper requires license authentication for each active VS instance.
  • ReSharper loses authentication on restart.
• Live Templates
  • Templates Editor: "Choose Macro" dialog is not styled properly.
• Platform - VS Integration
  • The specified option is not valid in this scope: TextViewHost[PATH].
  • System.ObjectDisposedException: Cannot access a disposed object. Object name: 'LeftEdgeSpacerMargin'.
• UI
  • AI Assistant tool window in VS 2026 doesn't draw the corners properly.
  • Wrong Test Pass Icon in Visual Studio 2026.
  • Indents for selection are not symmetrical.
  • "Invisible" fluent icons on the R# settings page with dark theme in VS.
  • Incorrect corner radius in JPM.
• XAML
  • Xaml intellisense incorrectly sees Maui Community Toolkit AppThemeColor bindings as invalid (Maui).

• NuGet
• "Open the NuGet PMC" action doesn't work.

• Now allows disabling of source maps when debugging.

• Documentation
  • JSDoc linkcode doesn't have special formatting in quick doc.
• Imports
  • File extensions are duplicated on import.
  • Aliases are replaced with relative paths on rename/move.
• Intentions, Inspections
  • False positive "module is not installed" inspection result.
• LSP, TypeScript LS
  • Error highlighting is lost in .svelte files when using svelte-language-server 0.18 (> 0.17.29).
• Run-Debug
  • JavaScript Debug is throwing an error.
• No subsystem
  • Renaming a folder changes aliased path to path relative to the baseUrl.
  • Directory rename removes aliases from directory imports.
  • Vue: stack overflow in resolve.

• Improved debugger performance.

• Code Insight
  • Pyrefly: false positive: 'Getter signature should be (self)'.
  • Concatenate not taken into account for variance inference.
  • Empty list literal collapses generic unification to 'Any'.
  • Passing 'None' to generic doesn't work.
  • Can't change type engine when looking at .pyi file.
• Jupyter
  • Markdown cell table alignment: Columns not aligning in Jupyter Notebook.
• LSP Tools
  • Python LSP plugin regression: Pyright and Ruff diagnostics not working after latest update on 2026.1.2.
• Restructured Text
  • Python code block in docstring does not render.

• IntelliSense (Code Completion)
  • Completion window width is not collapsing back if it was scrolled by mouse wheel.
• Live Templates
  • Templates Editor: "Choose Macro" dialog is not styled properly.
• Platform - VS Integration
  • Noticeable resizing of Alt-Enter submenus on non-main display with different scaling.
  • "Middle-click to scroll" locks cursor in hand mode for the file.
  • Visual Studio becomes topmost window after opening Find Results tool window.
• UI
  • AI Assistant tool window in VS 2026 doesn't draw the corners properly.
  • Wrong Test Pass Icon in Visual Studio 2026.
  • "Invisible" fluent icons on the R# settings page with dark theme in VS.
• XAML
  • Compiled bindings: adding x:DataType breaks the code analyzer.
  • MAUI Binding data source is not recognized by IntelliSense.

• Android Plugin
  • Running Release builds directly from within Rider causes the app to crash on launch due to missing symbols.
  • Error XA5300 : The Android SDK directory could not be found.
• Build
  • Rider doesn't rebuild/apply changes in referenced library when building a dependent project.
  • MAUI App Deployment: Failed to find application bundle after deployment.
  • Metadata file 'MauiApp7/MauiLib1/obj/Debug/net10.0-ios/ref/MauiLib1.dll' could not be found.
  • Fix failed MAUI solution build via Console because of APK file isn't found.
  • "Unable to evaluate the APK file path" error after building the solution.
• Code Analysis
  • 'and!' in task expression gives error in F# script.
  • Provided types from F# type provider are not detected.
• Quick Documentation
  • Quick documentation is not shown on hover (HtmlProvider)RIDER 135675 Issue not yet fixed.
• VCS - Git
  • Show diff preview on single click still available in settings of Commit tab.
• No subsystem
  • Inlay rename refactoring works slow with AI suggestions.

• Debugger
  • Added "Don't step into libs" option for debugger.
• Code Insight
  • Added support for const impl syntax and rait impl restriction syntax.
• Project model
  • Updated minimum supported version to 1.70.

• Code Insight
  • False positive 'Unnecessary cast' for 'None as Option&lt;*&gt;'.
  • False positive for self-import. Rework inspections for use {self as name} and use::{self as name}.
• Code insight. TOML
  • TOML incorrect autocomplete tail text for enums.
  • Completion in toml files other than Cargo.toml are duplicated.
• Project model
  • Updated minimum supported version to 1.70.

• Code: Highlighting and Inspections
  • Multiline TODO doesn't highlight any more in CLion 2026.1.
  • Nova: errors called from backend might be missing due to race condition.
• Debugger: Constexpr
  • Constexpr Dbg: CppCTRestartAction available in Debugger customization window.
  • Split debugger: no restart button in the Constexpr debugger when the debug session is finished/stopped.
• LLM / AI Assistant
  • CLion MCP server doesn't provide clangd diags.
  • CLion MCP: formatting toolset doesn't work.
  • CLion MCP server: SearchToolset.search_symbol doesn't work.
• Project and File Wizards
  • TAB doesn't reach 'Create associated header' and other checkboxes.

• 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.

• Code Parsing
  • Svelte: Quotes are marked as unclosed in a comment in the markup.
  • Quotes inside of an inline expression not recognized.
  • Svelte plugin parses in-attribute expressions incorrectly.
  • #await :then without a variable name marked as an error: "Identifier expected".
  • Valid Svelte syntax with regex, wrong syntax parsing in IDE.
• Intentions, Inspections
  • Svelte 5 named snippets warn with Unused Function Title.
  • Support reroute hook (don't mark as unused).
• Language injections
  • Weird input behaviour after SQL detection in a JS/TS literal and quoted strings.
  • Node.js interpreter and package manager.
  • Cannot enable "Coding assistance for Node.js".
• No subsystem
  • Svelte: special characters in text expressions cause "Unclosed string literal"/"Unexpected token".
  • Incorrect extensions matching and path building for exports field in package.json.
  • PsiInvalidElementAccessException: Element: class com.intellij.lang.javascript.psi.ecma6.impl.TypeScriptIndexedAccessTypeImpl; no psi for file stub JSFileStubImpl.
  • Vite plugin compatibility error with missing dependencies 'intellij.javascript.common'.

• Ruby. Debugger
  • RubyMine debugger is not able to skip non-project source files.

• Documentation
  • "What's new in PHPStorm" tab shows No content found for this page in 2026.1.3 RC.
• PHP Inspections
  • Getter/Setter can be replaced with hook: breaks with parent:: usage.
• PHP Quality Tools
  • PHPStan timeout / not analyzing individual files / not killing abandoned processes.
• Plugin: Psalm
  • Method return type described with array shape isn't parsed in @method annotation.

• AI Licensing
  • Added support for 'untrusted user' response.
  • Reworked 'AILicenseActivationStates'.
• XAML
  • Avalonia - added support for null conditional operator in bindings.

• AI Licensing
  • AI Enterprise from IDES is shown is AI Pro.
  • 'Start trial' action displays even after the expiration of AI Trial.
  • ToS for AI is shown twice.
• Command Line Tools
  • Running jb command tool causes multiple Roslyn exceptions.
• Licensing and Evaluation
  • DotTools do not auto-detect tbe server when user is logged in to IDEs through toolbox on Mac or Linux.
• Platform - VS Integration
  • Text is trimmed on non-main display with different scaling.
• Caches
  • Hang in 'CppLinkageEntityCache.FindEntitiesBySymbols'.
• Code Style - Formatter
  • Do not place the semicolon on a separate line in a do-while statement.
• Project Model
  • ClangCL toolset shouldn't be used when the toolset name is Clang.
• Unreal Engine - Blueprints
  • Hang in blueprints cache.

• Code Insight
  • Optimize find usages of a trait member.
  • RustRover freezes after removing a quote before large lazy_static! macro definition.
  • False Positive: errors from invalid parsing of comment starting with ////.
  • False positive E0070 "Invalid left-hand operand" for dereferenced &mut assignment.
  • False positive E0116/E0117 when type is also defined via include!() in build.rs - IDE resolves to build script crate.
  • False positive E0004 "match does not cover all possible cases" on Result with struct pattern and rest (..) syntax.
  • False positive E0658 "bool_to_result is unstable" - IDE resolves to nightly inherent method instead of in-scope trait method.
  • Broken type inference when if_let_guard syntax is used.
• Debugger
  • No "Remote Debug" in run/debug configuration template list.
• External Linter
  • Confusing red lines under the file name with running external linter on the fly option enabled.
• Project model
  • Enormous CPU usage with Rust plugin in IntelliJ IDEA 2025.3.3.