About

About Me

My name is Oleh Sych. I'm a software engineer with a long-standing interest in chess and a growing fascination with how chess engines work at a technical level.

VeryChess is a personal project where I combine programming and chess into a single pursuit: building an engine from scratch, testing it systematically, performing comparision of chess engines publicly.

Programming Background

I have been working in software development professionally over 25 years, with experience across different areas of engineering. Building a chess engine has turned out to be one of the most interesting technical challenges I have taken on — it combines algorithm design, performance optimisation, and careful testing in a way that most projects don't.

Chess engine development requires thinking carefully about search algorithms, evaluation accuracy, move ordering, and time management. Each of these is a solvable engineering problem, and I find that appealing.

Chess Background

I am an adult chess improver. I came to chess seriously as an adult and have been working on my game steadily since then. I play online regularly and try to study positions and endgames when time allows.

What drew me to engine development is partly the question of measurement — an engine gives you a way to observe chess strength objectively through testing rather than subjectively through intuition. That appeals to the engineer in me as much as the chess player.

Why VeryChess?

I started VeryChess because I wanted to understand how chess engines actually work — not just at a high level, but in detail: how moves are generated, how the search tree is pruned, how evaluation translates positions into numbers, and how time is managed under tournament conditions.

Building from scratch forces you to understand every part of the system. The project is documented publicly because I believe honest reporting of results — including losses — is more interesting and more useful than polished marketing.

The name is deliberately modest. VeryChess is just a chess engine project. Whether it eventually becomes "very" good is something the tournaments will decide.

VeryChess Engine — General Description

VeryChess is a UCI chess engine written in C++20, targeting native compiled binaries for macOS (ARM64 primary), Linux, and Windows. It's a classical alpha-beta engine with a hand-designed, automatically-tuned evaluation — no neural networks, no third-party dependencies, standard library only.

VeryChess is not a clone of any popular engine, but it is also not novel — it's a clean, conventional, correctly-built classical engine. Its DNA is the Chess Programming Wiki + Stockfish convention set, and its architecture mirrors didactic engines like VICE/CPW-engine (independently written). Its evaluation started from the well-known Michniewski Simplified Evaluation tables, but since version 0.6.0 every weight has been replaced by values fit with an in-house Texel-style tuner against millions of self-play positions.

The core is iterative deepening + negamax alpha-beta with this full set of techniques:

Search:

• Aspiration windows: root iterations searched in a narrow window around the previous score, widening on fail-low/fail-high;
• PVS (Principal Variation Search): full window on first move, null-window scout on the rest, verified through a three-level re-search (reduced → full-depth → full-window);
• Transposition table: 4-way clustered (one cache line per index), depth+age replacement; probed for cutoffs and move ordering in both the main and quiescence search;
• Null-move pruning: R=2–3, disabled in PV / in check / zugzwang-risk (no non-pawn material);
• Late move reductions: depth- and move-number-scaled table, reduced further for high-history quiet moves, applied cautiously inside PV nodes;
• Late move pruning: skips late, quiet, non-tactical moves entirely at shallow depth;
• Reverse futility pruning: skips a node outright when the static evaluation already clears the window by a depth-scaled margin;
• Internal iterative reduction: searches a node one ply shallower first when the transposition table holds no move for it, to improve move ordering before the full search;
• Singular extensions: extends the transposition-table move one ply deeper when it is verified to be the only good move at a node, and reduces it one ply when the verification proves the opposite;
• Check extensions: +1 ply when a move gives check;
• Mate-distance pruning: tightens the alpha/beta window;
• Staged move generation: moves are produced lazily (TT move → good captures → promotions → killers → quiet moves → losing captures) instead of being generated and scored all at once;
• Quiescence search: captures-only with stand-pat, delta pruning and SEE-based pruning of losing captures, and its own transposition-table probing/storing;
• Move ordering: TT move → SEE/MVV-LVA captures → killer moves → history heuristic;
• Draw detection in search: 50-move rule + repetition via the hash history.

Evaluation:

• Tapered, component-based scoring: interpolated between middlegame and endgame values by a game-phase measure;
• Full mobility: knights, bishops, rooks, and queens scored by safe reachable squares, restricted along the ray when a piece is pinned;
• Passed pawns and pawn structure: isolated, doubled, and connected pawns;
• Rook bonuses: on open and half-open files;
• King safety: a tuned attacker-count danger table and an open-file penalty near the king;
• Endgame scaling: pulled toward a draw for dead-drawn or reduced-material configurations (opposite-colored bishops, lone minor, KNNvK, and similar).

Endgame knowledge: an exhaustively generated KPK bitbase (verified against an independent reference over all legal positions) and a KBNvK mating technique, both embedded with no external files, for positions no practical search depth can convert on its own.