Oldworld, a classical chess engine

Oldworld is a lightweight UCI compliant chess engine built around a hand-crafted classical evaluation, written to play as closely as it can to an old school world champion from back in the day. It weighs pawn structure, space and restraint the way those players did, with no neural network and no weights file to ship alongside it.

Parts of this codebase were written with AI assistance. Oldworld is a fork of Berserk. Much of the work since the fork, including the classical evaluation, the pawn-structure layer, refactoring and tooling, was produced in collaboration with an AI assistant, directed and tested by the author. Every functional change was gated by a 48-game match before shipping, and the results are recorded, including the changes that failed and were reverted. This is disclosed so that testers and other developers can judge the project accurately.

Classical by design

The evaluation is entirely hand-written. NNUE was removed outright rather than left dormant, so there is no accumulator, no network file and nothing to download beside the executable. Every term is a term somebody chose and can explain.

Verified, not asserted

Four hand-written self-tests run inside every bench, cross-checking the structure layer, the board, the move generator and the static exchange evaluator. Perft and mate-in-one are hard invariants; no change ships if either moves.

Measured, and reverted

Every functional change plays a paired-opening match against the previous build and ships only if it wins. Ideas that lose are reverted and written down, the negative results are kept in the ledger alongside the wins.

Why classical

Nearly every strong engine today evaluates positions with a neural network. The networks are effective and they are not going away, but they are opaque: a number comes out and nobody, including the author, can say precisely why.

Oldworld goes the other way on purpose. Every term in the evaluation was chosen by a person, has a name, and can be explained. When it prefers a position, there is a reason written in the source that you can read. That choice costs some strength against the best networks, and it buys something back: an engine whose judgement is legible, and one that can be aimed at a particular kind of chess rather than simply at winning.

How it plays

The engine has a pawn-structure layer that most engines do not: it measures how locked a position is on a 0 to 64 scale, tracks which pawns are frozen against each other, and works out the squares each side needs for a freeing pawn break. Several parts of the engine read from it, and the result is a recognisable style.

It values space, but only when space is worth something

A flat bonus for territory scores badly, because in an open position space usually just means overextension. Oldworld scales the bonus by how locked the structure is, so it wants space when the opponent cannot free himself and shrugs at it otherwise.

It restrains breaks before they exist

Rather than meeting a pawn break when it comes, the engine counts the squares the opponent needs for that break and rewards covering them first. A break he cannot make is a plan he never gets.

It keeps tension rather than resolving it

While holding a modest advantage, move ordering examines tension-building pawn moves earlier and tension-releasing trades later. This changes only which moves it looks at first, never what is legal, but it steers the engine toward keeping the position pregnant.

It is patient in closed positions

When the structure is locked, pruning relaxes and quiet piece manoeuvres onto strong squares get searched more deeply. It thinks like a positional player where that is correct, and like a tactician everywhere else.

Strength

Being measured. A rating estimate is in progress: several hundred games against engines with published CCRL ratings, at a fixed time control on a single thread, anchored to those ratings. The result will be published here with the opponents, the time control and the error margin, so it can be checked.

Oldworld has not been submitted to CCRL or CEGT. Any figure posted here is an in-house estimate on one machine, not an official rating.

Download

Latest version: 0.6.0

Download Windows x64 · 425 KB
needs AVX2 (CPUs from roughly 2015)

Download for older CPUs Windows x64 · 423 KB
runs on much older hardware

Not sure which? Take the first. If it refuses to start, use the second. Both are the same engine, built for different processors.

Download the source code · 299 KB · complete source for the builds above

Installation

Download the build and unzip it wherever you keep engines.
In your chess GUI, add a new UCI engine and point it at oldworld.exe.
Set Hash and Threads to suit your machine. Nothing else is required, there is no network file to fetch.

Windows x64. Builds target modern instruction sets; use the portable build if your CPU is older.

Configuration

Oldworld exposes the standard UCI options plus dials for time management, evaluation weights and search selectivity. Search and evaluation knobs are inert at their defaults, the engine plays identically until one is changed.

Option	Type	Default	Range	Purpose
`Hash`	spin	16	2–max	Transposition table size in MB.
`Threads`	spin	1	1–2048	Search threads (lazy SMP).
`SyzygyPath`	string	n/a	n/a	Directory of Syzygy tablebase files.
`MultiPV`	spin	1	1–256	Number of principal variations reported.
`Ponder`	check	false	n/a	Think on the opponent's clock.
`UCI_ShowWDL`	check	true	n/a	Report win/draw/loss alongside the score.
`UCI_Chess960`	check	false	n/a	Fischer random castling rules.
`MoveOverhead`	spin	100	0–10000	Milliseconds reserved for GUI and IPC latency.
`SlowMover`	spin	100	10–100	Percent of stock thinking time to use.
`EvalScale`	spin	100	25–300	Scales reported evaluation magnitude.
`HCEWeights`	string	n/a	n/a	Load evaluation weights at runtime, no rebuild.
`StrictSearch`	check	false	n/a	Tighter pruning and extra late-move reduction.
`Contempt`	spin	0	-100–100	Draw aversion; scales with structural closedness.
`RfpMargin`	spin	110	20–200	Reverse futility pruning margin.
`RazorMargin`	spin	190	60–300	Razoring margin.
`NmpMargin`	spin	290	150–700	Null-move pruning margin.
`FutilityBase`	spin	95	0–200	Futility pruning base margin.
`FutilityMul`	spin	56	10–120	Futility margin per depth.
`HistPruneMul`	spin	3800	1000–6000	History-based pruning threshold.
`LmrDivisor`	spin	2135	1000–4000	Late-move reduction divisor.
`HistLmrMul`	spin	8	2–24	History influence on reductions.
`TimeAllocPct`	spin	575	200–1500	Share of the clock budgeted per move.
`TmMaxPct`	spin	5500	500–9900	Hard ceiling on one move's share of the clock.
`TmMaxMul`	spin	5928	1000–8000	Ceiling as a multiple of the soft budget.
`TmIncMoves`	spin	50	1–50	Future increments counted as available now.
`BreakDenyMg` / `BreakDenyEg`	spin	0	-40–120	Denying the opponent's pawn breaks.
`BlockadeMg` / `BlockadeEg`	spin	0	-40–120	Blockading enemy passed pawns.
`SpaceClosedMg`	spin	12	-40–120	Space bonus scaled by structural closedness.
`SpaceAreaMg` / `SpaceAreaEg`	spin	6 / 3	-40–120	Raw space-area bonus.

Changelog

0.6.0

Evaluation is classical only. NNUE was removed entirely on 2026-07-10; Evaluate() always calls EvaluateHCE. No network, no accumulators, no weights file.
The Structure Engine, a pawn-structure layer computing rams, tension, a 0–64 closedness scale, space projection, passed pawns and outpost holes, cached by pawn hash.
Patient Search, in closed positions, late-move pruning relaxes, quiet futility damps, and relocations onto uncontestable outposts earn a reduction credit. Gated at 53.1%.
Keep-the-Tension ordering, while nursing a modest edge, tension-building pawn moves are examined earlier and tension-releasing trades later. Gated at 52.1%, undefeated.
Squeeze Contempt, contempt scales with closedness when the engine owns the space and relaxes when cramped. Provably inert at Contempt 0.
Endgame draw-scaling, opposite-coloured bishops and wrong-bishop corrections, cross-checked against tablebases.
Idea ports, credited in-code and re-implemented from scratch: non-pawn and minor-piece correction history, correction-scaled pruning margins, TT-cutoff history bonus, deep-depth TT cutoffs with a fifty-move staleness guard.
Fix, an inherited latent bug: three move-picker constructors left picker->ss uninitialized.
New options, SlowMover, StrictSearch, HCEWeights, and the search and time-management dials listed above.

Development history

The search core reorganised and documented, with the search tree kept bit-identical throughout. Verified by unchanged node counts.
The classical evaluation written from scratch after the neural network was removed. +446 Elo.
Threats and king safety overhauled.
Piece-square tables reworked, plus a large evaluation re-tune and search tuning.
Higher-quality self-play training data and a blended re-tune. +145 Elo, then +39 more.
Search constants re-fit for a hand-crafted evaluation rather than the network they were tuned for. +123 Elo, and a more classical style.
Performance work, with search trees kept bit-identical. Roughly +2.5% nps.
Endgame draw-scaling, Syzygy tablebase support and MultiPV.
New classical evaluation terms; the blockade term ships. +70 Elo.
Board representation, move generator and static exchange evaluator reorganised and hardened, each gaining its own self-test.
Time management: a ceiling on any single move's share of the clock. Two more aggressive re-fits lost Elo and were reverted.

Originality

Lineage

Oldworld is a disclosed fork of Berserk by Jay Honnold, under GPL-3. What is inherited is stated plainly rather than blurred: the transposition table and a handful of cold utility files remain upstream work.

The evaluation is a different matter: it was written from scratch after the neural network was removed, and exists in no parent engine. The search, board representation, move generator and static exchange evaluator have been reorganised, hardened and given their own self-tests, but they still rest on Berserk's foundations rather than replacing them.

Idea ports

Techniques circulate openly in computer chess. Where an idea came from another open engine, correction history, correction-scaled margins, TT-cutoff bonuses, the concept is credited in a comment at the site that uses it, and the implementation was written here.

Original work

The Structure Engine, Patient Search, Keep-the-Tension ordering and Squeeze Contempt exist in no parent or reference engine. So does the testing method: a paired-opening match gate that every functional change must win, and a self-test suite that runs inside every benchmark.

Negative results

Failures are recorded, not quietly dropped. A hand-crafted “Harmony” evaluation term measured 47.9% twice and was reverted. Two time-management re-fits lost roughly 45 Elo and were reverted. Both remain in the ledger, with the reasoning that explains why they failed.