megaCan you trust the numbers?
megamaster ships its own solver. The only honest way to earn trust in a new engine is to put it next to the one you already trust — so we feed byte-identical solver scripts (same boards, same real ranges, same betting trees, same accuracy targets) to our engine and to PioSolver 2, and publish what each one answers. Every chart and number on this page comes from that run, regenerated with the data checked in. Nothing is illustrative.
Expected values: the answers agree
10 spots spanning river, turn, and full flop trees — including the complete 399-line production BB-vs-BTN template — solved by both engines. Each point is one player's EV in one spot: PioSolver's answer on the x-axis, ours on the y-axis. Perfect agreement is the diagonal.
Root EV: megamaster vs PioSolver 2
Per-spot detail
| Spot | Board | ΔEV OOP | ΔEV IP | worst Δ (% pot) | combined solve noise (% pot) |
|---|---|---|---|---|---|
| river K-high rainbow | 2c7sKh8dQs | +0.010 | -0.010 | 0.018% | 0.14% |
| river paired | 2c7sKh8d2h | -0.009 | +0.009 | 0.016% | 0.15% |
| river flush-complete | 2c7cKh8cQs | -0.001 | +0.001 | 0.002% | 0.15% |
| river broadway | TsJhQdKs2d | -0.015 | +0.015 | 0.028% | 0.12% |
| turn brick | 2c7sKh8d | -0.005 | +0.005 | 0.009% | 0.22% |
| turn flushdraw | 2c7sKh8s | -0.005 | +0.005 | 0.010% | 0.26% |
| turn pairing | 2c7sKh7d | -0.016 | +0.016 | 0.028% | 0.19% |
| flop K72 rainbow (full template) | 2c7sKh | +0.007 | -0.007 | 0.013% | 0.94% |
| flop K72 two-tone (full template) | 2c7sKs | -0.018 | +0.018 | 0.032% | 0.84% |
| flop AAA trips (full template) | AcAsAh | +0.019 | -0.019 | 0.035% | 0.95% |
Δ = megamaster − PioSolver, in chips on a 55-chip pot. The last column is the sum of both engines' achieved exploitability — the amount by which two perfect copies of the same engine could legitimately differ at these solve targets. Disagreement at or under that line is indistinguishable from solve noise.
Strategies: the same plays, combo by combo
EV agreement could hide strategy differences, so we also compare what the engines actually do: the per-combo action frequencies at the c-bet decision node of each spot — 18,510 (combo × action) comparisons, weighted by how often each combo reaches the node.
Per-combo action frequency
Distribution of |Δfrequency|
Mixed-strategy combos are the honest caveat: at equilibrium many combos are indifferent between actions, so two perfect solvers can legitimately split them differently — frequency differences on indifferent combos cost zero EV by definition. That is why the EV agreement above is the primary evidence and the strategy agreement is the corroboration, not the other way round.
Speed: the honest picture
Accuracy without speed context would be spin, so here are the wall-clock times from the same battery — identical trees, identical accuracy targets, one machine. On these wide-range single-raised-pot flops, PioSolver 2 is currently ~2× faster than us. On narrow-range 3-bet pots the picture reverses: our measured head-to-head on a real CO-vs-BB 3-bet template had megasolver at 106s against Pio 2's 158s to the same target (1.5× faster), isomorphism on for both. Speed is spot-dependent, and we would rather show you the dependency than an average that hides it.
Full-template flop solves to 0.5%-pot accuracy (seconds, lower is better)
+RBP = our opt-in regret-based pruning, measured on the same trees. All solves on a single Intel i9-9900T (8 cores, 35W) — a deliberately modest desktop; absolute times scale with hardware, the ratios roughly carry.
What actually moves solve time
| Factor | What we measured |
|---|---|
| Board texture & suit isomorphism | At a fixed accuracy target the iteration count barely moves (311 iterations on trips, two-tone, and rainbow alike) — the cost per iteration is what changes. Our engine: trips 751s → two-tone 1,902s → rainbow 2,735s on the same template. Rainbow boards admit the least suit-collapse, so they are the slowest class for any isomorphism-aware engine, ours and Pio's both. |
| Range widths | Wide-range spots (this SRP template: ~400 live combos per side) currently favour Pio 2 by ~2×. Narrow-range 3-bet pots favour us by ~1.5×. Bigger live hand lists shift the work toward memory traffic, and the engines handle that differently today. |
| Tree size | These are full production trees — 399 betting lines over three streets. Turn and river subtrees solve in seconds on both engines; whole-flop trees are where minutes live. |
| Pruning (RBP) | Opt-in for us because it is not a free lunch: measured +25% on the biggest blind-vs-blind trees, but on these exact SRP solves it cost 5–17% (the green bars above) — which is precisely why it is a switch and not a default, and why this page shows the measurement instead of the best case. |
Bottom line, honestly: Pio 2 is faster today on the most common spot class, we are faster on 3-bet pots, and our engine is the one still gaining speed release over release. The answers on this page are the part that is not a moving target.
Rake: verified against Pio to a tenth of a chip
Rake changes every answer, so we verified our implementation against PioSolver directly: an asymmetric river spot solved rakeless and under three rake settings, comparing each player's rake cost (rakeless EV minus raked EV) — a form that cancels both engines' reporting conventions. Measured 2026-08-22:
| Setting | Player | megamaster rake cost | PioSolver rake cost | difference |
|---|---|---|---|---|
| rakeless baseline | both | EVs identical to 3 decimals (99.865 / 0.135) | 0.000 | |
| 3.5%-style, cap 3 | OOP | 2.997 | 2.996 | +0.001 |
| IP | 0.003 | 0.004 | −0.001 | |
| 5%, cap 1000 | OOP | 4.996 | 4.994 | +0.002 |
| IP | 0.010 | 0.009 | +0.001 | |
| 5%, cap 0 | OOP | 0.000 | 0.000 | 0.000 |
| IP | 0.000 | 0.000 | 0.000 | |
Chips on a 100-chip pot; every cell within ±0.002 chips — two thousandths of one percent of the pot. We even reproduced Pio's less obvious conventions: set_rake is only accepted after build_tree, and a cap of 0 means zero rake, not "uncapped".
How we keep ourselves honest
Byte-identical inputs
Both engines speak PioSolver's own UPI scripting protocol, so every comparison sends the exact same script to both: same ranges, same lines, same rake, same accuracy target. There is no translation layer to hide a mistake in.
Independent cross-checks
Where we compute the same quantity two unrelated ways — e.g. pricing a sizing simplification by an engine-level restriction and by rebuilding the tree without those lines — the answers must agree. Our record: 0.0562 vs 0.0563 bb on the same rule, two fully independent methods.
Noise is disclosed, always
Every solve carries its achieved exploitability, and any comparison smaller than the combined noise is labelled that way rather than presented as precision. If a number on this page could be solve noise, the page says so next to the number.
Battery run 2026-08-24 on a single desktop machine; megasolver and PioSolver 2 (edge build), both multi-threaded, suit isomorphism enabled on flop spots for both engines. Regenerate with solver/scripts/parity_battery.py and solver/scripts/parity_page.py.