MagicTree LogoMagicTreeBack to Home
Development History

MagicTree History

A personal computer-chess project that grew from a learning move generator into a classical C++ UCI engine.

~2650-2700
Estimated blitz strength

Approximate private-testing range, not an official rating.

1 CPU
Single processor

Current public release uses single-threaded search with no multithreading.

PEXT
Attack backend

BMI2/PEXT-based sliding attacks on modern 64-bit CPUs.

HCE
Evaluation

Handcrafted tapered evaluation with no NNUE or external eval file.

Background

My interest in computer chess started in my teens. Around 2004, I began following and participating in discussions on TalkChess / CCC, while keenly watching the development of engines such as Fruit, Rybka, and later Stockfish.

Those years created a long-running interest in how chess engines think: move generation, search, evaluation, time management, and the trade-off between speed and chess knowledge.

The project began long before the first public MagicTree release. Its earliest roots were a simple mailbox-array move generator written as a learning project. That early work was set aside for several years, but the ambition to build a personal chess engine remained.

The project was later revived, first under the name VihaaChess, and eventually evolved into MagicTree.

The project originally began under the name VihaaChess, named after my daughter, Vihaa. As the engine matured from a learning project into a more serious C++ UCI chess engine, I wanted a name that reflected both the technical and creative side of computer chess. In chess-engine search, every position grows into a tree of candidate moves, variations, branches, and hidden tactical possibilities. The idea behind the name MagicTree is that somewhere inside that search tree, the engine is trying to find a move that creates a little bit of magic on the board.

There is also a small irony in the name: MagicTree does not actually use magic bitboards. The current engine uses a BMI2/PEXT-based sliding-attack backend instead. So the “magic” in MagicTree is not a reference to the bitboard technique, but to the aspiration behind the project — to make the engine search deeply, choose creatively, and gradually turn a tree of possibilities into strong chess moves.

Regards,
Vikrant Malvankar

Technical Profile

MagicTree is written in C++ and follows the classical handcrafted-engine path: no NNUE network, no external evaluation file, and no borrowed engine source code.

Its strength comes from bitboards, UCI support, alpha-beta search, move ordering, pruning, transposition tables, and a handcrafted tapered evaluation.

Later versions moved to a BMI2/PEXT-based sliding-attack backend, so the current release requires a modern 64-bit CPU with PEXT support.

C++ engine
UCI protocol
No NNUE file
Binary-only freeware

Development Timeline

The main stages of the project, from early move-generation experiments through the current MagicTree 3.2 release line.

Early roots

Mailbox move generator

The first stage of the project was a basic mailbox-array move generator. It was mainly a learning exercise in legal chess rules, board representation, and move generation.

Although this early version was not a public engine, it formed the seed of the project.

VihaaChess prototypes

From move generation to a working UCI engine

The next phase, preserved in the version archive as the VihaaChess minor builds, focused on building a complete working engine from the ground up.

These versions progressed from PERFT-tested move generation to legal move handling, FEN support, UCI communication, Zobrist hashing, transposition-table integration, basic search, and early evaluation.

  • -PERFT-tested move generation
  • -Basic UCI command handling
  • -Zobrist hashing and transposition-table experiments
  • -Early alpha-beta search and quiescence search
  • -Static evaluation and mate-search testing
  • -Stability fixes around legality, hashing, and move scoring
MagicTree 1.x

Stable classical-engine foundation

The 1.x line moved the project from an experimental engine into a more structured classical chess engine.

This stage introduced stronger move ordering, SEE support, repetition handling, improved time management, hash-table improvements, mate-search extensions, precomputed attack rays, LMR, futility pruning, and important en-passant correctness fixes.

MagicTree 1.7 became an important stable milestone because it combined reliable UCI operation, validated move generation, alpha-beta search, transposition tables, static evaluation, FEN support, and PERFT diagnostics.

MagicTree 2.x

Stronger search, PEXT, and evaluation work

The 2.x series was the engine's major strength-building phase. MagicTree moved toward a faster bitboard architecture with a BMI2/PEXT sliding-attack backend, improved pseudo-legal and legal move-generation flow, stronger semantic move ordering, null-move pruning, broader search and evaluation rewrites, and more serious tuning of handcrafted evaluation terms.

By the late 2.x versions, MagicTree had become a more competitive classical engine, with deeper search, richer move ordering, stronger pruning, improved quiescence search, and a more developed handcrafted evaluation.

Version 2.9 was a major internal strength step focused especially on move ordering and search heuristics.

MagicTree 3.0

First official public release

MagicTree 3.0 was selected as the first official public release and is listed on the site as released on 21 April 2026.

It packaged the engine as a free Windows x64 UCI binary and established the public baseline for the project.

  • -64-bit bitboards and UCI compatibility
  • -Full FEN and position setup support
  • -Legal move generation with castling, promotion, en-passant, check, pin, and double-check handling
  • -Iterative deepening alpha-beta search with PVS and aspiration windows
  • -Null-move pruning, reverse futility pruning, razoring, futility pruning, Late Move Pruning, Late Move Reductions, and singular extensions
  • -SEE-based capture handling and quiescence search
  • -Tapered handcrafted evaluation, Zobrist hashing, pawn hash, transposition table, time management, and PERFT diagnostics
MagicTree 3.2

Current search-heuristics release

MagicTree 3.2 is the current release line shown on the site. It continues the classical-engine path with stronger search heuristics and move-ordering refinements.

  • -Deeper Late Move Pruning limits
  • -More aggressive null-move pruning where applicable
  • -Internal Iterative Reduction in place of the earlier internal iterative deepening block
  • -Reworked history-aware SEE pruning
  • -Granular capture history using attacker, target square, and victim-piece type
  • -4-ply continuation history
  • -Static-evaluation correction history blended across pawn, non-pawn, and continuation components
  • -Non-pawn Zobrist-key support and transposition-table bucket prefetching
  • -Bishop-colour draw-detection fixes
  • -Additional UCI tuning options for SEE pruning and correction-history weights

Project Philosophy and Future Direction

MagicTree is a personal, classical chess-engine project built for learning, testing, and competitive engine play. It is currently deliberately handcrafted rather than neural-network based.

The aim is to keep improving the engine through careful implementation, testing, tuning, and ideas learned from the wider computer-chess community, while keeping the codebase personally written and understandable.

After the single-processor release is stable, well tuned, and reasonably maximised, the planned future direction is to add Lazy SMP support for multi-threaded search.

Beyond that, I eventually intend to explore NNUE-style evaluation so that MagicTree can evolve from a purely handcrafted engine into a stronger modern hybrid engine while still retaining the project's original learning-focused and personally written character.

MagicTree is free to use as a binary release. The source code is not included in the public release package.

Download MagicTreeBack to Home