REMY measures its progress by playing other chess engines whose ratings are already known. Each of them is an
independent project, with its own creator, its own history and its own ideas about how a computer should play
chess. This page introduces them.
The engines are listed by the reference rating REMY's measurements use. That number is a fixed point on a scale,
taken from one snapshot of a rating list; it says nothing about how interesting an engine is, how much work went
into it, or how strong its latest release has become. The profiles are our own research from the engines' public
sources, which each one lists. The results against REMY come from REMY's measurement records.
By Missing Player (Kacper Wieczorek) · C++20 · Reference rating 786
A young C++ engine built around the evaluation of pawn structure; REMY played its first release, v1, from August 2026.
Full profile
MissingPawn is written in C++ by a developer who presents himself as Missing Player (Kacper Wieczorek). Its public repository was created in mid-August 2026, and version 1, the release REMY played, followed on 20 August 2026. The project describes itself as “a modern UCI chess engine focused on the strength of pawn structure”, built to be a platform for experimenting with search and evaluation techniques. Its README closes with a motto: “Even a pawn can decide the game.”
Version 1 looks ahead with alpha-beta search, which skips lines that cannot change the result, deepening one move at a time and following captures until the position is quiet. It also uses common shortcuts that spend less time on unpromising moves, such as null-move pruning and late-move reductions. At this version it had no transposition table, the memory of already-analysed positions that most engines keep. Its evaluation is hand-written, with separate rules for each kind of piece and for pawn structure, and no neural network. Its openings come from a book compiled into the program, with no option to switch it off.
MissingPawn has changed quickly since. Version 2 (September 2026) and version 3 (October 2026) reworked its evaluation and search; version 3 added a transposition table and automatic tuning of the evaluation, adopted a move generator derived from Stockfish's, and changed the licence from MIT to GPL-3.0. None of those changes is in the version REMY played.
REMY 5 (panel P4): 4 games; REMY 5 won 2, drew 1 and lost 1 (2.5 points of 4). From the run's record: MissingPawn was dropped at pair 8.
Reference rating 786: the engine's CCRL Blitz rating in the list snapshot REMY's runs used (computed October 17, 2026). How the ratings are measured.
Version REMY played: MissingPawn 1, tag v1, commit c0714f3, from its source repository; C++20; licence MIT (LICENSE at the tag; later relicensed GPL-3.0).
M
Megalodon 1.0.0
By the Megalodon team (Patrick Huang, Arjun Sahlot and others) · C++17 · Reference rating 930
A C++ engine written in spring 2021 by a small team of students, who reached version 1.0.0 after more than twenty releases in six weeks.
Full profile
Megalodon is an open-source chess engine written in C++ by a small team that described itself as “three students and one consultant”, with Patrick Huang and Arjun Sahlot as its core developers. The name comes from the giant prehistoric shark. Work began in early March 2021, and the first release, two days later, said plainly that the engine “does not function fully yet”. More than twenty releases followed in six weeks, and version 1.0.0, the one REMY played, came out on 14 April 2021. The team's release notes record the journey, including an unusual early version that searched breadth-first rather than depth-first.
Version 1.0.0 stores the board as bitboards, where the squares of each kind of piece are held as the bits of a single number. It chooses moves with alpha-beta search, deepened step by step, and keeps a transposition table, a memory of positions it has already analysed. Its evaluation is hand-written, and the weight of each part (material, pawn structure, space, and the knights, rooks, queens and kings) can be changed by the user as an engine option. Queen-against-king endings are played by a dedicated checkmating routine instead of by search. This version has no opening book.
The team's plans for a version 2.0.0 included late-move reductions, null-move pruning and neural networks; that version was never released. A later 1.1.0, in 2023, added an optional opening book. The team also began work on a chess interface called Hammerhead.
REMY 5 (panel P4): 150 games; REMY 5 won 55, drew 45 and lost 50 (77.5 points of 150).
REMY 6 (panel P5): 150 games; REMY 6 won 89, drew 45 and lost 16 (111.5 points of 150).
Reference rating 930: the engine's CCRL Blitz rating in the list snapshot REMY's runs used (computed October 17, 2026). How the ratings are measured.
Version REMY played: Megalodon 1.0.0, tag v1.0.0, commit e2830b2, from its source repository; C++17; licence GPL-3.0.
F
Fatalii 0.1.1
By Patrick Heck · Rust · Reference rating 1058
A Rust engine by Patrick Heck; REMY played its second release, 0.1.1, from February 2022, a much simpler program than Fatalii's later versions.
Full profile
Fatalii is written in Rust, the language REMY is written in, by Patrick Heck (FitzOReilly on GitHub), and released under the MIT licence. Its repository begins in September 2020. The first release, 0.1.0, came in February 2022, and 0.1.1, the version REMY played, ten days later, on 21 February 2022: a small update that, among other things, added the version number to the engine's name.
Version 0.1.1 is deliberately compact. It stores the board as bitboards (one bit per square for each kind of piece), searches with alpha-beta and iterative deepening, follows captures to the end with a quiescence search, and remembers positions in a transposition table. Its judgement of a position counts just two things: material, and how many moves each side has (its mobility). The README listed better move ordering and a better evaluation as “coming soon”, and credited the Chess Programming Wiki and open-source engines such as Stockfish and FabChess as resources.
Those plans were carried out over the following years: piece-square tables and move ordering in 0.2.0, Chess960 support in 0.3.0, pruning techniques from 0.4.0, an automatic tuner for the evaluation from 0.5.0, and releases continuing into 2026, each reported by its release notes as stronger than the last. The engine REMY measured against is an early snapshot of that project, and its reference rating describes 0.1.1 only. Fatalii also plays on Lichess as FataliiBot.
REMY 5 (panel P4): 150 games; REMY 5 won 13, drew 40 and lost 97 (33 points of 150).
REMY 6 (panel P5): 150 games; REMY 6 won 52, drew 50 and lost 48 (77 points of 150).
REMY 7 (panel P6): 120 games; REMY 7 won 99, drew 20 and lost 1 (109 points of 120).
Reference rating 1058: the engine's CCRL Blitz rating in the list snapshot REMY's runs used (computed October 17, 2026). How the ratings are measured.
Version REMY played: Fatalii 0.1.1, tag v0.1.1, commit 111cad5, from its source repository; Rust; licence MIT (LICENSE).
M
Minnow
By tm512 · C99 · Reference rating 1451
A small engine in C by tm512, begun in 2014 and still updated now and then; its author calls it “a simple and fairly weak chess engine”.
Full profile
Minnow is written in C by the developer tm512 and released under the MIT licence. Its author describes it as “a simple and fairly weak chess engine”. Work began in May 2014, and a week later a commit message reported that the engine “can play itself (badly) now”. Most of the work dates from 2014; the author returned to it in 2015, 2022, 2024 and 2025, mainly fixing bugs and improving how it works with chess interfaces and online play.
Minnow has no numbered releases, and the rating list names it simply “Minnow”, so REMY played the latest commit, from 21 May 2025, which identifies itself by that date. It keeps the board in a 10-by-12 grid, a classic layout whose extra border squares make it easy to tell when a piece runs off the board, together with lists of where the pieces stand. It searches with iteratively deepened alpha-beta, uses hash tables to remember positions and to order moves, tries captures of the most valuable pieces first, follows captures with a quiescence search, and uses the null-move heuristic, which passes a turn in its calculations to spot positions that are clearly good. Its hand-written evaluation counts material, uses piece-square tables (bonuses for pieces on good squares) and rewards keeping both bishops.
REMY 5 (panel P4): 150 games; REMY 5 won 0, drew 0 and lost 150 (0 points of 150).
REMY 6 (panel P5): 150 games; REMY 6 won 10, drew 14 and lost 126 (17 points of 150).
REMY 7 (panel P6): 120 games; REMY 7 won 77, drew 16 and lost 27 (85 points of 120).
Reference rating 1451: the engine's CCRL Blitz rating in the list snapshot REMY's runs used (computed October 17, 2026). How the ratings are measured.
Version REMY played: Minnow, no release tag, commit 0f9530b, from its source repository; C99; licence MIT-style.
S
Shallow Blue 2.0.0
By Rhys Rustad-Elliott · C++11 · Reference rating 1578
A C++ engine whose name is a nod to IBM's Deep Blue; version 2.0.0, from January 2019, is its latest release and the one REMY played.
Full profile
Shallow Blue is a chess engine written in C++ by Rhys Rustad-Elliott and released under the MIT licence. Its name makes a joke at its own expense: its README puts the words “(not Deep Blue)” under the logo, after the IBM computer that beat the world champion Garry Kasparov in 1997. Work began in June 2017 and version 1.0.0 followed in July, its release notes recording that “ridiculous amounts of coffee were consumed to get to this point”. Version 1.1.0, in January 2018, was titled “Bugfixes, major improvements and new features”.
Version 2.0.0, released in January 2019, is the latest release; the code has not changed since. It brought a faster move generator based on magic bitboards (a table-lookup technique for the long-range pieces), a tapered evaluation that blends middlegame and endgame judgement as material comes off the board, more detailed pawn and mobility evaluation, and check extensions. The engine stores the board as bitboards, searches with principal variation search (a refinement of alpha-beta) and iterative deepening, follows captures with a quiescence search, orders moves with hash, killer and history heuristics, and remembers positions in a transposition table. Its hand-set evaluation covers piece-square tables, pawn structure, king safety, the bishop pair, rooks on open files and mobility. The README lists null-move pruning and late-move reductions, two common pruning techniques, as future improvements. Shallow Blue can play from an opening book in the PolyGlot format; the book was switched off in REMY's games.
REMY 6 (panel P5): 150 games; REMY 6 won 1, drew 4 and lost 145 (3 points of 150).
REMY 7 (panel P6): 120 games; REMY 7 won 46, drew 31 and lost 43 (61.5 points of 120).
REMY 8 (panel P7): 100 games; REMY 8 won 63, drew 19 and lost 18 (72.5 points of 100).
Reference rating 1578: the engine's CCRL Blitz rating in the list snapshot REMY's runs used (computed October 17, 2026). How the ratings are measured.
Version REMY played: Shallow Blue 2.0.0, tag v2.0.0, commit a04fbd9, from its source repository; C++11; licence MIT.
W
Walleye 1.6.0
By Mitchel Paulin · Rust · Reference rating 1708
A Rust engine named after a fish, by Mitchel Paulin; version 1.6.0, from March 2022, is its latest release and the one REMY played.
Full profile
Walleye is a chess engine by Mitchel Paulin, a software developer in Canada, and like REMY it is written in Rust: its GitHub page calls it “a chess engine written from scratch in Rust”. The name refers to the walleye, a North American fish. Work began in May 2021, version 1.0.0 appeared that September, and a quick run of releases followed through the autumn; the notes for 1.3.0 say that “with this release the engine is ready to compete in a tournament setting”. Later 2021 versions improved the evaluation and added principal variation search, null-move pruning and a check extension. Version 1.6.0, from March 2022, added detection of threefold repetition and is the latest release. Walleye also plays on Lichess as Walleye_Bot.
Version 1.6.0 keeps the board in a 12-by-12 grid, an 8-by-8 board ringed by extra squares that make edge checks simple, rather than in bitboards. It searches with alpha-beta and iterative deepening, follows captures with a quiescence search, tries killer moves and captures of the most valuable pieces first, and uses null-move pruning, which passes a turn in its calculations to spot positions that are clearly good. It keeps no transposition table of positions already searched. Its evaluation uses piece-square tables based on the published PeSTO tables, blended between middlegame and endgame by how much material remains. It has no opening book by design: its author explained that opening books are usually left to the program that runs the engine.
REMY 7 (panel P6): 120 games; REMY 7 won 38, drew 20 and lost 62 (48 points of 120).
REMY 8 (panel P7): 100 games; REMY 8 won 53, drew 28 and lost 19 (67 points of 100).
Reference rating 1708: the engine's CCRL Blitz rating in the list snapshot REMY's runs used (computed October 17, 2026). How the ratings are measured.
Version REMY played: Walleye 1.6.0, tag 1.6.0, commit 46d8b98, from its source repository; Rust; licence MIT.
R
Rustic Alpha 3.0.0
By Marcel Vanthoor · Rust · Reference rating 1794
A Rust engine documented in its author's online book, The Rustic Book; REMY played Rustic Alpha 3.0.0, from June 2021.
Full profile
Rustic is a chess engine by Marcel Vanthoor, and like REMY it is written in Rust. On the “About me” page of his book he describes playing chess since childhood and a first attempt at a chess program in Pascal in the mid-1990s; he did not want to write an engine in C or C++, he explains, “because everybody else already had one”. The first code dates from the summer of 2019, and serious work began in 2020. Its README states that Rustic is not derived from any other engine, while it uses concepts long established in chess programming.
Alpha 1 was released in January 2021, Alpha 2 added a transposition table in March, and Alpha 3.0.0, the version REMY played, followed in June 2021 with killer moves and principal variation search. It stores the board as bitboards and generates moves with magic bitboard lookups, searches with alpha-beta and iterative deepening, follows captures with a quiescence search, extends the search when in check, and orders moves by the transposition table's suggestion, by captures of the most valuable pieces and by killer moves. Its evaluation counts material and uses one set of piece-square tables; its search has no null-move pruning or late-move reductions.
Vanthoor documents the engine in The Rustic Book, written so that a similar engine could be built in any programming language. Later Alpha 3 releases were maintenance updates, the last of them preparing the ground for a Rustic 4, and in 2025 the project moved from GitHub to Codeberg. The reference rating on REMY's scale describes Alpha 3.0.0 only.
Rustic on Codeberg (linked from Rustic's README; the page could not be opened when this profile was researched)
Against REMY
REMY 7 (panel P6): 120 games; REMY 7 won 24, drew 25 and lost 71 (36.5 points of 120).
REMY 8 (panel P7): 100 games; REMY 8 won 46, drew 26 and lost 28 (59 points of 100).
Reference rating 1794: the engine's CCRL Blitz rating in the list snapshot REMY's runs used (computed October 17, 2026). How the ratings are measured.
Version REMY played: Rustic Alpha 3.0.0, tag alpha-3.0.0, commit 8069312, from its source repository; Rust; licence GPL-3.0.
Z
Zahak 1.0.0
By Amanj Sherwany · Go 1.16 module · Reference rating 1940
A Go engine by Amanj Sherwany, named after a figure from Iranian and Kurdish mythology; REMY played version 1.0.0, from April 2021.
Full profile
Zahak is written in Go by Amanj Sherwany (amanjpro on GitHub) and released under the MIT licence. Its name comes from Zahhak, an evil figure in Iranian and Kurdish mythology who, as the README tells it, had two giant snakes growing from his shoulders. The project began in January 2021. Version 1.0.0, the one REMY played, was tagged on 6 April 2021, about ten weeks and some 450 commits later.
Its README at 1.0.0 calls it a work in progress, but its search already used most of the standard ideas: magic bitboards, alpha-beta with principal variation search and aspiration windows, a quiescence search, a transposition table, static exchange evaluation, null-move pruning, late-move reductions, razoring and check extensions. Its evaluation was written by hand: material, piece-square tables for the middlegame and the endgame, pawn structure, rooks on open files, and mobility.
Zahak kept growing after 1.0.0. Later versions switched to a neural-network evaluation (NNUE), and its README now reports an invitation to TCEC, one of the best-known engine tournaments, and entries on most major rating lists. It takes part in ZaTour, a tournament series for open-source and original engines hosted on its author's website, and plays on Lichess as zahak_engine.
REMY 8 (panel P7): 100 games; REMY 8 won 39, drew 13 and lost 48 (45.5 points of 100).
REMY 9 (panel P8): 100 games; REMY 9 won 69, drew 14 and lost 17 (76 points of 100).
Reference rating 1940: the engine's CCRL Blitz rating in the list snapshot REMY's runs used (computed October 17, 2026). How the ratings are measured.
Version REMY played: Zahak 1.0.0, tag 1.0.0, commit c27d626, from its source repository; Go 1.16 module; licence MIT (LICENSE).
S
Stash 14.0
By Morgan Houppin · C · Reference rating 2059
A C engine by Morgan Houppin; REMY played version 14, from April 2020, an early release that judges a position almost entirely by a value for each piece on each square.
Full profile
Stash is written in C by Morgan Houppin (mhouppin on GitLab) and released under the GNU General Public License, version 3. Its repository describes it in four words: “Just a Chess engine.” The project was created in October 2019, the first release came in February 2020, and new versions followed quickly: version 14, the one REMY played, came out on 10 April 2020. Stash has since reached version 37.0, released in April 2025.
Version 14 is small. Its evaluation is almost entirely piece-square tables, a value for each piece on each square that already includes what the piece is worth, blended between middlegame and endgame by how many pieces are left on the board, plus a bonus for keeping the right to castle. That makes it close in spirit to REMY 7 and REMY 8, which also judge a position with a value for every piece on every square, though REMY learns its values from its own games.
Its search does more of the work: alpha-beta with principal variation search, a quiescence search that settles captures, a transposition table, iterative deepening, and pruning that skips unpromising lines, namely razoring, null-move pruning and late-move reductions. Those are the same kinds of ideas REMY 8 added.
REMY 8 (panel P7): 100 games; REMY 8 won 28, drew 10 and lost 62 (33 points of 100).
REMY 9 (panel P8): 100 games; REMY 9 won 62, drew 17 and lost 21 (70.5 points of 100).
Reference rating 2059: the engine's CCRL Blitz rating in the list snapshot REMY's runs used (computed October 17, 2026). How the ratings are measured.
Version REMY played: Stash 14.0, tag v14, commit d87eaa3, from its source repository; C; licence GPL-3.0 (LICENSE).
F
Fatalii 0.5.0
By Patrick Heck · Rust · Reference rating 2208
A later release of the Rust engine by Patrick Heck that REMY first met as Fatalii 0.1.1: version 0.5.0, from October 2023.
Full profile
Fatalii 0.5.0 comes from the same project as Fatalii 0.1.1, the engine REMY 5, REMY 6 and REMY 7 were rated against: a chess engine written in Rust, the language REMY is written in, by Patrick Heck (FitzOReilly on GitHub), under the MIT licence. The project began in September 2020. Version 0.5.0 was tagged on 11 October 2023, twenty months after 0.1.1, and releases have continued since, up to 0.10.1.
Those twenty months changed it a great deal. Version 0.1.1 judged a position by material and mobility alone. Version 0.5.0 adds piece-square tables, pawn structure (passed, isolated, backward and doubled pawns), a bonus for the bishop pair and for having the move, all blended between the middlegame and the endgame. Its search gained principal variation search, aspiration windows, null-move and futility pruning, and several ways of trying the most promising moves first. It also plays Chess960.
The values in its evaluation were tuned automatically on a published set of positions, the Zurichess quiet-labeled set. Its README thanks the Chess Programming Wiki, other open-source engines, Lichess, where it plays as FataliiBot, and CCRL for rating it.
REMY 8 (panel P7): 100 games; REMY 8 won 10, drew 9 and lost 81 (14.5 points of 100).
REMY 9 (panel P8): 100 games; REMY 9 won 38, drew 22 and lost 40 (49 points of 100).
Reference rating 2208: the engine's CCRL Blitz rating in the list snapshot REMY's runs used (computed October 17, 2026). How the ratings are measured.
Version REMY played: Fatalii 0.5.0, tag v0.5.0, commit 7124449, from its source repository; Rust; licence MIT (LICENSE).
b
byte-knight 3.0.0
By Paul Tsouchlos · Rust 2024 · Reference rating 2311
A Rust engine by Paul Tsouchlos that began as a port of his entry to a programming contest; REMY's panel uses version 3.0.0, from May 2025.
Full profile
byte-knight is written in Rust, the language REMY is written in, by Paul Tsouchlos (DeveloperPaul123 on GitHub), under the GNU General Public License, version 3. Its README calls it his first “real” Rust project, written by a long-time C++ developer who wanted to learn the language. It started as a port of the engine he entered in Sebastian Lague's Chess Engine Challenge, where, the README says, it placed in the top 32 of more than 600 entries. The project began in July 2024; version 3.0.0 was tagged on 18 May 2025, and a version 4.0.0 has followed.
Version 3.0.0 judges a position with piece-square tables alone: a value for each piece on each square, blended between the middlegame and the endgame. Its README says the tables use PeSTO's values, a well-known published set, and the project includes a tuner for them. That makes it close in spirit to REMY 7, REMY 8 and REMY 8.1, which also judge a position by a value for every piece on every square, though REMY learns its values from its own games.
Its search uses the standard ideas: iterative deepening, alpha-beta with principal variation search and aspiration windows, a quiescence search, a transposition table, null-move pruning, reverse futility pruning, late-move reductions and internal iterative reductions, with a history table to try promising moves first. Its README says new features are tested in games on the author's own OpenBench testing server, much as REMY tests each step. It plays on Lichess as byte-knight.
REMY 9 (panel P8): 100 games; REMY 9 won 13, drew 50 and lost 37 (38 points of 100).
Reference rating 2311: the engine's CCRL Blitz rating in the list snapshot REMY's runs used (computed October 17, 2026). How the ratings are measured.
Version REMY played: byte-knight 3.0.0, tag v3.0.0, commit 10fcf1f, from its source repository; Rust 2024; licence GPL-3.0 (LICENSE).
V
Velvet 1.0.0
By Martin Honert · Rust 2018, no dependencies · Reference rating 2513
A Rust engine by Martin Honert that grew out of his earlier browser engine, Wasabi; REMY's panel uses version 1.0.0, its first release, from August 2020.
Full profile
Velvet is written in Rust by Martin Honert (mhonert on GitHub) and released under the GNU General Public License, version 3 or later. Its README at 1.0.0 says it is based on his previous engine, Wasabi, which plays in a web browser. The repository's first commit is from July 2020, and version 1.0.0 was tagged on 11 August 2020, about five weeks later.
Version 1.0.0's evaluation was written by hand: piece-square tables blended between the middlegame and the endgame, mobility, doubled and passed pawns, the pawns sheltering the king, castling, and threats against the king. Its README says all of these values were tuned automatically on 725,000 test positions collected by the author of Zurichess, the same kind of published set Fatalii 0.5.0 was tuned on.
Its search used principal variation search with iterative deepening, a transposition table, null-move pruning with a check for zugzwang, late-move reductions, futility pruning and razoring, check extensions, and killer moves and a history table to try promising moves first. Velvet kept growing after 1.0.0: later versions judge positions with neural networks, and its README now offers two built-in networks with different playing styles, a strength limit for sparring with people, and analysis of several lines at once.
REMY 9 (panel P8): 100 games; REMY 9 won 9, drew 18 and lost 73 (18 points of 100).
Reference rating 2513: the engine's CCRL Blitz rating in the list snapshot REMY's runs used (computed October 17, 2026). How the ratings are measured.
Version REMY played: Velvet 1.0.0, tag v1.0.0, commit 8cc4c14, from its source repository; Rust 2018, no dependencies; licence GPL-3.0-or-later (LICENSE, Cargo.toml).
R
Reckless 0.3.0
By codedeliveryservice · Rust 2021, no dependencies · Reference rating 2615
A Rust engine by the developer known as codedeliveryservice; REMY's panel uses version 0.3.0, a small early release from November 2023.
Full profile
Reckless is written in Rust by the developer who publishes as codedeliveryservice on GitHub; the repository gives no other name. Its README calls it a personal project that, “guided by the insights from the chess programming community, … fearlessly combines established concepts, as the name suggests.” Version 0.3.0 was released under the MIT licence on 6 November 2023, eleven months after the first commit in December 2022.
Its evaluation at 0.3.0 is small and hand-crafted: piece-square tables that depend on where the side's own king stands, mobility for bishops, rooks and queens, and a small bonus for having the move, all blended between the middlegame and the endgame, with the values stored in a weights file built into the program. Its search uses principal variation search with aspiration windows, a quiescence search and a transposition table, with check extensions, reverse futility pruning, null-move pruning, late-move reductions and late-move pruning, and it orders moves with killer moves and a history table.
Reckless changed fast after 0.3.0. Later versions judge positions with a neural network, trained with the Bullet trainer, and the project's licence is now the GNU Affero General Public License, version 3. Its README now describes it as consistently performing among the top engines in major tournaments, including the Chess.com Computer Chess Championship and TCEC.
Reference rating 2615: the engine's CCRL Blitz rating in the list snapshot REMY's runs used (computed October 17, 2026). How the ratings are measured.
Version REMY played: Reckless 0.3.0, tag v0.3.0, commit c04775f, from its source repository; Rust 2021, no dependencies; licence MIT (LICENSE at the tag).