Hello everyone!
My project has finally been released—a project whose first version I imagined almost 30 years ago. That is approximately how long I have been interested in computer chess and experimenting with the idea of creating my own chess engine.
I first became fascinated by computer chess as a teenager. I read extensively about the first World Computer Chess Championship, which was won by the Soviet chess program Kaissa. I studied practically all the literature available to me at the time about how chess programs worked, and soon began conducting my own experiments.
Over the years, my knowledge evolved, computer technology changed dramatically, and so did my access to it.
I started writing my first chess program in BASIC on a Soviet computer powered by a KR580VM80A processor, an analogue of the Intel 8080. Later, I moved to Turbo Pascal on an Intel 486DX machine, and eventually to Delphi, which remained my main environment for chess-programming experiments for many years.
An enormous amount of time went into experimenting with minimax, position evaluation, tree traversal, time management, and many other aspects of chess-engine development. However, all those early versions were unstable, weak, and full of different kinds of bugs. None of them was ever ready to be released to the public.
Recently, I returned to the project once again, this time with a completely updated technology stack.
VeryChess is now written in C and C++ for macOS as a personal pet project. The extensive test infrastructure is written in Python—and there are already a great many tests. The engine now uses a much broader range of algorithms, and I also make extensive use of AI tools for code generation, debugging, analysis, and automation. This has accelerated the development process considerably.
In that sense, the VeryChess engine is the result of several decades of experimentation, frustration, learning, and persistence. At the same time, the current implementation—the actual codebase in the form in which it exists today—was developed during the last six months.
I expect that readers may have many questions about the engine and its source code, so I will try to answer the most obvious ones.
1. Why Is VeryChess Not Open Source?
I may decide to publish the VeryChess source code in the future, but I am not ready to do so yet.
First, I am still somewhat embarrassed to show the code publicly because I consider many parts of it unfinished, rough, and occasionally quite “dirty.” The engine is evolving quickly, and some areas still need substantial refactoring.
Second, it is emotionally difficult to simply give away something that has occupied my thoughts and experiments for several decades.
Perhaps this will change later—especially if VeryChess begins to demonstrate respectable results. At that point, I may decide that publishing the source code would be useful to other developers and to the computer-chess community.
For now, however, the project remains closed source.
2. Is the Source Code Unique?
The hand-written C++ implementation is original. The underlying data, algorithms, and conventions are not—and they were never intended to be.
VeryChess is a conventional classical bitboard chess engine. Almost every major structural decision belongs to a shared collection of techniques widely used throughout the hobby-engine and computer-chess community. These conventions are thoroughly documented in resources such as the Chess Programming Wiki and can also be observed in engines such as Stockfish and many educational projects.
The actual implementation—the way the code is organised and written—is my own. However, some constant tables are taken almost verbatim from public reference sources. This is common and generally accepted in this class of engine, but it also means that those parts cannot be described as unique.
The closest literal reuse comes from Tomasz Michniewski’s Simplified Evaluation Function, published through the Chess Programming Wiki. VeryChess uses its well-known piece-square tables and the classical material values:
- Pawn: 100
- Knight: 320
- Bishop: 330
- Rook: 500
- Queen: 900
Approximately 85–95% of the current basic evaluation constants correspond directly to those reference tables.
The move representation follows the standard Chess Programming Wiki encoding model:
from | to << 6 | flag << 12It uses 16 move flags, from quiet moves to captures, promotions, castling, and en passant. The general design is shared, while the implementation itself was written independently.
VeryChess also follows many familiar Stockfish and Chess Programming Wiki conventions:
Bitboardrepresented asuint64_t- squares enumerated from A1 to H8
- compact bitboard helper functions such as least-significant-bit extraction
- fixed-size move lists
- position-state history structures
- mate-score correction when storing and retrieving values from the transposition table
These are shared conventions rather than copied implementations.
The overall search architecture is also similar to many educational engines and tutorials, including VICE and CPW-engine:
- iterative deepening
- negamax
- alpha-beta pruning
- principal variation search
- null-move pruning
- late-move reductions
- killer moves
- history heuristics
- MVV-LVA move ordering
- quiescence search
This makes VeryChess conceptually similar to dozens of classical didactic engines. However, the algorithms were implemented independently rather than copied from a particular project.
VeryChess also uses classical ray-based sliding attacks rather than magic bitboards, which makes this part conceptually similar to engines such as TSCP and many early educational chess programs.
The king-safety evaluation follows the traditional “attack units converted into a non-linear penalty” model associated with the Glaurung and Chess Programming Wiki lineage. The concept is established, although the exact values and the way the components are combined in VeryChess are my own.
A Rough Reuse Estimate
There is no single engine from which a substantial portion of VeryChess was copied.
The most recognisable reused material consists of:
- the Michniewski evaluation tables
- the standard move-encoding scheme
- common bitboard and search-engine conventions
Conceptually, the engine shares much of its architecture with educational engines such as VICE, CPW-engine, BBC by Maksim Korzh, and many others.
If I had to express it as a single approximate number, I would estimate that around 10–15% of the codebase contains recognisably borrowed material, primarily evaluation data, encoding conventions, and standard idioms.
The remaining 85% or more is my own implementation.
3. What Is Unique About VeryChess?
VeryChess does not attempt to introduce a completely new theory of computer chess. Its originality lies primarily in the implementation and in the way several established ideas are combined.
The genuinely original parts include the following.
The C++ Implementation
The engine code itself was written specifically for VeryChess. Although it follows familiar patterns, the organisation, abstractions, data structures, and implementation details are my own.
King-Safety Evaluation
VeryChess uses an inner and outer king-zone model with a two-rank forward extension. Attacks within the inner zone receive double weight.
This is combined with penalties for open or semi-open files near the king. These penalties depend partly on whether the king appears to have castled, based on its location on the queenside or kingside.
The individual ideas are not new, but this particular combination and weighting model are my own composition.
Endgame King-Driving Evaluation
The engine includes a hand-written endgame term intended to help convert positions with a decisive material advantage.
It combines:
- Manhattan distance between the kings
- pressure that drives the defending king toward the edge of the board
- activation only when one side has a sufficiently large non-pawn-material advantage
This is primarily a practical mate-conversion helper rather than a theoretically sophisticated endgame model.
4. How Does VeryChess Differ from Strong Modern Engines?
VeryChess is a classical engine, and it differs substantially from modern top-level engines such as Stockfish.
No Magic Bitboards or PEXT
VeryChess currently uses classical ray-fill attack generation for bishops, rooks, and queens.
Most high-performance engines use magic bitboards, PEXT-based lookup tables, or similarly optimised techniques. This is probably one of the largest current performance gaps between VeryChess and stronger engines.
No NNUE and No Tapered Evaluation
VeryChess uses a single hand-crafted evaluation function.
It does not currently use NNUE, and it does not smoothly interpolate between middlegame and endgame evaluation. Instead, it uses a relatively simple endgame switch based on the total remaining non-pawn material.
Modern engines typically use NNUE or, in classical evaluation systems, a tapered evaluation that gradually blends middlegame and endgame scores.
A Simple Transposition Table
The current transposition table uses one entry per index:
index = key % table_sizeThis is the simplest practical design.
Stockfish and other advanced engines use clustered or bucketed transposition tables with more sophisticated replacement strategies.
No Staged Move Generation
VeryChess currently generates all legal or pseudo-legal moves and then sorts them.
Stronger engines usually generate moves in stages—for example, hash moves first, then captures, killer moves, and quiet moves. This avoids generating or sorting moves that may never need to be searched.
Conclusion
VeryChess is not a clone of any well-known engine, but it is not an attempt to reinvent computer chess either.
It is a conventional, classical bitboard engine built using established techniques from the Chess Programming Wiki, educational chess engines, and the broader computer-chess community.
Its evaluation tables have their roots in Michniewski’s Simplified Evaluation Function. Its overall search architecture resembles engines such as VICE and CPW-engine. Its data types, move encoding, and internal conventions belong to the same tradition used by many modern engines.
At the same time, the implementation is my own, and several evaluation components—particularly the king-safety and endgame king-driving models—represent my personal approach to combining these established ideas.
Most importantly, VeryChess is the first version of my chess-engine project that has finally reached the outside world.
It took nearly 30 years of ideas, abandoned versions, technical experiments, programming languages, hardware generations, mistakes, and renewed attempts to reach this point.
The current engine is still young. It is imperfect, sometimes slow, and undoubtedly contains many things that will need to be rewritten.
But this time, it exists.
And this time, it has been released.