# Sabaki: a desktop Go board and SGF editor for reviewing games and driving GTP engines

> Sabaki is an Electron application for reading and editing SGF game records, annotating boards, and connecting to GTP engines. It is aimed at Go players who want a local editor rather than a web board, and the last push to the repository was on 2026-09-13.

**SabakiHQ/Sabaki** — An elegant Go board and SGF editor for a more civilized age.

- Repository: https://github.com/SabakiHQ/Sabaki
- Website: https://sabaki.yichuanshen.de/
- Stars: 2,779 · Forks: 415
- Language: JavaScript
- License: MIT
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/sabakihq-sabaki

## The problem Sabaki solves: SGF files that need editing, not just viewing

Most Go software splits into two camps. Online servers handle play and leave you with whatever export they offer. Analysis tools concentrate on engine output and treat the game record as an afterthought. Sabaki sits in the middle: it is a desktop board whose primary object is the SGF file. The README lists reading and saving SGF games and collections, opening wBaduk NGF and Tygem GIB files, and a set of SGF editing tools that includes lines and arrows board markup. Copy and paste of variations is listed as a feature, as are undo and redo.

That combination points at a specific user: someone who collects game records, annotates them, and wants to move variations around without a browser tab. The formatted comment rendering uses a subset of Markdown, which the README links to its own guide. If you write long comments in SGF files, that matters more than the board rendering does. The project is an Electron application written in JavaScript, and its topics list baduk, weiqi and igo alongside sgf, which is a fair summary of who it is for.

## How Sabaki is put together and where the engine connection lives

The repository layout shows an Electron app: src/ holds the application code, main.js is declared as the entry point in package.json, and webpack.config.js plus a build/ directory handle packaging. style/ and index.html point to a renderer process, and e2e/ with playwright.config.js indicates end to end tests. The package.json build block configures electron-builder targets per platform, and it also sets Electron fuses: runAsNode is false, enableNodeOptionsEnvironmentVariable is false, enableNodeCliInspectArguments is false, onlyLoadAppFromAsar is true, and enableEmbeddedAsarIntegrityValidation is true. Those are hardening choices, and they mean you cannot casually attach a Node debugger or pass NODE_OPTIONS into a packaged build.

Engine support is the interesting seam. The README lists GTP engines support with board analysis for supported engines, and links separate guides for engines and for engine analysis integration. Sabaki does not bundle an engine. It talks to whatever GTP program you point it at, and board analysis only works with engines the guide describes as supported. The README also lists a score estimator and scoring tool, guess mode, and autoplay. The project publishes a family of supporting libraries, including gtp, sgf, go-board, immutable-gametree, boardmatcher, deadstones, influence and Shudan, the Preact goban component. That tells you the SGF parsing and board logic are not ad hoc code inside the app.

## Installing Sabaki and opening your first SGF file

The README does not give install commands. It points to the latest release on GitHub, and the package.json build configuration names the artifacts: an AppImage and a Flatpak for Linux, a DMG for macOS with notarization enabled, and an NSIS installer for Windows. So the practical install path is downloading the artifact for your platform from the releases page rather than running a package manager command, which the material never shows. The current version in package.json is 0.60.2, matching the v0.60.2 release.

If you build from source instead, the README sends you to the Building & Tests guide in docs/guides/building-tests.md. The repository carries an .nvmrc, so the Node version is pinned for you. The commands below are the standard npm entry points implied by package.json, not quoted from the README, so check that guide before running them.

```bash
npm ci
npm start
```

The first command installs from package-lock.json, which is committed to the repository. The second runs the Electron app from source. To run the end to end suite, playwright.config.js is at the repository root.

```bash
npx playwright test
```

Once the app is open, the workflow the README describes is: open an SGF file or a collection, navigate with the game tree, and use the SGF editing tools to add markup. Board markup with lines and arrows is a listed feature, so the editing controls are on the board rather than in a text field. To attach an engine, follow docs/guides/engines.md, since the README does not state the exact path or command format Sabaki expects for an engine binary.

## Where Sabaki stops being the right tool

Sabaki is a local editor. There is no server component in the repository layout and no account system in the README. If your workflow depends on several people annotating the same game at once, or on a shared library that syncs across machines, Sabaki gives you none of that. You would be passing SGF files around yourself.

The engine integration is narrower than the feature list suggests. The README says GTP engines support with board analysis for supported engines, and links a dedicated guide for engine analysis integration. That phrasing is a boundary: analysis overlays are not universal across GTP engines. An engine that plays fine may still not produce the analysis Sabaki can draw, and the README does not enumerate which engines qualify. Verify against the guide before you build a review routine around a particular engine.

Scoring is another soft spot. The README lists a score estimator and scoring tool and separately lists deadstones, described in the Related section as simple Monte Carlo functions to determine dead stones. Monte Carlo dead stone detection is a heuristic. For casual review that is fine; for anything where the final score matters, treat the estimate as a starting point and check the position yourself. The README does not claim the estimator is exact.

## Sabaki against a browser board such as OGS or KGS

The obvious alternative for many players is a browser based Go server. The difference is not cosmetic. A server owns your games: you log in, you play, the record lives on their infrastructure, and the editor is whatever they built. Sabaki owns files. You open an SGF, you edit it, you save it, and the file is on your disk. That also means Sabaki gives you no opponents, no rating, and no matchmaking, because none of those are in the README.

The second alternative is a dedicated analysis front end built around one engine. Those tend to go deeper on engine output for a single program. Sabaki's approach is the opposite: a general GTP client that also happens to be a full SGF editor with markup, variations, undo and redo, autoplay, and guess mode. If you only ever run one engine and never touch an SGF by hand, a single engine front end may fit better. If your work is the game record and the engine is one tool among several, the editor-first design is the reason to pick Sabaki.

A third comparison is worth naming because it is in the same repository family: Shudan, described as a highly customizable, low-level Preact goban component. Shudan is a building block for people writing their own Go interface. Sabaki is the finished application built on top of that kind of component. Choosing between them is choosing between writing an app and using one.

## Maintenance, releases and what the MIT licence lets you do

The repository is not archived, and the last push was on 2026-09-13. Releases show v0.60.2 on 2026-07-09 and v0.60.0 on 2026-07-03, after a long gap from v0.52.2 in 2022. That gap is worth knowing about if you are planning to depend on the project: the 0.60 line is recent, but the history is not one of steady small releases. The CHANGELOG.md at the repository root is where the project records what changed, so read it rather than assuming continuity.

The licence is MIT, declared in package.json and in LICENSE.md. In practical terms that permits use, modification and redistribution with the licence text retained, but it comes with no warranty, and I am not giving legal advice. If you fork Sabaki and ship it, the MIT notice needs to travel with it. The Electron fuses in the build configuration are also relevant to forks: onlyLoadAppFromAsar and enableEmbeddedAsarIntegrityValidation are enabled, so a repackaged build has to respect that structure rather than dropping loose files next to the asar.

Upgrade cost is mostly the Electron and Node toolchain. The .nvmrc pins Node, package-lock.json pins dependencies, and the build block pins an appimage toolset version of 1.0.2 and Flatpak runtime 23.08. Those pins are what keep builds reproducible, and they are also what you will be bumping when they age out.

## Conclusion

Adopt Sabaki if you review your own games offline, need SGF editing with board markup, or want to attach a GTP engine for analysis. Skip it if you want a server, a training platform, or anything with a hosted login, because none of that is in the README. Before relying on it for a study group, verify two things yourself: that your engine speaks GTP in the form the engine guides describe, and that the release artifacts for your platform are the ones you expect, since Linux builds are AppImage and Flatpak, macOS builds are DMG, and Windows ships an NSIS installer named sabaki-v0.60.2-win.exe.

## FAQ

### How do I use Sabaki?

The README points to the latest release on GitHub rather than giving an install command. The build configuration names an AppImage and a Flatpak for Linux, a DMG for macOS, and an NSIS installer for Windows, so you download the artifact for your platform.

### What is Sabaki in Go?

Sabaki is a Go board and SGF editor: a desktop application for reading and saving SGF games and collections, editing board markup, and connecting to GTP engines. The repository topics include baduk, weiqi and igo, which are the other names for the same game.

### What is Sabaki?

Sabaki is an Electron application, written primarily in JavaScript, that serves as a Go board and SGF editor. Its README lists SGF editing tools, board markup with lines and arrows, copy and paste of variations, undo and redo, a score estimator, and GTP engine support.

## Sources

- [License: MIT](https://github.com/SabakiHQ/Sabaki/blob/master/LICENSE)
- [Project website](https://sabaki.yichuanshen.de/)
- [README](https://github.com/SabakiHQ/Sabaki/blob/master/README.md)
- [Releases](https://github.com/SabakiHQ/Sabaki/releases)
- [SabakiHQ/Sabaki on GitHub](https://github.com/SabakiHQ/Sabaki)

---

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