CLion Changelog

What's new in CLion 2024.1 Build 241.14494.288

Apr 10, 2024

2024.1 levels up the CMake editing experience, unlocks multi-processdebugging capabilities, assists with more accurate hardware descriptions in devicetree files, and brings significantly improved integration with version control systems.
CMake update:
Do you find editing CMake scripts challenging? With CLion 2024.1, you get enhanced writing assistance for CMake targets for even easier script editing. Now, CLion suggests live templates to create new targets, as well as code completion, navigation, and Find Usages for target names.
Debugging enhancements:
We’re constantly improving CLion’s integration with debugger backends. With this latest release, it’s possible to debug multiprocess targets in CLion. GDB users will now benefit from bundled support for the latest GDB 14.1 version. A new option was also added to boost GDB indexing, thus boosting debugging performance.
Meson support:
We continue to improve CLion’s Meson support. This 2024.1 version comes with a Meson tool window with many useful commands, custom settings for Meson, and the option to create new Meson projects from the New Project wizard in CLion.
Improvements for VCS:
VCS support in CLion and other JetBrains IDEs has been updated significantly with our enhanced diff viewer, improved branch search functionality, a streamlined code review workflow, and many other useful improvements throughout the whole subsystem
Live templates:
Do you need a new CMake target? New live templates have been added that automatically create add_executable (type exe) and add_library (type lib) CMake commands for you.
Target name completion:
CLion now completes target names in CMake commands. This makes it easier for you to link files to the targets and perform other target-related operations.
Navigation to target definitions:
Looking for a place where a certain target is defined? Now, CLion lets you navigate to the corresponding add_library or add_executable commands from the target usage in just one click.
Find Usages for targets:
Rely on Find Usages (Alt+F7) to list all usages of the target in your project. The items in the tool window will be sorted into usages and target definitions.
Minimum required version:
When CMake fails to load because you don’t have the minimum required version of CMake enabled, CLion suggests a fix in the CMake tool window. Click Fix... and CLion will update the cmake_minimum_required command for you.
CMake preset loading:
You can now configure which CMake preset types to import into CLion. For example, you can choose Configure option from the import list. To do so, use Settings/Preferences | Advanced Settings | CMake | Automatically import CMake Presets.
DEBUGGER:
Debugging forked processes:
In CLion, it’s now possible to debug multiprocess targets. Our latest release lets you update the follow and detach policies from the context menu. This works on Linux (with LLDB and GDB) and for remote toolchains (WSL, remote, and Docker).
Other debugger improvements:
CLion now bundles GDB 14.1. The presentation of the standard types that were initially broken with this version in CLion has now been fixed.
If you experience performance issues with GDB, try out a new setting. This works on Linux machines for executables launched from the IDE. When it is enabled, CLion prepares indexes for GDB before the debug session starts.
DEVICE TREE:
If you develop for hardware and write device tree files, you can benefit from the device tree file coding assistance in CLion that was added in v2023.3. In this new version, we improved the code analysis in device tree files and synchronized CMake with the Zephyr settings by default.
Property type checks:
To validate node properties with binding, there are new checks for invalid property types and required or undeclared properties.
Duplicate elements:
A Duplicate element inspection detects duplicate elements inside the device tree nodes. This could either be two or more properties with the same name or two or more nodes.
Enum value checks:
When an enumeration type is used, CLion validates the values for such properties and reports the unpermitted values.
Code completion:
To help you write device tree files, we’ve added code completion for the root node.
NEW TERMINAL BETA:
New terminal:
The new terminal (Beta) is now available in JetBrains IDEs v2024.1. You can switch between the old and new terminal in Settings/Preferences | Tools | Terminal | Enable New Terminal.
We expanded the feature set, improved the visual appearance, and aligned it with the IDE’s refreshed look and feel.
Each command is now placed in the terminal as a distinct block. They are separated visually so that you can easily detect the start and end of each one. Easily navigate between blocks using the arrow keys or switch the focus between the prompt and output with the Ctrl+↑ and Ctrl+↓ keyboard shortcuts.
Code completion with documentation for commands, paths, arguments, options, and more will help you launch your required tasks more quickly.
The command history is also available in the new Terminal tool window.
The color scheme used in the Terminal tool window was updated to increase readability.
VERSION CONTROL:
This release brings updates to VCS support in CLion, including:
In-editor code reviews for GitLab and GitHub repos.
CI status checks in the Git tool window.
Prevention of large file commits to repositories.
New Stash tab in the Commit tool window.
Option to exclude folders and files from comparisons.
And more!
OTHER ENHANCEMENTS:
The input stream redirection option, which was present only for the CMake Application run configuration, is now also available in C/C++ File run configurations.
The Assembly view was updated to improve presentation and UX:
The Assembly view for ARM targets is now shown correctly.
Assembly view settings are now applied immediately, with no need to manually click the Refresh button.
When you edit a file for which the Assembly view is opened, a hint is now shown to the user suggesting they refresh the preview.

New in CLion 2024.1 Build 241.14494.229 RC (Apr 1, 2024)

New in CLion 2024.1 Build 241.14494.154 Beta (Mar 25, 2024)

New in CLion 2024.1 Build 241.14494.27 EAP (Mar 11, 2024)

New in CLion 2024.1 Build 241.13688.39 EAP (Mar 6, 2024)

New in CLion 2024.1 Build 241.12662.59 EAP (Feb 26, 2024)

New in CLion 2024.1 Build 241.8102.118 EAP (Jan 21, 2024)

New in CLion 2023.3 Build 233.11799.171 RC (Dec 6, 2023)

New in CLion 2023.3 Build 233.11799.37 Beta (Nov 27, 2023)

New in CLion 2023.3 Build 233.11555.2 EAP (Nov 4, 2023)

New in CLion 2023.3 Build 233.11361.11 EAP (Oct 31, 2023)

New in CLion 2023.3 Build 233.10527.7 EAP (Oct 23, 2023)

New in CLion 2023.3 Build 233.9802.5 EAP (Oct 13, 2023)

New in CLion 2023.3 Build 233.8264.3 EAP (Oct 1, 2023)

New in CLion 2023.3 Build 233.6745.300 EAP (Sep 23, 2023)

New in CLion 2023.2 Build 232.8660.186 (Jul 28, 2023)

CLion 2023.2 reimagines PlatformIO integration, improves support for vcpkg, includes the AI Assistant feature, weaving it naturally into some of the core IDE user workflows, and improves the experience of low-level, remote, and embedded debugging.
KEY UPDATES:
AI Assistant Limited access:
CLion 2023.2 includes the AI Assistant feature, weaving it naturally into some of the core IDE user workflows. In C and C++, it explains the selected code, suggests how to better refactor that code fragment, or finds potential problems with it. It also generates commit messages and explains CMake errors.
Debugger update:
Low-level debugging is easier with CLion 2023.2, which brings the ability to inspect the registers of the current frame. You can also see register values inlined right in the disassembly view. A major update to the Attach to Process dialog enables attaching to remote and WSL processes.
PlatformIO integration:
PlatformIO is an open-source platform that helps embedded developers with their projects. CLion 2023.2 integrates natively with the platform. The IDE works directly with the platformio.ini file, tracking changes in it and updating the project information accordingly.
vcpkg integration:
vcpkg is one of the most widely adopted package managers in C++. When working with vcpkg, there are two approaches – Classic mode and Manifest mode. CLion 2023.2 supports both. You can clearly distinguish them in the CLion UI and switch easily to the Manifest mode using a dedicated button.
AI ASSISTANT:
Limited access:
The new 2023.2 versions of IntelliJ-based IDEs and .NET tools include a major new feature: AI Assistant. It’s still in the early stages of development, but you can already try our approach of weaving AI assistance into the core IDE user workflows and integrating deep AI features with code understanding. Learn more in our webhelp.
AI Assistant is not currently bundled with stable releases of JetBrains IDEs and can be installed as a separate plugin. For the time being, there is a waiting list for access to the AI Assistant feature.
Chat with AI Assistant:
AI Assistant prefers programming topics and benefits from project-specific context. Iterate in the new dedicated tool window, and when you’re happy with the result, use Insert Snippet at Caret to put the AI-generated code in the editor – or just copy it over manually.
AI Actions... menu:
Select a specific code fragment in the editor and invoke an action from the AI Actions... context menu.
AI Assistant can help you:
Find potential issues in a selected code fragment.
Suggest how to better refactor that fragment.
Explain the selected code.
Start a new AI chat about the selected code.
Commit message generation:
Let AI Assistant help you describe the changes you made. Clicking the Generate Commit Message with AI Assistant button in the commit message dialog will send the diffs of your changes to the LLM, and it will generate a commit message describing your changes.
Explain CMake errors:
When CMake execution fails on your project, click Explain with AI in the CMake tool window to get a better understanding of what’s gone wrong and how to fix it.
DEBUGGER:
Attach to Process dialog:
The Attach to Process dialog allows users to debug processes launched outside of CLion – locally or remotely – but also benefit from the IDE’s debugger integration.
From v2023.2 you can:
Attach to local, remote, and WSL processes.
Select any debugger configured in the toolchains.
Attach to processes launched remotely with administrative privileges.
Registers in debug:
Low-level debugging is easier when you have the ability to inspect the registers of the current frame. CLion now shows register values in the Variables tab of the debugger tool window.
ARM assembly:
CLion now supports ARM assembly languages, which means you’ll see code highlighting for ARM assemblers in the disassembly view.
Assembly registers in debug:
When debugging disassembly code, CLion now shows register values inlined right in the disassembly view.
Other debugger improvements:
CLion bundles LLDB v16 and GDB v13.1.
Memory View now supports on-the-fly memory editing and displays the value right after editing.
To improve debugging of external libraries for remote toolchains, CLion now correctly handles breakpoints set in them and downloads missing source files on demand.
EMBEDDED DEVELOPMENT:
Native integration with PlatformIO:
PlatformIO is an open-source platform that helps embedded developers with their projects. In CLion 2023.2, the intermediate CMake level was removed from the integration with PlatformIO. The IDE now works directly with the platformio.ini file, tracking changes in it and updating the project information accordingly.
Learn how to install the PlatformIO plugin and create a new project or open an existing one with it in our webhelp.
PlatformIO actions and tool window:
Some pio commands can now be invoked directly from the IDE (Tools | PlatformIO) – no need to switch to the terminal. This includes project reloading, running static code analysis on the project, invoking the device monitor, and more.
The PlatformIO tool window gives quick access to the most used commands and project actions.
vcpkg:
Manifest mode:
When working with vcpkg, there are two approaches – Classic mode and Manifest mode. You can now clearly distinguish them in the CLion UI and switch easily to the Manifest mode using a dedicated button.
Console tab:
To make vcpkg’s Classic mode more convenient, we added a Console tab to the vcpkg tool window to show all commands and output.
CMAKE:
Creating CMake targets when adding new files to a project
CLion 2023.2 improves the new C/C++ file creation dialog in cases when there is no CMake target to add the new file to. The new Add new target... action creates a new target and adds it to the selected CMakeLists.txt file. After adding a target, you can then add new files to it.
CMake 3.25 and 3.26 support:
CLion 2023.2 adds highlighting and completion for new parameters from CMake 3.25 and for the new block command used to execute a group of commands in a requested scope. In CLion, the new command is now highlighted, formatted, folded, and documented correctly.
CLion 2023.2 comes with CMake 3.26 bundled.
CMake Parameter Info:
The Parameter Info popup shows signature variants as you type and is now available for CMake commands. It helps you figure out which parameter to enter next, especially with commands that have multiple variants.
DOCKLER IN WSL:
If your project contains a Docker file with a Linux-based environment and you want to develop your application in it from a Windows machine, you can set this up in CLion using WSL and Docker.
TERMINAL IN THE OUTPUT CONSOLE:
Docker in WSL:
Terminal emulation in the output console is now enabled or disabled separately for each configuration. It’s disabled by default, and the setting that controls it has been moved from Advanced Settings to the Run Configuration section.
On Windows, it now works for MSVC LLDB-based debugging with both regular and administrative privileges.
USER EXPERIENCE:
Light theme with light header:
For v2023.2, we’ve refined the user experience with the Light theme by introducing the alternate Light with Light Header option, featuring matching light colors for window headers, tooltips, and notification balloons.
Pinned run configurations:
To make managing multiple run configurations easier, we’ve implemented the option to pin preferred configurations in the Run widget.
Updated window controls on macOS:
When working on macOS in full screen mode using the new UI, the window controls are now displayed right in the main toolbar – not in the floating bar as before.
Removed title bar on Linux:
For the convenience of Linux users, the native header of the operating system has been removed in the new UI, resulting in a cleaner interface. By default, you will now see the custom IDE header, which offers a range of customization options to tailor your workspace.
Colored project headers:
CLion introduces colored headers to simplify navigation between several open projects. You can now assign a unique color and icon to each of your projects, making it easier to distinguish between them in your workspace.
Main toolbar customization:
We’ve expanded the customization options for the new UI’s main toolbar. You can now use a dropdown menu to quickly choose actions that you want to add to the toolbar. To do so, right-click on any widget, select Add to Main Toolbar, and explore the available options.
Text search in Search Everywhere:
Search Everywhere is primarily used for searching through files, classes, methods, actions, and settings. With this update, it now includes text search capabilities similar to Find in Files.
OTHER ENHANCEMENTS:
CLion and other IntelliJ-based IDEs have introduced initial integration with GitLab in v2023.2, allowing you to work with the Merge Request functionality right from the IDE and streamline your development workflow.
On Windows, CLion now defaults to amd64 Visual Studio toolchain architecture on non-ARM machines instead of x86.

New in CLion 2023.2 Build 232.8660.139 RC (Jul 23, 2023)

New in CLion 2023.2 Build 232.8660.49 Beta (Jul 13, 2023)

New in CLion 2023.2 Build 232.8453.115 EAP 5 (Jul 6, 2023)

New in CLion 2023.2 Build 232.8296.18 EAP 4 (Jun 28, 2023)

New in CLion 2023.2 Build 232.7295.14 EAP (Jun 14, 2023)

New in CLion 2023.2 Build 232.6095.18 EAP (May 25, 2023)

New in CLion 2023.2 Build 232.5150.115 EAP (May 17, 2023)

New in CLion 2023.1 Build 231.8109.80 Beta (Mar 20, 2023)

New in CLion 2023.1 Build 231.8109.4 EAP (Mar 9, 2023)

New in CLion 2023.1 Build 231.7665.29 EAP (Mar 2, 2023)

New in CLion 2023.1 Build 231.6890.13 EAP (Feb 14, 2023)

New in CLion 2023.1 Build 231.5920.6 EAP (Jan 30, 2023)

New in CLion 2022.3 Build 223.7571.171 (Dec 5, 2022)

CLion 2022.3 provides better user experience across the board, from projects with only a couple C/C++ files to complex CMake-based applications. It also helps you adopt modern C++20 features and work in embedded and remote setups more productively.
CMAKE:
CMake Debugger:
Since CMake is a language of build systems, investigating errors and catching suspicious behavior in a CMake script is not always easy. With CLion 2022.3 you can now debug CMake scripts as regular code. Set breakpoints, step through code, and watch CMake variables and targets.
Code assistance in CMakeLists.txt:
The CMake file editor in CLion has been enhanced with new abilities to help you edit CMakeLists.txt files more easily. This includes:
CMake font and color settings, which you can find in Settings | Editor | Color Scheme | CMake.
The ability to expand and collapse various code regions in CMake.
Code completion for find_package for packages bundled with CMake.
CMake command documentation in code completion.
CMake structure view.
Strikethrough highlighting of deprecated commands in CMake.
Add to CMake Project:
When there is a file in your CMake-based project that doesn’t belong to any CMake target, CLion code assistance is limited in that file. A new Add to CMake Project quick-fix shown on the notification bar will help you add a file to the existing CMake target.
The action is also available in the project view context menu when called on the file.
CMake targets with root privileges:
If you add a CMake target as an extra task before starting the selected run/debug configuration, the target can now be run with administrative privileges.
C++20 MODULES:
Modules were introduced in C++20 to reduce many of the problems associated with the use of header files by isolating declarations and keeping their visibility limited to the module. There is also the hope that modules will be able to reduce compilation times in many cases. CLion 2022.3 provides module support to help you use this great language feature.
Syntax highlighting:
CLion collects and parses information about modules from all .ixx, .cppm, and .mxx files in the project. Then it provides syntax highlighting for the new module keywords like import, export, and module.
Completion:
CLion provides code completion for symbols from modules.
Navigation:
With CLion, you can navigate to declaration/definition for symbols from modules in one click.
Find Usages and refactoring:
Both Find Usages and refactoring work as usual inside modules.
An early version of the Rename, Change Signature, and Extract refactorings that cross module boundaries work only for files opened in CLion.
Single file:
If you have just one or two C++ files that you write code in and then want to compile and run, you no longer need CMake or another project model to open them in CLion. There is a new option to compile and run a single C or C++ file!
A new C/C++ File configuration:
A new run/debug configuration type (C/C++ File) allows you to quickly configure the toolchain, source files, and compilation options. When created, it allows you to compile and run the selected files.
Run icon:
When you open a C/C++ file or a folder via the Open action in the Welcome wizard, the run icon appears in the left gutter and allows you to run or debug the current file.
A C/C++ File configuration is required, and when missing, is created automatically when you click on the run icon.
When debug is selected, CLion automatically adds the required compiler flags for generating debug information (i.e. -g for GCC and Clang, or similar options for MSVC), so no changes in the configuration are required.
Linker scripts:
If you develop for embedded systems, chances are that you need to write linker scripts. CLion 2022.3 now comes with Linker Script (LD) language support, which includes:
Code highlighting in LD files, which you can configure in Settings | Editor | Color Scheme | LinkerScript.
Code completion.
Structure view for top-level commands.
Code folding for sections, memory, and phdrs.
Code commenting / uncommenting.
Find Usages for simple cases.
Clang-Tidy enhancements:
The Clang-Tidy binary was updated to v16.0.0 in this release, bringing new checks and various LLVM fixes.
The Clang-Tidy settings (Settings | Editor | Inspections | C/C++ | Static Analysis Tools | Clang-Tidy) were updated and the detailed documentation is now rendered on the left-hand side.
In the Clang-Tidy tooltip in the editor, click on the kebab (three dots) icon on the right-hand side and choose Show Inspection Description to get a short description of a Clang-Tidy check. Use the special Learn More link to navigate to the settings dialog and find out more details about the check.
DOCUMENTATION:
The size of the type:
The Quick Documentation popup now shows the size of the type. Similar to other inspections, this one uses the flags from the project model that CLion passes to Clangd. This allows the IDE to calculate the correct size even in cross-compilation cases.
Documentation at cppreference.com:
CLion can now help you learn more about the standard functions, structures, and other parts of your code base. Use the link in the Quick Documentation popup or the External documentation (Shift+F1) action to open cppreference.com articles in a web browser. This works for anything with a definition in the std namespace that is likely to have documentation there.
DEBUGGER:
The size of the type:
Function return value:
When you step out of a function that has a non-void return type, CLion now shows its return value in the debugger tool window’s Variables view.
On macOS and Linux, the bundled LLDB version has been updated to LLDB 15.
RTOS thread view:
When debugging with RTOS, CLion provides a view of tasks (threads). Starting with CLion 2022.3, this also works for Symmetric Multiprocessing (SMP) if the processor cores are identical.
In addition to FreeRTOS and Zephyr, the view has also been enabled for Azure RTOS.
New UI:
IntelliJ-based IDEs are receiving a new UI. Modern and clean, it aims to reduce visual complexity, provide easy access to essential features, and progressively disclose complex functionality as needed.
Tool windows and features specific to C and C++ are now ready for the new UI! Ready to give it a test drive? Switch to it in Settings | Appearance & Behavior | New UI.
Settings synchronization:
A new solution for synchronizing settings is now available in all IntelliJ-based IDEs, including CLion. The new Settings Sync plugin is capable of syncing all shareable settings from the platform, bundled plugins, and third-party plugins. The settings are stored in the cloud attached to the user’s JetBrains Account. If you use different IntelliJ-based IDEs associated with the same user account, your settings will be automatically synced.
Profiling:
When profiling on a remote or embedded target, you can now import the results locally in CLion via Run | Open Profiler Snapshot. Jump to Source navigation works correctly for profiling data and continues to do so after import/export.
Remote and WSL2:CLion now provides an alternative way to work with projects in WSL2 (Windows Subsystem for Linux 2) via remote development. Instead of running a full IDE on Windows, your IDE backend will launch directly in WSL2 itself. Then you can connect to it the same way you would connect to any remote machine when using remote development.
To improve the performance of remote development with local sources, CLion now uses pigz (a multithreaded gzip implementation) for compression on the remote host to synchronize the header search paths back to the local host.
For remote development with local sources, you can avoid the CMake build folder synchronization after CMake reload by selecting the Local or mounted folder deployment type in Settings | Build, Execution, Deployment | Deployment.
Other enhancements:
CLion now bundles all default web development plugins from WebStorm (NodeJS, Karma, AngularJS, and others).
IAR language extensions are now supported in CLion. The code is parsed and highlighted correctly.
With CLion 2022.3, we have started distributing installers for Windows ARM64. Native tools like Clangd are not yet ported to the platform, so installers only work for Windows 11, which is able to run both x64 and x86 binaries.

New in CLion 2022.3 Build 223.7571.59 EAP (Nov 21, 2022)

New in CLion 2022.3 Build 223.7571.12 EAP (Nov 14, 2022)

New in CLion 2022.3 Build 223.7126.6 EAP (Oct 22, 2022)

New in CLion 2022.2 Build 222.3345.126 (Aug 3, 2022)

New in CLion 2022.2 Build 222.3048.7 EAP (Jun 20, 2022)

New in CLion 2022.2 Build 222.2680.4 EAP (Jun 2, 2022)

New in CLion 2022.1 Build 221.5080.224 (Apr 14, 2022)

The CLion 2022.1 release is focused on quality improvements. It enhances existing workflows for remote development, Docker, CMake projects, and CUDA debugging, as well as addresses the most annoying bugs in code completion, inlay hints, and other subsystems.
Remote Development:
The new remote development workflow is now bundled into CLion and available from CLion’s Welcome screen. Use a powerful remote machine to execute all IDE operations and to build, run, and debug code – all while running the IDE on a local thin client.
Cloud dev environments featured in Space can now be used with CLion to speed-up onboarding, get a ready-to-use IDE in seconds, and manage your development resources efficiently. Learn more about Space dev environments.
Learn more about remote development with the thin client or consider the other types of remote configurations available in CLion.
Docker:
When working with the Docker toolchain, you can now provide additional container settings, such as port and volume bindings, and so on.
The Valgrind memcheck tool for detecting memory-usage problems now works with the Docker toolchain.
CMake:
CMake is a first-class citizen project model in CLion. Version 2022.1 addressed inconsistencies and lack of configuration abilities in the core areas of CMake support – CMake presets and CLion CMake profiles.
CMake Presets:
CLion now automatically creates CMake Profiles for configure presets (it was only available for build presets before). The change makes the configuration process easier and allows the removal of redundant build presets.
CLion now also works with the --preset argument passed to the cmake command. The data from the preset is loaded into build type, toolchain, and build directory settings.
CMake Profiles reloaded sequentially:
When the parallel reload of CMake profiles is not possible, CLion can now reload them sequentially. You can enable this behavior in Settings | Advanced Settings | CMake.
CMake Generators:
CMake generators are now easier to configure in CLion with the new and updated options:
Use default – for new projects, this option now takes the build tool configured for the toolchain selected in the corresponding CMake Profile.
Let CMake decide – this option means CLion won’t be favoring any CMake generator explicitly, meaning that CMake will decide what generator to use.
CMake Profiling:
In CLion, you can now visually inspect why it takes a long time to reload your CMake project. Starting with CMake 3.18, the new tracing can be enabled in the CMake settings. CLion will help you run the tracing and visualize the results. Learn more.
CMake Formatting:
CMake scripts are now formatted more accurately:
if() .. endif(), else() and elseif(), endforeach(), endfunction(), endmacro(), and endwhile() are aligned correctly.
It is now possible to fold blocks for these commands.
Brace pairing and code block highlighting are available for these commands as well.
Debugger:
CUDA debugger:
The CUDA-GDB debugger can now be used in CLion. To make it work, you’ll need to specify the cuda-gdb binary in the debugger setting of your current toolchain, and use the following compiler option:
add_compile_options(-G) to add CUDA debug symbols.
Debugger UI update:
In the layout settings of the debugger tool window there are two new options available:
Separate Watches: enables you to use a separate tab with watches.
Show Tab Labels: enables you to use debugger tool window tab names.
Hex values in debugger:
The option to show both decimal and hex values in the debugger now works for LLDB on Windows (Settings | Build, Execution, Deployment | Debugger | Data Views | C/C++ | Show integers as hex values and Display alongside the original value).
Embedded Development:
Embedded GDB Server:
The Embedded GDB Server configuration can now reset the device at different stages:
Before or after the download (i.e. flashing MCU ROM or writing to RAM).
Always (both before and after).
Or never.
Macros now work in Embedded GDB Server configuration fields.
FreeRTOS:
The FreeRTOS GCC/Posix port is now supported and enables FreeRTOS debugging on Linux.
Code Analysis:
With code analysis being a key part of the IDE, we’ve been working to make it more accurate and easier to configure, and to make its notifications more informative.
Preview for intention actions:
Intention action suggestions are available via Alt+Enter (alternatively, click the bulb icon). In the suggestions list, now you can also see a preview of the result of the selected action. The preview is available for De Morgan's laws, invert if condition, merge if-else, merge nested if, Clang-Tidy, MISRA, Clazy, split into declaration and assignment, split into separate declarations, and a few other actions. Learn more.
Updated Clang-Tidy and MISRA settings:
Clang-Tidy and MISRA settings in Settings | Editor | Inspections | C/C++ | Static Analysis Tools were reworked to make the checks configuration process easier. A new visual representation includes a tree with all the checks. Speed search helps you find the required checks quicker – just start typing the name you are looking for when the dialog is in focus.
For Clang-Tidy, the dialog also links to LLVM documentation to help you learn about the checks in more detail.
More accurate code analysis:
The accuracy of the code analysis engine in CLion was increased by addressing a selection of issues, for example:
Condition is always false/true checks now work correctly with types and narrowing conversion.
CLion no longer marks fields as unused if they have nontrivial destructors.
Inlay Hints:
Parameter and type hints in CLion are now more informative and accurate for modern C++ code.
CLion now displays a user-friendly wstring alias as a type hint for the std::basic_string type.
CLion now displays an accurate type hint for dependent types.
CLion 2022.1 added parameter info for struct literals and initializer list, as well as made parameter info more informative for the emplace, emplace_back/emplace_front, and make_unique/make_shared functions.
Hints for array indices can now be disabled if you don’t need them.
Formatter:
New formatter options for structured bindings were added to Spaces and Wrapping and Braces sections.
UX improvements:
Small but helpful UX improvements were introduced to make everyday IDE actions more convenient and powerful.
Namespaces in the New C++ Class dialog:
When creating a new C++ class, you can now specify the namespace where you’d like the new class to be located. You can write in any existing or nonexistent namespace (which will be created along with the new class), a nested namespace, or even an anonymous (unnamed) namespace if you enter a blank space in this field.
Grouping in the Structure view:
In the Structure view, elements can now be grouped by the qualified name. Select between grouped view or plain view with a fully qualified name included in each element name.
Rust:
A new stub project generator for Rust projects will help you even if you don’t have the Rust plugin installed. It will help you install the plugin and navigate you through project creation.
Other enhancements:
In the Toolchains settings (Settings | Build, Execution, Deployment | Toolchains) you can now configure any build tool to be used with a toolchain, such as Make, Ninja, or others.
For library files, CLion no longer shows the This file does not belong to any project target notification.
Incorrect Clang-Tidy results that used to occur when the WSL toolchain was used are now fixed by executing Clang-Tidy inside WSL itself.

New in CLion 2022.1 Build 221.5080.93 Beta (Apr 5, 2022)

New in CLion 2022.1 Build 221.5080.52 EAP (Mar 31, 2022)

New in CLion 2022.1 Build 221.4906.7 EAP (Mar 14, 2022)

New in CLion 2022.1 Build 221.4165.77 EAP (Feb 14, 2022)

New in CLion 2022.1 Build 221.3427.90 EAP (Jan 31, 2022)

New in CLion 2021.3 Build 213.5744.123 RC (Nov 22, 2021)

New in CLion 2021.3 Build 213.5744.5 Beta (Nov 16, 2021)

New in CLion 2021.3 Build 213.5605.4 EAP (Nov 5, 2021)

New in CLion 2021.3 Build 213.3714.446 EAP (Sep 27, 2021)

New in CLion 2021.2 BUild 212.4746.93 (Aug 24, 2021)

CMAKE SUPPORT:
CMake 3.20 is supported and bundled in CLion 2021.2. This version includes CMake Presets, major updates to the CMake File API, support for C++23 compiler modes, and many updates for CUDA developers.
CMake Presets:
Store your project build configuration in new and universal CMake Presets, and CLion will automatically detect and import the necessary CMake Build Presets.
It will notify you and suggest reloading the presets if any changes are introduced to them, either in the editor or externally.
You can manage the imported presets in Settings | Build, Execution, Deployment | CMake.
New CMake project templates:
Additional templates for creating new CMake projects are available in the New Project wizard. They cover C and C++ libraries and executables, CUDA libraries and executables, and Qt projects.
You can find and edit the templates in Settings | Editor | File and Code Templates | Other.
CMake target in configurations
CMake targets as Before Launch tasks:
In the Before Launch section of the Run/Debug configuration, users can now specify CMake Target tasks, both built-in and user-specified. These tasks will be performed before starting the selected target.
Makefile projects:
GNU Autotools:
Support for GNU Autotools:
CLion now automatically detects GNU Autotools, Kbuild, and PERL MakeMaker projects. When these projects are loaded as Makefile projects, CLion automatically detects preconfiguration scripts and executes them to get the Makefile and load the project from it.
CLion 2021.2 detects whether the project has any configure.ac or configure scripts required to create its Makefile. On project load, CLion executes these preconfiguration steps automatically by using the command set in Settings | Build, Execution, Deployment | Makefile settings.
Load Makefile Project:
Load Makefile Project action:
If you open a project in CLion without loading the Makefile project model, you can still load it later. This might happen if your project requires some custom preconfiguration steps and no final Makefile is available until those steps are finished. To load it, call the context menu on the project's top-level Makefile and select Load Makefile Project.
Natvis support:
Windows: better Natvis support:
When you use the Microsoft Visual C++ toolchain on Windows, CLion provides its own LLDB-based debugger. Data rendering in this debugger was improved in v2021.2:
Natvis customization features such as Inheritable attribute, format specifiers, and CustomListItems are now supported.
Built-in renderers were improved by adding one-line colored summaries for all structures not covered by Natvis, enabling formatting for wide/Unicode strings, and showing the [Raw View] for Natvis-generated values.
Minidumps:
Windows: minidumps debug:
Postmortem debugging with core dumps is now supported on Windows. Use the Run | Open Core Dump action to start a core dump debug session.
External Console
Windows: Run in external console:
Instead of the internal console used by CLion, on Windows, it’s now possible to switch to the cmd.exe console to run and debug applications. Use the Run in external console checkbox in Run/Debug configuration to change the behavior.
Relaxed breakpoints:
There are cases with breakpoints when path mappings are too complex to fill them in in the debug configuration, or when the -fdebug-prefix-map option is set in the debugger. In these situations, it's now possible to use just the file name instead of its absolute path during debugging sessions.
Breakpoints in disassembly view:
While stepping through assembly code, you can now add/remove breakpoints on instruction lines. For non-default configuration of these address breakpoints, use the right-click context menu menu.
Preview tab for Debugger:
To avoid cluttering the editor with many tabs during stepping, consider enabling the preview tab. In CLion 2021.2 it works during debug sessions and allows you to view files in a single tab one by one, without opening each file in a new tab.
Remote LLDB:
Remote LLDB and LLDB 12:
To improve debugging with LLDB, LLDB v12.0 is now bundled. Remote debugging of any arbitrary executable from CLion is now possible with LLDB (in addition to GDB). Use the new Remote Debug configuration to provide arguments to connect to the remote host. On a remote host, you'll need to launch lldb-server/debugserver. Check out our web help for more details.
FreeRTOS thread view:
If you debug applications with FreeRTOS in CLion, a view with the task lists is now available. You can switch to the task you are interested in to explore task variables and more.
Code Analysis:
Diagnose common cases of dangling pointers and escaping from a local scope by using static analysis. This capability is made possible by the Lifetime Safety proposal that CLion has partially implemented. GSL annotations are also supported to let you mark your code and make local analysis more accurate.
Cling interpreter:
Cling:
Cling is an interactive C++ interpreter built on top of Clang and LLVM. It allows you to run code without building the project, which can be especially useful for prototyping and learning C++.
Install Cling on your system and benefit from its integration with CLion:
Start a new Cling session.
Send included headers or selection to Cling.
Send the current line to the Cling session via the code intention.
Remote and WSL:
Profiling in remote mode and on WSL:
Profiling is now possible in remote mode and on WSL. In both cases, the Perf backend is required. Find the instructions in our web help on how to install the Perf tool for your particular kernel release.
You'll also need to configure the path to the Perf tool in CLion Settings | Build, Execution, Deployment | Dynamic Analysis Tools | Perf.
Docker:
Remote development in Docker:
For Docker containers with mapped volumes, remote development without source synchronization is now available in CLion. This mode removes the code duplication and the initial project upload step. Learn how to configure this mode in Docker and in CLion.
WSL configuration:
WSL configuration in CLion has become much easier, as you no longer need an SSH server inside a WSL distribution to work with WSL in CLion. CLion now uses a dedicated WSL API.
CLion now supports WSL whether it's installed from the Microsoft Store or a custom distribution.
Text search in Local History:
Local History:
Text search through file revisions in Local History appeared in CLion 2021.2, helping you locate the point you want to roll back to more easily.
VCS
Pre-commit actions
Changes to pre-commit checks
In v2021.2, we expanded the list of possible pre-commit actions with the ability to execute tests. Tick the Run Tests checkbox and select the configuration to run.
We also added the ability to customize the Analyze code and Cleanup options by clicking Choose profile next to them.
Unified Show Diff:
CLion shows the difference between the initial and changed files in the editor by default, no matter where you invoke the Show Diff action. If you prefer to track changes in a separate window, simply drag the desired file outside the editor.
GPG signature:
CLion 2021.2 offers a way to secure your commits. To enable Git commit signing with GPG, go to Settings | Version Control | Git, click Configure GPG Key, and then select it from the drop-down list.
Toolbox App:
Toolbox update:
Do you use the Toolbox App to manage CLion installations and updates? Now you won't miss any critical product updates from it. Your IDE will alert you if there is a new version available for download and give you the option to upgrade right from CLion.
Localized UI:
You can now enjoy the CLion UI in Chinese, Korean, and Japanese. The fully localized UIs are available as non-bundled language pack plugins, which can be installed in CLion from Settings | Plugins.
Other enhancements:
Some other useful improvements and enhancements in CLion 2021.2 include:
If you want certain operations to be performed on Save, you can now configure them all in one place, in Settings | Tools | Actions on Save.
It is now easier to reorganize tool windows. Hover over the top of the tool window you want to move, then drag it to where you want it and drop it there.
IntelliJ Rust introduced a new name resolution engine and initial WSL support. The plugin is now also capable of expanding certain procedural macros.