By ByteBot
Mold 3.0 shipped on October 5, 2026, and with it came the end of the fastest linker’s C++ era. Rui Ueyama’s massively parallel linker has been completely rewritten in Rust — same performance, same command-line interface, same output. What’s new is memory safety, a cleaner build system, and an explicit mission: become the default linker in Linux distributions. GNU ld has held that title for roughly 30 years. Mold is coming for it.
Why Linkers Are Your Hidden Build Bottleneck
Compilation is a three-step chain: your compiler turns source into object files, the assembler processes those, and the linker combines everything into the final executable. On small codebases the linker step is invisible. On large ones — Chromium, Clang, Blender — it can eat more time than the compile itself, and it runs in a single critical-path step that stalls every developer waiting for a binary.
Mold was built to fix this. By parallelizing across all CPU cores, it turns what used to be a multi-second bottleneck into something that barely registers. The numbers from August 2026 benchmarks make the case:
| Project | lld | mold 3.0 | Speedup |
|---|---|---|---|
| Chromium 145 | 16.64s | 1.65s | 10.1x |
| Blender 5.2 | 4.72s | 0.86s | 5.5x |
| Clang 21 | 6.19s | 1.34s | 4.6x |
Median across projects: mold runs 4.9x faster than LLVM’s lld, and up to 112x faster than GNU ld on large programs. GNU gold — Google’s attempt to fix ld — was deprecated in 2025. The linker race is now effectively mold versus lld, and mold is consistently ahead.
What Actually Changed in 3.0
Mold 3.0 is a complete Rust rewrite. Version 2.42.1 was the last C++ release — that codebase is now retired. Here is what changed:
- Build system: CMake replaced by Cargo. Building from source now requires Rust 1.95 or later, plus a C compiler.
- Dependency dropped: oneTBB (Intel Threading Building Blocks) is gone.
- Performance: Unchanged. Mold 3.0 is a drop-in replacement for 2.42.1 in every measurable way.
- CLI compatibility: Same flags, same target architectures, same output format.
The Rust rewrite adds zero overhead and removes one optional dependency. That is a clean trade.
The Safety Upgrade That Actually Matters
The C++ version had a real problem with corrupted input files. Feed it a malformed object file and it could read memory out of bounds, producing a segmentation fault. In a CI pipeline, a segfault from the linker looks like an infrastructure failure — you get no useful diagnostic, no line number, nothing actionable.
The Rust version bounds-checks every read. A corrupted input now produces a panic at the exact faulty access rather than a silent crash. For developers running mold on untrusted or generated object files, this is a meaningful improvement. It is not performance theater — it is what memory-safe languages are for.
How to Switch Today
Switching is a one-flag change for most projects. Install via brew install mold (Homebrew 3.0 is available) or build from source with cargo build --release after cloning the mold GitHub repository.
C or C++ with Clang or GCC 12.1+:
clang -fuse-ld=mold main.c -o main
# or
gcc -fuse-ld=mold main.c -o mainCMake projects:
set(CMAKE_LINKER_TYPE MOLD)Rust projects — add to .cargo/config.toml:
[target.x86_64-unknown-linux-gnu]
linker = "clang"
rustflags = ["-C", "link-arg=-fuse-ld=mold"]The 3.x Roadmap: Gunning for GNU ld’s Default Status
Mold cannot yet replace GNU ld everywhere. The remaining gap is linker script support — the mechanism used by the Linux kernel, embedded firmware, and bare-metal toolchains to control exactly how sections are laid out in memory. Rui Ueyama has stated explicitly that closing this gap is the goal of the 3.x series, with the aim of getting mold adopted as the default linker in Linux distributions.
That is an ambitious target. GNU ld has been the default for roughly three decades. But lld was “too experimental for production” five years ago, and today it is the default linker in many Rust and Clang toolchains. Mold is already faster than lld on every real-world benchmark, ships Rust safety guarantees, and is used internally by large organizations. The linker script gap is the last technical obstacle. When it closes, developers on every major Linux distribution will get 5-10x faster link times with zero configuration change.
That kind of win does not come around often. Switching today costs one line in a config file.
