Nemorino is a UCI chess engine.


  • Syzygy Tablebase support
  • Pondering
  • Standard Chess and Chess960
  • Multi Core support (Shared Hash Table)
  • Multi PV analysis mode
  • CECP support (experimental - all testing is done using UCI)
UCI parameters:
  • UCI_Chess960: If set to true engine will play according to Chess960 rules (default false)
  • Hash: Size in MBytes used for the transposition table (default is 32. Nemorino will use additional memory for other fixed-size hash tables)
  • Clear Hash: Will clear the transposition table
  • MultiPV: Number of principal variations shown (default 1)
  • Threads: Maximum number of threads (cores) used (default determined by number of available hardware threads)
  • Ponder: When set to true, engine will continue analysis while waiting for opponent's move (default false)
  • Contempt: Score (in centipawns) for accepting draws. If Contempt > 0 then the engine will avoid draws (default 0)
  • BookFile: Polyglot book file the engine shall use (default "book.bin"). Nemorino doesn't have an own book so far
  • OwnBook: Use Polyglot book, specified by book file (default false)
  • SyzygyPath: Path(es) to directories Syzygy tablebase files can be found. Seperate multiple directories by ';' on windows and by ':' on linux
  • SyzygyProbeDepth: Minimum search depth for probing Syzygy Bases. The lower the number, more tablebase lookups will be done, but search speed will decrease (default 8)
  • MoveOverhead: Safety Time(in ms) needed to avoid time-losses (default 100)
  • UCI_Opponent: With this command the GUI can send the name, title, elo and if the engine is playing a human or computer to the engine (see UCI Specification)


Released executables can be downloaded in the Download section

The current development versions are also available:

Nemorino doesn't bring it's own UI. So for running it, you need a GUI supporting UCI (like Arena).
The engine requires 64-bit Windows.


  • Bitboard based (using magic bitboards for sliding move generation)
  • Principal Variation Search (with Aspiration Windows, Null-Move Pruning, Killermoves, Futility Pruning, Razoring, ...)
  • Tapered Eval based on Material, Mobility, Threats, King Safety, and Pawn Structure
  • Special evaluation functions for some endgames
  • Copy/Make

Version History


  • Bugfix: rare crashes caused by hash collisions in transposition table
  • Code changes for non-popcount compiles


  • New Parameters: SyzygyProbeDepth and MoveOverhead
  • Bugfix: Handling of EP-Squares in TB probing code


  • Several Improvements in Search: Singular Extensions, Cut Node Extensions, improved IID,..
  • Improved SEE (consider promotions and pinned pieces)
  • Improved King Safety Evaluation
  • Scale down endgame values if there are opposite colored bishops
  • Several minor improvements and clean-ups

2.00a (only bugfixes relevant when running with more than one thread):


  • Refactoring of SMP implementation => Improved stability
  • Several minor improvements in search and move ordering


  • Improved King Safety evaluation
  • Some Improvements when running with many threads
  • Some Evaluation Improvements (added some material imbalance terms, knight center mobility, ... and removed some useless terms)


  • Several minor Improvements especially for King Safety
  • Several Bugfixes
  • Replaced Syzygy probing code. Now instead of Fathom library, probing code from Stockfish is used




Nemorino is listed in several rating lists:

Nemorino 5.00

Nemorino 4.00


I wrote this engine because I wanted to understand, how a chess engine is working. And the best way to learn is to write an engine from scratch by yourself. I first started with C#, but after some time I got the ambition to learn C++. Therefore don't expect a lot of new ideas within my code, and neither expect clean and well-structured code. Instead you will find a unique combination of all those ideas explained in the Chess Programming Wiki.


These are my sources of information I used for my engine: