Cmake Clion

Tips & Tricks

All work in CLion is done within the context of a project. Projects serve as the basis for coding assistance, bulk refactoring, coding style consistency, and other smart features.

CLion now relies on CMake as a project model. It takes all the information about the project from CMake build system. You can specify which files are included in the project, which C++ standard to use, and where to search for header files.

CMake is a tool used by Clion for development. CMake is used to control the software compilation process using (simple platform and compiler independent) configuration files, and generate native. Clion integrates with CMake nicely and I have used it here for the cross compiling. I assume you already have a CMake project and have some CMakeLists files etc. Create a new directory for the cmake toolchain file or put it in the root directory. Call this file anything you like with a.cmake extension. Cmake-kernel-module for clion. Contribute to enginning/cmake-kernel-module development by creating an account on GitHub. Note for CLion Build configuration - Edit - Select CMake Application target - Working directory point to current project path. Note for windowsx64: Remember setting arch support is amd64 (File - Settings - Build, Execution, Deployment - Toolchains - Visual Studio, Architecture: amd64 ). CLion puts the compiled executables in the specified directory (i.e. Mybulddir), but does not copy any input files needed to run tests, for example. When configuring from command line in Linux, I can do the following.

Any CMake-based projects can be opened easily in CLion, with no additional configuration needed: simply point it to the root CMakeLists.txt file in your project sources. You can also import non-CMake projects (File Import Project…), for which CLion will generate a CMakeLists.txt file.

CMake project settings can be found in Settings/Preferences Build, Execution, Deployment CMake dialog, and Tools CMake menu shows several useful CMake-related actions:

While editing CMake files in CLion, you can use auto-completion for file names and CMake commands:
Additionally, CLion can apply CMake files changes automatically.

If you are interested in these and some other CMake-related features in CLion view our demo:

Sincerely yours,
The CLion Team

Qt is a cross-platform C++ framework for creating GUI applications. Qt uses its own build system, qmake, and also supports building with CMake starting from the version Qt4.

A pure Qmake project can't be imported in CLion directly. However, when converted into CMake, it can be opened and managed as a regular CMake application. You can also create a CMake-based Qt project in CLion using the New Project wizard.

Another option to open a Qt project is to use a compilation database. You can generate compile_commands.json for your qmake project with the help of scan-build or via the Build Generate Compilation Database action in Qt Creator, then open this file as a project in CLion and add custom build targets and custom Run/Debug configurations for it.

CMake-based Qt projects

For CMake version 3.0 and newer, Qt ships the modules that let CMake find and use Qt4 and Qt5 libraries. Take the following steps to configure CMakeLists.txt for your Qt project.

Clion Use Latest Cmake

CMakeLists.txt for a Qt project

  1. Add the find_package command to locate the required libraries and header files. For example:

    Then, use target_link_libraries to make your target dependent on these libraries and headers:

    target_link_libraries(helloworld Qt5::Widgets)
  2. For find_package to perform successfully, CMake should be instructed on where to find the Qt installation.

    One of the ways to do this is by setting the CMAKE_PREFIX_PATH variable. You can either pass it via -D in the CMake settings dialog or via the set command before find_package.

    For example, in the case of MinGW on Windows:

    set(CMAKE_PREFIX_PATH 'C:QtQt5.')
    set(CMAKE_PREFIX_PATH 'C:QtQt5.')
  3. If your project uses MOC, UIC, or RCC, add the following lines to enable automatic invocation of the corresponding compilers:

  4. List all the .ui and .qrc files in the add_executable() command along with your .cpp sources:

    add_executable( helloworld main.cpp mainwindow.cpp application.qrc)

Below you can find the full CMakeLists.txt script for a simple 'Hello, world' application:

cmake_minimum_required(VERSION 3.10)project(Qt-CMake-HelloWorld)set(CMAKE_CXX_STANDARD 17)set(CMAKE_INCLUDE_CURRENT_DIR ON)set(CMAKE_PREFIX_PATH 'C:QtQt5.')find_package(Qt5Widgets REQUIRED)set(CMAKE_AUTOMOC ON)set(CMAKE_AUTOUIC ON)set(CMAKE_AUTORCC ON)add_executable(helloworld main.cpp mainwindow.cpp application.qrc)target_link_libraries(helloworld Qt5::Widgets)

Setting up a Qt project in CLion

Toolchains on Windows

  1. When installing Qt on Windows, pick the distributive that matches the environment you are using in CLion, MinGW or MSVC.

    For MinGW, both the version and the bitness (32-bit MinGW or MinGW-w64) should match with your toolchain setup.

  2. In CLion, go to Settings (Ctrl+Alt+S ), navigate to Build, Execution, Deployment Toolchain and select the toolchain that matches your Qt installation.

    If you have several Qt installations, make sure to select the same toolchain as the one you specified in CMAKE_PREFIX_PATH.

    As an example, in the case of MinGW:

For details on Windows toolchains, take a look at the MinGW or MSVC section of our Windows Tutorial.

CMake settings

  • Qt projects are handled as regular CMake projects in CLion, so you can configure CMake settings in Settings/Preferences Build, Execution, Deployment CMake as necessary.

    For example, you can create different CMake profiles with different build types and set up CMake generators of your choice.

    In this dialog, you can also specify CMake options, such as CMAKE_PREFIX_PATH instead of setting them in CMakeLists.txt:

Debugger renderers

You can use Qt type renderers, which are usually shipped with Qt tools, for your project in CLion. However, for now, you need to set them manually either using the .gdbinit/ .lldbinit scripts or, in the case of MSVC, via native visualizers.

  • Windows MSVC

    CLion’s debugger for the MSVC toolchain can employ native visualizers if you have them in your project. Make sure to set the Enable NatVis renderers for LLDB option in Settings Build, Execution, Deployment Debugger Data Views C/C++.

    For example, copy qt5.natvis under your project root, and CLion will automatically detect and use it for rendering.

  • Windows MinGW / macOS / Linux

    For non-MSVC toolchains, a solution would be to configure the Qt renderers via .gdbinit/.lldbinit. These scripts are loaded on every invocation of GDB or LLDB, respectively.

    1. You can try KDevelop formatters for GDB, KDevelop formatters for LLDB, Lekensteyn's qt5printers (GDB), or create your own pretty-printers.

      To create custom pretty printers, follow the official instructions for LLDB or GDB. You can take the pretty-printers for Rust implemented in the IntelliJ Rust plugin as a reference.

    2. Point the debugger to your renderers via .gdbinit/ .lldbinit. Find an example in this github repo.

    3. Place the .gdbinit/ .lldbinit files under the project root and allow them in your home directory as described here.


Editing UI files in Qt Designer

By default, CLion opens .ui files in the editor. You can change this behavior in order to edit .ui files right in Qt Designer.

  1. Go to Settings / Preferences Editor File Types, select Qt UI Designer Form from the Recognized File Types list, and delete the associated file extension.

  2. Next time you click a .ui file for opening, set the Open in associated application checkbox, and the files of this type will always open in Qt Designer.

Creating a CMake-based Qt project

CLion provides two project templates for Qt: Qt Console Executable and Qt Widgets Executable.

Clion Cmake Error

Call File New Project and select the project type in the left-hand pane. Specify the location, language standard, and Qt version. You can also provide the path to be used in CMAKE_PREFIX_PATH. Click Create when ready.

CLion will generate a ready-to-go stub project with CMakeLists.txt filled in automatically, including the CMAKE_PREFIX_PATH variable:

Qt UI class templates

You can quickly create a Qt class with the corresponding .ui, .cpp, and .h files.

  1. In the Project view, select New from the context menu or press Alt+Insert. Choose Qt UI Class:

  2. In the dialog that opens, fill in the class name and configure the following settings:

    • Filename base- specify the name for the .ui/ .cpp/ .h files to be generated.

    • Parent class- select QWidget, QMainWindow, QDialog, or a custom parent class.

    • Namespace- specify the enclosing namespace if required.

    • Add to targets- set this checkbox to automatically add the new files to the list of sources for the selected target(s).

      The Art of Haute Couture Laura Jacobs, Victor Skrebneski on shipping on qualifying offers. The Art of Haute Couture. The art of haute couture 2019.

  3. CLion will generate the .ui, .cpp, and .h files following the templates defined in Settings / Preferences Editor File and Code Templates: Qt Designer Form, Qt Class, and Qt Class Header, respectively. If required, you can adjust these templates for your needs.

Qt-specific code insight

  • CLion provides code completion for Qt signals and slots, filtering the suggestion list to show only the corresponding members:

    Completion works for the SIGNAL() and SLOT() macros as well:

  • CLion's auto-import supports Qt-style header files, offering the shortest possible #include:

  • Also, CLion integrates with clazy, a Qt-oriented static code analyzer. You can configure the severity and level of clazy checks in Settings/Preferences Editor Inspections C/C++ General Clazy:


QtCreator keymap

CLion bundles the QtCreator keymap. You can switch to it in Settings / Preferences Keymap or by calling View Quick Switch Scheme from the main menu (Ctrl+` ):

Current limitations

Windows Clion Cmake

Two umbrella tickets in CLion tracker: Qt project support (CPP-318) and Qt issues (CPP-1897).

Cmake Clion 3

  • Some of the CLion's code generation features may not work for Qt macros, such as Q_PROPERTY, Q_SIGNAL, Q_SLOT, and others.

  • Although QML is not supported in CLion out of the box (see the feature request ), you can try the QML Support plugin.


If you get the Process finished with exit code -1073741515 (0xC0000135) error message when running on MinGW, the issue might relate to Qt deployment on Windows: dynamic libraries and Qt plugins must be found from the directory of the running binary. Try one of the workarounds described below.

Option 1

  • Add the path to bin under the MinGW directory in the Qt installation (for example, C:Qt5.15.1mingw81_64bin) to the system PATH or in the Environment variables field of the configuration settings.

    If this doesn't solve the issue for your project, try Option 2.

Cmake Clion 2

Option 2

Cmake Clone Git Repo

  1. Copy the .dll -s located in bin under the MinGW directory in the Qt installation to your project’s generation folder, which is cmake-build-debug or cmake-build-release by default.

    The libraries you will most likely need are libstdc++-6.dll, Qt5Widgets.dll, Qt5Gui.dll, and Qt5Core.dll, but your setup might require other libraries as well.

  2. In the settings of the configuration you use for running, set the QT_QPA_PLATFORM_PLUGIN_PATH environment variable to pluginsplatforms under the MinGW directory:

    Another option is to copy the contents of pluginsplatforms to cmake-build-debug(release)/platforms (make sure to create the platforms directory).

    Refer to the Qt Plugins documentation for more details.