Abstract:

This instructional video explores how Bazel addresses the complexities of C++ development at scale, offering a robust alternative to traditional build systems like CMake and Make. It demonstrates practical techniques for integrating C++ projects, managing external dependencies, and targeting multiple platforms. Key topics include setting up hermetic LLVM toolchains and sysroots to ensure reproducible and portable builds, configuring editor support with clangd using Bazel-generated compilation databases, and implementing advanced features like cross-compilation and Bazel transitions for multi-architecture deployments. The video also touches on integrating with OCI containers for running cross-compiled binaries and utilizing clang-tidy for linting.

C++ Build System Tutorial: Using Bazel for Scalable, Reliable Builds

• 0:10 Introduction to Bazel for C++: Bazel is presented as a superior build system for C++ not only for large-scale projects or multi-language environments but also because it overcomes inherent weaknesses of CMake and Make, which struggle with maintainability, consistency, and reproducibility at scale.
• 4:14 Key Bazel Concepts:
  • Bazel Central Registry (BCR): A repository for numerous pre-built C++ libraries and modules.
  • Hermetic Toolchains & Sysroots: Bazel manages specific compilers (e.g., LLVM/Clang) and sysroots (collections of headers and libraries), ensuring builds are reproducible, portable, and decoupled from the host machine's installed packages.
  • rules_cc: A Starlark-based re-implementation of Bazel's core C++ rules, offering greater flexibility.
• 10:08 Initial Project Setup: Demonstrates creating a new C++ project using aspect init, which scaffolds a Bazel repository, sets up LLVM toolchains, and configures for linting, version stamping, and OCI containers.
• 14:31 Basic C/C++ Building (cc_binary): Shows how to compile a simple "Hello World" C program using Bazel's cc_binary rule. This highlights Bazel's declarative approach, where users describe source files, and Bazel determines the necessary compilation commands, contrasting with Makefiles where users dictate commands directly.
• 23:21 Hermetic External Dependencies: Explains how to integrate third-party libraries like libmagic from the Bazel Central Registry. It addresses challenges like version skew of runtime data files (e.g., magic.mgc) by having Bazel generate them for the target platform and managing them as data dependencies.
• 36:38 Editor Support with clangd: Details how to set up clangd (the LLVM language server) in an editor for C++ development. This involves generating a compilation database (a JSON file describing build commands) from Bazel's action graph using bazel_compdb, which enables features like error highlighting, jump-to-definition, and code completion.
• 43:03 Cross-Compilation & Platforms: Introduces the concept of platforms in Bazel for defining target execution environments (e.g., linux_arm64). It explains how Bazel can cross-compile binaries by leveraging specific toolchains and sysroots tailored for the target platform, ensuring the compiled code links against the correct system libraries.
• 49:28 Docker Integration (OCI): Demonstrates packaging a cross-compiled Linux ARM64 binary into an OCI (Docker) container image using rules_oci. This allows for running binaries on different architectures (e.g., testing a Linux ARM64 build on a Mac via Podman).
• 54:04 Bazel Transitions for Multi-Platform Builds: Shows how to use Bazel transitions to build different parts of a project for various target platforms simultaneously, without repeatedly specifying --platforms on the command line. This enables generating multi-architecture OCI images, beneficial for optimizing compute costs (e.g., AWS Graviton) or deploying to diverse hardware.
• 57:44 Linting with clang-tidy & Build File Generation: Briefly covers using aspect lint (a wrapper around Bazel with clang-tidy) for code quality checks, mirroring editor warnings in the CI/CD pipeline. It also mentions aspect configure and Gazelle for automating the generation of BUILD files for C++ projects, reducing manual effort.
• 1:00:24 Key Takeaways & Q&A: Discusses ibazel for interactive building, clarifies bazel run's unpredictable working directory issues (suggesting Makefile as a task runner), and expresses views on improving Bazel's coverage system by moving it to an aspect-based approach.