| CMake | |
|---|---|
 | |
 | |
| Developers | Andy Cedilnik, Bill Hoffman, Brad King, Ken Martin, Alexander Neundorf |
| Initial release | 2000; 26 years ago (2000) |
| Stable release | 4.2.2[1]  / 22 January 2026 |
| Written in | C,C++[2] |
| Operating system | Cross-platform |
| Type | Software development tools |
| License | BSD-3-Clause |
| Website | cmake |
| Repository | |
CMake is a free,cross-platform,software development tool forbuildingapplications viacompiler-independent instructions. It also canautomatetesting,packaging andinstallation. It runs on a variety ofplatforms and supports manyprogramming languages.[3]
As a meta-build tool, CMake configuresnative build tools which in turn build thecodebase. CMake generatesconfiguration files for other build tools based on CMake-specific configuration files. The other tools are responsible for more directly building, using the generated files. A single set of CMake-specific configuration files can be used to build a codebase using the native build tools of multiple platforms.[4]
Notable native build tools supported by CMake include:Make,Qt Creator,Ninja,Android Studio,Xcode, andVisual Studio.[4]
CMake is distributed asfree and open-source software under a permissiveBSD-3-Clause license.[5]
Initial development began in 1999 atKitware with funding from theUnited States National Library of Medicine as part of theVisible Human Project.[4] CMake was first released in 2000.
CMake was developed to support building theInsight Segmentation and Registration Toolkit (ITK) for multiple platforms. Stated goals included addressing weaknesses while maintaining strengths of contemporary tools such asautoconf andlibtool, and to align with state of the art build technology of the time:configure scripts andMake files forUnix platforms, andVisual Studio project files forWindows.[6][4]
CMake was inspired by multiple contemporary tools. pcmaker – developed by Ken Martin and others to support building theVisualization Toolkit (VTK) – converted Unix Make files into NMake files for building on Windows.[4] gmake supported Unix and Windows compilers, but its design led to issues that were hard to resolve. Both tools were working examples of a build tool that supported both Unix and Windows, but they suffered from a serious flaw: they required Windows developers to use the command line even though many prefer to use an integrated development environment (IDE) such as Visual Studio.
CMake was to provide similar cross-platform support but to better satisfy the preferences of the developers on each platform.
The design goals of the first version included:[4]
For various reasons, CMake developers chose to develop a scripting language for CMake instead of usingTcl – a popular language for building at the time. Use of Tcl would have then added a dependency to the host machine which is counter to the goal of no dependencies other than a compiler. Also, Tcl was not well supported on Windows and some Unix systems at the time of initial development.[4]
Subsequent development and improvements were fueled by the incorporation of CMake into developers’ own systems, including theVXL Project,[clarification needed] the CABLE[7] features added by Brad King,[clarification needed] andGE Corporate R&D for support of DART.[clarification needed] Additional features were created when VTK transitioned to CMake for its build environment and for supportingParaView.
Version 3.0 was released in June 2014.[8] It has been described as the beginning of "Modern CMake".[9] Experts now advise to avoid variables in favor oftargets andproperties.[10] The commandsadd_compile_options,include_directories,link_directories,link_libraries that were at the core of CMake 2 should now be replaced by target-specific commands.
CMake developer Brad King stated that "the 'C' in CMake stands for 'cross-platform'".
CMake can generate project files forIDEs likeMicrosoft Visual Studio,Xcode,Eclipse CDT and build scripts for MSBuild or NMake on Windows;Unix Make on Unix-like platforms such asLinux,macOS, andCygwin; andNinja on both Windows and Unix-like platforms by specifying generator for a platform-specific build tool. By default, CMake automatically determines default generator for the host environment it runs on. Command line option-G can be used to specify alternative generator. E.g.-G Unix Makefiles forces CMake to create build scripts formake.[4]
CMake does not support custom generators without modifying the CMake implementation. None-the-less, the CMake source code could be modified to include a custom generator.
CMake supports building executables, libraries (e.g.libxyz,xyz.dll etc.),object file libraries and pseudo-targets (including aliases). CMake can produce object files that can be linked against by executable binaries/libraries, avoiding dynamic (run-time) linking and using static (compile-time) linking instead. This enables flexibility in configuration of various optimizations.[11]
Target generation can be configured via target properties. With older versions, this was done viaCMAKE_-prefixed global variables, but this approach is deprecated.[10][12]
CMake configuration files can be structured according the hierarchical structure of the source code; the source tree. ACMakeLists.txt in a root source directory serves as the root of the configuration. It may include sub-directories which each contain aCMakeLists.txt. Repeating this, results in a hierarchical structure of configuration that follows the structure of the source code.[10][12]
CMake can store generated files (both by CMake and the native build tools) in adirectory tree that is separate from the source tree.[4]
This enables multiple builds from the same source tree since each has non-overlappingfile system space. This may be leveraged to build different or even incompatible configurations such as for different platforms.
This also simplifies file management by allowing removing generated files by deleting a single directory tree instead of removing multiple files and directories throughout the source tree. This tends to prevent accidentally deleting source files or accidentally adding generated files tosource control.
CMake ensures that downstream components are re-built when its sources are changed or built.[4]
CMake can locate system-wide and user-specified executables, files, and libraries. These locations are stored in acache, which can then be tailored before generating the target build files. The cache can be edited with a graphical editor, which is shipped with CMake.
Complicated directory hierarchies and applications that rely on several libraries are well supported by CMake. For instance, CMake is able to accommodate a project that has multiple toolkits, or libraries that each have multiple directories. In addition, CMake can work with projects that require executables to be created before generating code to be compiled for the final application. Its open-source, extensible design allows CMake to be adapted as necessary for specific projects.[13]
CMake allows specification of features that the compiler is required to support in order to get the target program or library compiled.[14]
CMake supports many compilers, including: Apple Clang,Clang,GNU GCC,MSVC,Oracle Developer Studio, andIntel C++ Compiler.[15]
CMake can produce packages that can be consumed both by end-user and third-party cmake-based project. Via CPack, built files may be packed into anarchive file for a target system's package manager (e.g.dpkg) orinstaller supported by the target platform.[16]: 132, 142 [17][18] CMake provides functions for pulling packages from a remote server that can be used as part of the build process or link previously installed cmake packages.[18]
Cmake may be run by using ancurses program likeccmake that can be used to configure projects viacommand-line interface.
It is possible to generateprecompiled headers via CMake since version 3.6.[19] As of version 3.28, CMake can also compilemodules. Experimental support for header units also exists.[20]
CMake supports extracting values into variables fromJSON-data strings (since version 3.19).[21]
CMake includes aninterpreter for a relatively simple, custom, imperativescripting language that supports variables, string manipulation, arrays, function and macro declaration, and module inclusion (importing).
The interpreter reads CMake language commands from files namedCMakeLists.txt which specify source files and build preferences. CMake uses this information to generate native tool configuration files. Additionally, files with suffix.cmake can be used for storing additional script.[22]
CMake language commands are formatted as:
name(argument ...)
Arguments arewhitespace-separated and can include keywords to separate groups of arguments. For instance, in the following command, the keywordCOMPILE_FLAGS delimits a list of source files from compiler flags.[23]
set_source_file_properties(filename ... COMPILE_FLAGScompile_flag ...)
The CMake scripting language is implemented viaYacc andLex generators.
The executable programs CMake, CPack, and CTest are written inC++.
Much of CMake's functionality is implemented in modules written in theCMake language.[24]
CMake documentation (since release 3.0) usesreStructuredText markup. HTML pages and man pages are generated by theSphinxdocumentation generator.
CMake ships with numerous.cmake script files and development tools that facilitate tasks such as finding dependencies (both built-in and external, e.g.FindXYZ modules), testing the toolchain environment and executables, packaging releases (CPack), and managing dependencies on external projects (ExternalProject module). Additional development tools include:[25][26]
CMake has been very widely adopted among commercial, open source, and academic software projects. A few notable users includeAndroid NDK,Netflix,Inria,MySQL,Boost (C++ libraries),KeePassXC,KDE,KiCAD,FreeCAD,Webkit,Blender,[29] Biicode,ReactOS,Apache Qpid, theATLAS experiment,[30] andSecond Life.[31]
Building via CMake has a two major stages.[4] First, native build tool configuration files are generated from CMake configuration files – written in the CMake scripting language. The command line syntax iscmake <dir> where <dir> is a directory that contains aCMakeLists.txt file. Then, the native build tools are invoked either via CMake (cmake --build <dir>) or directly via the native tool's interface. The native build tools use the generated files.[13][32]
The following demonstrates configuring CMake to build ahello world program written inC++, and using CMake to build the program.
hello.cpp:
#include<print>intmain(){std::println("Hello, world!");return0;}
CMakeLists.txt:
cmake_minimum_required(VERSION3.22)project(HelloWorldCXX)add_executable(hellohello.cpp)
To build via CMake, first cd to the directory containing the two files above. Then, generate the native build config files via the cross-platform CMake command:
cmake-Bout.
All generated files will be under the directoryout as specified via-B out.
Then, build via the native build tool as supported thru CMake:
cmake--buildout
The program is then available for running. ViaBash, the command is like./out/hello. On Windows, the output file ends with.exe.
This example demonstrates configuring the preprocessor include path.
hello.cpp:
#include<print>#include"hello.hpp"intmain(){for(inti=0;i<TIMES;++i){std::println("Hello, world!");}return0;}
hello.hpp:
#pragma onceconstexprintTIMES=10;
CMakeLists.txt:
cmake_minimum_required(VERSION3.22)project(HelloWorldCXX)add_executable(hellohello.cpp)target_include_directories(helloPRIVATE${PROJECT_SOURCE_DIR})
cpack(1) – Linux General CommandsManual from ManKier.com.