A research platform for Go AI with a sense of style
A CLI research platform for Go AI, designed so that distinct personal styles (pungmyo, 기풍) can be learned, compared, and preserved on top of a strong shared skill layer. It is our research-side response to a long-running worry in the Go community — that, in the age of AI, every professional's moves seem to converge toward a single "correct" answer. EulerGo treats the individuality visible in the first ~50 moves as a learnable signal via a style latent and multi-algorithm comparison, aiming at a research environment where many characters coexist rather than one monolithic super-engine.
Internal Research PlatformA research platform that treats a long-running concern in the Go community — individuality, pungmyo — as something worth working on.
The opening fifty moves of a game are often described as the stretch where a player's thinking is most visible — where they play, which side they build first, when they invade. EulerGo takes the style differences in that opening phase as the starting point and treats them as a learnable signal.
Instead of making a single strong network stronger, EulerGo sits a shared skill layer beneath interchangeable style heads — so multiple distinct characters can coexist on the same foundation rather than converging into one.
This is a research platform, not a commercial engine. How do we define style, train it, measure it, classify it, and preserve it? EulerGo is meant as a place to run reproducible experiments around those questions.
One model, many characters. Same foundation, different hands.
The input tensor adds N style channels on top of 9 base channels. Each style dimension is a constant plane broadcast across the whole board. When style_vector=None, it is fully backward-compatible with the 9-channel model. The trainer auto-detects in_channels from features.shape[1] and restores them from checkpoint architecture metadata.
On the same self-play / eval / league interface, a single --algorithm flag switches between MCTS, Gumbel, QZero, PGS, native_mcts, and random. The algorithm is a knob — apples-to-apples comparison, identical metrics.
selfplay → train → checkpoint → stronger selfplay → analyze / league. Each iteration writes a RunManifest (seed/git/profile/version) automatically, and the pipeline records chain.json so every warm-start chain is auditable.
Train a style classifier to automatically label which game belongs to which character. v1 is reference-based; v2 is a learned model (--model). A --style-loss-weight flag reinforces the individuality signal directly during training.
Multiple families compared on a common interface
| Algorithm | Tier | Description |
|---|---|---|
mcts | stable | AlphaZero-class PUCT MCTS — default baseline |
random | stable | Uniform over legal moves (control) |
gumbel | beta | Gumbel root selection — simplified contrastive baseline |
gumbel_full | stable | Sequential-halving + full σ(q), faithful to Danihelka 2022 |
qzero | stable | Searchless Q-derived policy — no tree |
pgs | stable | Policy-Gradient Search — tree-free short stochastic rollouts |
native_mcts | stable | Root-parallel MCTS + C++ playouts (practical 19x19) |
distributed_selfplay | planned | Multi-machine selfplay (run via coordinator / worker) |
The data flow of the self-improvement loop
A single eulergo entry point with plugin auto-discovery
| Command | Description |
|---|---|
selfplay | Generate self-play games (--algorithm, --workers N) |
train | Neural-network training (PyTorch, --style-loss-weight) |
shuffle | Shuffle and merge training data |
export | Export / list checkpoints |
eval | Head-to-head evaluation between two configs |
analyze | Opening analysis + style comparison |
league | Round-robin tournament + ELO (--bootstrap CI) |
algorithms | List available algorithms with tiers |
classify | Automatic style labeling (reference-based or learned v2) |
coordinator | (Phase 6) Distributed selfplay coordinator |
worker | (Phase 6) Distributed selfplay worker |
tournament | (Phase 6) Information-gain dynamic pairing |
dashboard | (Phase 6) Web dashboard (i18n) |
pipeline | (Phase 6) Iterative training pipeline |
app | (Phase 6.1, optional) Toga-based GUI app — pip install eulergo[app] |
All help text and runtime output is translated via --lang ko|en|zh|ja|es.
18 step-by-step guides — from getting started to distributed training and the GUI app
| 01 | Getting Started with EulerGo — intro + --workers multi-core (5 min) |
| 02 | 9x9 Style Comparison — same algorithm, different hyperparameters |
| 03 | Multi-Algorithm Comparison (Phase 4) |
| 04 | Reading JSON Game Records (Phase 4) |
| 05 | League + ELO Estimation |
| 06 | Style-Latent Input Channels (introduced in Phase 3) |
| 07 | 19x19 Baseline Reproduction |
| 08 | QZero — Searchless Self-Play (Phase 5) |
| 09 | PGS — Tree-Free Rollouts (Phase 5) |
| 10 | Style Loss + Style Classifier (Phase 5) |
| 11 | Bootstrap ELO Confidence Intervals (Phase 5) |
| 12 | Native C++ MCTS + GPU Batching (Phase 5) |
| 13 | Multi-Machine Distributed Self-Play (Phase 6) |
| 14 | Information-Gain Tournament Scheduler (Phase 6) |
| 15 | Web Dashboard (Phase 6, i18n) |
| 16 | 19x19 Long-Running Training Pipeline (Phase 6) |
| 17 | Style Classifier v2 — Learned Classifier (Phase 6) |
| 18 | Desktop/Mobile App — Play Directly Against a Checkpoint (Phase 6.1) |
From venv and install to your first selfplay in one screen
5-language CLI, optional GUI, optional native build
All help text and runtime output switches via --lang ko|en|zh|ja|es. Default is Korean. Rooted in Korean baduk culture, designed multilingual from day one.
pip install eulergo[app] installs a Toga-based cross-platform GUI app (Mac/Win/Linux/iOS/Android) so you can play directly against a trained checkpoint. The app command is only exposed when the package is importable (strict plugin policy).
bash eulergo/native/build.sh builds root-parallel MCTS + C++ playouts for practical 19x19 speed. If the build is absent, native_mcts falls back to the Python MCTS automatically.
It is not a commercial engine. It aims to be a reproducible experimental environment for how personal style (pungmyo) can be learned, compared, and preserved.
The project was inspired by Lee Sedol's public remarks; it is not officially affiliated with him in any form.
Get Started on GitHub Contact