CLion
 
2022.3
Shortcuts: Windows
Get CLion
You are viewing the documentation for an earlier version of CLion.
  1. Configure projects
  2. Project formats
  3. Makefile
  4. Makefile projects

Makefile projects

Last modified: 11 January 2023

You can load Makefile projects in CLion and benefit from all the smart features the IDE provides.

Note that Makefiles support in CLion is in its early stages. Use the tickets linked to CPP-494 to leave your feedback and vote for the desired features. The list of the open-source projects that Makefile support has been tested on is available here.

tip

Refer to Autotools if your Makefile project requires pre-configuration.

Open a Makefile project

  1. Select File | Open from the main menu.

  2. Point CLion to a folder that contains the top-level Makefile or to that file directly:

    Opening a Makefile project

  3. In the dialog that opens, click Open as Project.

    Opening a Makefile as a project

  4. You will be prompted to clean the project:

    Load project dialog

    Cleaning is required for the project load as the Make build is incremental and only the updated files are compiled. When run on an uncleaned project, reload will miss all the unchanged files and might perform incorrectly.

    Clear the Clean project checkbox if you prefer to load without cleaning. You will be able to clean and reload your project later (for example, after performing the required bootstrapping).

  5. At this point, CLion starts loading the project, displaying the progress and status in the Build tool window:

    Project loading status in the Build tool window

    Warning messages may appear during the process, but if loading finishes with a green checkmark Successful load indicator next to the project name, this indicates a successful load. Take a look at the Troubleshooting section if your project fails to load correctly.

Load a Makefile for an opened project

You can also open a project as a folder and load the Makefile later. This is helpful, for example, if your project requires some preconfigure step or launching a script to prepare the final Makefile, so you don't have it when opening your project in CLion.

To load the Makefile when ready, open it in the editor and click the Load Makefile project link in the notification:

Load Makefile project notification

Alternatively, use the Load Makefile Project action from the file's context menu in the project tree.

    note

    When working with a Makefile project under VCS, consider not to share the .iml file, since it will be regenerated on import. See this instruction for more information.

    Configure auto-reload

    By default, CLion doesn't update or reload your project automatically except for the cases of external events like VCS update. You can change this behavior in the Build Tools settings.

    Reload manually

    Apart from the automatic options, you can also reload your project manually:

    • Call Reload Makefile Project or Clean and Reload Makefile Project from Tools | Makefile on the main menu.

      Tools | Makefiles menu

    • Alternatively, click the Reload icon or the Clean and reload icon in the Build tool window:

      Project reload icon in the Build tool window

    note

    Your project may also require the ./configure step to be performed after modifications in order to get the updated Makefiles.

    Adjust the project settings

    Use the Settings | Build, Execution, Deployment | Makefile dialog to control your project settings.

    Makefile settings

    • Toolchain

      Here you can select the toolchain to be used for loading your Makefile project.

      Note that NMake is not supported currently, so you can't use the Visual Studio toolchain directly. In order to work with it, you need to build the project separately using GNU Make.

      If the toolchain you selected includes non-default compilers (configured explicitly in the C Compiler and C++ Compiler fields), they will be passed to make as well.

      note

      Windows-specific details:

      • Your Makefile may include full paths to the tools. In this case, make sure to select the corresponding toolchain with the same paths.

      • When working with a MinGW toolchain, check that the paths don't contain spaces. Use the ~ notation if necessary, for example, C:\PROGRA~1\mingw-w64\....

    • Build options

      In this field, you can provide additional make options for the project build. These options don't affect the project reload.

    • Commands

      In this field, you can adjust preconfiguration parameters. See Pre-configuration (GNU Autoconf).

    • Arguments

      These arguments are used by CLion when calling the make command on the step of extracting project information, cleaning the project, or searching for build targets.

    • Build target and Clean target

      These targets are used along the make command to extract the project information. If you leave the Build target field empty, CLion will take the first target specified in the project’s top Makefile.

      Also, the targets specified here are used when you call Build Project or Rebuild Project from the Build actions menu.

    You can quickly access the Makefile settings dialog from the Build tool window. Select Makefile Settings from the context menu or click the Settings icon:

    Accessing Makefile settings from the Build tool window

    Advanced settings

    More settings for Makefile projects are available in Settings | Advanced Settings:

    Advanced settings for Makefile projects

    Makefile Application configurations

    CLion automatically creates a Makefile Application configuration for each target from the top-level Makefile. Note that targets from sub-directory Makefiles are disregarded.

    When creating configurations, CLion filters out the following targets:

    • The clean target.

    • Targets that correspond to object (.o) files.

    • Targets that end with unknown file extensions (for example, .d).

    You can customize the automatically created configurations or create new ones in the Edit Configurations dialog (see below).

    Create a Makefile Application configuration

    • To add a configuration, go to Run | Edit Configurations, click App general add, and select Makefile Application from the list of templates:

      Adding a Makefile Application configuration

    • In the Target field, you can choose one of the detected targets:

      Targets selection for a Makefile Application configuration

    • Another option is to set a custom build target with type Make. Click App actions inlay gear next to the Target field, add (App general add) a new Make target, and fill in the parameters:

      Custom targets for Makefile Application configurations

    • In the Executable field, provide the full path to the binary.

      To run/debug remotely, provide the path to the binary on your remote machine. The remote path needs to be set manually (if you click Platform impl icons process dots 1, CLion will suggest local paths).

    • Other settings of the Makefile Application template are described on the reference page.

    Makefile Target configurations

    You can use the gutter menu to quickly call make for a particular target:

    Gutter menu for running targets

    Alternatively, you can run targets from the Make tool window (View | Tool Windows | make). Double-click a target or select it and then click App actions execute:

    Running targets from the make tool window

    Upon one of these actions, CLion creates a temporary configuration of the Makefile Target type. You can customize it or create new configurations out of the same template in the Edit Configurations dialog (see below).

    Create a Makefile Target configuration

    • Go to Run | Edit Configurations, click App general add, and select Makefile Target from the list of templates:

      Adding a Makefile Target configuration

    • In the settings, you can set up several targets to run, provide additional arguments, and tune other parameters if required. See the reference page for details.

      A Makefile Target configuration

    note

    • Unlike Makefile Applications, Makefile Target configurations use the path to make from Settings | Build, Execution, Deployment | Build Tools | Make regardless of the currently selected toolchain.

    • Makefile Target configurations can't be used with remote or Docker toolchains. See below for details on WSL.

    WSL specifics

    Sync the settings

    When working with WSL, make sure to sync the per-project toolchain settings and the global Make settings:

    Non-root WSL user

    If you are working under a non-root WSL user, this user should be set as default in order to own the make process and all the files it may create.

    Troubleshooting

    Make sure that both Makefile and Makefile Language plugins are enabled. Check the Installed tab in Settings | Plugins.

    Makefile support plugins

    If your project fails to load correctly, try the following tips:

    • Check Makefile settings:

      1. Make sure to select a proper toolchain. Your project should build successfully in the selected environment.

      2. Arguments and Build target may need adjustments for the case of your project.

    • Call Tools | Makefile | Clean and Reload Makefile Project from the main menu or click the Clean and reload icon in the Build tool window.

    • If your project's Makefiles were generated by Premake, try removing the --no-print-directory arguments from the root Makefile.

    • In case none of the above helps, try cleaning the project cache from /makefiles in the system directory (for example, ~/Library/Caches/JetBrains/CLion2020.2/makefiles/postgrtipes.dc29ef09), then reload the project.

    Current limitations and future plans

    See also

    Procedures

    External Links