CLion Changelog

What's new in CLion 2023.3 Build 233.11361.11 EAP 3

Nov 2, 2023

Enhanced Bazel for CLion plugin
Memory leak analysis
Improved code completion in device tree files
Structure view for meson.build file

New in CLion 2023.2.2 Build 232.9921.42 (Sep 14, 2023)

New in CLion 2023.2.1 Build 232.9559.58 (Aug 25, 2023)

New in CLion 2023.2 Build 232.8660.8 EAP 6 (Jul 7, 2023)

New in CLion 2023.2 Build 232.8453.115 EAP 5 (Jun 30, 2023)

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

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

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

New in CLion 2023.1.2 Build 231.8770.66 (Apr 30, 2023)

New in CLion 2023.1.1 Build 231.8109.222 (Apr 6, 2023)

New in CLion 2022.3.3 Build: 223.8836.42 (Mar 11, 2023)

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

New in CLion 2022.3.2 Build 223.8617.54 (Feb 27, 2023)

New in CLion 2023.1 Build 231.7665.29 EAP 5 (Feb 27, 2023)

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

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

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

New in CLion 2022.2.4 Build 222.4345.21 (Nov 3, 2022)

New in CLion 2022.3 Build 223.7401.10 EAP (Nov 3, 2022)

New in CLion 2022.3 Build 223.7255.15 EAP (Oct 27, 2022)

New in CLion 2022.2.2 Build 222.4167.25 (Sep 14, 2022)

New in CLion 2022.2 Build 222.3739.54 (Aug 18, 2022)

New in CLion 2022.2 Build 222.3345.16 EAP 7 (Jul 11, 2022)

New in CLion 2022.2 Build 222.3244.6 EAP 6 (Jul 1, 2022)

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

New in CLion 2022.1.3 Build 221.5921.27 (Jun 23, 2022)

New in CLion 2022.2 Build 222.2964.48 EAP 4 (Jun 10, 2022)

New in CLion 2022.2 Build 222.2889.11 EAP 3 (Jun 4, 2022)

New in CLion 2022.1.2 Build 221.5787.29 (Jun 2, 2022)

New in CLion 2022.1.1 Build 221.5591.52 (May 13, 2022)

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

Enhanced in-editor experience:
For this release we’ve polished many CLion features that make your coding experience more comfortable, easy, and productive. We focused on their flexibility and accuracy regarding the modern C++ language.
Inlay hints
Parameter and type hints help you read and maintain your existing codebases with ease. The extra information is shown right in the editor and helps with parameter names in function calls and deduced types.
We’ve implemented a number of fixes to make inlay hints in C++ code more accurate
In CLion 2022.1 we’ve enhanced the settings in Settings/Preferences | Editor | Inlay Hints with some explanations and code examples. You can now better understand the cases where the hints are shown and tune the settings to your preferences. Hints for array indices can now be disabled if you don’t need them. Previously this was not possible.
Code analysis:
Because code analysis is 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.
The Clang-Tidy and MISRA settings in Settings/Preferences | Editor | Inspections | C/C++ | Static Analysis Tools were reworked to make the process of configuring checks easier. A new visual representation includes a tree with all of the checks. Speed search helps you find the checks you need faster – 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.
It’s much easier to improve your code when the suggestions from the IDE not only name the problem and suggest the fix, but also show how the selected fix will transform the code.
For Clang-Tidy, the issue causing incorrect results to occur when the WSL toolchain was used has been fixed by setting Clang-Tidy to execute inside the WSL itself.
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.
Structure View popup:
Structure View helps you navigate through the current file in just a few clicks. Sometimes you want the elements there to go in the same order as in the original file, but sometimes you want them to be grouped by the qualified name. There is now a dedicated toggle in the dialog that allows you to switch between these modes.
Formatter:
New formatter options for structured bindings were added to the Spaces and Wrapping and Braces sections
More powerful CMake support:
CMake is a first-class citizen project model in CLion. In this release, we focused on the flexibility of configuring CMake in CLion, as well as improving the CMake editing experience and adding profiling support.
CMake presets and CLion profiles:
CMake 3.19 introduced CMake Presets, a universal way to configure CMake and share the configurations within your team. It’s still young and is evolving quickly, with many approaches being tested and then later updated based on feedback from people using them in real projects. CLion’s support for CMake Presets is also evolving. We now create CMake profiles for configure presets. CLion uses CMake profiles to run and debug your application, but it previously only created them for build presets. Configure profiles allow redundant build presets to be removed in many cases.
If you don’t want CLion to create profiles from presets at all, a new setting that controls this was added to Settings/Preferences | Advanced Settings | CMake | Enable CMake Presets integration. Another setting there is the option to set CMake profiles in CLion to reload sequentially. You might need this in the event of non-trivial connections between profiles that make parallel reload (the default in CLion) impossible
CMake generators:
In the CLion toolchain, you can now configure any build tool of your choice, not just make. Now if you need one specific build tool for all profiles working with a specific toolchain, you can simply configure it in the toolchain itself instead of configuring it in every CMake profile. In CMake profiles, this means that the Use default option is selected in the generator field. Another new value in the generator setting is Let CMake decide. With this option selected, CLion won’t favor any CMake generator explicitly, and CMake will decide which generator to use instead.
CMake formatting:
Formatting support in CMake scripts now helps with if() ... endif(), else(), elseif(), endforeach(), endfunction(), endmacro(), and endwhile() commands and their corresponding blocks.
CMake profiling:
Have you ever wondered why it occasionally takes a long time to reload your CMake project? CMake v3.18 brought the new ability to profile your CMake scripts and inspect the traces to find the answer. CLion now offers support for this feature, including the automatic creation of profiling configurations and the visualization of tracing results
Wider range of debugger options:
If you develop with CUDA, you’ll be happy to learn that we’ve fixed some critical issues that were preventing you from using CUDA-GDB 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 to add CUDA debug symbols: add_compile_options(-G).
For developers on Windows using the Visual Studio C++ toolchain, CLion comes with the LLDB-based debugger maintained by the JetBrains team. The hex value view in this debugger has been fixed and you can now enable it using Settings | Build, Execution, Deployment | Debugger | Data Views | C/C++ | Show integers as hex values and Display alongside the original value.
Toolchains:
With container-based development being massively popular, Docker toolchain is one of the most widely used in CLion. In version 2022.1, we’ve improved its integration in CLion:
The Valgrind Memcheck tool for detecting memory-usage problems now works with the Docker toolchain.
In the toolchain settings you can now provide additional container settings, such as port and volume bindings.
Another big story is remote development. In the previous release, CLion got support for the new remote development workflow with the thin client. This support is now getting some enhancements and is available from the Welcome screen – you no longer need to install any additional gateway software, as it’s now bundled in CLion
Cloud dev environments featured in Space can now be used with CLion to speed up onboarding, access a ready-to-use IDE in seconds, and manage your development resources efficiently. Learn more about Space dev environments.

New in CLion 2022.1 Build 221.5080.1 EAP 5 (Mar 18, 2022)

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

New in CLion 2021.3.4 Build 213.7172.20 (Mar 16, 2022)

New in CLion 2022.1 Build 221.4501.161 EAP 3 (Feb 19, 2022)

New in CLion 2021.3.3 Build 213.6777.58 (Feb 1, 2022)

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

New remote development capabilities are bundled:
The new remote development mode was announced in the 2021.3 versions of our IntelliJ-based IDEs, including CLion. The main idea behind remote development is to 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. A remote host is a physical or virtual machine hosting the source code and running the headless IDE (i.e. CLion) to perform most of the IDE functions.
As we described in the release blog post, CLion 2021.3 didn’t bundle this functionality because there were several major workflow issues at the Beta stage, and JetBrains Gateway needed to connect the remote server and start a local thin client. But with 2022.1 EAP, the new remote development capabilities are now bundled in CLion! To access JetBrains Gateway, select Remote Development on CLion’s Welcome screen
Build tool in Toolchains settings:
In Toolchains settings (Settings/Preferences | Build, Execution, Deployment | Toolchains) you can now configure any build tool to be used with a toolchain. Previously, the make tool was required in this field, which you could later substitute with Ninja, for example in CMake profiles. This worked, but was definitely inconvenient and non-intuitive. Now you can specify the build tool in the Toolchains settings. In default toolchains, Ninja is used when nothing is configured
Enhanced UX for CMake generator:
We’re continuing to make the CMake generator easier to use in CLion. Two options are worth noticing in the generator dropdown list in CMake Profile settings, one new and one updated:
Use default – for new projects, this option now takes the build tool configured for the toolchain selected in the corresponding CMake Profile. The actual value is also shown in the dropdown option.
Let CMake decide – this option means CLion won’t be forcing any CMake generator explicitly, meaning that CMake will decide what generator to use. By default, CMake uses the CMAKE_GENERATOR environment variable to determine the CMake generator (CMAKE_GENERATOR).
CMake profiling:
Have you ever wondered why it takes a long time to reload your CMake project? CMake 3.18 introduced a way to generate trace information while generating a project. You can use it to inspect the tracing results and identify specific places in your CMake scripts that can be improved.
CMake uses Google’s Trace Event format for the results. To enable the tracing, simply add two flags to the CMake command: –profiling-format=google-trace and –profiling-output=<path>. CMake will then generate a JSON file with the tracing results under the specified <path>.
What’s new in this CLion EAP is that it can now help you run the tracing and visualize the results
Use one of these two ways to enable the CMake tracing:
Manual: add –profiling-format=google-trace and –profiling-output=<path> to the CMake options in your project.
Automatic: click Add event tracing to CMake in the CMake tool window
CLion will search for configurations with the CMake profiling option (with the -event-trace suffix in the name). If none are found, the IDE will copy the profile that is currently selected and add the required options
Once the CMake profile is reloaded, CLion will show a notification suggesting to open the profiling information
In the profiling tool window you can:
On the left-hand side: inspect the process ID and thread ID for the CMake reload process.
In the center: inspect the flame chart showing the stack trace of the CMake process in each time frame during the CMake reload.
On the right-hand side: explore the details of the selected event. Details include event (function) name, duration, function arguments, and where the function is located in CMake scripts.
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.
The field has basic validation checking the identifier is a valid namespace name or a blank space.
Preview for intention actions:
CLion’s intention actions cover a wide range of situations, from warnings to optimization suggestions. As you probably know, you can click the bulb icon or press Alt+Enter to open the list of suggestions and select an action from the list. Starting with this EAP, now you can also see a preview of the result of the selected action
To activate it, press Ctrl+Q (on Windows/Linux) or F1 (on macOS).
The preview is not available for all intention actions. If an intention action is too complex and the preview cannot be generated, you will see the intention action’s description. The preview is available, however, for DeMorgan laws, invert if condition, merge if-else, merge nested if, Clang-Tidy, MISRA, Clazy, split declaration and assignment, split into separate declarations, and a few others.
Once activated, the preview will appear every time you open the list of available intention actions. To close the preview, press the shortcut again while the list of intention actions is open.
Grouping by the qualified name 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 fully qualified name included in each element name.
Clang-Tidy settings
Clang-Tidy settings in CLion can be configured in Settings/Preferences | Editor | InspectionsC/C++ | Static Analysis Tools | Clang-Tidy. This EAP build comes with an updated dialog for checks configuration that simplifies the enable/disable process, by providing 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. Click the Visit Help Page icon (planet symbol) to navigate to the documentation on the LLVM website describing the check in detail.
Docker toolchain:
When working with the Docker toolchain, you can now provide additional container settings, such as port and volume bindings, and others
Notable fixes:
As this is a quality-focused release, we’d like to highlight some of the important fixes we’re delivering in this EAP build:
Project model:
Conflicts in CLion when setting build directory in CMake presets have been resolved (CPP-26755).
Makefile projects are now loaded correctly when using the Cygwin toolchain (CPP-27539).
CLion can now successfully find the compiler executable for compilation database projects with the Windows system toolchain (CPP-27732).
Embedded:
Fixes for STM32CubeMX projects (CPP-15489, CPP-23278, CPP-26942).
FreeRTOS GCC/Posix port is now supported and thus enables FreeRTOS debug on Linux (CPP-26898).
Macros now work in Embedded GDB Server configuration fields (CPP-27286). CMake variables now work for Embedded and Remote run/debug configurations (CPP-19627).
Dynamic analysis:
For remote toolchains, Valgrind and Sanitizers previews are now displayed correctly for out-of-project header files (CPP-23847).
Refactorings:
Fixed several issues in the Rename refactoring (CPP-6523, CPP-22927, CPP-25391).
Clangd:
Added __cplusplus and other predefined macro names to built-in macro completion (CPP-50).
Postfix completion now considers formatting options (CPP-25966).
Fixed several causes of Clangd crashes, and merged some of the recent changes from the LLVM upstream branch.
Editor:
Introduced various fixes for inlay hints (CPP-27854, CPP-27628, CPP-27151).
Added parameter info for structs literals (CPP-2075) and initializer list (CPP-15143), as well as make parameter info more informative for emplace, emplace_back, make_unique, and make_shared functions.

New in CLion 2021.3 Build 213.5744.254 (Dec 10, 2021)

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

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

New in CLion 2021.3 Build 213.5449.26 EAP Preview (Oct 29, 2021)

New in CLion 2021.2.3 Build 212.5457.51 (Oct 15, 2021)

New in CLion 2021.3 Build 213.4928.11 EAP 3 (Oct 14, 2021)

No hint for template type when it's used as return type
Clangd Signature Help: Incorrect highlighting of template parameter types in Parameter Info
Type Hint: No hint when variable name is MACROType Hint for parameter declared with auto
Type Hint for parameter declared with auto
Type Hints: Add option to disable obvious type detection cases
Goto TypeDecl for constructors & destructors
Go to type declaration doesn't work for pointer-to-member
Go to Type Declaration for std::forward does nothing
SID2: Split Initialization From Declaration should not be available on references
Clangd erroneously switches to clang-cl mode
Invalid '<unknown>' type generated for 'auto' reference
Do not suggest to change return type to auto
"Constructor 'x' is never used" false positive when using braced initializer
Inspection "Virtual call from constructor or destructor" complains about calls in lambdas
DIR_PATH not available in file templates
Unable to open a non-Autotools `Makefile` project if the project root contains a `configure` file
Drop `--symlink` from the default `autoreconf` switches
Source file is no longer considered in project after reopening
Running a build with multiple jobs (e. g.: `-j8`) seems to produce a race with Autotools_-generated `Makefile`'s
Unable to load CMake if cmake.api.toolchains.v1 is enabled
UOE while pre-configuring a `Makefile` project if the remote file system doesn't support POSIX file attributes
Docker toolchain on macOS requires file sharing
Don't show linker errors when checking embeded compilers for system toolchain
Support for custom compiler: allow to specify supported features, header search paths, defines etc.
NPE is thrown when change inspection settings from quick-fix in editor in master
Empty popup on navigation via "Navigate" link on StackTraceElement
Vgo shouldn't be shown under reformat code save action
Fast multi-threaded grep-like text search
ToolWindow Colorful Icons plugin causes IDE hang on start now
Can't disable plugin via 'Find action' (nothing happens when I press 'OFF')
JavaEE:ApplicationServers plugin should not require Coverage plugin probably
VM options stripped from existing run configurations
Expand the behaviour to disable inlay hints to all lenses
Intention preview: highlight changer or removed content in one-line diff
Make intention preview persistent
Formatting a YAML file breaks anchor references used as keys
Can't specify some JSON schema to yaml file
The selected option "Use Compose V2" is not remembered after restarting the IDE
Terminal caret blinks even though caret blinking is disabled in settings
IDEA UI freezes when browsing in the File Chooser dialog
Can't get to "Actions on Save" via Search Everywhere
Selection in Bookmarks popup disappears after deleting a bookmark
Shortcuts for plugin actions, assigned via 'use-shortcut-of=""' are not configurable in settings
New Project Wizard: New web project generator
Reformat on Save: Can't be found by 'reformat on save' or 'cleanup on save' in Settings
Currently active result tab gets removed when attempting to remove others
Configure link from VCS root configuration problems notification should open Directory Mappings settings
Changes: Commit message area is not changing color scheme properly
Don't show (1/1) when cherry picking one commit
DROP/CREATE instead of ALTER when editing stored procedure
Make global db not working
Auto udf-generator in Postgresql

New in CLion 2021.3 Build 213.4631.3 EAP 3 (Oct 6, 2021)

"Show Clang-Tidy Info" virtual file treated as regular file
No link to previous declaration in tooltip message when warning located in source file
Use WSL clangd for Makefile projects
Navigation to STL types is not working with WSL toolchain.
'Format code' option on the Actions on Save page could give a choice of file types to process.
Add "Override File Type" to editor tab context menu
seemingly endless indexing loop (PushedFilePropertiesUpdaterImpl restarts on each roots changed event)
Patches not applicable by Toolbox
Provide a way to customize behavior of 'guessProjectDir'
"Invalidate and restart" action deletes content of .idea/libraries directory in projects which use Gradle if Android plugin is enabled
New project model with .iml files stored externally loses `library.xml` in the system directory cache
SSH login dialog never closes if "HostName" is in ssh/config
Unable to open java file in LightEdit mode, UnsupportedOperationException occurs
java.lang.Throwable: Service/component class com.intellij.ide.lightEdit.project.LightEditFileEditorManagerImpl should be derived from class com.jetbrains.rdserver.editors.BackendServerFileEditorManager in order to work with Live Share
Identifier completion does not work in permits clause of sealed class
Add a registry to enable Show Combined Diff action
Display intention documentation if preview is not available
please remove 'new IntentionWrapper(action, file)' calls deprecated after commit 5febffd3490cb79f3689bba02597c6066d50140c
Allow intention actions and fixes to perform custom logic on intention preview
Can't edit nor run Shell Script run configuration when indexes are built
Upgrade version of Javascript for response handler
HTTP response handler script javascript syntax level
What's new tab is opened after second start of a fresh installed IDE
Git checkout: checkout dialog missing underscore char in the branch name in the title
Split and move right does not remember the pinned tab status
Add stats collector for Code Vision
Convert Paths affected In dialogs into toolwindow tabs
VCS settings: can't find gutter settings in the Version Control Confirmation settings via Settings search box or Find action
Add "limit 1 over (...)" syntax by Vertica
DB // Natural sort of numeric columns (CSV)
Remove "database" and "schema" from 'Filter' in Database Explorer
Console output tab: possibility to disable date time output
Can't "alter table" with "update indexes" expression in partitioned tables
Code inspector does not respects SET search_path in function declarationOutput window is only using half the space available

New in CLion 2021.3 Build 213.4293.2 EAP (Sep 30, 2021)

New in CLion 2021.2.1 Build 212.5080.54 (Aug 24, 2021)

New in CLion 2021.2 Build 212.4746.61 RC (Jul 22, 2021)

New in CLion 2021.2 Build 212.4535.17 EAP (Jul 1, 2021)

New in CLion 2021.2 Build 212.4321.2 EAP (Jun 18, 2021)

New in CLion 2021.2 Build 212.4037.2 EAP (Jun 10, 2021)

New in CLion 2021.1.2 Build 211.7442.42 (Jun 1, 2021)

New in CLion 2021.2 Build 212.3116.34 EAP (May 30, 2021)

New in CLion 2021.1.1 Build 211.7142.21 (Apr 28, 2021)

In code assistance and navigation:
Fixed the regression that resulted in slow code completion (CPP-24744).
Fixed the problem with compiler information collection failing and leading to code assistance not working (CPP-24777). The problem occurred if PCH files were passed via “--include=...”.
Fixed the problem with corrupted indexes that caused Find In Files to show no results (IDEA-266391).
Added a new intention to add/remove braces in if, for, while, and do-while statements.
Clangd fixes:
Fixed a problem with Clangd settings that failed to open in some cases (CPP-24742).
Fixed an issue with Clangd greedily allocating all the memory and freezing the system.
For CUDA projects:
Fixed the regression that caused the broken syntax highlighting (CPP-24756) and incorrect compiler information collection (CPP-24802) on CUDA projects.
CLion now uses the gcc compiler from CUDA installation, if it is installed.
We’ve added a few new MISRA checks and fixed a Clangd crash caused by MISRA-related code analysis.
CLion no longer ignores the clion.remote.resync.system.cache registry flag for Makefile projects (the flag specifies if CLion should always re-sync header roots upon project reload) and the Resync with Remote Hosts action is now also available for Makefile projects.
If there are directories on a remote host containing files that the remote toolchain user does not have read access to, the synchronization doesn’t fail now and CLion still tries to synchronize at least the files that the user can access (CPP-24792).
Fixed an issue with ASCII combination (Alt + Numpad) entered in the editor but not working as expected (IDEA-260888).
Fixed the modal dialog freezes on macOS Big Sur (IDEA-256329).
New plugins:
A few new plugins were bundled into this version. Grazie provides intelligent spelling and grammar checks for text that you write in the IDE. To use it in C++ files, turn the grammar checks on in Settings/Preferences | Editor | Proofreading | Grammar:
Grammar check settings:
To add consistent copyright notices throughout your codebase, rely on the Copyright plugin. Find the settings in Settings/Preferences | Editor | Copyright. Learn more in our webhelp.

New in CLion 2021.1 Build 211.6693.114 (Apr 7, 2021)

What's New in CLion:
CLion 2021.1 is enhancing the code analysis experience by upgrading Data Flow Analysis to global mode, expanding MISRA support, and integrating with Clazy for Qt projects. In the debugger, GDB and LLDB have reached feature parity for Core Dump debugging. And finally, remote mode has a wider range of abilities and works consistently across several project models.
Data Flow Analysis:
Data flow analysis (DFA) tracks the flow of data in your code and detects potential issues based on that analysis. In addition to the local DFA (which works within a single function), CLion 2021.1 includes global DFA (which takes a whole translation unit of a program as a single unit for analysis). Global DFA not only enriches the already existing checks but also adds several new unique inspections.
Enhancing local checks with global DFA:
The list of current DFA-based inspections that benefit from global DFA includes:
Dangling pointers – detects pointers that may point to already deleted memory.
Null dereference – detects dereferencing pointers that may contain nullptr.
Endless loops and Infinite recursion.
Constant conditions – detects possible conditions that are always true or false.
Unreachable code and Unused values.
Escape analysis – detects variables containing references to local variables that escape their scope.
New global DFA checks:
A few new inspections have been added that only make sense when analyzing globally – running DFA on a whole translation unit of a program:
Constant function result – reports functions whose return value appears to always be the same constant.
Constant parameter – reports functions where a parameter appears to always be the same constant.
Unreachable function calls – detects functions whose call sites are never executed.
Performance improvements:
CLion 2021.1 also optimizes many steps in DFA. The performance measurements on Postgres, Eigen, and Clangd projects, among others, show that the overall performance is good and that some characteristics have improved (such as the number of files where DFA execution was terminated by CLion because of a timeout).
Dynamic analysis:
Branch coverage:
In addition to line coverage, CLion 2021.1 can now also calculate Branch Coverage. This method takes into account all the branches of each control structure. Run your CMake application or tests with coverage and check out the new column that’s been added to the Coverage tool window.
Branch coverage is enabled by default and can be adjusted in Settings | Build, Execution, Deployment | Coverage, but it only works with GCC/gcov or version 12.0.0 and higher of LLVM/llvm-cov.
Dynamic analysis in Remote mode:
In order to reach feature consistency across all toolchains, project models, and configurations, CLion 2021.1 makes it possible for Google Sanitizers, Valgrind Memcheck, and Code Coverage to work with remote toolchains.
MISRA C and C++ checks:
CLion 2021.1 adds more checks from MISRA C 2012 and MISRA C++ 2008. The full list is maintained on our confluence page and allows you to easily track the progress.
Postfix completion for C and C++:
Postfix code completion for C and C++ lets you add code around an expression you’ve just typed. It can wrap an expression with a frequently used language construct, or pass the expression as the first argument of a free function.
Wrap the expression with language construct:
Postfix templates can help you with common language constructs. Type an expression then a dot, and then add the postfix template abbreviation and press the expansion key, or select the required template from the completion list that appears. The expanded template will wrap the given expression. Find the full list of templates in Settings | Editor | General | Postfix Completion.
Pass the expression to a free function:
Use postfix code completion to pass the expression you’ve just typed to a free function as the first argument. Type an expression, then a dot, and select a free function from the completion list that appears.
Enhancements for Makefile projects:
Initial support for Remote Makefile projects:
CLion 2021.1 allows you to work with Makefile projects on a remote machine. Change the toolchain in the Makefile settings to a remote one, then reload the project and it will synchronize with the remote machine. Compile, run, and debug your application remotely from your locally running CLion.
Makefile Language plugin:
The Makefile Language plugin (previously 3rd-party) is now maintained by the CLion team and comes bundled in CLion. The plugin provides make syntax highlighting, quick documentation, Find Usages for targets, and a variety of navigation and code completion actions for Makefile.
Enhancements for CMake projects:
Share CMake Profiles in VCS:
CMake Profile settings in CLion are now stored in a cmake.xml file in the .idea directory and can be shared in the VCS along with the project. Simply select the Share option in Settings | Build, Execution, Deployment | CMake.

New in CLion 2021.1 Build 211.6693.66 EAP (Apr 2, 2021)

Code: Completion:
Bug: Postfix Completion swallows comma
Code: Highlighting and Inspections:
Bug: clangd doesn't support rv32imafc architecture
Dynamic Analysis Tools:
Bug: Run with profile failed on Apple Silicon
Performance: Clion Remote SSH Code Coverage Performance (EAP)
Core. Diagrams:
Bug: Java Enterprise toolwindow: CDI Dependencies diagram is opened without layout
Bug: UML diagrams: Kotlin: tooltip over package item shows wrong statistics
Bug: Spring Beans toolwindow: the beans graphs appear without layout
Bug: CDI Dependencies diagram is always empty
Bug: CDI Dependencies diagram action appears outside the Diagrams menu group and causes exception only
Bug: UML diagrams: Kotlin: constructor is shown for object
Bug: JSF Navigation diagram: no layout on diagram opening
Bug: JSF Navigation diagram: on unchecking the ShowSelectedNodesWithDependencies the resulted diagram layout is incorrect
Usability: Add the ApplyCurrentLayout action to the context menu for the toolbar-less diagrams
Exception: Throwable: Read access is allowed from event dispatch thread or inside read-action only
Core. Indexing:
Bug: IntelliJ IDEA 2021.1 beta 4 cannot resolves JDK classes
Bug: VFS cache can't recover automatically after content storage corruption
Core. Licensing:
Bug: Broken license dialog UI when user has several licenses
Core. Plugin Management:
Exception: Plugin installation failure - StackOverflowError in findPluginExtensionPointRecursive
Core. Project Settings:
Bug: IJ resets content root to the incorrect directory
Bug: Maven projects can't be built after disabling the (not used) dependency
Tools. Docker Bug IDEA-264653 Docker. Before launch. Compose in compose parent task doesn't run
User Interface Bug IDEA-265418 'Subpixel' mode is default for the Editor on macOS
User Interface. Navigation Bug IDEA-265505 Backspace doesn't update speed search results in recent files
Bug IDEA-264890 Recent Files / Switcher chooses the first item by default
Code Insight Bug PY-47281 Fuzzy completion of not imported qualified names suggests definitions from internal modules (starting from underscore)
Inspections Bug PY-39262 False positive "Local variable might be used before assignment" when using assignment expression as part of and expression
Connectivity Bug DBE-12522 Incorrect icons for basic support drivers
Query Console Bug DBE-8092 Database Console Editor Tab Filename Includes Path

New in CLion 2020.3.3 Build 203.7717.62 (Mar 16, 2021)

New in CLion 2021.1 Build 211.6305.15 EAP (Mar 5, 2021)

Branch Coverage:
If you ever ask yourself how well your code is covered with tests, code coverage tools may help answer the question. Code coverage integration in CLion is available on all three platforms (Linux, macOS, and Windows) and with any toolchain (local, remote, or WSL), but only for CMake projects.
When you measure your code coverage, there are several criteria and approaches to how to do it. Previously, CLion was only able to measure Line Coverage (for GCC and gcov) and Statement Coverage (LLVM and llvm-cov). It showed how many lines/statements in your code (in %) were executed while running the tests.
But now, starting with this 2021.1 build, CLion can also show Branch Coverage. It takes into account all the branches of each control structure. For example, given an if statement, it can tell you if both the true and false branches have been executed.
In the CLion UI, this is displayed in the Code Coverage tool window, in the column next to the Line Coverage.
Please note that branch coverage is supported for LLVM version 12.0.0 and higher and for any version of GCC. It’s enabled by default in Settings/Preferences | Build, Execution, Deployment | Coverage. However it does nothing if your LLVM is older than 12.0.0.
It is also important to note that GCC and the gcov tool consider the compiler-generated branches when calculating branch coverage. This might affect the results if, for example, you use exception handling.
We’d like to thank zero9178, the author of the 3rd-party plugin C/C++ Coverage for CLion, who inspired us to add Branch Coverage to CLion.
Move execution point in disassembly view:
The Set Execution Point action lets you jump to an arbitrary line of code in the editor during a debug session and set the execution point there, skipping all the other commands in between. It now works in the disassembly view, so you can move the execution point while stepping through the assembly code.
New MISRA C and C++ checks:
We’re continuing to add MISRA C and C++ checks to CLion. A table with all supported checks can be found here. This time we added such fixes as:
The unary & operator shall not be overloaded
A pointer to a virtual base class shall only be cast to a pointer to a derived class by means of dynamic_cast
The statement forming the body of a switch, while, do … while or for statement shall be a compound statement
and a few others.
If you endeavor to comply with MISRA C or MISRA C++ guidelines in your project, please let us know if you find the CLion checks helpful. Thank you!
Initial support for Remote Makefile projects:
CLion now comes with support for Makefile projects with remote toolchains. They previously didn’t work together, as the full remote mode was only supported for CMake projects. But starting with this 2021.1 EAP build, CLion can handle remote Makefile projects! There are still a few limitations for it, so read on before giving it a try.
Like before, you can work on a macOS, Linux, or Windows desktop targeting a remote Linux machine connected via SSH, and the project source code should be located on the local machine. The CLion instance runs locally and synchronizes the source code to the remote machine, where it performs compilation using host compilers. You can run and debug your application or unit tests on a remote machine from the locally running CLion.
To make it work for your Makefile project:
Change the toolchain used by your Makefile project in Settings/Preferences | Build, Execution, Deployment | Makefile to a remote one configured in Settings/Preferences | Build, Execution, Deployment | Toolchains.
Call Tools | Makefile | Clean and Reload Makefile Project.
CLion will synchronize the project with the remote machine and will reload it for you.
A new Open Remote Host Terminal action
Sometimes when working with a remote project in CLion, you might want to open ssh to the remote host and execute some command in the project directory. Tools | Start SSH Session… can help you with that, but it won’t open the current project directory on a remote host by default. So we’ve added a new Tools | Open Remote Host Terminal action to do exactly that – it opens the project directory on the remote host if it exists. The remote host corresponds to the currently selected remote profile, or, if a local one is selected, the first remote profile found in the project.
The action works for both remote CMake and remote Makefile projects supported currently in CLion.
We’ve also improved performance for the CMake load step when a remote toolchain is used (CPP-17421).

New in CLion 2021.1 Build 211.6085.16 EAP (Feb 19, 2021)

New in CLion 2021.1 Build 211.5787.12 EAP (Feb 11, 2021)

Main highlights:
Qt projects:
Clazy: CLion now has a Qt-oriented static code analyzer.
QtCreator keymap.
Makefile projects:
Makefile plugin is now bundled.
Use compilers from toolchain during Makefile project resolution.
CMake projects:
You can now share CMake options in VCS.
CMake Profile Wizard is added.
Go to declaration performance improvements.
A new inspection: catching unmatched header guards.
Qt projects:
In CLion 2020.3 we added more sophisticated support for Qt projects that included code completion for signals and slots, Qt-style auto-import, and some Qt projects and Qt UI class templates. We’re not stopping there!
In this EAP we’ve integrated Clazy, a Qt-oriented static code analyzer, into CLion. We did it in the same way we implemented the Clang-Tidy integration, meaning checks appear in the editor similarly to how they are displayed in CLion’s own static analyzer.
Clazy is integrated into CLion’s own language engine based on Clangd, and the version currently used in CLion is 1.8.
In Settings/Preferences | Editor | Inspections | C/C++ | General | Clazy settings you can configure CLion’s severity level and the level of Clazy checks.
If you’re coming from QtCreator, you’ll be happy to know that CLion now bundles the QtCreator keymap. You can switch to it in Settings or via a Quick Switch Scheme action.
Makefile projects:
The Makefile Language plugin (previously 3rd-party) is now maintained by the CLion team and is bundled into CLion and GoLand in 2021.1 EAP.
You no longer need to install the plugin manually, so you now get make syntax highlighting, quick documentation, Find Usages for targets, and some navigation and code completion actions for Makefile right out of the box!
When loading a Makefile project, CLion now not only uses the make executable from the Makefile Toolchain, but also takes compilers from it (if configured explicitly in the corresponding Toolchain). This renders our Makefile project support more consistent and accurate.
CMake Profiles:
CMake Profiles, which are used when building projects via CMake, can be configured in Settings/Preferences | Build, Execution, Deployment | CMake in CLion. These settings are now stored in cmake.xml in the .idea directory and can be shared in the VCS along with the project. Simply tick the Share option in the settings. This new ability makes it much easier for the team to share a single CMake setup between all members!
Users can have both shared and local profiles (local profiles always go first in the list of profiles in settings) and switch between them in the editor.
Known limitations:
CMake Profiles with the same name are not allowed. If a shared and a local profile both have the same name, the local profile takes precedence and the shared one won’t appear in the settings.
Only CMake Profile settings can be shared. The “Reload CMake project on editing CMakeLists.txt” setting is common for all profiles and is stored in workspace.xml.
CLion now comes with a CMake Profile Wizard which helps users configure Toolchains and CMake Profiles for the first time. Depending on whether the project has previously opened, the process may include the following steps:
The Toolchains step is shown only if CLion is being launched for the first time and settings were not imported.
The CMake profiles step is shown if the project is opened for the first time (i.e. if the .idea directory is missing) or if workspace.xml or cmake.xml is missing in .idea or all the profiles are disabled.
Improved navigation performance for the Eigen library:
The most widely used navigation action, Go to Declaration, now works faster in the Eigen library (CPP-15082).
Catching the unmatched header guard:
We’ve added a new static code analysis check to catch situations when the comment at the #endif preprocessor directive doesn’t match the macro name from the #ifndef.

New in CLion 2020.3.2 Build 203.7148.70 (Jan 28, 2021)

New in CLion 2020.3.1 Build 203.6682.181 (Dec 31, 2020)

New in CLion 2020.3 Build 203.5981.166 (Dec 3, 2020)

CLion 2020.3 brings significant, eagerly anticipated improvements to key parts of the development process – code analysis, running and debugging applications, and unit testing. For embedded projects, CLion now comes with initial MISRA C and C++ support. And Qt users can benefit from IDE features tuned specifically for working with Qt code.
Debugger:
Debug as Root:
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.
Debugging with Core Dumps:
A new Run | Open Core Dump… action available for Linux and macOS allows you to open an existing core dump of a crashed process in CLion and debug it there. Users can inspect the frames and variables view, check the memory and disassembly view, evaluate expressions, and run debugger commands from the debugger console. Read more about this feature’s configuration process and known limitations.
Set Execution Point:
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.
Interactive hints and Inline watches:
Now when the application is running in debug mode, the editor displays clickable inline hints that you can expand to see all the fields belonging to a given variable. Moreover, you can change the variable values inside the drop-down list or add an arbitrary expression as an Inline Watch to this place in the code.
Run settings:
Configure environment with a script:
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.
Edit configurations while indexing:
No more waiting! Run/Debug configurations can be edited while the project is being indexed.
Unit testing:
CTest support:
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.
Test runner for Google Test:
Version 2020.3 enhances CLion’s support for Google Test, the most popular C++ unit testing framework in the world (Developer Ecosystem Research in 2020 shows that 31% of C++ developers use Google Test).
Updates include:
The full test tree is displayed immediately in the built-in test runner, and then the tests are executed.
For parameterized tests, CLion now displays test parameters right in the test tree.
Disabled tests (those with the DISABLED prefix in their names) are now also shown in the test tree with the corresponding icon.
Code analysis and refactoring:
MISRA C and C++:
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.
Unused value:
CLion 2020.3 improves the Unused Value inspection, which catches situations where a variable value is never used after it has been assigned. It can now also be tuned to follow the style that recommends using default variable initializers. A new option to turn the inspection off in such cases has been added to the settings.
Extract Lambda Parameter:
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.
Code completion:
Clang completion snippets:
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.
Completion for templates:
CLion 2020.3 improves code completion, as it now works much more accurately with template types. For example, completion options are displayed for container elements and iterators in the function template.
Qt projects:
Create a new Qt project:
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.
Create a new Qt UI Class:
A new QT UI Class item in the New menu (Alt+Insert) helps you simultaneously create a Qt class along with a .ui file. Fill in the class name and select the parent class (QWidget, QMainWindow, or QDialog). .h/.cpp/.ui files will be generated using the Filename base as their file names. The generated files follow the templates listed in Settings/Preferences | Editor | File and Code Templates – Qt Class, Qt Class Header, and Qt Designer Form.
Complete signals and slots:
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.
Auto-import in Qt style:
Auto-import suggestions in Qt projects in CLion 2020.3 are tuned to follow the most commonly used style for Qt.
Makefile projects:
Support for projects using libtool, dolt, and ccache:
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.
Run/Debug configurations:
Setting up a Makefile project in CLion is now even easier – the Run/Debug configurations are created automatically for the targets in the top-level Makefile when loading the project. Now to run and debug, you just need to point the configuration to the built executable.
Recompile single file:
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!
CMake:
Enable/Disable CMake Profiles:
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.
VCS:
Git tab in Search Everywhere:
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.
UI updates:
The VCS menu is now named according to the version control system in use. We’ve made the menu more concise, removing all but the most useful actions for versioning your project.
Additionally, now the two most popular buttons – Commit and Commit and Push… – are explicitly shown on the Commit screen.
Git staging support:
You can now stage changes directly from CLion. To enable this feature, go to Preferences/Settings | Version Control | Git and tick the Enable staging area checkbox. Click the + icon to add your files to the new Staged node in the Commit view. You can also stage changes right from the gutter or in the Diff view.
Remote development:
Automatic update of Exclude paths:
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.
Code With Me:
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.
UI update:
Updates to Welcome screen:
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.
Splitting an editor:
It’s now possible to split an editor by dragging and dropping a tab to the side of the main editor window. The Open in Right Split action splits the editor vertically upon opening a file.
You can invoke the action from the Project view or from other navigation popups, such as Recent Files and Search Everywhere (Shift+Enter).
IDE theme synced with OS 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.
Rust plugin update:
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.

New in CLion 2020.3 Build 203.5981.106 RC (Nov 27, 2020)

New in CLion 2020.3 Build 203.5784.34 EAP (Nov 13, 2020)

New in CLion 2020.3 Build 203.5600.25 EAP (Nov 10, 2020)

New in CLion 2020.3 Build 203.5419.20 EAP (Oct 29, 2020)

New in CLion 2020.3 Build 203.4818.55 EAP (Oct 15, 2020)

New in CLion 2020.2.4 Build 202.7660.37 (Oct 8, 2020)

New in CLion 2020.2.3 Build 202.7319.72 (Sep 18, 2020)

New in CLion 2020.2.2 Build 202.7319.62 (Sep 16, 2020)

No subsystem:
CMake panel doesn't apply changes when changing order of profiles
Manage toolchains link is not working in Preference for New Project
Removing current SSH hosts doesn't impact remote toolchain
Code - Highlighting and Inspections:
Wrong inspection 'Expression can be simplified
"Value is never used" does not work for nlohmann json type
Code - Intention Actions:
Wrong simplified expression when comparing the result of a bitwise boolean operation
Code - Refactorings:
Extracted function must be static in a static context
Extract method incorrectly adds const
Debugger - LLDB:
Cannot debug Doctest on Windows
Running:
Makefile Application configuration is not clickable in Run Configuration for New Projects
Toolchains:
Remote build issues after updating 2019.3.x -> 2020.2
Core. File System:
V2020.1 Won't Save To Disk
Core. IDE Settings:
Endless "Can't get shell environment" warnings in the log
Core. Navigation and Search:
Unable to navigate to enum constructor since 2020.2
Show enum constant usages on mouse middle-click
Core. Plugin Management:
IntelliJ Stuck Analyzing
Core. Project Settings:
AddModuleWizard class allows null to be passed to a NotNull method parameter.
Core. Run. Configurations:
Do not store relative path to bundled JDK in settings.
Core. SSH:
DB connection configuration dialog ignores selected ssh tunnel
Improper handling of connection to SFTP deployment servers which utilize 2FA
Editor:
Weird behavior when cursor is inside rendered Doc
Unable to open file in project mode from command line when another project is already open
Use LightEdit mode only for selected file extensions only
Editor. Code Completion:
Unable to toggle "Quick Documentation" and "Quick Definition" in the suggestion list
Tools. Terminal:
"Run IDE features from the Terminal" not working on Windows when git-bash is used as terminal shell
Version Control. Git:
New git merge dialogs - needs additional clicks to modify options
Merge git branch alphabetical order
Version Control. GitHub:
GitHub Pull Request: shortcut for leaving comment while reviewing changes
For remotes with github.com GitHub account is not used, regular Git login is requested
GitHub Pull Requests: "add review comment" icon is shifted when soft wrapping is enabled
Console:
FutureWarning in Python/Django Console
Console hangs after a period of inactivity
Inspections:
False positive: unexpected arguments for the new record if Flask-SQLAlchemy is used
Refactoring:
Rename refactor in string shows raw implementation method names
DB Connectivity:
Database connect - Username and password fields have vanished
DB Refactoring:
Submit changes to database (SQL Server) no longer working for PROC

New in CLion 2020.2.1 Build 202.6948.80 (Aug 26, 2020)

New in CLion 2020.2 Build 202.6397.78 RC (Jul 24, 2020)

New in CLion 2020.1.3 Build 201.8743.17 (Jul 22, 2020)

New in CLion 2020.2 Build 202.6250.12 EAP (Jul 15, 2020)

New in CLion 2020.2 Build 202.5428.21 EAP (Jun 11, 2020)

New in CLion 2020.1.1 Build 201.7223.86 (Apr 30, 2020)

New in CLion 2020.1 Build 201.6668.126 (Apr 14, 2020)

CUDA projects:
CUDA C and C++ are essentially C/C++ with a few extensions, and CLion 2020.1 is now able to handle CUDA code correctly. Most of our effort was put into teaching CLion’s language engine to parse such code correctly, eliminating red code and false positives in code analysis. The enhanced support also includes code navigation, code documentation, and other code assistance actions that work within CUDA code. And finally, code completion was expanded to complete angle brackets for kernel calls.
Additionally, CLion now supports CUDA file extensions – .cu/.cuh. You can select them when creating new C/C++ files. By the way, did you know that CLion suggests CMake targets to add your newly created files to? Now CUDA targets (created with cuda_add_executable / cuda_add_library) are added to the list of possible options to select from.
Finally, you can start a new CUDA project in CLion – the New Project wizard helps you generate the sample CMake and main.cu files. Learn more about how to work with CUDA projects in CLion in our webhelp.
Embedded development:
We keep improving CLion for embedded development, and in this release we’ve taken two important steps forward. The first is IAR compiler support. CLion can now collect compiler information correctly, making it possible for you to successfully use the compiler in your embedded projects. Here are a couple of useful tips to get you started with the IAR compiler:
MinGW is required. Use the MinGW environment in the IAR toolchain settings in CLion and provide paths to the IAR compiler in the corresponding fields.
Check out these notes on how to use CMake with IAR Embedded Workbench.
We’d like here to once again thank IAR Systems AB for their support and partner licenses. And we’d also like to assure our readers that we’ll continue the collaboration. Our next goal is to further investigate integration with this toolchain.
Our second big step forward is the ’PlatformIO for CLion’ plugin. PlatformIO is a new generation ecosystem, and it can be super useful for getting started quickly with an embedded development project (for example, for Arduino). The plugin generates a PlatformIO CMake-based project when the corresponding project type is selected in the New Project wizard, calling a proper PlatformIO command for you in the background.
For such projects, CLion automatically creates configurations for debug and upload. You can also create a PlatformIO Debug configuration to use the PIO Unified Debugger. Read on for more details in the official documentation.
Windows projects
We’ve seen a growing number of developers on Windows using CLion. Actually, Windows is a primary platform for our users, according to our statistics. That is why we have focused on a few of the most popular requests from the Windows community.
Clang is the second most popular compiler after GCC (according to The State of Developer Ecosystem 2019 study). Microsoft Visual Studio Compiler is of course the leader on Windows, but Clang-cl is also widely used. You can install it from the LLVM website or along with the Visual Studio tools. And it’s now possible to use it within CLion!
Another good piece of news for Windows developers is that the LLDB-based debugger developed by JetBrains for the Visual Studio C++ toolchain is now the default debugger for this toolchain. So you can start using it right away! In the screenshot above, you can see it’s preselected for the Visual Studio toolchain. Please note that this debugger is not a regular LLDB build. Rather, it is developed by the JetBrains team and can handle Native Visualizers (to enable Native Visualizer support, go to Settings | Build, Execution, Deployment | Debugger Data Views | Enable NatVis renderers for LLDB).
Clang-based tools update:
In another important development, our team is moving to our Clangd-based language engine wherever possible. There are two main reasons behind this move. First, we want to develop more accurate language features to catch up quickly with the recent updates to the language standard. Second, we want to improve the performance of language agnostic actions (which is not always possible with Clang, but we continue to experiment with more features).
In CLion 2020.1 we’ve moved Dataflow Analysis fully to Clangd. What is DFA, and why is it useful? DFA checks analyze how data flows through your code and detect potential issues based on that analysis. For example, they identify conditions that are always false or always true, endless loops, missing return statements, infinite recursion, and more.
Most compilers don’t do that for you. For sure, DFA requires very accurate code parsing and resolve, and it can take a significant amount of time, especially when the underlying resolve is slow. So moving to Clangd is a step toward improving the performance of such analysis checks.
In previous versions of CLion, we introduced a Clangd-based completion provider. But at that time it worked in combination with CLion’s own providers. During the 2020.1 iteration, we polished the completion provided by Clang (by fixing dozens of related issues and adding missing completion features) and finally enabled the mode in which Clang is the only provider for code completion in CLion as the default. This resolves some prioritization and ordering issues.
ClangFormat and Clang-Tidy are standard tools for many C++ projects, and their config files are often committed to project repositories. CLion’s integration for these tools, however, was not switching to them automatically. We sincerely thank our users who pointed out this inconvenience! CLion now:
Detects the .clang-format config file in the project root and switches to ClangFormat for you automatically (note that the IDE switches to per project settings at this moment).
Detects the .clang-tidy config file and automatically turns off the use of the IDE settings for Clang-Tidy in favor of this config file.
We do hope this makes working with these two Clang tools much nicer for you!
Refactorings, formatter, documentation, and editor enhancements:
With CLion you receive many useful refactorings, and one of the most popular is Change Signature (Ctrl+F6 on Windows and Linux, ?F6 on macOS). It allows you to change the function name and return type, as well as add, remove, and reorder parameters. And the biggest value (in comparison to manually updating the function) is that when changing a function signature, CLion searches for all usages of the function and updates all the calls, implementations, and override replacements of it that can be safely modified to reflect the change.
Here you might ask: What happens to a function usage when a new parameter is added? Previously, CLion added the default type value to the usages as an argument (i.e. 0 for numerical, nullptr for pointers) in order to keep your code compilable. With CLion 2020.1, you can tell CLion right in the refactoring dialog which value to substitute across all updated function usages
Note the code completion available in the new Default value field in the dialog! If you keep the field blank, the old behavior is applied and the default value for the type is used.
The formatter has been updated in this release, with new separate naming settings for struct member fields and class member fields. And code foldings now work for #pragma region and #pragma endregion.
Other editor updates include:
Quick Documentation – a universal tool to preview documentation and get information about function signature, inferred types, and macro replacement – is now available on mouseover.
The default font in the editor has been changed to JetBrains Mono, a new open source font created by JetBrains.
A new default light theme – IntelliJ Light – is now the standard theme across all the different operating systems.
And if you need several terminal sessions to work with at once, you can now split your terminal vertically or horizontally so that you can run multiple sessions side by side.
Run/Debug configurations
Run/Debug configurations help you launch applications for running and debugging them from within CLion. In this release, they’ve received several important updates:
The Remote GDB Server and Embedded GDB Server configurations now work with custom targets. This allows you to debug your application on a remote host or on the microcontroller from the CLion instance running on your local machine, not only in CMake-based projects but in any custom applications (including compilation database).
Google Test targets for v1.8.1 and higher are now recognized correctly in CLion, and corresponding Run/Debug configurations are created automatically (making it possible to run tests in CLion’s built-in test runner).
CLion 2020.1 brings macros and path variables to Run/Debug configurations:
Macros are predefined, and you can look through the list of available macros in the dialog that opens when you click on a plus sign in the Run/Debug configurations dialog. Note that macros are only available for CMake, Custom Build, and Gradle Native Applications at the moment.
Path Variables can be configured in Settings/Preferences | Appearance & Behavior | Path Variables. The typical use case is to create a Path Variable for a library that is used widely in your projects but that is located outside the project directory.
The Prompt/FilePrompt macro is especially useful when combined with the new Redirect input from field in the configuration. This field helps you redirect input from a file to the stdin of your application, and the FilePrompt macro invokes a file selection dialog every time the application launches.
IntelliJ Platform updates:
As usual, VCS and other IntelliJ Platform improvements are coming to CLion, in addition to an update for the IntelliJ Rust plugin. More info on the latter will be published separately very soon, so stay tuned!
What’s going on with Makefile support:
Whoa whoa whoa! Who said anything about working on Makefile support in CLion?! Well, whoever they were, they were correct. We’ve built a prototype of the Makefile project analyzer inside CLion and did a blog post on the approach we took and the state of the current solution. And with the help of our faithful users, we’ve built a list of projects for testing this prototype.
There are approximately 40 projects on the list at the moment, and more than half of them have been checked (CPython, some embedded projects, Nano, Nodejs, PostgreSQL). For the most part, they worked fine. Still, there are some projects on which the prototype failed (for example, because of wrappers like libtool). You can find GCC, FreeBSD, Wine, and Perl among these unsuccessful projects. There are also some brave users who tested the prototype on their private projects and gave us some really valuable feedback! Thank you all for that.

New in CLion 2020.1 Build 201.6668.86 RC (Apr 3, 2020)

New in CLion 2020.1 Build 201.6668.10 Beta (Mar 25, 2020)

New in CLion 2020.1 Build 201.6487.17 EAP (Mar 19, 2020)

New in CLion 2020.1 Build 201.6073.20 EAP (Mar 5, 2020)

New in CLion 2019.3 Build 193.4697.8 EAP (Oct 16, 2019)

New in CLion 2019.3 Build 193.4099.17 EAP 3 (Oct 7, 2019)

New in CLion 2019.3 Build 193.3793.19 EAP 2 (Sep 26, 2019)

New in CLion 2019.3 Build 193.3519.24 EAP (Sep 19, 2019)

New in CLion 2019.2.2 Build 192.6603.37 (Sep 12, 2019)

Code: Documentation:
Task CPP-16321 Provide default black list for C++ parameter name hints
Bug CPP-16652 Wrong name hint if literal operator is used inside function call
Usability CPP-17012 Add parameter hint before NULL
Bug CPP-17105 Don't show parameter hint before NULL in case of non-pointer
Debugger: LLDB:
Bug CPP-17126 Bundled LLDB doesn't work on macOS 10.15 Catalina
Code: Clangd:
Bug CPP-16345 Name hints do not handle brace elision in aggregate initialization
Bug CPP-16627 Hint '&' in pack expansions
Task CPP-16823 Namehints and Comments
Bug CPP-17103 Namehint for BinaryOperator with multiple macros
Code Analysis. Inspection:
Bug IDEA-219976 False alarm "class, interface, or method should not be extended"
Core:
Performance IDEA-220475 Freeze on project opening
Core. File System:
Bug IDEA-219943 PsiModificationTrackerImpl.incLanguageModificationCount() does not always attribute a PSI change to the correct language
Exception IDEA-121210 "VirtualDirectoryImpl#compare: PersistentFS returned duplicate file names ..." on case-insensitive FS
Core. IDE Settings:
Bug IDEA-211731 Settings for New Project aren't saved
Core. Platform API:
Bug IDEA-220367 Deprecate and avoid usage of `UElement.getLanguagePlugin()`
Bug IDEA-220618 IDEA can freeze when indexing is paused
Editor. Diff and Merge:
Bug IDEA-220302 Regression in 2019.2: CacheDiffRequestChainProcessor does not honor myRequestChain.getIndex()
Editor. Editing Text:
Bug IDEA-220351 Expandin collapsed blocks dont setup cursor to correct position
Bug IDEA-219192 Can't see hard wrap guide.
Cosmetics DEA-208775 "Enable font ligatures" unable to click on popup
Infrastructure. Packaging and Installation:
Bug IDEA-219214 Patch update from 2018.3 to 2019.2 doesn't work
Plugin. Shell Script:
Bug IDEA-220072 Bash functions missing in the Structure view
Bug IDEA-219928 Builtin Shell Script plugin causes color syntax error after bash variable substitution using escape character as last character in replacement string
Plugin. Terminal Bug:
IDEA-221853 Terminal crashes
Services. Docker Feature:
IDEA-210768 Docker. Support --ulimit command line option
Feature IDEA-218179 --network is not a recognized docker build option
Bug IDEA-217917 Services. Docker. Two "Jump to Source" navigation items from the deployed containers/compose apps
Bug IDEA-179900 Docker exec tab does not correctly wrap
Bug IDEA-207582 Cannot use more than one terminal in container using exec `/bin/bash`.
Exception IDEA-219940 Docker: com.github.dockerjava.api.exception.NotFoundException: {"message":"no such exec"} at attempt to edit some exec tabs
Services. SSH:
Bug IDEA-220121 SSHJ: SSH authentication fails when the only authentication method is a One-Time Password via keyboard-interactive
Bug IDEA-220693 SSHJ: Authentication process terminates if kerberos authentication fails
User Interface:
Feature IDEA-218792 Skip minimised and fullscreen windows in Activate Next Window action
Bug IDEA-192504 Enter Full Screen & Exit Full Screen does not execute when invoked via find action
Bug IDEA-153291 IDE opens on a last known location when external monitor is detached: outside of screen
Bug IDEA-219898 Double shift on modal makes it no responsible
Bug IDEA-199472 Tool windows broken when opening project
Exception IDEA-202927 Exception occurs on applying "Show F1, F2, etc. keys on the Touch Bar" option
User Interface. Controls:
Bug IDEA-219939 Missing scrollbars don't allow to properly edit Run Debug configurations
User Interface. Find, Replace, Usages:
Feature IDEA-109899 Automatically escape special symbols for "Find" and "Find in Path" dialogs if "Regex" ("Regular Expression") is checked
Bug IDEA-219877 Shortcut for Open in Find Window in Find in Path on Mac is Ctrl+Enter although tip says Cmd+Enter
User Interface. Focus:
Bug IDEA-221400 Projects stop switching using Cmd+` after exiting full screen
User Interface. Keyboard Input:
Bug IDEA-219266 Navigation Bar dropdown doesn't show up on ⏎ key in 2019.2
Bug IDEA-218926 Stretch left keybinding doesn't work
User Interface. Look and Feel:
Bug IDEA-219715 Borderless: ellipsis in window title when moving between displays with different DPI
User Interface. Navigation:
Bug IDEA-200255 New 'Go to Class' dialog sometimes doesn't show anything
User Interface. Project View:
Bug IDEA-215752 Nested sources folder not showing in Project view after updating to 2019.1
Version Control. Git:
Usability IDEA-219644 For multi-module project - single module branch compare shows multiple module diffs
Code Insight:
Bug PY-36004 Support named Unicode escapes (N{name}) in re
Bug PY-36003 Allow 'continue' in 'finally' clause
Console:
Bug PY-37204 Python Console documentation/parameters info don't work
Bug PY-37078 "AttributeError: can't set attribute" on opening debugger interactive console
Debugger:
Bug PY-35999 PyCharm doesn't take "Ignore library files" option into account while debugging
Bug PY-36942 Placing breakpoint in runtime in a template kills Python process
Bug PY-37012 Paths passed to _NormPaths must be str
Bug PY-36993 Debugger ignores breakpoints on the last scope line with IPython 7
Bug PY-37150 Exception when starting debugger on pytest: 'NoneType' object has no attribute 'f_locals'
Bug PY-37188 Slice evaluation in Data Viewer shows util variable name (like __py_debug_temp_var_262330507)
Bug PY-37124 Breakpoint in "server.py" are ignored
Inspections:
Bug PY-37054 False "line too long" erros
DB Console:
Feature DBE-1878 Database console: on switching to deselected schema suggest quick fix to select it in data source properties
DB Diff:
Feature DBE-8977 Compare table contents
Bug DBE-8995 Database diff case unsensitive not fully working
DB Introspection:
Bug DBE-9015 Server crash issue when using DataGrip with AWS Aurora
DB Refactoring:
Bug DBE-9017 When adding a SMALLINT type column with width and UNSIGNED, the width digit ignored.
Data Views:
Bug DBE-9021 Navigating to referenced and referencing rows from data grid doesn't put quotes around UUID's.
Navigation & Search:
Feature DBE-8897 Full text search enhancement - result list(s) should be ordered
Bug DBE-8963 When Ctrl+clicking on a table name in SQL, the Database window doesn't quite scroll that table on the screen
SQL Completion:
Bug DBE-4713 SQL completion failing on create table
Bug DBE-9046 Database tools: no autocomplete for table name when typing 'alter table' with postgres
Usability DBE-8918 'VARCHAR' is completed as 'VARCHAR()'
SQL Format and Style:
Feature DBE-7551 FOR XML formatting
Feature DBE-8451 Oracle: align CONSTANT keyword
Feature DBE-8321 EXPLAIN should be fromatted similar to CREATE VIEW
Bug DBE-8334 Unnecessary space before comma in ALTER TABLE when several ADD instructions
Bug DBE-8986 Extra indent of the line after where clause
Bug DBE-8328 SQL code style should support RETURNING on a separate line
Bug DBE-5853 indent incorrect with ms sql server-style column aliasing
Bug DBE-8841 SQL formatting: "New line after ALL, DISTINCT" doesn't work when the comma at first
Bug DBE-8666 Redshift: formatting SQL breaks syntax
Bug DBE-6170 The "Place comma" setting is ignored when "Wrap" is set to "Wrap if long"
Bug DBE-8974 SQL Pre-formatter doesn't handle commas when the setting is specified in the Common section
Bug DBE-8888 Indent Missing in SQL Formatting of While Loops in Stored Procedure SQL files:
Bug DBE-7497 Align of data types in alter instructions of SQL formatting is broken in 2018.3.1
Bug DBE-8452 Oracle: align CASE Expressions in pl/sql block
Bug DBE-8951 Stupid formatting of subqueries when they are not collapsed
Usability DBE-8978 The combination of Code Style settings and source line breaks cause ugly result
SQL General:
Bug DBE-6474 DataGrip does not operate properly with identifiers containing CRLF
Bug DBE-6538 Oracle SQL plus dialect: formatting changes and corrupts the query
SQL Generation:
Bug DBE-8962 Wrong Snowflake DDL generation
SQL Highlighting:
Bug DBE-9006 Unreachable code inspection is reported for Oracle package
Bug DBE-8939 "unreachable code" error when viewing an SQL Server stored procedure
Bug DBE-9003 Datagrip editor showing syntax error for amazon redshift query. In the attached screenshot when the isnull statement is in the same line as select clause the query gets executed but when the isnull is in second line it gives a syntax error.
Bug DBE-8940 Postgres SQL editor does not support PARTITION BY HASH
Bug DBE-7491 Add syntax highlighting for PL/pgSQL "special commands" (#variable_conflict)
Bug DBE-8398 False positive "unreachable code" warning
Bug DBE-3773 SQL: Inspections: Sybase: Ambiguous column reference: two different columns cannot have the same alias
Bug DBE-7455 MariaDB EXCEPT and INTERSECT support
SQL Refactoring:
Bug DBE-8807 [PLUGIN] Unable to rename table variable
Bug DBE-7709 Incorrect placing for table's alias
Usability DBE-8960 'Expand column list' should be available if caret is after '*'
SQL Resolve:
Bug DBE-5033 DataGrip does not recognize trigger logical tables DELETED/INSERTED when using ALTER TRIGGER
Bug DBE-5766 Unresolved savepoint

New in CLion 2019.2 Build 192.5728.28 Beta (Jul 12, 2019)

New in CLion 2019.2 Build 192.4488.4 EAP (May 30, 2019)

New in CLion 2019.1.2 Build 191.6707.69 (Apr 19, 2019)

New in CLion 2019.1.1 Build 191.6707.62 (Apr 17, 2019)

Embedded Development:
STM32CubeMX integration:
If you develop for STMicroelectronics boards, you’ll be happy to know that CLion now integrates with STM32CubeMX:
CLion can create a new .ioc project or open an existing one, and generate a CMake file to correctly work with it.
You can start STM32CubeMX any time directly from CLion to update board settings and generate code.
CLion reminds you to select a board config and suggests a list of options in the UI.
OpenOCD support:
Debugging with the Open On-Chip Debugger is now supported by CLion. Use the new Run/Debug configuration template, ‘OpenOCD Download and Run’ to debug on your microcontroller.
If you work with a STM32CubeMX project in CLion, an OpenOCD Run/Debug configuration will be created for you automatically.
Learn more about STM32CubeMX & OpenOCD integration
ClangFormat:
The ClangFormat tool is widely used in the C/C++ world and even regarded as a standard by many developers. Its config files can be found in many projects, and especially in open source software. And it’s now supported in CLion! Learn more.
ClangFormat across all IDE actions:
CLion 2019.1 adds ClangFormat as an alternative code formatter. Turn it on for your current project or all projects in CLion and let CLion use it to format your code as you:
Type in the editor or paste code
Call the Reformat Code action
Reformat as a pre-commit hook
Generate boilerplate code
Refactor code
Apply quick-fixes or intention actions
Working with .clang-format config
Working with .clang-format config
CLion detects .clang-format config files in your project and will suggest switching to ClangFormat. If there are multiple config files, you can identify which one is used in a particular file opened in the editor by selecting “View ClangFormat options for <file name>” from the toolbar switcher.
Don’t have a config file? No problem – CLion will simply default to LLVM style.
Naming conventions
Setting naming in CLion
Setting naming in CLion
CLion now respects the naming scheme you provide. The selected settings will be used when:
Autocompleting code
Generating code
Refactoring code
Applying quick-fixes
You can configure the style manually in Settings | Editor | Code Style | C/C++ | Naming Convention or select naming from the predefined scheme.
Inconsistent naming inspection:
CLion can help enforce the selected naming convention in the editor. Simply turn on the Inconsistent Naming inspection, and CLion will highlight problematic names and suggest a quick-fix to replace all usages with a more accurate name.
Header Guard style:
In Settings | Editor | Code Style | C/C++ | Naming Convention, you can configure the style for Header Guards to be used when creating a new header file.
You can update this Velocity template or select a style from one of the predefined schemes.
C++ support:
Code highlighting and quick-fixes with Clangd
Code highlighting and quick-fixes with Clangd
To improve the editor performance, code highlighting and quick-fixes are now implemented on top of the complementary Clangd-based language engine (and are enabled by default along with the engine).
For quick-fixes, the location of the quick-fix is calculated in Clangd, while the fix itself is provided by CLion.
Error messages powered by Clang:
For some time now, we have been leveraging the Clangd-based language engine to annotate code errors and warnings in the editor. In v2019.1, CLion gets improved and more detailed error messages powered by Clang.
A practically useful example of this is debugging a failed overload resolution in your C++ code.
Improved Rename refactoring:
We’ve improved the Rename refactoring for files:
When you do a file rename, CLion asks if you’d like to also rename an associated class/struct, and the other way around.
When the header file is renamed, the header guards are updated accordingly.
Improved Extract refactoring
Improved Extract refactoring
The Extract refactoring is now more accurate and:
Respects type aliases and doesn’t expand on static members
Respects std:: namespace qualifier
Respects template specialization and template parameters
Member function can be static:
This new inspection reports member functions that can be marked as static. It works on top of the Clangd-based language engine and analyzes the method body, trying to check if it depends on this or not.
Debugger:
Disassembly View:
Disassembly View is now available for LLDB in addition to GDB backend. We’ve also improved the view in general so that now it shows information divided by function.
As before, Disassembly View works when you use Force Step Into (Shift+Alt+F7) on a function with no source code.
Mute Variables:
To get a better stepping performance, or if you need to watch the variables only occasionally, you can now explicitly Mute Variables. A general per-IDE switch will stop the variable calculation, and each variable in the variables view gets a Load option which you can apply as needed.
Memory View:
Memory View dumps the memory behind the pointer in the Debug mode. To invoke it, select a pointer variable in the debugger’s variables view and press Ctrl+Enter.
During stepping, if you have Memory View opened, CLion will highlight the memory changes that take place in the selected memory piece.
Custom Build Targets:
Build-system independent Build Targets (Settings | Build, Execution, Deployment | Custom Build Targets) allow you to add custom targets and configure any tools to be used for Building/Cleaning the target.
The most typical use case is a compilation database project, which lacks the information about building the whole project.
Custom Run/Debug Configurations:
To run and debug Custom Targets from CLion, create a corresponding Run/Debug configuration by using the Custom Build Application template (Run | Edit Configurations…).
The debugger will be taken from the Toolchain setting of the Custom Build Target.
Injected languages:
String literals with pieces of code in other languages can now be treated accordingly. To temporarily inject a language, press Alt+Enter, apply the intention “Inject language or reference”, and select the appropriate language. For example, SQL strings, HTML code, or Regular Expressions.
Based on the language chosen, CLion will provide code highlighting and language-specific intentions and actions.
Custom color themes:
Brighten up Your IDE:
Tired of Black and White themes in CLion? Tweak literally every color in your IDE, from icons to radio buttons and arrows.
Each theme is actually a theme plugin that you can download directly from our plugin repository. Or, if you feel up to it, create your own theme plugin using the DevKit and modify CLion’s appearance via the JSON file.
Recent locations:
The Recent Locations Popup (Shift+Ctrl+E) lists all the locations that you’ve visited in a chronological order so that you can easily go back and find things.
Use instant search to filter the locations by file name or code snippet included. Or, switch to showing changed locations only.
Other improvements:
The process of building CLion’s plugins was simplified by publishing CLion as a Maven dependency to be used by gradle-intellij-plugin (since version 0.4.2). Learn more
The bundled CMake is updated to 3.13, the bundled LLDB is updated to 7.0.1, and the latest supported Cygwin is now 3.0.
IPv6 is now supported to help you use Remote Development mode in CLion. Learn more
The Rust plugin received a massive update: it suggests out-of-scope items in completion and auto-import, as well as supports Rust language injection into code snippets in doc comments. Besides, profiler tools (like DTrace or Perf) are now supported for Rust.

New in CLion 2019.1 Build 191.6183.49 RC (Mar 20, 2019)

New in CLion 2019.1 Build 191.6183.6 Beta (Mar 14, 2019)

New in CLion 2018.3.4 Build 183.5429.37 (Feb 21, 2019)

Remote to host synchronisation: path to tar-ball is always the same.
Colours messed up in npm output
Asynchonous highlighting of a lot of console content leads to Out Of Memory
Intellij hangs on "Save Test Results"
Parameter hints find wrong overload
Open In Find Window does a Replace All
Disable Uninstall feedback options activated by default when uninstaller running from installer(when you install update with installer).
Handle ProcessCanceledException during extension point listeners
Task Server password/token is lost after closing IDE
Help | Submit a Bug Report causes YouTrack to complain about template
[a11y] completion popup closes immediately in break point settings
[a11y] instant rename refactor popup items are not selectable
can't tab out a pane once breakpoint is hit
Navigation bar. Pressing Enter on a package selects a package in a Project View tree
Folders from "Scratches and Consoles" node do not disappear from the tree after deleting
File history missing part before rename/modified conflict.
GitUtil.isGitRoot is expensive on windows and called too many times
VCS Log repository root filter doesn't show tagged commits
Pasting a value changes indentation of line
f-string newline doesn't auto split string when caret is right before closing quote
Add Python 3.7 to list of python versions of Conda environment
Unable to connect to Heroku Postgres database
DataGrip: When executing SQL script in a script file (not console) the IDE switch over to the Console after executing SQL
Console History's "OK" button should be more descriptive
Schema compare compares non-selected schemas
PhpStorm Database PostgreSQL doesn't show new added columns
Trigger definer is not shown in DDL
MySQL: incorrect column default value introspection after update
Not able to rename a StoredProc, if I am just changing the casing.
First time commit is issued it needs to be issued twice
DefaultProjectDirectory is not working as expected
NPE at com.intellij.database.psi.DbPsiFacadeImpl.lambda$clearCachesImpl$1
Throwable at com.intellij.openapi.application.impl.ApplicationImpl.assertIsDispatchThread
Find yields duplicate results
plpgsql valid assignment is red
Auto complit for "create table", "create function" and etc by "ct".
MSSQL: Unable to resolve symbol
Quoted table name completion: a dot is added inside quotes
Extract Subquery as CTE appends CTE in wrong position
Extract Subquery as CTE produces unsupported inner CTEs
Reformat code: MSSQL table hint
DataGrip formatter breaks code when removing AS
Postgres: formatter ignores the context when unquotes aliases
ClickHouse syntax does not allow parameters
MSSQL: CREATE SECURITY POLICY
Schema cannot be created from UI in DB2
Can not edit trigger
MariaDB Dialect: Support "CREATE OR REPLACE EVENT"
Bug in postgresql dialect
SQL Server file starting with IF shows error when cursor on IF keyword
Unresolved reference using functions with xml data type
Exasol: Division Operator mistaken for query terminator
PostgreSQL function code following RETURN QUERY reported as unreachable
Oracle: support triggering event / statement more precise recovery syntax

New in CLion 2019.1 Build 191.5701.24 EAP (Feb 20, 2019)

New in CLion 2019.1 Build 191.5532.20 EAP (Feb 14, 2019)

clangd provides incorrect colors in block comment contains non-ascii symbols
Missing quick-fix "Create New Class" when class with similar name exists
DFA | Unreachable code' inspection setting doesn't work
Clangd doesn't apply custom function call/declaration colour to destructor
Types and errors in headers aren't highlighted on Windows
Don't highlight dependent names as "template value" with clangd
Unexpected spaces in inspection message
Use clang results as much as possible to improve basic highlighting performance
Cannot navigate to 'operator[]' from 'map[key]' - it navigates to either 'map' or 'key'
"Replace 'if else'" refactoring breaks code
Inlining typedef in function declaration produces invalid code
Renaming file unexpectedly renames class without asking me
2018.2 Code completion regression when using multiple level of namespace
CMake loading doesn't work in UE4 project
Add option to change variable naming style
Add predefined schemes for naming convention
"Inconsistent Naming" inspection
IPv6 support
Sometimes CLion throws timeout exception when remote client is Windows
File transfer doesn't preserve execute permission
Allow adding file contents to the Blank DIff Window
Compare two files action does not allow to select which file will be left and which one will be right (swap diff)
Partial commits: Excess "Uncheck all" checkbox on Diff dialog
Support after-line-end inlays in editor
Join Lines on selected text also joins not selected text
Git diff view in commit dialog does not allow copying text to clipboard (CTRL+C) if this shortcut is assigned to "Copy as Plain Text" action.
Editor: Action is applied for the wrong line if invoked from menu
Strange behavior when join lines with "builder.append('...')"
Moving Up/Down doesn't work properly for Enum constants in case of missing Parameters info shows the actual proper method signature as disabled
Scope popup closes diff fragment popup
after new file is added, "last edit location" doesn't work
Repaint issues for soft-wrap marks in a diff pane
"Move statement" skips position outside code block in Java
Moving Up/Down dowsn't work for Enum constant with body
IntelliJ froze for 148 seconds after tabbing alt-tabbing away and back to IntelliJ with large buffer.txt file
Should be able to set editor view options like soft wraps for certain file types
Gutter current line number highlighting doesn't respect conversion function
Import Database Schema + H2 datasource: select or unselect table or column may invoke exception InvalidPathException: UNC path is missing sharename
Find, Replace, Find
"Search Everywhere" is missing files
find usages in file (ctrl-f7) skips some usages
Pinned "Find in Path" window closes on clicking on a result
HTML
Questionable folding and preview of " " in HTML (Velocity)
show absolute time in local history
Patch update doesn't work on macOS (2019.1 EAP)
Bundle Kotlin 1.3.20 with IntelliJ IDEA
Completion on a LightClass that is an interface does not include static methods
If there there are two dependencies on the same plugin in plugin.xml and one of them is optional the other is treated as optional as well
Plugin manager should select ony one (latest compatible) version in custom plugin repository and use it
Typing lags in plugins search UI
Settings Repository plugin leaks sensitive information in the commit message
When starting up new 2019.1 IDEA it resets settings if JetBrains Account is used.
IllegalStateException when split Terminal tab
Fall back shell path for terminal settings
The window with the addition of the note does not stretch vertically
Recent Locations popup: after exiting presentation mode, popup may keep the enlarged font for snippets
Validation in tables: bugs
Structure View shows content of the previously opened editor tab
KDE global menu
Linux native menu: some submenu are empty
Linux native menu: popups are not closed when native menu is opened
Editor tab is minimized to OS title bar when detaching it with a mouse
"Switch Boot Runtime" dialog: Some local JDKs are shown as "Undefined[Local]" in drop-down list
Dialog Non-Project Files Protection: make OK primary button
Consistent names of actions in View menu
"Switch Boot Runtime" dialog takes a long time to show up
Git branches with underscores don't render properly in branch menu
Partial commits: 'Uncheck All' checkbox misaligned with dependent checkboxes
Rework validation in tables
"Throwable: Project is already disposed" in Structure View on Close project
Cannot assign context-dependent shortcut key if that shortcut is left alone for a different context
xception on a click to the hidden toolwindow toolbar item
Cannot open Settings when a theme is applied
Recent Locations popup: new-created file doesn't appear in popup
Recent Locations popup: after checkbox is checked by mouse popup loses keyboard focus
Compute breadcrumb information outside of EDT
[Autoscroll from source] in Unpinned/Undock modes doesn't work when using mouse
Unshelve Silently restores several changelists in one
Files which were not added under VCS at once, do not appear at the list of files proposed ti add to VCS on project reload
No line status markers for files modified without checkout
IDEA shows half of project with an olive color
Shelf: focus disappears after removing one of the shelved lists
Unbundle TFS plugin
Unbundle CVS plugin
Already disposed on exit from offline inspections
IO Commits: commits status is not saved after refresh time is over
Ignore empty remote section in git config
When a file is added to git and immediately deleted, IDEA update fails with no visible reason
'Update checks failed' warning on Branches popup
Unknown host question is asked N times for a single host
Bug in Log filtering by branch
Please get rid of dependency on javax.activation
Subversion: impossible to merge file conflict using idea
100% CPU usage when working with a changelists of ~100 files
Investigate duplicate condition in org.jetbrains.tfsIntegration.tests.ChangeHelper#getModificationChange
TFS: Axis2 configuration error/ClassCastException on workspace creation
TFS checkin not possible "Validation must be performed before checking in"
Don't expand top-level classes in structure view
Don't show notification about pydantic-stubs
Load big collections by parts
pycharm incorrectly groups import ujson with system packages
Cannot use assert to refine the type of a global variable
Remove PEP 8 warnings from "Recent Locations" snippets
Support multiprocessing tests
Database view: password in not saved by database creation
Adding custom driver results in IllegalArgumentException.
NullPointerException when adding project data source when host and port fields are empty and the connection is tested
Enable DBMS_OUTPUT setting
Console History does not allow to search for numbers
Font rendering in Datagrip 2017.3.5 class diagram is broken.
Comparison between two database tables which using trigger.
Cannot use Database Explorer for sql database prefixes with brackets in the name.
Incorrect argument type in database view
"SELECT permission was denied" error when introspecting stored procedures
Missing schema qualifier with Postgres schema
"Import Data from File" silently fails with columns that contain a space
suggest filter value from clipboard
Disabling SQL formatting in settings does not work
Second comment line indented on stored procedure comments
Clickhouse dialect reformat inserts extra spaces in quoted identifiers
Can't disable SQL formatting
Disable formatting setting doesn't disable also auto-formatting on type (but must do)
Parsing of Oracle SQL Script Incorrect within Database Console
DataGrip Can't See MySQL Foreign Key's Referenced Column

New in CLion 2019.1 Build 191.4738.15 EAP (Feb 1, 2019)

Code: Highlighting and Inspections:
'DFA | Unreachable code' inspection setting doesn't work
Cosmetics CPP-14198 Unexpected spaces in inspection message
Task CPP-15016 Use clang results as much as possible to improve basic highlighting performance
Code: Refactorings:
Bug CPP-8248 "Replace 'if else'" refactoring breaks code
Usability CPP-2724 Renaming file unexpectedly renames class without asking me
Project Model:
Bug CPP-15238 CMake loading doesn't work in UE4 project
Toolchains: Bug CPP-14252 File transfer doesn't preserve execute permission
Debugger:
Feature CPP-14825 Debugger: "Mute variables" option
Database:
Exception IDEA-205762 RE at com.intellij.openapi.application.impl.ApplicationImpl.assertIsDispatchThread
Editor.:
Editing Text Bug IDEA-205802 Repaint issues for soft-wrap marks in a diff pane
Bug IDEA-205365 Git diff view in commit dialog does not allow copying text to clipboard (CTRL+C) if this shortcut is assigned to "Copy as Plain Text" action.
Bug IDEA-205336 after new file is added, "last edit location" doesn't work
Bug IDEA-205130 Parameters info shows the actual proper method signature as disabled
Bug IDEA-192879 "Move statement" skips position outside code block in Java
Bug IDEA-205739 Editor: Action is applied for the wrong line if invoked from menu
Bug IDEA-205776 Moving Up/Down dowsn't work for Enum constant with body
Bug IDEA-205774 Moving Up/Down doesn't work properly for Enum constants in case of missing ';'
Bug IDEA-205622 Scope popup closes diff fragment popup
Performance IDEA-206039 IntelliJ froze for 148 seconds after tabbing alt-tabbing away and back to IntelliJ with large buffer.txt file
Task IDEA-205639 Gutter current line number highlighting doesn't respect conversion function
Find, Replace, Find Usages: Bug IDEA-203491 "Search Everywhere" is missing files
Bug IDEA-168548 find usages in file (ctrl-f7) skips some usages
Bug IDEA-202717 Pinned "Find in Path" window closes on clicking on a result
Packaging and Installation:
Task IDEA-202441 Bundle Kotlin 1.3.20 with IntelliJ IDEA:
Plugin Management:
Performance IDEA-205534 Typing lags in plugins search UI
Settings Repository:
Bug IDEA-206186 When starting up new 2019.1 IDEA it resets settings if JetBrains Account is used.
Terminal:
Bug IDEA-201228 IllegalStateException when split Terminal tab
Usability IDEA-206189 Fall back shell path for terminal settings
User Interface:
Bug IDEA-204678 Editor tab is minimized to OS title bar when detaching it with a mouse
Bug IDEA-205976 Structure View shows content of the previously opened editor tab
Exception IDEA-205460 "Throwable: Project is already disposed" in Structure View on Close project
Version Control:
Usability IDEA-167403 Shelf: focus disappears after removing one of the shelved lists
Exception IDEA-205978 Already disposed on exit from offline inspections
Version Control. Git:
Bug IDEA-205777 IO Commits: commits status is not saved after refresh time is over
Bug IDEA-171517 Ignore empty remote section in git config
Usability IDEA-206134 Unknown host question is asked N times for a single host
Usability IDEA-204470 'Update checks failed' warning on Branches popup
Code Insight:
Bug PY-33349 Don't expand top-level classes in structure view
Bug PY-33705 Don't show notification about pydantic-stubs
Inspections:
Bug PY-32113 Cannot use assert to refine the type of a global variable
Data Import & Export:
Bug DBE-7675 "Import Data from File" silently fails with columns that contain a space
SQL Format and Style:
Bug DBE-7690 Clickhouse dialect reformat inserts extra spaces in quoted identifiers
SQL Generation:
Bug DBE-7560 DataGrip Can't See MySQL Foreign Key's Referenced Column

New in CLion 2019.1 Build 191.4212.38 EAP (Jan 25, 2019)

New in CLion 2018.3 Build 183.4284.156 (Nov 28, 2018)

CLion 2018.3 takes a huge step towards Remote Development as it enables one of several major configurations for remote development. It has expanded its tooling support by integrating with CPU Profilers. The existing unit testing support has also been enhanced, with new IDE actions and faster code navigation and search which are now partially based on the Clangd-based language engine.
Initial Remote Development support:
You can now develop remotely from a Windows, Linux, or macOS client machine to a Linux remote host, for CMake-based projects only. The current setup assumes the source code is located on a local machine, which CLion synchronizes to the remote machine. Many other remote development setups are planned for future CLion releases.
Supported configurations:
To start developing remotely, first create a remote toolchain in Settings | Build, Execution, Deployment | Toolchains. Provide the remote host address and credentials, and then use the toolchain in one or several CMake Profiles. After CMake is reloaded, you’ll be ready to start working remotely with your project in CLion.
Remote mode:
After the configuration is done, you can run or debug your application or unit tests remotely from CLion. Code is built, run and debugged on a remote host, while you work with the code in CLion on your local machine. Code is resolved locally, and CLion synchronizes the header search path to the local machine to speed up the process.
Enable remote as defaultL
To use CLion in remote mode for all your projects, both the new and existing ones, you can set your remote toolchain to be the default.
Go to Settings | Build, Execution, Deployment | Toolchains and simply move the toolchain to the top of the list. CLion will then use this toolchain automatically for any projects you open in CLion.
CPU Profiler:
CLion now integrates with CPU Profiler on Linux (Perf) and macOS (DTrace). You can run the profiler right from the IDE and review the analysis results in a dedicated tool window (View | Tool Windows | CPU Profiler).
Use the flame chart, call tree and method lists to get a better overview of the possible performance issues in your code. Navigate to the source code to locate the issues in the code base.
C++ Support:
Clangd-based navigation and search:
We’ve been using an experimental, complementary Clangd-based language engine to help you annotate errors in the editor. Now, it also powers several navigation and search actions, including Go to declaration (Ctrl+B)/definition (Ctrl+Alt+B), highlighting references under the caret, quick documentation (Ctrl+Q), and Find usages (Alt+F7). The results are still merged with the ones collected by CLion’s own engine.
C++17: fold expressions and deduction guides:
Now, CLion correctly parses C++17 fold expressions and C++17 deduction guides. This means that there is less false code highlighting and better code assistance for you. For example, the correct type will be shown in the parameter info for user-defined deduction guides.
New IDE Actions:
New Build and Rebuild actions
The new Build menu comes with a set of new and updated build-related actions for CMake:
Build/Rebuild all target from all CMake Profiles
Build/Rebuild all target from the selected CMake Profile
Build/Rebuild the selected configuration
Recompile the current file
Install
Clean
Activity Monitor:
This new experimental feature shows how much CPU the subsystems and plugins (both built-in and additionally installed ones) are consuming. To access it, go to Help | Activity Monitor.
If you see a subsystem whose %CPU is unusually high, feel free to ask our support team about it or report it to the issue tracker.
New Run Anything:
Run Anything (Double Ctrl) is a new and universal way to run and debug any configuration in your project, or even open a project.
To run a configuration, just start typing its name.
To debug, hold down the Shift key to switch to the Debug Anything mode.
To open a project, type “Open” and select the desired project from the list.
Updated Search Everywhere:
The updated Search Everywhere (Double Shift) now includes all the multiple actions in one:
Search Everywhere
Find Action
Go to Class
Go to File
Go to Symbol
Each has its own separate tab in the dialog, and you can use Tab to switch between them.
Unit testing:
In v2018.3, we’ve reworked the integration with unit testing frameworks in CLion (Google Test, Boost.Test, and Catch (2)) in order to eliminate various performance issues and hangs. We’ve also improved output processing in many cases.
Show Test List:
To improve performance, CLion now uses lazy test detection. This reduces project indexing times in many situations. For diagnostic purposes, we’ve implemented a new action called Show Test List (available from the Find Action dialog), which provides a text file with a list of all the tests currently detected in the project.
Compilation database validation:
CLion now provides specific inspections to check for compliance with the compilation database’s JSON schema.
For example, it can highlight situations when an incorrect type is used for the property value, or when the property is missing.
Editor:
Formatted macro expansion:
CLion now formats the macro replacement in the Quick Documentation popup (Ctrl+Q). It also highlights strings and keywords used in the final substitution, so you can quickly understand the code that will be substituted after the preprocessor pass.
Multiline TODO comments:
To add more information to TODO comments but keep them readable, you can now split the comment into several lines. Just add an indent starting from the second line of your multiline TODO comment and the IDE will differentiate it from an ordinary comment.
VCS:
Git submodules:
You can now work with Git submodules in CLion. When you clone the root repository, CLion will clone all its submodules. The same is true for updates, and other VCS actions work with submodules as well.
GitHub pull requests:
A brand-new GitHub pull requests tool window (VCS | Git | View Pull Requests) lets you view all the pull requests to the repository. Search them by state, assignee, author, etc., and easily create a new local branch with a simple right click.
Accessibility improvements:
To make our tools accessible to as many people as possible, we’ve added a few new options to the Appearance section in the IDE’s settings (Settings | Appearance & Behavior | Appearance). Here, you’ll find a new High-contrast theme, expanded support for screen readers (they can now read line numbers, VCS annotations, and gutter icons tooltips) and an option to adjust IDE colors for people with color deficiencies.
High-contrast Theme:
A High-contrast Theme is now available for CLion. You can either switch it on just for the editor (Ctrl+`) or for the whole IDE (Settings | Appearance & Behavior | Appearance | Theme).
Plugins:
New Plugins UI:
Plugins settings under Settings | Plugins have been redesigned from the ground up. The new UI makes it much easier to control the plugins installed in your CLion instance and keep them up-to-date.
Featured plugins and marketplace:
You can see a list of the most valuable plugins for CLion located in the Featured plugins list. Or, sort all the plugins by rating or number of downloads.
If you are a plugin writer, check out our new platform for third-party plugin vendors.
Other improvements:
CLion 2018.3 comes with the Swift Package Manager support in the Swift plugin. Simply open the SPM project in CLion and work with it – no additional configuration required. Read more and watch a short demo
Rust plugin was updated to get partial Rust 2018 support, Move analysis inspection and cargo unit testing support.

New in CLion 2018.3 Build 183.4284.140 RC 2 (Nov 22, 2018)

New in CLion 2018.3 Build 183.4284.104 RC (Nov 16, 2018)

New in CLion 2018.3 Build 183.4284.40 EAP8 (Nov 14, 2018)

New in CLion 2018.3 Build 183.4139.25 EAP7 (Nov 14, 2018)

New in CLion 2018.3 Build 183.3975.20 EAP6 (Oct 25, 2018)

New in CLion 2018.2.5 Build 182.4892.24 (Oct 19, 2018)

New in CLion 2018.3 Build 183.3795.17 EAP5 (Oct 19, 2018)

New in CLion 2018.3 Build 183.3647.14 EAP (Oct 10, 2018)

New in CLion 2018.3 Build 183.3283.6 EAP (Oct 3, 2018)

New in CLion 2018.3 Build 183.2635.14 EAP (Sep 26, 2018)

New in CLion 2018.2.4 Build 182.4505.18 (Sep 19, 2018)

New in CLion 2018.2.3 Build 182.4323.58 (Sep 6, 2018)

Wrong directory is highlighted during moving files to Scratches
2018.2: PyCharm and Idea are very slow on MacBook with TouchBar if Django support is enabled
Pytest fixture code intelligence missing if from pytest import fixture
Dialect scopes for Live templates
Execute stored procedure: specify type length for the result or otherwise (if infer type length is not possible) indicate that the script is invalid
Synchronizing a Database (Intersystems CachÃ©) forgets the Schema
Column is missing from FK as displayed in Database tool window
DataGrip does not understand "included columns" of MS SQL Server indexes
MS SQL Server index condition (filter definition)
Postgres 11 broke backward compatibility (columns proisagg and proiswindow are dropped from pg_catalog.pg_proc)
Qualify table and routine names in editor tabs
Feature Request: Show column comments in tooltips
Consider data source group in Go to actions and other places where I'm choosing some database object
Remove storage files from "Go to file"
Editor tabs are not named consistently so they don't sort consistently
Complete function parameters in drop function statement
Live template problem
"Qualify Object on code completion" setting "Always" breaks postgresql updates
Procedure block: new line after BEGIN
MSSQL: Obscure spaces before and after dot between schema and table name
MariaDB: Support CREATE OR REPLACE PROCEDURE
Need temporal table support in SQLServer Dialects
Oracle ~= (not equals) operator causes parse error
Newline concatenation with a bind variable in COPY command is erroneously not recognized as a valid syntax with Postgres
PostgreSQL 10 drop function without arguments
Invalid "Ambiguous column reference"
MySQL: "where" keyword in select statement is highlighted as error
Can not drag Data Source to a group
When renaming a datasource, interpret slashes as groups or interpret slahes in datasource names as groups
Gutter color is not respected
Default row height int "Modify Table" dialog is equal to the biggest row in the dialog
Moving a datasource to a parent group that has no direct child only possible via "new..." group

New in CLion 2018.2.2 Build 182.4129.15 EAP (Aug 16, 2018)

New in CLion 2018.2.1 Build 182.3911.40 (Aug 8, 2018)

New in CLion 2018.8.2 Build 182.3684.76 (Jul 26, 2018)

New in CLion 2018.2 Build 182.3684.76 RC3 (Jul 23, 2018)

New in CLion 2018.1.6 Build 181.5540.8 (Jul 23, 2018)

New in CLion 2018.2 Build 182.3684.46 RC 2 (Jul 18, 2018)

New in CLion 2018.2 Build 182.3684.12 RC (Jul 12, 2018)

New in CLion 2018.2 Build 182.3569.10 EAP (Jul 5, 2018)

New in CLion 2018.2 Build 182.3341.14 EAP (Jun 21, 2018)

Code: Documentation Bug CPP-13228 Import Hierarchy doesn't show all included files in certain cases
Code: Find Usages Bug CPP-13395 EA-121798 - assert: OCSearchScope$.contains
Code: Intention Actions Bug CPP-12486 Simplify intention on an if statement makes code far more complex
Code: Resolving Bug CPP-7206 Cpp files included by cpp file are not considered as part of the project.
Project Model Task CPP-270 Project headers not included directly into project model but included from source files should be considered source files as well
Diff_Merge Bug IDEA-193373 Diff in Commit Changes: cannot resize TTF preview below some limit
Editor. Editing Text Bug IDEA-194054 Gutter icons of the underlying code displayed on folded region quick view
Find, Replace, Find Usages Bug IDEA-193321 SearchEverywhere: on scope switching the 'include non-project items' checkbox loses its state
Packaging and Installation Feature IDEA-194011 Turn vcs.log.graph module into a healthy maven dependency
User Interface Bug IDEA-193493 "Tip of the day" pixelated but correct size with 125% DPI scaling
Bug IDEA-174739 Combobox text is doubled in Android UI designer
Bug IDEA-193875 Synchronise '' context menu item
Version Control Performance IDEA-174636 Unregistered VCS root scanning, which happens in the Settings | Version Control, should be moved out of the EDT
Version Control. Git Bug IDEA-108316 Unregistered Git roots are not auto-detected if they are more than 2 folder levels deep than any project module
Code Insight Bug PY-28243 False negative for illegal TypeVar declaration
Bug PY-28249 False negative: Parameterized generics cannot be used with class or instance checks
Inspections Feature PY-20530 Validate and give visual feedback on PEP 484 type hints
Bug PY-16853 Round brackets of Union command are not highlited in .pyi file
Interpreters Settings Feature PY-26492 Add pipenv support
Bug PY-9081 Set as project interpreter with multiple projects opened in one window sets interpreter only in last project in the list
Bug PY-12247 Python Interpreters: multi-project associated virtualenv is removed from project when opened separably
Test Runner Feature PY-27630 Support completion for "@pytest.mark"
Bug PY-30153 pytest support: cannot go to "implementation" of a fixture from conftest.py
Code: Indexing Performance OC-17296 ReadAction with module map building activity is not cancelled by a write action

New in CLion 2018.1.5 Build 181.5281.33 (Jun 15, 2018)

New in CLion 2018.1.4 Build 181.5281.26 (Jun 14, 2018)

Build Bug CPP-12614 Message tool window is shown after Run program with warning
Code: Navigation Performance CPP-7168 CLion freezes navigating to related symbol (from .h to .cpp)
Project Model Bug CPP-13232 Compiler information detection fails with GCC on `-Wno-error=unknown` option with `no option -Wunknown` error
Bug CPP-13133 Compiler information detection fails with GCC on `-Werror=unknown` option with `no option -Wunknown` error
Toolchains Bug CPP-13098 Compiler information detection sensitive to -Werror=undef
Bug CPP-12968 CLion fails to detect WSL with Ubuntu 18.04
Editor. Editing Text Bug IDEA-191159 [windows] text in editor can float when parameter hint is on
Bug IDEA-182771 Editor: Split Vertically resets scroll and caret position
Find, Replace, Find Usages Usability IDEA-175973 Enter file name search popup is not closing itself after losing focus when no value available in textbox.
Indices Bug IDEA-188041 Uncommitted saved document still leading to "Outdated stub in index" sometimes
Bug IDEA-193172 Deadlock while typing after auto completion
Bug IDEA-181227 Throwable: unable to get stub builder
Exception IDEA-188028 A test failing with "Outdated stub in index"
User Interface Bug IDEA-192713 focus is lost on opening Find Usages tool window
Bug IDEA-191164 [windows] text floats in preview diffs
Bug IDEA-191170 [windows] tip of the day picture is large on 125% scale
Bug IDEA-190806 notification balloon shadow gaps
Bug IDEA-192691 Wrong title of JetBrains Privacy Policy window
Performance IDEA-192184 Goto Class/File/Symbol popups leak via native window and focus traversal policy
Version Control Bug IDEA-186772 Git compare two branches: sort is wrong
Performance IDEA-192017 Unshelving creates a thread for each shelved file
Version Control. Git Bug IDEA-191656 Git commit history with control characters causes intellij to spin, consuming CPU and repeating the same stack in the idea.log
Version Control. Perforce Bug IDEA-191521 Duplicate changelist is created when submitting a part of files in a Perforce changelist
Version Control. Subversion Bug IDEA-188180 "Merge from" fails if branch location of the current branch is under some other branch location
Bug IDEA-190790 Subversion: tree conflicts can't be viewed if path contains spaces
Bug IDEA-190960 "Error updating changes: can not parse output" error in local changes for certain tree conflicts
Usability IDEA-158791 Unexpected output of svn commands for a single file/revision should not prevent further svn operations
Cosmetics IDEA-188814 Subversion: correct the title of "BranchOrTag" tab in Messages tolwindow
Exception IDEA-190935 ISE at org.jetbrains.idea.svn.branchConfig.SvnBranchConfigurationManager.resolveConfiguration
Console Bug PY-29186 Printed outputs are hidden from the user when there is some computation at the beginning
Bug PY-29045 Python console folding covers staring script execution result
Debugger Bug PY-29671 Remote Debugging Server: 'module' object has no attribute 'declare_namespace'
Formatter Bug PY-10972 Wrong indent when typing a multi-line tuple or string literal
Inspections Bug PY-27858 SqlAlchemy table class attributes of Column(Unicode) type are mistaken for string type.

New in CLion 2018.2 Build 182.2371.31 EAP (May 18, 2018)

New in CLion 2018.1.2 Build 181.4668.70 (Apr 25, 2018)

New in CLion 2018.1.2 Build 181.4668.25 EAP (Apr 18, 2018)

New in CLion 2018.1.1 Build 181.4445.84 (Apr 11, 2018)

New in CLion 2018.1.1 181.4445.17 EAP (Apr 2, 2018)

New in CLion 2018.1 Build 181.4203.549 (Mar 28, 2018)

New in CLion 2018.1 Build 181.4203.505 RC 2 (Mar 22, 2018)

New in CLion 2018.1 Build 181.4203.106 RC (Mar 14, 2018)

New in CLion 2018.1 Build 181.3986.16 EAP (Mar 7, 2018)

No subsystem:
Feature CPP-10994 Support and bundle CMake 3.10
Bug CPP-9694 No tslint setting page under typescript in Preference
Build:
Usability CPP-12135 Add icon for Run-Install
Code: Highlighting and Inspections:
Bug CPP-2153 Local enum classes have integer type
Bug CPP-11393 Syntax highlighting error on inherited classes
Code: Indexing:
Bug CPP-12082 Regression, structure member is not resolved
Code: Parsing:
Bug CPP-11407 False positive incompatible types in initializer warning
Code: Resolving:
Bug CPP-12046 Can't resolve fields of a structure if there is a typedef for the struct before the struct is defined
Bug CPP-6009 CLion can't find constructor that comes from a "using = ..." statement [template related]
Bug CPP-12103 Error after macro substitution: Explicit type is required here
Debugger:
Cosmetics CPP-12133 Clipboard content in the Debugger settings looks weird
Toolchains:
Task CPP-12174 Set minimum supported Cygwin version to 2.8
Unit Testing: Google Test:
Feature CPP-12125 Support Google Test in MSVC toolchain
Editor. Editing Text:
Bug IDEA-187042 arg postfix template incorrectly replaces whole line
Exception IDEA-187187 Save settings failed: "Cannot get ScratchFileService component state"
Find, Replace, Find Usages:
Bug IDEA-187131 Find popup shows incomplete usages and doesn't indicate they're incomplete
Bug IDEA-185627 Regression: 'Search/Replace in Path' popup doesn't find usages under .idea directory even if explicitly invoked on that directory
Usability IDEA-186671 Find in path: automatically include project files into search scope if *.iml is set as a file mask
Terminal:
Bug IDEA-186950 Exception on trying to evaluate java program that throws exception in terminal
User Interface:
Bug IDEA-186564 Default size of Edit configuration -> tasks before launch is just for 1 step
Bug IDEA-187284 HiDPI JVM option is ignored in IntelliJ IDEA 2018.1 EAP
Bug IDEA-186989 Invoking "find action" in Evaluate dialog moves focus to the main window
Version Control:
Bug IDEA-187108 Commit action does not respect file selection in Local changes
Bug IDEA-187101 EAP #IC-181.3870.7:Create partial patch does not work as expected
Bug IDEA-186725 Changes grouping by repository: confusing results for external VCS root if group by module is used
Version Control. Git:
Bug IDEA-185964 Git: Partial Commits: after turning the HighlightFilesFromNonActiveChangelists ON the behavior becomes unpredictably wrong
Exception IDEA-186769 CME at com.intellij.openapi.vcs.changes.conflicts.ChangelistConflictTracker.optionsChanged
Code Insight:
Feature PY-16412 "Add comment with type hint" intention action for local variables
Console:
Bug PY-28551 Create folding for Console with "Show command line afterwards" option
Bug PY-27762 Soft wraps option has to be reenabled to make in work in Python console opened with "Show command line afterwards"
Debugger:
Bug PY-27886 pydevd does not adjust pythonpath correctly for targets that are symlinks
Exception PY-27154 Socket closed exception when Python Remote Debug process is stopped
Formatter:
Exception PY-28032 Reformat Code breaks when "from typing import Optional"
Inspections:
Bug PY-25497 False Positive inspection "Unexpected argument" for **kwargs in inheritence
Bug PY-24760 subprocess.check_output(..., encoding='utf-8') inspector reports unexpected argument
Bug PY-22221 Unresolved references option "Ignore references" feature not working ?
Bug PY-18629 Unresolved reference for imported module when there is namespace package with same name for Python 3
Bug PY-26555 "'function' object is not callable"
Bug PY-28593 False positive for redeclared import under try/except
Bug PY-27964 Unresolved reference false positive when using register function of @functools.singledispatch
Bug PY-19856 Redeclared variable inside possibly empty loop
Bug PY-22184 False positive "unreachable code" for while / try / break / finally
Bug PY-19898 Wrong return value is inferred for subprocess.check_output() in Python 3
Bug PY-23632 False positive: "can't find reference in function" for mock package on Python 2.7 interpreter
Interpreters Settings:
Bug PY-27931 PyCharm fails to create virtualenv based on detected python 3.6 interpreter

New in CLion 2017.3.4 Build 173.4674.29 (Mar 7, 2018)

New in CLion 2017.3.4 Build 173.4674.3 EAP (Feb 27, 2018)

New in CLion 2018.1 Build 181.3870.21 EAP (Feb 27, 2018)

New in CLion 2018.1 Build 181.3263.17 EAP (Jan 31, 2018)

New in CLion 2017.3.3 Build 173.4548.31 (Jan 31, 2018)

New in CLion 2018.1 Build 181.3007.15 EAP (Jan 24, 2018)

New in CLion 2017.3.2 Build 173.4301.33 (Jan 18, 2018)

New in CLion 2017.3.1 Build 173.4127.32 (Dec 28, 2017)

New in CLion 2017.3.1 Build 173.4127.6 EAP (Dec 14, 2017)

New in CLion 2017.3 Build 173.3727.114 (Dec 4, 2017)

New in CLion 2017.3 Build 173.3727.83 RC 2 (Nov 23, 2017)

New in CLion 2017.3 Build 173.3727.18 RC (Nov 16, 2017)

New in CLion 2017.3 Build 173.3622.10 EAP (Nov 9, 2017)

New in CLion 2017.3 Build 173.3531.13 EAP (Nov 2, 2017)

New in CLion 2017.3 Build 173.3415.24 EAP (Oct 27, 2017)

New in CLion 2017.3 Build 173.3302.18 EAP (Oct 20, 2017)

New in CLion 2017.3 Build 173.3188.25 EAP (Oct 13, 2017)

New in CLion 2017.3 Build 173.2941.5 EAP (Oct 5, 2017)

New in CLion 2017.2.3 Build 172.4343.16 (Oct 3, 2017)

New in CLion 2017.3 Build 173.2696.23 EAP (Sep 28, 2017)

New in CLion 2017.3 Build 173.2463.5 EAP (Sep 21, 2017)

New in CLion 2017.3 Build 173.2290.13 EAP (Sep 15, 2017)

New in CLion 2017.3 Build 173.2099.3 EAP (Sep 8, 2017)

New in CLion 2017.2.2 Build 172.3968.17 (Aug 30, 2017)

Code: Highlighting and Inspections:
Feature:
Use compile_commands.json for passing options to clang-tidy
Allowto disableindividual checks in Clang-Tidy
Allowto useexternal Clang-Tidy instead of the built-in one inCLion
Suppress Clang-Tidy inspection for line by NOLINT comment
Bug Fixes:
Heap allocating class with virtual destructor = default gives error "Instantiating abstract class"
Update list of clang-tidy inspectionsclang-tidy inspections do not work because clang-tidy requires newerlibcand libstdc++
CLion passes options to Clang-Tidy in incompatible form under MSVC toolchain
Build:
Two separate CLion instance will not build simultaneously - "Waiting for the current build to finish..."
Project Model:
Error icon appears on Cmake console configuration tabs after Reset Cache several times in a row
Diff_Merge:
Cannot move/resize diff view area of Commit Changesdialog
Editor. Editing Text:
UTF-8 symbols (koreanandjapanese) incorrect appears in the debugger
Multiple @since Javadoc tags are replaced with one on reformat
Cannot open javascript files
using spring indaolayer auto input a pair of braces
Lag while typing
File System:
FreeBSD-12, post ino64 update: no projects, config is not saved
Find, Replace, Find Usages:
Find Refactoring Preview is not shownfirsttime
Settings Repository:
Typing settings repository URL triggers path alert
User Interface:
Navigate | File and Class popups disappear
Incorrect terminology used to describe Jigsaw/JPMS features
Version Control:
File status remains "changed" after the file is changed back to initial state
Commitdialog: when the 'show right margin' option is off, but 'wrap when typing reaches right margin' is on, there is no wrapping
Improve displays of multi-line commit messages in Changes Window
Version Control. Git:
UI freeze after huge fetch
Version Control. Subversion :
"more..." link is shown in Version Control > Repository while there is no more content
Version Control. TFS:
TFS: Domain field should be disabled if Alternate auth type is used
Console:
aborting commands in debug console
Debugger:
Concurrency visualizer doesn't work with Python 3.6
Variables in function called from loop stick after console started in debug mode
Inspections:
False positive: comparing int and float, only left.__gt__(right) is checked, right.__lt__(left) is ignored
Actual type of variable is lost after it's compared with None
PyCharm thinks the Python version is 3.5 when using 3.7
False positive: PyTypeChecker - Type Checking Error on Child of Metaclass Instance
Test Runner:
Regression inunittestrunner if test removes its working directory
Pyramid project test don't work
Parsing:
False positive: "expression expected" for trailing comma after annotated function argument with default value
Refactoring:
Bulk Move operation only moves first item selected

New in CLion 2017.2.2 Build 172.3968.17 RC (Aug 23, 2017)

New in CLion 2017.2.1 Build 172.3544.40 (Aug 23, 2017)

New in CLion 2017.2.2 Build 172.3968.3 EAP (Aug 21, 2017)

New in CLion 2017.2 Build 172.3317.49 (Jul 21, 2017)

New in CLion 2017.2 Build 172.3317.14 RC (Jul 7, 2017)

New in CLion 2017.1.3 Build 171.4694.31 (Jun 30, 2017)

New in CLion 2017.2 Build 172.3198.18 EAP (Jun 30, 2017)

New in CLion 2017.2 Build 172.3095.8 EAP (Jun 21, 2017)

New in CLion 2017.2 Build 172.2953.14 EAP (Jun 15, 2017)

New in CLion 2017.2 Build 172.2827.9 EAP (Jun 8, 2017)

New in CLion 2017.2 Build 172.2465.12 EAP (May 26, 2017)

New in CLion 2017.2 Build 172.2273.4 EAP (May 18, 2017)

New in CLion 2017.2 Build 172.2103.9 EAP (May 11, 2017)

New in CLion 2017.1.1 Build 171.4073.41 (Apr 13, 2017)

No subsystem:
Missing errors when generic lambda argument type is incompatible with parameter type
Code: Highlighting and Inspections:
Const-qualified forwarded template parameter discards const-qualification
Regression: lambda return type not deduced correctly with type aliases of templates
Code: Parsing:
When the argument of operator[] cannot be determined, a non-integral parameter is flagged as an error
Type referenced in declaration via global namespace in if() condition is unrecognised
override specifier in local class highlighted as syntax error
Code: Resolving;
Local class type not resolved properly inside member functions
Project Model:
Compiler info cannot be collected with older GCC
CMake load fails with "Cannot get compiler information for configuration", CLion gives SDCC invalid arguments: '@/tmp/compiler-arguments.txt'
UI can be blocked during project reopening due to access to compiler info
Unit Testing:
Catch: Impossible to run test using context menu when caret is located inside TEST_CASE_METHOD
Catch Configuration: Expansion in CHECK not shown due to CAPTURE
Console:
ANSI Colors in the console : some escape codes are not interpreted correctly
Editor. Editing Text:
Flow annotations visible in Collections interface methods
Right-to-left bug
Copy/paste of type breaks 'module-info.java' with illegal import statement
Buggy caret position shown in status line
File System:
VirtualFIle.findChild() is slow on negative lookups
Find, Replace, Find Usages:
Regexes inserted into "Find" field are replaced with the value of its selection if "replace" mode is invoked
`Find in path` highlights all file in preview window
Different results in the results panel of the "Find in Path" window in comparison to the preview (specific Regex)
Search stopped working
Find in path: Home+End keys not working in text field
File mask field keyboard behaviour inconsistent with search field
New Find/Replace in tab dialog: Add spacing to checkbox list
"Find in path" dialog: find anywhere/in comments/... doesn't have a shortcut
Find usages preview throws exception: java.lang.Throwable
Packaging and Installation:
Installation destination folder for 64-bit and 32-bit Windows OS.
User Interface;
Welcome Screen unusable small
'Import Color Scheme' is broken (scheme is reset to Default after IDE restart)
FindInPath popup: keyboard focus can't be moved to results list after some control selecting or moving focus to preview
Tab key doesn't bring you into General Tab in Datasource Properties window
Buttons Yes/No in "Add file to Git" dialog lost their position
Version Control:
Check commit message for emptiness before code analysis
Version Control. Log:
Let reorder columns shown in the VCS Log and new File History
Show affected files in file history has no preselection
Adding duplicate element ref to the set containing otherref
Code Insight:
Allow PyImportResolver results to override standard import roots
Console:
Disabled "Show cmd afterwards" options is clickable after run config window reopening
Remote interpreter causes exception if "Emulate terminal" option is enabled
Debugger:
Argument parsing for subprocess under debugger
Debugger finishes in _pydev_execfile
Debugger fails with ValueError if "Collect run-time types information" option is enabled
Frame evaluation debugger: enable old tracing debugger for long functions with bad absolute jump instructions
Attach Debugger to console fails
Process finished with exit code 139 (interrupted by signal 11: SIGSEGV) upgrading from 2017.1 RC1 to RC2 171.3780.111 OSX
Debugger fails to connect to spawned subprocesses with Docker interpreter
Updates from PyDev debugger
Editing:
Some line comments are deleted when optimize imports is invoked
Formatter:
Code style options for "from" imports are not taken into account in several cases where imports are automatically created/modified
Optimize imports doesn't honor new code style settings for imports (parentheses in particular)
Inspections:
False positive "Old-style class..." inspection if class is inherited from six.with_metaclass
Interpreters Settings:
Cannot add symlinked Python/virtualenv as interpreter, e.g. created with venv
Run:
runnerw.exe sometimes finishes with exit code -1073741819 (0xC0000005)
Test Runner:
Doctest: missing diff link for failed doctest
Python Unittests with Python 2.6.4 Fail with SyntaxError in _jb_runner_tools
Cannot run Unittests with -Werror
Pycharm EAP test file detection
REST Client:
REST Client: VirtualFile: restClient/response21.html is invalid

New in CLion 2017.1.1 Build 171.4073.32 EAP (Apr 5, 2017)

New in CLion 2017.1 Build 171.3780.121 (Mar 29, 2017)

New in CLion 2017.1 Build 171.3780.43 RC (Mar 16, 2017)

New in CLion 2017.1 Build 171.3780.24 EAP (Mar 10, 2017)

New in CLion 2017.1 Build 171.3691.13 EAP (Mar 2, 2017)

In this EAP:
Disassembly view for debugger
Catch support
Some fixes for MSVC support
Disassembly view for debugger:
This build brings disassembly view for debugger. You can now step into disassembly code, when the sources are not available. The assembly code will be highlighted correctly and you can then step though it to investigate the problem:
disasm
As work on this feature is not yet finished, there are a couple of limitations and known issues:
It now works only with GDB (for LLDB support, please, follow CPP-8908)
Setting a breakpoint in the assembly code in not possible (CPP-8910)
Run to cursor (CPP-8945) and evaluate expression (CPP-8952) are not yet there
Try the disassembly view on your project and let us know what you think in our tracker.
Catch:
This EAP brings Catch support to CLion. Catch is a cross-platform test framework for C++ which you might consider as an alternative to Google Test, CppUnit and others due to following reasons:
To start you just need to include catch.hpp and that’s it! No external dependencies are used and it’s just a single header
Write test cases as, self-registering, functions or methods
Cases can be organized into sections, BDD-style Given-When-Then sections can be used
And now there is one more reason – CLion’s Catch support!
It includes:
Built-in test runner to inspect the results with ease: check the progress bar, test status and test duration, the whole test output stream, and more
Catch run/debug configurations in CLion
Completion for tags in the configuration settings
CLion support Catch v1.7.2 and higher. To learn more about Catch itself and its support in CLion read this blog post by Phil Nash, the original author of Catch and developer advocate here at JetBrains.
MSVC fixes:
The previous EAP build introduced experimental support for the Visual C++ compiler in CLion. It’s now possible to build projects with MSVC/CMake/NMake toolchains on Windows. A few fixes and usability changes were added this time:
If you were using VM option to turn on the MSVC support, please, revert it back (remove custom VM options file from configs) and use Registry: in Find Action dialog (Shift+Ctrl+A on Linux/Windows, ⇧⌘A on macOS) type Registry; open Registry and type msvc:
registry_on_msvc
VS 2013 is now also supported (in addition to VS 2015 and VS 2017)
CLion now auto-detects the Visual Studio versions installed on the machine
Navigation through compiler errors was introduced (links to the code were added, as well as navigation to the previous/next error):
messages
CMake settings for MSVC were updated with some hints for the possible values:

New in CLion 2017.1 Build 171.3566.4 EAP (Feb 22, 2017)

New in CLion 2016.3.3 Build 163.13906.4 (Feb 16, 2017)

New in CLion 2017.1 Build 171.3224.8 EAP (Feb 15, 2017)

No subsystem:
Support and bundle CMake 3.7
Code - Highlighting and Inspections:
Binary operator '<<' can't be applied to the expressions of type 'wostream' and 'string'
Code - Parsing:
Add a preprocessor macro for testing whether code is parsed by CLion
Project Model:
No more error/warning highlighting in CMake console
CLion incorrectly parses ; and other escaping in per-file compiler definitions
Problem with include, parser is now broken with -DCMAKE_SYSTEM_NAME=Generic (MinGW)
Rework compiler command line/response file parsing/building according to specs
Console filters can no longer change foreground text color
Can't remove first char in user input
Console:
Console filters can no longer change foreground text color
Can't remove first char in user input
Diff_Merge:
Open all files which are modified in the current branch
Editor. - Editing Text
Unicode â„•, UTF-8, Annotation Processor, Compiler source encoding on Windows
Find, Replace, Find Usages:
Find results from different files are merged
IntelliJ freezes when trying to invoke 'Find in path' on selection
Find: `Ctrl+F` on selected word doesn't pre-select text in search field if Find bar is open
Argument for @NotNull parameter 'scope' of com/intellij/psi/search/LocalSearchScope.<init> must not be null
Indices:
Out of memory dialog on IntelliJ IDEA start/open project
Building the stub tree for a file loads its contents twice in a row
User Interface:
Details in EventLog only clickable once
Project leak via com.intellij.ide.util.PsiClassListCellRenderer#INSTANCE
Active project window is hidden under already opened projects
strange highlight of settigns > appearance & behavior > notofications
Find Action popup can not be closed on Welcome Screen; NPE at com.intellij.ide.util.gotoByName.ChooseByNamePopup.dispose
Version Control:
Allow openning commit window when only unversioned files present
Version Control. Subversion:
Subversion1.8: cleanup invoked from file context menu fails with error
Code Insight:
Element type is not inferred in case of iteration over iterable with separate iterator
Debugger:
Element type is not inferred in case of iteration over iterable with separate iterator
Debugging jinja templates: visualization of currently active line is stuck on the first breakpoint
Add warning for slow debugger options
Can't debug python script with Remote Interpreter
Unable to debug with remote Python interpreter: cannot connect to X server
Inspections:
no warning about: `x, y = None` (TypeError: 'NoneType' object is not iterable)
Type doesn't have expected attributes with __slots__
Unresolved reference for attributes created by with statements
Test Runner:
Invalid subtest display with pytest.mark.parametrize

New in CLion 2017.1 Build 171.3019.8 EAP (Feb 9, 2017)

New in CLion 2017.1 Build 171.2822.8 EAP (Feb 2, 2017)

New in CLion 2016.3.2 Build 163.10154.43 (Jan 28, 2017)

New in CLion 2017.1 Build 171.2613.3 EAP (Jan 28, 2017)

Short summary:
Make auto intention
Polished Quick Documentation
Project Model improvements
VCS Log Viewer improvements
Zero latency typing mode is on by default
Dvorak layout support
Code analysis fixes and other improvements
SourceKit inspections and intentions for Swift
Closer to Almost Always Auto:
Using auto type for variable declarations is a powerful feature of modern C++ that makes the code less verbose and thus more readable. It also obliges you to initialize the variable. Herb Sutter once wrote an interesting article in his blog on AAA (Almost Always Auto) style, where he tried to analyze when the use of auto is justified and when it’s not. As we do support many ideas shared there and we’d like to help CLion users to modernize their C++ code, we’ve introduced this new intention action which converts variable type to auto:
auto_intention
While this is still a work in progress, we will also consider the opposite action – replacing auto with an appropriate variable type (CPP-8555).
This EAP also includes support for the auto return type (CPP-4321), which means more accurate code analysis, correct type inferred and shown in the Quick Documentation pop-up and code completion:
auto_return
Quick Documentation:
Quick Documentation pop-up (Ctrl+Q on Linux/Windows, F1 on macOS) combines lots of information about the code entity under the caret. For macros, it shows information about macro replacement, as well as macro substitution. For variables, it includes type information, even providing you with an inferred type for variables declared as auto. It shows signatures for functions, along with links to the referenced types, and much more, even including Doxygen-styled documentation preview and code comments.
In this build we’ve worked on polishing the Quick Documentation pop-up:
When comments are placed inside the code, Quick Documentation now includes both: type information and the comment
If the code entity under the caret doesn’t have any documentation comment, but the parent entity does, then Quick Documentation will show the parent documentation:
base_documentation
Project model:
Project model is becoming more user-friendly with a couple of useful fixes:
Renaming a project no longer breaks existing run configurations
Obsolete not-modified run configurations, and run configurations for deleted targets, are now removed automatically
For existing CMake projects, the project name in CLion is taken from CMake’s PROJECT_NAME on first opening
Besides, when opening a project in CLion for the first time, an executable run configuration is pre-selected now. Previously, it was a Build All configuration which may miss an executable to run and thus confuse users.
VCS Log Viewer
An updated VCS Log Viewer provides you with a few new options to tune search over commit messages there:
You can use regex
You can choose whether to make the search case sensitive
Zero latency typing:
While you type in the editor, the IDE is always doing lots of things in the background to provide you smart features on the fly, like completion, code analysis, formatting, etc. Wouldn’t it be great if typing performance weren’t visually affected by this fact? Ideally it should be comparable to that provided by a simple, code-agnostic text editor.
Some time ago Pavel Fatin, a developer at JetBrains, researched editor latency. Based on his findings, he implemented an experimental feature for IntelliJ IDEA (and the whole IntelliJ Platform) called zero latency typing. In a nutshell, his solution reduces the number of editor repaintings and performs them in a smarter way. The results are impressive:
editor-latency-linux-xml
So today, after almost 6 months of extensive testing, we are enabling zero latency typing as the default setting in all IntelliJ-based IDEs, including CLion.
Dvorak layout support and more:
If you’re more used to Dvorak layout in macOS than QWERTY, you’ll be glad to know that keyboards shortcuts like ⌘/, ⇧⌘], ⇧⌘[, ⌘+ and others are now working properly with it (JRE-172).
Besides, this EAP addresses an issue with Korean, Chinese and Japanese keyboard layouts on macOS.
Code analysis fixes and other improvements:
There are more bug fixes and enhancements introduced in this EAP build:
Incorrect Call to pow is ambiguous warning for GCC 6.2 was removed (CPP-8543)
Incorrect Too few template arguments warning was fixed (CPP-7150)
CLion now doesn’t suggest to reduce TRUE macro to ‘true’ for pure C code
CLion now doesn’t suggest to make static or friend functions pure virtual
Hidden functions from the base class are no longer suggested in the completion
Settings Repository plugin is finally bundled into CLion
Swift plugin: SourceKit inspections and intentions
We are glad to announce that SourceKit inspections and intentions are now available in the Swift plugin for CLion both on macOS and Linux:
linux_sourcekit@2x
Internally, the Swift plugin for CLion uses the SourceKit in-proc implementation.
Note that since the full support for reading Swift modules on Linux is not available yet, there could be issues with SourceKit integration in projects with complex dependencies. If you experience such problems, please report them in a sub ticket here.
Besides, we’ve added a New Project template for Swift, that allows you creating a new Swift project with ease (minimal working context is created automatically by CLion).

New in CLion 2016.3.2 Build 163.10154.14 EAP (Dec 16, 2016)

Configurations:
CLion’s approach to CMake has changed in v2016.3. CLion stopped building all 4 CMake configurations by default, letting you select which ones you need. While this reduces memory usage, as well as the time required for CMake reload, there was some inconvenience that our users reported in blog post comments, the tracker and other social channels.
After considering all the use cases carefully, we’ve come up with a UI that allows you to create additional CMake configurations (as many as you need):
cmake_additional_config
Go to Settings/Preferences | Build, Execution, Deployment | CMake and create any number of CMake configurations from scratch, or copy existing ones (with all the settings pre-filled). When done, additional resolve context will be available in the bottom right-hand switcher in the editor.
By the way, in case you have custom configurations created by the setting CMAKE_CONFIGURATION_TYPES, they will appear in the settings’ drop-down as well.
In the Run/Debug configuration settings dialog, you can switch between available CMake configurations:
If you used to switch between Release/Debug (or other configurations) during development, now you can create all the necessary CMake configurations and corresponding Run/Debug configurations (as necessary), and switch between them with ease.
Please, note, projects with multiple CMake configurations added in 2016.3.2 EAP might not work properly in v2016.3, but work ok in 2016.3.1 bug-fix update.
Exclude generated folders:
CLion 2016.3 allows changing the CMake generation folder path. Among other benefits, it brings the ability to generate in-source. However, this folder was not excluded from the project in CLion, which would cause usability issues. Now in the CLion 2016.3.2 EAP build, the directories are excluded, which means that:
Find in path and other searches do not go through the files in these folders; and
These folders are excluded from VCS.
CMake output console:
CMake output console has been updated to support error highlighting, links to corresponding CMake files, and navigation to next/prev errors:
cmake_console_errors
Besides, CMake 3.6.3 was bundled into this EAP build.
Project templates:
If you plan to start a project from scratch, we’ve got good news for you! Project templates finally have made their way to CLion. There are several options available in the dialog:
Select either a C++ project or a pure C project.
Select executable or library.
Select language standard and library type.
After you click Create, CLion will generate the sample project for you and pre-fill root CMakeLists.txt with the necessary information:
Project templates for Swift will also join a bit later (CPP-6155), as will compiler and additional libraries settings in the dialog (CPP-7919). Feel free to share your ideas in the corresponding tickets.
GCC6 support:
This build fixes the problem with correct recognition of (in case of GCC6) (CPP-7573). This work also covers most of the issues with #include_next (CPP-3821), and thus we are glad to announce that GCC6 can now be successfully used in CLion. If you still experience any issues, please, let us know.

New in CLion 2016.3.1 Build 163.9166.25 RC (Dec 8, 2016)

New in CLion 2016.3 Build 163.7743.47 (Dec 6, 2016)

New in CLion 2016.3 Build 163.7743.47 RC 3 (Nov 22, 2016)

New in CLion 2016.3 Build 163.7743.32 RC 2 (Nov 16, 2016)

New in CLion 2016.3 Build 163.7743.15 RC (Nov 10, 2016)

New in CLion 2016.3 Build 163.7342.13 EAP (Nov 4, 2016)

VALUABLE IMPROVEMENTS INCLUDE:
Remote GDB debug on Windows
User-defined literals rename
Fixes in code analysis
CMake reload optimizations
Remote GDB debug on Windows:
In CLion 2016.2 remote GDB debug was implemented for Linux and macOS platforms. With this build it comes to Windows! The following cases are supported:
Debugging of Windows targets built with MinGW (or MinGW-w64) from Windows host with MinGW (or MinGW-w64) GDB.
Debugging of Windows targets built with Cygwin from Windows host with Cygwin GDB.
Debugging of Windows targets built with one toolchain (MinGW/MinGW-w64 or Cygwin) from Windows host with GDB from another one. In that case don’t forget to provide correct path mappings in the Remote GDB Debug configuration’s settings.
Start your application under gdbserver on remote host, connect there in CLion on Windows and use all the features of CLion’s built-in debugger.
Cross-platform debug (i.e. targets on Linux) requires GDB for Linux to be used from CLion on Windows. The easiest way for it is to build it on Linux with cross-compilation settings. Get the binutils-gdb sources on Linux from the Git repository, switch branch to gdb-7.11.1-release and build like this (here the in-source build is used):
Copy the debugger (build-mingw-w64-x86_64/usr/bin/x86_64-linux-gnu-gdb.exe) to your Windows machine and select in the remote GDB configuration in CLion.
Renaming of user-defined literals:
First 2016.3 EAP introduced user-defined literals support in CLion. With this EAP you are now able to use Rename refactoring on such literals:
rename_udl
Besides, Find Usages works now for overloaded operators (except for new and delete)
Fixes in code analysis:
We continue our work on cleaning up the false-positive code analysis along with incorrect quick-fixes in CLion. This EAP build includes another set of fixes. The most important one relates to simplify quick-fix, that previously produced incorrect code for overloaded operators (CPP-2100).
Other fixes cover incorrect Reference may be null case (when one-element initializer list is used) and bogus loop variable is not updated inside the loop warnings.
CMake reload optimizations:
CMake project reload can be time-consuming, that’s why we’ve worked on the conditions in which the reload happens to be sure it’s not called when not necessary. Now CLion doesn’t reload project on opening, if nothing changed. Changes that do lead to reload are environment changes, CMake project settings changes and dependent files changes.

New in CLion 2016.2.3 Build 162.2228.26 (Oct 21, 2016)

New in CLion 2016.3 Build 163.6512.7 EAP (Oct 21, 2016)

New in CLion 2016.3 Build 163.6110.22 EAP (Oct 14, 2016)

New in CLion 2016.3 Build 163.5219.6 EAP (Sep 29, 2016)

Code - Highlighting and Inspections:
Variable read by cin is not detected as changed
Invalid 'Local variables used in loop condition are not updated in the loop'
Loop condition is not updated inside the loop (false positive)
Project Model:
'CMake output: Default' is not updated after some reloads (e.g. misconfigured CMake is fixed)
CMake console: Error icon isn't shown after reload with errors when non-default configuration selected
CMake doesn't recognize product file path with add_subdirectory after target renaming with case change
Unstable contents of iml file inside sourceFolder
Project and File Wizards:
Cannot open *.cmake/CMakeLists.txt using File | Open - project is opened instead
Console:
Saving console output to file produces an empty file
Move Filter#applyFilter from EDT to the pooled thread
Editor. Editing Text:
Selection gets broken for multi clicking Alt+Shift+Middle Mouse Button
Console Font preview - gutter is not updated on font size change
Breakpoints move unexpectedly on editing
'Quick Documentation' doesn't work in modal dialogs
In column mode, after pressing Shift-PageDown to efficiently extend the column to the bottom of the page, Shift-UpArrow stops working.
Line spacing makes cursor oversized
Quickdoc badly shows initialization of array
File System:
UI Freezes after maven build ends
Packaging and Installation:
Installation update: "background task running" dialog; patch is not applied if restart is postponed
Disable warnings in terminal
Cannot update EAP (from 163.3983.4 to 163.4396.1): IOException "Restart is not supported."
Settings Repository:
Custom keymaps not getting cloned/merged
User Interface:
Do not require confirmation each time I open an IPR file
Add "copy relative path" or make "copy path" configureable
java.lang.IllegalStateException: The DialogWrapper can only be used in event dispatch thread.
HiDPI Linux: Plugins repository: wrong icon rendering
HiDPI Linux: Project Settings - Module - Dependencies - columns are too small
LayeredIcon offsets are not scaled on hidpi
Find Action should populate the results in background
Change display behavior during background indexing: disable/remove content of tool windows instead of hiding windows
Version Control:
VersionControl toolwindow should not be available for project with no VCS enabled
VCS toolwindow is not available if the project has mapping
Version Control. Git:
Need GUI to configure remote repository and branch
Provide ability to add remote repositories to local git repository
Ability to change URL of git repository
Code Insight:
Invalid conversion character in fstring is not marked as an error
Unclosed braces inside a fstring should be an error
False positive: "Unresolved reference" for variable annotations with types from typing module
Named unicode character inside fstring causes IDE exception
Debugger:
Argument parsing for subprocess under debugger
Inspections:
PEP-8 E701 'Multiple statements on one line (colon)' for every variable annotation
False positive: unresolved reference for quoted type hints inside annotations
f-string expression cannot include a backslash
PyCharm does not see local variables when parsing fstrings

New in CLion 2016.3 Build 163.4830.5 EAP (Sep 21, 2016)

New in CLion 2016.3 Build 163.4396.13 EAP (Sep 14, 2016)

New in CLion 2016.2.3 Build 163.3983.6 EAP (Sep 8, 2016)

User-defined literals:
User-defined literals (UDL) is a C++11 feature that brings the concept of built-in type into the language, allowing developers to define types out of integer, float, character, and string literals by adding special suffixes. This makes the code easier to read. The Standard Library uses user-defined literals in a few places like std:string, std::complex, and std::chrono.
So please welcome UDL support in CLion! Use STL literals or define your own and be sure no more false positive errors are shown in the editor
Not only does CLion parse the user-defined literal, but it understands its type, as displayed in the Quick Documentation popup (Ctrl+Q on Lin/Win, F1 on macOS)
We plan to add a couple of smart actions for working with user-defined literals, including a quick-fix that generates a missing operator"" (CPP-7538) as well as Rename (CPP-7453) and Inline (CPP-7540) refactorings. Share your comments in the corresponding tickets and upvote and follow them to get updates.
C11 keywords:
CLion 2016.2.2 added support for some C11 keywords including _Thread_local, _Alignas, _Noreturn, _Static_assert, and _Atomic. CLion 2016.3 EAP expands this by adding _Generic keyword to the list, as well as providing code completion for C99 and C11 keywords
Code generation attributes:
The behavior of Override (Ctrl+O) and Implement (Ctrl+I) actions has been updated to use the virtual keyword by default when needed. The override attribute can be selected as an option:
override_implement
This helps avoid situations when both attributes are added automatically (CPP-416).
CMake output:
CMake tool window provides information on CMake warnings and errors (Problems tab) and CMake Cache variables (Cache tab). CLion 2016.3 EAP adds a new tab that contains CMake command output.
The tab provides several output logs, one per each CMake configuration. It can be used to track the progress and debug CMake scripts by checking the output messages from CMake.
When debugging CMake scripts, here’s one of the possible supported workflows:
1.Run CMake reload.
2.Check errors in the Problems tab.
3.If an error is caught and the reason is unclear, navigate to the Output tab.
4.Try to guess the problem source, make a fix, and re-run.
Projects opened from symlinked directories:
Previously CLion had debugging problems with projects whose paths included symlinks. Now it handles such projects correctly, especially adding and stopping at breakpoints in project and library files. If you face any issues at all with such projects, feel free to share with us.
Semantic highlighting:
Some say developers spend most of their time reading code rather than writing it. Reading code is not the same as reading a book. Code is usually well-structured, and while reading it we pay attention to a selected set of primitives and structural elements. This makes it easier to understand the idea (the algorithm) behind the code.
Usual highlighting picks out language keywords, types and values. However, if you’d like to understand how data flow through the code, it makes sense to highlight each variable/parameter with its own color. That’s where semantic highlighting comes in.
CLion 2016.3 EAP comes with a possibility to switch on semantic highlighting in the editor:
Go to settings Editor | Color & Fonts | Language Defaults.
Clone a scheme if you use any of the predefined ones (otherwise you won’t be able to introduce changes).
Go to Semantic highlighting settings and select the option Unique color for each parameter and local variable.
Now you can configure start/stop points for the gradient. Variables colors will be distributed uniformly between these points.
CLion follows these simple rules with its semantic highlighting:
Each parameter and local variable has its own color.
CLion tries to keep colors unique inside the body of a function or lambda.
Identifiers with the same name are assigned the same colors.
Try semantic highlighting in CLion today and let us know what you think!
rainbow
Command-Line Source Code Formatter:
Starting from this build, CLion comes with a command-line source code formatter (and so do IntelliJ IDEA and other IntelliJ-based IDEs). It can be used to format a set of selected files outside a project scope using an XML file with the exported code style settings. It’s available on Linux and Windows for now (macOS will join next EAP).
It can be used to format all files in a directory, or only those matching a list of file masks, or just a single file. Script should be provided with the code styles settings file in the XML format. The default code style is used if the file is omitted:
format_dir
To export code style settings, go to settings Editor | Code Style, click Manage… and export the code style you prefer to XML. This file can then be provided as a parameter to the format script.
VERSION CONTROL IMPROVEMENTS:
Undo:
With the new version, you can safely undo certain actions with no harm to your project. First, undo the last change that you haven’t pushed yet via the Log’s context menu
Second, restore a deleted local branch (or alternatively delete the tracked remote branch too).
Sign-off commit:
Some projects require Git –signoff commits to be used (most popular use case is getting patches into the Linux kernel). It simply adds a line at the end of the commit message, which certifies the commit author and can be interpreted as a chain of responsibility for the copyright status of the code. You can now find this option in CLion’s commit dialog:
USER INTERFACE:
Find in Path:
By popular request, we’ve changed the behavior of Find in Path so that it now preserves used previously settings, regardless of where you call it from:
find_in_path
Also, we are happy to share that the native file chooser on macOS is now back. Sorry for any inconvenience before!
Fira Code font:
CLion 2016.2 brought support for font ligatures. Now we are happy to announce that CLion 2016.3 EAP bundles the FiraCode font that supports ligatures, so you don’t need to install it manually. To set is as your editor font, select it in settings Editor | Colors & Fonts | Font

New in CLion 2016.2.2 Build 162.1967.7 (Sep 7, 2016)

New in CLion 2016.2.2 Build 162.1967.3 EAP (Aug 31, 2016)

New in CLion 2016.2.2 Build 162.1889.3 EAP (Aug 24, 2016)

New in CLion 2016.2.1 Build 162.1628.20 (Aug 10, 2016)

New in CLion 2016.2.1 Build 162.1628.2 EAP (Aug 3, 2016)

New in CLion 2016.2.1 Build 162.1531.1 EAP (Jul 27, 2016)

New in CLion 2016.2 Build 162.1236.16 (Jul 21, 2016)

This is our second release of 2016, building on the idea of releasing more often and bringing you the latest features faster. With many new fantastic tools, CLion can help you become a true C++ rockstar:
Inspect code more efficiently thanks to improved performance of debugger drivers and the remote GDB debug possibility.
Keep your code well-documented with Doxygen support (and thus reduce maintainability costs).
Save time on typing, with lots of new code generation options.
Work with CMake project model more easily thanks to smart CMake support.
DEBUGGER PERFORMANCE:
GDB and LLDB debugger drivers have been overhauled to improve both correctness and performance. We thank all our users for your collaboration – all your logs, sample projects and use case details finally made this possible!
If you’ve ever run into ‘command timeout’ in CLion, we encourage you to get this build as the problem should be fixed now. Lots of other issues have been fixed as well: ‘Variables’ windows that wasn’t updated on variable setting, problems with showing frames, incorrect debugger exit, and more.
As an important result, debugger performance has seen a huge boost – up to 600x in some cases:
The supported GDB version was updated to 7.11 and LLDB updated to 3.8. Besides, Linux users can now benefit from using LLDB (as it was previously available on macOS only).
REMOTE GDB DEBUG:
It’s finally here! One of the most awaited features has finally made its way into CLion. Run an executable on a target machine under gdbserver, connect remotely using CLion remote GDB configuration, and inspect code more powerfully from the IDE’s debugger. Set breakpoints to stop at, evaluate expressions, inspect variables views, change variable values on the fly, and more. For more details about the supported platforms and configuration, see this earlier blog post.
DOXYGEN SUPPORT:
Documenting code is a best practice that greatly aids code maintenance and support. Now CLion helps you with this by supporting the well-known Doxygen format.
See the Doxygen documentation preview in the Quick Documentation pop-up (Ctrl+Q on Linux/Windows, F1 on macOS), navigate to the function parameters from their description in Doxygen comments, and rely on function and function parameters rename that update Doxygen references automatically:
While adding new Doxygen comments to your code base, use Doxygen commands and function parameters completion, or simply generate the stub for Doxygen comments.
CODE GENERATION:
Saving time on typing is really easy with CLion. The many options of its ‘Generate’ menu (Alt+Insert on Linux/Windows, ⌘N on macOS) have been expanded with equality, relational and stream output operators. Select if you’d like to generate in-place, as class members, use std::tie for the implementation, and more:
Generate definitions (introduced in 2016.1) got updated behavior templates. Now CLion is able to adapt to the patterns you are using in your project. It can detect and support three possible patterns:
declarations are located in header files, definitions are in cpp-files;
class/struct is located in header file only; or
class/struct is located in cpp-file only.
If you switch from one of these patterns to another, CLion will pick up on that and behave accordingly when you use code generation the next time. More on that here.
Another way to save time on typing is the improved Complete Statement feature (Ctrl+Shift+Enter on Linux/Windows, or ⇧⌘⏎ on macOS). It helps you create syntactically correct code constructs by inserting the necessary syntax elements and getting you in position to start typing the next statement. It can complete namespaces, classes, enums, enum classes, structs and control statements
CODE FORMATTING:
CLion allows you to configure plenty of code style rules that will be applied on the fly as you type, to help you keep code well-formatted and thus easy to read and maintain. The newest settings fine-tune wrapping for lines after function return type in the scope of a class, in global and namespace scopes, lambda capture list, and in ‘’ operators.
Also, the list of predefined code styles has been expanded with LLVM and LLDB styles.
SMART CMAKE SUPPORT:
We keep working to make CMake easier to use in CLion. 2016.2 adds refactoring support for CMake:
Rename (Shift+F6 on Linux/Windows, ⇧F6 on macOS) for users symbols (like functions or macros) – all the usages will be updated accordingly.
Safe delete for files – related CMake commands will be updated, and a warning will appear in case of a possibly incorrect command.
To help you become a CMake guru, CLion also offers completion and navigation for user symbols, together with the new Boost-related live templates
If you want your CMake script to detect that it’s being called from CLion ( and if so, set special variables/paths or execute some additional scripts of your choice), you can now do that with the special environment variable, CLION_IDE. Environment variable completion in CMake will make the task even easier
EDITOR AND TOOL WINDOWS IMPROVEMENTS:
If you a fan of fonts with ligatures (e.g. FiraCode, Hasklig, Monoid or PragmataPro), you’ll be pleased to know that CLion now supports such fonts. Simply go to Editor | Colors & Fonts | Font settings, choose a corresponding font, and select the ‘Enable font ligatures’ option
To spice up your editor’s look, you can now set a custom background image. Use Find Action (Shift+Ctrl+A on Linux/Windows, ⇧⌘A on OS X), type Set Background Image, select an image and configure its settings in the dialog that appears:
background
If you work with long files, a new alphabetical sorting in Structure View (Alt+7) can come in handy to locate entities quicker (as opposed the reflecting the order in the original file).
OTHER CHANGES:
There’s a lot more in CLion 2016.2:
Important improvements in VCS support:
Files not yet under version control are now shown in the commit dialog, so you’ll never forget anything important.
The Log view for Git and Mercurial loads in the background on every change, so it’s always ready when you need it.
Patches can now be applied from the clipboard or by simply dragging them into the IDE. There’s also a Show Diff action to check the changes over your local version, and even a possibility to apply patches to files that were already moved or renamed.
Don’t worry about case-only renames in Git for Windows and macOS, as CLion now treats these situations correctly.
The Inspection results window makes it easier to preview the corresponding piece of code immediately, apply a quick-fix or disable a group of inspections in-place.
The maximum supported version of MinGW-w64 was updated to 5.*, and Cygwin to 2.*.
CLion on Windows now bundles a customized JDK version with font-rendering and focus fixes from the JetBrains team.
Swift plugin for CLion adds Swift 2.2 support, Introduce Variable refactoring and parameter placeholders for Swift. For more details head to the AppCode site.

New in CLion 2016.2.0 Build 162.1236.11 RC (Jul 14, 2016)

New in CLion 2016.2.0 Build 162.1236.1 EAP (Jul 6, 2016)

New in CLion 2016.2.0 Build 162.1120.17 EAP (Jul 1, 2016)

New in CLion 2016.2.0 Build 162.1024.9 EAP (Jun 23, 2016)

New in CLion 2016.2.0 Build 162.917.13 EAP (Jun 15, 2016)

New in CLion 2016.2.0 Build 162.844.13 EAP (Jun 10, 2016)

DEBUGGER:
Command timeout:
Sometimes an error would happen while collecting frames on breakpoint/interrupt or when the debugger was being launched. The debugging session would hang for some time and then a command timeout was reported to the user. Now a proper error message is reported to the console and in a notification balloon, so the ‘command timeout’ error shouldn’t bother you anymore.
Debugger correctness:
We overhauled debugger drivers, making it possible to fix many bugs with stepping and variables views, for example:
Value in “Variables” window wasn’t updated after the variable was set (CPP-5933).
Debugger failed to show frame variables when stepping into a function if const STL container was in outer frame (CPP-6150).
GDB didn’t exit correctly when program waited on cin (CPP-5615).
LLDB didn’t stop on breakpoints on case-insensitive file system if there were differences in file names/paths casing (CPP-6598).
GDB and LLDB versions updated:
We’ve also updated the bundled LLDB version (OS X only) to 3.8 and the GDB version to 7.11. Along with supported GDB version update, the maximum supported version of MinGW-w64 was updated to 5.3 and Cygwin to 2.5.
Performance improvements:
After all changes in both drivers, we ran performance tests to evaluate how they affected debugging startup/shutdown, stepping with various data views and expanding big data structures. The numbers are really promising (the picture shows the correlation between new and old data):
Besides, there were a few tests which finished with the TIMEOUT previously, while now they take some reasonable time to complete, like for example displaying strings or STL collections.
OTHER IMPROVEMENTS:
CMake and Safe delete:
Since the very first releases, when you add a new file, CLion has suggested updating the CMake targets with the newly created file. However, this automatic update was not possible in case of file deletion. Now it is!
If you delete a file listed as an argument in certain CMake commands, CLion will search for file usages in CMakeLists.txt files, warn you about an unsafe operation, and update the usages automatically.
These CMake commands include:
add_executable
add_library
set
add_custom_target_command
fltk_wrap_ui
qt_wrap_cpp
qt_wrap_ui
set_property
set_source_files_properties, and
try_compile
Note that if there are other files listed in the command arguments, CLion will simply delete the reference to the deleted file.
However, if the reference to the deleted file is the only command argument, deleting the reference (as well as the command itself) could lead to an incorrect CMake file, so this warning will be shown. You can then view the usages and decide if you’d like to proceed with deleting.
It works not only for C and C++ files, but for any file type (list resources for example, or other CMake scripts). Directories are not currently supported.
Live templates:
We’ve updated Boost-related live templates for CMake files and now there are two – boost and boost_with_libs. The latter is for linking your target with the Boost libraries. You only need to fill the components list and the target name.
Generate definitions:
When we first introduced the Generate definition action some users were confused by its behaviour. That’s why we’ve collected all the feedback and considered the cases carefully once again.
In general, there are several popular behaviour templates:
declarations are located in header files, definitions are in cpp-files,
class/struct is located in header file only,
class/struct is located in cpp-file only,
as well as any other custom case users might be interested in.
CLion now detects the case automatically, providing Generate in-place setting in the generate dialog:
It’s always unchecked when the action is called outside a class or a namespace.
When called inside a class or a namespace:
Unchecked if there are existing functions in the class with outside definitions.
Checked if there are no functions in the class or all the functions are in-place.
Unchecked if there are no functions in the class, the class is in a header file and there is a corresponding source file (unless it’s a template).
Font ligatures:
Font ligatures are officially supported by the IntelliJ-based IDEs now, and so does CLion. If you have a font that supports ligatures installed (e.g. FiraCode, Hasklig, Monoid or PragmataPro), then simply go to Preferences/Settings | Editor | Colors & Fonts | Font, choose a corresponding font there and select the Enable font ligatures option. That’s it!
There are a few more nice changes:
IDE’s notifications are now more friendly – there appear in the rightmost bottom corner and are grouped by the subsystem.
If you’d like to have a nice background image in your editor, it’s now possible in CLion. Call Find Action (Shift+Ctrl+A on Linux/Windows, ⇧⌘A on OS X), type Set
Background Image, select an image and configure its settings in the dialog that appears:
sea_line_background
Git/Mercurial log viewer now loads in the background on every change (a commit, fetch, rebase, etc) to be always ready when you open it.

New in CLion 2016.1.3 Build 145.1617.9 (Jun 8, 2016)

New in CLion 2016.2.0 Build 162.646.11 EAP (Jun 2, 2016)

New in CLion 2016.2.0 Build 162.426.5 EAP (May 26, 2016)

New in CLion 2016.2.0 Build 162.232.8 EAP (May 19, 2016)

Complete Statement:
Together with code completion and code generation, this feature helps you develop at the speed of thought. Invoked with Ctrl+Shift+Enter on Linux/Windows or ??? on OS X, it helps you complete many code constructs to syntactically correct ones. The simplest sample is a missing semicolon, but it’s actually much more!
With Complete Statement, CLion inserts parentheses, braces, semicolons, quotes, etc. for you where necessary, and then moves the caret in position where you can start typing the next statement automatically. Time savings are guaranteed.
CMake changes:
Starting from this build user symbols in CMake (like functions or macros) are available in code completion, as well as in the go to declaration/definition navigation actions. Quick definition pop-up is now also able to show definitions for user symbols. To invoke it, simply press Shift+Ctrl+I on Linux/Windows, or ?Y on OS X. The definition for the symbol at caret will be displayed:
cmake_quick_definition
Besides, Rename refactoring now works for user symbols in CMake as well:
Doxygen support:
Starting from this EAP build CLion makes it easier to keep your code properly documented with support for the widely-known documentation format, Doxygen. You can now view the documentation parsed from your Doxygen-styled comments in the Quick Documentation pop-up:
doc_doxygen_view
Besides, CLion will help you rename function parameters, by updating Doxygen comments automatically. It also provides code completion for a set of Doxygen commands and parameters names, and even code generation for the function documentation in Doxygen style. Read our blog post to learn more.
VCS improvements:
To make navigation through the VCS log easier, we’ve added tooltips with target commit information for arrows:
tooltip
If you’ve created several new files and didn’t add them to the version control, the commit dialog will show these files so you won’t forget to add them:
Several improvements were made for patches:
You can apply patch from the clipboard (the IDE will offer to apply the patch when it obtains focus). Alternatively, drag a file into the IDE.
If a file has been moved or renamed since a patch was created for it, the IDE will try to figure that out or let you manually choose the file to apply the patch to
Other improvements:
In debugger tool window, the Watches and Variables modes are now merged so you don’t need to switch between them. If you still prefer the old style, a new button is available in the watches toolbar to switch between the modes (new mode is on by default):
Following our custom JRE on Linux and OS X, our Windows builds are using a customized build of JDK now, which mostly includes font-rendering and focus fixes. (Just in case, build with the Oracle JRE is still available for the download.)

New in CLion 2016.1.2 Build 145.971.24 (May 17, 2016)

New in CLion 2016.1.2 Build 145.970.11 RC (Apr 28, 2016)

New in CLion 2016.1.1 Build 145.597.10 (Apr 1, 2016)

New in CLion 2016.1 Build 145.258.14 (Mar 17, 2016)

C++ language support:
This release brings long-awaited support for variadic templates (C++11). With the related fixes in the function overload resolution, this makes it possible to resolve the code correctly and avoid many false positives in code analysis. This also means that Qt C++11 connect calls are resolved correctly in CLion:
variadics_qt
Auto-import has been improved greatly for symbols from STL, and the quick documentation popup (Ctrl+Q on Linux/Windows, F1 on OS X) now shows lambda expressions, namespace aliases and explicit instantiation, as well as accurately redirecting hyperlinks.
Code generation:
In addition to Override that generates stubs for virtual member functions from any of base classes and Implement that overrides pure virtual functions from base classes, we’ve added Generate definitions (Shift+Ctrl+D on Windows/Linux, ⇧⌘D on OS X) which, as you would expect, generate definitions for existing declarations (in the previous versions you could use Implement action to get it). All three actions now put the code in the place the caret is positioned, in case it’s inside the class, or ask for a destination (if several options are available):
generate_definitions
Thus CLion 2016.1 makes the code generation behaviour quite simple and straightforward – if you want the function to be generated in a header file – locate the caret in that class in your header file, and if you want it in the source file – execute action there.
‘Generate definitions’ can be called up in three different ways:
By pressing Shift+Ctrl+D on Windows/Linux, ⇧⌘D on OS X.
Under the Generate menu (Alt+Insert in Windows/Linux, ⌘N on OS X).
As an intention action (Alt+Enter).
Read more details in the corresponding blog post.
CMake and directories control:
On the CMake side, a new feature called Reset CMake Cache is now available which allows you to clear the CMake Cache without dropping all of IDE indexes and caches.
Sometimes your project folders may contain binaries, logs, generated data or build artifacts (that you surely don’t want CLion to index) or simply libraries (that you don’t want to touch with refactorings). To handle this, a new feature was introduced – ‘Mark directory As’, which allows you to manually set directory as:
Excluded
Library files
Project sources and headers
Read how code completion, code generation, navigation and search features and refactorings are working for each of these cases.
The bundled Remote Host Access plugin will help you synchronize your sources with the remote host from time to time, for example if you develop on one machine but build/run on another. You can configure a FTP, FTPS or SFTP server together with the path mappings and excluded paths (to avoid downloading/uploading any files in particular):
remote_server
Debug:
In case you have a process running locally on your machine that you’d like to debug, you can do this within CLion. You just need to have the sources and open them in CLion, then call Attach to local process (from the Run menu or Find Action dialog) – and benefit from the built-in debugger. Processes can be searched by process name or process pid: just start typing and select a match from the list:
attach_to_local
New languages:
CLion 2016.1 comes with support for two additional languages: Python and Swift. The Python plugin is bundled into the IDE and is on by default. To easily start working on your mixed Python and C/C++ code project, install the Python SDK and point CLion to the Python interpreter for your project.
python_settings
The feature set corresponds to the PyCharm IDE Community Edition and includes all the essential Python editing features, like code completion, formatting, navigation, etc., as well as Python refactorings, code analysis, and running/debugging/testing the Python part of your project. Get more details and watch a demo in this blog post.
Another addition is support for Swift language. As Apple has open sourced Swift, developers on Linux can now try the language, and for their work an IDE is essential. CLion is cross-platform, so version 2016.1 can be used as a Swift IDE on Linux. You can find the plugin in our repository.
The feature set of the Swift plugin comes from AppCode (our IDE for iOS/OS X development which is based on Xcode toolchain and runs on OS X only). Swift code can be properly highlighted, formatted and completed; navigation and search actions are also available. If you’re looking for more high-level features, welcome the familiar Rename refactoring for Swift:
refactoring
The plugin also includes Override/Implement for functions and protocols, and a built-in debugger. More details and short demo can be found in a related blog post.
Other fixes and enhancements in this release include:
By-word difference highlighting option.
Support for multiple Git working trees and Checkout with Rebase Git action.
Right-to-left languages (Arabic and Hebrew) are now supported in the editor.
Automatic detection of Google Test configurations on project loading.
Custom bundled JRE on Linux with fixes from the JetBrains team.
And lots more.

New in CLion 2016.1 Build 145.257.16 RC 2 (Mar 15, 2016)

New in CLion 2016.1 Build 145.256.37 EAP (Mar 10, 2016)

New in CLion 1.5 Build 145.184 EAP (Mar 3, 2016)

New in CLion 1.5 Build 144.4199 EAP (Feb 18, 2016)

Generate definitions and more:
CLion helps you implement your ideas at the speed of thought with the code generation features, getting routine and mundane tasks out of your way. The set of features includes Override/Implement, generating constructors/destructors and getter/setter functions, ‘Surround with’ and Live Templates, and create from usage possibility.
Override and Implement actions generate stubs for virtual member functions from any of base classes. Having a couple of requests related to these features, we now added generate definitions (Shift+Ctrl+D on Windows/Linux, ⇧⌘D on OS X), that (we believe you can guess!) generates definitions for existing declarations. If the caret is placed inside the class, then the definition will be located right there in-place. In other cases, CLion will ask you about possible destinations (if several are possible):
By the way, Override/Implement features now work in the same way, asking for a destination (if several options are available) or generating code in-place for the caret located inside the class. That means if you want the function to be generated in a header file – locate the caret in that class in your header file, and if you want it in the source file – execute action there.
Generate definitions can be called in various ways:
By pressing Shift+Ctrl+D on Windows/Linux, ⇧⌘D on OS X.
From the generate menu (Alt+Insert in Windows/Linux, ⌘N on OS X):
generate_menu
As an intention action (Alt+Enter) – the only difference from the above is that intention action can generate only one definition at a time, while other options allow you to generate several function definitions at once.
This also makes Implement action more logical and consistent with other JetBrains IDEs – now it just overrides pure virtual functions from base classes.
Try this new feature and let us know what you think!
Auto-import:
Another big change introduced in this EAP build is an improved auto-import. Import assistance in CLion allows you to add includes automatically when non-imported symbol is met. Just press Alt+Enter and the include statement will be added, no need to move cursor from the current position and interrupt your editing session.
Some unexpected headers were suggested for STL symbols before. In this EAP build we’ve implemented special heuristics to solve the problem for C++ files and STL symbols, and we encourage you to evaluate the changes:
auto_import
Besides, this build addresses the following problems:
When the code generation is called or Extract Function refactoring is invoked, the enum types arguments and return types are now passed by value, not by reference (CPP-5781).
The bug with generating incorrect implementation for functions with default value is fixed (CPP-1889).
The bug with Rename that didn’t update non-code usages in case refactor preview was called is now fixed (CPP-5471).

New in CLion 1.5 Build 144.3891.18 EAP (Feb 11, 2016)

New in CLion 1.5 Build 144.3600.8 EAP (Feb 4, 2016)

New in CLion 1.5 Build 144.3357.5 EAP (Jan 28, 2016)