| CMake | |
| Logo Size: | 96px |
| Developer: | Andy Cedilnik, Bill Hoffman, Brad King, Ken Martin, Alexander Neundorf |
| Programming Language: | C, C++[1] |
| Operating System: | Cross-platform |
| Genre: | Software development tools |
| License: | BSD-3-Clause |
CMake is a free, cross-platform, software development tool for building applications via compiler-independent instructions. It also can automate testing, packaging and installation. It runs on a variety of platforms and supports many programming languages.[2]
As a meta-build tool, CMake configures native build tools which in turn build the codebase. CMake generates configuration 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.[3]
Notable native build tools supported by CMake include: Make, Qt Creator, Ninja, Android Studio, Xcode, and Visual Studio.
CMake is distributed as free and open-source software under a permissive BSD-3-Clause license.[4]
Initial development began in 1999 at Kitware with funding from the United States National Library of Medicine as part of the Visible Human Project. CMake was first released in 2000.
CMake was developed to support building the Insight Segmentation and Registration Toolkit (ITK) for multiple platforms. Stated goals included addressing weaknesses while maintaining strengths of contemporary tools such as autoconf and libtool, and to align with state of the art build technology of the time: configure scripts and Make files for Unix platforms, and Visual Studio project files for Windows.[5]
CMake was inspired by multiple contemporary tools. pcmaker developed by Ken Martin and others to support building the Visualization Toolkit (VTK) converted Unix Make files into NMake files for building on Windows. gmake supported Unix and Windows compilers, but was its design lead to hard to resolve environment issues. 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:
For various reasons, CMake developers chose to develop a scripting language for CMake instead of using Tcl 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.
Subsequent development and improvements were fueled by the incorporation of CMake into developers’ own systems, including the VXL Project, the CABLE[6] features added by Brad King, and GE Corporate R&D for support of DART. Additional features were created when VTK transitioned to CMake for its build environment and for supporting ParaView.
Version 3.0 was released in June 2014.[7] It has been described as the beginning of "Modern CMake".[8] Experts now advise to avoid variables in favor of targets and properties.[9] The commands,,, 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.[10]
CMake generates configuration files for a particular native build tool via one of its generators. A user can select a generator via the CMake command line.
The build files are configured depending on the generator used (e.g. Unix Makefiles for make) and associated toolchain files. Advanced users can also create and incorporate additional makefile generators to support their specific compiler and OS needs. Generated files are typically placed (by using 's flag) into a folder outside of the source's one (out of source build), e.g., .
Each build project in turn contains its own file and directory in every project (sub-)directory of included by the command, helping to avoid or speed up regeneration when it is run repeatedly.
The generation process and the output can be fine-tuned via target properties. Previously it was done via -prefixed global variables that are also used to configure CMake itself and to set up initial defaults.[11] The older approach is discouraged now.
CMake supports building executables, libraries (e.g., 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.[12]
One of its major features is the ability to place compiler outputs (such as object files) into a build tree which is located outside of the source tree. This enables multiple builds from the same source tree and cross-compilation. Separate source and build files ensure that removing a build directory will not affect source files and prevents clutter which might confuse version control systems.
CMake tracks changes and recompiles upstream dependencies of a given sub-module if its sources are changed.
CMake can locate system-wide and user-specified executables, files, and libraries. These locations are stored in a cache, 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 can generate project files for several popular IDEs, such as Microsoft Visual Studio, Xcode, and Eclipse CDT. It can also produce build scripts for MSBuild or NMake on Windows; Unix Make on Unix-like platforms such as Linux, macOS, and Cygwin; and Ninja on both Windows and Unix-like platforms.
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, and Intel C++ Compiler.[15]
Even though CMake is not a package manager, it provides basic modules (see CPack) functions for installing binaries and package information declared by the script to be used by consumer CMake projects. The package may also be packed into an archive file for package manager or installer supported by a target platform. Third-party packages may also be imported via configured CMake files which are either provided by the same third-party or created manually.[16] [17] [18]
Cmake may be run by using a ncurses program like that can be used to configure projects via command-line interface.
It's possible to generate precompiled headers via CMake since version 3.6.[19]
CMake supports extracting values into variables from JSON-data strings (since version 3.19).[20]
Building via CMake has a two major stages. First, native build tool configuration files are generated from CMake configuration files written in the CMake scripting language. The command line syntax is where
CMake includes an interpreter for a relatively simple, custom, imperative scripting language that supports variables, string manipulation, arrays, function and macro declaration, and module inclusion (importing).
The interpreter reads CMake language commands from files named which specify source files and build preferences. CMake uses this information to generate native tool configuration files. Additionally, files with suffix can be used for storing additional script.[22]
CMake language commands are formatted as:
name(argument ...)
Arguments are whitespace-separated and can include keywords to separate groups of arguments. For instance, in the following command, the keyword delimits a list of source files from compiler flags.[23]
set_source_file_properties(filename ... COMPILE_FLAGS compile_flag ...)
The CMake scripting language is implemented via Yacc and Lex generators.
The executable programs CMake, CPack, and CTest are written in C++.
Much of CMake's functionality is implemented in modules written in the CMake language.[27]
Since release 3.0, CMake's documentation uses reStructuredText markup. HTML pages and man pages are generated by the Sphinx documentation generator.
CMake ships with numerous script files and development tools that facilitate tasks such as finding dependencies (both built-in and external, e.g. modules), testing the toolchain environment and executables, packaging releases (CPack), and managing dependencies on external projects (module). Additional development tools include:[28] [29]
CMake has been very widely adopted among commercial, open source, and academic software projects. A few notable users include Android NDK, Netflix, Inria, MySQL, Boost (C++ libraries), KeePassXC, KDE, KiCAD, FreeCAD, Webkit, Blender,[32] Biicode, ReactOS, Apache Qpid, the ATLAS experiment,[33] and Second Life.[34]
The following demonstrates how to configure CMake to build a hello world program written in C++.
hello.cpp:
int main
CMakeLists.txt:
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:
The program is then available for running. Via Bash, the command is like . On Windows, the output file ends with .
This example demonstrates configuring the preprocessor include path.
hello.cpp:
int main
hello.h:
CMakeLists.txt: