How Engines Were Built, 2000 → Modern
The search-vs-evaluation page is about how an engine thinks. This one is about how engines were constructed — and that's a different story with a sharper arc. In 2000, one clever programmer could write a world-class engine in a single C file. By 2026 the top engine is a distributed ML project no individual could build alone. Five shifts got us from there to here.
Five shifts, one arc
Strip away the individual engines and the same five transitions show up, each one moving a piece of the engine out of the programmer's head and into a system. Here they are in order.
One person, one C file, hand-tuned weights
A single-threaded C or C++ program: a move generator, an alpha-beta search, and a handcrafted evaluation function, often with an early mailbox or bitboard board representation. The defining trait is that the evaluation weights were tuned by hand — a human decided a bishop pair was worth 40 centipawns because it felt right and tested a little. Fritz 6, Shredder, and Junior lived here. This was the world where one gifted author could top the field.
Magic bitboards, and Fruit sets the template
Board representation matured — rotated bitboards gave way to magic bitboards, making sliding-piece attacks a single table lookup — and the real gains moved into search: better move ordering, pruning, extensions. In 2004, Fabien Letouzey's Fruit shipped with an architecture so clean and readable that essentially everyone copied it. Clean structure became a competitive asset.
The weights stop being guessed
Two things happened at once. Search went parallel across multiple cores, and evaluation weights stopped being hand-guessed and became a data-fitting problem — Texel tuning and similar methods learned the numbers from game results. The structure of the evaluation was still handcrafted, but the numbers inside it were now optimized against data instead of intuition.
Fishtest and SPRT — TDD for a game engine
The pivotal shift wasn't in the engine at all — it was in how the engine was developed. Stockfish's Fishtest turned improvement into a distributed pipeline: every proposed change is played across thousands of volunteer-donated games and accepted only if it passes an SPRT statistical test. Development became a gated regression-testing loop, and Stockfish pulled away from the field.
This is construction as a statistically-gated regression-testing pipeline — test-driven development for a game engine. Nothing enters the codebase without proof it helps, measured against a real workload with enough runs to clear the noise. It's the same discipline that separates "I think this index helps" from "this index measurably cut the workload's cost, significantly, over N runs." The automation page shows this hands-on.
The handcrafted eval is replaced outright
AlphaZero (2017) proved a neural network could evaluate positions better than decades of human chess knowledge. In 2020 Stockfish adopted NNUE, a small, efficiently-updatable net, running a trained evaluation on top of its classical search; by 2023 it had removed the last handcrafted evaluation term entirely. Building an engine now included training a network — a whole ML pipeline bolted onto the codebase. (The mechanics are on the NNUE page.)
Hand-engineered search + trained neural eval + tablebases + distributed testing
The modern engine is a composite: a hand-tuned alpha-beta search, a trained NNUE evaluation, Syzygy tablebase probing, all developed on Fishtest or OpenBench. Construction is now as much machine-learning work as classical coding, and the lone-author top engine is extinct — the strongest engines are team efforts with training infrastructure behind them.
The one-line arc: author's judgment → shared clean architectures → machine-tuned weights → statistically-gated distributed development → learned evaluation.
Every shift moved judgment out of a head and into a system
Read the five together and there's one motion repeating: knowledge that used to live in a talented individual kept getting externalized into a system. The evaluation weights moved from intuition to data. The architecture moved from private to shared and readable. The testing moved from "it feels stronger" to a statistical gate. The evaluation itself moved from human-written rules to a trained network. Each step traded a genius's judgment for a reproducible, auditable process — and the results got stronger every time.
This is the arc of every maturing engineering practice, databases included: from the heroic individual who "just knows" the right index, to shared patterns, to tuning against real telemetry, to CI gates that won't let a regression merge. The lesson computer chess learned the hard way is the one worth stealing — the auditable, tested, reproducible system beats the brilliant black box, and it keeps beating it as the problem scales.
- Chessprogramming Wiki — Fruit, magic bitboards, Texel tuning, Stockfish, NNUE.
- Stockfish + Fishtest history; NNUE landed in the Stockfish repo in August 2020 (~+90 Elo in Fishtest) and shipped in Stockfish 12 — stockfishchess.org.
- SSDF and CCRL rating-list archives for the era-by-era strength progression (treated as dated, build-specific snapshots — see the Disputes page).
- DeepMind AlphaZero paper (2018) for the neural-evaluation proof point.
The code that got borrowed along the way
This clean-architecture arc had a litigious underside — whose code was whose. Or go straight to the neural step that ended the handcrafted era.