CLion 2022.1 Help

CMake profiles

Settings required for building a CMake project are incorporated into a CMake profile. It includes toolchain and build type, as well as CMake options such as generators and environment variables. You can configure multiple profiles for your project in order to, for example, use different compilers or to build targets with differing settings.

To set up the profiles for your project, go to Settings / Preferences | Build, Execution, Deployment | CMake. You can quickly access this dialog from Find Action (Ctrl+Shift+A) (search for CMake Settings) or assign a shortcut for it in Settings / Preferences | Editor | Keymap.

Add a new profile

  1. Go to Settings / Preferences | Build, Execution, Deployment | CMake.

  2. Click App general add, and CLion will add a new profile to the list.

  3. Change the profile name, build type, and other settings as required.

Build with a profile

  1. The enabled profiles are listed in the Run/Debug configuration switcher. Select the one you need before building, running, or debugging your application:

    cmake profiles in the configuration switcher
  2. Click the Build button or call one of the available Build actions. Also, build is performed by default before run App actions execute or debug App actions start debugger (you can change this in configuration settings).

Default profiles for new projects

  • Go to File | New Projects Setup | Settings for New Projects | Build, Execution, Deployment | CMake.

  • Configure the list of profiles to be used for all new projects by default.

Share profiles

You can share CMake profiles in VCS along with the project. The profiles' settings are stored in cmake.xml in the .idea directory.

  • Select the profile you want to share and set the Share checkbox:

    Shared CMake profile

    Note that only the Profile settings can be shared. The Reload CMake project on editing CMakeLists.txt or other CMake configuration files option is common for all profiles and is stored in workspace.xml.

    Make sure to have different names for shared and local profiles. If a shared and a local profile have the same name, the local one takes precedence and you will not see the shared one in the settings.

Disable/enable profiles

You can disable the profiles that are not currently in use to save time on loading and avoid potential errors (for example, when you have a remote profile you don't use regularly and the machine is shut down).

Use one of the following options:

  • Clear or set the Enable profile checkbox in Settings / Preferences | Build, Execution, Deployment | CMake. Disabled profiles are grayed out in the list.

    Disabled profiles
  • To disable a successfully loaded profile, select Disable This Profile from the configuration menu in the CMake tool window:

    Disabling a loaded profile from the CMake tool window

    From this menu, you can also enable any of the previously disabled profiles:

    Enabling a previously disabled profile from the CMake tool window
  • If a profile has failed to load, you can disable it form the CMake tool window using the Disable profile option:

    Disabling an unloaded profile

Compiler flags

In CLion, there are two ways to specify compiler flags: either in CMake options of a profile, or right in the CMakeLists.txt script.

  • Using CMake options:

    Select the profile in Settings / Preferences | Build, Execution, Deployment | CMake and edit the CMake options field.

    Use -D with the CMAKE_CXX_FLAGS variable (or CMAKE_C_FLAGS for C projects). For example, -DCMAKE_CXX_FLAGS="-Wall -Wextra".

    Setting compiler flags in CMake options

  • In CMakeLists.txt:

    Alternatively, add the following line in your CMakeLists.txt script: set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra")

Generators

In the Generator field, you can switch between CMake generators. Use the default value for the selected toolchain or set another generator from the predefined list:

Specifying a custom CMake generator

Use default

CLion uses either Ninja or Makefiles as the default generator.

Ninja is used when all of the following is true:

  • The selected toolchain is local (this excludes Remote, Docker, and WSL).

  • The build tool configured for the selected toolchain in Ninja (bundled Ninja is the default build tool).

  • CMake version is 3.20 or later.

  • The project is created or opened for the first time in CLion 2021.3.

  • The Use legacy generator for CMake 3.20 and higher checkbox in Advanced Settings is not set.

In all other cases, the Makefiles generator is used.

Let CMake decide

If you choose this option, CLion will not force any generator explicitly, and CMake will decide which generator to use. By default, this is controlled by the CMAKE_GENERATOR environment variable.

Alternatively, you can set the generator in CMake options via -G. When the Generator field is used, CLion automatically updates CMake options and vice versa:

CMake generator in CMake options

Current limitations

  • CLion uses CMake File API, which first appeared in CMake v3.14. However, CLion supports it starting from the update introduced in CMake v3.15, so if you decide to switch from the bundled CMake, make sure to use version 3.15.x or later.

  • For multi-config generators like Ninja Multi-Config, Xcode, or Visual Studio, CLion uses only the configuration that corresponds to the build type specified in the CMake profile (CPP-20890).

Build types

Use the Build type field to set one of the following CMake build types:

  • Default (corresponds to the empty value of CMAKE_BUILD_TYPE).

  • Debug (the default build type)

  • Release

  • RelWithDebInfo (Release with debugging information)

  • MinSizeRel (Release optimized for size)

To refer to the build type in CMakeLists.txt, use the CMAKE_BUILD_TYPE variable. For example:

if (CMAKE_BUILD_TYPE MATCHES Debug) add_definitions(-DDEBUG=1) endif()

You can also create conditional statements in your code based on the current build type:

int main(int argc, const char* argv[]) { #if DEBUG ... #else ... #endif

Custom build types

The list of the available build types is defined in the CMAKE_CONFIGURATION_TYPES command. The default value of this command is the four build types given above, but you can extend it to have other build types. For example:

# adding two custom build types to the cached value # variable CMAKE_CONFIGURATION_TYPES should be defined before other definitions: set(CMAKE_CONFIGURATION_TYPES "MyDebug;MyRelease" CACHE STRING "" FORCE)

After reloading the project, custom types will be available from the CMake settings:

Custom build types

Note that the custom types were added to the value Debug which was cached in CMakeCache.txt. So for example, if you add a new CMake profile, it will have its own CMakeCache.txt, and for this profile, the list of the available build types will contain your custom types only:

Custom build types for new cmake profile

Build options

In the Build options field, you can set the options to be passed either to the build tool used by CMake or as command line parameters to CMake itself. These options will be used during the build phase.

Arguments for the underlying build tool (make, Ninja, or another one) should be preceded with --. For example, if you specify -j 5 --clean-first -- -d -p, then -j 5 --clean-first will be processed by CMake, while -d -p will be passed to the build tool.

When nothing is specified in this field, CLion uses default settings which depend on the selected environment. For example, if the make generator is set, the default value of this field is -- -j <80%_of_logical_cores>, while for Microsoft Visual C++ this field is empty.

Environment variables

You can pass additional environment variables to CMake generation and build via the Environment field of the CMake Settings dialog (navigate to Settings / Preferences | Build, Execution, Deployment | CMake).

The overall impacting environment for CMake generation and build consists of:

  • Parent environment

    To include parent environment, open the Environment Variables dialog by clicking App general inline variables or pressing Shift+Enter, and set the Include system environment variables checkbox. The values you specify additionally will be appended to system variables. Otherwise, when the checkbox is cleared, your custom values will overwrite the system ones.

  • Toolchain environment

    These are the variables defined by the selected toolset (for example, vcvarsall.bat for MSVC or path variables like mingw/bin), or the variables from an environment initialization script.

  • CMake profile environment

    Your custom variables specified in the Environment field.

For references to existing variables, use the $VAR$ syntax. Mind that such references are case-sensitive, for example, PATH=xxx:$PATH$ for Linux and macOS, and Path=xxx;$Path$ for Windows. Referencing existing variables is currently not available if you are using a remote toolchain (CPP-15693).

Last modified: 08 April 2022