# Stockfish: the UCI chess engine you install separately from your board

> Stockfish is a free UCI chess engine, not an app. This covers what it does, how to build it from src with the bundled Makefile, how to drive it from a GUI, and where the GPL-3.0 source obligation lands.

**official-stockfish/Stockfish** — A free and strong UCI chess engine

- Repository: https://github.com/official-stockfish/Stockfish
- Website: https://stockfishchess.org/
- Stars: 16,766 · Forks: 3,049
- Language: C++
- License: GPL-3.0
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/official-stockfish-stockfish

## What Stockfish actually is, and who ends up using it

The README opens with a single sentence of scope: Stockfish is a "free and strong UCI chess engine" derived from Glaurung 2.1 that "analyzes chess positions and computes the optimal moves." That is the whole product. It reads a position, searches, and returns a move or an evaluation. It does not draw a board.

The README is unusually blunt about this: Stockfish "does not include a graphical user interface (GUI) that is required to display a chessboard and to make it easy to input moves," and those GUIs "are developed independently from Stockfish and are available online." So the audience is not the casual player looking for an app. It is the person wiring an engine into something else: a desktop analysis program, a bot, a tournament runner, a training pipeline, or a test harness. If you are evaluating Stockfish because you want to analyze your own games, you are really evaluating a GUI and using Stockfish as the component behind it.

## The UCI boundary: what Stockfish does and what the GUI does

Stockfish speaks UCI, the Universal Chess Interface. The repository topics list "uci" alongside chess, chess-engine, cpp and stockfish, and the README links to a wiki page on the UCI commands the engine supports. The practical consequence is a clean split of responsibilities. The engine owns search, evaluation and move selection. The GUI owns the board, the move list, the clock, the opening book, and the decision of when to ask the engine anything at all.

That boundary explains most of the confusion around the project. When someone asks how to use Stockfish on a given site or device, the answer usually lives in the GUI's documentation, not here. The README says as much: "Read the documentation for your GUI of choice for information about how to use Stockfish with it." The repository itself contains source, a licence, an authors list and the README. There is no user-facing configuration file in the top level, no settings screen, no defaults you can tune without a front end to send commands.

Evaluation also depends on a neural network. The file listing describes "a file with the .nnue extension, storing the neural network for the NNUE evaluation," and notes that binary distributions will have this file embedded. If you compile yourself, that detail matters: a build without the network available is not the thing you benchmarked.

## Building Stockfish from src on a Unix-like system

The README gives compilation as the primary path on Unix-like systems, using the Makefile inside the src directory. It recommends running make help first to see the available targets with their descriptions. For most Intel and AMD chips it gives this example:

```bash
cd src
make -j profile-build
```

The result is an engine binary in that directory. Note that profile-build is a target the README names explicitly for typical Intel and AMD hardware; the README also says Stockfish supports 32-bit and 64-bit CPUs, certain hardware instructions, big-endian machines such as Power PC, and other platforms, and points to a wiki page with detailed compilation instructions for all of them. If your target is not a mainstream x86 machine, go there rather than guessing at flags.

Once you have a binary, the engine is driven over UCI by whatever front end you chose. The README does not document a first-run wizard, so the honest first step is: open your GUI, point it at the binary you just built, and let the GUI send the UCI handshake. The README directs usage questions to its wiki page on downloading and usage, and command questions to the wiki page on UCI and commands. Those two pages, not the README, are where a first real session is described.

## Where Stockfish is the wrong tool

The most common mismatch is expecting a product. There is no GUI, no board, no account, no mobile build described in the README. Someone who wants to play a game against a strong opponent on a phone needs an app that bundles or downloads an engine; Stockfish supplies the engine half only.

The second mismatch is redistribution. Stockfish is GPL-3.0, and the README spells out the practical shape of that: you may distribute it, sell it, or build a project on it, but whenever you distribute Stockfish "you MUST always include the license and the full source code (or a pointer to where the source code can be found) to generate the exact binary you are distributing," and any changes you make must also be made available under GPL v3. If your plan is to ship a closed-source product with a modified engine inside, this licence is a direct obstacle, not a detail to sort out later. The network data adds a second layer: the README states that Stockfish uses neural networks trained on data provided by the Leela Chess Zero project, made available under the Open Database License (ODbL).

Third, the project's own development model assumes heavy testing. The README describes improving Stockfish as requiring "a massive amount of testing," run on Fishtest, with a contributing guide that anyone proposing changes is asked to read first. That is a healthy process, and it also means casual patches are unlikely to land.

## Leela Chess Zero: the same game, a different way of deciding moves

The README itself points at Leela Chess Zero twice: as the source of the training data behind Stockfish's neural networks, and as a separate project. The interesting part for anyone choosing an engine is that the two arrive at moves differently. Stockfish's lineage is a classical alpha-beta search engine, derived from Glaurung 2.1, with the NNUE network supplying the evaluation that the search consumes. Leela Chess Zero is built around a neural network guided by Monte Carlo tree search, and its training data is published under the ODbL.

The practical difference is in how you reason about the output. A search-based engine's evaluation is the product of a tree it walked; a network-and-MCTS engine's evaluation is the product of a policy and value estimate averaged over many simulated playouts. For most users the distinction shows up as style and as hardware sensitivity rather than as a correctness question, and both are usable through the same kind of GUI. If your pipeline already assumes a classical search engine's behaviour, Stockfish is the closer fit; if you specifically want a network-first engine, that is a different project, and the README's acknowledgement section is where the relationship is stated.

## Release cadence, licence and the cost of staying current

The last push to the default branch was on 2026-09-19, and the most recent release carries the same date: stockfish-dev-20260919-17a6c8f1. Before that came sf_19 on 2026-09-05 and sf_18 on 2026-01-31. Two things follow. First, the project is not dormant; development is continuous, and the dev tags track it. Second, the practical upgrade question is not "is there a new version" but "which of these do I pin."

A dev build and a numbered release are different commitments. The numbered releases are the ones a downstream product should pin, because a dev tag names a specific commit and will be superseded within days. If you build from src yourself, you are effectively on the dev line whether you meant to be or not, and the profile-build target you used is tied to the machine you built on, so a rebuild on different hardware is a different binary. That is worth knowing before you attribute a behaviour change to the engine rather than to your build.

On licensing, the README's summary is generous and the obligation is narrow: use it, sell it, fork it, but ship the licence and the corresponding source, and publish your modifications under GPL v3. It also flags the ODbL on the Leela Chess Zero training data. Whether a particular product design is compatible with those terms is a question for a lawyer, not for this article.

## Conclusion

Adopt Stockfish if you want an engine to plug into an existing chess GUI, a bot, or a test harness, and you are willing to compile from src or use a binary distribution with the .nnue network embedded. Do not adopt it expecting a board, a mobile app, or a finished product: the README states plainly that no GUI ships with it, and every interface question routes to whichever GUI you pick. Before committing, check that your target platform appears in the compiling-from-source documentation, confirm whether the build you download embeds the .nnue file or expects it beside the binary, and read Copying.txt if you plan to redistribute a modified build.

## FAQ

### What is Stockfish's level of chess?

The README describes it as a free and strong UCI chess engine that analyzes positions and computes optimal moves, and does not publish an Elo figure for it. Any specific rating claim needs a source outside this repository.

### How do I install Stockfish?

On Unix-like systems the README's path is to compile from source with the Makefile in src, for example cd src followed by make -j profile-build, after running make help to see the targets. Detailed instructions for other platforms are in the wiki page on compiling from source.

### How do I use Stockfish?

Stockfish is a UCI engine with no board of its own, so you connect it to a GUI and read that GUI's documentation for how to drive it. The README links to wiki pages on downloading and usage, and on the UCI commands the engine supports.

### How do I use Stockfish to analyze games?

The engine computes moves and evaluations; the analysis view, the move list and the board come from the GUI you attach it to. The README tells readers to consult their GUI's documentation for usage, so the analysis workflow is defined there rather than in this repository.

### What kind of fish is Stockfish?

This question is about the fish, not the project. Stockfish is a free and strong UCI chess engine derived from Glaurung 2.1, and the repository says nothing about the animal.

## Sources

- [License: GPL-3.0](https://github.com/official-stockfish/Stockfish/blob/master/LICENSE)
- [official-stockfish/Stockfish on GitHub](https://github.com/official-stockfish/Stockfish)
- [Project website](https://stockfishchess.org/)
- [README](https://github.com/official-stockfish/Stockfish/blob/master/README.md)
- [Releases](https://github.com/official-stockfish/Stockfish/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/official-stockfish-stockfish