Overview
Rookie Engine is a high‑performance C++ UCI chess engine built with a focus on speed, modularity, and clarity. It demonstrates how a modern engine can be designed around bitboards, efficient search algorithms, and clean architecture suitable for fullstack integration.
Goal
Build a strong, practical engine with a clean, modular architecture — easy to understand, easy to extend, and easy to connect to modern backends and frontends.
Tech Stack
- C++: Core engine, bitboards, move generation, evaluation, search.
- CMake: Build system and project structure.
Move Generation
Rookie Engine uses a fully bitboard‑based move generator. All attacks are computed using precomputed masks and optimized sliding algorithms, giving predictable branching and high performance.
- Bitboards: 64‑bit representation for pieces and occupancy.
- Sliding attacks: Optimized rook, bishop, and queen attack generation.
- Precomputed tables: Knight, king, and pawn attacks stored in lookup tables.
- Legal filtering: Ensures the king is never left in check.
Evaluation
The evaluation combines classical heuristics with lightweight positional scoring. Material, piece‑square tables, king safety, mobility, and pawn structure form the core of the model.
- Material: Phase‑based piece values.
- PSTs: Placement bonuses for all pieces.
- King safety: Pawn shields, open files, exposure.
- Pawn structure: Passed, isolated, doubled pawns.
- Mobility: Active pieces and square control.
Search
Rookie Engine uses iterative deepening alpha‑beta search with a transposition table. Move ordering and pruning significantly reduce the search tree.
- Alpha‑beta: Core pruning algorithm.
- Iterative deepening: Reuses information across depths.
- Transposition table: Zobrist hashing for fast lookups.
- Move ordering: PV, captures, killers, history.
- Quiescence: Extends tactical positions.
Results
Rookie Engine achieves strong practical play and integrates cleanly with UCI‑based GUIs and backends. Its modular architecture makes it ideal for experimentation, teaching, and future expansion.
What I Learned
Building the engine deepened my understanding of bitboards, search algorithms, evaluation design, and performance optimization. It also reinforced the value of clean architecture and modular design.