What's New in CLion
CLion 2023.1 brings a solution for package management, gets your debugging experience to a new level, helps with QML coding, and includes a host of improvements for the new UI, which has been overhauled based on the valuable feedback we’ve received from our users.
Key updates
Debugger update
CLion debugger integration got a major update bringing you powerful debugging abilities that include:
- The ability to explore the underlying assembly code even when the source code is available (aka disassemble on demand).
- A reworked Attach to Process... dialog to make finding processes and attaching to them even easier and faster.
- Actions to suspend or resume individual threads, to help debug multithreaded applications.
Integration with vcpkg
vcpkg is a package manager that’s growing in popularity among C++ developers. CLion now integrates with it, assisting with installing and updating vcpkg and its packages and browsing installed and available packages in the dedicated tool window.
CLion helps with the missing dependencies by suggesting quick-fixes when you:
-
add
#includefor the header file from a package that is not yet installed. - use a package in a CMake script that is not yet installed.
Clangd-based indexer
Experimental
To speed up the Find Usages action and make it produce more accurate results in C++ code, a brand-new Clangd indexer was introduced in CLion. Enable it in Settings/Preferences | Advanced Settings | Clangd | Use Clangd-based indexer.
Note that the indexer is still in its early stage of development and is considered experimental. Check out the online help for the list of known issues and limitations.
New UI
Beta
The new UI has less visual clutter and shows the starting points for powerful features more concisely. In v2023.1, we’ve fine-tuned the user experience of the new UI by redesigning the Run widget, adding an option to show hidden tabs and an option to split tool windows vertically, bringing a new Compact Mode for smaller screens, and other changes.
Debugger enhancements
Disassemble on demand
CLion debugger allows you to step into and debug the disassembled code in a dedicated view. Now even when the source code is available.
In the context menu in the frames view, there is now a new action that opens a regular disassembly view for the selected frame. The view opens side-by-side with the source code and highlights the execution line in both.
Read about known issues and limitations.
Attaching to processes in debug
CLion provides a way to attach the debugger to local processes started outside the IDE. The updated Attach to Process... action’s dialog now makes finding processes and attaching to them even easier and faster.
Display all available processes as a list or a tree in a new table view, check out the name of the user who launched the process, the debuggers available for this process, and the command used to launch the process, and select a debugger for toolchains that support multiple debuggers. Find out more.
Suspend or resume individual threads
When debugging a multithreaded application, step through the selected thread with all other threads suspended. To achieve that, use the Freeze/Unfreeze actions in the context menu in the thread view of the debugger or in the Run | Debugging Actions menu.
- All 4 actions are available with LLDB.
- For GDB, only Freeze Other Threads and Unfreeze All Threads work. These actions also are not supported on Windows for GDB.
Memory View
Memory View provided by CLion got a massive update, with many issues fixed and the overall user experience enhanced.
Highlighting the changes
CLion now highlights all changed bytes in the memory view during debugging. Also, when scrolling through the memory view, CLion now automatically loads the data.
Configurable view
The number of columns in the Memory View (i.e., the number of bytes per line) is configurable now. Click on the settings icon in the view to change it.
C++ language support
Adding a new C++20 module
CLion 2023.1 adds an action to help you create a new C++ Module Interface Unit in your project.
In the dialog that opens, enter the module name and type (extension), and specify whether you want CLion to add the newly created module to the existing CMake target. CLion will create a new module file using the file template from Settings/Preferences | Editor | File and Code Templates.
More flexible refactorings
The Change Signature and Extract Function refactorings now support making
a function const, constexpr, or noexcept.
The Extract Constant refactoring now suggests declaring a new constant with
the constexpr and auto specifiers.
Easier Clang-Tidy configuration
CLion 2023.1 comes with an updated Clang-Tidy checks options dialog:
- All options are now displayed with predefined default values.
- If you change an option, it is highlighted in blue and moved to the top of the table.
- Speed search is available: Simply put the table in focus and start typing the name of the check you’re looking for.
Support for QML
QML syntax support
If you are using Qt Modeling Language (QML) in your code, you will now benefit from the QML syntax support in CLion. This includes:
- A better editing experience with code highlighting and code completion.
- Instant search for usages.
- Structure View for easier navigation in QML files.
- The Quick Documentation popup for information about the symbols under the caret.
QML formatter and other settings
QML syntax support in CLion works for both Qt5 and Qt6. CLion uses qmlformat to format QML code by default.
Qt and QML paths, qmlformat as a formatting tool, and QML language server can be configured in Settings/Preferences | Languages & Frameworks | QML.
Filtering abilities in Profiling and Coverage
Filtering Call Tree results in the profiler
The Call Tree tab in the profiling results now allows you to collapse any frames you’re not interested in. For example, you can hide library classes or classes from specific frameworks to help yourself focus on the application code.
Filtering code coverage results
You can now filter files in the Coverage view to focus on recently updated files when testing. By default, you’ll see a list of files with uncommitted changes.
Terminal in the output console
CLion now emulates the terminal in the output console. This behavior is enabled by default in Settings/Preferences | Advanced Settings | Run/Debug | Emulate terminal in the output console and helps you work with text-based user interfaces (TUI), for example, curses/ncurses applications.
CMake enhancements
CLion 2023.1 supports CMake presets up to version 5 and bundles CMake v3.25.
CMake color settings
New color settings have been added for CMake – one for scripts’ keywords and one for CMake arguments’ keywords.
CMake changes notification
The CMake reload notification is now floating. It takes less editor space while still being noticeable.
New UI
Beta
Compact mode
To improve the user experience with CLion’s new UI on smaller screens, we’ve introduced Compact Mode, which provides a more consolidated look and feel of the IDE thanks to scaled-down spacings and elements.
Hidden toolbar in Zen and Distraction Free modes
We’ve refined the IDE’s look and feel when the new UI is enabled. The top toolbar is no longer visible in Zen and Distraction Free modes.
New Dark theme
CLion 2023.1 features a new Dark theme activated by default when the user enables the new UI.
Run widget
The Run widget in the main window header has been redesigned so that its appearance is unobtrusive and easier on the eyes.
Show hidden tabs in the new UI
Users of the new UI can now see the full list of open editor tabs. It’s accessible via the Show Hidden Tabs selector located at the right-end of the tabs row.
Splitting tool windows
The new UI now offers an option to vertically split the tool window area and conveniently arrange these windows, just like in the old UI.
User Experience
Full IDE zoom
You can now zoom into and out of CLion entirely, increasing or decreasing the size of all UI elements simultaneously. Select View | Appearance and adjust the IDE’s scaling. You can also assign custom shortcuts for calling these actions in Settings/Preferences | Keymap | Main Menu | View | Appearance.
Multiple tool window layouts
With CLion 2023.1, you can save and manage several tool window layouts and switch between them when needed. With the new Window | Layouts menu, you can save the current layout as a new one, update the already saved layout, or activate a previously saved layout.
Remember size for tool windows
A new layout option allows you to unify the width of the side tool windows or retain the ability to freely adjust their sizes as you customize your layout. The new Remember size for each tool window checkbox is available in Settings/Preferences | Appearance | Appearance & Behavior | Tool Windows.
Actions on save
You can now predefine the behavior of Actions on Save for new projects. For this, go to File | New Projects Setup | Preferences For New Projects | Tools | Actions on Save and select which actions you want to be triggered when saving changes in your future projects.
Editor
Location of pasted content
Where would you like to paste a line that was copied or cut without selection? In CLion, there is now a special setting that allows you to control the placement of the pasted content. In Settings/Preferences | Advanced Settings, find the Editor section and select the desired behavior for the Paste action from the drop-down list.
Showing whitespaces
CLion 2023.1 features a new Selection checkbox in Settings/Preferences | Editor | General | Appearance | Show Whitespaces that allows you to configure this setting so that the IDE shows whitespaces as small dots only when you select code.
VCS
VCS status in Structure View
To make tracking changes to files more convenient, we’ve added color hints to the Structure tool window.
The names of modified objects will now become blue, and the names of the newly added objects will appear in the tool window highlighted in green.
Enhancements for branches
CLion 2023.1 provides auto-completion in the Create New Branch popup. Once you start typing a name for your new branch, the IDE will suggest relevant prefixes based on the names of existing local branches.
In the Branches popup, branches are now grouped and stored in expandable lists for easier navigation.
Improved code review workflow for GitHub
We’ve fine-tuned the process of reviewing code inside the IDE by reworking the Pull Request tool window. It now features a dedicated tab for each pull request you open. The tab instantly displays the list of changed files but now provides less information than before, allowing you to better focus on the current task. There is also a dedicated button to easily execute the action that’s considered the most important given the pull request’s current state.
Markdown
Reformat table
A new intention action allows you to correct the formatting of tables in Markdown files. You can access the quick-fix via the Context actions shortcut (Alt+Enter) or by pressing the yellow bulb icon and selecting Reformat table from the list that appears.
Fill Paragraph
The Fill Paragraph editor action is now supported for Markdown files, allowing you to break long texts into several lines of even length. To do this, set the caret inside the paragraph you want to edit and call the action from the Edit menu or search for the Fill Paragraph command using Find Action.
Rust plugin update
As a part of continuous improving macro support, the IntelliJ Rust plugin shows inlay type hints in function-like and attribute macro calls now. Besides inlay hints, the plugin started highlighting errors inside attribute macro calls.
The new version of the plugin provides a way to exclude some specific items from
auto-import. The most annoying cases, like methods from Borrow and
BorrowMut traits from stdlib, are already excluded by
this mechanism by default.
Starting from this release, the plugin shows content behind any struct reference and pointer during debugging, as well as the content of raw slice pointers.
What's New in CLion 2022.3
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_packagefor 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 refactorings
Both Find Usages and refactorings 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.
Learn more about CLion’s support for C++20 modules and the known limitations.
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, andphdrs. - 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
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.
What's New in CLion 2022.2
The CLion 2022.2 release integrates better with CMake and CMake presets. The Quick Documentation popup has become a useful source of knowledge about your C++ and CMake code. Enhanced static and dynamic code analysis, better debugger integration, and performance improvements for remote and Docker toolchains help you develop more productively.
CMake integration
CLion now comes with CMake 3.23 bundled. It integrates better with CMake presets and makes updating CMake scripts and options easier.
Quick Documentation in CMake
The Quick Documentation popup is now available in CMake scripts. The documentation is shown for the standard CMake entities:
- Commands
- Policies
- Modules
- Variables
- Properties
Documentation is always rendered for the currently bundled CMake version and is not available for the user-defined entities for now.
Qt-related command completion
While editing CMake files in CLion, you can use auto-completion for CMake commands and variables with static names. In v2022.2, Qt-related commands were added to completion lists.
CMake Cache viewer and options editor
In CLion 2022.2, you can now review CMake cache variables and update CMake options that are passed to the CMake command in a single table-based UI in Settings | Build, Execution, Deployment | CMake.
When the table is in focus, start typing to search for a variable or its value. CLion also shows the short description in tooltips for CMake cache variables.
CMake presets
When auto-creating CLion profiles for all the configure and build presets, CLion now uses a new naming scheme for the CMake profiles created in CLion:
- Configure presets are imported with the name configure-preset-name.
- Build presets are imported as a configure-preset-name - build-preset-name combination.
A copy action for profiles created from presets is enabled.
Colorized Ninja output
Colorized compiler output helps users deal with compilation errors much faster. That’s why we made our own contribution to CMake v3.24. We implemented a way to enable colorized output for the Ninja generator in CMake in CLion by default.
Note: CLion bundles CMake v3.23 for now. To get the colorized output, you need to get CMake 3.24 and use it in the CLion toolchain.
Code documentation
The Quick Documentation popup (Ctrl+Q) is a universal tool to help you get more information on a code element at the caret. By default, CLion shows quick documentation in a popup on mouseover automatically. In v2022.2, CLion has added more code insight to this documentation.
Values of constant expressions
When reading through the code base, you often want to check the value of constant
expressions. CLion now shows the value of the expressions evaluated at compile time
in the Quick Documentation popup. This works for consteval,
constexpr, or template instantiations, just to name a few examples.
Enum values
CLion 2022.2 makes it possible to see the enum value as an integer in the Quick Documentation popup.
Copyable and movable
It can be useful to see whether a given struct or class declaration supports copy and move operations, so CLion now shows this information in the Quick Documentation popup.
Embedded development
GDB servers are often used to debug on-chip. A new wizard helps with creating Embedded GDB Server run configurations with the predefined GDB server arguments corresponding to the GDB server type selected in the wizard settings. The supported types are:
- Segger JLink
- QEMU emulator
- PyOCD
- St-util
- STM32CubeIDE ST-LINK GDB server
- PE Micro (OpenSDA)
Static analysis
We’re continuing to make code analysis in CLion more accurate. CLion 2022.2 removes many
incorrect warnings, adds new checks, and makes Clangd correctly recognize the
-std=gnu++23 option.
Interval analysis
CLion’s data flow analysis now calculates the upper and lower bounds of the possible values for every integral variable. This provides extra information for checks like Unreachable code, Constant conditions, and others.
On top of this interval analysis, the Array index is out of bounds check is built. It reports variables that access an array or allocated buffer via the index which may be out of bounds.
A new Clang-Tidy widget
If you prefer Clang-Tidy configuration files over IDE settings, select this option in Settings | Editor | Inspections | C/C++ | Static Analysis Tools | Clang-Tidy. In this case, a new widget will appear in the bottom right-hand corner of the editor:
- If there is no file with settings, the widget will help you create one.
- If you’d like to know what exact Clang-Tidy configuration CLion is using to analyze the current file, you can open it via the new widget.
Highlighting configuration
The inspection settings in Settings | Editor | Inspections now visualize the highlighting style. When you want to change how an inspection appears in the editor, you can set it up using the new Highlighting in editor drop-down menu, which conveniently shows all available highlighting styles.
Dynamic analysis
Valgrind Memcheck is a tool integrated into CLion for detecting memory usage problems. In v2022.2, we’ve enhanced the way configuration issues are reported. CLion now notifies you when Valgrind Memcheck is launched for the release configuration and the debug information is missing for the executable as a result.
Debugger
Symbol servers on Windows
When debugging, sometimes the library symbols are not available on your local machine. In this case, you can use a symbol server, a file server that stores your debug symbols centrally on a server rather than on each developer’s machine. In CLion on Windows, you can now configure symbol servers for the debugger in Settings | Build, Execution, Deployment | Debugger | Symbol Servers.
Bundled GDB and LLDB
CLion v2022.2 bundles GDB v12.1 and LLDB v14.
Remote development
When using remote development with local sources, the initial synchronization step might take quite some time. CLion 2022.2 uses rsync to synchronize your deployment configuration. Our measurements have shown that this leads to a significant improvement in performance.
Docker
Performance improvement
To improve the performance of compiler information collection for the Docker toolchain,
CLion now uses Docker exec instead of run.
Environment
Usually toolchains in Docker images have an environment file located inside the image. CLion now correctly picks the file from inside the container.
Rust plugin updates
IntelliJ Rust now takes
#![recursion_limit] into account, which controls the macro expansion
depth. If you don’t need macros to expand fully, you can adjust the
Maximum recursion limit for macro expansion setting.
We’ve also enabled the new approach to detecting changes in configuration files, as well as a new way to reload project models.
Other IntelliJ Rust plugin improvements:
- The plugin can now convert JSON to Rust structs via copy-paste.
-
We’ve added inspections and quick-fixes for
unused_must_useandclippy::double_must_uselints. - The plugin now parses generic parameters, type aliases, and type bindings of generic associated types.
- If the Emulate terminal in output console option is enabled, the proper terminal is now used.
- We’ve implemented some improvements for type inference, including unsized coercion.
- URLs are highlighted and you can open them in a browser.
Space integration
Space integration is now bundled with CLion 2022.2. With the first-class integration, you can browse Space projects and clone repositories, then start working on them directly. When your changes are ready, you can create a merge request and perform a code review from within the IDE.
Other enhancements
- The support for CUDA development in CLion has been enhanced. CUDA compilation database projects are now supported in CLion. And the CUDA-gdb debugger integration was fixed to allow you to step out from CUDA calls correctly.
- CLion v2022.2 enables system header indexing for the Microsoft Visual C++ toolchain. This makes auto-import work for such headers.