Reckless: a Rust chess engine that speaks UCI and nothing else

What Reckless is, and what it is not

The README makes the design decision in one sentence. Reckless is not a standalone chess program but a chess engine designed for use with UCI-compatible GUIs, such as Cute Chess, En Croissant or Nibbler. That is the whole integration story: the engine speaks UCI, and the GUI is the application the human actually sees. The project describes Reckless as an open source competitive chess engine, consistently performing among the top engines in major tournaments including the Chess.com Computer Chess Championship and the Top Chess Engine Championship. The primary language is Rust, the licence is AGPL-3.0, the default branch is main, and the release tags are v0.10.0-dev-7300f044 from 2026-05-01, v0.10.0-dev-6abcff05 from 2026-04-01 and v0.9.0 from 2026-03-01, with the last push on 2026-10-22. The topic list names the techniques in the open: alpha-beta, chess-ai, nnue and uci.

make
# ./reckless

That is the whole build for the default configuration, and the Makefile shows what it does under the hood: the all target runs a release build of the reckless binary and emits the link output under the name reckless.

The rating table, and the pace of the improvement

The README carries a rating history across three lists, and the progression is the most informative part of the page. Reckless v0.9.0 from Mar 1, 2026 is listed at 3833 plus or minus 4 on SPCC, 3767 plus or minus 13 on CCRL Blitz and 3612 plus or minus 19 on CCRL 40/15, all at number 2 in their lists. The line below it, v0.8.0 from Aug 29, 2025, shows 3777 and 3765 and 3609. Before that, v0.7.0 from Aug 23, 2024 sits at 3500 and 3422, and v0.6.0 from Mar 22, 2024 at 3386 and 3317. The earliest entry, v0.1.0 from May 16, 2023, is at 2005 on CCRL Blitz. Read down the table and the project has gained roughly 1800 rating points on that list in under three years, which is a fast climb by engine standards and is the clearest evidence in the README that the underlying search and evaluation work is serious rather than a hobby project. The README also links the underlying lists, SPCC and the two CCRL pages, so the numbers can be checked.

Binary variants, and the choice the README recommends

Precompiled builds are downloaded from the GitHub Releases page and come in three flavours, and the difference between them is instruction set support rather than features. The avx512 build is the fastest and requires a recent CPU with AVX-512 support, the avx2 build is fast and supported on most modern CPUs, and the generic build is compatible with virtually all CPUs but is significantly slower than the AVX2 or AVX512 builds. The README's advice is blunt about which to try first: if you are unsure which binary to use, try the AVX-512 build first, and if it does not run on your system, fall back to the AVX2 build, or the generic one as a last resort. This matters more than it might look, because the Makefile also sets a default RUSTFLAGS of -C target-cpu=native for source builds, and the x64-check target compiles for x86-64 versions one through four with the relevant feature flags for the newest.

Building from source, and the Clang dependency you may not want

Building from source needs Rust 1.88.0 or later and Clang, and the README says Clang is required for building the Fathom library used for Syzygy endgame tablebase support. The Fathom library is the C tablebase reader, and it is why the build has a C dependency at all, since the Cargo.toml carries cc and bindgen as build dependencies and a build.rs. If you would rather not install Clang, the Makefile has a target for that.

make no-syzygy
# ./reckless

The no-syzygy target builds with the default features disabled, and the Cargo.toml confirms the mechanism, with a default feature set of syzygy and a separate spsa feature alongside it. There is also a WebAssembly target, built with a nightly toolchain and build-std for panic_abort and std, then passed through wasm-bindgen and wasm-opt with SIMD, threads and relaxed SIMD enabled, which suggests the engine is intended to run in a browser as well as on the metal.

Profile-guided optimization, and what the benchmark step does

The PGO path is documented as a separate build flavour rather than a detail. It needs the llvm-tools component and the cargo-pgo tool.

rustup component add llvm-tools
cargo install cargo-pgo

The build then runs the instrumentation, a benchmark, and the optimization step.

cargo pgo instrument
cargo pgo run -- bench
cargo pgo optimize
# ./target/x86_64-unknown-linux-gnu/release/reckless
# (the path may vary based on your system)

The middle step is the interesting one, because the engine has to play representative games to produce a usable profile, and the bench command is the engine's own self test. The Makefile's pgo target does the same three steps and then moves the binary out of the target directory under the plain name reckless. The repository also carries a dedicated PGO workflow badge in its CI, next to the main Rust build badge, which tells you the profile build is a maintained pipeline rather than a one-off instruction.

The UCI option surface, and the limits the README puts on it

The options table is short enough to read in full and it tells you what the engine exposes. Hash defaults to 16 megabytes for the transposition table with an accepted range from 1 to 262144. Threads defaults to 1 with a range of 1 to 512, and MultiPV, the number of principal variations to display, defaults to 1 with a range of 1 to 218. UCI_Chess960 defaults to false and enables Fischer Random support, and Minimal defaults to false and trims the UCI output. MoveOverhead defaults to 100 milliseconds of time reserved for overhead during each move, with a range of 0 to 2000. Clear Hash empties the transposition table, and SyzygyPath points at the endgame tablebases. The ranges are worth noting because they are the contract a GUI depends on, and the fact that they are documented at all is a sign of a library built for integration rather than a script.

The default UCI options that a GUI will set are hash, threads and move overhead, and the values in the table are the ones a fresh engine starts with.

Debugging commands, and where the AGPL licence bites

Beyond the standard UCI commands, Reckless adds extra commands for testing and debugging. The README lists perft with a depth argument, which runs a perft test counting the number of leaf nodes at a given depth, and bench, which is the command the PGO pipeline uses. Perft is the traditional correctness check for a chess engine, because the answer is a fixed number that any correct implementation must produce, and having it exposed as a command is a sign the author expects the engine to be checked by other people. The licence is the other thing to weigh. AGPL-3.0 means that if you modify the engine and let others interact with it over a network, you owe them the corresponding source. For running the engine locally against your own analysis, that is not a constraint. For a hosted analysis service built on a modified Reckless, it is a decision to make deliberately.

Editorial conclusion

Adopt Reckless if you run engine versus engine testing or analysis through a UCI compatible GUI and you want a strong Rust engine with an open source build you can inspect and modify. Do not adopt it as a desktop chess application, because the README is explicit that it is not a standalone chess program but an engine for GUIs such as Cute Chess, En Croissant or Nibbler. Before you point a GUI at it, pick the binary variant that matches your CPU, and remember the licence is AGPL v3, which matters if you intend to modify the engine and distribute the result.

Frequently asked questions

Official sources

1. codedeliveryservice/Reckless on GitHub
2. Issues
3. License: AGPL-3.0
4. README
5. Releases