COMPACT CHESS ENGINE · WRITTEN IN C

Small source.
Serious chess.

Mite is a lightweight chess engine written in C, built around a simple goal: deliver a playable, UCI-compatible engine targeting ~2000-Elo-class strength with a remarkably compact codebase of under 20 KB source code and a ~115 KB standalone binary.

Play Mite Live Explore on GitHub
Language Written in C
Protocol UCI compatible
Source Size < 20 KB source
Distribution Windows (~115 KB)
Position Preview eval +1.84 · depth 18/24
e4 Hover or click any square to inspect
Mite tactical initiative
OVERVIEW & ARCHITECTURE

An engine built with constraints in mind.

Mite demonstrates that high playing strength does not require hundreds of thousands of lines of code. By combining efficient algorithmic density with strict memory constraints, it provides a tournament-ready engine in a single C source file.

Developed by Viraj Ravani, Mite was conceived as an engineering study in minimalism: how much chess intelligence can be packed into a single C file without relying on external dependencies or compromising search depth?

The engine operates strictly through the Universal Chess Interface (UCI) standard protocol. Rather than embedding a proprietary user interface, Mite connects directly over standard input and output (stdin / stdout) to established chess GUIs like Arena, Cutechess, and BanksiaGUI, as well as automated tournament managers.

“Every heuristic in Mite is evaluated for its algorithmic density: maximum tactical value per byte of compiled code.”

The complete engine source code is contained in src/Mite.c, measuring approximately 19.7 KB across ~409 lines. When compiled with optimization, it produces a standalone Windows binary of approximately 115 KB requiring zero runtime DLLs, and a ~60 KB WebAssembly module for instant in-browser play.

Mite Logo Engine Specifications
ANSI C / C99
Project Mite Chess Engine
Author Viraj Ravani
Language ANSI C (C99 standard compatible)
Protocol UCI (Universal Chess Interface)
Source Size < 20 KB (19.7 KB, ~409 lines in src/Mite.c)
Binary Size ~115 KB static executable (bin/Mite.exe)
Board Rep. 0x88 coordinate system with O(1) bounds checks
Search Depth Iterative Deepening up to 24 plies with PVS
Hash Table 16 MB default (2²⁰ entries, 64-bit Zobrist)
Platforms Windows (x64), POSIX / Linux, WebAssembly
License MIT License
ENGINE CAPABILITIES

Engineered for density and speed.

Every component in Mite is verified against the actual source implementation in src/Mite.c. No fabricated capabilities or unverified heuristics.

Compact Single-File C Implementation

The entire engine is implemented in a monolithic C file under 20 KB. Move generation, 0x88 board state, evaluation tables, iterative deepening, and UCI communication run without external dependencies or auxiliary data files.

src/Mite.c · 19.7 KB · ~409 lines
// 0x88 board representation & move generator
#define IS_ON_BOARD(sq) (!((sq) & 0x88))

int search(int alpha, int beta, int depth) {
  if (depth <= 0) return quiesce(alpha, beta);
  // PVS, Transposition Table probe, NMP, LMR
  ...
}

Standard UCI Protocol Compliance

Full compliance with the Universal Chess Interface standard enables instant integration into Arena, Cutechess, BanksiaGUI, and Fritz via standard I/O streams.

stdin / stdout communication

Advanced Search & Pruning

Negamax search with Principal Variation Search (PVS), iterative deepening to 24 plies, aspiration windows (±65), Null-Move Pruning, and SEE-guided quiescence.

PVS · NMP · LMR · Quiescence

Handcrafted Static Evaluation

Carefully tuned evaluation combining packed piece-square tables, pawn structure, rook open files, king safety penalties, knight outposts, and endgame king-opposition heuristics.

Material + Piece-Square Tables

Browser WebAssembly Build

Compiled to a lightweight ~60 KB WASM module running in a dedicated Web Worker on Hugging Face Spaces, sustaining 800,000 to 1,500,000 nodes per second.

mite.wasm (~60 KB)

Zero-Dependency Distribution

Precompiled standalone 64-bit Windows binary (~115 KB) with zero external runtime DLL requirements. Drop it straight into any chess GUI and begin play immediately.

bin/Mite.exe (~115 KB)

Audited Match Records & Docs

Includes all 2,600 raw tournament PGN match records, an exhaustive 2,200-line architectural guide, Makefile scripts, and reproducible benchmark testing pipelines.

2,600 Verified PGN Records
VERIFIED TOURNAMENT BENCHMARKS

Performance, measured carefully.

Engine strength depends on opponents, hardware, time controls, and test conditions. Benchmark results are meaningful only when their methodology is clear.

Methodology & Rating Clarification: All benchmark data is derived from 13 automated match series (2,600 games) using alternate-color pairings (100 as White, 100 as Black per 200-game match). 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, or FIDE rating list.
Total Match Games 2,600 Across 13 match series
Overall Match Score 78.5% +1,947 −466 =187
Stability Record 0 / 0 / 0 0 crashes · 0 forfeits · 0 illegal
Color Performance 80.3% / 76.7% White (+1001) / Black (+946)

Match Score Distribution

Aggregate game outcomes (Wins, Draws, Losses) across opponents

Performance Across Time Controls

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

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
View full interactive 2,600-game tournament benchmark report → Raw GitHub report →
DISTRIBUTION & DOWNLOADS

Get Mite.

Choose how you want to experience Mite: run the standalone Windows binary, inspect and compile the C source code, or play immediately in your browser.

Standalone Binary

Windows Executable

Precompiled 64-bit static executable. Completely self-contained with zero runtime dependencies. Ready to install into Arena, Cutechess, or BanksiaGUI.

File Mite.exe
Platform Windows x64
Binary Size ~115 KB
Download Mite.exe (~115 KB)
Source Code

C Source Repository

Complete ANSI C99 source code in a single file under 20 KB. Fully readable, inspectable, and portable across GCC, Clang, and MSVC compilers.

File src/Mite.c
Source Size < 20 KB (19.7 KB)
License MIT Open Source
Explore on GitHub
WebAssembly

Play in the Browser

Experience Mite live with zero local installation on Hugging Face Spaces. Powered by Mite compiled directly to WebAssembly in a dedicated Web Worker.

Platform Modern Web Browser
Engine Module mite.wasm (~60 KB)
Throughput 800k–1.5M nodes/sec
Play on Hugging Face
INTEGRATION & USAGE

How to play and test Mite.

Mite is a pure UCI engine that communicates over standard input and output. It does not provide an internal GUI, but integrates seamlessly into all major chess interfaces.

Play Instantly in Your Browser

01.
Open the official Hugging Face Space in any desktop or mobile browser.
02.
Select your preferred time control: Bullet (1+0, 1+1), Blitz (3+0, 3+2, 5+0, 5+3), or Rapid (10+0, 15+10).
03.
Choose your side (White, Black, or Random) and start moving pieces on the board. The engine runs locally on your device via WebAssembly.
CREDITS & AUTHOR

Built by an independent developer.

Mite is an independent chess-engine project exploring what can be achieved with a compact C implementation.

Viraj Ravani

Creator and Developer

Viraj is a developer specializing in systems programming, algorithmic efficiency, and interactive web tools. Mite represents an ongoing effort to push the boundaries of algorithmic density in chess computing.

Portfolio (virajravani.in) GitHub Profile LinkedIn
Independence & Licensing

Mite is licensed under the terms of the MIT License. Reference engines (Stockfish, TSCP, Fairy-Max) are trademarks and intellectual property of their respective creators. Mention does not imply affiliation or official endorsement.