Open-Source Pluribus: Code and Weights

There is no official open-source Pluribus. The original Pluribus code and strategy were never released. What exists is community reproductions. This page covers what is publicly available, and describes SHARINGAN-2, an open Pluribus implementation in Rust with downloadable weights, its results with confidence intervals, and how to run it or play against it.

What exists publicly

Searching GitHub for Pluribus returns many repositories. Most are small poker engines, CFR tutorials, or partial attempts. As far as we know, none of them ships trained weights for the full six-player game together with published head-to-head results.

Open heads-up poker work does exist. Slumbot is a well-known public heads-up bot, and DecisionHoldem published a heads-up no-limit agent in 2022. Those are strong references, but heads-up play is a different problem from six seats. See the history of poker AI for how the two settings differ.

A useful test for any repository is whether it answers four questions. Does it include a full six-player game engine? Does it train a blueprint at scale? Does it include real-time search? Does it publish measured results against other bots with confidence intervals? A repository that covers the first item only is a starting point, not a reproduction. This is also why a README that says "Pluribus" does not tell you much on its own.

So the usual search, "download Pluribus," has no real answer. The practical options are to write your own from the paper or use a reproduction that has been tested. Poker Sharingan is our attempt at the second.

What SHARINGAN-2 is

Poker Sharingan is an open, from-scratch reproduction of Pluribus, written in Rust and licensed Apache-2.0. It has two parts: the training and search code, and an arena that scores six-player bots with duplicate deals and AIVAT luck correction.

SHARINGAN-2 is the trained model. It is a blueprint from training run "C," finished on 2026-11-02 after the full budget of 1.83e11 MCCFR iterations. In play it adds real-time search on the turn and river. Weights are on Hugging Face and the code is on GitHub. The model page is here.

What is implemented

• Engine. A six-player no-limit hold'em engine.
• Card abstraction. Preflop is lossless, with 169 hand classes. Flop, turn and river use 200 buckets each. Flop and turn buckets come from k-means over equity histograms with earth mover's distance. The river uses an OCHS-style clustering. Recall is imperfect, and suit isomorphism follows Waugh.
• Training. External-sampling MCCFR with Linear CFR discounting early on, negative-regret pruning on 95% of iterations (never on the river), and a lock-free hash store for regrets.
• Action translation. A "shadow game" state tracks off-tree bets. In our tests it cut exploitability by about 37 times compared with naive nearest-size translation.
• Search. Nested unsafe depth-limited Monte Carlo Linear CFR, four continuation strategies at the leaves, and Bayesian beliefs over the 1,326 possible hole-card pairs. It runs on the turn and river only, with 200,000 iterations and a time budget that falls back to the blueprint.

Training ran on rented bare-metal CPU servers. No GPUs were used. The background on the algorithms is on the CFR page.

How it differs from the paper

It is a reproduction, so it does not match the paper exactly. Two differences stand out.

• Bet menus. The exact Pluribus bet-size menus are unpublished. We built three menus, trained each, and kept the "medium" one because it measured best.
• Search coverage. Our search runs on the turn and river only. The paper's description is broader.

The abstraction is also coarser than it may sound. Two hands that fall in the same bucket share a strategy, so the model cannot tell them apart. Better buckets would help, and the bucket count is a clear place for future work. In the same spirit, the shadow-game translation is our own design. We measured it against the naive method, and it is much better, but we have not compared it with the translation Pluribus used because that was not published.

Other details, such as bucket definitions and training schedules, are also our own choices where the paper was silent. Treat SHARINGAN-2 as a strong open system in the Pluribus family, not as a copy.

Results, with the caveats

We measure head-to-head with duplicate deals and AIVAT, and report 95% confidence intervals. The unit is mbb/game, thousandths of a big blind per hand. See how to measure a poker bot for why.

The earlier checkpoints are the same model trained less. The 2e10 checkpoint, with search, won +77.6 bb/100 over 2,329 live hands on a public bot arena, and the 4.77e10 checkpoint beat SvanBot, the top bot there, in both seatings. Live hand counts are small, so treat those as encouraging, not precise.

Why are the margins small? Both sides of each match are strong, and every gap here is between versions of the same model. A difference of a few mbb/game is only a few thousandths of a big blind per hand, which is why millions of deals and luck correction are needed to see it. Small margins between checkpoints are expected. They do not say how the model would do against humans.

A short best response (12M iterations) found no profitable exploit. That is a sanity check, not a measure of exploitability. SHARINGAN-2 has not played professional humans, and we do not claim it is unexploitable or superhuman.

How to download, run and play it

To get the weights, use the Hugging Face repository. If you use the Hub CLI, huggingface-cli download markokraemer/sharingan-2 fetches the files. Clone the GitHub repo for the Rust code. Exact build and run commands are in the docs.

To play against it with no setup, open the browser table. To pit your own bot against it, write one Python function, act(state), and submit it with sharingan submit mybot.py. Hosted runs play 20,004 hands and return a verified, reproducible score. The local harness can run millions of hands. The leaderboard reference opponent is the 2e10 checkpoint without search. For a how-to on building a bot, read poker bot.

This is for research and bot arenas. Real-money poker sites ban bots.

FAQ

Is there an open-source Pluribus on GitHub?

There is no official one, because the original code was never released. Poker Sharingan is an open reproduction in Rust under Apache-2.0, with a trained six-player model, SHARINGAN-2.

Can I download Pluribus?

No. The original Pluribus strategy was never published. You can download the SHARINGAN-2 weights from Hugging Face at huggingface.co/markokraemer/sharingan-2.

Is there a Pluribus implementation in Python or Rust?

SHARINGAN-2 is implemented in Rust for training and search. Bots that play against it are written as a Python function, act(state), through the SDK.

How close is SHARINGAN-2 to the real Pluribus?

It follows the paper's method: MCCFR blueprint, abstraction, and depth-limited search with four continuation strategies. The bet menus are our own, and search runs only on the turn and river.

Has SHARINGAN-2 beaten human professionals?

It has not played professional humans. Its results are against other bots and earlier checkpoints, measured with duplicate deals and AIVAT.