Open-source software tool for managing the build process of software!

Cmake (64-bit)

Cmake (64-bit)

  -  32.4 MB  -  Open Source
  • Latest Version

    Cmake 3.31.0 (64-bit) LATEST

  • Review by

    Daniel Leblanc

  • Operating System

    Windows 7 64 / Windows 8 64 / Windows 10 64 / Windows 11

  • User Rating

    Click to vote
  • Author / Product

    Kitware, Inc. / External Link

  • Filename

    cmake-3.31.0-windows-x86_64.msi

CMake is an open-source, cross-platform family of tools designed to build, test and package software. The app is used to control the software compilation process using simple platform and compiler independent configuration files, and generate native makefiles and workspaces that can be used in the compiler environment of your choice. The suite of the tools was created by Kitware in response to the need for a powerful, cross-platform build environment for open-source projects such as ITK and VTK.

CMake 64 bit is an extensible, open-source system that manages the build process in an operating system and in a compiler-independent manner. Unlike many cross-platform systems, It is designed to be used in conjunction with the native build environment. Simple configuration files placed in each source directory (called CMakeLists.txt files) are used to generate standard build files (e.g., makefiles on Unix and projects/workspaces in Windows MSVC) which are used in the usual way. It can generate a native build environment that will compile source code, create libraries, generate wrappers, and build executables in arbitrary combinations.

It supports in-place and out-of-place builds, and can, therefore, support multiple builds from a single source tree. It also supports static and dynamic library builds. Another nice feature of the app is that it generates a cache file that is designed to be used with a graphical editor. For example, when CMake runs, it locates files, libraries, and executables, and may encounter optional build directives. This information is gathered into the cache, which may be changed by the user prior to the generation of the native build files.

CMake is designed to support complex directory hierarchies and applications dependent on several libraries. For example, It supports projects consisting of multiple toolkits (i.e., libraries), where each toolkit might contain several directories, and the application depends on the toolkits plus additional code. It can also handle situations where executables must be built in order to generate code that is then compiled and linked into a final application. Because the app is open source and has a simple, extensible design, It can be extended as necessary to support new features.

Features and Highlights
  • Supports complex, large build environments. It has been proven in several large projects.
  • Generates native build files (e.g., makefiles on Unix; workspaces/projects on MS Visual C++). Therefore standard tools can be used on any platform/compiler configuration.
  • Has powerful commands include the ability to locate include files, libraries, executables; include external CMake files that encapsulate standard functionality; interfaces to testing systems; supports recursive directory traversal with variable inheritance; can run external programs; supports conditional builds; supports regular expression expansion; and so on.
  • Supports in-place and out-of-place builds. Multiple compilation trees are possible from a single source tree.
  • It can be easily extended to add new features.
  • It operates with a cache designed to be interfaced with a graphical editor. The cache provides optional interaction to conditionally control the build process.
If you are looking for Cmake (64-bit) alternatives, we recommend you to download Apache Maven or Gradle.

Also Available: Cmake (32-bit)

  • Cmake 3.31.0 (64-bit) Screenshots

    The images below have been resized. Click on them to view the screenshots in full size.

    Cmake 3.31.0 (64-bit) Screenshot 1
  • Cmake 3.31.0 (64-bit) Screenshot 2
  • Cmake 3.31.0 (64-bit) Screenshot 3

What's new in this version:

New Features:
Presets:
- cmake-presets(7) files may now include comments using the key $comment at any level within the JSON object to provide documentation
- cmake-presets(7) files may now request graphviz output using the graphviz key in a configure preset

Generators:
- The Ninja Generators and Makefile Generators now produce a codegen build target. It drives a subset of the build graph sufficient to run custom commands created with add_custom_command()'s new CODEGEN option.

Command-Line:
- The cmake --workflow mode now accepts a preset name as the first argument, allowing the simpler command line cmake --workflow <preset>
- The cmake -LR[A][H] option was added to list cache entries whose names match a regular expression

Compilers:
- The LFortran compiler is now supported with compiler id LFortran

Commands:
- The add_custom_command() command gained a CODEGEN option to mark a custom command's outputs as dependencies of a codegen target
- The cmake_pkg_config() command was added as an endpoint for using CMake's native pkg-config format parser. The only supported option in this release is EXTRACT, which provides low-level access to the values produced by parsing a pkg-config file. For most users, this is not yet a suitable replacement for the FindPkgConfig module.
- The file(ARCHIVE_CREATE) command gained a WORKING_DIRECTORY option to specify a working directory for the archiving process.
- The file(MAKE_DIRECTORY) command gained a RESULT option to capture failure in a result variable.
- The install(FILES) and install(DIRECTORY) commands' TYPE argument gained support for a LIBEXEC type.

Variables:
- The CMAKE_AIX_SHARED_LIBRARY_ARCHIVE variable and corresponding AIX_SHARED_LIBRARY_ARCHIVE target property were added to create shared libraries on AIX as shared library archives.
- The CMAKE_EXPORT_BUILD_DATABASE variable, a corresponding CMAKE_EXPORT_BUILD_DATABASE environment variable, and an EXPORT_BUILD_DATABASE target property, were added to enable exporting C++ module compile commands. This is only supported with Ninja Generators.
- The CMAKE_HOST_EXECUTABLE_SUFFIX variable was added to provide the suffix for executable names on the host platform.
- The CMAKE_<LANG>_HOST_COMPILER_ID and CMAKE_<LANG>_HOST_COMPILER_VERSION variables were added, where <LANG> is either CUDA or HIP. They are populated when CMAKE_<LANG>_COMPILER_ID is NVIDIA to identify NVCC's host compiler.
- The CMAKE_<LANG>_STANDARD_LINK_DIRECTORIES variable was added. Toolchain files can set this variable to control which link library directory paths are always passed to the compiler for the specified language.
- The CMAKE_LINK_LIBRARIES_STRATEGY variable and corresponding LINK_LIBRARIES_STRATEGY target property were added to optionally specify the strategy CMake uses to generate link lines.

Properties:
- The MACOSX_FRAMEWORK_BUNDLE_NAME target property was added to set the CFBundleName key in an Apple FRAMEWORK's Info.plist file
- The UNITY_BUILD target property now supports the CUDA language
- The VS_FRAMEWORK_REFERENCES target property was added to tell Visual Studio Generators to add framework references

CTest:
- The ctest_submit() command and ctest -T Submit step now verify TLS server certificates for connections to https:// URLs by default. See the CTEST_TLS_VERIFY variable for details.
- The ctest_submit() command and ctest -T Submit step now require TLS 1.2 or higher for connections to https:// URLs by default. See the CTEST_TLS_VERSION variable for details.

CPack:
- The CPack DEB Generator gained a CPACK_DEBIAN_PACKAGE_MULTIARCH option to support multi-arch packages.
- The CPack IFW Generator gained the new CPACK_IFW_PACKAGE_PRODUCT_IMAGE_URLS variable to specify images associated with entries of CPACK_IFW_PACKAGE_PRODUCT_IMAGES. This feature is available for QtIFW 4.0 and newer.
- The CPack RPM Generator gained support for zstd as a CPACK_RPM_COMPRESSION_TYPE value.
- The CPack module enables per-machine installation by default in the CPack WIX Generator

Deprecated and Removed Features:
- Compatibility with versions of CMake older than 3.10 is now deprecated and will be removed from a future version. Calls to cmake_minimum_required() or cmake_policy() that set the policy version to an older value now issue a deprecation diagnostic.
- The CMakeFindFrameworks module has been deprecated via CMP0173. Projects should use find_library() instead.
- The Visual Studio 12 2013 generator has been removed

Other Changes:
- When static libraries on link lines are de-duplicated (by policy CMP0156), the first occurrence is now kept on all platforms

Empty list elements in the TEST_LAUNCHER and CROSSCOMPILING_EMULATOR target properties are now preserved by:
- The add_test() command.
- The ExternalData_Add_Test() command from the ExternalData module
- The gtest_add_tests() and gtest_discover_tests() commands from the GoogleTest module. Empty list elements after the EXTRA_ARGS keyword of these two commands are also now preserved.
- The execute_process() command's ENCODING option, meaningful on Windows, now defaults to UTF-8
- The file(DOWNLOAD) and file(UPLOAD) commands now verify TLS server certificates for connections to https:// URLs by default. See the CMAKE_TLS_VERIFY variable for details. This change was made without a policy so that users are protected even when building projects that have not been updated. Users may set the CMAKE_TLS_VERIFY environment variable to 0 to restore the old default.
- The file(DOWNLOAD) and file(UPLOAD) commands now require TLS 1.2 or higher for connections to https:// URLs by default. See the CMAKE_TLS_VERSION variable for details.
- The file(GET_RUNTIME_DEPENDENCIES) command was updated to more closely match the dynamic loader's behavior on Linux.
- The install() command's DESTINATION arguments are now normalized, with the exception of INCLUDES DESTINATION arguments in install(TARGETS)
- The project() command now always sets <PROJECT-NAME>_SOURCE_DIR, <PROJECT-NAME>_BINARY_DIR, and <PROJECT-NAME>_IS_TOP_LEVEL as both normal variables and cache entries
- The cmake_parse_arguments(PARSE_ARGV) command now defines a variable for an empty string after a single-value keyword