Mite Chess Engine Benchmarks — 2,600 Verified Tournament Games

1. INTRODUCTION & SCOPE

Testing methodology & benchmark purpose.

Engine playing strength depends on opponents, deliberation time controls, transposition table sizing, and match conditions. This report provides full transparency into Mite’s internal test tournament framework.

Methodology & Rating Clarification: All benchmark data documented on this page is derived from 13 automated match series (2,600 games) using alternate-color pairings (100 games as White, 100 as Black per 200-game match series). The approximately 2000 Elo figure is an unofficial internal experimental estimate based on controlled testing against reference opponents (Stockfish calibrated to 2000 UCI limit, TSCP, and Fairy-Max). It does not constitute a certified CCRL, CEGT, IPON, or FIDE rating list. Independent community verification and rating submissions are welcomed.

Standardized Opponents

Opponents were chosen to span canonical historical reference engines to modern calibrated grandmaster-level engines:

Stockfish (UCI_Elo = 2000): Calibrated handicap limit representing club/expert play.
TSCP v1.81: Historic C benchmark (~1700-1800 Elo) testing tactical baseline execution.
Fairy-Max 5.0b: Compact micro-engine (~1850-1900 Elo) testing move ordering against a similar footprint.

Deliberation Time Controls

Tests cover both conventional per-move time limits and fixed search limits to observe search scaling:

Conventional (Per-Move): 1s, 3s, 5s, 7s, 10s, and 60s deliberation limits.
Fixed Search Time (ST): Exact 0.5s and 2.0s search quotas without dynamic time management.
Search Verification: Testing search depth growth from ~8-10 plies (1s) to ~14-16 plies (60s).

Report Purpose

Systematic quantitative validation of Mite's compact C codebase:

Search Pipeline Safety: Verifying Null-Move Pruning (NMP) and Late Move Reductions (LMR) without tactical horizon collapses.
Evaluation Tuning: Material balance, pawn structures, and piece-square table weights.
Stability Audit: Proving zero illegal moves, memory leaks, or crashes over thousands of games.

2. OVERALL AGGREGATE RESULTS

2,600 games across 13 match series.

Summary metrics compiled directly from 13 completed 200-game match series. Standard chess scoring: 1.0 point per win, 0.5 points per draw, 0.0 per loss.

Total Match Games 2,600 13 series · 200 games each

Overall Match Score 78.5% 2,040.5 / 2,600 total points

Total Wins (+) +1,947 74.9% overall win frequency

Total Losses (−) 466 17.9% overall loss frequency

Total Draws (=) 187 7.2% overall draw frequency

Technical Stability 100% 0 crashes · 0 forfeits · 0 illegal

White Performance 80.3% +1,001 −213 =86 (1,300 g)

Black Performance 76.7% +946 −253 =101 (1,300 g)

Aggregate Performance Breakdown by Opponent

Opponent Engine	Match Series	Games	Wins (+)	Draws (=)	Losses (−)	Score %	White Record (% W)	Black Record (% B)	Color Bias
TSCP Tom's Simple Chess Program v1.81	8	1,600	+1,356	=105	−139	88.0%	+684 −68 =48 (88.5%)	+672 −71 =57 (87.6%)	+0.9% White
Stockfish (2000 Elo) Stockfish with UCI_Elo limit = 2000	3	600	+345	=34	−221	60.3%	+181 −99 =20 (63.7%)	+164 −122 =14 (57.0%)	+6.7% White
Fairy-Max Fairy-Max 5.0b micro-engine	2	400	+246	=48	−106	67.5%	+136 −46 =18 (72.5%)	+110 −60 =30 (62.5%)	+10.0% White
Total / Overall Benchmark	13	2,600	+1,947	=187	−466	78.5%	+1,001 −213 =86 (80.3%)	+946 −253 =101 (76.7%)	+3.6% White

3. OPPONENT BENCHMARK TABLES

Verified match series by opponent.

Separate, detailed match tables for Stockfish (2000 Elo), TSCP, and Fairy-Max. Each row documents exact game counts, win/loss/draw records, color splits, estimated rating differential with 95% confidence intervals, and PGN logs.

Stockfish (2000 Elo) 3 Match Series · 600 Games

Engine: Stockfish · Configuration: UCI_LimitStrength=true, UCI_Elo=2000 · Platform: x64 Standalone

Aggregate: 60.3% Score

Record: +345 −221 =34

Time Control	Games	Wins (+)	Draws (=)	Losses (−)	Score %	White / Black Score	Elo Diff (±95% CI)	LOS %	PGN Archive
Aggregate (3 Matches)	600	+345	=34	−221	60.3%	63.7% White (+181 −99 =20) 57.0% Black (+164 −122 =14)	+73.6 Elo	99.9%	Directory

Engineering Analysis vs Stockfish (2000 Elo): Across 600 games, Mite achieved a decisive positive record (+345 −221 =34, 60.3%). Most notably, Mite’s score scales upward with deliberation time: advancing from 56.3% at 1s/move (+43.7 Elo) to 58.3% at 5s/move (+57.9 Elo) and reaching 66.5% at 10s/move (+119.1 Elo, 100.0% LOS). This confirms that Mite’s search tree pruning heuristics (Null-Move Pruning, Late Move Reductions, and Quiescence search with SEE) scale soundly with additional plies of search depth without succumbing to tactical horizon blindspots.

TSCP (Tom's Simple Chess Program) 8 Match Series · 1,600 Games

Author: Tom Kerrigan · Version: v1.81 · Protocol: Text / UCI Wrapper · Historic Benchmark: ~1700–1800 Elo

Aggregate: 88.0% Score

Record: +1,356 −139 =105

Time Control	Games	Wins (+)	Draws (=)	Losses (−)	Score %	White / Black Score	Elo Diff (±95% CI)	LOS %	PGN Archive
Aggregate (8 Matches)	1,600	+1,356	=105	−139	88.0%	88.5% White (+684 −68 =48) 87.6% Black (+672 −71 =57)	+315.4 Elo	100.0%	Directory

Engineering Analysis vs TSCP: TSCP represents the classic pedagogical baseline chess engine in computer chess literature. Across 1,600 games, Mite achieved an overwhelming 88.0% aggregate score (+1,356 −139 =105). In conventional time controls, Mite scored between 79.8% (at 5s) and 91.0% (at 60s), with an Elo differential exceeding +240 to +400 Elo. In fixed-time (st) tests, Mite scored 99.3% (st 0.5s) and 99.0% (st 2s), demonstrating Mite’s massive speed and move-ordering advantage (MVV-LVA, two-tier killer moves, history heuristic) over older alpha-beta engines.

Fairy-Max (v5.0b) 2 Match Series · 400 Games

Author: H.G. Muller · Version: 5.0b · Architecture: Compact Micro-Max Variant · Benchmark: ~1850–1900 Elo

Aggregate: 67.5% Score

Record: +246 −106 =48

Time Control	Games	Wins (+)	Draws (=)	Losses (−)	Score %	White / Black Score	Elo Diff (±95% CI)	LOS %	PGN Archive
Aggregate (2 Matches)	400	+246	=48	−106	67.5%	72.5% White (+136 −46 =18) 62.5% Black (+110 −60 =30)	+127.0 Elo	100.0%	Directory

Engineering Analysis vs Fairy-Max: Fairy-Max is famous for achieving surprisingly high chess playing strength with an extremely tiny C footprint. Testing against Fairy-Max was specifically designed to evaluate whether Mite’s under-20 KB codebase maintains positional superiority against other micro-engines. Mite recorded 67.0% at 1s/move and 68.0% at 5s/move (+123 to +131 Elo differential), establishing a consistent, reproducible performance advantage.

MASTER DATASET (ALL 13 MATCHES)

Filterable & Sortable Master Benchmark Table

Sort by column headers (click on header to toggle ascending/descending) or filter matches by opponent using the pill selectors below.

Showing 13 of 13 verified match series (2,600 games)

Opponent & Version	Time Control	Games	Wins (+)	Draws (=)	Losses (−)	Score %	White / Black Score	Archive

Standard chess score formula: Score % = (Wins + 0.5 × Draws) / Games × 100 Read raw Markdown benchmark report on GitHub →

4. INTERACTIVE VISUALIZATIONS

Comparative charts & scaling curves.

Clean, accessible vector charts rendering verified outcomes, deliberation scaling, color splits, and decisiveness breakdowns. Hover over data points and bars for precise counts.

Match Score Distribution

Wins, Draws, and Losses breakdown across opponents

Deliberation Time Scaling

Score percentage scaling as deliberation time increases (1s to 60s)

White vs. Black Color Performance

Scoring percentage when playing White versus Black across opponents

Decisiveness & Game Termination Types

Distribution of checkmates, repetitions, 50-move draws, and forfeits (2,600 games)

5. DETAILED RESULTS & STABILITY

Reliability audit & terminations.

In competitive computer chess, engine reliability is as vital as evaluation strength. An engine that crashes or plays an illegal move forfeits instantly.

Engine Crashes 0 Across 2,600 tournament games

Illegal Move Forfeits 0 100% UCI move generation accuracy

Time Forfeit Losses 0 Zero time-management overruns

Decisive Game Ratio 92.8% 2,413 wins/losses · 187 draws

Termination Category	Games Count	Percentage	Technical Notes
Mite Checkmate Wins	1,944	74.8%	Verified clean king checkmates delivered by Mite
Checkmate Losses	466	17.9%	Defeats delivered by opponent engines (Stockfish 221, TSCP 139, Fairy-Max 106)
Threefold Repetition Draws	74	2.8%	Draw claimed by threefold board repetition via Zobrist key history
Insufficient Material Draws	54	2.1%	KvK, KvK+N, KvK+B endgames resolved by referee
Fifty-Move Rule Draws	29	1.1%	50 consecutive moves without pawn advance or piece capture
Stalemate Draws	4	0.2%	Legal stalemate verified by referee
Opponent Time Forfeits (Mite Wins)	3	0.1%	2 by Stockfish at tc10; 1 by Fairy-Max at tc1
Total Tournament Games	2,600	100.0%	13 Completed Series · Alternate Colors

Raw PGN Match Records in Repository

All 2,600 games are committed as open-source PGN files in the official GitHub repository for complete independent auditing, opening replay, and analysis:

vs Stockfish (2000 Elo)

vs TSCP v1.81 (1,600 games)

vs Fairy-Max 5.0b (400 games)

6. METHODOLOGY & LIMITATIONS

Testing conditions & statistical rigor.

Responsible benchmarking requires documenting testing hardware, tournament protocols, mathematical definitions, and technical limitations.

Tournament Execution Protocol

All matches were executed using Cutechess-cli with strict protocol enforcement:

Alternate Colors: Engines alternated White and Black every game to neutralize first-move advantage.
Equal Deliberation: Opponents shared identical time allocations under single-thread CPU scheduling.
Transposition Tables: 16 MB default hash table (2²⁰ entries) with 64-bit Zobrist indexing.
Zero External Books: Engines calculated exclusively from the standard initial chess array.

Standard Formulas

Scores and rating differences are computed using standard computer chess mathematics:

Score %: (Wins + 0.5 × Draws) / Games × 100
Elo Difference: Calculated using the logistic Elo equation ΔElo = -400 × log10(1/Score - 1) with 95% confidence intervals.
Likelihood of Superiority (LOS): Probability that Mite is genuinely stronger than opponent based on game distribution.

Compilation Environment

Standard ANSI C99 compilation pipeline:

Compiler: GCC / MinGW-w64 with -O3 -march=native optimization flags.
Binary Footprint: ~115 KB static standalone Windows executable.
Source Constraints: Under 20 KB source across ~409 lines in src/Mite.c.
Dependencies: Zero third-party runtime libraries or external DLLs.

Explicit Testing Limitations & Scientific Integrity

1. Internal Estimate, Not Certified List Rating: Mite’s estimated ~2000 Elo playing strength is an internal benchmark calibrated from controlled matches against Stockfish (UCI_Elo = 2000). It is not an official rating issued by CCRL (Computer Chess Rating Lists), CEGT (Chess Engine Games Tournament), or FIDE.

2. No Opening Book: Because games began without an opening book, matches began from the standard chess starting position (1.e4 or 1.d4). While this evaluates pure internal search and piece-square evaluation, engines in rating lists typically test against diverse opening books (e.g. 8-ply balanced opening books) to prevent repeated pawn transposition lines.

3. Artificial Handicap Opponents: Stockfish’s UCI_LimitStrength mechanism handicaps play by introducing controlled search limits and evaluation noise. While widely used as a reproducible rating anchor, it does not perfectly mimic human or organic rating pool engine behavior.

4. Independent Testing Welcome: We invite chess programmers and rating list operators to benchmark Mite in independent rating pools. Mite is UCI compliant and ready to load into Arena, Cutechess, BanksiaGUI, or automated testing rigs.

REPRODUCE & TEST

Test Mite in your own GUI.

Download the ~115 KB standalone binary or inspect the single-file C source code. Run your own tournament series in Arena, Cutechess, or BanksiaGUI.

Download Mite.exe (~115 KB) Setup & Testing Guide → ← Return to Mite Home