BitChess Engine

A Pure Algorithmic Chess Engine

Chess Engine Overview

BitChess is a high-performance chess engine developed as a hobby project to explore low-level optimization techniques and algorithmic game theory. The engine uses traditional, non-AI approaches to chess programming, focusing on efficient data structures, multithreaded search, and careful optimization of critical paths.

This project demonstrates how far a pure algorithmic approach to chess can go without relying on neural networks or machine learning techniques that dominate modern engines like Stockfish, Leela Chess Zero, or AlphaZero.

Motivation

The primary goals of this project are:

• Deepen understanding of bitboard representations and bit manipulation
• Master low-level optimization techniques in C
• Explore multithreaded search algorithms
• Build an efficient, pure algorithmic chess engine from scratch
• Benchmark algorithmic approaches against more modern techniques

Key Features

• Bitboard-based representation for maximum performance
• Alpha-beta pruning with move ordering for efficient search
• Multithreaded search to utilize multi-core processors
• Position evaluation using piece-square tables and material value
• Clean terminal interface that updates in real-time
• Standard Algebraic Notation (SAN) support for move representation

Technical Approach

Board Representation

The engine uses bitboards (64-bit unsigned integers) to represent the chess position, where each bit corresponds to a square on the board. This approach allows for extremely fast position updates and move generation using bitwise operations.

Bitboard for White Pawns (P): 0x000000000000FF00

    ----------------
8 | . . . . . . . . |
7 | . . . . . . . . |
6 | . . . . . . . . |
5 | . . . . . . . . |
4 | . . . . . . . . |
3 | . . . . . . . . |
2 | P P P P P P P P |
1 | . . . . . . . . |
    ----------------
    a b c d e f g h

Search Algorithm

BitChess employs a classic Minimax algorithm with Alpha-Beta pruning to search the game tree efficiently. The engine implements:

• Move ordering to maximize alpha-beta cutoffs
• Multithreaded search at the root node to parallelize evaluation
• Iterative deepening to find good moves quickly
• MVV-LVA (Most Valuable Victim - Least Valuable Aggressor) for capture ordering

Evaluation Function

The evaluation combines several components:

• Material balance - basic piece values (pawn=100, knight=320, etc.)
• Piece-square tables - bonuses/penalties for piece positioning
• Mobility - counting legal moves as a proxy for piece activity
• King safety - evaluating the king's defensive structure

Move Generation

The engine generates moves using precomputed attack tables:

• Sliding pieces (bishops, rooks, queens) - using ray attacks
• Knights and kings - using precomputed attack patterns
• Pawns - handling special moves like promotions, en passant, and double pushes

Implementation Details

BitChess is written in C and designed with modularity in mind:

• Bitboard module - manages attack tables and bit manipulation
• Board module - handles game state and move application
• Movegen module - generates legal moves
• Evaluation module - assesses positions
• Search module - finds the best move
• Notation module - converts between internal move representation and SAN

Performance Considerations

Several optimizations are implemented:

• Precomputed attack tables - eliminate expensive calculations during search
• Move ordering - dramatically improves alpha-beta pruning efficiency
• Multithreading - utilizes all available CPU cores
• Bit manipulation - uses built-in popcount and bit-scan operations
• Structure organization - designed to maximize cache efficiency

Current Capabilities

The engine currently:

• Implements all chess rules correctly, including castling, en passant, and promotions
• Searches at configurable depths with reasonable performance
• Uses multiple threads to speed up search
• Displays evaluation in centipawns
• Provides a clean terminal interface

Future Improvements

Planned enhancements include:

• Transposition tables to avoid re-searching identical positions
• Quiescence search to resolve tactical sequences
• Opening book for stronger play in the early game
• Endgame tablebases for perfect play in simplified positions
• UCI protocol support for compatibility with chess GUIs
• Performance profiling and further optimization

Building and Running

Clone the repository

git clone https://git.srtk.in/sarthak/bitchess.git
cd bitchess

Build the project

make

Run the engine

./build/bin/bitchess

Requirements

• GCC or Clang compiler with C99 support
• POSIX-compliant operating system (Linux, macOS, or Windows with WSL)
• pthread library