Nibbler: a real-time analysis GUI for Leela Chess Zero

The engine runs in the background and the board never stops updating

Nibbler is described as a real-time analysis GUI for Leela Chess Zero, and the key phrase in the project description is constantly. Leela runs in the background and Nibbler displays its opinions about the current position as you play, and you can compel the engine to evaluate one or more specific moves on demand.

That is a different interaction model from a conventional analysis board. A traditional engine GUI waits for you to stop, then thinks. Nibbler keeps a position in front of the engine and lets you move while it searches, so the evaluation you see is the engine's opinion of the position you are in, not of the position you were in a minute ago. The features list makes this concrete: display Leela's top choices graphically, a winrate graph, and optionally the Leela statistics for each move.

Those statistics are named in the feature list as N, P, Q, S, U, V and WDL. For people who know Lc0, they are the raw policy and value outputs of the network rather than a single collapsed number, and showing them per move is the part of the interface that makes the tool interesting for people who want to understand the network's reasoning rather than just take its move.

The project states that it is loosely inspired by Lizzie and Sabaki, both of which are analysis interfaces for the same kind of engine, so the design lineage is the category of tool rather than a unique invention.

The repository itself is small in listing terms, with a LICENSE.md, a README.md and a files/ directory at the top level, and the source lives under src/ according to the run instructions. The project is GPL v3.0 licensed.

searchmoves is how you stop Leela from ignoring your candidate

The hints and tips section contains the one feature that changes how the engine thinks, and it is worth understanding before you blame the evaluation.

The UCI searchmoves option is available in the Analysis menu. Once enabled, you can specify one or more moves as the ones to focus on, and Leela will ignore the other moves. The README gives the reason plainly: this is useful when you think Leela is not giving a certain move enough attention.

This is a real characteristic of neural network engines rather than a bug in the GUI. A search that is free to explore any move may simply not visit the line you care about, especially in an opening where the network is confident about something else. searchmoves forces the search into the branch, so the number you see for that move is the number the engine produces when it is actually looking.

The second tip concerns continuity. Leela forgets much of the evaluation if the position changes, so the interface lets you hover over a principal variation on the right and see it played out on the board without changing the position actually being analysed. The README suggests halting Leela while you do that, so the variations do not shift under you while you are reading them.

The third tip is about memory. Leela running out of RAM can be a problem if searches go on too long, and the suggestion is to set a reasonable node limit in the Engine menu, perhaps ten million or so. A node cap is the practical way to bound a search that is otherwise limited only by your patience and your RAM.

Together these three options are the difference between a display of an opinion and a tool you can interrogate.

Stockfish works, but the settings are not optional

The project is candid about the traditional engine case. It says that these days Nibbler more or less works with engines like Stockfish too, and then it lists the conditions: ensure MultiPV is 1, Threads (CPU) is set, and Hash is set, more is better, for maximum strength.

The MultiPV requirement is the interesting one. Nibbler draws a graph of top choices per move, which assumes one principal variation per position, and a multi-PV engine returns several candidate lines at once. Leaving MultiPV at its default of several produces a display the tool was not designed to render. The other two settings are about the engine doing its best work: threads for the CPU to use and hash for the transposition table, and the parenthetical about more being better is the project telling you the memory settings are a performance lever.

The engine configuration has two routes. Leela itself automatically loads options from a file called lc0.config at startup, with a link to the Lc0 configuration documentation, and separately Nibbler sends the UCI options specified in Nibbler's own engines.json file, which you can find through the Dev menu. The Dev menu entry is the useful discovery mechanism, since a GUI that hides its engine configuration behind a developer menu is telling you the setting is for people who know what they are doing.

The end result is that Nibbler is a Lc0-first tool that tolerates a conventional engine, not a general engine GUI. If your interest is Stockfish lines rather than neural network evaluation, the setup friction here is a signal.

The rest of the feature set is standard analysis workflow: automatic full-game analysis, playing against Leela from any position, Leela self-play from any position, PGN loading through a menu, the clipboard or drag and drop, support for PGN variations of arbitrary depth, FEN loading, and Chess 960.

Three installation paths, and macOS is a community build

Some standalone Windows and Linux releases are uploaded to the Releases section from time to time, and the README notes the releases are not continuous. Prebuilt binaries for macOS do not exist from the main project. Mac builds have been made by twoplan, by Jac-Zac and by Zamana, and the README says the last of these is probably the most up to date.

That is the whole macOS story, and it is the sharpest platform caveat in the project. On macOS you are depending on a third-party fork, and the project itself declines to say which one to trust beyond the up-to-date hint.

Running from source is described as requiring Electron and having no other dependencies. If Electron is installed, for example through a global npm install of electron, you can enter the src directory and run electron . to launch it. The README states compatibility with at least version 5 and above of Electron. There is also a route to a standalone app, with the details in the comments of the Python script builder.py.

Two install scripts are provided, one for Linux and one for macOS, each a one-liner that fetches a script over curl and pipes it to bash:

curl -L https://raw.githubusercontent.com/rooklift/nibbler/master/files/scripts/install.sh | bash

The macOS script exists for a specific reason, stated in the README: building the app on the fly removes codesigning problems, that is, Gatekeeper refusing to open unauthorised apps. The author adds that they cannot test it themselves, which is worth weighing before you pipe it into a shell on your main machine.

The most useful path for support is the Discord, which the README suggests is the best bet for help, with GitHub issues as the alternative.

The release cadence slowed while the repository kept moving

The version list is short and recent enough to be useful. The releases are v2.5.8 on 2026-03-31, v2.5.7 on 2026-03-19 and v2.5.6 on 2026-03-05, so the patch cadence in early 2026 was roughly every two weeks, and the last push to the repository was on 2026-10-09. The repository is not archived.

The gap between the newest tagged build and the newest commit is the number to keep in mind, because Nibbler is distributed as binaries rather than as a library you compile. A commit is not something you can install, so the code in the tree and the binary you can download are not the same thing. For a tool whose whole value is being current with the engine it drives, that gap matters more than it would for a library, and the README's own description of the Releases section as holding binaries uploaded from time to time is the reason.

The dependencies of the project are worth noting too, and they are unusual for a desktop app. Nibbler is a JavaScript project that runs inside Electron, and the interface pieces, the board, the pieces and the graph, are credited to Lichess. The icon design is credited to a named designer and is based on a chess piece from a public SVG repository.

The licence is GPL v3.0, with the terms in the LICENSE.md file. For an end user installing a binary, that is unremarkable. For anyone thinking of extending the interface, the copyleft terms and the attribution to Lichess for the interface pieces both apply, and the latter is the one that is easy to overlook when you reuse board code in a project of your own.

Editorial conclusion

Nibbler is worth installing if you train against Leela rather than only against a traditional engine, because the live opinion overlay and the searchmoves focus make it possible to see which moves the neural network prefers and why, and the winrate graph makes the trajectory of a position legible in a way a static evaluation does not. It is the wrong tool if you want only Stockfish analysis, since the project describes that case as more or less working rather than first class, and it is the wrong tool on macOS if you need a maintained signed build. Before you run it, verify three things yourself: that your engine is configured for the strength you expect, since the README asks for MultiPV set to 1, Threads set and Hash set, that you set a node limit if your search runs long enough to exhaust RAM, and that the licence terms suit you, since the project is GPL v3.0.

Frequently asked questions

Official sources

1. Issues
2. License: GPL-3.0
3. README
4. Releases
5. rooklift/nibbler on GitHub