What Is a Poker Solver and How Does It Work

A poker solver is a program that plays one specific poker situation against itself millions of times, adjusting after every repetition, until neither side can improve by changing anything. What comes back is an equilibrium strategy: every legal action, with a frequency and an expected value attached. It will not tell you what to do with A♠K♠ on a queen-high flop. It tells you how often to do each thing you could do, and what each one is worth in chips.

What a solver actually is

A solver is not a database of what winning players do, and it is not an oracle. It is an optimiser pointed at a game tree.

You hand it a fully defined situation: two ranges, a stack depth, a pot size, a list of bet sizes each player is allowed to use, and the rake. It then searches for the pair of strategies where neither player can raise their expected value by unilaterally changing anything. That pair is a Nash equilibrium, and in poker it is what people mean by GTO.

The important consequence is defensive, not offensive.

A solver does not find the play that wins the most. It finds the strategy that loses the least against a perfect opponent.

Play the equilibrium strategy and nobody can beat you for more than the rake, no matter how well they read you. That guarantee holds whether your opponent is a world champion or a bot. What it does not do is punish bad players any harder than necessary.

The algorithm: regret, repeated

Nearly every modern solver runs some version of counterfactual regret minimisation, usually shortened to CFR. The mechanism is simpler than the name.

The solver starts by playing every decision point randomly. Then it walks the tree and asks, at each node, a single question: how much better off would I have been taking a different action here? That difference is the regret. Actions with positive regret get played more often on the next pass; actions with negative regret get played less.

Repeat that a few million times and something useful happens. The strategy on any single iteration bounces around, but the average strategy across all iterations converges on equilibrium. That averaging step is the part people miss — the answer is the long-run average of the machine's behaviour, not its final guess.

Progress is measured by exploitability: how much a perfect counter-strategy could win against the current solution. It starts high and falls towards zero. A solve is called converged when exploitability drops below a threshold small enough that the residual error is smaller than the mistakes you make at the table.

What you have to feed it

A solver answers exactly the question you ask, which means most bad solver output is a bad question.

Input	What happens if you get it wrong
Both ranges	The single biggest source of nonsense output — the solution is only valid against the range you typed
Effective stack	Changes every bet size and the entire shove threshold
Allowed bet sizes	Restrict it to one size and you never see the overbet the spot actually wants
Rake	Ignore it and the solver calls too wide and opens far too many hands
Starting pot	Sets the price on every later street

Reading the output

The output is a grid: every hand in the range, each one split by colour into the actions the solver takes with it, plus an expected value in chips or big blinds for each action.

Three numbers matter. The frequency tells you how often that action is taken with that hand. The EV tells you what the action is worth. And the difference in EV between the best action and your action tells you the size of the mistake — which is the only number that should change your play. A hand where raising and calling are worth almost the same is a hand you can play either way without cost.

Getting fluent at this is a skill of its own, and it is worth learning properly before you draw conclusions; the details of colour coding, EV columns and range-wide statistics are covered in how to read a solver output.

Why the answer is a mixture

New users find the percentages frustrating. You wanted an answer and got a probability distribution.

The mixing exists because any fixed rule is exploitable. If you always three-bet AKo and always flat QQ, an observant opponent knows your exact holding the moment you act, and can play perfectly against you for free. The equilibrium prevents that by putting some hands into more than one bucket, so no action reveals a narrow set of hands.

Here is the reassuring part. Whenever the solver mixes an action, the actions it mixes have nearly identical expected value — that is precisely why it is indifferent between them. So choosing one and playing it consistently costs you almost nothing at the table. The reasoning behind that indifference, and when a mix is worth respecting, is unpacked in why solvers mix their strategies.

What a solver cannot tell you

Every solver output carries an assumption you should say out loud: my opponent is also playing this strategy perfectly. Nobody in your game is.

That assumption creates four blind spots.

• It never exploits. Against a player who folds to 80% of river bets, the equilibrium keeps bluffing at its balanced frequency and leaves money on the table.
• It abstracts. Real solvers group similar boards and limit bet sizes to keep the tree computable. The solution is exact for the simplified game, approximate for poker.
• It struggles multiway. Two-player equilibria are well defined; three-player ones are far messier, both to compute and to interpret.
• It ignores everything human. Tilt, timing, table image, and the fact that your opponent has been shoving every button for twenty minutes.

None of that makes solvers useless — it makes them a baseline. You learn the equilibrium so you can measure how far a real opponent sits from it, then deviate deliberately. That trade-off is the whole subject of GTO versus exploitative play.

Preflop and postflop solvers are different beasts

A postflop solver starts from a fixed flop with ranges already set. That tree is small enough to converge on a laptop in minutes, which is why desktop tools like PioSOLVER work the way they do.

A preflop solver has to account for every board that could come, so the tree is astronomically larger. Solving one preflop configuration takes serious hardware and hours or days of computing, which is why nobody solves preflop live at the table. Instead the solutions are computed once and served as a library — that is what solver-generated preflop opening ranges are, the compressed output of solves you never have to run.

Newer engines, Sharkling's included, use neural networks to generalise across similar spots rather than solving each one from scratch, which is what makes on-demand postflop solutions and multiway trees practical.

Using one without wasting your time

1. Solve spots you actually played. Take a hand from last night's session, build it, and compare.
2. Guess first, then look. Write down your action and your reasoning before you reveal the solution. Passive reading teaches almost nothing.
3. Chase EV gaps, not frequencies. A 0.1bb difference is noise. A 3bb difference is a leak worth fixing.
4. Vary one input at a time. Re-solve at 40bb instead of 100bb and watch what moves. The pattern is more valuable than the answer.
5. Convert findings into rules. "Check my whole range on low paired boards out of position" is usable at the table; a memorised grid is not.

The goal is never to replay the solver from memory. It is to build accurate intuitions about pressure, price and range advantage — and then to know exactly which of those intuitions to abandon when the player opposite you is clearly not playing the same game.