KaTrain: KataGo Analysis and Teaching Games for Go Players

What KaTrain is for, and who it is for

KaTrain is a desktop application for reviewing Go games and playing against AI, built around KataGo. The README lists four things it does: review games to find the moves that cost the most points, play against AI with immediate feedback and an option to retry, play against weakened AIs with different styles, and generate focused SGF reviews that highlight your biggest mistakes. Those four functions describe a training loop rather than a reference tool. You play or load a game, the engine scores your moves, and the app turns the worst ones into a file you can study.

The audience follows from that loop. A player who already reviews games by hand or in another SGF editor gets a faster way to rank mistakes by points lost. A teacher or study group gets generated SGF files that point at specific positions. Someone who only wants to look up joseki occasionally is not the target: the app is built around playing and reviewing, and the README's own video list includes a local joseki analysis clip, but joseki lookup is not the headline feature.

The project is written in Python and uses Kivy for its interface. That matters for expectations. Kivy is a cross-platform GUI toolkit, not a native toolkit, so the app behaves consistently across Windows, macOS and Linux rather than looking native on each. The pyproject.toml classifies the project as production/stable and lists Windows and POSIX Linux as operating systems; macOS support is visible in the dependencies, where pygame is pulled in only on Darwin and screeninfo only off Darwin. That is a small but concrete sign that the three platforms are maintained separately rather than as an afterthought.

How the KataGo engine is bundled and selected

The most consequential design decision in KaTrain is that it ships with an engine. According to the README, KaTrain comes pre-packaged with a working KataGo for Windows, Linux and Mac, using OpenCL except on Apple Silicon where it uses the Metal backend. It also bundles the `b10c384h6nbt` transformer model, which the README describes as stronger per visit than the strongest 18 block models while being about as fast. For a new user this removes the step that stops most people: downloading a binary, finding a matching network and wiring the two together.

The trade-off is that a bundled OpenCL build is a compromise. OpenCL runs on a wide range of hardware, but the README states plainly that CUDA and TensorRT for NVIDIA GPUs, ROCm for AMD GPUs, and ONNX for Intel GPUs or NPUs may offer much better performance, at the cost of being harder to set up. The ONNX route additionally requires setting `onnxProvider` in `KataGo/analysis_config.cfg`. So the default is chosen for reach, not speed, and the fast path is documented but manual.

Swapping components happens inside the app rather than on the command line. Open 'General & Engine Settings' with F8, click 'Download models' to pick a different network from a dropdown, or click 'Download KataGo versions' to change the binary, for example to the Eigen/CPU version if you have no GPU. That in-app download flow is the intended path; the README points to the KataGo release site for hardware-specific builds instead of mirroring them. The INSTALL.md file is where multi-GPU setup is covered, according to the README's own pointer.

Installing KaTrain and running a first review

The README gives three install routes. Downloadable executables for Windows and macOS are on the releases page, which avoids Python entirely. On any 64-bit OS you can install from PyPI in an isolated environment with pipx. On macOS there is a Homebrew cask, with the caveat that the README says it can lag several versions behind the releases page.

The pipx route is one command:

pipx install katrain

After that, the `katrain` entry point is available, because pyproject.toml declares `katrain = "katrain.__main__:run_app"` under `[project.scripts]`. Running it opens the Kivy interface. Note the Python constraint before you start: `requires-python` is `>=3.11,<3.14`, and a comment in pyproject.toml explains the upper cap is there because kivy and ffpyplayer do not yet ship cp314 wheels. If your default Python is 3.14, pipx will fail rather than silently install something broken.

Once the window is open, the first real task is loading a game to review. The README does not spell out a file-open walkthrough, but it does document the keyboard surface: F8 opens General & Engine Settings, and a separate section of the manual covers keyboard and mouse shortcuts. The workflow the README describes is that you review a game and the app ranks moves by points lost, then you can have it generate a focused SGF review containing your biggest mistakes. For AI play, the README describes immediate feedback on mistakes with the option to retry the move, which is the feature that distinguishes it from a plain analysis board. If you have no GPU, the README's stated fallback is to switch the binary to the Eigen/CPU version through 'Download KataGo versions'.

Where KaTrain runs, and where it does not

The README lists executables for Windows and macOS and a pipx install for any 64-bit OS, plus a macOS brew cask. pyproject.toml classifies the project for Microsoft Windows and POSIX Linux. There is no web build and no hosted service described anywhere in the README. If you want to analyze a game from a browser on a machine you do not control, KaTrain is the wrong tool, and the README does not suggest otherwise.

The packaging constraints are also worth reading before installation rather than after. The Python version is capped below 3.14, and the pyproject.toml comment is explicit that this is a binary-wheel availability issue for kivy and ffpyplayer, not a policy choice. That cap will move when those wheels ship, but until then a 3.14 environment is out of scope. The dependency on ffpyplayer is direct and the comment notes kivy does not pull it, which means audio support is a deliberate dependency rather than a side effect of the GUI toolkit.

One more boundary: the README's installation section points to INSTALL.md for detailed instructions and troubleshooting, and to the KataGo release site for hardware-specific binaries. KaTrain does not vendor CUDA, TensorRT, ROCm or ONNX builds. If your hardware needs one of those, you are combining two projects, and the README only guarantees that the bundled OpenCL or Metal engine works out of the box.

KaTrain compared with Lizzie and Sabaki

The natural comparison is with other KataGo front ends, and the difference is mostly about what ships in the box. KaTrain bundles an engine and a model and manages both from inside the app, with F8 opening 'General & Engine Settings' and dropdowns for downloading models and KataGo versions. A front end that expects you to supply the engine yourself puts that configuration on you: you obtain a KataGo binary, obtain a network, and point the program at both. Neither approach is strictly better. Bundling lowers the entry cost and makes the default path short; external configuration gives you full control over which binary and which network you use, which matters if you already have a tuned setup.

The second difference is the training loop. KaTrain's README describes playing against weakened AIs with various styles, immediate feedback on mistakes with a retry option, and automatic generation of focused SGF reviews showing your biggest mistakes. That is a teaching-oriented feature set. A general SGF editor is organized around editing and navigating game records, and analysis is one thing it can do rather than the thing it is built around. If your work is annotating and exchanging SGF files, a general editor fits better. If your goal is to find out where you lost points and practice the position again, KaTrain's loop is the more direct path.

A third point of difference is the interface stack. KaTrain uses Kivy, so the UI is the same on every platform and does not adopt native widgets. Users who care about a native-feeling macOS or Windows application should weigh that. The README also links a Discord server and translated versions of the manual in German, French, Ukrainian, Russian, Turkish, Simplified Chinese, Traditional Chinese, Korean and Japanese, which says something about the user base even though the README does not quantify it.

Maintenance, licence and upgrade cost

The repository is not archived, and the last push was on 2026-09-03. Releases are frequent enough to be worth tracking: v1.20.0 on 2026-08-24 bundled KataGo v1.18.1 with what the release title calls minor improvements, v1.19.0 on 2026-08-05, and v1.18.1 on 2026-06-08. The cadence suggests a project that ships fixes and engine updates rather than sitting still, and the version number in pyproject.toml matches the latest release.

The upgrade cost depends on your install route. A pipx install upgrades with pipx, and the bundled engine and model are managed inside the app, so an engine update arrives with the app rather than as a separate manual step. The macOS brew cask is the one route the README flags as potentially stale, so a Homebrew user may need to check the releases page to know what they are actually running. Windows and macOS executable users re-download from the releases page.

On licensing, the picture is mixed and worth checking yourself. The README badge and pyproject.toml both say MIT for KaTrain. The repository metadata reports the licence as NOASSERTION, which means the automated classifier did not reach a conclusion, and the LICENSE file at the repository root is the authoritative text. KataGo is a separate project with its own licence, and the bundled model has its own terms; the README does not state them. If you plan to redistribute KaTrain or its bundled engine and model, read the LICENSE file and the KataGo project's terms rather than relying on the badge. This is not legal advice.

Editorial conclusion

Adopt KaTrain if you want a local, GPU-accelerated Go review and teaching tool and you are willing to read INSTALL.md when the bundled engine does not match your hardware, particularly on AMD, Intel or multi-GPU systems. Skip it if you need a browser-based client or a phone app: the README only lists Windows, macOS and Linux install paths, and Android is not among them. Before you commit, verify that your Python is between 3.11 and 3.13, and check whether the brew cask version matches the release you expect, since the README warns it can lag several versions behind.

Frequently asked questions

Official sources

1. Issues
2. README
3. Releases
4. sanderland/katrain on GitHub