Which C++ build system should I use?

Existing project?
  → Use what's already there. Migration cost is almost never worth it.

New project:
  Needs Windows + Visual Studio / CLion / VS Code IDE support?
    → CMake  (universal lingua franca)

  Linux/macOS only, new codebase, care about clean syntax?
    → Meson  (faster config, readable DSL, good defaults)

  Large monorepo, hermetic builds, distributed caching?
    → Bazel or Buck2

  Want build + packages in one tool, minimal config?
    → xmake

  Embedded / bare-metal cross-compilation?
    → CMake with a toolchain file

cmake_minimum_required(VERSION 3.20)
project(myapp VERSION 1.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

add_executable(myapp
    src/main.cpp
    src/app.cpp
)

target_include_directories(myapp PRIVATE include)
target_compile_options(myapp PRIVATE
    $<$<CXX_COMPILER_ID:GNU,Clang>:-Wall -Wextra -Wpedantic>
    $<$<CXX_COMPILER_ID:MSVC>:/W4>
)

add_library(mylib STATIC
    src/widget.cpp
    src/parser.cpp
)

# PUBLIC: consumers of mylib get this include path too
target_include_directories(mylib
    PUBLIC  include          # consumers see include/
    PRIVATE src              # only mylib sees src/
)

# Link against another library — PUBLIC means consumers also link it
target_link_libraries(mylib PUBLIC fmt::fmt)
target_link_libraries(mylib PRIVATE spdlog::spdlog)

# Configure (generate build files):
cmake -B build -DCMAKE_BUILD_TYPE=Release

# Build:
cmake --build build -j$(nproc)

# Install:
cmake --install build --prefix /usr/local

# Run tests:
ctest --test-dir build --output-on-failure

# Presets (modern, replaces command-line flags):
# CMakePresets.json defines "debug", "release", "ci" etc.
cmake --preset release
cmake --build --preset release

include(FetchContent)

FetchContent_Declare(fmt
    GIT_REPOSITORY https://github.com/fmtlib/fmt.git
    GIT_TAG        10.2.1
)
FetchContent_Declare(googletest
    GIT_REPOSITORY https://github.com/google/googletest.git
    GIT_TAG        v1.14.0
)
FetchContent_MakeAvailable(fmt googletest)

target_link_libraries(myapp PRIVATE fmt::fmt)
target_link_libraries(tests PRIVATE GTest::gtest_main)

# Install vcpkg (one-time):
git clone https://github.com/microsoft/vcpkg.git
./vcpkg/bootstrap-vcpkg.sh

# Manifest mode (recommended): vcpkg.json in project root

{
  "name": "myapp",
  "version": "1.0.0",
  "dependencies": [
    "fmt",
    "boost-algorithm",
    { "name": "opencv", "version>=": "4.8.0" }
  ]
}

# CMakeLists.txt — vcpkg packages become CMake targets:
find_package(fmt CONFIG REQUIRED)
find_package(OpenCV REQUIRED)

target_link_libraries(myapp PRIVATE fmt::fmt ${OpenCV_LIBS})

# Build with vcpkg toolchain:
cmake -B build -DCMAKE_TOOLCHAIN_FILE=vcpkg/scripts/buildsystems/vcpkg.cmake
cmake --build build

- uses: lukka/run-cmake@v10
  with:
    cmakeListsTxtPath: CMakeLists.txt
    configurePreset: release
    buildPreset: release

# conanfile.txt
[requires]
fmt/10.2.1
boost/1.83.0

[generators]
CMakeDeps
CMakeToolchain

# Generate CMake integration files:
conan install . --output-folder=build --build=missing

# Configure with Conan's toolchain:
cmake -B build -DCMAKE_TOOLCHAIN_FILE=build/conan_toolchain.cmake
cmake --build build

# meson.build
project('myapp', 'cpp',
  version: '1.0',
  default_options: ['cpp_std=c++23', 'warning_level=3'])

# Dependencies from system or wrap (Meson's package mechanism):
fmt_dep     = dependency('fmt')
threads_dep = dependency('threads')

mylib = static_library('mylib',
  sources: ['src/widget.cpp', 'src/parser.cpp'],
  include_directories: include_directories('include'),
  dependencies: [fmt_dep]
)

executable('myapp',
  sources: 'src/main.cpp',
  link_with: mylib,
  dependencies: [fmt_dep, threads_dep]
)

# subprojects/fmt.wrap
[wrap-git]
url = https://github.com/fmtlib/fmt.git
revision = 10.2.1
depth = 1

[provide]
fmt = fmt_dep

meson setup build
meson compile -C build
meson test -C build

# BUILD (Starlark)
cc_binary(
    name = "myapp",
    srcs = ["src/main.cpp"],
    deps = [
        ":mylib",
        "@fmt//:fmt",
    ],
    copts = ["-std=c++23"],
)

cc_library(
    name = "mylib",
    srcs = ["src/widget.cpp"],
    hdrs = ["include/widget.hpp"],
    includes = ["include"],
)

-- xmake.lua
set_project("myapp")
set_languages("c++23")

add_requires("fmt", "spdlog")

target("myapp")
    set_kind("binary")
    add_files("src/*.cpp")
    add_packages("fmt", "spdlog")
    add_includedirs("include")

xmake         # build
xmake run     # run
xmake test    # test

# buildfile
exe{myapp}: cxx{main} lib{mylib}
lib{mylib}: cxx{widget parser}

name: CI
on: [push, pull_request]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with: { submodules: recursive }

      - name: Install vcpkg
        uses: lukka/get-cmake@latest

      - name: Configure
        run: cmake -B build -DCMAKE_BUILD_TYPE=Release
             -DCMAKE_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake

      - name: Build
        run: cmake --build build -j$(nproc)

      - name: Test
        run: ctest --test-dir build -j$(nproc) --output-on-failure