CMake Mastery 2025: From Fundamentals to Expert Practices

Explore CMake as a cross-platform, open-source build system generator that creates platform-specific build files for Windows, Mac, and Linux.

CMake enables cross-platform, portable code across Windows, Mac, and Linux, supports Make, Ninja, and MSBuild, and streamlines large project management with IDE integration for efficient incremental builds.

CMake expects a source file and a cmakelists.txt; provide these, and it performs configuration, generation, and the build stage to create executables or libraries.

Discover how to write a minimal cmake project with a CMakeLists.txt, including cmake minimum required version 3.25 and a hello message, while exploring configuration, generation, and build stages.

install and uninstall cmake across macOS, Windows, and Linux, download the 3.30 release from cmake.org, validate with cmake --version, and update your path.

Understand the possible outputs of a C or C++ program, including executables and dynamic or static libraries, with cross-platform naming and cmake guidance for r_executable and r_library.

Learn how to generate a binary executable with CMake by creating a first CMake program, setting the minimum CMake version to 3.30, and building from mod one.cpp.

Demonstrates creating a simple c++ program in macOS with Visual Studio Code, writing mod one.cpp using iostream and cmath, and configuring cmakelists.txt to build an executable.

Navigate the three CMake stages—configure, generation, and build—by configuring and generating build files, then building with CMake --build in a dedicated build directory to run the executable across platforms.

Explore configuration, generation, and build workflows in cmake, including linking, makefiles, and the role of cmake files during error handling and executable creation.

Explore a high-level multi-module cmake plan to generate executables, static and dynamic libraries, and interface libraries across Windows, macOS, and Linux, with demos and on-demand tool installations.

Create a cross-platform static library with CMake by defining a library target and supplying src/module_two.cpp, then build to produce a .a archive on macOS, Windows, and Linux.

Master building and testing a static library with cmake by compiling test module two.cpp in the test folder, linking to the library via target_link_libraries, then configuring and building the executable.

Master library generation and use CMake by organizing headers in include and sources in source directory, applying header guards or pragma once, and configuring include paths to avoid missing files.

Configure CMake builds by specifying target include directories, exploring public, private, and interface scopes, resolving build errors, and demonstrating creation and use of a static library.

Explain the scope of CMake target link libraries, showing that public, private, and interface can be optional, and that the target include directory is mandatory. Preview dynamic library generation.

Learn to generate a static library in Linux with CMake: configure, build, and link a test library named lib<name>.a across Linux, Windows, Mac, and WSL.

In this Linux demo, learn to build a dynamic library with CMake, run a test executable, and address runtime shared library loading issues, with Windows demo to follow.

Learn how interface library in CMake defines usage requirements for dependents without compiling or producing artifacts, guiding include directories, compile definitions, and link libraries for module five.

Create and test a header-only interface library by writing a main.cpp, call sum and diff, configure CMake to build an executable, and link the library with target_link_libraries.

Move the header-only library into its own space and call its cmake list from the root via a subdirectory, correcting the include path to header-only lib/include and building an executable.

Master cmake project structure by placing library and tests in separate folders, including a test folder, setting minimum version 3.30, and using add_subdirectory to build a header-only interface library.

Explore target scopes in a cmake demo by building a single library target A in a lib subdirectory, configured in root cmake and built to produce liba.a as static library.

Explore how CMake handles target include directories and interface include directories, clarifying public versus private scopes and how consumers access headers during configure, generation, and build.

Explore how target link libraries and their private, public, and interface relationships affect linking, along with target include directories and get and set target properties in CMake.

Learn to inspect cmake target properties to diagnose build issues, and write user defined functions that print a target's properties, while understanding the difference between cmake functions and macros.

Review the plan for module five, detailing binary creation by integrating the static, dynamic, and interface libraries across modules two, three, and four, with a Visual Studio Code demonstration.

Demonstrate building a multi-module cmake project on linux using wsl, with module five and project one completed, using updated git sources and a cross-platform workflow from macos to linux.

Show how to configure and build a Linux project with CMake, clean the Linux build directory, reconfigure, rebuild, and verify the modify binary runs as expected.

Learn to set up GitHub Actions for cross-platform builds (macOS, Ubuntu, Windows) with CMake, resolve clang vs gcc issues, and validate multi-platform workflows.

optimize a cross-platform CMake workflow in GitHub Actions by removing explicit compilers, relying on the runner's default toolchain (gcc/clang/MSVC) across Ubuntu, Windows, and macOS, and maintain release builds.

Configure GitHub actions by disabling auto triggers, edit workflow lines, and implement a workflow dispatch with inputs to selectively build on Ubuntu, Windows, or Mac runners.

Explore defining a sum function in CMake to add two numbers using the math command, avoid string concatenation, and print accurate results with proper expression handling.

Discover how to replace multiple CMake commands with a single target executable, and learn to write reusable functions to simplify argument passing and library management.

Trace the build flow from preprocessor to compiler to assembler to linker to loader. Produce sample.i or sample.ii, sample.s, and sample.o from sample.c or sample.cpp, culminating in the executable.

Learn to solve the birthday chocolate subarray problem using a sliding window to count contiguous segments of length m with sum d.