CLion 2020.3 can run and debug your application with root privileges – you just need to select this option in the corresponding Run/Debug configuration. This works for CMake, Makefile, Gradle Native, Custom Build, and CTest applications.

With a new Set Execution Point to Cursor action, you can move back and forth though your program’s execution while debugging, break loops or restart them, select another branch in an if-else clause or switch-case statement, and even skip loops completely. It is as simple as dragging-and-dropping an arrow in the gutter to the line you are interested in.

In CLion, you can now use a script to specify the environment in which a Run/Debug configuration will be launched. You'll find the new setting for this in all Application and Unit Testing configurations.

CTest, a CMake-specific test runner, is now supported in CLion. This means the list of tests that are run with CTest is detected, and the IDE automatically creates run/debug configurations for them. When tests are launched, the results are presented in the built-in test runner, from which you can debug tests, rerun only failed tests, and much more.

CLion 2020.3 brings partial support for MISRA C 2012 and MISRA C++ 2008, guidelines used widely in embedded development and especially in the automotive industry. This support speeds up the development of such projects by revealing incompatibilities earlier in the development cycle. The list of currently supported checks is available on CLion’s Confluence page.

A new Extract Lambda Parameter refactoring has been added to CLion. It extracts an expression or statement into a new parameter with a lambda expression passed as a corresponding argument. The statement could, for example, be a comparator passed to a sorting function.

Watch Extract Refactorings in Action

Clang completion snippets help you insert common constructs when C++ keywords are typed. In some cases, when completing a typedef keyword, for example, code completion can suggest not only the keyword itself but also stubs for the type and the new name.

The New Project dialog suggests the Qt Console Executable and Qt Widgets Executable project types. You can also select the Qt CMake prefix path, the C++ language standard to be used in the project, and the Qt version. The new project is generated using the corresponding templates.

Signals and slots are central features of Qt, as they are the entities used for communication between objects. CLion now understands when signals or slots have to be completed, and it filters only the corresponding members in the completion dropdown.

Makefile projects using various wrappers like ccache, libtool, dolt, slibtool, and jlibtool can now be successfully loaded in CLion. Read more about some of the limitations that remain.

The Recompile action (Ctrl+Shift+F9) helps speed up the development process by compiling a single file without building the whole project. It now works for Makefile projects, too!

With CLion 2020.3, it’s now possible to keep several CMake profiles configured in CLion while disabling the ones that are not currently in use. This improves the project loading times and saves from the redundant failures from temporarily unavailable profiles (like for the remote configurations which are currently shut down). The option is available from the CMake tool window and the CMake Profiles settings dialog.

The Search Everywhere dialog now includes a Git tab. It helps with finding commit hashes and messages, tags, and branches. You can also perform simple mathematical calculations in the search field.

Directories marked as Excluded locally are now automatically marked as Excluded paths for remote toolchains when they are initially being configured. And when changes are made to an already synchronized project, CLion shows an update notification and suggests updating the list of Excluded paths.

CLion 2020.3 supports Code With Me (EAP), a new service from JetBrains for collaborative development and pair programming. Code With Me enables you to share the project you currently have open in your IDE with others, and work on it together in real time. You can download it today from the plugin marketplace (Preferences / Settings | Plugins | Marketplace). Check out these posts to learn more about Code With Me.

CLion 2020.3 gets a revamped Welcome screen. The new layout puts the most common operations at your fingertips and gives you immediate access to recent projects, customization options, and plugin settings.

CLion can now synchronize with your OS theme. To enable this feature, go to Settings / Preferences | Appearance & Behavior | Appearance and tick the Sync with OS checkbox. Click the gear icon next to Sync with OS to select your preferred theme.

IntelliJ Rust now fully supports Cargo features and allows you to configure them with a smart new UI. Features of a workspace can be toggled on and off with a single click, and the plugin’s code assistance will take these settings into account. Check out the details in this blog post.

Also, the plugin now allows using Rustfmt as the default code formatter. Just set the corresponding checkbox in Settings / Preferences | Languages & Frameworks | Rust | Rustfmt, and the whole file reformatting will employ Rustfmt. For now, if you call Reformat Code on a selection, the IDE’s formatter will be used instead.

The plugin’s project wizard has been enhanced with more templates and the option to use custom cargo-generate templates.

Other updates include the introduction of WebAssembly project support and a new experimental engine for name resolution.

Developing a Makefile-based project? Benefit from CLion’s smart features – CLion now comes with Makefile project support out of the box. Open a folder with a top-level Makefile as a project, or directly point CLion to a Makefile in the Open dialog. The IDE will run make (with the --just-print option to avoid running an actual build), parse the output of the make command, and load the project. Check out the details, known limitations, and a long list of projects we’ve tested our approach with in this blog post.

Take a short tour

CLion now bundles CMake 3.17 and adds initial support for two of its most recent features:

1. Ninja Multi-Config: you can now pass the -G "Ninja Multi-Config" generator option to get CLion build files generated for every configuration (note that, temporarily, CLion will still use only one selected configuration for the CMake profile).
2. CMake precompiled headers: use the target_precompile_headers command to add header files to the PRECOMPILE_HEADERS and/or INTERFACE_PRECOMPILE_HEADERS properties of a target. CLion will treat such precompiled headers correctly.

Take a short tour

The Recompile single file action helps speed up the development process by quickly checking local changes, and it is now available for Ninja and other generators used in CMake and supported in CLion.

Thanks to an important bug fix, CLion can now build multiple independent projects in parallel, without them blocking each other from starting.

Pointers that point to invalid data lead to run-time issues. Typical cases are double-free and use-after-free combinations. CLion now catches such dangling pointers if they appear in the local scope, no pointer arithmetic is involved, and macros are not preventing CLion from performing the analysis.

This CLion inspection detects situations where a loop condition is not updated inside the loop. It’s similar to Clang-Tidy’s clang-tidy:bugprone-infinite-loop but works for loops with exit points and can handle cases with lambdas or references.

Last but not least, we’ve introduced a new Inspection Widget. It displays the number of warnings and errors in the current file and lets you navigate between them with ease. You can also configure the highlighting level (just like you could previously with the so-called Hector icon).

If you click on the Inspection Widget, the Problems View tool window will open (View | Tool Window | Problems). It shows the list of warnings and errors in the current file, helps you navigate to the place in your code where the problem was encountered, and allows you to fix the issues by invoking the Alt+Enter shortcut right from the tool window.

Newly added keywords are supported by CLion 2020.2 in code highlighting and completion:

• char8_t
• consteval and constinit
• co_await, co_return, and co_yield

The C++20 explicit(bool) construct is now highlighted correctly. It’s also equipped with name hints for condition arguments and is supported in navigation and refactoring.

A new inspection for code that uses Concepts has been added. It suggests constraining local variables declared as auto if the result of a constrained function call is assigned to them.

The GTEST_SKIP() macro in Google Test provides the ability to skip tests at runtime. This is now supported by CLion.

CLion 2020.2 improves the user experience by adding coverage flags automatically when you click the Run with Coverage button. Now, if your currently selected CMake profile doesn’t include compiler options for coverage, CLion will search for a CMake profile (and create one if not found) with the coverage flags passed via CMAKE_CXX_FLAGS and CMAKE_C_FLAGS.

PlatformIO project configuration files are now highlighted properly, so you can read and update them more easily.

CLion now automatically creates CMake Profiles for the CMAKE_CONFIGURATION_TYPES entries in the PlatformIO CMake project.

If you develop with the WSL2 toolchains and use Git on WSL2, you will now benefit from CLion switching between Git executables depending on the project location. It will auto-detect the Git executable from WSL2 for projects opened from there (via \\wsl$ path) and switch all Git-related features to work with it.

The Go to Declaration or Usages action (Ctrl+Click / Ctrl+B) behaves differently depending on the case and the IDE settings:

• When invoked on a symbol usage, it navigates to that usage’s declaration.
• When invoked on a declaration, it shows the list of that declaration’s usages.
• When invoked on a definition, it shows the associated declaration or usages. This depends on the settings in Settings | Editor | General | Go to Declaration or Usages.

In version 0.3 of the plugin, the new engine for macro expansion, which until now had been experimental, is enabled by default. This engine handles macro-generated impl blocks and module declarations, providing code insight for the entirety of your code, including crates like tokio and async-std. Learn more in this blog post.

Another major update is the introduction of initial debugger support for Rust’s MSVC toolchain. Now you can use the LLDB-based debugger bundled in CLion for the Visual Studio toolchain to debug Rust code built on Windows using Rust’s MSVC.

Other enhancements include new refactorings (Move for files and top-level items and Introduce Constant), initial support for or_patterns, error highlighting in format literals inside macros like println!, rendering for documentation in the editor, inlay hints for chain method calls, and improvements to the debugger workflow in IntelliJ IDEA.

Remote GDB Server and Embedded GDB Server configurations now work with custom targets. These configurations, which previously only worked with CMake targets, allow you to debug your application on a remote host or on the microcontroller from the CLion instance running on your local machine.

If you have already created these configurations, CLion 2020.1 will store previous Run/Debug Configuration settings in the projectFilesBackup directory in the project folder and will notify you about this.

If you need to redirect input from a file to the stdin of your application, you can now do that. Use a new field in the configuration called Redirect input from. Enter:

• A relative path (CLion will prepend with the Working directory path).
• An absolute path (will be remapped for remote configurations).
• Or macros (like FilePrompt).

Now, when you first open a project with a .clang-format config file in the project root, CLion will detect it and switch to ClangFormat for you automatically.

If you enable ClangFormat on a project that doesn't have a .clang-format config file, CLion will suggest creating one for you.

When calling the Change Signature refactoring (Ctrl+F6), CLion updates all the usages of the function. A new Default value field in the Change Signature dialog offers the ability to specify the value of the parameter to be used across all usages. Keep it blank to use the default value type as before.

The same logic and a new Default value field apply to the Create Parameter From Usage quick-fix and the Add Parameter to Constructor intention.

Quick Documentation – a universal tool to preview documentation and get information about function signature, inferred types, and macro replacement – is now available on mouseover.

It can be controlled by the setting Show quick documentation on mouse move in Settings | Editor | Code Editing.

An updated tool window provides more space for the list of modified files and the diff. It also lets you add changes to a commit when they are ready, compose a commit message iteratively, and choose which of the staged changes go into which commit.

The new UI is enabled by default for new users; existing users can switch to it in Settings | Version Control | Commit.

With improvements to LLDB support, IntelliJ Rust now properly renders enums and primitive types, and it also shows demangled function names in the call stack.

Another major update that has landed in the plugin is REPL integration. Invoke the console from Tools | Rust REPL and use it for prototyping and checking your code line by line. The integration provides syntax highlighting and code completion, along with some handy console actions: command history, soft wrap, quick scroll to end, and others.

On the language-support side, IntelliJ Rust now handles impl blocks for type aliases. Taking performance into account, we've only enabled this feature for types with a limited number of aliases.

Other enhancements include highlighting for unused local variables, fixes in cfg attribute support, and the new Lift return inspection.