How to Install CMake on Ubuntu

CMake reads each project's CMakeLists.txt configuration file, finds your compiler, and generates build instructions for a lower-level tool such as Make or Ninja, which then runs g++ or Clang. It does not replace a C or C++ compiler. Most modern C and C++ projects expect CMake on the build host—see install OpenCV on Ubuntu or install Boost on Ubuntu for larger examples after CMake is available.

On Ubuntu the default path is sudo apt install cmake. Ubuntu 26.04 already ships CMake 4.2.x in main; 24.04 and 22.04 stay on CMake 3.x, so projects that require CMake 4.x may need Kitware's apt repository, the Snap, or an official Linux binary on those LTS releases. This guide was tested on Ubuntu 26.04 with apt 4.2.3, Kitware apt 4.4.4, and the official 4.4.4 linux-x86_64 installer under /opt.

Quick answer

For most developers on a supported Ubuntu LTS:

sudo apt update
sudo apt install cmake

Check whether that version satisfies your project's cmake_minimum_required(VERSION …) line in CMakeLists.txt. If apt is too old, add Kitware's apt repository and run sudo apt install cmake again, or install an official binary under /opt without replacing Ubuntu's package.

Before you begin

CMake is a build configuration tool, not a C or C++ compiler. On Ubuntu, install build-essential when you need g++ for the C++ test at the end of this guide.

A typical C++ workflow looks like this:

     CMakeLists.txt
           ↓
         CMake
           ↓
    Make or Ninja
           ↓
      g++ / Clang
           ↓
 Program or library

Near the top of CMakeLists.txt, projects often declare the oldest CMake they support:

cmake_minimum_required(VERSION 3.28)

Compare that number with cmake --version before you replace Ubuntu's package with a newer CMake.

The install commands below run on the Ubuntu machine where you build your software. PATH is the ordered list of directories your shell searches when you type a command; if several cmake binaries exist, the first matching directory on PATH wins.

CMake versions on Ubuntu 26.04, 24.04, and 22.04

Run apt-cache policy cmake on your machine before choosing another install path. Confirm your release with check Ubuntu version when you are not sure which row applies.

Which CMake installation method should you use?

         ┌──────────────────────────────────────────┐
         │   Need CMake on Ubuntu for a C/C++ app   │
         └────────────────────┬─────────────────────┘
                              │
              ┌───────────────┴────────────────┐
              │ Does Ubuntu apt CMake satisfy  │
              │ cmake_minimum_required(VERSION)?│
              └───────────────┬────────────────┘
                    yes       │        no
                     ▼        │         ▼
              ┌──────────┐    │    ┌─────────────────────┐
              │ Ubuntu   │    │    │ Want newer CMake    │
              │ apt      │    │    │ through apt upgrade?│
              └──────────┘    │    └──────────┬──────────┘
                              │       yes     │      no
                              │        ▼      │       ▼
                              │   ┌──────────┐│  ┌──────────────┐
                              │   │ Kitware  ││  │ Official     │
                              │   │ apt repo ││  │ binary /opt  │
                              │   └──────────┘│  └──────────────┘

Pick one primary cmake on your PATH when you can. Common locations:

• /usr/bin/cmake — Ubuntu apt or Kitware apt packages
• /snap/bin/cmake — Snap install
• /opt/cmake-VERSION/bin/cmake — isolated official binary (recommended for manual installs)
• /usr/local/bin/cmake — many source or .sh installs with --prefix=/usr/local

/usr/local/bin often precedes /usr/bin, and Snap adds /snap/bin, so cmake --version can disagree with the package you thought you installed until you run type -a cmake.

Install CMake from Ubuntu apt

Ubuntu documents CMake as a normal development package installed with apt. This path is the one to try first.

Check the available CMake version

Refresh indexes and inspect the candidate before you install:

sudo apt update

Then read the candidate version apt would install. In apt-cache policy output, Candidate is the version APT would install or upgrade to right now:

apt-cache policy cmake

Sample output on Ubuntu 26.04 (amd64):

cmake:
  Installed: (none)
  Candidate: 4.2.3-2ubuntu2
  Version table:
     4.2.3-2ubuntu2 500
        500 http://archive.ubuntu.com/ubuntu resolute/main amd64 Packages

On 24.04 you should see a 3.28.x candidate; on 22.04, 3.22.x. The candidate line is what sudo apt install cmake will place in /usr/bin/cmake.

Install CMake

Install the cmake package. It pulls in cmake-data automatically—you do not install cmake-data separately.

sudo apt install cmake

Verify the installation

Ask the shell which binary wins and print the version Kitware reports:

command -v cmake

List every cmake on your PATH when more than one install might exist:

type -a cmake

Print the version string from the binary that wins:

cmake --version

/usr/bin/cmake
cmake is /usr/bin/cmake
cmake is /bin/cmake
cmake version 4.2.3

CMake suite maintained and supported by Kitware (kitware.com/cmake).

type -a is especially useful after you add Kitware apt, Snap, or a manual tree—multiple paths can coexist on disk.

Install a newer CMake from Kitware's apt repository

Kitware develops and maintains CMake. Kitware's apt repository is their signed Ubuntu package source—not a Launchpad PPA—and ships newer cmake packages than some LTS releases include in the main archive.

The repo documents 26.04 (resolute), 24.04 (noble), and 22.04 (jammy) repository lines. The page header still mentions older supported releases only, but the resolute instructions are present and worked on the Ubuntu 26.04 test host (apt offered 4.4.4 after the repo was added).

Use this path when Ubuntu's archive CMake is below your project's cmake_minimum_required but you still want sudo apt upgrade to manage CMake.

When the Kitware repository makes sense

Kitware apt is a good fit when:

• You are on 22.04 or 24.04 and need CMake 4.x or a newer 3.x than Ubuntu ships
• You are on 26.04 and want 4.4.x while staying on apt rather than a manual /opt tree
• You prefer .deb integration over Snap or a standalone tarball

Kitware asks that you not point CI jobs at this repository—use official release binaries for repeatable pipelines.

Add the Kitware repository

On a minimal image, install certificate and key tools first:

sudo apt-get update

Install tools needed to fetch and verify the repository signing key:

sudo apt-get install ca-certificates gpg wget

If kitware-archive-keyring is not already on the system, import the signing key once (fingerprint documented on apt.kitware.com):

test -f /usr/share/doc/kitware-archive-keyring/copyright ||
wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null |
  gpg --dearmor - | sudo tee /usr/share/keyrings/kitware-archive-keyring.gpg >/dev/null

Add the repository line for your Ubuntu codename—only one of the following blocks applies:

Ubuntu 26.04 (resolute):

echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ resolute main' | sudo tee /etc/apt/sources.list.d/kitware.list >/dev/null

Ubuntu 24.04 (noble):

echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ noble main' | sudo tee /etc/apt/sources.list.d/kitware.list >/dev/null

Ubuntu 22.04 (jammy):

echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ jammy main' | sudo tee /etc/apt/sources.list.d/kitware.list >/dev/null

Update indexes:

sudo apt-get update

If you imported the key manually and kitware-archive-keyring was not installed before, remove the temporary key file so the package can own the keyring:

test -f /usr/share/doc/kitware-archive-keyring/copyright ||
sudo rm /usr/share/keyrings/kitware-archive-keyring.gpg

Install the keyring package so key rotation stays managed:

sudo apt-get install kitware-archive-keyring

Install and verify CMake from Kitware apt

Install CMake now that the Kitware repository is enabled:

sudo apt-get install cmake

Check that apt now prefers Kitware's build:

apt-cache policy cmake

cmake:
  Installed: 4.4.4-0kitware1ubuntu26.04.1
  Candidate: 4.4.4-0kitware1ubuntu26.04.1
  Version table:
 *** 4.4.4-0kitware1ubuntu26.04.1 500
        500 https://apt.kitware.com/ubuntu resolute/main amd64 Packages
     4.2.3-2ubuntu2 500
        500 http://archive.ubuntu.com/ubuntu resolute/main amd64 Packages

Confirm the active binary:

cmake --version

cmake version 4.4.4

CMake suite maintained and supported by Kitware (kitware.com/cmake).

To return to Ubuntu's archive CMake later, remove the Kitware list and refresh indexes:

sudo rm /etc/apt/sources.list.d/kitware.list

Refresh package indexes after the list file is gone:

sudo apt update

Compare the Installed line with Ubuntu's archive Candidate:

apt-cache policy cmake

If the installed Kitware build is newer than Ubuntu's Candidate, APT will not downgrade automatically when you run sudo apt install cmake. Either install the Ubuntu package version explicitly (use the exact 4.2.3-2ubuntu2-style string shown under Ubuntu's entry in apt-cache policy), or purge the Kitware packages first and reinstall Ubuntu's cmake:

sudo apt purge cmake cmake-data

Reinstall from the Ubuntu archive only:

sudo apt install cmake

Install a specific CMake version from official binaries

Kitware publishes prebuilt Linux archives on the CMake download page for linux-x86_64 and linux-aarch64. This section uses the self-extracting .sh installer; the .tar.gz is the same file tree without the installer wrapper—unpack it under /opt if you prefer tar over sh.

If you need one specific CMake version that stays separate from Ubuntu's package, use a dedicated prefix such as /opt/cmake-4.4.4. /opt is commonly used for manually installed third-party software; one directory per version makes removal a single rm -rf without touching /usr/bin/cmake.

Check your CPU architecture

Map Ubuntu's architecture name to Kitware's binary name:

dpkg --print-architecture

amd64

Replace linux-x86_64 in the URLs below with linux-aarch64 on ARM64 systems.

Install the official Linux binary

Download the version you need (example 4.4.4 on amd64):

cd /tmp

Download the self-extracting installer for your architecture:

wget https://github.com/Kitware/CMake/releases/download/v4.4.4/cmake-4.4.4-linux-x86_64.sh

Mark the script executable:

chmod +x cmake-4.4.4-linux-x86_64.sh

Create the target prefix, then run the installer non-interactively:

sudo mkdir -p /opt/cmake-4.4.4

Run the installer non-interactively. --skip-license skips the license prompt; --exclude-subdir places the CMake tree directly inside the prefix instead of creating another versioned folder beneath it:

sudo sh cmake-4.4.4-linux-x86_64.sh --skip-license --exclude-subdir --prefix=/opt/cmake-4.4.4

The installer prints Unpacking finished successfully when the tree is ready under /opt/cmake-4.4.4.

You can keep Ubuntu's apt cmake installed. /usr/local/bin and /opt/.../bin only take precedence after you extend PATH. If you want the manual tree to be the default in every new shell, append:

echo 'export PATH="/opt/cmake-4.4.4/bin:$PATH"' >> ~/.bashrc

Reload the shell or run export PATH="/opt/cmake-4.4.4/bin:$PATH" for the current session before testing.

Verify which CMake binary is active

Call the binary by full path first—this proves the unpack worked regardless of PATH:

/opt/cmake-4.4.4/bin/cmake --version

cmake version 4.4.4

CMake suite maintained and supported by Kitware (kitware.com/cmake).

After adjusting PATH, compare with the system default:

command -v cmake

Compare every candidate binary the shell knows about:

type -a cmake

If command -v still shows /usr/bin/cmake while you intended to use /opt, your PATH order needs another look—not a failed install.

Optional: Install CMake with Snap

The cmake Snap is published by Canonical and maintained separately from the upstream CMake project. Install it when you want a current upstream build without adding Kitware apt or unpacking binaries yourself:

sudo snap install cmake --classic

--classic gives the Snap broader filesystem access than a strictly confined Snap, which a build tool needs to work with arbitrary source and build directories.

Check the Snap's view of the version:

snap run cmake --version

Snap places cmake under /snap/bin. If both apt and Snap are installed, type -a cmake may list /snap/bin/cmake before or after /usr/bin/cmake depending on /etc/environment and your shell profile.

Optional: Build CMake from source

Compiling CMake is rarely the fastest way to get the latest stable release—Kitware apt and official binaries cover that case. Source still matters for custom patches, unsupported platforms, or pre-release trees.

Install toolchain dependencies:

sudo apt update

Pull in a compiler and OpenSSL headers for the bootstrap step:

sudo apt install build-essential libssl-dev

Download and build (example 4.4.4):

cd /tmp

Fetch the source archive from GitHub releases:

wget https://github.com/Kitware/CMake/releases/download/v4.4.4/cmake-4.4.4.tar.gz

Extract the tarball:

tar -xzf cmake-4.4.4.tar.gz

Move into the source tree:

cd cmake-4.4.4

Configure the build with your install prefix:

./bootstrap --prefix=/opt/cmake-4.4.4-src

Compile CMake itself (this step takes several minutes):

make -j"$(nproc)"

-j"$(nproc)" lets the build use all CPU cores; lower the number if you need to cap load on a shared machine.

Install as root into the chosen prefix:

sudo make install

Add /opt/cmake-4.4.4-src/bin to PATH the same way as the official binary section. To remove a source install, delete that prefix directory—or use install_manifest.txt from the build tree if you need an exact file list.

Optional: Install CMake GUI tools

Ubuntu ships optional front ends alongside the cmake package:

Qt GUI (cmake-gui):

sudo apt install cmake-qt-gui

Terminal curses UI (ccmake):

sudo apt install cmake-curses-gui

Official binary trees under /opt also include cmake-gui and ccmake in the same bin directory as the CLI.

Test CMake with a minimal C++ project

CMake configures projects out of source: -S . points at the directory that contains CMakeLists.txt, and -B build puts generated files in a separate build/ folder. The test below needs a C++ compiler—install build-essential if g++ is missing.

Configure an out-of-source build

Create a tiny project under /tmp:

mkdir -p /tmp/cmake-hello

Use that directory for the source and build trees:

cd /tmp/cmake-hello

Write CMakeLists.txt with a floor that matches Ubuntu 22.04's apt CMake (3.22):

cat > CMakeLists.txt <<'EOF'
cmake_minimum_required(VERSION 3.22)
project(hello LANGUAGES CXX)
add_executable(hello main.cpp)
EOF

Add a valid C++ source file:

cat > main.cpp <<'EOF'
#include <iostream>
int main() {
    std::cout << "CMake build OK\n";
    return 0;
}
EOF

Generate build files in build/. CMake picks a generator (for example Unix Makefiles or Ninja) that tells Make or Ninja how to compile the project:

cmake -S . -B build

CMake should finish with Generating done and no errors about the minimum version.

Build and run the program

Compile the target:

cmake --build build

Run the binary:

./build/hello

CMake build OK

If configure fails with a version error, compare cmake --version against cmake_minimum_required in the project you are building—not only this hello-world stub.

Update CMake

Ubuntu apt: run sudo apt update and sudo apt install --only-upgrade cmake when a security or point release lands in the archive.

Kitware apt: with kitware.list enabled, the same sudo apt install --only-upgrade cmake pulls newer Kitware builds when they publish.

Snap: sudo snap refresh cmake.

Manual /opt binary: download a newer .sh, install to a new prefix (for example /opt/cmake-4.5.0), update your PATH line, and remove the old prefix when you no longer need it.

Uninstall CMake

Ubuntu packages: remove only what you installed. If you added the CLI plus both optional GUI packages, for example:

sudo apt purge cmake cmake-qt-gui cmake-curses-gui

Preview suggested removals:

sudo apt-get -s autoremove

Run sudo apt autoremove only after you agree with the simulated list.

Kitware apt: remove /etc/apt/sources.list.d/kitware.list, run sudo apt update, and check apt-cache policy cmake. APT does not downgrade a newer Kitware cmake automatically—use the explicit downgrade or purge-and-reinstall steps in the Kitware section above if you want Ubuntu's archive build back.

Snap:

sudo snap remove cmake

Official or source tree under /opt: remove only the prefix you created—for example sudo rm -rf /opt/cmake-4.4.4—and delete any PATH lines you added in ~/.bashrc. Avoid broad sudo rm -rf /usr/local/share/cmake-* unless you are certain no other software shares that layout.

For general package cleanup patterns, see remove software on Ubuntu.

Troubleshooting

Summary

Install CMake on Ubuntu with sudo apt install cmake whenever the version in apt-cache policy cmake meets your project's cmake_minimum_required line. Ubuntu 26.04 already provides CMake 4.2.x in main; 24.04 and 22.04 remain on 3.28.x and 3.22.x, so newer upstream trees may push you toward Kitware's apt repository or an official binary.

When apt is too old but you still want package management, add Kitware's signed repository for your codename (resolute, noble, or jammy), install kitware-archive-keyring, then upgrade cmake—the test host moved from 4.2.3 to 4.4.4 that way. If you need one specific version separate from Ubuntu's package, unpack the linux-x86_64 or linux-aarch64 .sh installer under /opt/cmake-VERSION and put that bin directory on PATH.

After any method, run command -v cmake, type -a cmake, and cmake --version, then configure a minimal out-of-source C++ project with cmake -S . -B build. Keeping apt, Snap, /usr/local, and /opt installs straight on PATH prevents the common case where a newer install is on disk but the shell still runs an older /usr/bin/cmake.

References

• Installing CMake — official overview
• CMake download — Linux .sh, .tar.gz, and source archives
• Kitware APT Repository — signed Ubuntu repositories
• cmake on Snapcraft — Snap distribution notes