Skip to content
Portada » Chess engines stockfish derived

Chess engines stockfish derived

Stockfish Derived Engines by Jorge Ruiz Centelles: Architecture, Features, and Research-Driven Development

Executive summary

This article surveys the Stockfish-derived chess engines and related codebases authored by Jorge Ruiz Centelles. It focuses on Revolution and Wordfish—two UCI engines that explore modern search and evaluation ideas on top of the Stockfish family—and on a dedicated StockfishPolyglota fork that adds native Polyglot book support. We outline their design goals, NNUE-centred evaluation, search heuristics and time-management refinements; explain book/experience systems; and position the projects within contemporary engine-testing practices (e.g., SPRT) and the wider Stockfish ecosystem. Where helpful, we reference public READMEs, release notes, and forum posts associated with each project. (GitHub)

1) Why Stockfish derivatives still matter

Stockfish remains the de facto reference for classical alpha-beta search with NNUE evaluation. Its openness makes it uniquely suited to rapid experimentation: new pruning schedules, alternative time-allocation schemes, and light-weight learning layers can be tried against a world-class baseline and validated by regimented testing (OpenBench, Fishtest-style pipelines, or community tournaments). Ruiz’s engines embrace that culture: they keep UCI compatibility, leverage NNUE, and ship practical affordances for tablebases, experience files, and Polyglot opening books—all with an eye toward reproducible Elo measurement. (GitHub)

2) Revolution: a research engine that blends Stockfish DNA with targeted refinements

2.1 Project overview and scope

Revolution is presented as “a free and open-source UCI chess engine combining classical algorithms with neural network innovations,” derived from Stockfish and actively modified to test new ideas. The repository documents a modern C++ codebase, standard multi-platform Makefiles, and a feature set consistent with high-strength UCI engines: SMP parallel search (YBWC), history-based move ordering, reverse futility and late-move pruning, and an NNUE pipeline. The published README also highlights Syzygy tablebase probing and a suite of experience-file options to bias root move ordering across games. (GitHub)

2.2 Architecture at a glance

Revolution’s README emphasizes:

  • Hybrid evaluation (classical features + NNUE)
  • YBWC SMP for scalable multi-threaded search
  • Pruning and reductions (Late Move Pruning, Reverse Futility, LMR-style ideas)
  • Move ordering via history heuristics and killer moves
  • Experience cache that stores root moves & evals, used as soft guidance in future searches
  • Syzygy: SyzygyPath support and an optional SyzygyPremap pre-mapping step to reduce probe latency at runtime

These statements are explicitly laid out in the project’s README and options sections. (GitHub)

2.3 The experience system: a pragmatic learning layer

One distinctive element is the experience file. Rather than forcing book moves, the engine persists search-derived knowledge about promising root moves and their qualities. UCI options include enabling/disabling writes, pointing to a custom file name (default experience.exp), choosing a width (how many candidate moves to keep), setting minimum depth thresholds, and flipping a “book mode” that allows the cache to behave like a lightweight opening book. In practice, this nudges move ordering and can stabilise openings across gauntlets—without conflating rating-list “book” effects with pure search strength. (GitHub)

2.4 Endgame precision through Syzygy—and why pre-mapping matters

SyzygyPremap instructs the engine to memory-map WDL/DTZ tables at startup. This trades a bit of initialisation time and RAM for lower probe latency during search, especially at the root. In longer time-controls or endgame-heavy suites, this can trim node overhead in probe-heavy positions and reduce search volatility near tablebase transitions. The README documents both SyzygyPath and SyzygyPremap. (GitHub)

2.5 Time-management guardrails

Revolution surfaces sensible time controls like Minimum Thinking Time and a Time Buffer. The goal is to avoid pathological instant replies and to preserve a reserve against time forfeits under GUI timekeeping. This is especially pertinent in testing frameworks that reward stability (e.g., SPRT gauntlets at fast time controls). (GitHub)

2.6 Release hygiene and licensing

Revolution is distributed under GPLv3, inheriting Stockfish license obligations (provide complete corresponding source, disclose modifications, etc.). The README repeats the GPLv3 linkage to Stockfish and advises contributors about documentation and testing. (GitHub)

2.7 Evidence of iteration

Community posts indicate ongoing benchmarking and versioned releases (e.g., v1.0.1 in late August 2025), often validated by SPRT. Even when individual numerical results live on sites that block crawlers, the public README and forum threads show an iterative development cadence characteristic of engines that chase small but cumulative Elo gains. (GitHub)

3) Wordfish: a Stockfish-line derivative with hands-on engineering for robustness and UX

3.1 Project profile

Wordfish is another Ruiz engine in the Stockfish family. Public posts and release notes describe it as a UCI engine that pairs parallel alpha-beta search with NNUE evaluation, mirroring the broad architecture of Revolution while pursuing its own implementation choices. It aims for practical deployment in GUIs (Fritz, Arena, etc.) and includes NNUE file-location resilience and multi-network handling. (chessengines.blogspot.com)

3.2 Notable implementation details in recent builds

Recent Wordfish release notes (September 2025) mention:

  • Platform-specific logic to resolve the executable directory (e.g., GetModuleFileName on Windows, _NSGetExecutablePath/readlink on other platforms) so that NNUE networks are found reliably when launched by external GUIs.
  • Calibrations that scale dynamic activity bonuses so they “nudge” NNUE scores without drowning them out.
  • A sentinel-guarded evaluation cache to avoid stale evals after position changes.

These are practical, engineering-driven improvements: they do not reinvent search, but they reduce user error and subtle state bugs, which in turn stabilise Elo testing and GUI interoperability. (chessengines.blogspot.com)

3.3 Loading alternate networks with “FalconFile”

Users and forum guidance repeatedly refer to a FalconFile UCI option for Wordfish that lets testers point at an alternate NNUE file (a common pattern when experimenting with smaller/faster or differently-trained nets). Documentation and community posts illustrate this with a “3.net” placeholder. While the actual weight files are typically sourced from Stockfish infrastructure or built by testers, the option surface is what matters for reproducible tests. (open-chess.org)

3.4 Release cadence and community visibility

Engine-watcher blogs regularly track new Wordfish versions (e.g., 2.40 and 2.50 in September 2025), echoing the standard description—Stockfish-derived UCI engine with NNUE plus modern pruning—and noting incremental fixes that improve robustness across platforms and GUIs. This pattern signals continuous integration habits and iterative refinement rather than sporadic “big bang” releases. (chessengines.blogspot.com)

4) StockfishPolyglota: enabling Polyglot .bin books in a Stockfish fork

4.1 Purpose and scope

The StockfishPolyglota repository’s purpose is explicit: “Stockfish with support bin books.” In practice, this means adapting a modern Stockfish fork to read Polyglot opening books natively, a convenience prized by analysts and by testers who maintain curated .bin repertoires for controlled gauntlets or coverage of specific ECO segments. (GitHub)

4.2 Why built-in Polyglot still matters

While many GUIs can inject book moves, embedding Polyglot reader logic at engine level decouples book usage from GUI idiosyncrasies. It also makes headless tools (e.g., FastChess, CuteChess CLI) easier to script in identical conditions across different harnesses and OSes—particularly useful for SPRT workflows that require reproducibility. (GitHub)

5) Testing philosophy: SPRT and disciplined iteration

Stockfish-line derivatives thrive when incremental ideas are gated by SPRT (Sequential Probability Ratio Test): propose a change, run a DEV vs BASE gauntlet under fixed openings/time controls, and accept or reject based on target Elo bounds and error rates. Ruiz’s projects surface this ethos in public READMEs and discussions, and link out to testing artefacts and harnesses. The approach aligns with the broader Stockfish documentation and the culture of small, testable improvements over grand rewrites. (GitHub)

6) Feature deep-dive and practical implications

6.1 NNUE-centric evaluation with classical scaffolding

Both Revolution and Wordfish retain Stockfish’s incrementally updated NNUE evaluator, which amortises feature recomputation across make/unmake and turns evaluation into a dense matrix-vector pipeline. The engines’ descriptions underscore that NNUE is not used in isolation: classical terms (tapered PSTs, mobility, king safety features) often remain in some hybrid or calibrating role, and the search stack—not the evaluator alone—determines tactical sharpness and throughput. (GitHub)

Practical impact:

  • NNUE reduces eval noise compared to hand-tuned heuristics, improving PV stability under aspiration windows.
  • Hybridisation (when present) can add shape to evaluations in sparse parts of the net’s training manifold.
  • Smaller auxiliary nets or alternative layers (exposed via options like FalconFile) allow testers to explore speed/strength trade-offs at fixed time controls. (open-chess.org)

6.2 Search and pruning: getting “free Elo” without breaking soundness

Revolution’s README explicitly lists Reverse Futility, Late Move Pruning, and history-driven ordering. These are mainstream techniques, but each comes with thresholds that must be re-tuned when evaluation scales shift (e.g., when changing NNUE nets). The engines’ ongoing release notes and gauntlets suggest an active tuning posture—chasing the last fractions of Elo that come from carefully balancing reductions, extensions, and aspiration widths. (GitHub)

Practical impact:

  • On commodity hardware, well-tuned LMR schedules usually grant more depth equivalent than raw node speedups.
  • Over-aggressive reductions risk tactical blindness in quiet-looking positions; guardrails like Minimum Thinking Time cushion the worst-case responses. (GitHub)

6.3 Experience files vs Polyglot books

Ruiz’s engines make a clear distinction between experience (learned from search) and book (externally authored move trees). Revolution’s experience system supports a book-mode, but its default role is biasing root move ordering rather than forcing lines. When a strict, reproducible opening policy is needed—e.g., UHO suites in rating tests—Polyglot books via the StockfishPolyglota fork (or GUI-level books) remain ideal. The key is to separate “search strength” from “opening selection” during experiments. (GitHub)

6.4 Tablebases and pre-mapping in the testing loop

Syzygy probing is now table-stakes for top engines; the twist here is Revolution’s SyzygyPremap option. For long gauntlets, especially at classical controls or endgame-rich books, pre-mapping can reduce jitter in late-endgame PVs and help avoid time spikes on I/O. As always, RAM budgets and startup overhead must be balanced against throughput in the chosen harness. (GitHub)

6.5 Time management you can trust in GUIs

The combination of Minimum Thinking Time and Time Buffer is deliberately conservative: it reduces “zero-time” blunders and accidental flags when the GUI’s scheduler and the engine’s timers disagree. Wordfish’s path-resolution fixes for NNUE files address another class of GUI-integration hazards: engines launched from complex working directories (or via third-party tools) should still find their networks without manual babysitting. (GitHub)

7) Positioning within the Stockfish ecosystem

7.1 Respecting GPLv3 and community norms

The GPLv3 inheritance from Stockfish is not just a legal nicety; it defines the collaboration model: source availability, reproducibility, and acknowledgment of upstream authors. Ruiz’s READMEs and forum communications repeatedly situate his engines as Stockfish-derived, with modifications credited and repositories public. That transparency enables peer review and diff-level discussion of ideas. (GitHub)

7.2 GUIs, protocols, and end-user usability

All projects target the UCI protocol and are usable under mainstream GUIs (Arena, CuteChess-CLI/FastChess harnesses, Fritz). The official Stockfish docs remain a canonical reference for UCI usage and binary choices (e.g., x86-64-bmi2/avx2 builds), and they apply equally to these derivatives—choose the best architecture target for your CPU to extract full speed. (official-stockfish.github.io)

7.3 Community touchpoints

Beyond GitHub, releases and milestones for Ruiz’s engines appear on engine-watcher blogs and in forum threads (Open-Chess, Outskirts). These outlets provide informal change logs, configuration tips (e.g., FalconFile), and testing anecdotes that complement the code repositories. (open-chess.org)

8) Practical guidance for testers and users

  1. Pick the right binary & net
    Build with the highest architecture your CPU supports (e.g., AVX2/BMI2) and pair it with a network that fits your hash & time constraints. Smaller nets can help at ultra-fast controls; larger nets pay off at blitz/classical. Use Wordfish’s FalconFile (or equivalent options) to A/B networks cleanly. (official-stockfish.github.io)
  2. Separate book from strength
    If you seek engine Elo, use balanced opening sets and disable hard book forcing. When you need opening coverage or line-repetition control, prefer Polyglot and a curated .bin book, whether via GUI or StockfishPolyglota. (GitHub)
  3. Stabilise endgames
    Enable Syzygy where disk and RAM permit; consider SyzygyPremap for long sessions to reduce probe latency. (GitHub)
  4. Use SPRT
    Gate changes with LEAN matches (fixed TC, fixed book, reproducible seeds) rather than anecdotal testing. The Stockfish docs and community harnesses offer patterns to follow. (official-stockfish.github.io)
  5. Mind time management & I/O
    Turn on Minimum Thinking Time and a Time Buffer for stability, especially in GUIs known to juggle multiple engine processes. Ensure NNUE paths are resolved reliably (Wordfish’s recent fixes are a good model). (GitHub)

9) Conclusion

Jorge Ruiz Centelles’ Stockfish-derived work illustrates how open-source chess engines evolve: not by single dramatic overhauls, but by measured, test-driven increments across search heuristics, evaluation plumbing, I/O robustness, and user-facing options. Revolution codifies a clean experimental surface for pruning, NNUE hybridisation, experience learning, tablebases, and time policy. Wordfish emphasises pragmatic reliability (portable NNUE pathing, alternative-net loaders like FalconFile) while keeping pace with mainstream search/eval techniques. And StockfishPolyglota rounds out the ecosystem by restoring a time-tested capability—Polyglot .bin books—directly inside a Stockfish-line codebase.

For engine developers and testers, these projects are valuable not only as artifacts to use, but as repositories to study: they make design trade-offs explicit, surface options that clarify experimentation, and plug neatly into today’s SPRT-centric evaluation culture. That, more than any single tweak, is the enduring contribution: engines that are easy to test, easy to compare, and easy to learn from.

References

  • Revolution (GitHub repository and README). Architecture, UCI options, Syzygy Premap, experience file system, licensing, and release metadata. (GitHub)
  • StockfishPolyglota (GitHub). Stockfish fork “with support bin books,” used to enable Polyglot opening books at engine level. (GitHub)
  • Wordfish release/watch posts. Public notes on versions 2.40 and 2.50; description of goal and implementation; practical fixes for NNUE path resolution and evaluation cache handling. (chessengines.blogspot.com)
  • Community note on FalconFile (Open-Chess). How to point Wordfish to alternate networks (e.g., 3.net). (open-chess.org)
  • Stockfish documentation (official). UCI usage, binary selection by architecture; general engine behaviour and ecosystem context. (official-stockfish.github.io)

Editor’s note on scope: you provided an IJCCRL page for an SPRT of Revolution 1.0.1 vs 1.0. That page is currently blocked to our crawler, so we did not quote its figures; instead we cite the public Revolution README and community posts that document the project’s iterative, SPRT-oriented workflow. (GitHub)

Downloads