# Quick start guide ## 0. Before you start ### Is CLion a cross-platform IDE? Yes, you can install and run CLion on Windows, macOS, and Linux. * See [Install CLion](installation-guide.html) for OS-specific instructions. * For more information about choosing the right keymap for your operating system, and learning the most useful shortcuts, refer to [CLion keyboard shortcuts](mastering-keyboard-shortcuts.html). ### What compilers and debuggers can I work with? In CLion, you can use [GCC](https://gcc.gnu.org/)-based compilers, [Clang](https://clang.llvm.org/), [Clang-cl](quick-tutorial-on-configuring-clion-on-windows.html#clang-cl), [Visual Studio C++ compiler](quick-tutorial-on-configuring-clion-on-windows.html#msvc-compiler), as well as [IAR compiler](iar-toolchain.html) and [custom-defined compiler](custom-compilers.html). For more information, refer to [Compilers](how-to-switch-compilers-in-clion.html). CLion supports debugging with [GDB](https://www.gnu.org/software/gdb) (either bundled or custom) on all platforms and with the bundled [LLDB](https://lldb.llvm.org) on macOS and Linux. Also, there is an [LLDB-based debugger for the MSVC toolchain](quick-tutorial-on-configuring-clion-on-windows.html#msvc-debugger) on Windows. For more information, refer to the [section on debugging](#debugging) and to the [Debugger options](configuring-debugger-options.html) page. ### What build systems are supported? What are the project formats? CLion fully integrates with the [CMake](https://cmake.org/) build system: you can create, open, build and run/debug [CMake projects](quick-cmake-tutorial.html) seamlessly. CMake itself is bundled in CLion, so you don't need to install it separately unless you decide to use a custom version. Apart from CMake, CLion supports [Makefile](makefiles-support.html), [Meson](meson.html), [compilation database](compilation-database.html), and [Gradle](gradle-support.html) projects. Note that the New Project wizard is not available for these project types yet. For more information, refer to [Project Formats](project-models.html). ### Do I need to install anything in advance? Windows: On Windows, CLion requires a working environment. CLion bundles a version of the MinGW toolset for quick setup. You can use this bundled toolchain or switch to another MinGW installation, Cygwin, or Microsoft Visual C++. If you are working with WSL or Docker, you will need to install them as well. For more information, refer to our [Windows tutorial](quick-tutorial-on-configuring-clion-on-windows.html). macOS: On macOS, the required tools might be already installed. If not, update command line developer tools as described in [Configuring CLion on macOS](quick-tutorial-on-configuring-clion-on-macos.html#reqtools). Linux: On Linux, compilers and make might also be pre-installed. Otherwise, in case of Debian/Ubuntu, install the [build_essentials](https://packages.ubuntu.com/xenial/build-essential) package and, if required, the [llvm](http://apt.llvm.org/) package to get Clang. ### Are languages other than C++ supported as well? Yes, CLion fully supports [Python](python.html), HTML (including HTML5), CSS, JavaScript, and XML. Support for these languages is implemented via the bundled plugins, which are enabled by default. For more information, refer to [CLion features in different languages](clion-features-in-different-languages.html). You can install other plugins to get more languages supported in CLion (for example, [Markdown](https://plugins.jetbrains.com/plugin/7793-markdown-support)). Learn more about plugins from the [Valuable language plugins](valuable-unbundled-plugins.html#langs_filestypes) article. ## 1. Open/create a project Procedure: Open a local project CMake: Use one of the following options: * Select File | Open and locate the project directory. This directory should contain a `CMakeLists.txt` file. * Select File | Open and point CLion to the top-level `CMakeLists.txt` file, then click Open as Project. * Select File | Open and locate the `CMakeCache.txt` file, then click Open as Project. Makefile: 1. Select `File | Open` from the main menu. 2. Point CLion to the folder containing the top-level `Makefile` or to `Makefile` itself (in this case, click Open as Project on the next step). Meson: 1. Select `File | Open` from the main menu. 2. Point CLion to the folder containing `meson.build` and click Open. Compilation database: 1. Select `File | Open` from the main menu. 2. Point CLion to the folder containing `compile_commands.json` or to the `compile_commands.json` itself (in this case, click Open as Project on the next step). Gradle: 1. Select `File | Open` from the main menu. 2. Point CLion to the folder containing `build.gradle` or to the `build.gradle` file itself (in this case, click Open as Project on the next step). Procedure: Clone a repository 1. Click Get from VCS on the Welcome screen or select Git (or your VCS) | Clone. 2. Enter the credentials to access the storage and provide the path to the sources. > **Tip:** > For more information, refer to [Clone repository](set-up-a-git-repository.html#clone-repo). Procedure: Create a new CMake project 1. Select `File | New Project` from the main menu or click New Project on the Welcome screen. 2. Set the type of your project: C or C++, an executable or a library. Note that [STM32CubeMX](embedded-stm32.html#new-project) and [CUDA](cuda-projects.html) are also CMake-based project types. 3. Provide the root folder location and select the language standard. CLion creates a new CMake project and fills in the top-level `CMakeLists.txt`: ![CMakeLists.txt in a stub CMake project](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_simple_cmakeprj.png) The initial `CMakeLists.txt` file already contains several commands. Find their description and more information on working with CMake in our [tutorial](quick-cmake-tutorial.html). ## 2. Take a look around New UI: ![New UI overview](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_qsg_newui_overview.png) Find a detailed description of the new UI elements in [New UI](new-ui.html). Classic UI: ![Classic UI overview](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_mainWindow.png) Find a detailed description of the Classic UI elements in [User interface](guided-tour-around-the-user-interface.html). Any time you need to find an IDE action, press `Ctrl+Shift+A` (Windows), `⌘ ⇧ A` (macOS), `⌘ ⇧ A` (IntelliJ IDEA Classic (macOS)), `⌘ ⇧ P` (macOS System Shortcuts), `Ctrl+Shift+A` (XWin), `Ctrl+Shift+A` (GNOME), `Ctrl+Shift+A` (KDE), `Escape, X` (Emacs), `Ctrl+Shift+P` (Sublime Text), `⌘ ⇧ P` (Sublime Text (macOS)), `⌘ ⇧ A` (Xcode), `Ctrl+Shift+A` (Visual Studio), `⌘ ⇧ A` (Visual Studio (macOS)), `Ctrl+Shift+A` (ReSharper), `⌘ ⇧ A` (ReSharper (macOS)), `Ctrl+Shift+A` (QtCreator), `⌘ ⇧ A` (QtCreator (macOS)), `Ctrl+I` (NetBeans), `Ctrl+Shift+A` (Eclipse), `⌘ 3` (Eclipse (macOS)) or go to `Help | Find Action` in the main menu and start typing the name of a command, setting, or even a UI element that you are looking for: ![Search for any action in the IDE](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_search_foraction.png) ## 3. Customize your environment ### Change the IDE appearance The quickest way to switch between the IDE's [color schemes](configuring-colors-and-fonts.html), [code styles](configuring-code-style.html), [keymaps](mastering-keyboard-shortcuts.html), [viewing modes](viewing-modes.html), and look-and-feels ([UI themes](user-interface-themes.html)) is the Switch... pop-up. To invoke it, click `View | Quick Switch Scheme` or press `Ctrl+`` (Windows), `⌃ `` (macOS), `⌃ `` (IntelliJ IDEA Classic (macOS)), `⌃ `` (macOS System Shortcuts), `Ctrl+`` (XWin), `Ctrl+`` (GNOME), `Ctrl+`` (KDE), `Ctrl+`` (Emacs), `Ctrl+`` (Sublime Text), `⌃ `` (Sublime Text (macOS)), `⌃ `` (Xcode), `Ctrl+`` (Visual Studio), `Ctrl+`` (Visual Studio (macOS)), `Ctrl+`` (ReSharper), `Ctrl+`` (ReSharper (macOS)), `Ctrl+`` (QtCreator), `⌃ `` (QtCreator (macOS)), `Ctrl+`` (NetBeans), `Ctrl+`` (Eclipse), `⌃ `` (Eclipse (macOS)): ![Quick scheme switcher](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_quicktheme_switcher.png) To explore all the customizable options, go to the dedicated pages in `Settings``Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `⌘ Comma` (Xcode), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Ctrl+Alt+S` (ReSharper), `⌘ Comma` (ReSharper (macOS)), `Ctrl+Alt+S` (QtCreator), `⌘ Comma` (QtCreator (macOS)), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS)). ### Tune the code editor Pages under the Editor node of the `Settings` dialog help you adjust the editor’s behavior, from the most general settings (like Drag'n'Drop enabling and scroll configuration) to highlighting colors and code style options. Code styles are configurable for each language separately in the pages under the `Editor | Code Style` node. For C/C++, you can set one of the [predefined code styles](predefined-code-styles.html) or provide your own, and configure the desired [naming convention](naming-conventions.html) including the [header guard](header-guards.html) template: ![Code style settings](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_qsg_codestyle_newui.png) ### Adjust the keymap In CLion, almost every action possible in the IDE is mapped to a keyboard shortcut. To view the default mapping, call `Help | Keyboard Shortcuts PDF`. You can customize the shortcuts in `Settings| Keymap`. Use one of the predefined keymaps (Visual Studio, Emacs, Eclipse, NetBeans, Xcode, and others) and tune it as required, or create your own keymap from scratch. ![Keymap settings](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_qsg_keymapsettings.png) There are also plugins that extend the list of available keymaps. For example, [VS Code Keymap](https://plugins.jetbrains.com/plugin/12062-vs-code-keymap) or [Vim emulation](https://plugins.jetbrains.com/plugin/164-ideavim) (which includes the Vim keymap). Find more useful plugins for the CLion editor in [Valuable non-bundled plugins](valuable-unbundled-plugins.html#tune_editor). ## 4. Code with assistance ### Auto-completion Completion `Ctrl+Space` (Windows), `⌃ Space` (macOS), `⌃ Space` (IntelliJ IDEA Classic (macOS)), `⌃ Space` (macOS System Shortcuts), `Ctrl+Space` (XWin), `Ctrl+Space` (GNOME), `Ctrl+Space` (KDE), `Alt+/` (Emacs), `Ctrl+Space` (Sublime Text), `⌃ Space` (Sublime Text (macOS)), `⌃ Space` (Xcode), `Ctrl+Space` (Visual Studio), `⌃ Space` (Visual Studio (macOS)), `Ctrl+Space` (ReSharper), `⌃ Space` (ReSharper (macOS)), `Ctrl+Space` (QtCreator), `⌃ Space` (QtCreator (macOS)), `Ctrl+Space` (NetBeans), `Ctrl+Space` (Eclipse), `⌃ Space` (Eclipse (macOS)) in CLion works as you type and gives a list of all available completions. To filter this list and see only the suggestions that match the expected type, use Smart completion `Ctrl+Shift+Space` (Windows), `⌃ ⇧ Space` (macOS), `⌃ ⇧ Space` (IntelliJ IDEA Classic (macOS)), `⌃ ⇧ Space` (macOS System Shortcuts), `Ctrl+Shift+Space` (XWin), `Ctrl+Shift+Space` (GNOME), `Ctrl+Shift+Space` (KDE), `Ctrl+Shift+Space` (Emacs), `Ctrl+Shift+Space` (Sublime Text), `Ctrl+Shift+Space` (Sublime Text (macOS)), `⌃ ⇧ Space` (Xcode), `Ctrl+Alt+Space` (Visual Studio), `⌃ ⌥ Space` (Visual Studio (macOS)), `Ctrl+Shift+Space` (ReSharper), `⌃ ⇧ Space` (ReSharper (macOS)), `Ctrl+Shift+Space` (QtCreator), `⌃ ⇧ Space` (QtCreator (macOS)), `Ctrl+Shift+Space` (NetBeans), `Alt+Shift+Space` (Eclipse), `⌥ ⇧ Space` (Eclipse (macOS)): ![SmartType completion](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_smartcompletion_type.png) Completion, along with other code insight features, is available for CMake code as well. See [Coding assistance in CMakeLists.txt](cmakelists-txt-file.html#code-insight-cmake). ![Completion in CMake](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_cmake_findpackage_completion.png) ### Code generation Even an empty class or a new C/C++ file contains boilerplate code, which CLion generates automatically. For example, when you add a new class, CLion creates a header with stub code and header guard already placed inside, and the corresponding source file that includes it. One of the most useful code generation features is create from usage. It helps you focus on the ideas as they come up and takes care of the routine. For example, when you call a function that is not yet implemented, there is no need to break the flow: press `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `⌥ ⏎` (Xcode), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Alt+Enter` (ReSharper), `⌥ ⏎` (ReSharper (macOS)), `Alt+Enter` (QtCreator), `⌥ ⏎` (QtCreator (macOS)), `Alt+Enter` (NetBeans), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS)) to generate stub code that you can come back to later. Create from usage works for variables and classes as well: ![Generate code from usage](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_codegen_createfromusage.png) To get the list of code generation options at any place in your code, press `Alt+Insert` (Windows), `⌘ N` (macOS), `⌃ N` (IntelliJ IDEA Classic (macOS)), `⌘ N` (macOS System Shortcuts), `Alt+Insert` (XWin), `Alt+Insert` (GNOME), `Alt+Insert` (KDE), `Alt+Insert` (Emacs), `Alt+Insert` (Sublime Text), `⌘ N` (Sublime Text (macOS)), `⌘ N` (Xcode), `Alt+Insert` (Visual Studio), `⌘ ⌃ N` (Visual Studio (macOS)), `Alt+Insert` (ReSharper), `⌘ ⌃ N` (ReSharper (macOS)), `Alt+Insert` (QtCreator), `Alt+Insert` (QtCreator (macOS)), `Alt+Insert` (NetBeans), `Alt+Insert` (Eclipse), `⌘ N` (Eclipse (macOS)) to invoke the Generate menu: ![The Generate menu](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_generatemenu.png) These options can help you skip a lot of code writing. In addition to generating constructors/destructors, getters/setters, and various operators, you can quickly override and implement functions: ![Implement/override functions](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_codegen_override.png) [Live templates](using-live-templates.html) are the tool to generate entire code constructs. Find the list of ready-to-use templates in `Settings | Editor | Live Templates`. To paste a template in your code, call `Code | Insert Live Template` or press `Ctrl+J` (Windows), `⌘ J` (macOS), `⌘ J` (IntelliJ IDEA Classic (macOS)), `⌘ J` (macOS System Shortcuts), `Ctrl+J` (XWin), `Ctrl+J` (GNOME), `Ctrl+J` (KDE), `Ctrl+J` (Emacs), `Ctrl+J` (Sublime Text), `Ctrl+J` (Sublime Text (macOS)), `⌘ J` (Xcode), `Ctrl+K, X` (Visual Studio), `⌘ E, L` (Visual Studio (macOS)), `Ctrl+J` (ReSharper), `⌘ J` (ReSharper (macOS)), `Ctrl+J` (QtCreator), `Ctrl+J` (QtCreator (macOS)), `Ctrl+J` (NetBeans), `Ctrl+Alt+Shift+J` (Eclipse), `Ctrl+J` (Eclipse (macOS)), for example: | Before | After | | --- | --- | | ![List of the available live templates](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_qsg_livetemplates_before.png) | ![The result of inserting a live temlate](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_qsg_livetemplates_after.png) | To quickly surround your code with loops and conditional statements like `if`, `while`, `for`, `#ifdef`, call `Code | Surround With` or press `Ctrl+Alt+T` (Windows), `⌘ ⌥ T` (macOS), `⌘ ⌥ T` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ T` (macOS System Shortcuts), `Ctrl+Alt+Shift+B` (XWin), `Ctrl+Alt+Shift+B` (GNOME), `Ctrl+Alt+Shift+B` (KDE), `Ctrl+Alt+T` (Emacs), `Ctrl+Alt+T` (Sublime Text), `⌘ ⌥ T` (Sublime Text (macOS)), `⌘ ⌥ T` (Xcode), `Ctrl+Alt+T` (Visual Studio), `Ctrl+Alt+T` (Visual Studio (macOS)), `Ctrl+Alt+T` (ReSharper), `Ctrl+Alt+T` (ReSharper (macOS)), `Ctrl+Alt+T` (QtCreator), `⌘ ⌥ T` (QtCreator (macOS)), `Ctrl+Alt+T` (NetBeans), `Alt+Shift+Z` (Eclipse), `⌘ ⌥ Z` (Eclipse (macOS)): | Before | After | | --- | --- | | ![The 'Surround with' options](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_qsg_surroundwith_before.png) | ![The result of surrounding with while](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_qsg_surroundwith_after.png) | ### Intentions and quick-fixes When you see a light bulb next to a symbol in your code, it means that CLion's code analysis has found a potential problem or a possible change to be made: * ![](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.actions.quickfixBulb.png) indicates an error and lets you choose a quick fix for it, * ![](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.expui.codeInsight.intentionBulb.png) indicates that one or several [intention actions](intention-actions.html) are available. Click the light bulb icon (or press `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `⌥ ⏎` (Xcode), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Alt+Enter` (ReSharper), `⌥ ⏎` (ReSharper (macOS)), `Alt+Enter` (QtCreator), `⌥ ⏎` (QtCreator (macOS)), `Alt+Enter` (NetBeans), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS))) and choose the most suitable action or quick-fix: | Quick-fixes | Intention actions | | --- | --- | | ![Quick-fix example](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_qsg_quickfix_example.png) | ![Intentions example](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_qsg_intention_example.png) | ### Inspections During on-the-fly code analysis, CLion highlights suspicious code and shows colored stripes in the right-hand gutter. You can hover over a stripe to view the problem description and click it to jump to the corresponding issue. The sign at the top of the gutter indicates the overall file status: ![Analysis results in the scrollbar](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_rightgutter_lense.png) CLion detects not only compilation errors but also code inefficiencies like unused variables or dead code. Also, it integrates a customizable set of [Clang-tidy checks](clang-tidy-checks-support.html). To enable or disable inspections, configure their severity levels (whether an inspection should raise an error or just be shown as a warning) and set the scopes, go to `Settings | Editor | Inspections`. You can also run inspections on demand for the whole project or a custom scope, and view the results in a separate window. For this, call `Code | Inspect Code` or use `Code | Analyze Code | Run Inspection by Name…` `Ctrl+Alt+Shift+I` (Windows), `⌘ ⌥ ⇧ I` (macOS), `⌘ ⌥ ⇧ I` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ ⇧ I` (macOS System Shortcuts), `Ctrl+Alt+Shift+I` (XWin), `Ctrl+Alt+Shift+I` (GNOME), `Ctrl+Alt+Shift+I` (KDE), `Ctrl+Alt+Shift+I` (Emacs), `Ctrl+Alt+Shift+I` (Sublime Text), `⌘ ⌥ ⇧ I` (Sublime Text (macOS)), `⌘ ⌥ ⇧ I` (Xcode), `Ctrl+Alt+Shift+I` (Visual Studio), `⌘ ⌥ ⇧ I` (Visual Studio (macOS)), `Ctrl+Alt+Shift+I` (ReSharper), `⌘ ⌥ ⇧ I` (ReSharper (macOS)), `Ctrl+Alt+Shift+I` (QtCreator), `⌘ ⌥ ⇧ I` (QtCreator (macOS)), `Ctrl+Alt+Shift+I` (NetBeans), `Ctrl+Alt+Shift+I` (Eclipse), `⌘ ⌥ ⇧ I` (Eclipse (macOS)) for a particular inspection. From the results tool window, you can batch-apply quick fixes for several issues at a time. Click Fix partially in the description tab: ![Applying quick-fixes to several inspection results](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_inspections_results_fixpartially_newui.png) > **Tip:** > For more information, refer to the [Static code analysis](code-inspection.html) section. ### Refactorings [Refactorings](refactoring-source-code.html) help improve your code without adding new functionality, making it cleaner and easier to read and maintain. Use the Refactor section of the main menu or call Refactor This... `Ctrl+Alt+Shift+T` (Windows), `⌃ T` (macOS), `⌘ ⌥ ⇧ T` (IntelliJ IDEA Classic (macOS)), `⌃ S` (macOS System Shortcuts), `Ctrl+Alt+Shift+T` (XWin), `Ctrl+Alt+Shift+T` (GNOME), `Ctrl+Alt+Shift+T` (KDE), `Ctrl+Alt+Shift+T` (Emacs), `Ctrl+Alt+Shift+T` (Sublime Text), `⌃ T` (Sublime Text (macOS)), `⌘ ⌃ ⌥ T` (Xcode), `Ctrl+Shift+R` (Visual Studio), `⌘ ⇧ R` (Visual Studio (macOS)), `Ctrl+Shift+R` (ReSharper), `⌘ ⇧ R` (ReSharper (macOS)), `Ctrl+Alt+Shift+T` (QtCreator), `⌃ T` (QtCreator (macOS)), `Ctrl+Alt+Shift+T` (NetBeans), `Ctrl+Alt+Shift+T` (Eclipse), `⌃ T` (Eclipse (macOS)) to get the list of refactorings available at the current location: ![The Retactor This popup](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_refactorthis.png) For example: * [Rename](rename-refactorings.html) `Shift+F6` (Windows), `⇧ F6` (macOS), `⇧ F6` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ R` (macOS System Shortcuts), `Shift+F6` (XWin), `Shift+F6` (GNOME), `Shift+F6` (KDE), `Shift+F6` (Emacs), `Shift+F6` (Sublime Text), `⇧ F6` (Sublime Text (macOS)), `⌘ ⌃ E` (Xcode), `Ctrl+R, R` (Visual Studio), `⌘ R, R` (Visual Studio (macOS)), `F2` (ReSharper), `F2` (ReSharper (macOS)), `Ctrl+Shift+R` (QtCreator), `⌘ ⌃ R` (QtCreator (macOS)), `Ctrl+R` (NetBeans), `Alt+Shift+R` (Eclipse), `⇧ F6` (Eclipse (macOS)) renames a symbol in all references. * [Change Signature](change-signature.html) `Ctrl+F6` (Windows), `⌘ F6` (macOS), `⌘ F6` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ S` (macOS System Shortcuts), `Ctrl+F6` (XWin), `Ctrl+F6` (GNOME), `Ctrl+6` (KDE), `Ctrl+F6` (Emacs), `Ctrl+F6` (Sublime Text), `Ctrl+F6` (Sublime Text (macOS)), `⌘ F6` (Xcode), `Ctrl+R, S` (Visual Studio), `⌘ R, S` (Visual Studio (macOS)), `Ctrl+F6` (ReSharper), `⌘ F6` (ReSharper (macOS)), `Ctrl+F6` (QtCreator), `⌘ F6` (QtCreator (macOS)), `Ctrl+F6` (NetBeans), `Alt+Shift+C` (Eclipse), `⌘ ⌥ C` (Eclipse (macOS)) adds, removes, or reorders function parameters, changes the return type, or updates the function name (affecting all usages). * [Inline](inline.html) `Ctrl+Alt+N` (Windows), `⌘ ⌥ N` (macOS), `⌘ ⌥ N` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ N` (macOS System Shortcuts), `Ctrl+Alt+N` (XWin), `Ctrl+Alt+N` (GNOME), `Ctrl+Alt+N` (KDE), `Ctrl+Alt+N` (Emacs), `Ctrl+Alt+N` (Sublime Text), `⌘ ⌥ N` (Sublime Text (macOS)), `⌘ ⌥ N` (Xcode), `Ctrl+R, I` (Visual Studio), `⌘ R, I` (Visual Studio (macOS)), `Ctrl+Alt+N` (ReSharper), `⌘ ⌥ N` (ReSharper (macOS)), `Ctrl+Alt+N` (QtCreator), `⌘ ⌥ N` (QtCreator (macOS)), `Ctrl+Alt+N` (NetBeans), `Alt+Shift+I` (Eclipse), `⌘ ⌥ I` (Eclipse (macOS))/[Extract](extract-method.html) a function. ## 5. Explore your code ### Search everywhere To search for anything in CLion, be it an item in your codebase, action, or UI element, press `Shift` twice and start typing what you are looking for in the [Search Everywhere](searching-everywhere.html) dialog. Use the filter ![filter](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.expui.general.filter.svg) menu to narrow your search: ![The Search Everywhere popup](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_searcheverywhere_filtered.png) ### Find usages To locate the usage of any code symbol, call Find Usages (`Alt+F7` (Windows), `⌥ F7` (macOS), `⌥ F7` (IntelliJ IDEA Classic (macOS)), `⌃ U` (macOS System Shortcuts), `Alt+F7` (XWin), `Alt+Shift+7` (GNOME), `Alt+Shift+7` (KDE), `Alt+F7` (Emacs), `Alt+F7` (Sublime Text), `⌥ F7` (Sublime Text (macOS)), `⌥ F7` (Xcode), `Shift+F12` (Visual Studio), `⇧ F12` (Visual Studio (macOS)), `Alt+F7` (ReSharper), `⌥ F7` (ReSharper (macOS)), `Ctrl+Shift+U` (QtCreator), `⌘ ⇧ U` (QtCreator (macOS)), `Alt+F7` (NetBeans), `Ctrl+G` (Eclipse), `⌘ ⇧ G` (Eclipse (macOS)) or `Edit | Find | Find Usages`). You can filter the results and jump back to the source code: ![Find Usages results](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_findusages_qsg.png) ### Navigate in the code structure * Switch between header and source file `F10` (Windows), `F10` (macOS), `F10` (IntelliJ IDEA Classic (macOS)), `F10` (macOS System Shortcuts), `F10` (XWin), `F10` (GNOME), `F10` (KDE), `F10` (Emacs), `F10` (Sublime Text), `F10` (Sublime Text (macOS)), `F10` (Xcode), `Alt+O` (Visual Studio), `⌘ ⌃ O` (Visual Studio (macOS)), `Alt+O` (ReSharper), `⌘ ⌃ O` (ReSharper (macOS)), `F4` (QtCreator), `F4` (QtCreator (macOS)), `F10` (NetBeans), `F10` (Eclipse), `F10` (Eclipse (macOS)) * Go to declaration/definition `Ctrl+B` (Windows), `⌘ B` (macOS), `⌘ B` (IntelliJ IDEA Classic (macOS)), `⌘ B` (macOS System Shortcuts), `Ctrl+B` (XWin), `Ctrl+B` (GNOME), `Ctrl+B` (KDE), `Ctrl+Alt+G` (Emacs), `F12` (Sublime Text), `F12` (Sublime Text (macOS)), `⌘ Click` (Xcode), `F12` (Visual Studio), `F12` (Visual Studio (macOS)), `Ctrl+B` (ReSharper), `⌘ B` (ReSharper (macOS)), `F2` (QtCreator), `F2` (QtCreator (macOS)), `Ctrl+B` (NetBeans), `F3` (Eclipse), `F3` (Eclipse (macOS))`Ctrl+Alt+B` (Windows), `⌘ ⌥ B` (macOS), `⌘ ⌥ B` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ B` (macOS System Shortcuts), `Ctrl+Alt+B` (XWin), `Ctrl+Alt+B` (GNOME), `Ctrl+Alt+B` (KDE), `Ctrl+Alt+B` (Emacs), `Ctrl+Alt+B` (Sublime Text), `⌘ ⌥ B` (Sublime Text (macOS)), `⌘ ⌥ Click` (Xcode), `Alt+End` (Visual Studio), `⌘ ⌥ Click` (Visual Studio (macOS)), `Ctrl+Alt+B` (ReSharper), `⌘ ⌥ B` (ReSharper (macOS)), `Ctrl+Alt+B` (QtCreator), `Ctrl+Alt+B` (QtCreator (macOS)), `Ctrl+Alt+B` (NetBeans), `Ctrl+T` (Eclipse), `Ctrl+Alt+B` (Eclipse (macOS)) * Show file structure `Alt+7` (Windows), `⌘ 7` (macOS), `⌘ 7` (IntelliJ IDEA Classic (macOS)), `⌘ 7` (macOS System Shortcuts), `Alt+7` (XWin), `Alt+7` (GNOME), `Alt+7` (KDE), `Alt+7` (Emacs), `Alt+7` (Sublime Text), `⌘ 7` (Sublime Text (macOS)), `⌘ 3` (Xcode), `Ctrl+Alt+F` (Visual Studio), `⌃ ⌥ F` (Visual Studio (macOS)), `Ctrl+F11` (ReSharper), `⌃ F11` (ReSharper (macOS)), `Alt+7` (QtCreator), `⌘ 7` (QtCreator (macOS)), `Ctrl+7` (NetBeans), `Alt+7` (Eclipse), `⌘ 7` (Eclipse (macOS)) * View type hierarchy `Ctrl+H` (Windows), `⌃ H` (macOS), `⌃ H` (IntelliJ IDEA Classic (macOS)), `⌃ ⌥ H` (macOS System Shortcuts), `Ctrl+H` (XWin), `Ctrl+H` (GNOME), `Ctrl+H` (KDE), `Ctrl+H` (Emacs), `Ctrl+H` (Sublime Text), `Ctrl+H` (Sublime Text (macOS)), `⌃ H` (Xcode), `Ctrl+E, H` (Visual Studio), `⌘ E, H` (Visual Studio (macOS)), `Ctrl+Alt+H` (ReSharper), `⌘ ⌥ H` (ReSharper (macOS)), `Ctrl+Shift+T` (QtCreator), `⌃ ⇧ T` (QtCreator (macOS)), `Alt+Shift+F12` (NetBeans), `F4` (Eclipse), `F4` (Eclipse (macOS)) * View call hierarchy `Ctrl+Alt+H` (Windows), `⌃ ⌥ H` (macOS), `⌃ ⌥ H` (IntelliJ IDEA Classic (macOS)), `⌃ ⇧ H` (macOS System Shortcuts), `Ctrl+Alt+H` (XWin), `Ctrl+Alt+H` (GNOME), `Ctrl+Alt+H` (KDE), `Ctrl+Alt+H` (Emacs), `Ctrl+Alt+H` (Sublime Text), `⌃ ⌥ H` (Sublime Text (macOS)), `⌃ ⌥ H` (Xcode), `Ctrl+Alt+H` (Visual Studio), `⌃ ⌥ H` (Visual Studio (macOS)), `Ctrl+Alt+H` (ReSharper), `Ctrl+Alt+H` (ReSharper (macOS)), `Ctrl+Alt+H` (QtCreator), `⌃ ⌥ H` (QtCreator (macOS)), `Ctrl+Alt+H` (NetBeans), `Ctrl+Alt+H` (Eclipse), `⌃ ⌥ H` (Eclipse (macOS)) * View import hierarchy `Ctrl+Shift+I` (Windows), `Ctrl+Shift+I` (macOS), `Ctrl+Shift+I` (IntelliJ IDEA Classic (macOS)), `Ctrl+Shift+I` (macOS System Shortcuts), `Ctrl+Shift+I` (XWin), `Ctrl+Shift+I` (GNOME), `Ctrl+Shift+I` (KDE), `Ctrl+Shift+I` (Emacs), `Ctrl+Shift+I` (Sublime Text), `Ctrl+Shift+I` (Sublime Text (macOS)), `Ctrl+Shift+I` (Xcode), `Ctrl+Shift+I` (Visual Studio), `Ctrl+Shift+I` (Visual Studio (macOS)), `Ctrl+Shift+I` (ReSharper), `Ctrl+Shift+I` (ReSharper (macOS)), `Ctrl+Shift+I` (QtCreator), `⌃ ⇧ I` (QtCreator (macOS)), `Ctrl+Shift+I` (NetBeans), `Ctrl+Shift+I` (Eclipse), `Ctrl+Shift+I` (Eclipse (macOS)) For your code, CLion builds the [hierarchies](analyzing-applications.html) of types, call, imports, and functions. To view them, use the shortcuts given above or the commands in the `Navigate` menu. For example, type hierarchy helps you not only to navigate the code but also to discover what type relationships exist in the your codebase: ![Type hierarchy](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_typehierarchy.png) To explore the structure of the currently opened file, call `View | Tool windows | Structure` or press `Alt+7` (Windows), `⌘ 7` (macOS), `⌘ 7` (IntelliJ IDEA Classic (macOS)), `⌘ 7` (macOS System Shortcuts), `Alt+7` (XWin), `Alt+7` (GNOME), `Alt+7` (KDE), `Alt+7` (Emacs), `Alt+7` (Sublime Text), `⌘ 7` (Sublime Text (macOS)), `⌘ 3` (Xcode), `Ctrl+Alt+F` (Visual Studio), `⌃ ⌥ F` (Visual Studio (macOS)), `Ctrl+F11` (ReSharper), `⌃ F11` (ReSharper (macOS)), `Alt+7` (QtCreator), `⌘ 7` (QtCreator (macOS)), `Ctrl+7` (NetBeans), `Alt+7` (Eclipse), `⌘ 7` (Eclipse (macOS)): ![File Structure](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_filestructure.png) Also, use the left gutter icons to quickly jump to a declaration/definition or navigate through the class hierarchy (![the Implemented method icon](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.expui.gutter.implementedMethod.svg) / ![the Implementing method icon](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.expui.gutter.implementingMethod.svg), ![the Overridden method icon](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.expui.gutter.overridenMethod.svg) / ![the Overriding method icon](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.expui.gutter.overridingMethod.svg)). ### View pop-up documentation [Quick Documentation](viewing-inline-documentation.html) popup (available on mousehover or via the `Ctrl+Q` (Windows), `F1` (macOS), `⌃ J` (IntelliJ IDEA Classic (macOS)), `⌘ I` (macOS System Shortcuts), `Ctrl+Q` (XWin), `Ctrl+Q` (GNOME), `Ctrl+Q` (KDE), `Ctrl+Q` (Emacs), `Ctrl+Q` (Sublime Text), `Ctrl+Q` (Sublime Text (macOS)), `⌘ ⌃ ⇧ /` (Xcode), `Ctrl+K, I` (Visual Studio), `⌘ K, I` (Visual Studio (macOS)), `Ctrl+Q` (ReSharper), `⌃ Q` (ReSharper (macOS)), `Ctrl+Q` (QtCreator), `Ctrl+Q` (QtCreator (macOS)), `Ctrl+Q` (NetBeans), `Alt+Middle-Click` (Eclipse), `⌥ Middle-Click` (Eclipse (macOS)) shortcut) helps you get more information on a symbol at caret without leaving the current context. Depending on the element you invoke it for, the popup shows: * function signature details, * code documentation (either regular or [Doxygen](creating-and-viewing-doxygen-documentation.html) comments), * inferred types for variables declared as `auto`: ![C++ inferred type in Quick Documentation popup](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_qdoc_inferredtype.png) * formatted macro expansions: ![Formatted macro expansion in Quick Documentation popup](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_qdoc_format.png) Besides, you can instantly view the definition of a symbol at caret. Press `Ctrl+Shift+I` (Windows), `⌥ Space` (macOS), `⌘ ⇧ I` (IntelliJ IDEA Classic (macOS)), `⌘ Y` (macOS System Shortcuts), `Ctrl+Shift+I` (XWin), `Ctrl+Shift+I` (GNOME), `Ctrl+Shift+I` (KDE), `Ctrl+Shift+I` (Emacs), `Ctrl+Shift+I` (Sublime Text), `⌥ Space` (Sublime Text (macOS)), `⌃ F1` (Xcode), `Alt+F12` (Visual Studio), `⌥ Space` (Visual Studio (macOS)), `Ctrl+Shift+I` (ReSharper), `⌥ Space` (ReSharper (macOS)), `Ctrl+Shift+I` (QtCreator), `Ctrl+Shift+I` (QtCreator (macOS)), `Ctrl+Shift+I` (NetBeans), `Ctrl+Shift+I` (Eclipse), `⌥ Space` (Eclipse (macOS)) to invoke the [Quick Definition](viewing-definition.html) popup: ![Quick definition](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_quickdef.png) ## 6. Build and run ### Run single file If you have only one or two files to compile and run, there is no need for you to get into project models: your files can be compiled and run/debug without it. Procedure: 1. [Open a source file or folder](run-single-file.html#open-a-file-no-project). 2. In the editor, click the left gutter icon next to your program's entry point and select the action: ![Run/debug a file using the gutter menu](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_rundebug_singlefile_gutter.png) > **Tip:** > For more information, refer to [Run/debug single file](run-single-file.html). ### Run/Debug configurations For each target in your project, CLion creates a [run/debug configuration](run-debug-configuration.html). It is a named setup which includes target, executable, arguments to pass to the program, and other options. Run/Debug configurations are generated from templates, such as CMake Application, Google Test, Remote GDB Debug, and so on. The templates are customizable: when you edit a template parameter, you change the default settings of all configurations that will be created from this template later. `Edit Configurations` dialog is accessible from the Run menu or the configuration switcher. Here you can manage the templates and add, delete, or edit your configurations. For example, you can customize the steps to be taken Before launch: call [external tools](configuring-third-party-tools.html) (including the remote ones), use [CMake install](using-cmake-install.html), or even run another configuration. ![Run/debug configurations dialog - the Before launch list](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_configurations_and_beforelaunch.png) To launch your program, select the desired configuration and use commands from the ![](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app-client.expui.run.run.svg)Run menu or press `Shift+F10` (Windows), `⌃ R` (macOS), `⇧ F10` (IntelliJ IDEA Classic (macOS)), `⌥ ⇧ R` (macOS System Shortcuts), `Shift+F10` (XWin), `Shift+F10` (GNOME), `Shift+F10` (KDE), `Shift+F10` (Emacs), `Shift+F10` (Sublime Text), `Shift+F10` (Sublime Text (macOS)), `⌘ ⌥ ⇧ R` (Xcode), `Ctrl+F5` (Visual Studio), `⌃ F5` (Visual Studio (macOS)), `Ctrl+F5` (ReSharper), `⌃ F5` (ReSharper (macOS)), `Ctrl+R` (QtCreator), `⌘ R` (QtCreator (macOS)), `F6` (NetBeans), `Alt+Shift+X` (Eclipse), `⌘ ⇧ F11` (Eclipse (macOS)). Alternatively, invoke the Run Anything dialog by pressing `Ctrl` twice and start typing the configuration name: ![The Run Anything dialog](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_run_anything_run.png) > **Tip:** > Hold down `Shift` to switch to Debug Anything. ### Build actions Build is included in many Run/Debug configuration templates as a default pre-launch step. However, you can also perform it separately by calling the desired [action](build-actions.html) from the Build menu: ![The Build menu](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_buildmenu.png) Notice the [Recompile](compiling-single-file.html) option that compiles a selected file without building the whole project. ### Remote and embedded development With CLion, you can also build and run/debug on remote machines including embedded targets. See the sections on [Remote development](remote-development.html) and [Embedded development](embedded-overview.html). ## 7. Debug CLion integrates with the GDB backend on all platforms (on Windows, the bundled GDB is available only for [MinGW](http://mingw.org/)) and LLDB on macOS/Linux. You can switch to a custom version of GDB on all platforms, a custom version of LLDB on macOS/Linux, or a [DAP debugger](dap-support.html) on all platforms. CLion also provides an [LLDB-based debugger](quick-tutorial-on-configuring-clion-on-windows.html#msvc-debugger) for MSVC on Windows. Currently, the versions of the bundled debuggers are the following: * LLDB v21.1.7 for macOS/Linux and 9.0.0 for Windows (MSVC) * GDB v17.1 for Windows * GDB v17.1 for Linux * Custom GDB v7.8.x-17.1 To start a debug session, select the desired configuration and press `Shift+F9` (Windows), `⌃ D` (macOS), `⇧ F9` (IntelliJ IDEA Classic (macOS)), `⌥ ⇧ D` (macOS System Shortcuts), `Shift+F9` (XWin), `Shift+F9` (GNOME), `Shift+F9` (KDE), `Shift+F9` (Emacs), `Shift+F9` (Sublime Text), `⌃ D` (Sublime Text (macOS)), `⌘ R` (Xcode), `Alt+F5` (Visual Studio), `⌥ F5` (Visual Studio (macOS)), `Alt+F5` (ReSharper), `⌥ F5` (ReSharper (macOS)), `F5` (QtCreator), `⌘ Y` (QtCreator (macOS)), `Ctrl+F5` (NetBeans), `Alt+Shift+D` (Eclipse), `⌘ F11` (Eclipse (macOS)) or click ![](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app-client.expui.run.debug.svg). You can set [breakpoints](using-breakpoints.html) by clicking the gutter next to a code line. To follow through the execution process, use debugger's [stepping actions](stepping-through-the-program.html): ![Stepping actions](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_debugSteppingToolbar_newUI.png) In the [Variables](examining-suspended-program.html#variables) tab of the debugger tool window, you can explore the values and change them without interrupting your debug session. To evaluate an expression, press `Alt+F8` (Windows), `⌥ F8` (macOS), `⌥ F8` (IntelliJ IDEA Classic (macOS)), `⌘ ⌃ L` (macOS System Shortcuts), `Alt+F8` (XWin), `Alt+Shift+8` (GNOME), `Alt+Shift+8` (KDE), `Alt+F8` (Emacs), `Alt+F8` (Sublime Text), `⌥ F8` (Sublime Text (macOS)), `⌥ F8` (Xcode), `Shift+F9` (Visual Studio), `⇧ F9` (Visual Studio (macOS)), `Shift+F9` (ReSharper), `⇧ F9` (ReSharper (macOS)), `Alt+F8` (QtCreator), `⌥ F8` (QtCreator (macOS)), `Ctrl+F9` (NetBeans), `Ctrl+U` (Eclipse), `⌘ U` (Eclipse (macOS)). CLion also shows the current variables' values right in the editor, and in case you enable [hex view](using-hexadecimal-view.html), it is shown inlined as well: New UI: ![CLion debugger IU](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_debugger_overview_newui.png) Classic UI: ![CLion debugger IU](https://resources.jetbrains.com.cn/help/img/idea/2026.2/gdbserver](remote-debug.html). ## 8. Analyze at run-time Some vulnerabilities and bugs can only be revealed during the program's execution: memory leaks, uninitialized accesses, concurrency issues, undefined behavior, and others. To help you catch run-time problems, CLion integrates [Valgrind Memcheck](memory-profiling-with-valgrind.html) and [Google Sanitizers](google-sanitizers.html). Also, you can analyze your application performance using the built-in [CPU Profiler](cpu-profiler.html) and measure [code coverage](code-coverage-clion.html). For these tools, CLion provides visualized output and handy features like the option to import/export analysis results. Settings for Valgrind, Sanitizers, and Profile are located under `Settings | Build, Execution, Deployment | Dynamic Analysis Tools`. For more information, refer to the section about [Dynamic code analysis](profiling-tools.html). ### Valgrind Memcheck [Valgrind Memcheck](memory-profiling-with-valgrind.html) in CLion works on Linux, macOS, and Windows via [WSL](how-to-use-wsl-development-environment-in-product.html). You need to [install](http://www.valgrind.org/docs/manual/dist.install.html) Valgrind, point CLion to the binary, set up the analysis flags, and then run the program using `Run | Run Valgrind Memcheck` or by pressing ![](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.actions.startMemoryProfile.svg). ### Google Sanitizers Google Sanitizers are supported on Linux for certain versions of Clang and GCC. Take a look at our detailed [guide](google-sanitizers.html) on using Sanitizers in CLion. ### CPU Profiler CLion’s [profiler](cpu-profiler.html), available on Linux and macOS, collects performance data for both user and kernel code of your application. The profiler collects performance metrics and visualizes them in flame charts and statistic views. To run it, call `Run | Profile` or use the ![](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.expui.toolwindow.profiler.svg) button. ### Code Coverage [Code Coverage](code-coverage-clion.html) integration in CLion is based on llvm-cov/gcov tools and is available for CMake applications and tests. Coverage results show the percentage of files per folder and lines per file covered during a launch. To get coverage measurements, set the necessary [compiler flags](code-coverage-clion.html#compiler-flags) and call `Run with Coverage` or click ![](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.expui.run.runWithCoverage.svg). ## 9. Add unit tests CLion supports [Google Test](creating-google-test-run-debug-configuration-for-test.html), [Boost.Test](boost-test-support.html), [Catch(2)](catch-tests-support.html), [CTest](ctest-support.html), and [Doctest](doctest-support.html) testing frameworks with the built-in test runner and dedicated Run/Debug configurations. For CMake targets linked with gtest or gmock, CLion creates Google Test configurations automatically. Running tests is similar to running a regular executable: CLion passes the specified test classes or methods to the test runner. Test runner shows the progress bar, output stream, and tree view of the running tests, and indicates their status and duration: ![CLion test runner](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_testrunner.png) You can rerun particular tests, all of them, or only the failed ones ![](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.expui.run.restartFailedTests.svg), export test results and open previous results from the history. Icons in the left gutter help you quickly run/debug tests and check the test status, success ![](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.expui.gutter.runSuccess.svg) or failure ![](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.runConfigurations.testState.red2.svg): ![Gutter icons for tests](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_tests_run_icons.png) ## 10. Keep it under version control ### VCS CLion integrates with several [version control systems](version-control-integration.html): Git (or GitHub), Mercurial, Perforce, and Subversion. To manage the settings of a particular VCS, go to `Settings | Version Control`. Use the VCS Operations Popup (`Alt+`` (Windows), `⌃ V` (macOS), `⌃ V` (IntelliJ IDEA Classic (macOS)), `⌃ C` (macOS System Shortcuts), `Alt+`` (XWin), `Alt+`` (GNOME), `Alt+`` (KDE), `Alt+`` (Emacs), `Alt+`` (Sublime Text), `Alt+`` (Sublime Text (macOS)), `⌃ S` (Xcode), `Ctrl+Alt+Q` (Visual Studio), `⌃ V` (Visual Studio (macOS)), `Alt+`` (ReSharper), `⌃ V` (ReSharper (macOS)), `Alt+`` (QtCreator), `⌃ V` (QtCreator (macOS)), `Alt+`` (NetBeans), `Alt+`` (Eclipse), `⌃ V` (Eclipse (macOS)) or `VCS | VCS Operations Popup`) to call version control commands. The list of actions in this popup includes both the currently enabled VCS and [local history](#local-history). For example: | No VCS Enabled | VCS Enabled | | --- | --- | | ![VCS disabled](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_vcs_disabled.png) | ![VCS enabled](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_vcs_enabled.png) | You can find all the available VCS commands in the VCS section of the main menu. Also, some basic commands are accessible from the toolbar: New UI: ![VCS actions on the main toolbar](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_vcs_toolbar_newui.png) > **Tip:** > CLion toolbar is customizable, see [Quickly add actions to the toolbar](customize-actions-menus-and-toolbars.html#add-toolbar-actions) Classic UI: ![VCS actions on the toolbar](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_QST_VCSbasic.png) ### Local history In addition to full version control, you can go back and review changes step by step by browsing the [local history](local-history.html). To view it for a file or folder, call `File | Local History | Show Local History`. Here you can revert changes and create patches: ![Local history](https://resources.jetbrains.com.cn/help/img/idea/2026.2/cl_localhistory.png) ## 11. Learn more We hope this brief overview of the CLion essentials will give you a quick start. To dig deeper, take a look at other articles and sections in the webhelp, for example: * [Project formats](project-models.html) * [Quick CMake tutorial](quick-cmake-tutorial.html) * [Toolchains](how-to-create-toolchain-in-clion.html) * [Code inspections](code-inspection.html) * [Dynamic code analysis](profiling-tools.html) * [Remote development](remote-development.html) * [Embedded development](embedded-overview.html) * [Unit testing tutorial](unit-testing-tutorial.html) For news and useful tips, check our [twitter](https://twitter.com/clion_ide) and [CLion blog](http://blog.jetbrains.com/clion/). Feel free to ask any questions on the [community forum](https://devnet.jetbrains.com/community/clion) and don't hesitate to report problems in the [CLion issue tracker](https://youtrack.jetbrains.com/issues/CPP). ## See also ### External Links [Webinar Recording: CLion 101 and Beyond](https://blog.jetbrains.com/clion/2020/06/webinar-recording-clion-101/)