Guide of fastchess sprt test

Fastchess on Windows

If you’ve ever wished for a fast, modern, Cutechess-style tournament runner that plays nicely with today’s UCI engines, Fastchess is exactly that. In this tutorial we’ll go from zero to running reliable round-robin tournaments and gauntlet-style tests, using PGN/EPD opening suites (and what to do if your book is a Polyglot .bin). Along the way we’ll cover threads, book depth (plies), SPRT, logging, resuming runs, and practical Windows tips so any chess-engine enthusiast can reproduce the results at home.

Short version: you’ll download the Windows build from the Fastchess Releases page, extract it, then run commands like
fastchess.exe -engine ... -engine ... -each tc=10+0.1 -openings file=... format=pgn order=random plies=8 -rounds 200 -repeat -concurrency 4
and optionally add -sprt ... when you want early-stop testing. See examples below. (GitHub)

What is Fastchess and why use it?

Fastchess is a command-line tournament runner for engine-vs-engine testing (think Cutechess, but newer and very efficient). It supports multiple engines, concurrent games and features like Cutechess-compatible output, extended PGN telemetry, and a quick match mode for fast A/B comparisons. From v1.0.0-alpha it explicitly supports round-robin tournaments; you can also emulate gauntlets (one engine against many) with simple patterns we’ll show later. (GitHub)

1) Download & install Fastchess on Windows

1. Grab the latest Windows build
   Go to the Fastchess Releases page and download the Windows artefact (zip). Extract it to a convenient folder, e.g. C:\fastchess. (GitHub)
2. (Optional) Add Fastchess to PATH
   • Press Win → type environment variables → open Edit the system environment variables.
   • Click Environment Variables…, select Path (User), Edit, New, add C:\fastchess.
   • Click OK → open a new Windows Terminal or PowerShell window and run fastchess.exe --help to confirm it’s visible.
3. Create a working structure
   For tidy testing, create: C:\fastchess\engines\ C:\fastchess\books\ C:\fastchess\output\ Put your engine EXEs under engines and your opening suites under books.

2) Collect engines (UCI) and basic checks

• Place engine binaries (e.g., Stockfish.exe, your own builds, etc.) into C:\fastchess\engines\.
• You can ask Fastchess to check UCI compliance quickly (handy for home-built engines): fastchess.exe --compliance C:\fastchess\engines\MyEngine.exe (Compliance checker is advertised in the README.) (GitHub)

Tip: Engine options (Threads, Hash, Syzygy path, etc.) are passed as UCI options with the option.<Name>=Value syntax on each -engine (see the man page’s “option.name=VALUE”). We’ll use option.Threads later. (GitHub)

3) Opening books & suites: PGN/EPD (and how .bin fits in)

The native Fastchess way: -openings with PGN or EPD

Fastchess’s tournament book switch is -openings, and the supported formats are PGN and EPD. You can set ordering (random, sequential), book depth by plies, and a start index. The syntax looks like:

-openings file=MySuite.pgn format=(pgn|epd) [order=ORDER] [plies=PLIES] [start=START] …

-openings file=MySuite.pgn format=(pgn|epd) [order=ORDER] [plies=PLIES] [start=START] …

This is documented in the man page. In practice you’ll use, for example:

-openings file=books\Noomen-SH-2024.pgn format=pgn order=random plies=8

-openings file=books\Noomen-SH-2024.pgn format=pgn order=random plies=8

which means “take random lines from the PGN and limit to 8 plies from the book per game”. (GitHub)

Book depth = plies: “8 plies” equals 4 full moves from the start position. Increase for more theory; decrease to get more variety and less book bias.

What if your book is Polyglot .bin?

Fastchess itself does not read Polyglot .bin files via -openings; that switch is PGN/EPD-only per the manual. If you have a .bin book you want to use as a neutral opening source, convert it to PGN/EPD first:

• Polyglot can dump .bin book lines (per-colour) using: polyglot dump-book -bin book.bin -color white -out book_white.txt polyglot dump-book -bin book.bin -color black -out book_black.txt (Commands from Polyglot docs.) Those dumps are text lines of moves which you can clean or import into a GUI like ChessX and re-export as PGN. (manpages.ubuntu.com, sources.debian.org, SourceForge)
• Alternative tooling exists (e.g., polyglot-tolerant scripts; some people change the dump’s extension and normalise via ChessX; or use jja in the Rust ecosystem to work with .bin books). Choose the path that best fits your workflow, but the key is: end up with a PGN or EPD file so you can feed Fastchess’s -openings. (SourceForge, talkchess.com, Lib.rs)

Engine-side books: Some UCI engines support internal Polyglot books via options like BookFile, OwnBook, etc. That is engine-specific (not part of Fastchess), and risks asymmetric book behaviour across engines. For fair A/B testing, a neutral PGN/EPD suite with -openings is recommended.

4) Your first match (two engines)

Let’s pit two engines at 10 seconds + 0.1s increment, using a PGN suite to avoid repetitive openings, playing both sides of each line, and running several games in parallel.

Open Windows Terminal in C:\fastchess and run:

fastchess.exe ^
  -engine cmd="engines\EngineA.exe" name="EngineA" option.Threads=4 ^
  -engine cmd="engines\EngineB.exe" name="EngineB" option.Threads=4 ^
  -each tc=10+0.1 ^
  -openings file="books\MySuite.pgn" format=pgn order=random plies=8 ^
  -rounds 200 -repeat ^
  -concurrency 4 ^
  -pgnout "output\A-vs-B.pgn" ^
  -output cutechess

fastchess.exe ^
  -engine cmd="engines\EngineA.exe" name="EngineA" option.Threads=4 ^
  -engine cmd="engines\EngineB.exe" name="EngineB" option.Threads=4 ^
  -each tc=10+0.1 ^
  -openings file="books\MySuite.pgn" format=pgn order=random plies=8 ^
  -rounds 200 -repeat ^
  -concurrency 4 ^
  -pgnout "output\A-vs-B.pgn" ^
  -output cutechess

What each bit means

• -engine … lines define participants. We set option.Threads=4 per engine (UCI option). (GitHub)
• -each tc=10+0.1 sets time control to 10s initial + 0.1s increment (per move). (Time control usage is mirrored from Cutechess-style syntax used by Fastchess.) (GitHub)
• -openings … plies=8 limits book to 8 plies. (This is your “book depth”.) (GitHub)
• -rounds 200 -repeat plays each opening twice so both engines get White and Black. (Repeat is the usual “play both sides” behaviour in cutechess-style runners.) (manpages.ubuntu.com)
• -concurrency 4 runs four games in parallel (tune for your CPU to avoid throttling).
• -pgnout saves all games.
• -output cutechess emits Cutechess-compatible progress lines, which other tools expect. (Feature mentioned in the README.) (GitHub)

Concurrency vs Threads: If a single game uses Threads=4 on each engine (8 threads total), and you set -concurrency 4, you may oversubscribe cores. On an 8–12 core machine, sensible starts are Threads=1–2 with -concurrency 4–8, then benchmark.

5) Round-robin tournaments (3+ engines)

From v1.0.0-alpha, Fastchess supports multiple engines for round-robin tournaments. You add more -engine lines and keep the same switches. Example for four engines:

fastchess.exe ^
  -engine cmd="engines\A.exe" name="A" option.Threads=2 ^
  -engine cmd="engines\B.exe" name="B" option.Threads=2 ^
  -engine cmd="engines\C.exe" name="C" option.Threads=2 ^
  -engine cmd="engines\D.exe" name="D" option.Threads=2 ^
  -each tc=10+0.1 ^
  -openings file="books\Balanced.pgn" format=pgn order=random plies=8 ^
  -rounds 50 -repeat ^
  -concurrency 6 ^
  -pgnout "output\RR-4engines.pgn" ^
  -output cutechess

fastchess.exe ^
  -engine cmd="engines\A.exe" name="A" option.Threads=2 ^
  -engine cmd="engines\B.exe" name="B" option.Threads=2 ^
  -engine cmd="engines\C.exe" name="C" option.Threads=2 ^
  -engine cmd="engines\D.exe" name="D" option.Threads=2 ^
  -each tc=10+0.1 ^
  -openings file="books\Balanced.pgn" format=pgn order=random plies=8 ^
  -rounds 50 -repeat ^
  -concurrency 6 ^
  -pgnout "output\RR-4engines.pgn" ^
  -output cutechess

Fastchess will handle the pairing and rotation across participants. (Round-robin support is called out in the release notes.) (GitHub)

6) “Gauntlet” style (one engine vs many)

Fastchess’s manual and README focus on round-robins and two-engine matches; there isn’t a dedicated -tournament gauntlet switch in the docs at the time of writing. Practically, you have two simple ways to run a gauntlet pattern:

1. Quick match loops: Use the -quick facility to spin up rapid A/B matches against each opponent in turn (very handy for smoke-tests with a book). The README documents -quick like this:

-quick cmd=ENGINE1 cmd=ENGINE2 book=BOOK

-quick cmd=ENGINE1 cmd=ENGINE2 book=BOOK

which you can repeat per opponent (in a batch file). (GitHub)

2. Scripted pairs: Run a series of two-engine commands (as in section 4) where EngineA is your fixed baseline and B/C/D are challengers. You’ll end up with A-vs-B.pgn, A-vs-C.pgn, etc., which is clean for later analysis.

Either approach is a gauntlet in practice—A plays many others—while keeping Fastchess’s core command-line simple and reproducible.

7) Using EPD test suites

For tactics/position testing style suites (EPD lines), switch format=epd. Example:

fastchess.exe ^
  -engine cmd="engines\A.exe" name="A" option.Threads=2 ^
  -engine cmd="engines\B.exe" name="B" option.Threads=2 ^
  -each tc=10+0.1 ^
  -openings file="books\STS.epd" format=epd order=sequential ^
  -rounds 2 -repeat ^
  -concurrency 4 ^
  -pgnout "output\EPD-suite-A-vs-B.pgn" ^
  -output cutechess

fastchess.exe ^
  -engine cmd="engines\A.exe" name="A" option.Threads=2 ^
  -engine cmd="engines\B.exe" name="B" option.Threads=2 ^
  -each tc=10+0.1 ^
  -openings file="books\STS.epd" format=epd order=sequential ^
  -rounds 2 -repeat ^
  -concurrency 4 ^
  -pgnout "output\EPD-suite-A-vs-B.pgn" ^
  -output cutechess

EPD suites often pair better with short time controls and a higher number of distinct positions rather than many rounds per position. Tweak -rounds and order accordingly. (EPD/PGN support per man page.) (GitHub)

8) SPRT in Fastchess (early-stop A/B testing)

SPRT (Sequential Probability Ratio Test) lets you stop early when the Elo difference is likely above/below your chosen thresholds. Fastchess exposes it as:

-sprt elo0=E0 elo1=E1 alpha=ALPHA beta=BETA model=MODEL

-sprt elo0=E0 elo1=E1 alpha=ALPHA beta=BETA model=MODEL

Typical values (popular in engine dev circles) are around elo0=0 and elo1=3 (or 5) with alpha=0.05, beta=0.05. MODEL may include a normalised variant (Fastchess mentions “normalized sprt” in releases). Exact parameter names come from the man page. Example command:

fastchess.exe ^
  -engine cmd="engines\Baseline.exe" name="Base" option.Threads=2 ^
  -engine cmd="engines\NewBuild.exe" name="New"   option.Threads=2 ^
  -each tc=10+0.1 ^
  -openings file="books\Noomen-SH-2024.pgn" format=pgn order=random plies=8 ^
  -rounds 400 -repeat ^
  -concurrency 4 ^
  -sprt elo0=0 elo1=3 alpha=0.05 beta=0.05 model=normalized ^
  -pgnout "output\SPRT-Base-vs-New.pgn" ^
  -output cutechess

fastchess.exe ^
  -engine cmd="engines\Baseline.exe" name="Base" option.Threads=2 ^
  -engine cmd="engines\NewBuild.exe" name="New"   option.Threads=2 ^
  -each tc=10+0.1 ^
  -openings file="books\Noomen-SH-2024.pgn" format=pgn order=random plies=8 ^
  -rounds 400 -repeat ^
  -concurrency 4 ^
  -sprt elo0=0 elo1=3 alpha=0.05 beta=0.05 model=normalized ^
  -pgnout "output\SPRT-Base-vs-New.pgn" ^
  -output cutechess

• elo0, elo1 define the indifference band; the test stops when evidence is strong that the Elo diff is ≤ elo0 (reject improvement) or ≥ elo1 (accept improvement), with error probabilities given by alpha and beta. (SPRT concepts widely described in testing docs and community posts.) (GitHub, manpages.ubuntu.com, talkchess.com)
• -rounds still matters: it caps the maximum number of games if the test doesn’t reach a decision.

9) Threads, hash and concurrency: getting the most from your CPU

• Threads
  Most UCI engines expose Threads as an option. Set it per engine: -engine cmd="engines\A.exe" name="A" option.Threads=2 (Engine options are option.<Name>=Value per the man page.) Balance this with -concurrency. If you have an 8-core CPU, a sensible starting point is Threads=1–2 with -concurrency 6–8, then measure throughput and time-losses. (GitHub)
• Hash
  If your games are short (e.g., 10+0.1), huge hash isn’t necessary. Values between 64–256 MB per engine are often enough: option.Hash=128
• Syzygy tablebases (optional)
  If your engines support them, set e.g.: option.SyzygyPath="D:\TB\Syzygy" (Fastchess release notes mention Syzygy support additions.) (GitHub)
• Watch time-losses
  If you see many timeouts, reduce Threads and/or -concurrency, or slightly bump engine timemargin (some engines call it Move Overhead).

10) Book depth (plies): picking values that make sense

• What’s a good plies value?
  For balanced A/B testing at fast time controls, plies=6–10 (3–5 full moves) is a sweet spot—enough variety without letting the book decide outcomes.
• For EPD (positions), plies is less central; you might leave it out or keep it at low values so play deviates quickly from the first move.

Again, the switch is on -openings … plies=PLIES per the manual. (GitHub)

11) Output, logging, and resuming runs

• Cutechess-style console output
  Add -output cutechess to make progress and summary lines compatible with many external tools/scripts. (GitHub)
• PGN
  Use -pgnout output\mygames.pgn. Fastchess can embed extended telemetry like nodes, nps, etc., as per the README notes. (GitHub)
• Autosave & resume
  Fastchess can autosave state and resume a crashed/paused run from a config file. If you ever hard-reset a PC mid-tournament, try: fastchess.exe -config file=config.json (Community thread describing successful resumption via -config.) (talkchess.com)
• Quick matches
  For “smoke tests”, -quick cmd=ENGINE1 cmd=ENGINE2 book=BOOK fires an immediate book-based match, as advertised in the README. Useful to confirm an engine build before a long test. (GitHub)

12) Worked examples you can paste

A) Two-engine A/B with a PGN suite (10+0.1), book depth 8 plies

fastchess.exe ^
  -engine cmd="engines\Wordfish.exe"  name="Wordfish"  option.Threads=2 ^
  -engine cmd="engines\Wordfish1.exe" name="Wordfish1" option.Threads=2 ^
  -each tc=10+0.1 ^
  -openings file="books\Noomen2024.pgn" format=pgn order=random plies=8 ^
  -rounds 300 -repeat ^
  -concurrency 6 ^
  -pgnout "output\Wordfish-vs-Wordfish1.pgn" ^
  -output cutechess

fastchess.exe ^
  -engine cmd="engines\Wordfish.exe"  name="Wordfish"  option.Threads=2 ^
  -engine cmd="engines\Wordfish1.exe" name="Wordfish1" option.Threads=2 ^
  -each tc=10+0.1 ^
  -openings file="books\Noomen2024.pgn" format=pgn order=random plies=8 ^
  -rounds 300 -repeat ^
  -concurrency 6 ^
  -pgnout "output\Wordfish-vs-Wordfish1.pgn" ^
  -output cutechess

B) Four-engine round-robin with an EPD set

fastchess.exe ^
  -engine cmd="engines\A.exe" name="A" option.Threads=1 ^
  -engine cmd="engines\B.exe" name="B" option.Threads=1 ^
  -engine cmd="engines\C.exe" name="C" option.Threads=1 ^
  -engine cmd="engines\D.exe" name="D" option.Threads=1 ^
  -each tc=10+0.1 ^
  -openings file="books\STS.epd" format=epd order=sequential ^
  -rounds 3 -repeat ^
  -concurrency 8 ^
  -pgnout "output\RR-EPD.pgn" ^
  -output cutechess

fastchess.exe ^
  -engine cmd="engines\A.exe" name="A" option.Threads=1 ^
  -engine cmd="engines\B.exe" name="B" option.Threads=1 ^
  -engine cmd="engines\C.exe" name="C" option.Threads=1 ^
  -engine cmd="engines\D.exe" name="D" option.Threads=1 ^
  -each tc=10+0.1 ^
  -openings file="books\STS.epd" format=epd order=sequential ^
  -rounds 3 -repeat ^
  -concurrency 8 ^
  -pgnout "output\RR-EPD.pgn" ^
  -output cutechess

C) Gauntlet-style via quick matches (Engine X vs many)

Create a small batch file, e.g. gauntlet-X.bat:

@echo off
set BOOK=books\Gauntlet-Book.pgn

for %%E in (B.exe C.exe D.exe E.exe) do (
  fastchess.exe -quick ^
    cmd="engines\X.exe" cmd="engines\%%E" ^
    book="%BOOK%"
)

@echo off
set BOOK=books\Gauntlet-Book.pgn

for %%E in (B.exe C.exe D.exe E.exe) do (
  fastchess.exe -quick ^
    cmd="engines\X.exe" cmd="engines\%%E" ^
    book="%BOOK%"
)

That runs X vs B/C/D/E back-to-back using the same book. (The -quick option is described in the README.) (GitHub)

D) A clean SPRT run (normalised model)

fastchess.exe ^
  -engine cmd="engines\Base.exe" name="Base" option.Threads=2 ^
  -engine cmd="engines\New.exe"  name="New"  option.Threads=2 ^
  -each tc=10+0.1 ^
  -openings file="books\Balanced.pgn" format=pgn order=random plies=8 ^
  -rounds 600 -repeat ^
  -concurrency 6 ^
  -sprt elo0=0 elo1=3 alpha=0.05 beta=0.05 model=normalized ^
  -pgnout "output\SPRT-Base-New.pgn" ^
  -output cutechess

fastchess.exe ^
  -engine cmd="engines\Base.exe" name="Base" option.Threads=2 ^
  -engine cmd="engines\New.exe"  name="New"  option.Threads=2 ^
  -each tc=10+0.1 ^
  -openings file="books\Balanced.pgn" format=pgn order=random plies=8 ^
  -rounds 600 -repeat ^
  -concurrency 6 ^
  -sprt elo0=0 elo1=3 alpha=0.05 beta=0.05 model=normalized ^
  -pgnout "output\SPRT-Base-New.pgn" ^
  -output cutechess

(Parameters follow the man page’s SPRT syntax; “normalized” model support was noted in release notes.) (GitHub)

13) Converting a Polyglot .bin to something Fastchess can open

Here’s a minimal, reproducible workflow:

1. Dump the .bin into text lines per side with Polyglot: polyglot dump-book -bin books\mybook.bin -color white -out books\dump_white.txt polyglot dump-book -bin books\mybook.bin -color black -out books\dump_black.txt (manpages.ubuntu.com, sources.debian.org)
2. Normalise to PGN
   • Import those dumps into ChessX (or another GUI that can consume list-of-moves text) and export as PGN; or
   • Use community tools (e.g. polyglot-tolerant script to create PGN; jja for editing/inspection) to get clean PGN/EPD. (SourceForge, talkchess.com, Lib.rs)
3. Use in Fastchess -openings file="books\mybook.pgn" format=pgn order=random plies=8

Why not use .bin directly? Because Fastchess’s -openings accepts pgn|epd per its manual; .bin is Polyglot’s format, and belongs either inside an engine’s own book mechanism or converted externally. (GitHub)

14) Practical tips & troubleshooting

• Engines crash or misbehave?
  Try option.Threads=1, reduce -concurrency, and verify the engine passes Fastchess’s --compliance check. (GitHub)
• Many time-losses (flagging on time)?
  Lower -concurrency, choose a slightly slower TC (e.g., tc=15+0.15), or reduce engine threads. If your engine has a “Move Overhead”/timemargin option, bump it a little.
• Openings repeat too often
  Ensure order=random and set a sensible plies (e.g., 8–10). Use big, well-curated suites.
• Resuming after a power cut
  If Fastchess wrote a config in the run folder, relaunch with: fastchess.exe -config file=config.json (Reported successful by users.) (talkchess.com)
• Cutechess-style logs for downstream tools
  Keep -output cutechess to make external Elo calculators happier. (GitHub)
• Gzipped books
  Newer releases mention gzipped book support—useful if your PGN book is large. (GitHub)

15) Typical Windows batch files you can reuse

run-ab-10s.bat

@echo off
set FC=C:\fastchess\fastchess.exe
set ENGINES=C:\fastchess\engines
set BOOKS=C:\fastchess\books
set OUT=C:\fastchess\output

"%FC%" ^
 -engine cmd="%ENGINES%\EngineA.exe" name="EngineA" option.Threads=2 ^
 -engine cmd="%ENGINES%\EngineB.exe" name="EngineB" option.Threads=2 ^
 -each tc=10+0.1 ^
 -openings file="%BOOKS%\Noomen2024.pgn" format=pgn order=random plies=8 ^
 -rounds 300 -repeat ^
 -concurrency 6 ^
 -pgnout "%OUT%\A-vs-B.pgn" ^
 -output cutechess

@echo off
set FC=C:\fastchess\fastchess.exe
set ENGINES=C:\fastchess\engines
set BOOKS=C:\fastchess\books
set OUT=C:\fastchess\output

"%FC%" ^
 -engine cmd="%ENGINES%\EngineA.exe" name="EngineA" option.Threads=2 ^
 -engine cmd="%ENGINES%\EngineB.exe" name="EngineB" option.Threads=2 ^
 -each tc=10+0.1 ^
 -openings file="%BOOKS%\Noomen2024.pgn" format=pgn order=random plies=8 ^
 -rounds 300 -repeat ^
 -concurrency 6 ^
 -pgnout "%OUT%\A-vs-B.pgn" ^
 -output cutechess

roundrobin-4.bat

@echo off
set FC=C:\fastchess\fastchess.exe
set ENGINES=C:\fastchess\engines
set BOOKS=C:\fastchess\books
set OUT=C:\fastchess\output

"%FC%" ^
 -engine cmd="%ENGINES%\A.exe" name="A" option.Threads=1 ^
 -engine cmd="%ENGINES%\B.exe" name="B" option.Threads=1 ^
 -engine cmd="%ENGINES%\C.exe" name="C" option.Threads=1 ^
 -engine cmd="%ENGINES%\D.exe" name="D" option.Threads=1 ^
 -each tc=10+0.1 ^
 -openings file="%BOOKS%\Balanced.pgn" format=pgn order=random plies=8 ^
 -rounds 50 -repeat ^
 -concurrency 8 ^
 -pgnout "%OUT%\RR-4engines.pgn" ^
 -output cutechess

@echo off
set FC=C:\fastchess\fastchess.exe
set ENGINES=C:\fastchess\engines
set BOOKS=C:\fastchess\books
set OUT=C:\fastchess\output

"%FC%" ^
 -engine cmd="%ENGINES%\A.exe" name="A" option.Threads=1 ^
 -engine cmd="%ENGINES%\B.exe" name="B" option.Threads=1 ^
 -engine cmd="%ENGINES%\C.exe" name="C" option.Threads=1 ^
 -engine cmd="%ENGINES%\D.exe" name="D" option.Threads=1 ^
 -each tc=10+0.1 ^
 -openings file="%BOOKS%\Balanced.pgn" format=pgn order=random plies=8 ^
 -rounds 50 -repeat ^
 -concurrency 8 ^
 -pgnout "%OUT%\RR-4engines.pgn" ^
 -output cutechess

sprt-newfeature.bat

@echo off
set FC=C:\fastchess\fastchess.exe
set ENGINES=C:\fastchess\engines
set BOOKS=C:\fastchess\books
set OUT=C:\fastchess\output

"%FC%" ^
 -engine cmd="%ENGINES%\Baseline.exe" name="Base" option.Threads=2 ^
 -engine cmd="%ENGINES%\NewBuild.exe" name="New" option.Threads=2 ^
 -each tc=10+0.1 ^
 -openings file="%BOOKS%\Noomen2024.pgn" format=pgn order=random plies=8 ^
 -rounds 600 -repeat ^
 -concurrency 6 ^
 -sprt elo0=0 elo1=3 alpha=0.05 beta=0.05 model=normalized ^
 -pgnout "%OUT%\SPRT-Base-New.pgn" ^
 -output cutechess

@echo off
set FC=C:\fastchess\fastchess.exe
set ENGINES=C:\fastchess\engines
set BOOKS=C:\fastchess\books
set OUT=C:\fastchess\output

"%FC%" ^
 -engine cmd="%ENGINES%\Baseline.exe" name="Base" option.Threads=2 ^
 -engine cmd="%ENGINES%\NewBuild.exe" name="New" option.Threads=2 ^
 -each tc=10+0.1 ^
 -openings file="%BOOKS%\Noomen2024.pgn" format=pgn order=random plies=8 ^
 -rounds 600 -repeat ^
 -concurrency 6 ^
 -sprt elo0=0 elo1=3 alpha=0.05 beta=0.05 model=normalized ^
 -pgnout "%OUT%\SPRT-Base-New.pgn" ^
 -output cutechess

16) FAQs

Q: Where exactly do I get Fastchess for Windows?
A: From the project’s Releases page; grab the Windows artefact for the latest version. (GitHub)

Q: Can I feed a .bin book directly to Fastchess?
A: Not with -openings. Convert to PGN/EPD (Polyglot dump-book, ChessX normalisation, or other tooling) and point -openings to the PGN/EPD. (GitHub, manpages.ubuntu.com)

Q: Does Fastchess really do round-robins?
A: Yes. Multi-engine round-robin support is called out in the release notes (v1.0.0-alpha and onward). (GitHub)

Q: How do I run a “gauntlet” (one vs many)?
A: Use repeated two-engine commands or -quick in a loop—functionally a gauntlet—so your anchor engine faces each opponent in turn, keeping outputs per opponent. (The -quick switch is documented in the README.) (GitHub)

Q: How do I set “threads”?
A: On each -engine, pass option.Threads=<N>. (Engine options via option.name=VALUE are described in the man page.) (GitHub)

Q: How do I control book depth?
A: Use -openings … plies=<N>. For example plies=8 = four full moves from book, then engines are on their own. (GitHub)

Q: Can I resume a crashed tournament?
A: Yes—try -config file=config.json in the run folder (as reported by users). (talkchess.com)

17) Final checklist for reliable tests

• Use PGN/EPD suites with -openings; set order=random and a reasonable plies (6–10). (GitHub)
• Keep time controls consistent (e.g., 10+0.1 for fast dev cycles).
• Balance Threads and -concurrency against your CPU; watch for time-losses.
• Prefer two-engine A/B for tuning; use round-robin for comparative ranking across many engines. (Round-robin support is explicit.) (GitHub)
• For SPRT, pick an indifference band (elo0, elo1) and error bounds (alpha, beta) that match your risk tolerance; normalised model is available. (GitHub)
• Save results with -pgnout and choose -output cutechess for maximum tool compatibility. (GitHub)

Useful documentation & notes cited above

• Fastchess README (downloads, quick match -quick, Cutechess output, extended PGN notes). (GitHub)
• Fastchess man page (options such as -openings with format=(epd|pgn), plies=PLIES, and SPRT syntax). (GitHub)
• Releases page (Windows artefacts; notes including multi-engine round-robin support and gzipped books). (GitHub)
• Polyglot tools (how to build or dump .bin books for conversion). (manpages.ubuntu.com, GitHub, sources.debian.org)

With this setup you can reproduce stable, apples-to-apples results on Windows, whether you’re tuning a single engine (SPRT), ranking a pool (round-robin), or stress-testing a new build (quick matches). Happy testing—and may your Elo never blunder!

RAM planning table

RAM planning: picking safe Hash × concurrency combinations

When you run many parallel games, Hash multiplies quickly because each game runs two engines. Use this quick estimator:

• Per-game RAM ≈ 2 × Hash_MB + 64
  (the extra ~64 MB covers engine overhead; keep it conservative if your engines are heavy)
• Total RAM for testing ≈ Per-game RAM × concurrency

Also leave headroom for Windows, GUIs, tablebases, logging, and background apps. A safe starting point is to keep testing RAM ≤ ~60% of your installed memory (go lower if you use Syzygy TBs or heavy GUIs).

Quick planning table (conservative presets)

How totals were estimated:
Per-game ≈ 2 × Hash + 64 MB.
Example (Hash = 256): 2×256 + 64 = 576 MB. With concurrency = 12: 12 × 576 ≈ 6.9 GB.

Important caveats

• These totals exclude Syzygy tablebases, opening book caching, and GUI memory. If you use TBs, lower Hash or concurrency.
• Engines differ: some allocate extra buffers (NNUE nets, eval caches). If you see paging or time losses, dial down Hash and/or concurrency.
• For short TCs (e.g., 10s+0.1), big Hash gives diminishing returns. Prioritise concurrency over giant Hash.

Batch templates with Hash planning

Throughput-oriented (more games):

@echo off
set FC=C:\fastchess\fastchess.exe
set ENG=C:\fastchess\engines
set BOOKS=C:\fastchess\books
set OUT=C:\fastchess\output

rem 16 GB PC example: concurrency 12, Hash 256 MB
"%FC%" ^
 -engine cmd="%ENG%\EngineA.exe" name="A" option.Threads=1 option.Hash=256 ^
 -engine cmd="%ENG%\EngineB.exe" name="B" option.Threads=1 option.Hash=256 ^
 -each tc=10+0.1 ^
 -openings file="%BOOKS%\Balanced.pgn" format=pgn order=random plies=8 ^
 -rounds 300 -repeat ^
 -concurrency 12 ^
 -pgnout "%OUT%\A-vs-B.pgn" ^
 -output cutechess

@echo off
set FC=C:\fastchess\fastchess.exe
set ENG=C:\fastchess\engines
set BOOKS=C:\fastchess\books
set OUT=C:\fastchess\output

rem 16 GB PC example: concurrency 12, Hash 256 MB
"%FC%" ^
 -engine cmd="%ENG%\EngineA.exe" name="A" option.Threads=1 option.Hash=256 ^
 -engine cmd="%ENG%\EngineB.exe" name="B" option.Threads=1 option.Hash=256 ^
 -each tc=10+0.1 ^
 -openings file="%BOOKS%\Balanced.pgn" format=pgn order=random plies=8 ^
 -rounds 300 -repeat ^
 -concurrency 12 ^
 -pgnout "%OUT%\A-vs-B.pgn" ^
 -output cutechess

Depth-oriented (fewer games, bigger hash):

@echo off
set FC=C:\fastchess\fastchess.exe
set ENG=C:\fastchess\engines
set BOOKS=C:\fastchess\books
set OUT=C:\fastchess\output

rem 32 GB PC example: concurrency 8, Hash 1024 MB
"%FC%" ^
 -engine cmd="%ENG%\EngineA.exe" name="A" option.Threads=2 option.Hash=1024 ^
 -engine cmd="%ENG%\EngineB.exe" name="B" option.Threads=2 option.Hash=1024 ^
 -each tc=10+0.1 ^
 -openings file="%BOOKS%\Balanced.pgn" format=pgn order=random plies=8 ^
 -rounds 300 -repeat ^
 -concurrency 8 ^
 -pgnout "%OUT%\A-vs-B-deeper.pgn" ^
 -output cutechess

@echo off
set FC=C:\fastchess\fastchess.exe
set ENG=C:\fastchess\engines
set BOOKS=C:\fastchess\books
set OUT=C:\fastchess\output

rem 32 GB PC example: concurrency 8, Hash 1024 MB
"%FC%" ^
 -engine cmd="%ENG%\EngineA.exe" name="A" option.Threads=2 option.Hash=1024 ^
 -engine cmd="%ENG%\EngineB.exe" name="B" option.Threads=2 option.Hash=1024 ^
 -each tc=10+0.1 ^
 -openings file="%BOOKS%\Balanced.pgn" format=pgn order=random plies=8 ^
 -rounds 300 -repeat ^
 -concurrency 8 ^
 -pgnout "%OUT%\A-vs-B-deeper.pgn" ^
 -output cutechess

SPRT with safe Hash budget:

@echo off
set FC=C:\fastchess\fastchess.exe
set ENG=C:\fastchess\engines
set BOOKS=C:\fastchess\books
set OUT=C:\fastchess\output

rem 16 GB PC: concurrency 6, Hash 512 MB (≈ 6 × (2×512+64) = ~6.9 GB)
"%FC%" ^
 -engine cmd="%ENG%\Baseline.exe" name="Base" option.Threads=2 option.Hash=512 ^
 -engine cmd="%ENG%\New.exe"      name="New"  option.Threads=2 option.Hash=512 ^
 -each tc=10+0.1 ^
 -openings file="%BOOKS%\Noomen2024.pgn" format=pgn order=random plies=8 ^
 -sprt elo0=0 elo1=3 alpha=0.05 beta=0.05 model=normalized ^
 -rounds 600 -repeat ^
 -concurrency 6 ^
 -pgnout "%OUT%\SPRT-Base-New.pgn" ^
 -output cutechess

@echo off
set FC=C:\fastchess\fastchess.exe
set ENG=C:\fastchess\engines
set BOOKS=C:\fastchess\books
set OUT=C:\fastchess\output

rem 16 GB PC: concurrency 6, Hash 512 MB (≈ 6 × (2×512+64) = ~6.9 GB)
"%FC%" ^
 -engine cmd="%ENG%\Baseline.exe" name="Base" option.Threads=2 option.Hash=512 ^
 -engine cmd="%ENG%\New.exe"      name="New"  option.Threads=2 option.Hash=512 ^
 -each tc=10+0.1 ^
 -openings file="%BOOKS%\Noomen2024.pgn" format=pgn order=random plies=8 ^
 -sprt elo0=0 elo1=3 alpha=0.05 beta=0.05 model=normalized ^
 -rounds 600 -repeat ^
 -concurrency 6 ^
 -pgnout "%OUT%\SPRT-Base-New.pgn" ^
 -output cutechess

Quick RAM calculator

The formula is simple:

Total_RAM_MB = (2 × Hash_MB + 64) × Concurrency

Total_RAM_MB = (2 × Hash_MB + 64) × Concurrency

• Hash_MB = Hash option you set per engine (in MB)
• Concurrency = number of parallel games (-concurrency)
• The 64 is a safe overhead cushion for engine buffers, NNUE nets, etc.

Excel / Google Sheets formula

In a spreadsheet, create columns for Hash_MB and Concurrency.
In the Total_RAM_MB column, enter:

=(2*A2 + 64) * B2

=(2*A2 + 64) * B2

Where:

• A2 = Hash size (MB)
• B2 = Concurrency

Format the result in MB or divide by 1024 for GB:

=((2*A2 + 64) * B2) / 1024

=((2*A2 + 64) * B2) / 1024

One-liner (Windows PowerShell)

You can also calculate on the fly:

$hash=256; $conc=8; ($conc * (2*$hash + 64))/1024

$hash=256; $conc=8; ($conc * (2*$hash + 64))/1024

This prints the total RAM in GB.
For example, with Hash=256 and Concurrency=8, output is about 2.3 GB.

One-liner (Linux/macOS Bash)

hash=256; conc=8; echo "scale=2; $conc*(2*$hash+64)/1024" | bc

hash=256; conc=8; echo "scale=2; $conc*(2*$hash+64)/1024" | bc

This outputs the total GB needed.

Jorge Ruiz

connoisseur of both chess and anthropology, a combination that reflects his deep intellectual curiosity and passion for understanding both the art of strategic

SÍGUEME