# KataGo: a GTP engine for Go analysis and self-play training

> KataGo is a C++ GTP engine with a JSON analysis backend and an AlphaZero-style self-play pipeline. It solves score estimation and handicap play, but it ships without a GUI and expects you to bring your own neural net.

**lightvector/KataGo** — GTP engine and self-play learning in Go

- Repository: https://github.com/lightvector/KataGo
- Website: https://katagotraining.org/
- Stars: 5,156 · Forks: 768
- Language: C++
- License: NOASSERTION
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/lightvector-katago

## What KataGo solves that winrate-only engines do not

Most Go engines report a win probability. That number is nearly useless in a kyu game, where both players are far from optimal and the game is rarely decided by a single move. KataGo's README states that it estimates territory and score, rather than only winrate, which is what makes it usable for reviewing amateur games. The same design choice changes how it plays: the README says KataGo cares about maximizing score, which produces strong play in handicap games when it is far behind and reduces slack endgame moves when it is winning.

The engine also handles conditions that self-play bots often ignore. It supports alternative komi values, including integer values, and good high-handicap game play. Board sizes run from 7x7 to 19x19, and the README notes that as of May 2020 it may be the strongest open source bot on both 9x9 and 13x13. Rules coverage is broader than most: the README points to a rules page and claims support for rules matching Japanese rules in almost all common cases, plus ancient stone-counting-like rules.

The audience is therefore two groups that rarely share a tool. Go players and reviewers who want score-aware analysis, and researchers who want a self-play testbed. The README addresses the second group directly, describing the training process as AlphaZero-like with enhancements, and noting that many techniques are general and could be applied in other games.

## The engine, the net, and the analysis protocol

KataGo is split into a binary and a neural net, and the two are distributed separately. The README sends readers to the GitHub releases page for precompiled executables for Windows and Linux, and to katagotraining.org for the latest neural nets. Nothing in the README suggests a bundled download containing both, so a first run means reconciling a binary with a model file.

The engine speaks GTP, described in the README as a simple text protocol that Go software uses. That is the whole interface. A GUI or analysis program sits above it and issues GTP commands. The README lists KaTrain as one of the easier or more popular options, and notes that a few GUIs bundle KataGo so you can get everything from one place rather than downloading separately and managing the file paths and commands.

For tool developers there is a second interface. The README describes a JSON-based analysis engine that can batch multiple-game evaluations efficiently and be easier to use than GTP. That distinction matters: GTP is one position at a time, oriented toward interactive play, while the analysis engine is oriented toward evaluating many positions in bulk. If you are building a review tool or a dataset pipeline, the JSON path is the one to read first.

The README also mentions GTP extensions and an analysis engine section under features for developers, so the plain GTP surface is not the full command set.

## Setting up KataGo and getting to a first analysis session

There is no package manager step here. The README directs you to the releases page for Windows and Linux executables and to katagotraining.org for neural nets, so setup is a download-and-place operation. Compiling from source is covered separately in Compiling.md at the repository root.

Start by fetching a precompiled binary and a net, then confirm the engine starts. The README's setup section is where the engine is launched and where the model and config arguments are described; the example config ships with the repository rather than being generated by the binary.

Once the engine is running, a GUI connects to it over GTP. The README's guidance is to use one of the GUIs rather than driving GTP by hand, and KaTrain is the example it gives. In the GUI you point at the engine binary and the model file, then load a game record for review.

For batch work, the analysis engine takes a JSON request instead. The README describes it as able to batch multiple-game evaluations efficiently, which is the reason to prefer it over issuing GTP commands in a loop when you have a directory of games to process. The repository also carries python/ and pytest.ini at the top level, so there is Python tooling alongside the C++ engine, though the README's setup instructions stay focused on the binary and the GUI path.

## Backends are a real decision, not a detail

The README devotes a section to OpenCL versus CUDA versus TensorRT versus ROCm versus ONNX versus Eigen. That list is the practical constraint on adoption. Which one you can use depends on your GPU vendor and driver, and the choice is made at build or download time, not at runtime.

This is where most first-time failures will land. The README has separate subsections for issues with specific GPUs or GPU drivers and for common problems, which is a signal about where users get stuck. Recent releases reinforce the point: v1.18.2 is titled CUDA Speedup for Turing (RTX 20xx, etc), and v1.18.0 is titled New backends, major CUDA optimizations, rules fix support. Optimization work is landing per backend and per GPU generation, so a build that is fast on one card may not be on another.

Eigen is the fallback that does not need a GPU. The README lists it among the backends without ranking it, but its position in the list and its nature make it the option for machines with no usable accelerator. Expect it to be the slowest path, and treat it as a way to get the engine running rather than a way to get useful analysis throughput.

Performance tuning has its own README section, which implies that default settings are not assumed to be optimal. If your first results feel slow, the documented next step is that section, not a different engine.

## Where KataGo is the wrong tool

The clearest limitation is stated by the project itself: KataGo implements just a GTP engine and does not have a graphical interface on its own. If you want to open an app, load an SGF and see colored territory, KataGo alone will not do it. The README's answer is to pair it with a GUI, and it notes that some GUIs bundle KataGo so you avoid managing file paths and commands yourself. That is an admission that the manual path is fiddly.

The second limitation is the model dependency. The engine and the neural nets are downloaded from different places, and the README does not describe a version compatibility check between them. Nothing in the README documents rollback if a new net or a new binary regresses your setup, so if you are deploying this in a pipeline, pin both artifacts yourself.

Third, this is not a general game-playing framework. The training techniques are described as general and applicable to other games, but the engine, its rules support and its analysis output are Go-specific. A researcher wanting to test self-play ideas on chess or shogi would be adapting a Go codebase, not using a neutral platform.

Finally, the README's own framing of strength is careful. It says KataGo remains one of the strongest open source Go bots as of 2026, which is a claim about open source bots, not about all Go software. Anyone expecting a documented, reproducible head-to-head result against a closed system will not find it in the README.

## How KataGo differs from Leela Zero and from AlphaGo

The natural comparison is Leela Zero, the other well-known open source self-play Go engine. The README does not name it, so the difference has to be read from what KataGo documents about itself rather than from a stated head-to-head. KataGo's README emphasizes score and territory estimation, komi and handicap support, board sizes from 7x7 to 19x19, and a JSON analysis engine for batch evaluation. Those are analysis-tool features. A winrate-only engine gives you a single number per position; KataGo's stated design gives you score estimates that remain meaningful in amateur games where the winrate is already lopsided.

AlphaGo is the other name people reach for, and the README addresses it indirectly. KataGo is described as trained using an AlphaZero-like process with many enhancements and improvements, capable of reaching top levels entirely from scratch with no outside data. The README also notes that KataGo experimentally tried limited ways of using external data at the end of its June 2020 run and continued doing so into the most recent public distributed run, kata1. External data is described as not necessary for reaching top levels, but as providing mild benefits against some opponents and noticeable benefits in an analysis tool for situations that do not occur in self-play but do occur in human games. That is a meaningful architectural difference from a pure self-play system: the analysis target is human games, not self-play games.

The practical difference for a reader choosing a tool is access. AlphaGo was not released as software. KataGo is a C++ engine with a public repository, precompiled releases for Windows and Linux, and a distributed training site at katagotraining.org.

## Maintenance, licensing and what an upgrade costs

The repository is not archived, and the last push was on 2026-09-20. Releases have been frequent: v1.18.0 on 2026-08-22, v1.18.1 on 2026-08-24, and v1.18.2 on 2026-08-30. The release titles show what kinds of changes arrive: new backends, major CUDA optimizations, rules fix support, better benchmark and genconfig tooling, and a CUDA speedup for Turing-generation cards. Upgrades are therefore not purely cosmetic, and a backend optimization can change which build you should be running.

The upgrade cost has two parts. The binary is a download from the releases page, so replacing it is cheap. The neural net is separate, comes from katagotraining.org, and the README does not document a compatibility matrix or a rollback procedure. If you run KataGo inside an analysis pipeline, budget for keeping the binary, the config and the model pinned together, and for re-running whatever validation you use when any one of them changes.

The licence field in the repository metadata is NOASSERTION, meaning the metadata does not resolve to a standard SPDX identifier. The repository has a LICENSE file at the top level, and that file is the thing to read, not the metadata field. The README's own license section is where the project states its terms. This is not legal advice, and the terms of the neural nets published at katagotraining.org are a separate question from the terms of the engine source.

## Conclusion

Adopt KataGo if you want score and territory estimates rather than only winrate, need komi and handicap handling, or intend to run self-play training on your own GPUs. Do not adopt it if you want a finished application: the README states plainly that KataGo implements just a GTP engine and has no graphical interface of its own, so a GUI such as KaTrain has to be installed alongside it. Before committing, verify three things: that a neural net from katagotraining.org matches your build, that your GPU driver works with the backend you compiled against, and that your GUI can locate the engine binary and the model file, since the README treats that path and command management as the user's job.

## FAQ

### Is KataGo better than AlphaGo?

The README does not make that claim. It says KataGo remains one of the strongest open source Go bots as of 2026, and describes its training as AlphaZero-like with many enhancements. AlphaGo was not released as software, so a direct comparison is not something the README provides.

### What is KataGo used for?

The README describes it as an engine aimed at Go players and developers, used for play and analysis through a GUI or analysis program. It estimates territory and score rather than only winrate, and for developers it offers a JSON-based analysis engine for batch evaluation.

### Is KataGo still being developed?

The repository is not archived and the last push was on 2026-09-20. Three releases landed in August 2026: v1.18.0, v1.18.1 and v1.18.2.

### Who created KataGo?

The repository is lightvector/KataGo, and the README credits Jane Street with supporting the training of KataGo's major earlier published runs. The README also links a computer Go discord channel for general questions.

### How do I install KataGo?

The README points to the releases page for precompiled executables for Windows and Linux, and to katagotraining.org for the latest neural nets. A GUI is needed separately, and the README notes that a few GUIs bundle KataGo so you avoid managing file paths and commands yourself.

## Sources

- [Issues](https://github.com/lightvector/KataGo/issues)
- [lightvector/KataGo on GitHub](https://github.com/lightvector/KataGo)
- [Project website](https://katagotraining.org/)
- [README](https://github.com/lightvector/KataGo/blob/master/README.md)
- [Releases](https://github.com/lightvector/KataGo/releases)

---

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