Ended Bitboard engine, what's next?

Nicholas — Tue, 30 Jun 2026 21:16:27 +0000

Hey guys ;)

Today I finally finished my bitboard engine! Let me take you through its architecture, and then we'll explore the next steps.

The Core Architecture

All the engine logic lives in bitboard_engine.py, which contains the Move and BitboardEngine classes. However, for everything to sync up, we rely on a few other modules: board.py (with the Board class), move_gen.py (with AttackTables), and bitboard_utils.py (housing BitboardConstants).

Here is a breakdown of what each component does:

BitboardConstants: Contains static methods for fundamental bitwise operations like setting, popping, or getting a bit (set_bit, pop_bit, get_bit), along with constant masks for the board edges (like the A/H files or ranks 1/8).
Board: Implements the state of all pieces on the board, handles the initial setup, and tracks tracking piece movements.
AttackTables: Pre-computes static attack tables for knights and kings, and builds sliding attack tables for rooks, bishops, and queens using magic numbers.
Move: Describes individual moves, storing data like piece_moved, piece_captured, and flags for special moves (is_enpassant, is_castling, is_promotion). It also handles dictionaries for correct chess notation.

The Heart of the Engine

BitboardEngine is where all these components unite. The core functionality is split into two types of functions:

Move Generation: The get_valid_moves function generates legal moves using complex bitwise masking (check masks, pin masks, enemy attack masks, and edge masks).
State Management: Functions responsible for tracking the game state (like checkmate or draws) and preparing data for the future RL model.

Honestly, this was one of the hardest parts of the project due to the sheer amount of math and theory involved, but the performance payoff compared to the matrix engine will be massive.

What's Next?

Next, I’m going to write two "bridge" functions to map bitboard indices back to the matrix format for the UI. After that, it’s time for rigorous testing. To be honest, I won't rest easy until I test it thoroughly—especially regarding special moves and check detection states.
Once the tests pass, the Reinforcement Learning phase officially begins!

Thanks for reading! If you have any questions or suggestions about magic numbers or bitboard optimization, let's chat in the comments below!

#python #chess #bitboards #showdev

My first post

Nicholas — Sat, 27 Jun 2026 19:42:20 +0000

Hey everyone, it’s my first post here ;)

Today I want to show you the project I’m currently working on. It’s Chess Project X (available as chess-project on GitHub). The development is divided into two main milestones.

Milestone 1: The Matrix Engine & UI

The first step was creating a basic chess engine from scratch along with a graphical interface. I built the initial core using matrix logic in pure Python and used the Pygame library for the UI. It includes all the neat features I personally enjoy on Chess.com: analysis arrows, highlighted squares, visual move hints, and even the native sound effects.
For the AI at this stage, I implemented a classic Minimax algorithm with Alpha-Beta pruning running at a maximum depth of 4.
Check video of gameplay on X:
// Detect dark theme var iframe = document.getElementById('tweet-2046898283264495656-673'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2046898283264495656&theme=dark" }

Milestone 2: Transitioning to Bitboards & RL

The ultimate goal is to implement a Reinforcement Learning (RL) agent. Doing this on top of a matrix-based engine would be heavily bottlenecked by performance, so I decided to rewrite the entire engine using bitboards.
Current state of the rewrite:

Implemented a new Board class.
Wrote basic bitwise utility functions (set_bit, get_bit, pop_bit).
Generated pre-computed attack masks for every piece type. For the last two days, I’ve been heavily focused on the move validation logic. There are two ways to find legal moves:
The Matrix Way: Execute make_move, check if the king is under attack, and then undo_move. It's easy to code but much slower.
The Bitboard Way: Generate all possible pin and check masks via bitwise operations. It's significantly harder to implement, but the performance payoff is massive. Right now, I've finished the logic for the king and knights. Next up: rooks, bishops, queens, and pawns. Once done, I’ll hook it up to the Pygame UI, run tests, and finally start training the RL model!

I hope you found this breakdown interesting! If you have any questions, tech suggestions, or ideas about bitboards, feel free to drop them in the comments below. See you in the next update!

#python #chess #reinforcementlearning #bitboards

DEV Community: Nicholas