The CLion Roadmap: What’s Coming Between Now and Late 2026

This blog post covers the updates we plan to introduce over the next four months in the upcoming minor releases (2026.2.x) and the next stable release (2026.3).

After reviewing your feedback and our strategic goals, we’ve decided to focus on improving agentic workflows, embedded development support, and the debugger. Here are some of the highlights:

AI skill for HardFault debugging.

Debug profiles: JSON configuration support and a customized TRACE32 profile.

LLDB 21 support for Windows.

Support for QNX projects.

Read on for the full list of planned updates.

Our team is committed to delivering an IDE that makes development smooth and productive. The roadmap below is preliminary, and we can’t guarantee that every issue or feature listed will be addressed or implemented in CLion 2026.2. Priorities may shift, and unexpected circumstances could require us to adjust our plans or timelines.

AI features

In the last release, we improved the agentic workflow for general debugging with a new skill. Next, we want to extend agentic debugging capabilities for embedded developers. We also plan to make it easier to set up a project with agent assistance, which can be especially helpful for those just getting started with CLion.

HardFault debugging skill

A hard fault occurs when an ARM Cortex-M MCU encounters a serious runtime error that it cannot recover from. Common errors include jumping to an invalid address, stack overflow, and dereferencing a bad pointer. HardFault_Handler can usually catch a hard fault, but it tells you nothing about what actually faulted. Debugging a hard fault means inspecting the CPU state at the moment of the crash, including registers, stack frame, fault status registers, and sometimes disassembly.

We want to let agents handle this for you.

Since the MCP debugging feature was introduced in the previous release, we’ve continued improving agentic debugging in CLion by adding more skills and exposing more IDE tools to agents. The new skill, planned for a future minor release, will be tailored specifically for embedded systems prone to hard faults. To support this, agents will have access to additional tools to enable more effective debugging of C and C++ code – including in embedded projects. Agents will have access to memory, register, and disassembly views alongside the already available stepping, breakpoints, and more. This skill will make it easier to develop and validate embedded projects with real hardware attached.

Agent-assisted project setup

There are several reasons why setting up a project in CLion may fail, ranging from a build system misconfiguration to missing toolchain components. For some highly customized projects, it may not be easy to investigate the root cause, even with the built-in IDE assistance. To fix configuration issues more quickly, CLion will offer your agent’s help. Once an issue occurs, the IDE will identify which agents you have installed, offer to pick one you prefer, and launch it in the terminal. The bundled skill will direct the agent to the required IDE tools to handle setup issues faster.

Debugger

Many of the planned debugger updates focus on embedded development workflows involving the DAP integration and debug profiles. We’ll also add support for LLDB 21 for Windows and update GDB for all platforms.

Debugger updates for embedded development

DAP support

Since we added support for the Debug Adapter Protocol (DAP) last year, we’ve been extending its capabilities. Embedded development will be the focus for the next DAP-related updates. Among those are support for the peripheral view, as well as debugging RTOS threads and FreeRTOS objects.

Debug profiles

JSON configuration: With debug profiles introduced in CLion 2026.2, configuring and switching debuggers is now much easier and more straightforward. For the next release, we want profiles to become more flexible, configurable for broader use cases, and with more options. We’ll add the ability to save a debug profile as a JSON file and to configure it manually or with the help of an AI agent. This will provide you with more configuration options than CLion’s UI currently exposes. You’ll also be able to import your existing JSON debug configuration, for example, from VS Code, so you get the same debugger settings in CLion without the need to reconfigure everything from scratch. This flexibility will be especially beneficial for embedded and agentic development.

Customized profile for Lauterbach TRACE32: Currently, configuring the TRACE32 debugger requires a generic DAP profile, which may not be convenient for everyone. We plan to add a debug profile template specifically designed for TRACE32, with customized fields and options to simplify configuration.

Moving embedded run configurations to debug profiles: Having separate run configuration templates, such as Embedded GDB Server or OpenOCD Download & Run, with debug profiles is redundant and may be confusing. Our plan is to move the necessary configuration options to embedded-related debug profiles so that you have all the required settings in one place.

General debugger updates

LLDB 21 support for Windows: Currently, the only LLDB-based debugger available for Windows is the JetBrains fork of LLDB for the MSVC toolchain, tuned for PDB and Natvis. However, we understand that some CLion users would prefer to use a newer LLDB version, and we want to give them that option.

In the next stable release, we plan to add LLDB 21 support for Windows. MSVC toolchain users will be able to select this option in the debug profile settings – the IDE will suggest downloading the LLDB 21 build. The PDB and Natvis optimizations from the old bundled LLDB will carry over to the new one. The old bundled LLDB will also remain available as a separate selectable option.

Bundled GDB will be updated to v17.2 for all platforms.

CMake / Debug Profiles switcher improvements: We want to improve the UI of the profile switcher in the main toolbar. The goal is to make it easier to detect problems in CMake and debug profile configurations by adding helpful notifications. For example, when a selected debug profile is incompatible with an active CMake profile, you’ll see a warning in the switcher’s UI, and hovering over it will show a tooltip with a detailed explanation.

Embedded development: Support for QNX projects

QNX is a Unix-like real-time operating system used mostly in embedded, safety-critical systems. Today, there’s no built-in support for QNX in CLion. For example, the IDE doesn’t fully support QNX’s QCC compiler, so files often aren’t indexed correctly and developers lose code assistance.

We want to make CLion a solid tool for QNX development, providing essential IDE functionality. This includes support for the QCC compiler and the x86-64 and AArch64 target architectures, a dedicated debug profile, and agent-assisted configuration and debugging.

Build tools and project formats

We’re going to focus on improving code insight for projects with unsupported build systems.

Default resolve configuration: CLion resolves your code and provides smart features by relying on project-level information from your toolchain configuration. Currently, if you add a new file to your project but don’t update the toolchain configuration file accordingly – for example, CMakeLists.txt – CLion might not resolve the code in this file correctly. This means you don’t get proper highlighting, auto-completion, inspections, and other smart features. In other cases, a new file may never need to be part of your project at all – for instance, a header you’re just viewing – but you’d still benefit from smart features while working in it. For such cases, we want CLion to find an appropriate resolve configuration from the available toolchains and use it as the default one. If no such configuration exists, the IDE can use the toolchain from PATH. This mechanism will allow CLion to provide smart features for files outside your project configuration in most cases.

Bundled CMake will be updated to v4.4.2.

Language updates: Support for ISPC

ISPC (Intel SPMD Program Compiler) is a C-based language and compiler for writing high-performance parallel code that runs on the SIMD vector units in CPUs and GPUs. It is often used in performance-critical C/C++ codebases, such as physics simulations, rendering, and game engines.

CLion doesn’t currently recognize .ispc files, so mixed ISPC/C++ codebases lose code insight features on the ISPC parts. For the next release, we plan to add support for ISPC, including proper syntax highlighting, code analysis, and completion (CPP-23363).

Performance, stability, and decluttering

For the next release, we’re also focusing on maintenance – improving CLion’s performance, stability, and user experience.

IDE responsiveness: Several users have reported UI freezes and long indexing times in certain workflows and project configurations. We’re actively working on these issues and plan to improve IDE responsiveness by v2026.3.

Last stable version of the Classic engine: In v2026.2, we unbundled our legacy language engine, CLion Classic, and moved it to a separate plugin. This was another step in the transition to the new, more powerful CLion Nova engine, which is now the default. As announced in our blog, in v2026.3, we’ll release the last stable version of the Classic plugin compatible with the IDE. This will allow us to allocate more resources to Nova development and improvement. If your team still depends on Classic-specific behavior or workflows, please contact your customer success engineer, account manager, or our support team.

Unbundling the JavaScript and TypeScript plugin: Based on our internal statistics, almost no CLion users have used JavaScript or TypeScript support in their projects in recent years. Maintaining this built-in support requires resources and increases the CLion package size, with little benefit to most users. Therefore, we’re going to unbundle the JavaScript and TypeScript plugin in v2026.3.

If you do need JavaScript or TypeScript support, you’ll still be able to install the plugin via Settings | Plugins | Marketplace or from the JetBrains website.

Improvements to Dev Container support: We’re investing in Dev Container integration as CLion’s primary approach to container-based development and refining its current support. The goal is to make it easier to configure and expand what it can do.

Conclusion

The Early Access Program is just around the corner and will give you the chance to try all of the new features planned for the next major release for free. In the meantime, upgrade to CLion 2026.2 if you haven’t already done so, and let us know what you think!

DOWNLOAD CLION