An introduction to the build pipeline, and how we can orchestrate it manually

Before working with CMake, it's useful to understand the tools it orchestrates. This lesson guides you through setting up a C++ toolchain.

Building C++ Programs

Walking through the steps of the C++ compilation process, from source code to machine code.

The Compilation Pipeline

The linker's role in the build process, how it resolves symbols to combine object files, and how to troubleshoot common errors.

Object Files and the Linking Process

The difference between static and dynamic libraries, how to create them, and the trade-offs between them.

Static and Shared Libraries

The C++ Build Process

Recommended approaches for managing large projects and the libraries that they depend on

Learn how to structure your C++ projects for scalability and maintainability, from basic directory layouts to managing multiple modules.

Organizing a C++ Project

Learn to manage third-party libraries in C++, covering include/library paths, static vs. shared libraries, versioning, and platform differences.

Managing Libraries and Dependencies

An introduction to traditional build tools like Makefiles and IDE projects, highlighting the maintenance, scalability, and cross-platform challenges that result

Automated Build Systems and Their Limitations

Project Structure and Dependency Management

Setting up CMake and creating your first project

An introduction to CMake, the cross-platform, open-source meta-build system that solves the core challenges of C++ project management.

Why CMake?

A step-by-step guide to installing CMake. We'll explore command-line, GUI, and IDE workflows, and how to configure your compiler.

Setting Up a CMake Environment

Creating the bare minimum `CMakeLists.txt` file and build up to a project with an executable and a library, learning the fundamental commands along the way.

Writing a CMakeLists File

Learn the two-stage process of building a CMake project. This lesson covers configuring, generating, building, running, and troubleshooting common errors.

Building and Running CMake Projects

Learn how to organize large C++ projects in CMake using subdirectories and the `add_subdirectory()` command to create modular, maintainable builds.

CMake Project Structure and Subdirectories

Introducing CMake

Exploring CMake's programming features, caching mechanisms, and interactions with the file system

A primer on the fundamental building blocks of the CMake language: variables, string interpolation, and logging messages.

CMake Variables and Logging

Discover the CMake Cache, the mechanism for storing persistent user-configurable options, and learn how to create and manage cached variables.

The CMake Cache

Exploring CMake's command syntax and its list data type, including how to create, manipulate, and use lists in your projects.

CMake Commands, Arguments, and Lists

Transform your static build descriptions into dynamic scripts with CMake's control flow commands, if() and foreach().

CMake Conditionals and Loops

Exploring CMake's `file()` command, covering how to read, write, copy, and glob files, and how to manipulate paths.

Working with the File System

Learn to create reusable logic with CMake functions and macros, and how to organize them into modules for clean, scalable build systems.

Modularizing CMake Code

CMake Language and Fundamentals

Learn more about targets, and how their properties and links are the foundation of modern CMake

Learn to work with target properties - understanding their purpose, setting and updating them, and retrieving them when your build requires it

Target Properties

Learn about target types, and how the `PUBLIC`, `PRIVATE`, and `INTERFACE` keywords control how properties are shared.

Relationships Between Targets

Discover how CMake's `target_link_libraries()` command builds a dependency graph, and how it uses this graph to automatically manage transitive dependencies and link order.

Indirect Relationships and the Dependency Graph

Learn to use abstract target types like `INTERFACE`, `ALIAS`, and `IMPORTED` to model complex project needs, organize build properties, and integrate pre-compiled binaries.

Using `INTERFACE`, `ALIAS`, and `IMPORTED` Libraries

Adding support for user-configurable library types and an initial introduction to target installation.

Using Shared Libraries

Targets and Dependencies

Learn how to manage multiple build configurations within the same project, and how to create scripts that adapt to the environment

Learn how CMake manages different build configurations like Debug and Release, the difference between generator types, and how to apply settings conditionally using modern techniques.

Build Configurations (Debug, Release, etc.)

Learn the tools and patterns needed to write portable CMakeLists.txt files that work seamlessly across platforms and compilers

Cross-Platform Configurations

Learn to write architecture-aware CMake scripts for 32/64-bit systems and Apple's Universal Binaries (Intel/ARM).

Handling Different Architectures

Learn to build for different operating systems and architectures using CMake's cross-compilation support and toolchain files.

Cross-Compilation and Toolchain Files

Platforms and Build Configurations

Learn how to add external libraries to our build, and how to create our own packages for others to use

Learn to find and use pre-installed libraries with `find_package()`, understanding Module vs. Config mode and the power of imported targets

Finding Dependencies using `find_package()`

Learn how to make your libraries consumable by other projects using CMake by turning your build-tree into a distributable install-tree.

Creating a Consumable Package

Learn how to consume a CMake package you've installed, completing the producer-consumer cycle. We'll cover using `find_package()` and how to point CMake to your library's location

Using Installed Packages

Learn how to create self-contained, reproducible builds by fetching dependencies from source using `FetchContent()` and `ExternalProject_Add()`.

Fetching External Dependencies

Creating and Consuming Packages

Integrating the vcpkg and Conan package managers to handle external dependencies

Learn to manage C++ dependencies effortlessly with the vcpkg package manager and its seamless CMake integration using toolchain files and manifests.

Integrating CMake and vcpkg

Learn the day-to-day commands for managing dependencies with vcpkg and how to guarantee reproducible builds using baselines and version overrides

vcpkg Commands and Versioning

Combine vcpkg with CMake's cross-compilation capabilities. Learn to use triplets to target different architectures and chain-load toolchain files

Cross-Compiling with vcpkg

Discover Conan, the binary-first C++ package manager, and learn how to integrate it with CMake using profiles and lockfiles for fast, reproducible builds.

Using Conan with CMake

Learn to cross-compile C++ projects with Conan, using build and host profiles to manage dependencies for different platforms.

Cross-Compilation with Conan

Package Managers

Introducing presets, allowing us to simplify our workflow and share common configurations across our team

Learn the fundamentals of CMake Presets. This lesson introduces `CMakePresets.json` to simplify complex build commands.

CMake Presets

Learn to structure your CMake presets with inheritance and customize them for your local environment using `CMakeUserPresets.json`.

User Presets and Inheritance

Learn to make your CMake presets portable by using environment variables and conditional logic to adapt to different machine configurations.

Environment Variables and Conditional Presets

Learn how to extend the build process beyond simple compilation by integrating external tools and custom commands

Learn how to use generator expressions `$<...>` for build-time conditional logic.

Generator Expressions and Conditional Logic

Learn how to attach commands to specific points in a target's build lifecycle using `add_custom_command(TARGET)` for tasks like post-build file copying.

Integrating Tools with `add_custom_command()`

Learn to integrate code generators like Protobuf into your build process using `add_custom_command()`, creating automated file-level dependencies in CMake.

Generating Files with Protobuf and `add_custom_command()`

Custom Commands

An introduction to automating common workflow chores by creating custom targets

Learn to create standalone, non-code targets using add_custom_target() for utility tasks like code formatting and documentation generation.

Custom Targets and Build Utilities

Using the Clang-Format tool to automatically enforce a consistent coding style, and integrating it into our build using a custom CMake target

Using Clang-Format

An introduction to file sets and the `target_sources()` command, allowing us to manage our header files in a more controlled way

Using File Sets

A step-by-step guide to integrating Doxygen into your CMake build process for automated C++ documentation.

Generating Documentation with Doxygen

Custom Targets

Integrate automated tests into a CMake project using CTest, GoogleTest, and GoogleMock

Learn the fundamentals of automated testing in C++ with CTest. Create your first test suite, register tests with `add_test()`, and run them with the `ctest` command.

Automated Testing and CTest

Learn to refactor manual C++ tests into a professional test suite using the GoogleTest framework, managed by vcpkg and integrated with CTest.

Integrating GoogleTest with CMake

Learn to use a wide range of assertions, write data-driven parameterized tests, and isolate dependencies with Google Mock.

Assertions and Parameterized Tests

Learn how to isolate dependencies that our project uses, and then how to replace those dependencies at test time using Google Mock.

Dependency Injection and Mocking

Learn the standard pattern for testing application logic by refactoring it into a linkable library

Testing Executables

Move beyond individual tests to manage a full test suite. Learn to organize tests, run tests in parallel, filter by labels, and measure our code coverage

Managing a Test Suite

Automated Testing

Using static and dynamic analysis in CMake projects to automatically detect memory bugs, performance issues, and problematic code

Learn to find memory bugs at runtime by integrating AddressSanitizer (ASan) into a CMake project

Using AddressSanitizer (ASan)

Adding benchmarks to our build to measure the performance of our code, and track how it changes over time

Using Google Benchmark

Integrating Clang-Tidy to enforce good practices and find bugs before we even compile

Using Clang-Tidy

Automated Analysis

Automating the entire development lifecycle using Git for souce control, GitHub Actions for cloud builds, and CPack to create distributable packages and installers.

An introduction to Git, the version control system that underpins modern collaborative software development and automated build pipelines.

Source Control with Git

Learn how to automate your build and test process with Continuous Integration (CI) and a build server. This lesson provides a guide to creating a GitHub Actions workflow for a CMake project.

Build Servers and Continuous Integration

Learn to package your C++ projects using CMake's CPack. This lesson covers creating developer ZIP archives and professional Windows MSI installers with components.

Packaging with CPack

Learn to automate the packaging process by integrating CPack with a multi-platform GitHub Actions workflow

Packaging with GitHub Actions

Learn to automate the creation of a professional Windows installer by integrating CPack, the WiX Toolset, and a multi-platform GitHub Actions workflow.

Creating Installers with CPack and GitHub Actions

Learn to automate the release process using a GitHub Actions workflow that builds, packages, and publishes artifacts to a GitHub Release

Deployment with GitHub Releases

Continuous Integration and Packaging

If you have a basic grasp of C++ but find the build process intimidating, this course is for you. We assume you know the language, but not how to manage large projects.

Manage complex, cross-platform builds using industry-standard tools. Create scalable build systems that automate the entire development lifecycle.

This course is a comprehensive deep-dive into the entire C++ build ecosystem, centered around the power and flexibility of modern CMake. We leave no stone unturned.

Start with a foundational understanding of compilers, linkers, static vs. shared libraries, and object files.

The Full Build Pipeline

Learn every aspect of the CMake language, from variables and control flow to functions, modules, and generator expressions.

Complete CMake Language Mastery

Master the modern target-centric paradigm, including properties, usage requirements, and abstract targets.

Advanced Target Management

Explore every method for handling dependencies, from `find_package` and `FetchContent` to vcpkg and Conan, including versioning and cross-compilation.

In-Depth Dependency Management

Integrate a full suite of professional tools for testing (CTest, GoogleTest), analysis (ASan, Clang-Tidy), and packaging (CPack).

Total Workflow Automation

Build a fully automated deployment pipeline that takes your code from a Git push to a published GitHub Release with multi-platform installers.

End-to-End CI/CD and Deployment

What You'll Learn

Become a software engineer with C++.  Starting from the basics, we guide you step by step along the way

Intro to C++ Programming

If you're completely new to programming or want a thorough introduction, consider starting with our free introductory course:

New to Programming?

Managing C++ Projects Using CMake

In the last two lessons, we've explored two ways of handling dependencies: finding them on the system with `find_package()` and fetching them from source with `FetchContent()`. Both are powerful, but they represent a trade-off: `find_package()` is fast but relies on external state, while `FetchContent()` is reproducible but can be slow to configure and build.


What if we could have the best of both worlds? What if a tool could automatically download, build, and install libraries for us, and then make them available to a clean, simple `find_package()` call?


This is the role of a C++ package manager. For years, the lack of a standard, cross-platform package manager was a major pain point in the C++ ecosystem, especially when compared to languages like Python (`pip`) or Rust (`cargo`). Today, that has changed.


This lesson introduces **vcpkg**, a free, open-source package manager from Microsoft that has become an industry standard. We'll learn how to use its modern, manifest-based workflow to declare dependencies and integrate them seamlessly into our CMake project.


## Why Use a Package Manager?


Let's review the benefits and problems with asking consumers to preinstall packages to support `find_package()`, and with fetching them on every clean build using `FetchContent()` or similar techniques:


| Feature             | `find_package()` (System Libs)                                          | `FetchContent()` (Fetched Source)                                   |
| ------------------- | ----------------------------------------------------------------------- | ------------------------------------------------------------------- |
| **Build Speed**     | **Fast**. Uses pre-compiled binaries.                                   | **Slow**. Must compile dependency from source on every clean build. |
| **Reproducibility** | **Low**. Depends on whatever version the user has installed.            | **High**. Fetches a specific Git tag or commit.                     |
| **User Setup**      | **High Effort**. User must manually install all dependencies correctly. | **Low Effort**. Just needs Git and a compiler.                      |


A package manager like vcpkg improves our workflow and project in several ways:

- **Centralized Declaration:** All direct dependencies are listed in a single "manifest" file stored in the project root, making it easy to see what your project needs at a glance.
- **Decoupled from the Build System:** Dependencies are managed by the vcpkg tool itself based on this manifest file. This keeps your `CMakeLists.txt` files cleaner and focused on their core job: defining how to build **your** code, not how to acquire and build third-party code.
- **Standardized and Discoverable Packages:** With `FetchContent()` you need to find the Git repository URL and a specific tag for every dependency. vcpkg provides a central, curated registry of thousands of libraries. You can easily search for and add packages by a single, standardized name.

## Installing vcpkg


Before we can use vcpkg, we need to install it. The process involves cloning its Git repository and running a one-time bootstrap script.


Note that we should **not** run the following commands in our usual `./build` directory.  We want to install vcpkg into a permanant location on our system so it can be used across multiple projects.


We're free to choose whatever location we want.  As a reminder, we can move our terminal to the installation location we want to use via the `cd` command.


For example, if we were on Windows and wanted to install vcpkg in `c:\tools`, we'd first use the command:


```c++
//<ti>
cd c:\tools
```


On macOS and Linux, a typical location might be `~/vcpkg` or `~/dev/vcpkg`


```c++
//<ti>
cd ~
```


You should make a note of the installation directory you use here, as we'll need it later.


### Installation on Linux (Debian/Ubuntu)


First, ensure you have the necessary prerequisites installed using your distribution's package manager. For Debian-based systems like Ubuntu, this would be:


```c++
//<ti>
sudo apt update
```


```c++
//<ti>
sudo apt install git-all
```


Next, clone the vcpkg repository, and then `cd` into the directory that this creates:


```c++
//<ti>
git clone https://github.com/microsoft/vcpkg.git
```


```c++
//<ti>
cd vcpkg
```


Finally, run the bootstrap script. This will compile the vcpkg tool itself.


```c++
//<ti>
./bootstrap-vcpkg.sh
```


### Installation on macOS


On modern macOS releases, you can simply try to use `git` from the terminal:


```c++
//<ti>
git --version
```


If it's not already installed, this command will guide you through the process.  Alternatively, using Homebrew:


```c++
//<ti>
brew install git
```


Next, clone the vcpkg repository to a location of your choice:


```c++
//<ti>
git clone https://github.com/microsoft/vcpkg.git
```


```c++
//<o>
Cloning into 'vcpkg'...
Updating files: 100%, done
```


Finally, `cd` into the `vcpkg` directory this creates and run the bootstrap script to build the vcpkg executable:


```c++
//<ti>
cd vcpkg
```


```c++
//<ti>
./bootstrap-vcpkg.sh
```


### Installation on Windows (Visual Studio)


On Windows, we open the **Developer Command Prompt for Visual Studio** and clone the repository:


```c++
//<ti>
git clone https://github.com/microsoft/vcpkg.git
```


We then `cd` into the directory that this creates:


```c++
//<ti>
cd vcpkg
```


And finally run the `bootstrap-vcpkg.bat` file that vcpkg includes to complete the setup:


```c++
//<ti>
./bootstrap-vcpkg.bat
```


### Installation for MSYS2 UCRT64


If you are using the MSYS2 UCRT64 terminal, you first need to install the prerequisites using `pacman`.


```c++
//<ti>
pacman -S --needed git mingw-w64-ucrt-x86_64-toolchain
```


Then, from the UCRT64 terminal, clone and bootstrap vcpkg:


```c++
//<ti>
git clone https://github.com/microsoft/vcpkg.git
```


```c++
//<ti>
cd vcpkg
```


```c++
//<ti>
./bootstrap-vcpkg.sh
```


When using MSYS2, we may also need to set the `VCPKG_TARGET_TRIPLET` cache variable to help vcpkg understand our environment.  We can set this to `x64-mingw-static` on the command line as part of the configure step on every clean build:


```c++
cmake .. -DVCPKG_TARGET_TRIPLET="x64-mingw-static"
```


Alternatively, we can hardcode it into our `CMakeLists.txt` file **before** the `project()` command:


<CodeFile path="CMakeLists.txt">


```c++
#<cmake>
cmake_minimum_required(VERSION 3.16)

# This should be BEFORE project()
set(#<h>
  VCPKG_TARGET_TRIPLET "x64-mingw-static"#<h>
  CACHE STRING "The vcpkg triplet to use"#<h>
)#<h>

project(Greeter)

add_subdirectory(greeter)
add_subdirectory(app)
```


</CodeFile>


Later in the course, we introduce **CMake presets**, which give us a better way to manage configuration such as this.


<Pw>


## Integrating with CMake


Now that vcpkg is installed, we'll go back to running commands from our project's `/build` directory as before:


```c++
cd /path/to/project/build
```


How does CMake know to use vcpkg?  You tell it by setting the `CMAKE_TOOLCHAIN_FILE` variable during the configure step.  We've already seen this variable - it is what we used to "rewire" CMake to make it use a cross-compiler.


In this lesson, we use this same technique to rewire CMake to use vcpkg.


To do this, we set our `CMAKE_TOOLCHAIN_FILE` variable to point to a `/scripts/buildsystems/vcpkg.cmake` that vcpkg provides within the directory we installed it to.


We'll walk through a practical example soon, but the configure command we use would look something like this:


```c++
//<ti>
cmake .. -DCMAKE_TOOLCHAIN_FILE="~/vcpkg/scripts/buildsystems/vcpkg.cmake"
```


This single setting is all it takes to activate vcpkg for your project.  Most notably, it empowers `find_package()` commands in our `CMakeLists.txt` files to let them find dependencies managed by vcpkg:


<Img hasTransparency invertible file="vcpkg-cmake-file.png" alt="Diagram showing the vcpkg-CMake integration" width="1400" height="497" blurHash="LAE:0n_3?b~q009F4nD%D%RjM{WB" />


Remember, this value gets cached in our build folder, so we only need to set it on our first configure.  However, if we perform a clean build by deleting the contents of our build folder, we'll need to reapply this variable.


Alternatively, we can set it from our `CMakeLists.txt` file, removing the need to set it on the command line:


<CodeFile path="CMakeLists.txt">


```c++
#<cmake>
cmake_minimum_required(VERSION 3.16)

set(#<h>
  CMAKE_TOOLCHAIN_FILE "~/vcpkg/scripts/buildsystems/vcpkg.cmake"#<h>
  CACHE STRING "The toolchain file"#<h>
)#<h>

project(Greeter)

add_subdirectory(greeter)
add_subdirectory(app)
```


</CodeFile>


Later in the course, we introduce **presets**, which improves the developer experience of applying commonly-used cache variables.


## Declaring Dependencies with `vcpkg.json`


With vcpkg installed, we can now declare our project's dependencies. The modern way to do this is with a manifest file named `vcpkg.json`, placed at the root of your project. This file is the single source of truth for all your project's external libraries.


Let's create one for our `Greeter` project and add `spdlog` as a dependency.  The syntax looks like this:


<CodeFile path="vcpkg.json" status="New">


```c++
{
  "dependencies": [
    "spdlog"
  ]
}
```


</CodeFile>


One of the benefits of package managers is that they maintain a **registry** of common packages.  Previously, we had to tell CMake exactly where spdlog was.  We did that by providing a URL to its git repository.


vcpkg already knows about spdlog and, at the time of writing, [around 2,600 other packages](https://vcpkg.io/en/packages?query=).  To use one of those packages, we just need to reference it by name.


We typically add some additional metadata to our `vcpkg.json`, such as our project's name, version, and description:


<CodeFile path="vcpkg.json" status="New">


```json
{
  "name": "Greeter",
  "version": "1.0.0",
  "license": "MIT",
  "description": "An impressive program that says hello to people",
  "homepage": "https://www.studyplan.dev",
  "dependencies": [
    "spdlog"
  ]
}
```


</CodeFile>


## Using Packages


Using a dependency that came from vcpkg looks identical to using any other external dependency.  We find it using `find_package()` and link it in the normal way.


We'll update our `app/CMakeLists.txt` to find and link spdlog:


<CodeFile path="app/CMakeLists.txt">


```c++
#<cmake>
cmake_minimum_required(VERSION 3.16)

add_executable(GreeterApp src/main.cpp)

find_package(spdlog CONFIG REQUIRED) #<h>

target_link_libraries(GreeterApp
  GreeterLib
  spdlog::spdlog#<h>
)
```


</CodeFile>


And we'll ensure our `app/src/main.cpp` is using the library:


<CodeFile path="app/src/main.cpp">


```c++
#include <greeter/Greeter.h>
#include <spdlog/spdlog.h> //<h>

int main() {
  spdlog::info(get_greeting()); //<h>
  return 0;
}
```


</CodeFile>


Now, let's configure our project from the `build` directory.  We should do this from a **clean** build directory.


Remember to update the `-DCMAKE_TOOLCHAIN_FILE` argument in the following example, replacing `~/vcpkg` with the location that you installed vcpkg in:


```c++
//<ti>
cmake .. -DCMAKE_TOOLCHAIN_FILE="~/vcpkg/scripts/buildsystems/vcpkg.cmake"
```


When you run this, you'll see vcpkg spring into action. It will read your `vcpkg.json`, notice that `spdlog` is required but not yet installed for your platform, and automatically download, build, and install it.


The output will also share what targets have become available to link against.  In this case, it's `spdlog::spdlog`, which we're already using:


```c++
//<o>
Installing spdlog...
Elapsed time to handle spdlog: 21.4 ms
Packages installed in this vcpkg installation declare the following licenses:
MIT
The package spdlog provides CMake targets:

    find_package(spdlog CONFIG REQUIRED)
    target_link_libraries(main PRIVATE spdlog::spdlog)

All requested installations completed successfully in: 71.7 ms
```


If the configure step completed successfully, we should build and run our program in the usual way to ensure everything works:


```c++
//<ti>
cmake --build .
```


```c++
//<ti>
./app/GreeterApp
```


```c++
//<ti>
[2025-08-14 14:03:19.423] [info] Hello from the modular greeter library!
```


## Summary


This lesson introduced vcpkg, a modern C++ package manager that streamlines dependency management by combining the speed of pre-compiled binaries with the reproducibility of declarative manifests.

- **Why a Package Manager?**: It solves the trade-off between `find_package()` (fast but requires manual user setup) and `FetchContent()` (reproducible but slow to build from source).
- **Installation**: We learned how to install vcpkg by cloning its repository and running the one-time bootstrap script.
- **Manifest Mode**: Modern vcpkg uses a `vcpkg.json` file in your project's root to declare all dependencies in one place.
- **CMake Integration**: Activating vcpkg is as simple as pointing the `CMAKE_TOOLCHAIN_FILE` variable to `vcpkg.cmake` during the initial configure step. This hijacks `find_package()` and directs it to the libraries managed by vcpkg.

<Preview>


### vcpkg Commands and Versioning


We've seen how vcpkg can automatically install dependencies declared in our manifest. But vcpkg is more than just an automated installer; it's a full-featured command-line tool.


In the next lesson, we'll learn more about the vcpkg executable itself. We'll learn how to search for available packages, manage versions with baselines to ensure reproducible builds, and use overrides for fine-grained control over our dependency tree.


</Preview>


</Pw>

Vendoring and Fetching Dependencies

Package Managers Integration (Conan)

vcpkg Homepage

vcpkg: A C++ package manager for Windows, Linux, and macOS

Manifest mode

CMake Toolchains

vcpkg: The C++ Library Manager for Everyone - Robert Schumacher & Augustin Popa

vcpkg GitHub Repository

A complete guide to using vcpkg with CMake. Learn how to install vcpkg, use manifest files (vcpkg.json) for reproducible builds, and integrate it seamlessly into your project with a CMAKE_TOOLCHAIN_FILE.

Integrating CMake and vcpkg

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Managing C++ Projects Using CMake