[News](https://blog.jetbrains.com/clion/category/news/)
[Releases](https://blog.jetbrains.com/clion/category/releases/)
With JetBrains Air, agent-assisted embedded debugging and CMake project setup, plus support for NVIDIA CUDA Tile C++ and ISPC.
CLion 2026.3 is now available. This latest version of the JetBrains IDE for C and C++ includes the following key features:
- [JetBrains Air,](#jetbrains-air-one-place-to-run-your-agents-and-verify-their-work) a new layer for agentic development in JetBrains IDEs.
- [Agentic debugging of hard faults](#agentic-debugging-of-hard-faults) .
- [Agent-assisted CMake project configuration](#agent-assisted-cmake-project-configuration) .
- [Support for NVIDIA CUDA Tile C++](#support-for-nvidia-cuda-tile-c) .
You can download CLion 2026.3 from the link below, via the Toolbox App, as a snap package if you’re using Ubuntu, or apply a patch update from the 2026.2 version.
JetBrains Air – one place to run your agents and verify their work #
As of this release, JetBrains IDEs ship with Air, a new layer for agentic development. Run, track, and verify multi-agent workflows inside your IDE, where code intelligence guides agents away from common pitfalls and integrated review tools let you inspect every change before it lands in your codebase.
Your agents, your models, your subscriptions – with Junie Lite for free
Air works with Claude Agent, Codex, Gemini, GitHub Copilot, Junie, OpenCode, and other ACP-compatible agents. It automatically detects agents already installed on your machine so you can connect them in a click, and you can add more from the agent registry, too.
Your existing workflows carry over seamlessly: Provider subscriptions, API keys, and custom base URLs all work, with no JetBrains AI subscription required. Run Claude Agent on your Claude subscription in the terminal or in a full-screen IDE tab, work with other agents in the chat or terminal, and switch between subscriptions at any moment, even mid-session.
To help you get started without an external subscription, Air includes free AI with Junie Lite out of the box. All you need is a JetBrains Account.
A central workspace to review changes and guide the agent
Review an agent’s changes with the surrounding code and your project tools in view, and send feedback straight back to the agent. Anchor notes to specific lines in the diff, or comment directly from the editor to give the agent concrete context for adjustments. Work in the chat or the terminal, whichever suits you.
If you use AI Assistant, CLion will offer you a trial of Air. Activating Air hides AI Assistant (you can switch back at any time by following these steps*). Air automatically migrates your IDE skills, MCP configuration, agents installed through ACP, credentials, and regular chat history.* Chat mode history isn’t migrated.
Agentic debugging of hard faults #
A hard fault on an ARM Cortex-M chip signals that something went wrong, but rarely explains why. Diagnosing the root cause takes manually decoding the fault status registers, matching the faulting program counter against disassembly, and often reproducing the crash several times.
CLion now automates this investigation work through dedicated MCP tooling and a bundled AI skill. Your agent inspects fault registers, memory, and disassembly to trace the problem to its source using the same debugger tools you would.
This workflow supports Lauterbach TRACE32, SEGGER J-Link, ST-LINK, and other debug probes, as well as any agent connected to the IDE’s MCP server. Learn more in our blog post.
Agent-assisted CMake project configuration #
A new CMake project can fail to load due to a misconfigured profile or a missing toolchain component, and identifying the cause can take time.
When a CMake load fails, CLion now shows a notification with a Configure with [agent] button. Select one of your installed terminal agents, such as Claude Code, Codex, or Junie, and the IDE opens its terminal with a ready-made prompt.
The agent interacts with CLion’s MCP server to diagnose the problem, update your CMake profiles and toolchains, and reload the project.
Debugger #
JSON configuration for debug profiles
Until now, debug profiles could only be configured through the CLion UI. This wasn’t flexible enough, as you couldn’t edit a profile as a file, copy one from documentation, or generate settings.
The IDE now stores debug profiles in JSON, for example, in .idea/debug-profiles.json for shared profiles. You can continue configuring profiles in the UI, or choose Configure Profile in .json to edit them right in the editor, with JSON schema validation and code completion.
CLion reloads the file automatically when you or your agent modifies it. The IDE also retains settings it doesn’t recognize, such as those for a different setup or a disabled plugin, so you don’t lose them.
Dedicated debug profile for Lauterbach TRACE32
Configuring the TRACE32 debugger in CLion previously required a generic DAP profile, and you had to enter every attach parameter yourself. There was no launch mode, and some TRACE32-specific options were unsupported.
CLion now provides a dedicated TRACE32 debug profile. Based on the DAP, it comes with launch and attach parameters prefilled with TRACE32 values, so you only need to add the values specific to your target and project.
The profile supports both launching a debug session from the IDE and attaching to an active session via the t32debugadapter that ships with TRACE32. CLion also supports TRACE32 memory access qualifiers in the Memory View tab and provides syntax highlighting for PRACTICE scripts.
Improvements to DAP support
Previously, CLion always started a DAP debugger in the same default directory and with the same toolchain environment. If your debugger needed a different directory or its own environment variables, you couldn’t configure this in the profile.
DAP debug profiles now come with Working directory and Environment variables fields in the Advanced section, configurable either via the UI or directly in debug-profiles.json.
RTOS objects for AI agents
In the previous release, we introduced the MCP tooling that provides agents with essential debugging features, such as starting and stopping debug sessions and setting breakpoints. It also covers tools specific to embedded development: the memory map, disassembly view, and peripheral registers.
CLion 2026.3 adds RTOS tasks, queues, and timers to the toolset so agents can inspect them during a debug session. A bundled skill tells the agent when to use these tools.
To see how RTOS debugging works in the IDE, read the RTOS debugging documentation.
C/C++ language engine #
Support for NVIDIA CUDA Tile C++
NVIDIA CUDA Tile C++ introduces a tile-based programming model for GPU code. It lets you write GPU kernels at the level of an entire tile of data rather than manually coordinating individual GPU threads. Although CLion already supported CUDA C/C++, the IDE didn’t recognize CUDA Tile C++ syntax.
CLion is now among the first C++ IDEs to support CUDA Tile C++. It understands the new syntax and highlights tile-specific code issues as you type, such as unsupported control flow or a non-positive irange step.
The support works for projects targeting C++20 and CUDA Toolkit 13.3 or later.
Other improvements to CUDA support include:
- Execution spaces : CLion checks whether a function can be called from the CUDA execution space of the calling code, following the rules of the CUDA Programming Guide. The check takes into account
__CUDA_ARCH__guards, CUDA runtime API functions, C library functions available in device code (such asprintfandmalloc), and calls to overloaded operators. - Memory spaces : New inspections detect invalid uses of the
__device__,__constant__,__shared__,__managed__, and__grid_constant__specifiers. Examples include memory space specifiers on data members or function parameters, initializers on__shared__variables, and conflicting specifiers.
Class memory layout visualization
How a class is laid out in memory determines how much space each object takes, how well its data fits into CPU cache lines, and whether it matches a binary format or an ABI shared with other code. To satisfy alignment requirements, the compiler silently inserts padding between fields. As a result, a class can end up noticeably larger than the sum of its members, which adds up quickly for objects that are allocated in large numbers or processed in tight loops.
The new Class Layout tool window visualizes the memory layout of a class, struct, or union. It displays the offset and size of every field and bit-field, base class subobjects, virtual table pointers, and the padding between them.
This makes it easy to spot redundant padding, check the effect of alignas or #pragma pack, and inspect the layout of classes in a complex hierarchy. To open it, press ⌥↩︎ on macOS (Alt+Enter on Windows/Linux) on a type or its usage, and then select Class Layout.
Support for ISPC
The Intel SPMD Program Compiler (ISPC) is a C-based language and compiler for writing high-performance parallel code that runs on the SIMD vector units in CPUs and supported Intel GPUs. It’s often used in performance-critical C/C++ codebases, such as physics simulations, rendering, and game engines.
CLion now supports ISPC syntax, including core constructs such as uniform, varying, and foreach. The IDE delivers code completion, navigation, and on-the-fly error highlighting.
For CMake projects that enable the ISPC language, CLion detects the ISPC compiler and reads its include paths and macros.
Code insight without a build system
Previously, when you opened a folder of single files, or your CMake project had no targets, CLion couldn’t find the standard headers. Code highlighting, inspections, and code completion worked incorrectly or didn’t work at all. The editor showed false errors.
CLion now automatically retrieves the headers and macros from the C and C++ compilers of your default toolchain. Code insight works right away. When your build system provides its own settings, CLion switches to them instead.
Last update for the Classic engine
In CLion 2026.2, the legacy Classic engine moved from the IDE bundle to an optional plugin. Following the transition timeline, the Classic version compatible with CLion 2026.3 is the last stable release, and updates end in November 2026.
If you still need Classic, install the *C/C++ Language Support via Classic Engine* plugin from *Settings | Plugins | Marketplace* or from [JetBrains Marketplace](https://plugins.jetbrains.com/plugin/32355-c-c--language-support-via-classic-engine). If something prevents you from moving to the default CLion Nova engine, please [contact our Support team](mailto:clion-support@jetbrains.com).
If your team depends on Classic-specific behavior or workflows, contact your customer success engineer or account manager. We’ll work with you to understand your obstacles and plan the transition. If you’re unsure whom to contact, please use our [enterprise customer contact form](https://www.jetbrains.com/support/enterprise-support/contact/).
Git worktrees for parallel work and easy code reviews #
CLion can now automatically replicate your local project configuration into new Git worktrees, including run configurations and other settings stored in .idea. You no longer need to commit those settings to Git or recreate them for each worktree. You can also specify local and ignored files in .worktreeinclude for the IDE to transfer, and configure a custom script to run when a worktree is created, for example, to install dependencies.
Additional worktree improvements include:
- Support for multi-root projects.
- More reliable worktree creation in repositories with submodules.
- The option to check out a branch that is already in use in another worktree, using
--ignore-other-worktrees. - Automatic cleanup of deleted worktrees from Recent Projects .
- Improved support for WSL and container-based projects.
Try CLion and tell us what you think #
We invite you to try CLion 2026.3. If you have an active subscription, you can update it right away. New to CLion? You can use the IDE for free on non-commercial or educational projects. Otherwise, just start a free 30-day trial to access all the latest features and improvements.
We value your feedback! If you have anything to share or if you run into any problems, please let us know in the comments below, on X, or via our issue tracker.