Compilation benchmark

Compilation speed benchmark.

Select a programming language and a CPU to estimate compilation time for small, medium, and large projects. Compare your processor against reference tiers.

Systems

Scripting

Configure your estimate

Follow the three steps on the left to calculate estimated compilation time for your CPU.

Choose a programming language

Select project size

Pick your CPU

How to read the compile-time estimate

The estimator compares processors on the job a developer actually waits for: a clean build. Here is what goes into the number, examples that show where more cores pay off and where they do not, and what the estimate leaves out.

Using it

Pick the language your project is mostly written in. Each one carries a baseline time and a parallel factor — how well its toolchain spreads work across cores.
Pick the processor. The tool uses its performance index and its core count.
Pick the project size: small is about 5,000 lines, medium about 50,000 and large about 500,000. If your project sits between two sizes, look at both results.

The baseline is the time a clean build of that size takes on a reference 6-core processor with an index of 5,000, roughly a Ryzen 5 5600. A faster processor divides it; more cores divide it again, but only as far as the language lets them.

More cores or a faster processor? It depends on the language

The parallel factor is the most important number on the page, and it varies more than people expect. C (0.95), C++ and Fortran (0.9) use almost every core you give them, because each source file compiles on its own. Rust (0.7) and Go (0.65) parallelise well but not perfectly: a crate or package has to wait for the ones it depends on. TypeScript (0.25) and JavaScript (0.2) barely benefit, since the classic TypeScript compiler type-checks a project on one thread. Python, Ruby, Perl and Lua (0.1) do almost no compiling at all.

Large C++ project (450 s baseline): a Ryzen 5 5600 takes about 7 min 39 s, a Ryzen 7 9800X3D (8 cores) 3 min 8 s, a Ryzen 9 9950X (16 cores) 1 min 40 s and a Core i7-14700K (20 cores) 1 min 38 s. Doubling the cores from the 9800X3D to the 9950X nearly halves the wait.
Large TypeScript project (85 s baseline): the 9800X3D takes about 43 s and the 9950X about 33 s. Twice the cores buys a quarter off, because the work does not spread.
Medium Rust project (65 s baseline): about 66 s on the Ryzen 5 5600 and 29 s on the 9800X3D.
Medium Go project (12 s baseline): about 12 s on the Ryzen 5 5600 and 3 s on the 9950X. Go builds are fast enough that a faster processor matters less than the cache does.

The practical reading: if you build C, C++ or Rust all day, core count is worth paying for. If you work in TypeScript or a scripting language, a fast 6- or 8-core processor gets you nearly all of the benefit, and the money is better spent on memory or a quieter machine.

What the estimate leaves out

It estimates clean builds. Most builds in a working day are incremental: one or two files change and the linker does most of the work. Those depend far more on single-thread speed and on the build system than on core count, and a good build cache can make them almost instant on any machine.

Every core counts the same. Intel's recent processors mix performance and efficiency cores, and the Core i7-14700K's 20 cores are 8 of one and 12 of the other, so the estimate flatters it. Treat close results between a hybrid Intel chip and an AMD one as a tie.

Memory and storage are assumed to keep up. A large C++ build wants roughly 2 GB of memory per parallel job; a machine that runs out starts swapping and every core waits. The baselines themselves are editorial estimates of typical projects, not measurements of a particular codebase, as the methodology page explains.

Before you buy

Compare two or three processors at your project's size rather than reading one result in isolation: the gap between them is more reliable than either absolute time. Then check the rest of the build — a 16- or 20-core processor under a long build draws a lot of power, which the power supply calculator sizes for, and the electricity calculator turns into a monthly cost.

Frequently asked questions

What makes a machine compile quickly?

Core count first, because compilation splits cleanly across cores. Then single-core speed, which governs linking and the parts that refuse to parallelise. Then memory capacity, since each parallel job needs its own, and finally the drive, which matters most on a cold build of a large tree.

More cores or a higher clock speed?

For full builds, more cores, almost without exception — the work is close to embarrassingly parallel. For the incremental builds you actually run all day, where one or two files change and the linker dominates, single-core speed matters more than the core count.

Will an NVMe drive speed up my builds?

On a clean build of a large project, noticeably. On incremental builds, much less than people expect, because the files in play are already in the operating system's cache. Moving from a mechanical drive is transformative; moving from a good SATA SSD to NVMe is not.

How much memory do I need?

Budget roughly 2 GB per parallel job for a large C++ project, so a 16-core machine running 16 jobs wants 32 GB and is happier with 64. Running out is worse than having too few cores: the machine starts swapping and the build slows to a crawl.

Does the operating system make a difference?

It can, and the gap is largest for projects with very many small files, where filesystem and process-creation overhead dominate. The effect is real but smaller than the difference between a four-core and a sixteen-core processor.

Keep going

Other tools and reference pages that pick up where this one leaves off.

Assembly simulator Build a PC piece by piece and check it boots. Build configurator Complete, coherent parts lists by budget. Power supply calculator Size the PSU your components actually need. Bottleneck detector See whether the CPU or the GPU is holding you back. DDR4 vs DDR5 What changes, and when it is worth it. AM5 vs LGA1851 AMD and Intel's current sockets, compared.