Chess Engine Glossary

Board Representation

Bitboard

A 64-bit integer used as a set of squares, one bit per square. Engines keep several (white pawns, black rooks, all occupied squares, and so on). Move generation and attack detection become fast bitwise operations. The natural fit for 64-bit CPUs and the backbone of every modern engine.

Piece list / mailbox

Older, simpler board representations: an array of 64 (or 120, with border squares) holding what sits on each square. Easier to read, slower than bitboards. Tutorial engines often use mailbox.

Magic bitboards

A hashing trick to look up sliding-piece (rook/bishop) attacks instantly from a precomputed table, given the occupied squares. "Magic" refers to the specially-found multiplier constants that make the hash collision-free.

Zobrist hashing

A scheme that assigns a random 64-bit number to every (piece, square) combination; XOR-ing them together gives a near-unique key for a position, updated incrementally as pieces move. The key used by the transposition table.

FEN (Forsyth–Edwards Notation)

A one-line text string describing a full position — piece placement, side to move, castling rights, en passant, move counters. The standard way to feed a position to an engine.

PGN (Portable Game Notation)

The standard text format for recording whole games (moves plus metadata tags). What you batch-analyze or import into a database.

Search

Search

Looking ahead through possible move sequences to decide the best move — the "how many moves ahead it calculates" half of an engine.

Ply

A single half-move (one side moving once). "Searching 20 ply deep" = 20 half-moves = 10 moves for each side.

Minimax

The base algorithm: assume both sides play best; you maximize, the opponent minimizes. The engine picks the move leading to the best guaranteed outcome.

Alpha-beta pruning

The essential optimization on minimax. Tracks bounds (alpha = best you're assured, beta = best the opponent allows) and stops examining a branch once it can't affect the result. Cuts the tree massively without changing the answer. DBA parallel: skipping partitions proven not to contain the answer.

Iterative deepening

Search to depth 1, then 2, then 3, reusing results. Improves move ordering and always leaves a usable best move ready under time pressure.

Move ordering

Trying likely-best moves first (captures, killer moves, hash move) so alpha-beta prunes more. Worth enormous speed.

Transposition table (TT)

A hash cache, keyed by Zobrist hash, storing results for positions already evaluated — since the same position is reached by different move orders. Sized via the engine's Hash setting. DBA parallel: a plan/result cache.

Quiescence search

An extended search at the leaves that looks only at "noisy" moves (captures, checks) until the position is calm, so the engine doesn't misjudge mid-capture. Fixes the horizon effect.

Horizon effect

The error of stopping at a fixed depth right before something decisive — e.g., not seeing a recapture next move. Quiescence search exists to combat it.

Pruning / reductions

Techniques to skip or shorten unpromising branches: null-move pruning (let the opponent move twice; if you're still winning, prune), late move reductions (search later moves shallower), futility pruning (skip quiet moves that can't raise the score near the leaves).

Extensions

The opposite of reductions: search deeper in critical lines (e.g., when in check).

Pondering

Thinking on the opponent's clock, guessing their move and searching the expected reply in advance.

MultiPV

Reporting the N best lines instead of one. Handy for analysis; slower because it can't prune as aggressively.

Node

One position examined during search. Speed is quoted in nodes per second (NPS) — modern engines hit hundreds of millions.

MCTS (Monte Carlo Tree Search)

An alternative to alpha-beta used by AlphaZero and Leela. Selectively grows the tree toward promising lines guided by a neural network's move probabilities — fewer nodes, each far more expensively evaluated.

Evaluation

Evaluation function (eval)

Scores how good a position is for the side to move, usually in centipawns. The "positional judgment" half of an engine, called at the leaves of the search.

Centipawn (cp)

The unit of evaluation: 100 centipawns = one pawn. "+1.50" means about a pawn and a half ahead.

Handcrafted evaluation (HCE)

The classical approach: a human-designed formula scoring material, king safety, pawn structure, mobility, and so on, with hand- or auto-tuned weights. Defined engines for ~50 years; Stockfish removed its HCE entirely in 2023.

Material

The raw value of pieces (pawn 1, knight/bishop ~3, rook 5, queen 9). The biggest single eval term.

Piece-square tables (PST)

A table giving each piece a bonus/penalty per square (knights like the center, pawns want to advance). Cheap positional knowledge.

Mobility

How many moves/squares a side's pieces control. A classic eval term.

King safety

Eval terms for pawn cover, attackers near the king, open files, and the like.

Tapered eval

Blending separate midgame and endgame scores based on remaining material, so priorities shift smoothly as pieces come off.

Contempt

A tunable bias that makes the engine avoid (or seek) draws by treating a draw as slightly negative (or positive). Used to play for a win vs weaker opposition.

Neural Networks (NNUE and friends)

NNUE (Efficiently Updatable Neural Network)

Pronounced "n-new." A neural network evaluation designed to be incrementally updatable and fast on CPU. Imported from computer shogi, adopted by Stockfish 12 (2020). The modern standard: neural eval + classical alpha-beta search.

Feature transformer

NNUE's huge first layer. Maps a sparse input of tens of thousands of possible features (only ~30 active at once) into the accumulator. Where most of the network's knowledge lives.

Accumulator

The vector of numbers output by the feature transformer for each side. Kept up to date incrementally rather than recomputed each position.

Incremental update

The core NNUE trick: when a piece moves, only the couple of input features that changed are added/subtracted from the accumulator, instead of recomputing the whole first layer. Undone the same way when the search takes back a move. DBA parallel: a maintained running aggregate vs. a full re-scan.

HalfKA / HalfKAv2 / HalfKAv2_hm

The feature sets used by Stockfish's NNUE. Encode each piece's location relative to its own king's square ("Half" = one perspective per side; "K" = king-relative; "hm" = horizontal mirroring to halve size). Because features are king-relative, a king move forces a full accumulator refresh — the expensive special case.

Threat Inputs (SFNNv10, 2026)

New NNUE features encoding which squares are attacked/defended, so the static eval directly "sees" hanging pieces and tactics rather than relying on search to find them. Headlined the Stockfish 18 release, which gained ~46 Elo over Stockfish 17.

Buckets / sub-networks

NNUE splits its later layers into several small output networks selected by material count (or king placement), so an endgame is judged by a different sub-net than a full board.

Clipped ReLU (crelu)

The activation functions NNUE uses. Cheap, integer-friendly nonlinearities (ReLU clamped to a range), chosen for speed over elegance.

Quantization

Storing/running the network in small integers (int8/int16) instead of floats, for speed. NNUE is built around integer arithmetic so it flies on ordinary CPUs.

Self-play / reinforcement learning

Training by having the engine play itself and learn from results, no human games required. The AlphaZero method; Leela trains this way. Stockfish's nets are trained on data labeled partly by Leela evals.

Policy vs value

In AlphaZero-style nets: the policy head suggests which moves to explore; the value head estimates who's winning. MCTS uses both.

Endgame Tablebases

Tablebase (EGTB)

A precomputed database of perfect results for positions with few pieces — every legal position solved to win/draw/loss (and distance). The engine stops calculating and plays flawlessly.

Piece count (3–7 man)

How many total pieces (including kings) the tablebase covers. Sizes explode: 5-piece ≈ 7 GB, full 6-piece ≈ 1.2 TB (Nalimov), 7-piece ≈ 140 TB (Lomonosov, 2012; the compact Syzygy 7-piece set from 2018, ~18 TB, is the one queryable online).

Nalimov tablebases

The 2000s-era standard (used by Fritz/Shredder/ChessBase), indexed by DTM.

Syzygy tablebases

The modern standard (Ronald de Man, 2013). Far more compact; used by Stockfish and Leela. Split into WDL (win/draw/loss — small, for use during search) and DTZ (distance-to-zeroing — for converting the win).

DTM (Distance to Mate)

The exact number of moves to forced mate. Nalimov's metric.

DTZ (Distance to Zeroing)

Distance to the next pawn move or capture (which "zeroes" the 50-move counter). Syzygy's metric; more compact and 50-move-rule aware.

Gaviota / Scorpio tablebases

Other formats between the Nalimov and Syzygy eras.

50-move-rule blind spot

Some tablebase wins take 200+ (even 500+) moves without a capture or pawn move — mathematically won but drawn under the 50-move rule, and beyond human comprehension.

Opening Books

Opening book

A stored tree of opening moves the engine plays instantly instead of searching. Keeps it in known good theory early, then hands off to search once "out of book."

.ctg

ChessBase's proprietary book format (used by Fritz/Shredder/Junior). Ships as a trio: .ctg (data) + .ctb + .cto (index files) — all three must stay together. Stores per-move stats and editable weights.

Polyglot (.bin)

The open, standard opening-book format used across many GUIs and engines. Position-hash based.

.abk / .gbk / .obk

Book formats used by the Arena GUI and others.

Powerbook

ChessBase's commercial opening book built from large game databases (the 2026 edition: ~1.7M games → ~25M positions).

Book learning

A book that adjusts move weights based on won/lost games, steering the engine away from lines that scored badly.

Protocols, Tooling & Testing

UCI (Universal Chess Interface)

The dominant text protocol between an engine and a GUI/script. The engine reads commands (position, go, setoption) on stdin and replies with analysis and bestmove. Lets any engine plug into any GUI, or be scripted.

WinBoard / XBoard (CECP)

The older engine protocol UCI largely replaced. Still supported by some engines — and the client ytoics emulated a server for.

GUI

The front-end you look at: Arena, Cute Chess, BanksiaGUI, ChessBase/Fritz, Lucas Chess. The engine is a separate, GUI-agnostic program behind it.

cutechess-cli

A command-line tool for running automated engine-vs-engine matches and tournaments. The scripting workhorse for testing.

Fishtest

Stockfish's distributed testing framework (since 2013). Volunteers donate CPU time to play thousands of games validating each proposed patch — improvement as a crowd-sourced, statistically-gated pipeline. DBA parallel: statistically-gated regression testing.

SPRT (Sequential Probability Ratio Test)

The statistical stopping rule Fishtest uses: keep playing games only until a patch is proven to gain (or lose) Elo, using the fewest games necessary. Nothing merges without passing SPRT.

OpenBench

Fishtest's spiritual offspring — the distributed testing framework many modern open-source engines develop on.

Elo

The rating scale for relative playing strength. A ~400-point gap ≈ the stronger side scoring ~90%. Top engines (~3600+) sit several hundred Elo above the best human players — though on a separate engine rating scale, so the gap is approximate, not a direct subtraction. A rating is a measurement, not a property — see the Disputes page.

Rating lists

Independent leaderboards that test engines on standardized hardware: SSDF (Swedish, the classic 2000s list), CCRL (Computer Chess Rating Lists), CEGT.

Engine tournaments

TCEC (Top Chess Engine Championship) and the Chess.com Computer Chess Championship (CCC) are the premier engine-vs-engine competitions. WCCC (World Computer Chess Championship) is the historic title event.

Perft (performance test)

A move-generation correctness/speed test: count all leaf nodes to depth N from a position and compare against known values. The first thing you verify when writing an engine — if perft is wrong, move generation is buggy.

A Few Historical Names Worth Knowing

Deep Blue

IBM's special-hardware machine that beat Kasparov in 1997. Brute-force, custom chess chips.

Fruit

Fabien Letouzey's clean open-source engine (2004) whose readable code influenced a generation; central to the Rybka plagiarism case.

Rybka

Vasik Rajlich's engine that dominated 2005–2010, then was banned by the ICGA (2011) for deriving from Fruit and Crafty.

Glaurung

Tord Romstad's engine (2004); the direct ancestor of Stockfish.

Stockfish

The open-source engine forked from Glaurung in 2008; today's strongest, using NNUE evaluation and Fishtest-driven development.

AlphaZero

DeepMind's self-play neural engine (2017) that beat Stockfish 8 and proved the neural/MCTS paradigm.

Leela Chess Zero (Lc0)

The open-source community recreation of AlphaZero (2018); the strongest neural engine and Stockfish's main rival.

Rule of thumb for reading any engine discussion: almost everything falls under either search (how far and how cleverly it looks ahead) or evaluation (how well it judges a position). Tablebases perfect the endgame, books handle the opening, and the protocol/testing tools are the plumbing around it all.