Logo Chess Nerd
Bookstacks • Crazèd Fooliosity • Text Utilities

New GitHub Releases

grandchesstree

Tim Jones (Manchester)
a public distributed effort to traverse the depths of the game of chess.
C#, TypeScript, Python, Dockerfile, JavaScript, HTML, CSS
https://github.com/Timmoth/grandchesstree

GrandChessTree-0.1.5
2025-03-06 11:16 UTC
https://github.com/Timmoth/grandchesstree/releases/tag/GrandChessTree-0.1.5

- Added silent mode, when set to true it won't output the realtime metrics to the console (see below config)
- Client now reports thread count, allocated memory, MIPS to the server
- API request / response bodies use binary encoding to minimize bandwidth requirements.

{
"api_url": "https://api.grandchesstree.com/",
"api_key": ,
"workers": 24,
"worker_id": 0,
"task_type": 0,
"mb_hash": 1024,
"sub_task_cache_size": 2046,
"sub_task_launch_depth": 3,
"silent": false
}

Jomfish-Source-Code

Jimmy Luong
This is the repository for my chess bots first versions
Rust
https://github.com/github-jimjim/Jomfish-Source-Code

JF-10.0
2025-03-06 11:15 UTC
https://github.com/github-jimjim/Jomfish-Source-Code/releases/tag/JF-10.0

- **Stockfish 11 Parity**: Jomfish includes all major features found in Stockfish 11, providing a high-performance engine capable of competing at advanced levels of play.
- **No Neural Networks (NNUE)**: Unlike modern engines that rely on neural network-based evaluation, Jomfish exclusively uses classical evaluation methods. This ensures predictable and interpretable behavior during gameplay. But still it has a very strong performance of a estimated **3200** elo
- **Rust-Based Development**: The engine was developed using the Rust programming language, focusing on performance, safety, and reliability.
- **Full Changelog**: https://github.com/github-jimjim/Jomfish/commits/JF-10
- **Binaries**: Only basic binaries. compile it by your self if you want to use avx2

PZChessBot

Kevin Lu (Los Angeles)
chess engine made by high school students
C++, CMake, Shell
https://github.com/kevlu8/PZChessBot

20250302T22 - Last working version before hashtables
2025-03-04 18:49 UTC
https://github.com/kevlu8/PZChessBot/releases/tag/20250302T22

This release contains the last (and highest-skill) version of PZChessBot before hashtables were added, since adding new and large features like hashtables generally comes with everything breaking.

Kojiro

babak
A simple UCI Chess Engine
C++, Makefile, C
https://github.com/Babak-SSH/Kojiro

Kojiro 0.1.1
2025-03-04 15:51 UTC
https://github.com/Babak-SSH/Kojiro/releases/tag/0.1.1

- Add flags to Makefile to treat warnings as errors and fixed them (#1).
- Removed upper case letters to show piece type in promotion moves in UCI output to avoid conflicts with gui and tools that play chess and doesn't recognize upper case in promotion moves (#1).
- Fixed a bug where checking for en passant availability in a pawn double push checked wrong files for presence of opposite sides pawn (#2).

Arcanum

Lars Aurud (Norway)
UCI chess engine
C++, Makefile
https://github.com/LarsAur/Arcanum

Release v2.5
2025-03-03 00:09 UTC
https://github.com/LarsAur/Arcanum/releases/tag/2.5

# Changes
## NNUE
* New architecture with 8 output buckets based on number of pieces on the board: 768->8x(512->16->1)
* The layers are quantized to reduce the compute and memory load. The quantization is performed when the net is loaded.
* The arcanum-net-v5.0.fnnue net is trained on the same dataset as arcanum-net-v4.0.fnnue, but performs better due to being larger and faster.
* The net is embedded in the executable, so the arcanum-net-v5.0.fnnue file is not required to run the engine.

## Search
* Use isPv to replace TT entries
* Only set the exact flag for TT entries in PV-nodes

## Other
* The engine is compiled with clang. All previous versions have been compiled using gcc.
* Add support for using binpack to train NNUE nets. This was not used for training the v5 net.
* Use specific sort algorithm (stable-sort) and random generator (mt19937) to avoid differences in the engine when using different compilers and stdlibs.

# For Testers

* Arcanum still does not support pondering.
* Arcanum requires AVX2.
* All builds are statically linked and should not require any libraries.
* The default net is embedded in the executable, so arcanum-net-v5.0.fnnue does not need to be present to run the engine.

# Elo Estimate
Arcanum v2.5 is estimated to be 95 Elo stronger than Arcanum v2.4 based on self play.

## Self Play
Time control: 120s + 1s
Opening book: [8moves_v3.pgn](https://github.com/official-stockfish/books/blob/547e76cf338cedd6ecdcc08ad3e4e81dc7ecfb6f/8moves_v3.pgn.zip)
Tablebase: 5-man syzygy.

Score of v2.5 vs v2.4: 273 - 60 - 467 (Win - Loss - Draw)
v2.5 playing White 154 - 23 - 223
v2.5 playing Black: 119 - 37 - 244
Elo difference: ***95 +/- 15***, LOS: 100.0 %, DrawRatio: 58.3 %

calvin-chess-engine

Dan Kelsey (Amsterdam, Netherlands)
A superhuman chess engine written in Java.
Java, Shell, Makefile, Batchfile
https://github.com/kelseyde/calvin-chess-engine

6.0.0
2025-03-02 17:28 UTC
https://github.com/kelseyde/calvin-chess-engine/releases/tag/6.0.0

This major release of Calvin aims to achieve two significant milestones:
- Reaching an elo rating of 3600 (CCRL Blitz).
- Establishing Calvin as the strongest Java chess engine in the world.

Calvin 6.0.0 does not feature a new neural network or any improvements to the evaluation function. Instead, all the strength gains were found in search - the most notable being singular extensions.

Tests against the previous release suggest a strength increase of around 93 elo LTC / 67 elo STC:

[LTC (40+0.4)](https://kelseyde.pythonanywhere.com/test/319/): `Elo | 93.39 +- 5.84`
[STC (8+0.08)](https://kelseyde.pythonanywhere.com/test/320/): `Elo | 67.19 +- 6.13`

Those improvements give Calvin 6.0.0 an estimated rating of 3600 CCRL Blitz.

## The strongest Java chess engine

I ran some tests againt Serendipity, the current top Java engine. The results show that Calvin is now significantly stronger:

[LTC (40+0.4)](https://kelseyde.pythonanywhere.com/test/322/): `Elo | 51.79 +- 14.33`
[STC (8+0.08)](https://kelseyde.pythonanywhere.com/test/321/): `Elo | 71.19 +- 18.94`

Therefore Calvin is (as far as I am aware) the new top Java engine in the world!

## 🔍 Search Improvements

- Singular extensions (#115)
- Double extensions (#305)
- Negative extensions (#306)
- Double negative extensions (#310)
- Fix corrhist updates (#286 / #287)
- Use history score in PVS SEE pruning (#284)
- Fix cutnode usage (#309)
- Cutnode LMR (#310)
- Futility LMR (#304)
- Do IIR when TT depth is shallow (#312)
- Write to TT in Q-search stand-pat beta cutoff (#298)
- Only skip SEE pruning for good noisies (#297)
- SPSA tune (#301)

# How to run

To run the jar file, you will need to enable the Vector API package which Calvin uses for SIMD, via this command:

```java --add-modules jdk.incubator.vector -jar path/to/calvin-chess-engine-6.0.0.jar```

For CCRL testers who use ChessGUI, please also download the calvin-wrapper.jar file and place it in the same folder as the calvin jar. When loading Calvin in ChessGUI, pass this file instead of the engine jar. This wrapper allows you to run Calvin without passing in the required JVM args (which ChessGUI does not support).

--

And finally, many thanks to the kind people who have tested Calvin, and to those who have offered their advice and expertise in the chess programming Discord channels!

Stockfish

Stockfish
A free and strong UCI chess engine
C++, Makefile, Python, C, Shell
https://github.com/official-stockfish/Stockfish

Stockfish dev-20250228-f3bfce35
2025-02-28 08:57 UTC
https://github.com/official-stockfish/Stockfish/releases/tag/stockfish-dev-20250228-f3bfce35

scoria

Ian Nathan Kusmiantoro (Jakarta, Indonesia)
An rudimentary chess bot, designed and programmed completely in Java.
Java
https://github.com/iannathan-k/scoria

Scoria 2
2025-02-27 10:41 UTC
https://github.com/iannathan-k/scoria/releases/tag/sc_v2.6.17

I can now estimate Scoria to have lichess rating of ~1700 on lichess, a far improvement from the previous Scoria 1. In just one month many more advanced ideas have been implemented, but there is still room for improvement, as I am working on even before this release. See below for the improvements that have been made.

## Changelog

### Language Switch (#11)

Now using Java instead of python, which increases speed monumentally. Despite python using C behind the scenes, it is still an interpreted language meaning it is much slower and doesn't have the optimizations that JVM makes during compilation. Just using Java without any more optimizations to the code already saw a significant perfomance jump being able to search to depths twice as deep in a fraction of the time putting it around 20x faster.

### Commands

Added commands like perft and eval which are useful for debugging as well as configuring the program to your needs with more freedom than before. This was especially useful when testing different positions and tweaking evaluation functions to yield better results, or version tracking with the version command. A full list of the available commands can be found in the README.md.

### Zobrist Hashing

Implemented [Zobrist hashing](https://en.wikipedia.org/wiki/Zobrist_hashing) which takes advantage of the one cycle XOR logic to make 500ns hashes for board states which makes the transposition table and threefold repetition implementation much faster.

### Improved castling and en passant handling

Castling and En Passant are now properly handled using stacks which are added and popped from when moves are made, meaning that the state is properly accounted for in both moves and pseudomoves unlike before which always defaulted the reset to whatever was the current true board state instead of the relative one.

### Iterative Deepening

[Iterative deepening](https://www.geeksforgeeks.org/iterative-deepening-searchids-iterative-deepening-depth-first-searchiddfs/) now means that searches can be time limited rather than depth limited making the program allover considerably more comfortable because the time between searches is always known without having to wait 30 seconds for the next move because there are just too many nodes.

## Footnotes

README.md has also been majorly improved, now bringing much more clarity and structure similar to the standards. There is also now a simple way to clone, compile and run the engine on your computer with instructions on how to do so which much better than the previously said "Just download it and run main.py". This is also a testament to how much object oriented programming can improve the organization of a program.

Scoria v2.6.17

lozza

Colin Jenkins (Mumbles, Wales, UK.)
A UCI Javascript chess engine.
JavaScript, Python, Rust, Shell, Makefile
https://github.com/op12no2/lozza

Lozza 5
2025-02-25 20:58 UTC
https://github.com/op12no2/lozza/releases/tag/5

## Changes

- Fix beta pruning!
- Use Math.imul() instead of * in netFastEval() to force integer multiplication.
- Cumulative SPRT against Lozza 4: +112 +/- 28 at 60+1.
- Cumulative SPRT against Lozza 4: +118 +/- 29 at 20+0.2.
- Use a save_rate of 1 and train on SB net with minimum mean batch loss (see loss.py).
- Use RAdam optimiser (see lozza.rs).
- Generate more data. 320M FENs total.
- Tweak datagen to save FENs in bullet text format (see datagen.js).
- Simplify PSTs away.
- Simplify lonePawns away.
- Micro optimisation to piece Zobrist access.
- Fix lower/upper bound logic.
- Add network command showing network info and stats.
- Add a serialise (weights) command for use when making releases.
- Fix board.fen() WRT black queen castling rights.
- Optimise accessing 'them' weights a bit more.
- Swap to bullet (768 -> 128)x2 -> 1 SqrReLU.
- Use performance.now() not Date.now().
- Use 10k soft nodes for datagen.

python-chess

Niklas Fiekas (Germany)
A chess library for Python, with move generation and validation, PGN parsing and writing, Polyglot opening book reading, Gaviota tablebase probing, Syzygy tablebase probing, and UCI/XBoard engine communication
Python
https://github.com/niklasf/python-chess


2025-02-25 19:10 UTC
https://github.com/niklasf/python-chess/releases/tag/v1.11.2

111

belal sileem
This is a repository for the project "111" which aims to develop innovative solutions for sustainable energy production through advanced technology and research. Follow our progress and contribute to creating a greener future with "111".

https://github.com/blela/111

Release v1.0
2025-02-23 12:18 UTC
https://github.com/blela/111/releases/tag/v1.0

The "111" repository presents its first release tagged as version 1.0. Stay updated with the latest advancements in sustainable energy production innovations and join us in shaping a greener future through technology and research contributions. Exciting progress awaits as we work towards creating a more sustainable world with "111".

chess-app

Nazar Tarasiuk (Kyiv)
My pet chess engine
C++, Python, CMake
https://github.com/adidvar/chess-app

v0.2
2025-02-22 15:29 UTC
https://github.com/adidvar/chess-app/releases/tag/v0.2

## What's Changed
* UCI support and time management by @adidvar in https://github.com/adidvar/chess-app/pull/5
* Fixed generation bugs by @adidvar in https://github.com/adidvar/chess-app/pull/7
* Moves ordering added by @adidvar in https://github.com/adidvar/chess-app/pull/9
* UCI score fixed by @adidvar in https://github.com/adidvar/chess-app/pull/10


**Full Changelog**: https://github.com/adidvar/chess-app/compare/v0.1...v0.2

Jomfish

Jimmy Luong
A open source Rust chess engine
Rust
https://github.com/github-jimjim/Jomfish

JF-10
2025-02-22 13:33 UTC
https://github.com/github-jimjim/Jomfish/releases/tag/JF-10

- **Stockfish 11 Parity**: Jomfish includes all major features found in Stockfish 11, providing a high-performance engine capable of competing at advanced levels of play.
- **No Neural Networks (NNUE)**: Unlike modern engines that rely on neural network-based evaluation, Jomfish exclusively uses classical evaluation methods. This ensures predictable and interpretable behavior during gameplay. But still it has a very strong performance of a estimated **3200** elo
- **Rust-Based Development**: The engine was developed using the Rust programming language, focusing on performance, safety, and reliability.
- **Full Changelog**: https://github.com/github-jimjim/Jomfish/commits/JF-10
- **Binaries**: Only basic binaries. compile it by your self if you want to use avx2

RukChess

Ilya Rukavishnikov
Chess engine with terminal user interface, UCI support and NNUE evaluation function
C++, C
https://github.com/Ilya-Ruk/RukChess

RukChess 4.0.2 NNUE2 (2025-02-15)
2025-02-15 16:59 UTC
https://github.com/Ilya-Ruk/RukChess/releases/tag/4.0.2

# RukChess 4.0.2 NNUE2.exe

Main executable file, requires net-3ba7af1fe396.nnue file with neural network (included in the release).

# net-3ba7af1fe396.nnue (https://github.com/Ilya-Ruk/RukChessNets/blob/master/Nets%20159/rukchess_077.nnue)

Neural network for RukChess 4.0.x NNUE2, trained with https://github.com/Ilya-Ruk/RukChessTrainer based on data obtained from https://www.computerchess.org.uk/ccrl/4040/games.html (05.10.2024) and https://www.computerchess.org.uk/ccrl/404/games.html (13.10.2024).

# book_.txt

Opening book (587604 positions; up to 12 moves) for RukChess 3.x/4.x, generated based on data obtained from https://www.computerchess.org.uk/ccrl/4040/games.html (05.10.2024) and https://www.computerchess.org.uk/ccrl/404/games.html (13.10.2024).

Rename to book.txt to use (remove the underscore).

EmeraldChessEngine

Zhongle Qu (Charlie)
A toy chess engine playing at 1600 Elo
C++, Python
https://github.com/UndefinedCpp/EmeraldChessEngine

Emerald Chess 0.1.1
2025-02-14 12:59 UTC
https://github.com/UndefinedCpp/EmeraldChessEngine/releases/tag/emerald_0.1.1

Minor updates:

- Show version message in UCI and on start up
- Insignificant time management update
- Provide binary that can run on machines with AVX512 support (`skylake`)

Stockfish-DQN-Agent

Samrichier
♟️ Optimized Chess RL Trainer using DQN vs Stockfish. Built with PyTorch and python-chess, it learns using per-move rewards from Stockfish evaluations. Implements Prioritized Experience Replay (PER) and parallel CPU/GPU execution for faster training. The agent dynamically adjusts Stockfish skill level based on performance.

https://github.com/Samrichier/Stockfish-DQN-Agent

Stockfish DQN Agent v2.0
2025-02-13 19:45 UTC
https://github.com/Samrichier/Stockfish-DQN-Agent/releases/tag/v2.0

Release v2.0 of "Stockfish-DQN-Agent" introduces enhanced training capabilities utilizing PyTorch and python-chess. The implementation of Prioritized Experience Replay (PER) and parallel CPU/GPU execution accelerates the learning process. The agent's adaptive Stockfish skill level adjustment based on performance elevates its strategic gameplay abilities.

chessidle

Alvin Peng
A pip installable Python chess engine
Python, Makefile
https://github.com/alvinypeng/chessidle

Chessidle 1.0.0
2025-02-06 06:28 UTC
https://github.com/alvinypeng/chessidle/releases/tag/1.0.0

Bench: 763992

Astra

Semih Özalp (Vorarlberg)
UCI chess engine
C++, C, Makefile
https://github.com/h1me01/Astra

Astra 5.0
2025-02-04 18:28 UTC
https://github.com/h1me01/Astra/releases/tag/5.0

# Release Notes

## NNUE Architecture
- Previously 2x(768→1024)→1; now features a king bucket of size 10, resulting in a new arch: 2x(10x768→1024)→1

## Evaluation
- Besides the new network I added phase evaluation as well

## Search
- Improved time management within the search
- Various other minor improvements

## Miscellaneous
- More efficient transposition table implementation
- Added cuckoo tables to detect upcoming repetitions

## Results vs. Astra 4.1

Astra-5 vs Astra-4.1 (STC)
Elo: 186.0 ± 7.3 (95%)
SPRT: 8.0+0.08s Threads=1 Hash=16MB
GAMES: N: 5474 W: 2984 L: 305 D: 2185

The book used for the test was `8moves_v3.epd`.

dinora

Alisher Zhubanyshev (Almaty, Kazakhstan)
Python Chess Engine with MCTS + NN
Python, Jupyter Notebook, Shell
https://github.com/Saegl/dinora

Outcome-based Training, Training docs and simple MCTS
2025-02-01 16:56 UTC
https://github.com/Saegl/dinora/releases/tag/v0.2.3

## Documentation
The documentation approach is now much simpler—no more Sphinx, readthedocs, or build steps. Instead, plain markdown files are placed in the `docs` directory. Most documentation pages have been removed, and a new, detailed training guide has been added. It covers installation, dataset creation, training configuration, and evaluation.
The README has been updated with new features, project status, and additional acknowledgments.

## Outcome-Based Training
Previous networks used the "Q trick," learning position evaluation from Stockfish annotations. Initially, I assumed purely outcome-based networks weren’t learning properly due to their high value loss (~0.75–0.8 MSE). However, I now believe the high value loss is due to the difficulty of learning the loss formulation itself—where values alternate (+1, -1, +1) even for opening positions that should be closer to 0.

In actual gameplay tests, outcome-trained networks (Z) are not significantly weaker than Stockfish-annotated ones (Q):

| Model | Elo Rating |
|----------------------|------------|
| alphanet ext_mcts Q | 2597 |
| alphanet ext_mcts Z | 2356 |
| alphanet mcts Q | 2465 |
| alphanet mcts Z | 2362 |

PGN game files and configuration settings are attached to this release.

[Graphs for Z](https://wandb.ai/saegl/dinora-chess/runs/yaq4wszk)
[Graphs for Q](https://wandb.ai/saegl/dinora-chess/runs/uz15r3ii)
[Network weights Z](https://wandb.ai/saegl/dinora-chess/artifacts/valid-state/valid-state-4/v6/files)
[Network weights Q](https://wandb.ai/saegl/dinora-chess/artifacts/valid-state/valid-state-4/v7/files)

## New Switchable Searchers
Search strategies can now be changed using the `--searcher` option:
- `dinora --searcher mcts`
- `dinora --searcher ext_mcts`
- `dinora --searcher onemove`

The new `mcts` searcher is a minimal Monte Carlo Tree Search (MCTS) implementation in about 100 lines of code.
While simple, it serves as a useful framework for experimenting with optimizations like tree reuse, parallelization, and solver integration.

## Miscellaneous Changes
- The program for running matches against Stockfish and estimating Elo has been renamed:
`elo_estimator` -> `elofish`
- Internally, time limits are now called "stoppers" instead of "constraints."
- The build tool is now `uv`, and old artifacts for conda/miniconda/poetry have been removed.

## Note on weights
Weights are only on wandb above

Lizard

Liam McGuire (Virginia, USA)
Strongest A/B chess engine written in C#
C#, C++, C, Makefile
https://github.com/liamt19/Lizard

Version 11.2
2025-01-08 21:06 UTC
https://github.com/liamt19/Lizard/releases/tag/v11.2

Has a more complex network and a few search tweaks/additions.

For the sake of my sanity (and because .NET can't/doesn't autovectorize NNUE code), this requires at least AVX2 to be performant, but will still function without it.

## A note on bindings:
This release includes C++ code from [Horsie](https://github.com/liamt19/Horsie) to make NNUE evaluation faster. This code is only used if your processor supports Avx2.

The Windows and Linux releases here already have it compiled and embedded as a `.dll`/`.so` within it. For technical reasons this embedded file will automatically extract itself into a file called `HorsieBindings.dll`/`HorsieBindings.so` which Lizard will try to use when it launches.

You will see "Loaded Horsie bindings!" if they are successfully loaded, or "Running without Horsie bindings" if they aren't. The bindings aren't required, but they do make Lizard significantly faster.

## Picking a binary:
**Use a `...-512` binary if your processor has Avx512.**
AOT binaries aren't being included here because they are strictly slower.

### STC:
Elo | 15.02 +- 5.26 (95%)
Conf | 8.0+0.08s Threads=1 Hash=32MB
Games | N: 3008 W: 380 L: 250 D: 2378
Penta | [6, 178, 1013, 294, 13]
https://somelizard.pythonanywhere.com/test/2210/

### LTC:
Elo | 18.55 +- 5.35 (95%)
Conf | 60.0+0.60s Threads=1 Hash=64MB
Games | N: 1500 W: 133 L: 53 D: 1314
Penta | [0, 29, 616, 101, 4]
https://somelizard.pythonanywhere.com/test/2209/

### DFRC:
Elo | 16.10 +- 7.08 (95%)
Conf | 8.0+0.08s Threads=1 Hash=32MB
Games | N: 3002 W: 714 L: 575 D: 1713
Penta | [28, 297, 723, 414, 39]
https://somelizard.pythonanywhere.com/test/2212/

Horsie

Liam McGuire (Virginia, USA)
1:1 Port of the Lizard engine to C++
C++, C, Makefile
https://github.com/liamt19/Horsie

Version 1.0
2025-01-08 17:41 UTC
https://github.com/liamt19/Horsie/releases/tag/v1.0

First release! Contains most of the features from [Lizard](https://github.com/liamt19/Lizard) besides multipv and pretty printing.

### Picking a binary:
Start with v4, and move down until it no longer crashes.
- v4 enables Avx512,
- v3 enables Avx256,
- v2 is a fallback for older CPU's


### STC vs Lizard 11.2:
Elo | 30.53 +- 7.87 (95%)
Conf | 8.0+0.08s Threads=1 Hash=32MB
Games | N: 2008 W: 557 L: 381 D: 1070
Penta | [4, 171, 482, 339, 8]
https://somelizard.pythonanywhere.com/test/2211/

EubosChess

Chris Bolt (Cambridge, UK)
A Java chess engine. Uses UCI protocol. Playable on lichess.
Java, Batchfile
https://github.com/cjbolt/EubosChess

Eubos v3.8.1
2025-01-07 14:50 UTC
https://github.com/cjbolt/EubosChess/releases/tag/v3.8.1

Nectar

Dragjon (Singapore, Singapore)
NNUE Chess Engine
C#, GLSL
https://github.com/Dragjon/Nectar

V0.2.2
2024-12-30 09:53 UTC
https://github.com/Dragjon/Nectar/releases/tag/V0.2.2

* New Neural Network

# STC (SPRT)
Score of NectarV0.2.2 vs NectarV0.2.1: 151 - 63 - 40 [0.673] 254
... NectarV0.2.2 playing White: 74 - 28 - 25 [0.681] 127
... NectarV0.2.2 playing Black: 77 - 35 - 15 [0.665] 127
... White vs Black: 109 - 105 - 40 [0.508] 254
Elo difference: 125.6 +/- 41.5, LOS: 100.0 %, DrawRatio: 15.7 %
SPRT: llr 2.96 (100.7%), lbound -2.94, ubound 2.94 - H1 was accepted

Raphael

Rei Meguro (Tokyo/Michigan)
A chess GUI and a UCI chess engine coded in C++ and SFML.
C++, Python, Makefile, C
https://github.com/Orbital-Web/Raphael

v1.8 Evaluation Tuning + Better Bishop & Draw Eval
2024-12-27 17:39 UTC
https://github.com/Orbital-Web/Raphael/releases/tag/v1.8.0

`v.1.8`
- Used [GediminasMasaitis's Texel Tuner](https://github.com/GediminasMasaitis/texel-tuner) and [Blunder 8.1's Texel Tuning Dataset](https://talkchess.com/viewtopic.php?t=78536&start=20) to tune evaluation parameters
- Switched to fully tapered evaluation (not just a select few parameters)
- Added bishop-colored corner distance boost
- Added bishop pair bonus
- Added early draw evaluation evaluation scaling to avoid premature captures that result in draws

**Performance**
`v1.8` 🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩⬜ `v1.0` [380 / 16 / 4]
`v1.8` 🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩⬜⬜⬜⬜⬜🟥🟥🟥🟥🟥 `v1.7` [197 / 100 / 103]

ELO Increase: 118

radiance

Paul-Elie Pipelin
UCI Chess Engine written in C++
C++, CMake
https://github.com/ppipelin/radiance

Radiance 3.4
2024-12-25 15:07 UTC
https://github.com/ppipelin/radiance/releases/tag/3.4

### Added

- Bitboard evaluation function
- Linux GCC errorless compile
- Github actions compilation for Linux

### Changed

- Bit manipulation functions
- Evaluate table code flow
- Use 64 bits `UIntL` for nps display and perft

### Removed

- `opt` preprocessor variable for perft

Lynx_BOT

Lynx
Lichess bot. Runs Lynx chess engine (https://github.com/lynx-chess/Lynx)
Dockerfile
https://github.com/lynx-chess/Lynx_BOT

v1.8.0
2024-12-20 17:24 UTC
https://github.com/lynx-chess/Lynx_BOT/releases/tag/v1.8.0

[Lynx v1.8.0](https://github.com/lynx-chess/Lynx/releases/tag/v1.8.0)

Lynx

Lynx
Chess Engine, written in C#
C#, Makefile
https://github.com/lynx-chess/Lynx

v1.8.0
2024-12-20 17:15 UTC
https://github.com/lynx-chess/Lynx/releases/tag/v1.8.0

🔍 Search

* Improving: LMP (https://github.com/lynx-chess/Lynx/pull/1129)
* Improving: RFP (https://github.com/lynx-chess/Lynx/pull/1130, https://github.com/lynx-chess/Lynx/pull/1133)
* Improving: LMR (https://github.com/lynx-chess/Lynx/pull/1135)
* NMP, tweak reduction using eval - beta (https://github.com/lynx-chess/Lynx/pull/1139)
* NMP: Use the right score for TT condition (https://github.com/lynx-chess/Lynx/pull/1268)
* LMR: reduce more on cutnode (https://github.com/lynx-chess/Lynx/pull/1233)
* LMR: avoid when being checkmated (https://github.com/lynx-chess/Lynx/pull/1231)
* LMR: increase pv min moves 2 (https://github.com/lynx-chess/Lynx/pull/1230)
* History: `History_BestScoreBetaMargin` 80 -> 60 (https://github.com/lynx-chess/Lynx/pull/1118)
* History: increase bonus when best score is over beta by some margin (https://github.com/lynx-chess/Lynx/pull/1110)
* History: increase bonus when static eval is lower than alpha (https://github.com/lynx-chess/Lynx/pull/1123)
* Save static eval in TT (https://github.com/lynx-chess/Lynx/pull/1084, https://github.com/lynx-chess/Lynx/pull/1085)
* Aspiration windows: fail high reduction (https://github.com/lynx-chess/Lynx/pull/800, https://github.com/lynx-chess/Lynx/pull/1285)

⌛ Time management

* Add node time management (https://github.com/lynx-chess/Lynx/pull/1203, https://github.com/lynx-chess/Lynx/pull/1206)
* Add best move stability (https://github.com/lynx-chess/Lynx/pull/1211)
* Add score stability (https://github.com/lynx-chess/Lynx/pull/1223)
* Soft limit <= hard limit (https://github.com/lynx-chess/Lynx/pull/1210)

⚡ Speedups

* Move to .NET 9 (https://github.com/lynx-chess/Lynx/pull/1108)
* Don't attempt continuation history on root moves (https://github.com/lynx-chess/Lynx/pull/1065)
* Use `Unsafe.Add` for `PSQT()` (https://github.com/lynx-chess/Lynx/pull/1153)
* Make `TaperedEvaluationTerm` fields constant (https://github.com/lynx-chess/Lynx/pull/1174)
* Make TT (wrapper) a readonly struct (https://github.com/lynx-chess/Lynx/pull/1200)
* Flatten killer moves array (and stack-allocate it) (https://github.com/lynx-chess/Lynx/pull/1247)
* Minimal speedup in `go` UCI command parsing (https://github.com/lynx-chess/Lynx/pull/1264)

🐛 Bug fixes

* Clear `PlyStackEntry` shared array on return (https://github.com/lynx-chess/Lynx/pull/1182)
* Don't allow the search to stop if no best move is found (https://github.com/lynx-chess/Lynx/pull/1251)
* IDDFS finishes some depths with no moves (https://github.com/lynx-chess/Lynx/pull/1266)
* Incorrect (too negative) mate scores when being checkmated (https://github.com/lynx-chess/Lynx/pull/1271)
* Make sure `staticEval` var always gets initialized as part of the search (https://github.com/lynx-chess/Lynx/pull/1272)
* Prevent aspiration windows to go outside of [MinEval, MaxEval] after window overflow (https://github.com/lynx-chess/Lynx/pull/1275)

🟰 Multithreaded search

* Add support for multi-threaded search: basic lazy SMP implementation (https://github.com/lynx-chess/Lynx/pull/1263)

| Threads # | 1 | 2 | 4 | 8 |
|:------------:|:---------:|:---------:|:---------:|:---------:|
| **ELO @ 8+0.08** | - | [+100.96](https://openbench.lynx-chess.com/test/1112/) | [+195.65](https://openbench.lynx-chess.com/test/1113/) | [+263.42](https://openbench.lynx-chess.com/test/1114/) |
| **ELO @ 40+0.4** | - | [+83.35](https://openbench.lynx-chess.com/test/1115/) | [+167.44](https://openbench.lynx-chess.com/test/1116/) | [+220.54](https://openbench.lynx-chess.com/test/1117/) |
| **NPS** | 1.21 Mnps | 2.47 Mnps | 4.88 Mnps | 10.07 Mnps |

![Image](https://github.com/user-attachments/assets/63143da5-b703-4ed7-9fe7-82c61250bfca)

More detailed results can be found [here](https://github.com/lynx-chess/Lynx/commit/41ae2c878ffeb587c02f016265bafc333207b544#commitcomment-150588822).

Non strength-winning changes

* Allow non-power of two Hash sizes, implemented via 'fixed-point multiplication trick' (https://github.com/lynx-chess/Lynx/pull/1072)
* Improve and standardize `nps` reporting (https://github.com/lynx-chess/Lynx/pull/1081)
* Use the total max ply as `selfdepth` value instead of last search's max ply (https://github.com/lynx-chess/Lynx/pull/1289)
* Make `bench` quiet by default, and add `verbosebench` (https://github.com/lynx-chess/Lynx/pull/1286)
* Various big refactorings to accommodate multithreaded search (https://github.com/lynx-chess/Lynx/pull/1147, https://github.com/lynx-chess/Lynx/pull/1184, https://github.com/lynx-chess/Lynx/pull/1201, https://github.com/lynx-chess/Lynx/pull/1262)

----

**Full Changelog**: https://github.com/lynx-chess/Lynx/compare/v1.7.0...v1.8.0

Tucano

Alcides Schulz (New Jersey, USA)
Tucano Chess Engine
C, C++, Makefile
https://github.com/alcides-schulz/Tucano

Tucano 12.00
2024-12-12 20:22 UTC
https://github.com/alcides-schulz/Tucano/releases/tag/12.00

Tucano version 12.00 release.
It now returns to the version 10.00 neural network architecture but with the incremental evaluation update, and other search improvements.
In this release you will find the network file "tucano_nn03.bin" that has to be saved to the same folder as the executable file, or can be indicated in the parameters. Please review the readme.md file for more information.
Also includes executables for windows and linux (centos).
This version is stronger than previous 11.00 version.


jfxchess

Dominik Klein
JFXChess - Chess Program
Java, Inno Setup, Shell, Batchfile, CSS
https://github.com/asdfjkl/jfxchess


2024-12-10 09:54 UTC
https://github.com/asdfjkl/jfxchess/releases/tag/v4.3.0

## Changelog

- various bug-fixes and enhancements, cf. full changelog [here](https://github.com/asdfjkl/jfxchess)

## Installation on Windows:

- download `SetupJFXChess.exe` and execute it
- The executable is not signed. On the resulting blue Smart Screen Defender window
- click on "More info" (upper left corner) and then
- click on "Run anyway" (lower right corner)

## Installation on Linux

### Install the attached `.deb'
- (remove previous versions with `sudo apt remove jfxchess`)
- install with `sudo dpkg -i jfxchess_x.y_amd64.deb`

### Or download manually the attached `tar.xz`, `untar` & `unzip`
- open a command prompt and change to the extracted folder
- execute `start_jfxchess`
- you need to have a recent Java JDK installed, e.g. OpenJDK 17 or higher: `sudo apt install openjdk-17-jdk`

You need a 64 bit OS both for Windows and Linux!

cli-chess

Trevor
A highly customizable way to play chess in your terminal. Play online (via Lichess.org) and offline against the Fairy-Stockfish engine. All Lichess variants are supported.
Python
https://github.com/trevorbayless/cli-chess

cli-chess v1.4.3
2024-12-07 16:14 UTC
https://github.com/trevorbayless/cli-chess/releases/tag/v1.4.3

- Fixes a regression which caused the game over status to not be reported during offline games.

Patricia

Adam Kulju
Super aggressive chess engine
C++, C, Makefile
https://github.com/Adam-Kulju/Patricia

Patricia 4
2024-12-03 02:51 UTC
https://github.com/Adam-Kulju/Patricia/releases/tag/4

Update 12/3/2024, 20:02 UTC: Added v4 binaries for machines with avx512 support.

# Estimated Rating: 3500 CCRL
# Estimated EAS: 330k-450k (depending on the testing method)

Patricia 4 is now out! Thanks to a new net trained on Patricia data, a lot of search patches, and a bitboard rewrite, she's now able to compete much more effectively with top engines, while retaining her status as the most aggressive chess engine out there.

## Explanation about the EAS value:
I measured an EAS score of 470,000 in my initial testing before release, however when Stefan Pohl tested it under his conditions he only got a score in the low 300 thousands. I've traced this discrepancy to the different books used in the testing, with Pohl using more unbalanced books than me. Pohl's EAS score is more likely to be accurate in engine games, meaning I have a lot of work to do EAS-wise, however I've held up the release long enough so the task of hiking up the EAS under top engine tournament conditions will be left to Patricia 4.1/5.

Patricia is still the most aggressive engine out there and is now far stronger than 3.1 was, able to fully hold its own in TCEC and CCC.

## Binaries

Linux and Windows binaries are found below. Use v3 (avx2) for most computers, and use v2 (SSE) for very old models. If you're not sure about which one to download, try v3 first.

If you have a machine that supports AVX512 or you want to compile from source for other reasons, you can easily build Patricia from source by running the commands:

git clone https://github.com/Adam-Kulju/Patricia
cd Patricia/engine
make -B
The executable patricia will be found in the current directory, that is, Patricia/engine.


## Acknowledgements

Gabe, the Obsidian author, is responsible for a majority of Patricia's Elo increase. I really appreciate his help and collaboration - the only reason he's not a coauthor is because he declined to be added as one.

Thank you to everyone who supports Patricia. I'm truly grateful for all the attention she's received.


## A Note on Antivirus Software

I've been getting a lot of reports of antivirus software flagging Patricia as a virus. She is not a virus and this problem happens to most chess engines, but it's been especially annoying and persistent with her for some reason. If you're struggling with getting an executable due to this let me know and I'll see what I can do to help you out.






FreddyyBot

Frederick Andrews (Ottawa, Ontario, Canada)
C++ chess engine from scratch.
C++, Python, C, Makefile, Jupyter Notebook, Shell
https://github.com/FreddyyAndrews/FreddyyBot

Bug fix: Checkmate evaluation
2024-11-16 18:48 UTC
https://github.com/FreddyyAndrews/FreddyyBot/releases/tag/3.0.1

Stormphrax

Ciekce (UK)
UCI chess engine, with NNUE trained from zero knowledge
C++, CMake, Makefile
https://github.com/Ciekce/Stormphrax

Stormphrax 6.0.0
2024-10-29 02:03 UTC
https://github.com/Ciekce/Stormphrax/releases/tag/v6.0.0

Stormphrax 6.0.0 is significantly stronger than 5.0.0 - a longstanding bug in datagen has been fixed, and the entire dataset has been regenerated, resulting in a massively improved (and much larger) network. The regular search tweaks have also happened, along with improvements to time management, and Stormphrax now supports `go searchmoves`.

Many thanks again to everyone who has contributed CPU time to the [OpenBench instance](https://chess.swehosting.se/index/) that Stormphrax is tested on - now too many to list, but as always especially @JouanDeag for contributing hosting together with @noobpwnftw for a constant presence of workers :3

### Results against Stormphrax 5.0.0

STC:
Elo | 87.03 +- 7.22 (95%)
Conf | 8.0+0.08s Threads=1 Hash=32MB
Games | N: 3024 W: 938 L: 196 D: 1890
Penta | [4, 105, 691, 569, 143]

LTC:
Elo | 77.25 +- 8.43 (95%)
Conf | 60.0+0.60s Threads=1 Hash=128MB
Games | N: 1504 W: 373 L: 44 D: 1087
Penta | [0, 24, 414, 275, 39]

FRC STC:
Elo | 115.83 +- 8.10 (95%)
Conf | 8.0+0.08s Threads=1 Hash=32MB
Games | N: 3004 W: 1209 L: 243 D: 1552
Penta | [2, 108, 533, 640, 219]

DFRC STC:
Elo | 136.13 +- 8.64 (95%)
Conf | 8.0+0.08s Threads=1 Hash=32MB
Games | N: 3022 W: 1409 L: 282 D: 1331
Penta | [6, 100, 439, 693, 273]

Elo testing done with OpenBench's [8moves_v3.epd book](https://github.com/AndyGrant/OpenBench/blob/master/Books/8moves_v3.epd.zip) for standard chess, [3moves_FRC.epd](https://github.com/AndyGrant/OpenBench/blob/master/Books/3moves_FRC.epd.zip) for FRC, and [DFRC.epd](https://github.com/AndyGrant/OpenBench/blob/master/Books/DFRC.epd.zip) for DFRC.
Results are obtained from self-play and will likely not scale perfectly to games against other opponents :)

**Full Changelog**: https://github.com/Ciekce/Stormphrax/compare/v5.0.0...v6.0.0

motor

Martin Novák
UCI chess engine written in C++
C++, CMake, Makefile
https://github.com/martinnovaak/motor

Motor v0.8.0
2024-10-28 19:51 UTC
https://github.com/martinnovaak/motor/releases/tag/v0.8.0

### Progression Tests:

Tests on UHO_Lichess_4852_v1.epd opening book:
Elo | 39.00 +- 3.67 (95%)
Conf | 8.0+0.08s Threads=1 Hash=32MB
Games | N: 10002 W: 3176 L: 2058 D: 4768
Penta | [33, 774, 2342, 1746, 106]

Elo | 38.35 +- 6.32 (95%)
Conf | 40.0+0.40s Threads=1 Hash=64MB
Games | N: 3002 W: 878 L: 548 D: 1576
Penta | [4, 225, 721, 539, 12]

Test on 8moves_v3.pgn:
Elo | 18.43 +- 4.42 (95%)
Conf | 40.0+0.40s Threads=1 Hash=64MB
Games | N: 3000 W: 312 L: 153 D: 2535
Penta | [0, 108, 1134, 249, 9]

### Changes
- Most changes come from experiments with correction history:
- Threat structure correction history
- Minor structure correction history (idea from [Sirius](https://github.com/mcthouacbb/Sirius))
- Continuation correction history
- New weight formula
- Qsearch correction
- New network with 8 input buckets
- New history table for move ordering indexed by material index

Perseus-Engine

TheRealGioviok
UCI chess engine
C++, Jupyter Notebook, Makefile, Python, C
https://github.com/TheRealGioviok/Perseus-Engine

Perseus 0.9-alpha
2024-10-21 19:23 UTC
https://github.com/TheRealGioviok/Perseus-Engine/releases/tag/Prerelease

The first official (pre)release of this most definitely bad engine.
Obligatory thanks to the Stockfish Discord Server people for their invaluable help.

While the `Perseus.exe` executable should provide a good degree of compatibility with older cpus, it is strongly advised to use a faster more optimized executable. These are `Perseus_hashwell.exe` for intel based platforms and `Perseus_znver2.exe` for amd cpus.

ChessEngine

Marcel Gerber
Basic bitboard UCI chess engine for learning purposes.
C++, CMake
https://github.com/marcel-gerber/ChessEngine

ChessEngine v1.0
2024-10-13 20:20 UTC
https://github.com/marcel-gerber/ChessEngine/releases/tag/v1.0

## What's Changed
* Fixed bug in attackedSquares by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/1
* Fixed bug in checkMask by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/2
* Fixed bug in en Passant move generation by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/3
* Fixed bug in makeMove by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/4
* Reworked pawn Move Generation + massive speed-up! by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/5
* Added GTest and Unit Tests by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/6
* Fixed bug when building fails with g++ 11.4.0 by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/8
* Refactoring - Split project into header and source files by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/9
* Feature/movegentype - Added MoveGenType to Move Generation by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/10
* Feature/evaluation - Added Evaluation by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/11
* Feature/zobrist - Added Zobrist Hashing by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/12
* Refactoring/externals - Moved googletest dependency to externals folder by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/13
* Feature/transpositon_table - Added transposition table by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/14
* Feature/search - Added basic search by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/15
* Feature/move_ordering - Added MoveOrdering by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/16
* Feature/uci - UCI temporarily done by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/17
* Feature/iterative deepening - Added Iterative Deepening by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/18
* Fixed bug in uciToMove which causes Segmentation Fault by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/20
* Modified Transposition Table that causes illegal move by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/22
* Fixed bug that Engine doesn't checkmate by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/24
* Fixed bug that caused illegal PV nodes by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/25
* Fixed bug in initialization of zobrist hash by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/27
* Fixed illegal move bug before repetition occurs by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/29
* Added some small features by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/30
* Feature/time control - Added time control by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/31
* Cleanup of whole project by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/32
* Documentation - Added documentation by @marcel-gerber in https://github.com/marcel-gerber/ChessEngine/pull/33

## New Contributors
* @marcel-gerber made their first contribution in https://github.com/marcel-gerber/ChessEngine/pull/1

**Full Changelog**: https://github.com/marcel-gerber/ChessEngine/commits/v1.0

amelia

Joey Bednar (San Diego, CA)
Chess engine accepting challenges on lichess.org
C, Makefile, Shell
https://github.com/joey-bednar/amelia

v0.15
2024-10-06 21:13 UTC
https://github.com/joey-bednar/amelia/releases/tag/v0.15

Added UCI functionality and various search/evaluation improvements.

- Added late move reduction
- Added support for UCI stop command
- Added evaluation bonus to bishop pair
- Fixed bug in repetition detection
- Refactored floating point to integer math

**v0.15 vs v0.14:** 110 wins, 42 draws, 33 losses (0.708)

**Elo increase:** 154.0 +/- 47.3

seawall

Pétur Runólfsson
An UCI chess engine
C++, Shell, Makefile
https://github.com/petur/seawall

Release 20240926.
2024-09-26 18:57 UTC
https://github.com/petur/seawall/releases/tag/r20240926

Goldfish

Bendik Samseth (Norway)
Goldfish - Stockfish's very distant and not so bright cousin - a UCI chess engine
Rust, Python, Shell, Makefile
https://github.com/bsamseth/Goldfish

Bugfix: Draw by repetition (again)
2024-09-21 07:06 UTC
https://github.com/bsamseth/Goldfish/releases/tag/v2.1.1

## What's Changed
* Bugfix: Draw by repetition again by @bsamseth in https://github.com/bsamseth/Goldfish/pull/49


**Full Changelog**: https://github.com/bsamseth/Goldfish/compare/v2.1.0...v2.1.1

uci-rs

Ankit Goel (Ireland)
A library to programmatically communicate with UCI compatible chess engines
Rust
https://github.com/crazymerlyn/uci-rs

uci 0.2.0
2024-09-10 21:21 UTC
https://github.com/crazymerlyn/uci-rs/releases/tag/v0.2.0

* Make Engine Cloneable.

Bagatur

Krasimir Topchiyski (Bulgaria)
Java Chess Engine (UCI compatible)
Java, C++, C, Makefile, Batchfile, Shell
https://github.com/bagaturchess/Bagatur

5.1c
2024-08-28 09:56 UTC
https://github.com/bagaturchess/Bagatur/releases/tag/v5.1c

* Fix *.sh scripts and make them working
* Revise how the distribution looks like:
* Pack all java classes and NNUE data file into a single jar file
* Move bat/sh scripts to the root of the distribution
* Add a configured main class to run the engine in order to remove the necessary program arguments in the scripts

Reckless

Arseniy Surkov
UCI chess engine written in Rust
Rust, Makefile
https://github.com/codedeliveryservice/Reckless

Reckless v0.7.0
2024-08-23 19:40 UTC
https://github.com/codedeliveryservice/Reckless/releases/tag/v0.7.0

## Release Notes

The NNUE hidden layer size has been increased from 128 to 384, further improved by adding 4 output buckets (#56) and material scaling (#62). The final architecture is `(768 -> 384)x2 -> 1x4`.

## Changelog

### Time management

- Time adjustment based on score stability (#50)
- Time adjustment based on best move stability (#42)

### Performance optimizations

- Allocate a quiet move list on the stack (#51)
- Implement operation fusion for NNUE (#58)
- Optimize accumulator handling (#59)

### Various search improvements

- History tuning (#39)
- Null Move Pruning tuning (#54)
- Check extensions before the move loop (#40)
- Disable quiescence search pruning for recaptures (#35)
- Treat non-winning captures as unfavorable in quiescence search (#57)
- Static Exchange Evaluation (#36, #37, #44, and #61)
- Fully fractional LMR (#60)

### Features

- Mate Distance Pruning (#43)
- Multi-threaded transposition table initialization (#63)

**Full Changelog**: https://github.com/codedeliveryservice/Reckless/compare/v0.6.0...v0.7.0

## Self-Play Benchmark Against v0.6.0

STC 8.0+0.08s

Elo | 172.12 +- 11.31 (95%)
Conf | 8.0+0.08s Threads=1 Hash=32MB
Games | N: 2000 W: 1007 L: 90 D: 903
Penta | [6, 38, 229, 487, 240]

LTC 40.0+0.4s

Elo | 154.77 +- 13.83 (95%)
Conf | 40.0+0.40s Threads=1 Hash=128MB
Games | N: 1002 W: 449 L: 30 D: 523
Penta | [0, 16, 136, 263, 86]

Trinket

Daniel Ke (America)
I love giving Trinkets and Checkmates to my friends and family :)
Rust, Makefile
https://github.com/DkeRee/Trinket

Trinket V3.5.0
2024-07-24 04:05 UTC
https://github.com/DkeRee/Trinket/releases/tag/V3.5.0

Roughly 650 elo stronger. May be buggy.
https://computerchess.org.uk/ccrl/404/cgi/engine_details.cgi?print=Details&each_game=1&eng=Trinket%203.5.0%2064-bit#Trinket_3_5_0_64-bit

Thrawn

Feiyu Lin
UCI compliant NNUE chess engine @ ~2800 ELO
C++, Makefile, C
https://github.com/feftywacky/Thrawn

Thrawn v2.1
2024-07-16 02:19 UTC
https://github.com/feftywacky/Thrawn/releases/tag/v2.1

Changes:
- Support for ARM chips
- Compilation support for Windows, MacOS, and, Linux

IMPORTANT NOTE: nnue file must be placed in the same directory of the executable or the engine will play random moves

Clarity

Joseph Pasfield
UCI chess engine with NNUE evaluation
C++, CMake, C, Makefile
https://github.com/Vast342/Clarity

Clarity V7.2.0
2024-07-01 02:27 UTC
https://github.com/Vast342/Clarity/releases/tag/V7.2.0

I am back once again!

More crashes were found, many fixes were tried, and this one seems to work! I have played nearly 1000 games without a crash when before, with the same testing configuration, it crashed roughly 1 out of every 40 games. I deem that good enough.


I also have made it accept input during searches, which means that ***Banksia support is back!***

---
### How to choose what binary to use:

Each binary here is separated by the features that your CPU has, v1 has a simple popcnt instruction, but I'm not sure about v2, and v3 is divided into bmi2 and magic bitboard builds (if you have a Ryzen 3000 series CPU, go for the v3_magic), and v4 has everything.

If you are unsure about what features your CPU has, start from v4 and attempt to run it, if it doesn't run, move one lower, and keep doing that until a build runs. If none of them run, open an issue and I'll attempt to help.

Renegade

Krisztián Peőcz (Budapest)
A strong chess engine using a neural network to evaluate positions
C++, Python, C, Rust, Makefile
https://github.com/pkrisz99/Renegade

Renegade 1.1.0
2024-06-26 19:00 UTC
https://github.com/pkrisz99/Renegade/releases/tag/v1.1.0

**Renegade 1.1.0** (June 26, 2024)

It's been a while, but it's time for another release!

Renegade now features a bigger and much better neural network. The final iteration was trained on over 2.7 billion positions obtained from self-play of various development versions. FRC support was added, and the training dataset now includes a small portion of DFRC games as well.

A few search improvements had been made, but the more notably, a big part of the code was rewritten now that I'm more experienced with engine development. This has little effect on playing strength, but it is good for my sanity, and for everyone who dares to look at the source code, though still plenty of work left to be done in this regard.

As always, huge thanks to everyone who ran tests, tournaments, and to those who helped me and gave me feedback, I appreciate you all!

**Changelog**
- Neural net improvements
- Regenerated the whole dataset, now amounting to over 2.78 billion positions
- Increased arch size, now (768->1024)x2->1
- Using QA=255 quantization again with improved order of operations
- Training with tapered WDL proportion
- Search improvements
- Added double extensions
- Added multicut for non-PV nodes
- Adjusting reductions in LMR based on cutoff count
- Changed RFP margin calculations when improving
- When not improving, reduced move counts before LMP kicks in
- Reduced default aspiration window size
- Not performing futility pruning if the history score is high enough
- Added FRC (and DFRC) support
- Simplifications
- No longer reducing less when giving check
- Removed fallback move ordering method when history score is 0
- Removed additional en passant threat calculations when previous move was a pawn double push
- Support for search parameter tuning
- Performance improvements
- Using static move lists in move generation
- Partial insertion sort for faster move ordering
- Not recalculating the whole hash after a null move
- More efficient calculation of threats
- Prefetching for null-move pruning
- Added a proper (but not great) way of checking move legality
- Refactored code
- Saner separation of files
- Rewritten position handling
- Updated WDL models

**Progression testing:** (10s+0.1, Pohl.pgn)

Score of Renegade 1.1.0 vs Renegade 1.0.0: 520 - 87 - 393 [0.717] 1000
... Renegade 1.1.0 playing White: 417 - 3 - 81 [0.913] 501
... Renegade 1.1.0 playing Black: 103 - 84 - 312 [0.519] 499
... White vs Black: 501 - 106 - 393 [0.698] 1000
Elo difference: 161.1 +/- 17.2, LOS: 100.0 %, DrawRatio: 39.3 %

You know the drill, expect less for balanced books and against other engines.

The provided binaries are targeting `x86-64-bmi2` (`v3` microarchitecture level).

Throttle

Dragjon (Singapore, Singapore)
Throttle - A UCI chess engine in C#
C#, GLSL, Makefile
https://github.com/Dragjon/Throttle

v3.2.2
2024-05-29 17:32 UTC
https://github.com/Dragjon/Throttle/releases/tag/v3.2.2

- King cornering
- Mate distancing pruning
- More UCI options
- Bugfix

mcu-max

Gissio
A low-resource chess engine for MCUs
C
https://github.com/Gissio/mcu-max

1.0.5
2024-05-01 12:37 UTC
https://github.com/Gissio/mcu-max/releases/tag/1.0.5

**Full Changelog**: https://github.com/Gissio/mcu-max/compare/1.0.4...1.0.5

Victoire

Mattéo Delucchi (Strasbourg, France)
A UCI chess engine written in Zig.
Zig
https://github.com/MattEstHaut/Victoire

1.3.0
2024-04-11 16:31 UTC
https://github.com/MattEstHaut/Victoire/releases/tag/1.3.0

# ⚙️ 1.3.0 Release

## Changelog

- Add `go infinite`
- Improve heuristic evaluation
- Fix bugs

berserk

Jay Honnold (Tempe, AZ)
UCI Chess Engine written in C
C, Shell, C++, Makefile
https://github.com/jhonnold/berserk

Berserk 13
2024-03-31 05:10 UTC
https://github.com/jhonnold/berserk/releases/tag/13

## Details

Berserk 13 is officially available!

**LTC vs Berserk 12**
Elo | 52.78 +- 3.25 (95%)
Conf | 60.0+0.60s Threads=1 Hash=64MB
Games | N: 20034 W: 6114 L: 3094 D: 10826
Penta | [12, 1122, 4775, 4050, 58]
http://chess.grantnet.us/test/36089/

## Thanks

Berserk wouldn't be possible without Andrew Grant (Ethereal + Torch), Finn Eggers (Koivisto + Torch), and Kim Kåhre (Koivisto + Torch). They are excellent developers with an immeasurable amount of knowledge - it is a pleasure to discuss CC concepts with them and have the opportunity to work alongside them on the Torch Chess Engine.

## Choosing a binary
Binaries currently require `popcnt`. Each binary is labeled with a standard minimum instruction set requirement. `x86-64`, `sse2`, `ssse3`, `avx2` and `avx512`.

For those labeled with `pext`, your system requires `bmi2` support. For AMD users, if you're using a Zen or Zen 2 processor, you should avoid the `pext` binaries as they will be slow.

If you're unsure which to use or what your processor supports
- Download them all
- Open them and run `go depth 24`
- If it crashes, you can't use it.
- Pick the fastest one

I highly recommend you follow the [build guide](https://github.com/jhonnold/berserk#building) in the readme to compile your own version. This will generate a native build for your machine and should be optimal as a result.

#### Contacting

I can be reached in the OpenBench discord if you'd like a custom binary for your system and can't compile it yourself.

Zagreus

Danny Jelsma (The Netherlands)
Zagreus is a UCI Chess Engine. Currently around ~2100 ELO Rapid on Lichess.
C++, CMake, Dockerfile
https://github.com/Dannyj1/Zagreus

v5.0
2024-03-18 10:38 UTC
https://github.com/Dannyj1/Zagreus/releases/tag/v5.0

## ELO Change (self-play)
Elo | 113.74 +- 16.13 (95%)
SPRT | 60.0+0.60s Threads=1 Hash=64MB
LLR | 2.95 (-2.94, 2.94) [0.50, 2.50]
Games | N: 1474 W: 787 L: 321 D: 366
Penta | [27, 73, 235, 211, 191]

## What's Changed
* Check extension in search by @Dannyj1 in https://github.com/Dannyj1/Zagreus/pull/71
* Fix check extension causing less TT hits by @Dannyj1 in https://github.com/Dannyj1/Zagreus/pull/72
* Late Move Reduction by @Dannyj1 in https://github.com/Dannyj1/Zagreus/pull/73
* Bias tuner towards smaller evaluation values by lowering base values by @Dannyj1 in https://github.com/Dannyj1/Zagreus/pull/74
* Tuner: Five-point Stencil Approximation, Train for multiple epochs, accuracy improvements & bug fixes by @Dannyj1 in https://github.com/Dannyj1/Zagreus/pull/76
* Fix compilation by @Dannyj1 in https://github.com/Dannyj1/Zagreus/pull/77


**Full Changelog**: https://github.com/Dannyj1/Zagreus/compare/v4.1...v5.0

CeeChess

bctboi23
UCI / Xboard compliant chess engine written in C
C, Makefile
https://github.com/bctboi23/CeeChess

CeeChess 1.4 - The tuning update
2024-02-16 07:25 UTC
https://github.com/bctboi23/CeeChess/releases/tag/v1.4

+150 ELO self-play (1s / move)

- Increased Futility and Reverse Futility Pruning Depths
- Tweaked LMR
- Cleaner, easier to understand code
- Researches null window first before searching full window
- Added Second Set of Killer Moves
- Added King Safety in the form of King Tropism
- Extra bonus to diagonals in line with the king
- Extra bonus to attack if enemy king is near semi-open files
- Weighted by attacker's material
- Evaluation tuned using a logistic regression over a custom constructed dataset, similar to the Texel Method
- Black box tuning was done using Simulated annealing + local search, using a pseudo-huber loss
- pseudo-huber loss was used here since there are likely outliers that would unfavorably skew the relatively simple evaluation function. This was a choice I made based on what I understood about the dataset, and made a marginal improvement to the evaluation quality as opposed to the traditional MSE loss (+10ish elo from 2000 games). If my evaluation were more complex, I might be more tempted to stay with MSE loss, as long as on-board checkmates are removed from the dataset
- Fixed some timeout bugs
- Increased hash table stability
(95)

Gauntlet run for test ratings (1 min, 0.5sec inc), with elo centered around the v1.4 release (ratings from bayeselo):
| Rank | Name | Elo | + | - | Games | Score | Oppo. | Draws |
|------|---------------------------|------|-----|-----|-------|-------|-------|-------|
| 1 | Barbarossa-0.6.0 | 38 | 34 | 33 | 240 | 55% | 95 | 23% |
| 2 | CeeChess-v1.4 | 0 | 13 | 13 | 1664 | 65% | -13 | 26% |
| 3 | Barbarossa-0.5.0-win10-64| -34 | 33 | 33 | 240 | 45% | 95 | 28% |
| 4 | Kingfisher.v1.1.1 | -107 | 32 | 33 | 240 | 34% | 95 | 36% |
| 5 | gopher_check | -146 | 34 | 35 | 238 | 29% | 95 | 26% |
| 6 | CeeChess 1.3.2 | -149 | 34 | 36 | 238 | 29% | 95 | 25% |
...

Since CCRL ratings got adjusted down recently (stockfish went from 3900 CCRL to ~3630 afaik), this no longer breaks the CCRL 2400 barrier, but comparing the results here to the old ratings of Barbarossa-0.6.0(2468), Barbarossa-0.5.0(~2375ish i believe?) and the others suggests that this release would have broken that barrier. I now expect the engine to land in the range of 2300-2350, given Barbarossa-0.6.0 has a new rating of 2355

Leorik

lithander
Leorik is a strong, open-source UCI chess engine written in C#
C#
https://github.com/lithander/Leorik

Leorik 3.0
2024-02-05 23:16 UTC
https://github.com/lithander/Leorik/releases/tag/3.0

Leorik 3.0 replaces the previously used HCE with a NNUE based evaluation.

The architecture is (768->256)x2->1 which means that the network uses 768 inputs (2 colors x 6 piece-types x 64 squares) and one hidden layer of 256 neurons. It maintains two separate accumulators (from black's perspective and from white's perspective) and has two sets of output weights to allow the network to learn tempo. It uses quantization (16bit integers) and AVX2 intrinsics so that 16 "synapses" can be processed in parallel. And of course the two accumulators are updated "efficiently", that is incrementally, by adding and subtracting weights when a piece moves or captures.
The network was trained using [Bullet](https://github.com/jw1912/bullet) on 622M labeled positions extracted from selfplay games.

Other notable changes since the previous released version (v2.5) are [Aspiration Windows](https://www.chessprogramming.org/Aspiration_Windows) and a revamped Staged Move Generation that replaces the 2nd Killer with a [Counter](https://www.chessprogramming.org/Countermove_Heuristic) and FollowUp move if available.

Polyfish

Khalid Omar
UCI chess engine derived from Stockfish with added support for for various chess book formats
C++, Makefile, C, Batchfile, Shell
https://github.com/khalid-a-omar/Polyfish

Polyfish 20240114
2024-01-14 17:54 UTC
https://github.com/khalid-a-omar/Polyfish/releases/tag/20240114

## Change log

[Merge with latest Stockfish development branch (last revision: b5e8169a85f6937d7d9d90612863fe5eec72d6ca)](https://github.com/khalid-a-omar/Polyfish/commit/bfb26547b81a3000bcc0021ec8ecfddc247fedcd)

## Windows Release files (64-bit)
[Windows_Polyfish_240114_x86-64-vnni512.zip](https://github.com/khalid-a-omar/Polyfish/releases/download/20240114/Windows_Polyfish_240114_x86-64-vnni512.zip)
[Windows_Polyfish_240114_x86-64-vnni256.zip](https://github.com/khalid-a-omar/Polyfish/releases/download/20240114/Windows_Polyfish_240114_x86-64-vnni256.zip)
[Windows_Polyfish_240114_x86-64-avx512.zip](https://github.com/khalid-a-omar/Polyfish/releases/download/20240114/Windows_Polyfish_240114_x86-64-avx512.zip)
[Windows_Polyfish_240114_x86-64-bmi2.zip](https://github.com/khalid-a-omar/Polyfish/releases/download/20240114/Windows_Polyfish_240114_x86-64-bmi2.zip)
[Windows_Polyfish_240114_x86-64-avx2.zip](https://github.com/khalid-a-omar/Polyfish/releases/download/20240114/Windows_Polyfish_240114_x86-64-avx2.zip)
[Windows_Polyfish_240114_x86-64-sse41-popcnt.zip](https://github.com/khalid-a-omar/Polyfish/releases/download/20240114/Windows_Polyfish_240114_x86-64-sse41-popcnt.zip)

## Linux Release files (64-bit)
[Linux_Polyfish_240114_x86-64-vnni512.zip](https://github.com/khalid-a-omar/Polyfish/releases/download/20240114/Linux_Polyfish_240114_x86-64-vnni512.zip)
[Linux_Polyfish_240114_x86-64-vnni256.zip](https://github.com/khalid-a-omar/Polyfish/releases/download/20240114/Linux_Polyfish_240114_x86-64-vnni256.zip)
[Linux_Polyfish_240114_x86-64-avx512.zip](https://github.com/khalid-a-omar/Polyfish/releases/download/20240114/Linux_Polyfish_240114_x86-64-avx512.zip)
[Linux_Polyfish_240114_x86-64-bmi2.zip](https://github.com/khalid-a-omar/Polyfish/releases/download/20240114/Linux_Polyfish_240114_x86-64-bmi2.zip)
[Linux_Polyfish_240114_x86-64-avx2.zip](https://github.com/khalid-a-omar/Polyfish/releases/download/20240114/Linux_Polyfish_240114_x86-64-avx2.zip)
[Linux_Polyfish_240114_x86-64-sse41-popcnt.zip](https://github.com/khalid-a-omar/Polyfish/releases/download/20240114/Linux_Polyfish_240114_x86-64-sse41-popcnt.zip)

## Release binaries have the following nets embedded

- Big net: [nn-baff1edbea57.nnue](https://tests.stockfishchess.org/api/nn/nn-baff1edbea57.nnue)
- Small net: [nn-baff1ede1f90.nnue](https://tests.stockfishchess.org/api/nn/nn-baff1ede1f90.nnue)

pawn

Rui Coelho (Porto)
An experimental UCI chess engine
C++, C, Makefile
https://github.com/ruicoelhopedro/pawn

pawn 3.0
2024-01-12 18:05 UTC
https://github.com/ruicoelhopedro/pawn/releases/tag/v3.0

In this release, support for Chess960 is added.
Furthermore, this version introduces a new NNUE architecture and some search improvements. In self-play, an improvement of roughly 100 Elo has been observed, and the new version wins on average 16 more game pairs than it loses.

LTC vs pawn 2.0
Games: 2000/2000 Elo diff: 103.16 [94.59, 111.86] (95%)
W: 628 L: 51 D: 1321 Draw ratio: 66.0%
Pntl: [0, 30, 481, 371, 118]

seer-nnue

connormcmonigle
UCI chess engine using neural networks for position evaluation
C++, C, Makefile, Python
https://github.com/connormcmonigle/seer-nnue

seer-v2.8.0
2023-12-31 18:08 UTC
https://github.com/connormcmonigle/seer-nnue/releases/tag/v2.8.0

This release adds an estimated 50 Elo in self play under UHO testing conditions. This improvement in strength can be attributed to an improved network fine-tuned exclusively on a self play game result (WDL) target, improved repetition detection, SPSA search parameter tuning and a number of miscellaneous search refinements. As was the case for the prior release, the embedded network was trained solely on data originating from Seer produced by way of many self play iterations starting with the initial "retrograde learning" network bundled with v2.0.0-v2.1.0 as a base.

Elo | 52.22 +- 3.42 (95%)
Conf | 40.0+0.40s Threads=1 Hash=64MB
Games | N: 20002 W: 6531 L: 3547 D: 9924
Penta | [33, 1217, 4716, 3803, 232]
http://chess.grantnet.us/test/34901/

Thanks to everyone involved with the OpenBench project for making Seer's continued development possible!

Flengine

Team Flyndre (Germany)
A UCI chess engine.
Java
https://github.com/flyndre/Flengine

Release v1.0.0
2023-12-30 17:37 UTC
https://github.com/flyndre/Flengine/releases/tag/v1.0.0

Release zur Projektabgabe.

juliette

Alan Tao (Atlanta, Georgia)
Computer program that plays chess.
C++, Python, C
https://github.com/alantao912/juliette

v1.0.0
2023-12-14 10:16 UTC
https://github.com/alantao912/juliette/releases/tag/v1.0.0

First official release of juliette, a multi-threaded alpha-beta chess engine!

Notable Features:
- Negamax principle variation search
- Iterative deepening
- Quiescence search
- Futility pruning
- Delta pruning
- History heuristic
- Killer heuristic
- Hand crafted evaluation
- LazySMP multi-threading

Special thanks to my good friend Devin Zhang, for collaboration and fruitful discussion!

lunachess

Thomas Mergener (Rio de Janeiro, RJ, Brazil)
A UCI chess engine.
C++, C, Python, CMake
https://github.com/Mergener/lunachess

Luna 2.0.0
2023-09-24 06:43 UTC
https://github.com/Mergener/lunachess/releases/tag/luna_2.0.0

## Release Notes

Very excited to announce that version 2.0.0 is out!

**This release is about 260 Elo points stronger than it's predecessor in STC and 220 in LTC!**

## Comparison with previous version

### Test configuration
#### STC
* Time control: 8+0.08
* Opening book: 8moves_v3.pgn
* Hash: 32MB

#### LTC
* Time control: 60+1
* Opening book: 8moves_v3.pgn
* Hash: 32MB

### Test results

#### STC (compat version)
Score of Luna 2.0.0 vs Luna 1.1.0: 368 - 37 - 105 [0.825] 510
... Luna 2.0.0 playing White: 190 - 21 - 44 [0.831] 255
... Luna 2.0.0 playing Black: 178 - 16 - 61 [0.818] 255
... White vs Black: 206 - 199 - 105 [0.507] 510
Elo difference: 268.8 +/- 32.0, LOS: 100.0 %, DrawRatio: 20.6 %

#### STC (AVX2 version)
Score of Luna 2.0.0 vs Luna 1.1.0: 843 - 80 - 187 [0.844] 1110
... Luna 2.0.0 playing White: 420 - 45 - 91 [0.837] 556
... Luna 2.0.0 playing Black: 423 - 35 - 96 [0.850] 554
... White vs Black: 455 - 468 - 187 [0.494] 1110
Elo difference: 292.9 +/- 23.3, LOS: 100.0 %, DrawRatio: 16.8 %

#### LTC (compat version)
Score of Luna 2.0.0 vs Luna 1.1.0: 730 - 113 - 249 [0.783] 1100
... Luna 2.0.0 playing White: 383 - 47 - 115 [0.808] 545
... Luna 2.0.0 playing Black: 347 - 66 - 134 [0.757] 547
... White vs Black: 449 - 394 - 249 [0.525] 1092
Elo difference: 222.4 +/- 20.4, LOS: 100.0 %, DrawRatio: 22.8 %

## Changelog

* Staged movegen rewritten
* Many more generation stages
* Stage ordering changed (killer moves are now searched before bad captures)
* Quiet move ordering revamped
* Improved TT replacement policy
* Removed TT cleanup before searches
* New search features
* Reverse Futility Pruning (aka Static Null Move Pruning)
* Razoring
* Internal Iterative Deepening
* PVS SEE Pruning
* Added tempo score
* Added previously hardcoded king safety weights to weights.json and tuned them
* Improved HCE tuning
* Added seldepth output

beast

Miloslav Macůrek (Brno)
UCI chess engine
Python, Batchfile
https://github.com/maelic13/beast

Beast 2.0 Classical
2023-08-12 14:51 UTC
https://github.com/maelic13/beast/releases/tag/v2.0

Classical evaluation only release of Beast chess engine. For neural network version, check out release Beast 2.0 Neural.

**Highlights**
+ complete re-write of engine
+ 100% speed-up

megalodon

Megalodon Chess (California)
Chess engine with the UCI protocol
C++, Python, Shell, CMake
https://github.com/megalodon-chess/megalodon

Megalodon 1.1.0
2023-07-01 02:26 UTC
https://github.com/megalodon-chess/megalodon/releases/tag/v1.1.0

This release adds opening book functionality to Megalodon. This is currently toggleable through the UCI option `OwnBook`. By default, it is set to false. In order to successful use this functionality though, it is required to have a `openings.txt` file in the same directory that you run Megalodon. The file must be formatted such that on each new line there is a sequence of moves notated with the UCI format, nothing else. We have provided an example `openings.txt` file in the `openings` folder.

RapCpw

Thibor
2500 uci elo chess engine
C++, C
https://github.com/Thibor/RapCpw


2023-05-20 17:11 UTC
https://github.com/Thibor/RapCpw/releases/tag/2023-05-20

RapShortCs

Thibor
CSharp Small Chess Engine
C#
https://github.com/Thibor/RapShortCs


2023-02-21 12:07 UTC
https://github.com/Thibor/RapShortCs/releases/tag/2023-02-21

BookReaderMem

Thibor
This program can read and add moves to chess openig book with mem extension
C#
https://github.com/Thibor/BookReaderMem


2023-02-02 22:39 UTC
https://github.com/Thibor/BookReaderMem/releases/tag/2023-02-02

swindle

Noah Klein (New York)
The Swindle chess engine
Go, Shell
https://github.com/noahklein/swindle

v2.1.0
2023-01-17 09:04 UTC
https://github.com/noahklein/swindle/releases/tag/v2.1.0

## Changelog * 195fec0 Add ctrl+c capture to puzzles * aedd2a6 Add fen parsing to position UCI command * 5734483 Add negative tag search to puzzle package * 686302d Bump version, fix tests * adb142c Create bitboard package for common bitboard operations * b0107e8 Huge improvement: futility pruning, passed and isolated pawns, and basic king safety * d459a7c Improve depth reduction/extensions * 9ad604f Passed pawns in eval * b5704fe Rewrite move sorter to use an incremental insertion sort * 65263dd Upgrade dragon to v1.2.2 to fix check bug * 7d1e1b0 improve bitboard package

Koivisto

Finn Eggers (Aachen)
UCI Chess engine
C++, C, Makefile, CMake
https://github.com/Luecx/Koivisto

Koivisto 9.0
2023-01-15 22:12 UTC
https://github.com/Luecx/Koivisto/releases/tag/v9.0

Today, we are excited to announce the release of Koivisto 9. After a six-month break, we are back and eager to continue development. The majority of the strength increase since Koivisto 8 comes from improvements in training data, but we also made some small search adjustments.

ELO | 89.70 +- 3.53 (95%)
CONF | 8.0+0.08s Threads=1 Hash=8MB
GAMES | N: 20000 W: 7876 L: 2824 D: 9300

We had the pleasure of working with Jay (author of Berserk) which resulted in both of our engines merging and sharing a neural network training framework as well as training data. This collaboration led to a significant increase in strength:

ELO | 19.41 +- 6.65 (95%)
SPRT | 40.0+0.40s Threads=1 Hash=64MB
LLR | 2.95 (-2.94, 2.94) [0.00, 2.50]
GAMES | N: 5072 W: 1369 L: 1086 D: 2617

ELO | 20.02 +- 6.80 (95%)
SPRT | 8.0+0.08s Threads=1 Hash=8MB
LLR | 2.96 (-2.94, 2.94) [0.00, 2.50]
GAMES | N: 4968 W: 1373 L: 1087 D: 2508

The addition of more training data also contributed to nice gains:

ELO | 29.79 +- 2.91 (95%)
CONF | 8.0+0.08s Threads=1 Hash=8MB
GAMES | N: 16848 W: 3334 L: 1893 D: 11621

Although we don't have regression tests to show for the search improvements and speed-ups, they are where the rest of the gains come from. Attached you can find executables for AVX2 and SSE systems. Executables for PEXT and/or AVX512 systems are available via Ipman.

With love and appreciation,
Finny and Kimmy.

zerofish

Petr Pravda
UCI chess engine
Java, TypeScript, Rust, Python, JavaScript, Shell, HTML
https://github.com/petrpravda/zerofish

v0.1.0 This is initial release. Common UCI syntax is supported. The engine works.
2023-01-02 20:30 UTC
https://github.com/petrpravda/zerofish/releases/tag/v0.1.0

## Changes
* Alpha-beta pruning
* Aspiration search
* Transposition table
* Quiescence
* Iterative deepening
* Null-move heuristics
* Late move reductions
* Zobrist hashing

## Installation
The chess engine is available for Linux and requires a 64-bit CPU.
It can be build however for other platforms easily.

BookReaderUci

Thibor
Chess engine bridge reading file with moves in uci format
C#
https://github.com/Thibor/BookReaderUci


2022-12-31 12:09 UTC
https://github.com/Thibor/BookReaderUci/releases/tag/2022-12-31

binbo

Sergei Semichev
Chess representation written in Erlang using Bitboards, ready for use on game servers
Erlang, Makefile, Batchfile
https://github.com/DOBRO/binbo

Binbo 4.0.3
2022-07-09 13:59 UTC
https://github.com/DOBRO/binbo/releases/tag/4.0.3

- Unused function `binbo_position:get_side_indexes/2` deleted.
- Fixed OTP-25 dialyzer warnings.
- Added support for testing on Apple silicon SoC.


**Full Changelog**: https://github.com/DOBRO/binbo/compare/4.0.2...4.0.3

Cinnamon

Giuseppe Cannella (Milan, Italy)
C++ UCI chess engine
C++, C, HTML, Makefile, CMake
https://github.com/gekomad/Cinnamon

v2.5
2022-07-06 08:41 UTC
https://github.com/gekomad/Cinnamon/releases/tag/v2.5

- Time management
- Tapered eval

Weiawaga

Heiaha (Seattle, Washington)
A UCI chess engine written in Rust.
Rust
https://github.com/Heiaha/Weiawaga

v5.0
2022-04-23 03:19 UTC
https://github.com/Heiaha/Weiawaga/releases/tag/v5.0

This release introduces an evaluation function based on a NNUE-style architecture of input size 728, with 8 buckets of 256 hidden neurons which is chosen depending on the number of pieces left on the board. This network was trained on 125 million positions from self-play games using Weiawaga v4.0. The only new search change is the introduction of reverse futility pruning. The release also includes many minor optimizations, and is ~350 Elo stronger than Weiawaga v4.0.

chess-engine-eval-debugger

Giuseppe Cannella (Milan, Italy)
Chess engine web evaluator
JavaScript, HTML, Python, CSS
https://github.com/gekomad/chess-engine-eval-debugger

1.0
2022-01-11 16:04 UTC
https://github.com/gekomad/chess-engine-eval-debugger/releases/tag/1.0

Python3
Generate random fen
Script to generate csv file

Fairy-Stockfish

Fairy-Stockfish
chess variant engine supporting Xiangqi, Shogi, Janggi, Makruk, S-Chess, Crazyhouse, Bughouse, and many more
C++, Python, JavaScript, Makefile, Shell, C
https://github.com/fairy-stockfish/Fairy-Stockfish

Fairy-Stockfish 14.0.1 XQ
2021-11-19 15:05 UTC
https://github.com/fairy-stockfish/Fairy-Stockfish/releases/tag/fairy_sf_14_0_1_xq

This release is specifically for providing built-in [NNUE](https://en.wikipedia.org/wiki/Efficiently_updatable_neural_network) networks for Xiangqi and Janggi, so that the NNUE evaluation can be used without the need for any additional downloads or configuration. This release of course still supports all other variants, but for those you can also use the smaller standard releases without built-in NNUE.

With NNUE evaluation, playing strength for Xiangqi and Janggi is far surpassing classical Fairy-Stockfish, and reaching super-human level. See the test results below for comparison against Fairy-Stockfish without NNUE.

#### Xiangqi

STC (10''+0.1'')
ELO: 541.10 +-95.1 (95%) LOS: 100.0%
Total: 200 W: 184 L: 1 D: 15
LTC (30''+0.3'')
ELO: 541.10 +-107.7 (95%) LOS: 100.0%
Total: 200 W: 186 L: 3 D: 11

#### Janggi

STC (10''+0.1'')
ELO: 350.27 +-73.4 (95%) LOS: 100.0%
Total: 200 W: 172 L: 19 D: 9
LTC (30''+0.3'')
ELO: 297.95 +-67.2 (95%) LOS: 100.0%
Total: 200 W: 167 L: 28 D: 5

### Files of the release
* The `.nnue` files do **not** need to be downloaded. They are only included in the release so that the build can be reproduced from source if desired.
* `.exe` are Windows executables, the files without extensions are Linux binaries.
* Use `bmi2` versions for best performance on modern hardware, or [fairy-stockfish-largeboard_x86-64.exe](https://github.com/ianfab/Fairy-Stockfish/releases/latest/download/fairy-stockfish-largeboard_x86-64.exe) for best compatibility.
* This release does not contain non-largeboard binaries, since they would not support Xiangqi and Janggi.

Demolito

lucasart
UCI Chess Engine
C, Makefile
https://github.com/lucasart/Demolito

Demolito 20211004
2021-10-07 01:01 UTC
https://github.com/lucasart/Demolito/releases/tag/20211004

Adds human playable levels (see UCI option Level).

FrankyGo

Frank Kopp
Learning Go by implementing a Chess Engine
Go, Batchfile
https://github.com/frankkopp/FrankyGo

v1.0.3 Bugfix Release
2021-06-04 00:35 UTC
https://github.com/frankkopp/FrankyGo/releases/tag/v1.0.3

Updated some libraries to solve Snyk warnings

durandal

Roland Chastain (France)
UCI chess engine written in Pascal
Pascal
https://github.com/rchastain/durandal

Durandal 0.0.8
2021-03-02 11:30 UTC
https://github.com/rchastain/durandal/releases/tag/0.0.8

Gothic chess.

Chess-Engine-Rapchess

Thibor
Javascript uci chess engine and game
JavaScript, CSS, HTML
https://github.com/Thibor/Chess-Engine-Rapchess


2020-04-02 17:48 UTC
https://github.com/Thibor/Chess-Engine-Rapchess/releases/tag/2020-04-02

BerldChess

Bernt Nielsen
Tool for playing and analyzing chess games.
C#, F#, PowerShell
https://github.com/Bernton/BerldChess

Stability release
2019-05-29 20:57 UTC
https://github.com/Bernton/BerldChess/releases/tag/1.7

Mostly bug fixes and stability/performance improvements.

cuckoo

Torben (Karlsruhe, Germany)
This is an adaption of Peter Österlund's CuckooChess 1.12. The source code provided is a Java Maven project in UTF-8. The program, except for the chess font, is copyrighted by Peter Österlund, and is available as open source under the GNU GPL v3 license.
Java
https://github.com/sauce-code/cuckoo

2017-07-30: Version 1.12 (Maven Port)
2017-07-30 19:50 UTC
https://github.com/sauce-code/cuckoo/releases/tag/1.12

- Reuploaded the project on GitHub as an Eclipse Maven Project.
- Applied cleanup.
- Set required Java version to 1.8.