Build 232.7295.14 is available from our website, via the Toolbox App, or as a snap package if you are using Ubuntu. Update via patch if you are using the previous EAP build.

DOWNLOAD CLION EAP

The main highlights of this build:

• CMake Parameter Info
• The ability to inspect register values during debug
• Updates to the UI
• GitLab integration

CMake Parameter Info

The Parameter Info popup shows signature variants as you type and is now available for CMake commands:

This helps you figure out which parameter to enter next, especially in case of commands that have multiple variants. Check out this page to learn about this and other CMake coding assistance features.

Inspecting register values during debug

Low-level debugging is easier when you have the ability to inspect the registers of the current frame. CLion now provides this! Together with the disassembly, memory, and peripherals views, this feature helps developers to get a better and deeper understanding of what’s going on in their code. This is especially useful in embedded debugging.

There are two ways to view the registers in the debugger tool window, in the Variables tab:

1. When you open the disassembly view, CLion automatically adds the Registers node to the Variables view for you.
2. Otherwise, call Show Registers from the context menu in the Variables tab.

By default, CLion shows registers from the first register set. You can select register sets using the Register sets sub-menu in the context menu of the Variables tab. The values are shown in hex, and the alternative values (for example, floating values for the floating-point registers) are shown nearby in gray.

Note that registers and register sets are provided by the underlying debugger and are thus different in GDC and LLDB.

User Experience

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.

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.

GitLab integration

CLion and other IntelliJ-based IDEs introduce initial integration with GitLab in v2023.2, allowing you to work with the Merge Request functionality right from the IDE, thus streamlining your development workflow.

Other improvements

• The new bundled MinGW toolchain brings GCC 13.1.0.
• A Console tab was added to the vcpkg tool window to show all commands and output from them.

The full release notes are available here.

DOWNLOAD CLION EAP

Your CLion team
JetBrains
The Drive to Develop

Today we’re excited to share that a new CLion 2023.2 EAP build is ready for you to try.

Build 232.6095.18 is available from our website, via the Toolbox App, or as a snap package if you are using Ubuntu. Update via patch if you are using the previous EAP build.

DOWNLOAD CLION EAP

Creating CMake targets when adding new files to the project

CLion helps you add new C/C++ files to CMake targets automatically. This now works even when the target hasn’t been created yet!
The Add new target… action can be found in the new C/C++ file creation dialog:

And in the Add to CMake Project dialog:

In this dialog, select the CMake target type, its name, and the CMakeLists.txt file to locate it. Then, press Add. After adding a target, you can now add new files to it.

Other improvements include:

• This EAP build improves code completion performance for big files.
• Terminal emulation in the output console on Windows now works for MSVC LLDB-based debugging with both regular and administrative privileges. Regardless of whether or not there’s a redirected input, it works only for local toolchains.
• To make sure CLion can debug with Segger J-Link GDBserver correctly, it now handles the SIGTRAP signal in addition to the usual SIGINT and SIGSTOP.

The full release notes are available here.

DOWNLOAD CLION EAP

Your CLion team
JetBrains
The Drive to Develop

Download build 231.9011.31 from our website, through the Toolbox App, as a snap for Ubuntu, or via patch from the IDE.

DOWNLOAD CLION

• CMake:
  • Cyclic dependency in CMake presets no longer causes CLion’s UI to freeze (CPP-33193).
  • When opening a project in CLion for the first time, CLion’s Open Project wizard is shown, allowing you to configure CMake profiles the same way as before CLion v2023.1.1.
  • CLion no longer fails with CMake configuration in cases where the /we4067 MSVC compiler flag is used (CPP-33010).
• We addressed the issue that prevented the debugger from being launched successfully on MacOS with a Docker toolchain (CPP-32652).
• CLion now retriggers code completion correctly after a typed prefix has changed (CPP-33049).

You can find the full release notes here.

Your CLion team
JetBrains
The Drive to Develop

And the CLion 2023.2 Early Access Program starts today! EAP builds are free to use. Give them a try, and let us know what you think about the changes! Share your feedback in the comments below or in our issue tracker.

Build 232.5150.115 is available from our website, via the Toolbox App, or as a snap package if you are using Ubuntu.

DOWNLOAD CLION 2023.2 EAP

Here are the main highlights of this first EAP build:

• Docker in WSL
• CMake improvements
• Attach to remote process and other fixes in the debugger

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

After addressing this issue, you can now select the Docker WSL option and get everything working in CLion:

Be aware that wsl.conf requires several changes to get debugger output in such a setup.

CMake

This EAP build adds highlighting and completion for new parameters from CMake 3.25 (CPP-32140).

CMake 3.25 introduced a new block command to execute a group of commands in a requested scope. We added support for the new command to CLion’s parser, so it’s now highlighted, formatted, folded, and documented correctly.

As a next step, we plan to add support for variable scopes in PARENT_SCOPE and block (CPP-32483).

Debugger

To improve debugging of external libraries for remote toolchains, CLion now correctly handles breakpoints set in them and downloads missing source files on demand (CPP-32278).

In the attach to process dialog, you can now select any debugger configured in the toolchains (CPP-32316). This makes it possible to attach to processes launched on a remote machine! The debugger is taken from the remote toolchains configured in Settings/Preferences | Build, Execution, Deployment | Toolchains in this case.

Disassemble on demand got a few fixes for the Windows LLDB debugger (for the Microsoft Visual C++ toolchain):

• Stepping in the disassembly view now works as expected, executing one instruction per step (CPP-32979).
• We fixed the missing function name in the disassembly view (CPP-32439).

Memory View now supports on-the-fly memory editing and displays the value right after editing.

To keep up with the latest debugger updates, CLion 2023.2 EAP bundles LLDB v16 and GDB v13.1.

Other improvements

• Run/Debug configurations
  • When opening a .cpp file as a project, the Run/Debug configuration dialog now appears, allowing you to perform all necessary configuration (CPP-32880).
  • In CLion, you can compile and Run/Debug a single file without creating, loading, and building a whole project. The compilation options provided in the dedicated Run/Debug configuration have been added after the source file, addressing various issues like this one with the libraries.
• QML support
  • We added support for Inline components (CPP-31850).
  • We fixed the “Newline or semicolon expected” error that occurred for some properties (CPP-31880).
  • We fixed the auto-detection for Qt paths on Windows (CPP-32203).

This build also includes various small fixes in code hints, Clang-Tidy integration, code analyzer, profilers, and others. The full release notes are available here.

DOWNLOAD CLION 2023.2 EAP

Your CLion team
JetBrains
The Drive to Develop

Download build 231.8770.66 from our website, through the Toolbox App, as a snap for Ubuntu, or via patch from the IDE.

DOWNLOAD CLION

• Docker toolchain:
  • CUDA projects can now be opened successfully in CLion with a Docker toolchain (CPP-31357).
  • We fixed the issue that prevented CLion from finding some headers inside a Docker toolchain, like in the example with ROS2 in this report.
• CMake
  • We added support for comments in the CMakePresets.json schema.
  • CLion can now successfully parse the CMake presets files containing byte order marks (BOM) (CPP-26352).
  • We enlarged the space for the CMake cache variables table in the CMake profile settings in CLion (CPP-29390).
• Debugger
  • The new disassemble on demand feature now works correctly with GCC 13.1.
• Inlay hints
  • We fixed the performance degradation caused by inlay hints to prevent the Go to Declaration action from hanging (CPP-32273).
  • We fixed the incorrect parameter hint for abbreviated function templates (CPP-32470).
• Unit testing
  • We added support for doctest::may_fail().
• Other improvements
  • TextMate bundles now work correctly with the registered file extensions (CPP-32527).
  • Previously set window sizing is preserved after restarting the IDE on Linux (IDEA-313378).
  • The IDE no longer flickers when working on Linux using two screens (JBR-5417).
  • It’s again possible to move the IDE’s tool windows between two monitors when using KDE (IDEA-313243).
  • Compact Mode has been enhanced.

Full release notes are here.

Your CLion team
JetBrains
The Drive to Develop

In preparation for CLion 2023.2 and 2023.3, we’d like to share our plans, as well as the ideas and directions we’ll be working on over the next few months. In general, our plan for the 2023.2 release is to polish and finalize many of the improvements we started delivering in 2023.1. You can consider the 2023.2 release as a quality-focused release for CLion.

The following is a preliminary plan and not a promise or commitment. Tasks might be changed or rescheduled for various reasons. We can’t guarantee that all of the issues listed below will be addressed in CLion 2023.2.

There is ongoing work for the IntelliJ platform to polish the new UI and eliminate UI freezes. CLion will benefit from both of these improvements, even though the changes apply to all IntelliJ-based IDEs and are not CLion-specific. Regarding CLion-specific improvements, here is our plan for this year:

• C++ language support
• Integration with vcpkg
• CMake integration
• Enhanced debugger
• Embedded development

C++ language support

An experimental Clangd-based indexer was added in CLion 2023.1 to help make Find Usages in the C++ code faster and more accurate. Our users have reported significant improvements from it, but the new indexer is still unstable – we plan to polish and stabilize it. We also plan to implement a user-friendly crash report mechanism so that you can report the issues you meet more easily and we can address them faster.

The experimental Clangd-based indexer will also come to Fleet soon.

There is ongoing work to optimize the performance of built-in data flow analysis in CLion. It will be continued in 2023.

Integrations: vcpkg

CLion 2023.1 integrated vcpkg. We hosted a round of UX sessions to determine if the integration is convenient for our users, and they find it helpful. Based on this feedback, we plan to introduce the following changes:

• Improved support for Manifest mode: In the initial release, we were mostly focused on the support for Classic mode since it’s easier to use for projects starting with vcpkg from scratch. But Manifest mode is also important and we want to support it in CLion.
• Improve integration with vcpkg for projects already using it:
  • Improve the indication that vcpkg is enabled in the project (CPP-32521, CPP-32524, CPP-32520).
  • Introduce an easier way to enable vcpkg for profiles (CPP-32522).
• Allow installing a specific package version in vcpkg (CPP-32519).

Integrations: CMake

There are the following plans to improve CMake integration and make the user experience more productive:

• The ability to add a new CMake target from the New C++ File dialog (CPP-31483).
• Support for CMake 3.25’s blocks (CPP-32126).
• Parameter Info for CMake commands (CPP-30016).
• Other small tasks with CMake code insight.

Debugger

• Disassemble on demand landed in CLion 2023.1. We now plan to launch UX sessions and collect user feedback to see if there is room for improvement. Let us know if you have tried the feature and have any feedback on it!
• We will continue with the Memory View improvements we started this year. Some of them were already released in 2023.1, while others are coming later this year. The biggest one is to make the memory view editable (CPP-27163).
• We plan to add the ability to inspect register values in CLion (CPP-6988).
• We plan to proceed with the task of Qt type renderers in CLion (CPP-605).
• We will proceed with the Emulate terminal feature in CLion. For example, terminal emulation doesn’t currently work when running a local process with admin privileges.

Embedded development

We are currently working on improving the existing PlatformIO integration. The main effort is to make the PlatformIO experience more native, making it unnecessary to generate CMake projects.

That’s it! Have an idea for a feature? Share it with us in the issue tracker or in the comments.

Your CLion team
JetBrains
The Drive to Develop

When debugging C or C++ code in CLion, you can explore the underlying assembly code. To open the disassembly view, right-click a frame in the debugger tab and select Disassemble. This opens the disassembly view side-by-side with your source code and highlights the current execution line in both. You can freely switch between debugging in the C/C++ and assembly views and step through lines of code or instructions. Both views follow each other while debugging. Disassemble on demand works for both Intel and ARM assembly, and it also works when using remote debugging, like for embedded development.

Interested? Watch this short demo video and give the new action a try!

DOWNLOAD CLION

Your CLion team
JetBrains
The Drive to Develop

• Disassemble on demand, and other debugger enhancements.
• Integration with vcpkg.
• A new experimental Clangd-based indexer to speed up the Find Usages action.
• A huge update to the new UI.

We found a few issues in the release, which we’ve addressed with this new bug-fix update, CLion 2023.1.1. If you haven’t upgraded to v2023.1, now is definitely a good time to do so!

Download build 231.8109.222 from our website, through the Toolbox App, as a snap for Ubuntu, or via patch from the IDE.

DOWNLOAD CLION

The main improvements are:

• When CLion was installed via snap, the built-in LLDB debugger was failing to launch on Ubuntu due to a permissions error (CPP-31989). This has been fixed, so you can now safely install via snap.
• Using the Rename refactoring on a local variable was not updating all of the usages (CPP-32581). The issue was caused by the changes we made to improve navigation speed (CPP-32189), but they affected other functionality. We’ve disabled the changes for now to make sure the Rename refactoring works correctly, and we’ll spend some time in 2023.2 to re-implement the performance improvement.
• CLon 2023.1 brought new built-in QML support. Unfortunately, it broke the JavaScript/TypeScript support in CLion (CPP-32895). This has now been fixed.

Full release notes are here.

Your CLion team
JetBrains
The Drive to Develop

CLion 2023.1 is available in the Toolbox App, as a snap package (on Ubuntu), from our website, or via a patch update from version 2022.3.

Read on for details about the key improvements in this version:

• Debugger update: disassemble on demand, improved Attach to Process… dialog, actions to help debug multithreaded applications, updated memory view.
• Support for Qt Modeling Language (QML).
• Integration with vcpkg.
• Terminal emulation in the output console.
• Better C++ support.
• Improvements to CMake integration.
• Enhanced user experience and new UI.
• VCS updates.
• Other changes.

DOWNLOAD CLION 2023.1

Debugger update

The new release makes your debugging powers even stronger! The CLion debugger allows you to step into and debug the disassembled code in a dedicated view, 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:

Once the disassembly view has been opened, it stays synchronized with the current frame selected in the frames view, and switching frames scrolls to the execution point in both the editor and the disassembly view.

A few important issues to mention:

• Instruction-level stepping is not yet implemented for LLDB on Windows.
• CLion does not yet mirror breakpoints between the source file and the disassembly view.
• We want to improve the discoverability of the disassemble action.

Check out our webhelp for more information.

CLion 2023.1 provides a better way to attach the debugger to local processes started outside the IDE. In v2023.1, we’ve completely reworked the Attach to Process… dialog to make finding processes and attaching to them even easier and faster – the dialog features a new table view used to search for processes. The view now shows the name of the user who launched the process, the debuggers available for this process, and the command used to launch the process. This functionality works for local and WSL processes.

If you’re developing a multithreaded application, there is the possibility that during the debug you would like to step through the selected thread with all other threads suspended. You can now do that in CLion! The new Freeze/Unfreeze actions are available in the context menu in the thread view of the debugger or in the Run | Debugging Actions menu:

Memory View provided by CLion got a massive update, with many issues fixed and the overall user experience enhanced. CLion now highlights all changed bytes during debugging, and, when scrolling through the memory view, the IDE now automatically loads the data. Finally, the number of columns in the Memory View (i.e., the number of bytes per line) is configurable now:

Support for QML

For some time already, CLion has given special treatment to for Qt projects, including templates for Qt UI classes and Qt-specific code insight. Now, as a further enhancement, there is also QML syntax support. 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.

Read our webhelp for more information.

Integration with vcpkg

Managing dependencies and using external libraries in the code bases can be painful. CLion now helps by integrating with vcpkg, a package manager growing in popularity among C++ developers. The IDE assists with installing and updating vcpkg and its packages and browsing installed and available packages in the dedicated View | Tool Windows | Vcpkg tool window.

CLion will ask you to specify the name and URL of your vcpkg repository and the installation directory (or rely on the default value suggested). When provided, the repository will be cloned. To make it work with your CMake project, vcpkg provides a CMake toolchain file, which CLion will link to the CMake profiles you selected in the dialog when adding a package manager.

After running a few UX sessions with the early previewers, we built a roadmap to enhance the vcpkg integration even more in the upcoming CLion versions. You can learn about the current implementation and abilities in our webhelp.

Terminal emulation

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.

Better C++ support

If you already utilize C++20 modules in your codebase or are considering adding them to your current project, CLion 2023.1 helps you create a new C++ Module Interface Unit:

CLion creates a new module file using the file template from Settings/Preferences | Editor | File and Code Templates.

To help you adopt more modern C++ in your codebase, 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.

The Clang-Tidy checks options dialog was updated in this release. You can now see all predefined values for all the options, and updated values are highlighted in blue and moved to the top of the table. To search easily throughout the table, use the speed search – put the table in focus and start typing the name of the check you’re looking for.

To speed up the Find Usages action and make it produce more accurate results in C++ code, a brand-new experimental Clangd indexer was introduced in CLion. You can enable it in Settings/Preferences | Advanced Settings | Clangd | Use Clangd-based indexer. When enabled, CLion enables looking for constructors which can be used for implicit conversion and for implicit conversion operators. Indexing takes some time, but when ready, searches are instant, no matter how many usages of a symbol there are in the project. The experimental engine only works for Find Usages now and is not applied to any other actions.

Improvements to CMake integration

CMake is the most used project model among C and C++ developers. That’s why the CLion team contributes to its integration with every release. In 2023.1, the following improvements were added:

• CLion v2023.1 bundles CMake v3.25.
• CLion now supports CMake presets up to version 5. This covers, among other changes, presets with the include statement.
• New color settings have been added for CMake – one for scripts’ keywords and one for CMake arguments’ keywords.
• The CMake reload notification is now floating. It takes less editor space while still being noticeable.

Enhanced user experience and new UI

CLion and other IntelliJ-based IDEs by JetBrains have received a new UI as of v2022.3. You can switch to it in Settings/Preferences | Appearance & Behavior | New UI. In v2023.1, it’s still in the Beta stage, as we’re continuing to improve and polish it. Find the following changes in this release:

• 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.
• Similarly, to improve the look and feel in specific cases, the top toolbar is no longer visible in Zen and Distraction Free modes.
• CLion 2023.1 features a new Dark theme activated by default when the user enables the new UI.
• The Run widget was redesigned based on the feedback we received from our users:
• 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 right at the end of the tabs row.

• The new UI now offers an option to vertically split the tool window area and conveniently arrange these windows:
  

It’s also worth mentioning a few new options that improve user experience. The full IDE zoom lets you increase or decrease the size of all UI elements simultaneously.

And with the new Window | Layouts menu, you can save the current tool window layout as a new one, update the already saved layout, or activate a previously saved layout.

VCS updates

In version control systems integration, we reworked the Pull Request tool window, added color hints to the Structure tool window to reflect the changes to files, provided auto-completion in the Create New Branch popup, and a grouping in the Branches popup.

Other changes

• The Call Tree tab in the profiling results now allows you to collapse any frames you’re not interested in.
• You can now filter files in the Coverage view to focus on recently updated files when testing.
• A new Reformat table intention has been added to correct the formatting of tables in Markdown files.
• Multiple enhancements are added to the IntelliJ Rust plugin, including inlay type hints in function-like and attribute macro calls, highlighting errors inside attribute macro calls, a way to exclude some specific items from auto-import, and more.

That’s all for now! We encourage you to give CLion 2023.1 a try. If you have an active subscription, you can update today. Otherwise, feel free to start your free 30-day trial to check out all of the new features and improvements!

DOWNLOAD CLION 2023.1

Your CLion team
JetBrains
The Drive to Develop

To install CLion 2023.1 RC (build 231.8109.141), download it from the website, update via the Toolbox App, or use this snap package (for Ubuntu).

You need an active subscription or a trial license to use CLion 2023.1 RC.

DOWNLOAD CLION 2023.1 RC

In this build, we fixed an issue in the new UI causing the CMake tool window to be hidden by default.

The full release notes are available here. Give this build a try, and report any problems you find to our issue tracker. The final release is just around the corner, so stay tuned!

Your CLion team
JetBrains
The Drive to Develop

DOWNLOAD CLION 2023.1 BETA

The main highlights:

• Docker improvements:
  • A missing Docker image no longer causes exceptions and indefinite CMake loading in CLion, as CLion now tries to pull the image from the registry before loading CMake (CPP-32511).
  • GDB pretty printers are now configured for the Docker toolchain (CPP-32432).
• CMake presets:
  • Build presets with configurePreset from the included file are no longer reported as incorrect (CPP-32270).
• Multi-threaded RTOS debug improvements:
  • FreeRTOS views are now available when working with the STM32 toolchain and the arm-none-eabi-gdb-py debugger (CPP-32211).
• Memory View:
  • We removed uninformative blank lines (CPP-32364).
  • We improved the scrolling in the memory view (CPP-32299).
  • We removed the unused selection of memory blocks (CPP-15661).
• Fixes for terminal emulation:
  • Navigation via the Up, Down, Right, Left, Home, End, PageUp, and PageDown keys now works in the program output console (CPP-32313).
  • The search in the console is once again case insensitive (CPP-32325).
• We implemented several improvements to speed up navigation.

You can find the full release notes here.

Your CLion team
JetBrains
The Drive to Develop

Download build 223.8836.42 from our website, through the Toolbox App, as a snap for Ubuntu, or via patch from the IDE.

Here are the highlights of this update:

• CMake debugger:
  • CLion now detects the CMake errors more accurately and shows the Debug hint in all necessary cases (CPP-31585).
  • We fixed the case when the IDE fails to connect to the CMake debugger (CPP-31587).
• Unit Testing:
  • We fixed an issue in the Catch2 integration to support versions 3.2.1 and higher (CPP-31805).
• Linker scripts:
  • We fixed the parsing of binary operations (CPP-31552).
• UI on macOS Ventura:
  • We’ve resolved the long-standing issue that caused the screen to flicker in full-screen mode on macOS Ventura (JBR-4959).
  • The IDE no longer displays empty popups on macOS Ventura. (JBR-5258).
• VCS:
  • The Shelf tab doesn’t disappear from the Commit tool window anymore (IDEA-305906).
• Other:
  • It’s now possible to check the configuration status of Windows Defender and update it directly from the IDE. To do so, search for Check Windows Defender Status in Find Action (⇧⌘A/Ctrl+Shift+A) (IDEA-310423).

The full release notes are available here.

DOWNLOAD CLION

Your CLion team
JetBrains
The Drive to Develop