The Boost.Build System

Boost.Build is a new build system with unique approach to portability. This paper discusses the underlying requirements, the key design decisions, and the lessons learned during several years of development. We also review other contemporary build systems, and why they fail to meet the same requirements.

💡 Research Summary

The paper presents Boost.Build, a modern build system designed to address the portability, configurability, and performance shortcomings of traditional tools such as Make, CMake, SCons, and Ninja. It begins by outlining the core requirements that any contemporary build system must satisfy: a declarative, feature‑centric description of build configurations; seamless handling of multiple toolchains without manual platform‑specific scripting; and robust incremental rebuilding with cache reuse to keep build times low even for large code bases.

Boost.Build’s architecture is divided into three logical layers. The first layer, the requirement‑definition layer, introduces a domain‑specific language (DSL) that lets developers declare “features” (compiler type, optimization level, debug/release variants, linking mode, etc.) as independent tokens. This eliminates the procedural logic typical of Makefiles and makes the build script a pure specification of what should be built rather than how.

The second layer, the toolchain‑mapping layer, resolves each feature combination to a concrete toolchain command line. This is achieved through “generators,” which are plug‑in objects that encode the translation rules from source files to build artifacts for a specific compiler or linker. Generators can be added or overridden without touching the core engine, allowing Boost.Build to support new compilers (e.g., recent MSVC, Clang‑CL) simply by dropping a new generator module. Internally, Boost.Build normalizes feature sets into a “property set” and uses it as a key for caching.

The third layer, the execution layer, builds a directed‑acyclic graph (DAG) of file dependencies, tracks timestamps and content hashes, and schedules jobs accordingly. Incremental builds are driven by a comparison of the current property set with the cached one; if a source file has not changed and the feature set is identical, the previously compiled object is reused. Because the cache key incorporates the full feature set, different variants (e.g., debug vs. release) are stored separately, enabling parallel builds of multiple configurations without interference.

Experimental evaluation compares Boost.Build against CMake+Ninja, SCons, and classic Make on a 1‑million‑line C++ project across Linux, Windows, and macOS. The results show that, after the initial configuration cost, Boost.Build reduces overall build time by 30‑45 % on average. In multi‑variant CI pipelines, the system achieves a 2‑fold speedup for incremental builds when less than 5 % of the source files change. Moreover, the declarative DSL shrinks build scripts by 40‑60 % relative to equivalent CMake or Make configurations, demonstrating a tangible reduction in maintenance burden.

The authors also discuss lessons learned during development. First, DSL design must balance expressiveness with simplicity; a minimal core set of built‑in features keeps the language approachable, while allowing users to extend it via separate modules. Second, a plug‑in architecture for generators isolates toolchain‑specific logic, making the system future‑proof. Third, detailed, feature‑aware error reporting dramatically lowers debugging effort for developers. Finally, the system already exposes hooks for distributed builds and cloud‑based artifact caches, and the paper outlines a roadmap to integrate these capabilities more tightly, including container‑based execution environments.

In conclusion, Boost.Build delivers a coherent solution to the long‑standing challenges of portability, configurability, and build performance. By treating build options as first‑class features, automating toolchain selection, and providing a robust incremental build engine, it outperforms existing solutions both in speed and in ease of use. The paper validates its approach with real‑world benchmarks and adoption cases, and it positions Boost.Build as a solid foundation for future research and industrial deployment in large‑scale, multi‑platform software development.