Chinese Checkers AI

JumpStar is the world's strongest AI engine for Chinese Checkers

Now on iPhone JumpStar Chinese Checkers Play the strongest AI offline, solve daily puzzles, get hints, and save replays. Download

Origin

I built JumpStar for my mom. The project began on May 15, 2026 in Indiana when I was helping my parents move out of our childhood home. While packing their things, we found our old Chinese Checkers board and started reminiscing about how fun it was to play as a family.

After my brother and I left for college, my mom had tried to find Chinese Checkers iPhone apps so she could continue to play by herself, but none of them were any good. Given the successes of AlphaGo and Stockfish, I thought that, surely, there would be many strong open source AI engines for Chinese Checkers - but there aren't. Despite its popularity and elegance, Chinese Checkers had received surprisingly little attention from the AI community. That gap is what led me to build JumpStar.

My goal was to build the first superhuman AI engine for Chinese Checkers. A strong computer player would make it possible for my mom to keep playing even when my brother and I were not nearby. A superhuman AI engine may even uncover beautiful new patterns and strategies of the game that weren't yet widely known.

That is also why the project became public-facing. A strong private engine is interesting, but it is difficult for anyone else to evaluate or improve. A public benchmark turns the work into something inspectable: a ruleset, a protocol, a position suite, baselines, logs, and a named JumpStar model that other systems can challenge.

The beauty of Chinese Checkers

Chinese Checkers is a race across a six-point, star-shaped board. Each player begins with a group of ten pieces in one triangle and tries to move all of their pieces into the opposite triangle first. The game can be played by two, three, four, or six players. There are only two movements, stepping and jumping, and no opportunities to capture pieces, which is one reason the board feels so alive: simple movement rules produce complex kinds of traffic as players try to build jumping chains and block opponents from doing the same.

Despite the name, Chinese Checkers did not originate in China, and it is not really checkers. The game is usually traced to Stern-Halma, or Star Halma, a German star-board adaptation of Halma published in 1892. The familiar English name came later through American marketing, and it has since become a globally popular board game.

How to play Chinese Checkers

On your turn, you move one of your pieces. A piece can step to a neighboring empty hole, or it can jump over an adjacent occupied hole into the empty hole beyond it. Jumps can chain together, so a single move may cross a large part of the board if the spacing is right. Jumped pieces stay on the board. They are not captured.

The goal is to move all of your pieces into the triangle directly across from your starting triangle. Good play is not only about rushing forward. You need to build useful ladders, avoid blocking your own pieces, use the crowded center well, and decide when a move that looks slow now will create a faster route later.

Why Chinese Checkers AI is interesting

Classic board games have been central to AI for decades. IBM's Deep Blue defeated world chess champion Garry Kasparov in 1997. AlphaGo defeated Lee Sedol in 2016. Those games became landmarks because strong computer play changed how people understood them.

Chinese Checkers has not had the same public AI ecosystem. Compared with chess and Go, there are far fewer engines, benchmarks, rating lists, public game records, or shared research tools. That gap is surprising because the game has exactly the kind of structure AI systems like to study: perfect information, no randomness, a clear win condition, and an enormous number of possible futures.

Even the quiet opening position branches quickly. In JumpStar's two-player rule set, the starting board has 14 legal first moves. After each side has moved once, there are 196 possible two-ply sequences. By depth three, there are 4,760 possible move sequences from the initial position. Later in the game, chained jumps and crowded lanes make the choices feel much less obvious than the rules suggest.

What JumpStar is

JumpStar is a self-play-trained Chinese Checkers engine built on a compact C++20 rules/search core, a neural policy/value model, and Monte Carlo tree search. Its strongest public checkpoint, JumpStar_60, is the current CCERL-2P10-v2 benchmark champion. The surprising result is efficiency. All JumpStar models were trained on a MacBook M4 rather than from the large TPU/GPU clusters associated with landmark Go and chess systems.

The ambition is superhuman play, but the public claim is deliberately testable: JumpStar appears to be superhuman or near-superhuman under the two-player rule profile, and CCERL exists so future engines can challenge that result.

The system

JumpStar is not just a model checkpoint. It is a full engine and benchmark stack: board representation, rules, search, self-play, training records, referee tools, and public evidence.

• Rules and search. JumpStar uses a compact bitmap-style representation of the 121-hole star board, strict two-player rules, legal step and multi-hop move generation, goal-locking, terminal checks, deterministic hashing, baseline bots, and a native match runner. The rules implementation is deliberately explicit because Chinese Checkers engines can otherwise exploit edge cases: camping in home or goal triangles, creating artificial blockades, or winning by quirks of the referee instead of by better play. JumpStar's rule profile is meant to reward clean racing, strong geometry, and reproducible search rather than anti-blocking tricks.
• Self-play training. Self-play and reanalysis generate board states, legal actions, MCTS visit counts, game results, and progress features. Those records train a policy/value model that guides the next round of search. JumpStar_60 is a geometry_v1, 512x4 MLP with approximately 10.36M parameters, trained from a 1.8M-example reanalyzed dataset. The practical work was making that loop small and fast enough to run repeatedly on local hardware.
• Public benchmarking. Because Chinese Checkers did not already have a mature public engine ladder, I developed CCERL-2P10-v2 alongside JumpStar. CCERL defines the ruleset, engine protocol, frozen position suite, baseline engines, release artifacts, and rating methodology. The benchmark uses paired side-swapped positions and publishes logs so results are reproducible rather than merely asserted. That means future engines can challenge JumpStar under the same referee instead of comparing vague claims of strength.

How JumpStar Plays Chinese Checkers

One of the most interesting qualitative observations is that JumpStar often does not play like a simple racing heuristic. Instead, it develops sophisticated strategies like slowing the opponent down, preserving useful blockers, and building compact triangle-like formations that restrict traffic through important corridors.

That style is easy to miss if Chinese Checkers is viewed only as a forward-progress race. Because pieces are never captured, a defensive shape can matter for many turns: it can deny a hop ladder, force the opponent to route around congestion, or buy enough time for the model's own pieces to convert. Some of JumpStar's strongest ideas may therefore be about controlling geometry, not merely advancing faster.

The search and training loop

At a high level, JumpStar follows the AlphaZero pattern: self-play produces MCTS visit targets, those targets train a policy/value model, and the stronger model guides the next round of search.

self-play -> MCTS visit targets -> policy/value training -> stronger search -> self-play

The practical strength came from making that loop cheap enough to run repeatedly: native C++ self-play workers, efficient move generation, batched leaf evaluation, transpositions, subtree reuse, compact records, and release builds tuned for local Apple hardware.

A major part of that compression came from using Codex with GPT-5.5 as an implementation and research partner. Codex helped inspect the codebase, profile bottlenecks, rewrite hot paths, analyze training logs, package benchmark runs, and keep multiple experiment threads moving at once. The most important gains were practical: large speed-ups in self-play and evaluation, memory reductions of roughly 98% in the training path so the work could fit on my local machine, and enough automation to keep improving the engine while I was also doing my full-time job running Edia as CEO.

The project moved unusually fast because the loop was not only self-play for the model; it was also an iterative engineering loop for the system around it. Codex made it possible to run an experiment, inspect the failure mode, optimize the code, rerun the benchmark, summarize the result, and turn the next question into a concrete patch. That feedback cycle compressed work that might otherwise have taken months of infrastructure, tooling, frontend, benchmark, and writeup time into about one week from first board discovery to public launch.

Local Codex accounting gives a rough sense of the scale of that collaboration. Across the project threads visible in the local Codex state database, recorded tokens_used totaled approximately 559.9M tokens. Those numbers include context, tool output, cached-context effects, reasoning/output accounting, and overlapping work threads, so they should be read as a process metric rather than a scientific measurement of compute.

CCERL and the public benchmark

Chinese Checkers does not have a mature public engine ladder like chess and Go, making it difficult to evaluate engine strength and progress. CCERL fills that void. CCERL is the first public benchmark for evaluating Chinese Checkers AI engine strength. Based on similar concepts from chess and Go, CCERL provides fixed rules, audited starting positions, paired side swaps, downloadable game logs, and public baselines.

Based on CCERL benchmarks, JumpStar appears to be the world's strongest publicly available AI engine for Chinese Checkers by a large margin.

I believe that JumpStar has reached near-superhuman Chinese Checkers strength under the two-player rule profile, using local MacBook-scale compute. More importantly, CCERL gives all future contributors a target: modify JumpStar, build a new model, port an existing engine more faithfully, add better positions, or submit a challenger under the same referee.

Future Work

JumpStar is not meant to be just a private bot. The project is trying to become three things:

• A strong public AI model. JumpStar is open license, and this website is free. Anyone can play against JumpStar or try to improve it themselves. JumpStar was trained entirely on a MacBook M4. More compute will surely improve the performance.
• Public benchmark infrastructure. Chess and Go have communities where engines can be tested, compared, and improved. CCERL brings that same infrastructure to Chinese Checkers: clear rules, reproducible matches, public logs, and a path for other people to build their own models.
• Research into the game itself. Strong AI changes what we can see. I want to understand what good play looks like, how openings evolve, why crowded boards behave the way they do, and what happens in three, four, and six-player games when the middle of the board becomes a traffic jam of possibility.
• Multiplayer variants. The two-player model is only the beginning. The wilder questions start when the board gets more crowded: three players, four players, six players, shifting alliances, blocked paths, and strange emergent openings. I want to find out what strong play looks like there too and on boards that are far larger than standard. The complexities and patterns that emerge will be mesmerizing.

I hope JumpStar encourages more people to think about Chinese Checkers, play it, study it, and build around it.