StockShark

Chess has roughly 10¹²⁰ possible games - more than there are atoms in the observable universe. A strong engine can't come close to enumerating that, so its strength comes entirely from how cleverly it doesn't look at moves: pruning branches that can't matter, ordering moves so the best ones are examined first, caching results so the same position is never searched twice, and evaluating quiet positions with enough nuance to tell a winning plan from a losing one.

StockShark implements the full modern engine pipeline - bitboards, iterative-deepening alpha-beta with null-move pruning, principal variation search and late-move reductions, quiescence search, a transposition table, killer and history heuristics, and a tapered PeSTO evaluation. Every part was written from scratch in safe Rust, with no chess libraries.

The result is empirically calibrated at ~2460 Elo against Stockfish - grandmaster strength - and every step of the ~+400 Elo climb from its baseline was proven with statistical game testing rather than intuition, while remaining a single self-contained binary you can hand to anyone with no installation required.

A single search request flows through five subsystems. The board layer answers "what is the position and what is its hash?"; the move layer generates and applies moves with full undo; the search layer explores the tree; the evaluation layer scores the leaves; and the book layer short-circuits the opening entirely with known theory.

The codebase mirrors this exactly - each concern lives in its own module under src/, so the search never touches the bit-twiddling and the evaluation never touches the GUI.

Rather than an array of squares, the position is stored as bitboards - one 64-bit integer per piece type per colour, so 12 in total. Bit N being set means that piece occupies square N. Two extra occupancy boards track "all white pieces" and "all black pieces".

This turns whole-board questions into single machine instructions. Pawn attacks, sliding-piece rays, and legal-square masks all become bitwise shifts, ANDs and ORs the CPU executes in one cycle - the foundation of the engine's search speed.

Each Position also carries side-to-move, castling rights, the en-passant square, the halfmove clock, a redundant [Option<Piece>; 64] array for O(1) lookup by square, and a Zobrist hash.

The Zobrist hash is a 64-bit fingerprint built by XOR-ing a random key for every piece/square combination. Because XOR is its own inverse, it's updated incrementally on each move - flip the key for the from-square and the to-square rather than rehashing the whole board. That single number is what makes the transposition table and repetition detection possible.

generator.rs produces all pseudo-legal moves; the search filters out any that leave the king in check. Splitting it this way is a deliberate speed trade - full legality checks are expensive, and most illegal moves are never reached once a branch is pruned.

• ▸Pawns - single/double pushes, all four promotions, diagonal captures, en passant.
• ▸Sliding pieces - ray-casting loops in each direction, stopping at the first blocker.
• ▸Castling - enforces all five FIDE rules: king & rook unmoved, clear path, and the king never in, through, or into check.

The real trick is the undo path. make_move applies a move and returns an Undo struct capturing everything needed to reverse it - previous castling rights, en-passant square, halfmove clock, the captured piece, and the prior Zobrist hash.

unmake_move restores all of it with no cloning of the position. Since the search visits millions of nodes, mutating one shared board and stepping back out is dramatically faster than copying the board at every node.

At every leaf the engine scores the position in centipawns (hundredths of a pawn), always from the side-to-move's perspective. Material and placement are fused into tapered PeSTO piece-square tables - the Texel-tuned values from the chess-programming literature.

Every piece has two tables - a middlegame set and an endgame set - and the final score blends them, weighted by a game phase computed from the remaining material (minor piece = 1, rook = 2, queen = 4; full board = 24). Values shift smoothly as pieces come off - a knight on the rim, a centralised king, an advanced pawn are all worth different amounts in the opening than in the endgame - instead of flipping abruptly at a fixed material threshold, as earlier versions did. Switching to this scheme measured +165 Elo on its own.

Mobility, king safety, and structural terms add the positional judgement that separates a club player from a master - and dedicated endgame coordination bonuses let it actually finish won endings like K+R vs K instead of shuffling until the 50-move rule.

Every change to the engine was kept or discarded based on game results, never intuition. Matches run under fastchess against Stockfish 18 throttled to fixed strengths via its UCI_Elo option - 8s + 0.08s per side, from a book of 99 balanced openings, 8 games in parallel.

Two scripts drive it. sprt.sh is the A/B gate: each candidate build plays the previous one head-to-head under a sequential probability ratio test (SPRT) that stops as soon as the result is statistically decided. A change ships only when the data rejects "no improvement". gauntlet.sh handles absolute calibration: the engine plays Stockfish across a spread of Elo levels, and where it scores ~50%, its rating ≈ that level - the conversion is only trusted near 50%, where it's least sensitive to noise.

The loop caught things no amount of code reading would. The very first match was a clean sweep of losses - not from bad moves, but from overrunning the clock by milliseconds, so a time-safety margin became the first fix. The engine was also self-throttling at a fixed depth 6 and leaving most of its clock unused; removing that cap was the single cheapest large gain. And a full king-safety term (pawn shield plus scanning enemy attacks around the king) measured −16 Elo - the per-node cost outweighed the knowledge - while cutting it back to the cheap pawn-shield half turned the same batch into a +32 gain.

Ratings are on Stockfish's UCI_Elo scale at a fast time control, which reads higher than public lists like CCRL or FIDE - a consistent relative yardstick for progress, not a guaranteed list rating.

No search is needed for well-known openings - they've been analysed for hundreds of years. StockShark plays book moves instantly and only switches to its own search once the position leaves theory.

It reads the standard Polyglot .bin format used across the chess world. Drop a book like Titans.bin beside the binary and the engine loads it automatically, computing the Polyglot-compatible Zobrist hash (a separate key table from its internal one, required for cross-compatibility) and binary-searching the sorted file. Moves are chosen weighted by their stored grandmaster frequency, so mainlines appear often and sidelines occasionally.

With no book file present it falls back to ~35 hardcoded opening lines covering every main system - Ruy Lopez, Italian, Sicilian, French, Caro-Kann, Queen's Gambit, King's Indian, Nimzo-Indian and more. A per-game seed from the system clock picks among candidates, so no two games open the same way.