Speeding up C++ build times

Original Article ↗ Hacker News Discussion ↗

Overall reaction to the blog post

  • Many commenters find the post shallow and self-promotional, arguing it “reinvents the wheel” and rehashes decades‑old C++ knowledge (headers, IWYU, PIMPL, etc.).
  • Some say the interesting part is the attempt to auto‑refactor a large C++ codebase and the pain of tooling (libclang, LibTooling), but they still wanted more technical depth and data.
  • A few defend the topic as valid, but think solutions like ccache, distcc, unity builds, and linkers are under‑emphasized.

Headers, includes, and PIMPL

  • Strong focus on reducing included headers: IWYU, forward declarations, PIMPL, Rob Pike–style “no headers-in-headers,” and avoiding transitive include explosions.
  • Others argue modern compilers optimize away duplicate header parsing via include guards / #pragma once, so header discipline mainly helps via reduced dependencies, not raw re-parsing.
  • PIMPL sparks heated debate:
    • Pro: improves ABI stability, hides implementation, and can help build times.
    • Con: feels like a hack, adds indirection/boilerplate, highlights C++’s inability to cleanly separate interface from layout.

Build tooling and workflows

  • Common “practical fixes”:
    • Compiler caches (ccache/sccache), distributed builds (distcc, icecream, Incredibuild), and remote workers (Bazel).
    • Faster linkers (mold) and parallel builds (ninja, CMake presets).
    • Precompiled headers and explicit template instantiation.
  • Several note that for large projects, link time and template-heavy optimization (e.g., Eigen) dominate, not just preprocessing.
  • Some report dramatic improvements (minutes to seconds) from ccache or unity builds; others say incremental builds and linker bottlenecks limit these gains.

Unity / jumbo / single-TU builds

  • Widely discussed technique: concatenate many or all .cc files into few big translation units (unity/jumbo/master files).
  • Benefits: fewer redundant header parses and more inlining; cited 5–10× compile-time speedups in games and projects like SQLite.
  • Downsides: harder incremental builds, tricky failure modes, reduced parallelism unless carefully batched.

Language and ecosystem limitations

  • Frustration that C++’s header/preprocessor model is fundamentally flawed; comparisons made to Ada, D, Jai, Rust, and Go.
  • C++20 modules seen as a potential big win but currently “bleeding edge,” poorly integrated in tooling/build systems, and not widely adopted (tracked by “are we modules yet” resources).
  • Some argue that C++ culture tolerates slow builds and over-complex features, making real fixes slow to arrive.