Pikafish gives you a xiangqi engine and nothing else

The board lives somewhere else entirely

Pikafish describes itself as a free and strong UCI xiangqi engine, and the same sentence is the whole product definition. It analyzes xiangqi positions and computes the optimal moves. What it does not do is draw one. The README is explicit that Pikafish does not include a graphical user interface, and that such interfaces are required to display a chessboard and to make it easy to input moves. Those GUIs are built independently from Pikafish, and the project points you at the documentation for whichever one you pick rather than naming a default.

That boundary decides who the tool is for. If you want to open xiangqi on a laptop and analyse a game, Pikafish is a component you bolt under someone else's interface, not something you install and run. If you are writing a board application, embedding an analysis line, or running batch analysis over position files, then the absence of a GUI is the feature: you need a process that speaks a text protocol on standard input and standard output, and Pikafish is exactly that shape of program.

The project also runs a site at pikafish.com and a rule book at pikafish.org/rule.html, so rules and notation have somewhere authoritative to live even though the engine itself has no interface. The homepage and the rule book are documentation, not part of the binary.

A Stockfish fork pointed at a different board and piece set

Pikafish is derived from Stockfish, and the repository makes no attempt to hide that. The engine is written in C++, the default branch is master, and the repository topics are cpp, pikafish, uci, xiangqi and xiangqi-engine. Everything about the build story points back to that inheritance: a Stockfish tree retargeted at a ninety square board, with its own move generator, its own piece set and its own evaluation.

Evaluation here is neural rather than hand written. The distribution carries a file with the .nnue extension that stores the network used for the NNUE evaluation, and those networks were trained on data provided by the Pika Xiangqi Zero project. Whatever Pikafish calls the optimal move therefore rests on a weights file that this project did not train itself.

Where inherited techniques get explained, you are routed elsewhere rather than given a write up. The chessprogramming wiki has a section on Stockfish covering many features and techniques used by Pikafish, and that coverage is explicitly generic rather than focused on Stockfish's precise implementation. Day to day discussion happens on the Pikafish Discord server, which the README names as the best place to ask questions about the codebase and how to improve it.

The .nnue file is listed but never named, and no option is given to find it

The distribution consists of README.md, Copying.txt, AUTHORS, a src subdirectory holding the full source code and a Makefile, and a file with the .nnue extension storing the NNUE neural network. Read that list closely and two things are missing. The file is never given a name, and no option, path or environment variable is documented anywhere in the README for pointing the engine at it.

That matters more than a missing file listing usually would. A neural evaluation that cannot locate its weights file has nothing to evaluate with, and every number the engine returns downstream depends on which network was loaded. The README's answer to the question is a pointer to the wiki, which is where the UCI commands and the per platform compilation details actually live.

The same gap appears in the repository root. The tree carries .clang-format, .gitattributes, .github/, .gitignore, AUTHORS, CITATION.cff, CONTRIBUTING.md, Copying.txt, README.md, Top CPU Contributors.txt, scripts/, src/ and tests/. The Files section describes a smaller distribution than the repository, which is normal for a built package, but it means the scripts/ and tests/ directories you can see in the tree have no description anywhere in the README.

profile-build is the only compile recipe the README spells out

On Unix like systems the build is a two step affair from the source tree. The Makefile lives in the src subdirectory, and running make help first lists the available make targets with their descriptions. Pikafish targets 32 or 64-bit CPUs, certain hardware instructions, and big-endian machines such as Power PC, so the profile build is a starting point rather than the whole platform story.

cd src
make help

Then the profile build itself, which is what the README recommends running directly:

cd src
make -j profile-build

After it finishes you have a compiled engine and a .nnue file sitting next to it in the distribution, and at that point you need a GUI, because nothing in the binary will show you a position. The -j flag lets the build use every core, and profile build is the target the project actually points people at rather than a bare default.

What the README does not contain is any list of output artefact names, any install step, and any packaging guidance. It also does not enumerate what the build produces beyond the engine, so if you are scripting a pipeline you will be reading the wiki at pikafish.com rather than the README for platform specific compilation instructions.

The UCI command set is documented somewhere the README does not reach

This is the section that decides whether you can adopt Pikafish today or next week. Pikafish speaks UCI, the text protocol a chess or xiangqi GUI drives an engine through, and the README confirms that the wiki has information about the UCI commands supported by Pikafish. It does not print a single command.

There is no position setup syntax in the README, no move output format, no go depth parameter, no option list with defaults. That is not sloppiness, it is a deliberate division of labour: the engine half of the pair and the GUI half of the pair each document their own side. The README puts the responsibility on you explicitly, telling you to read the documentation for your GUI of choice for information about how to use Pikafish with it, and pointing at the Pikafish documentation for further usage help.

The practical consequence for an integrator is that you cannot build a Pikafish integration from this README alone. Every protocol detail, every tunables set name and every engine option default has to come from the wiki. Budget a reading pass there before writing the first line of glue code, and treat the README as a project overview rather than a specification.

Strength is measured on Fishtest, not in a benchmark you can run

Pikafish has no performance numbers in its README and no way to reproduce strength claims from the repository. What it offers instead is the testing infrastructure the project actually uses. The README states that improving Pikafish requires a massive amount of testing, and gives you two routes in.

The first is compute. Installing the Fishtest Worker lets you donate hardware resources, and the current tests are viewed on Fishtest at test.pikafish.org, which is also where the header badges point. The second is code and test design. The README points contributors to a Fishtest guideline explaining the basics of Pikafish development, and notes that engine testing is done on Fishtest.

This is worth understanding as an adoption fact rather than a community detail. A UCI engine has no benchmark you can run and no score you can quote, because strength is defined relationally against opponents on a distributed test cluster. If you need a defensible number for a decision, you will have to run Fishtest style testing yourself or measure wins against the specific engines you already use.

Redistributing the binary obliges you to ship the source too

Distribution is the part of the terms with real engineering consequences, and Pikafish states them without hedging. It is free under GPL v3, so you may hand it to friends, make it downloadable from your own site, sell it alone or inside a larger package, and start your own project from it, but every distribution must carry the licence plus the full source code, or a pointer to where the source generating that exact binary lives, and any change you make to the source has to be published under the same terms. For a team embedding the engine in a commercial product, that obligation travels with the artefact rather than with a download page.

The weights file sits outside those terms and needs its own review, so read the code terms and the training data terms separately before bundling them. On the repository itself, the last push to master was on 2026-10-01, and nothing in the tree is marked archived.

Editorial conclusion

Adopt Pikafish if you already run xiangqi through a third party GUI and want a strong, freely redistributable engine underneath it, or if you want to donate idle CPU to test.pikafish.org. Do not adopt it as a standalone application, as a library with a documented API, or on a machine where you cannot install a compiler toolchain. Before committing, check the one thing the README leaves open: how the unnamed .nnue file beside the binary is located and replaced, because every analysis result depends on it.

Frequently asked questions

Official sources

1. License: GPL-3.0
2. official-pikafish/Pikafish on GitHub
3. Project website
4. README
5. Releases