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 few lessons, we've explored how to customize our build process with `add_custom_command()` and `add_custom_target()`. These tools let us integrate any external script or utility into our workflow, transforming our build system from a simple compiler-driver into a complete development automation engine.


This lesson provides a practical, real-world example of this concept: **automated code formatting**. Maintaining a consistent coding style across a project, especially with multiple developers, is crucial for readability and maintainability. Manually enforcing style rules is tedious and prone to arguments. A far better approach is to automate it.


We'll learn how to use **Clang-Format**, the industry-standard tool for C++ code formatting, and integrate it seamlessly into our project with a custom CMake target.


## Installing `clang-format`


The `clang-format` tool is part of the LLVM toolchain, which also includes the Clang compiler.  You may already have it installed - you can check by running the following command:


```c++
//<ti>
clang-format --version
```


If you see a version number, you're ready to go.  If not, we've provided some installation guides for various environments below.


### On Windows


The easiest way is to install the "LLVM tools" via the Visual Studio Installer.

1. Run the Visual Studio Installer and click "Modify" on your installation.
2. Go to the "Individual components" tab.
3. Search for "Clang" and select "C++ Clang Compiler for Windows".

Alternatively, you can install the full LLVM toolchain from its [official GitHub releases page](https://github.com/llvm/llvm-project/releases). During installation, make sure to select the option to "Add LLVM to the system PATH".


The `clang-format` tool should now be available from the Developer Command Prompt or PowerShell for VS.


### On MSYS2 UCRT64


From the UCRT64 terminal, you can install the MinGW version of the LLVM toolchain, which includes `clang-format`:


```c++
//<ti>
pacman -S mingw-w64-ucrt-x86_64-clang-tools-extra
```


### On macOS


The simplest way is with Homebrew:


```c++
//<ti>
brew install clang-format
```


If you've installed the full LLVM toolchain (`brew install llvm`), `clang-format` is included.


### On Linux (Debian/Ubuntu)


Use your distribution's package manager:


```c++
//<ti>
sudo apt install clang-format
```


### Confirming Installation was Successful


After installation, open a **new** terminal and verify it's working by running:


```c++
//<ti>
clang-format --version
```


## Creating a `.clang-format` File


The behavior of `clang-format` is controlled by a configuration file, by default named `.clang-format`, which you place in the root directory of your project.  This file is shared among the team, so that everyone conforms to a similar style.


When we run `clang-format`, it automatically finds and uses the configuration from this file.


The file uses the YAML format. A common practice is to start with one of the built-in base styles (like `LLVM`, `Google`, `Microsoft`, or `WebKit`) and then override the specific rules you want to change.


Let's create a simple `.clang-format` file in our `Greeter` project's root directory. We'll base our style on the `Google` standard but change the indent width to 2 spaces.


<CodeFile path=".clang-format" status="New">


```c++
# Inherit from the Google style guide
BasedOnStyle: Google
# Override the indent width
IndentWidth: 2
```


</CodeFile>


There are hundreds of options you can configure. The [official documentation](https://clang.llvm.org/docs/ClangFormatStyleOptions.html) is the definitive guide, and online tools like [clang-format configurator](https://clang-format-configurator.site/) can help you generate a configuration interactively.


## Using `clang-format` from the Command Line


Let's quickly see how the tool works. Let's make one of our source files messy by adding inconsistent spacing and indentation.


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


```c++
#include <iostream>

int main()
{ std::cout << "Hello world";
  return 0;
  }
```


</CodeFile>


From your project's root directory, you can run `clang-format` with the `-i` flag (for "in-place") to format a file:


```c++
//<ti>
clang-format -i app/src/main.cpp
```


If you now open `app/src/main.cpp`, you'll see that it has been magically reformatted to comply with the rules in your `.clang-format` file.


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


```c++
#include <iostream>

int main() {
  std::cout << "Hello world";
  return 0;
}
```


</CodeFile>


Running this command for every file is tedious. Let's automate it.


## Finding External Tools with `find_program()`


Before we can create a custom target that runs `clang-format`, our `CMakeLists.txt` needs a reliable way to find the `clang-format` executable on the developer's machine.


Hardcoding a path like `/usr/bin/clang-format` is not portable and will fail on most systems.


The standard CMake command for this task is `find_program()`. It searches for an executable in standard system locations and stores the full path in a variable if it's found.


### The `find_program()` Syntax


The basic syntax is straightforward:


```c++
#<cmake>
find_program(<variable> <program_name>)
```


In this example, `<variable>` will be the name of the variable where the result will be stored. By convention, this is often an all-caps name ending in `_EXE` or `_EXECUTABLE`.


`<program_name>` is the name of the executable to search for. CMake is smart about this; you can just provide `clang-format`, and it will automatically look for `clang-format.exe` on Windows.


### How it Works


The `find_program()` command searches a series of locations in a well-defined order, starting with standard system binary directories (like those in the `PATH` environment variable).

- **If the program is found**: The `<variable>` you provided will be set to the full, absolute path of the executable.
- **If the program is NOT found**: The `<variable>` will be set to a special value: `<variable>-NOTFOUND`. For example, if we searched for `CLANG_FORMAT_EXE`, the variable would become `CLANG_FORMAT_EXE-NOTFOUND`.

As we briefly covered in our variables introduction, values using this special `*-NOTFOUND` format are treated as falsy by CMake.  This lets us easily check whether `clang-format`  was found using an `if()` statement.


### A Practical Example


Let's use this command to find `clang-format` and report its location. We can add this to our root `CMakeLists.txt`.


<CodeFile path="CMakeLists.txt" status="Updated">


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

add_subdirectory(app)

# Find the clang-format executable
find_program(CLANG_FORMAT_EXE clang-format) #<h>

# Check if it was found
if(CLANG_FORMAT_EXE) #<h>
  message(STATUS "Found clang-format at ${CLANG_FORMAT_EXE}") #<h>
else() #<h>
  message(WARNING "clang-format not found") #<h>
endif() #<h>
```


</CodeFile>


When we configure our project, this script will search for the tool. If it's in our `PATH`, we'll see a success message:


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


```c++
//<o>
...
-- Found clang-format at D:/msys64/ucrt64/bin/clang-format.exe
...
```


If `clang-format` isn't installed or isn't in the `PATH`, `CLANG_FORMAT_EXE` will not be set to a valid path. The `if()` condition will evaluate to false, and we'll see our warning message instead. This allows us to gracefully handle the absence of optional tools.


### The `REQUIRED` Keyword


If a program is required for our build to be functional, we can add the `REQUIRED` argument to our `find_program()` command:


```c++
find_program(CLANG_FORMAT_EXE clang-format REQUIRED)
```


This removes the need for an `if()` check - if `clang-format` isn't found on the build system, our script would now simply throw an error explaining that it's required.


For a program like `clang-format`, this is generally **not** recommended.  Making it `REQUIRED` would mean that anyone using our project would need to have `clang-format` installed, even if they have no desire to use it.  Perhaps they already have some other formatting tool, or are using an IDE that takes care of it for them.


Instead, we should set our script up so that, if `clang-format` isn't found, the custom target that requires it simply isn't available, but the build otherwise works as normal.  We'll set that up next.


## Integrating `clang-format` as a CMake Target


Our goal is to create a custom target named `format` that, when built, will run `clang-format` on all the C++ source files in our project.


We'll add this logic to our root `CMakeLists.txt`.


### Step 1: Find the `clang-format` Executable


First, we need to find the `clang-format` executable as before:


<CodeFile path="CMakeLists.txt" status="Updated">


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

add_subdirectory(app)

# Find the clang-format executable
find_program(CLANG_FORMAT_EXE clang-format) #<h>
```


</CodeFile>


This command searches for a program named `clang-format` in standard system locations (i.e., the directories in the `PATH` environment variable) and stores the full path to it in the `CLANG_FORMAT_EXE` variable.


### Step 2: Gather All Source Files


Next, we need a list of all the `.cpp` files in our project. We can get this by inspecting the `SOURCES` property of our target, which we'll save to a variable called `target_sources`:


<CodeFile path="CMakeLists.txt" status="Updated">


```c++
#<cmake>
cmake_minimum_required(VERSION 3.16)
project(Greeter)
add_subdirectory(app)

find_program(CLANG_FORMAT_EXE clang-format)
get_target_property(target_sources GreeterApp SOURCES) #<h>
```


</CodeFile>


### Step 3: Create the Custom Target


Finally, we create the `format` target. We'll add a check to ensure `clang-format` was actually found before creating the target. This means the target won't be available on systems where the tool isn't installed.


Then, we'll pass our list of source files to `clang-format` using the `-i` argument as before.


One additional consideration here is that our `target_sources` paths are relative to the `/app` directory rather than the project root.  For example, the path will be `/src/main.cpp` rather than `/app/src/main.cpp`.


We'll see a few different ways to deal with this as we build out this target over the next two lessons.  For now, a simple solution is to set `/app` as the target's `WORKING_DIRECTORY`:


<CodeFile path="CMakeLists.txt" status="Updated">


```c++
#<cmake>
cmake_minimum_required(VERSION 3.16)
project(Greeter)
add_subdirectory(app)

find_program(CLANG_FORMAT_EXE clang-format)
get_target_property(target_sources GreeterApp SOURCES)

if(CLANG_FORMAT_EXE) #<h>
  add_custom_target(format #<h>
    COMMENT "Formatting files with clang-format..." #<h>
    COMMAND ${CLANG_FORMAT_EXE} -i ${target_sources} #<h>
    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/app#<h>
  ) #<h>
  message(STATUS "Added 'format' target") #<h>
else() #<h>
  message(WARNING#<h>
    "clang-format not found - format target unavailable") #<h>
endif() #<h>
```


</CodeFile>


## Using Our `format` Target


After configuring our project, we now have a simple, memorable command for a common development task.  We can configure our project from our build directory to confirm that our target was added:


```c++
//<o>
cmake ..
```


```c++
//<ti>
...
-- Added 'format' target
...
```


We can then run it from the `build` directory:


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


```c++
//<o>
[1/1] Formatting files with clang-format...
```


This will invoke our custom target, which in turn runs `clang-format` with the `-i` flag on the list of all source files we collected.


We can also create a build preset for this in the usual way:


<CodeFile path="CMakePresets.json">


```json
{
  "version": 3,
  "configurePresets": [{
    "name": "base",
    "binaryDir": "${sourceDir}/build"
  }],
  "buildPresets": [{
    "name": "format",
    "configurePreset": "base",
    "targets": ["format"]
  }]
}
```


</CodeFile>


```c++
//<ti>
cmake --build --preset format
```


## Formatting Multiple Targets


Let's expand this target to integrate some of the techniques we've seen in previous lessons, as well as introduce some new additions.


In this example, we've re-added our `greeter` library, meaning we now have multiple targets we want to run `clang-format` on.


To accommodate this, we add a `FORMAT_TARGETS` variable to store the list of the targets.  We then iterate over this list and append each target's source files to an `ALL_SOURCES` variable.


Instead of using the `WORKING_DIRECTORY` argument, we'll handle the relative path issue (`/src/main.cpp` vs `/app/src/main.cpp`) using a different technique.

1. We'll iterate over each source in the target
2. If the source is already using an absolute path, we'll add it to our `ALL_SOURCES` list without modification.  CMake includes an `if(IS_ABSOLUTE SomePath)` helper for this.
3. If the source is using a relative path, we'll prefix the target's source path before appending it to `ALL_SOURCES`
4. We can get a target's source path (eg `c:/my-project/app` and `c:/my-project/greeter`) from the `SOURCE_DIR` property.

Our complete target might look something like this:


```c++
#<cmake>
cmake_minimum_required(VERSION 3.16)
project(Greeter)
add_subdirectory(app)
add_subdirectory(greeter)

find_program(CLANG_FORMAT_EXE clang-format)
set(FORMAT_TARGETS GreeterApp GreeterLib)
set(ALL_SOURCES)

foreach(target IN LISTS FORMAT_TARGETS)
  get_target_property(target_sources ${target} SOURCES)
  get_target_property(target_source_dir ${target} SOURCE_DIR)
  
  # Convert relative paths to absolute paths for this target
  foreach(source ${target_sources})
    if(IS_ABSOLUTE ${source})
      list(APPEND ALL_SOURCES ${source})
    else()
      list(APPEND ALL_SOURCES ${target_source_dir}/${source})
    endif()
  endforeach()
endforeach()

if(CLANG_FORMAT_EXE)
  add_custom_target(format
    COMMENT "Formatting files with clang-format..."
    COMMAND ${CLANG_FORMAT_EXE} -i ${ALL_SOURCES}
  )
  message(STATUS "Added 'format' target")
else()
  message(WARNING
    "clang-format not found - format target unavailable")
endif()
```


If you mess up the formatting of source files in both `/app` and `/greeter`, your `format` target should now fix both of them:


```c++
//<ti>
cmake --build --preset format
```


```c++
//<o>
[1/1] Formatting files with clang-format...
```


<Preview>


### What about the Headers?


You may have noticed a problem with our `format` target. We're using `get_target_property(... SOURCES)` to collect files, but this property only includes the source files (`.cpp`) passed to `add_executable()` or `add_library()`. It doesn't know anything about our header files (`.h`).


To address this, it would be helpful if we had a list of the header files associated with a target.  We could create and maintain this list as a regular variable, but CMake 2.23 introduced the concept of **file sets** to help with problems like this.


In the next lesson, we'll learn how to use `target_sources()` to formally declare a target's `PUBLIC` and `PRIVATE` headers as a file set, and the benefits that this gives us.


</Preview>


## Summary


Integrating developer utilities like `clang-format` into our build system can improve the developer experience of working on the project.  It automates tedious tasks, ensures consistency, and makes life easier for everyone on the team.

- **Automate Formatting**: `clang-format` is the standard tool for automatically enforcing a C++ coding style. Its behavior is controlled by a `.clang-format` file in your project root.
- **Find Your Tools**: Use `find_program()` to locate external command-line tools in a portable way.
- **Create Utility Targets**: Use `add_custom_target()` to create named, standalone targets for developer tasks.
- **Gather Your Files**: We can use `get_target_property()` to collect the source files associated with a target.

File Sets

Clang-Format Documentation

Clang-Format Style Options

`find_program()` Documentation

`.clang-format` file generator

Oh No! More Modern CMake - Deniz Bahadir

How to run clang-format over a whole C++ project?

A step-by-step guide to integrating Clang-Format with CMake. Learn how to install and configure .clang-format, and create a custom CMake target to automatically format your entire C++ codebase.

CMake Tutorial: Integrating Clang-Format for Automated Code Formatting

Using `clang-format` from the Command Line

Finding External Tools with `find_program()`

Integrating `clang-format` as a CMake Target

Step 1: Find the `clang-format` Executable

Using Clang-Format

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Managing C++ Projects Using CMake