Kingdom Come: Deliverance Dice Strategy

An exact, computed solution to the single-turn push-your-luck decision and to the full two-player race, each verified against independent Monte Carlo simulation. Generated locally: all numbers below come from farkle_kcd.py, farkle_dp.py, farkle_sim.py, farkle_race.py, race_dp.py, race_compare.py and farkle_report_data.py in this folder.

Conclusions & decision flowchart Is it solved? Rules modeled Bust probabilities Optimal thresholds Reading your first roll The "decline the triple" finding Strategy comparison Who actually wins games The full race, solved exactly Cheat sheet Caveats

Conclusions, up front

The rest of this report is the derivation, the exact numbers, and the validation. If you just want the answer: play with the flowchart below, which captures essentially all of the decision quality with none of the exact-threshold bookkeeping.

Both layers of this problem (the single-turn "push or bank" decision, and the full two-player race to a target score) are solved exactly by dynamic programming, each independently verified against large-sample Monte Carlo simulation and against a from-scratch audit of the recursion logic itself.
Bust risk roughly tracks dice remaining: 3% with 6 dice, climbing to 67% with 1 die, but the single biggest, most common strategic error isn't misjudging that risk, it's comparing the wrong number to it: the right question is never "how many dice do I have," alone, it's "how many dice do I have and how much have I already banked this turn," together.
Two genuinely non-obvious, DP-verified findings: it's sometimes correct to decline a cheap three-of-a-kind (triple 2s or 3s) and bank only a stray single instead, purely to keep more dice live; and once either player is close to the match target, the correct play is to never bank partial progress: keep rolling for the exact win, every dice count, not just a cautious "take the safe points."
Going first is worth a real, exactly-quantified edge (about 56% win probability between two optimal players), and full race-awareness beats a strategy that only optimizes each turn in isolation by roughly 3.5 points of win rate, most of that from adjusting risk tolerance throughout the whole game, not just the final turn.

The decision, as a flowchart

This collapses the exact per-state thresholds derived later in this report into rule-of-thumb numbers. It intentionally blurs small differences between specific match targets, checked against both commonly-cited defaults for a standard KCD1 match (sources disagree: 2,000 and 4,000 points both appear as "the" default, and real games vary further by opponent and wager; see the note below the chart). The qualitative shape of the decision is the same at either target; only the precise cutoff numbers shift a little.

① Roll your dice: 6 at the start of a turn, or however many are still live if you're continuing.

② Did that roll produce any scoring dice at all (a 1, a 5, or a triple-or-better)?

BUST. Every point banked this turn is lost. Turn passes to your opponent.

yes

continue to ③ below

③ Bank the scoring dice: normally take the highest-scoring combination on offer. (Exception worth knowing: a cheap triple of 2s or 3s is sometimes better left unbanked in favor of a single stray 1 or 5, see "Decline the cheap triple" below. Blurred here on purpose; it's a small effect.)

④ Does your new total (already-banked score + this turn's points) reach the match target?

yes

STOP. You win the match.

continue to ⑤ below

⑤ Are either you or your opponent within roughly 1,000 points of the target (the "end-game zone")?

yes

END-GAME RULE: never bank partial progress here. Keep rolling with whatever dice you have left until you hit the target outright or bust trying. Dice-remaining stops mattering this close to the finish.

continue to ⑥ below (normal mid-game rule)

⑥ Compare your turn total so far to this rule of thumb for your current dice count:

Dice left	Rule of thumb
5 or 6	Keep rolling, essentially always
4	Keep rolling unless your turn total is already past ~1,000
3	Keep rolling unless your turn total is already past ~400
2	Bank: unless your total is right at its minimum possible (~200, i.e. four lone 5s and nothing else)
1	Bank: unless your total is right at its minimum possible (~250, i.e. five lone 5s and nothing else)

⑦ Does the rule of thumb above say "keep rolling"?

yes

CONTINUE: go back to ① and roll your remaining dice again.

BANK: end your turn here and keep the points.

On the realistic target: independent sources disagree on KCD1's default match length: gamepressure.com states a 2,000-point default, another wiki says "usually 4,000," and several sources agree the actual target scales with the opponent and the size of the wager. This report's fully-detailed exact solve below targets G=4,000; race_dp.py takes the target G as a plain parameter, so re-solving at G=2,000 (or any other target) is a self-check anyone can run directly rather than a result this report asserts a specific number for; the flowchart above and the cheat sheet later in this report are intended for either commonly-cited target, and for stakes in between.

Is this game "solved," academically?

Partly: in two distinguishable senses.

Framed using the taxonomy from L.V. Allis's 1994 PhD thesis Searching for Solutions in Games and Artificial Intelligence (Rijksuniversiteit Limburg, Maastricht), which defines ultra-weakly, weakly, and strongly solved games, this project meets the strongly-solved bar for the ruleset and target (G=4,000) modeled here: every reachable state's exact optimal value is computed, not just the outcome from a fixed starting position. Two caveats apply: that taxonomy was written for deterministic, perfect-information games, so applying it to a dice game borrows the framing rather than claiming a literal fit, and the result is two-player only. 3+ player dynamics are a different, unsolved problem not covered by this work.

The single-turn decision (when to bank vs. keep rolling) is exactly solved. This is structurally the same problem as the classic dice game Pig, whose optimal stopping policy was computed exactly by Neller & Presser ("Optimal Play of the Dice Game Pig," 2004) via finite-state dynamic programming. KCD's dice game has a richer scoring table (triples, straights, doubling multipliers) but it is still a finite Markov Decision Process: the state is just (dice remaining to roll, points banked this turn), and all scores are multiples of 50, so a discretized value-iteration grid is exact, not approximate. That's what this report's thresholds come from: not a heuristic, not a trained model, a provably optimal policy for the stated objective.

Update: the full two-player race has now also been solved exactly: see § The full race, solved exactly. It needed a state of (your score, opponent score) and backward induction over that larger (but still finite) grid, which correctly produces risk-seeking / risk-averse adjustments near the finish line that the simpler turn-level solve can't see. Both the turn-level and full-race solutions are reported below, each checked against independent large-sample Monte Carlo simulation, and the two are compared head-to-head so you can see exactly how much the harder solve actually buys you.

Rules modeled

Single 1 / single 5	100 / 50
Three of a kind (1s / 2s / 3s / 4s / 5s / 6s)	1000 / 200 / 300 / 400 / 500 / 600
Each additional die beyond 3-of-a-kind	doubles the value
Straight 1–5 / 2–6 / full 1–6	500 / 750 / 1500
Bust	no scoring die/combo at all → turn's points lost
Hot dice	bank all currently-rolled dice → re-roll all 6

Devil's-head wildcard dice (special inventory items) are out of scope: this models the default 6 regular dice.

Two rules matter more than they first appear, and both are modeled exactly:

You choose how many of a scoring face to bank, not just whether to. Two 5s can be banked one at a time. A triple+ group can also be partially declined, e.g. with four 2s you may bank only 3 of them. 2s/3s/4s/6s can never be banked below a group of 3 (a lone 2 never scores).
A straight can have leftover dice. Rolling six dice as {1,2,3,4,5,5} lets you bank the 1–5 straight (500) and the spare 5 (+50): the model checks for a straight pattern inside the roll, not just an exact match of all dice.

Rules engine spot-check

The DP and its Monte Carlo cross-checks elsewhere in this report both call the same scoring function (enumerate_actions in farkle_kcd.py), so agreement between them confirms the solver's logic, not that the scoring rules themselves were transcribed correctly from the game. Here's that layer checked by hand against a few specific rolls:

Roll	Best score available	By hand
{1,2,3,4,5,5}	straight 1–5 + spare 5	500 + 50 = 550
{2,2,2,2}	four 2s (double the three-of-a-kind value)	200 × 2 = 400
{5,5,5,5,5,5}	six 5s (triple the value three times over)	500 × 2³ = 4,000
{1,1,1,2,3,4}	three 1s only (2/3/4 don't score alone or as a pair)	1,000
{2,3,4,6}	nothing scores at all	bust

Bust probability by dice remaining

Exact combinatorics (not simulated) over all 6^k equally likely outcomes for rolling k dice:

6 dice

3.09%

5 dice

7.72%

4 dice

15.74%

3 dice

27.78%

2 dice

44.44%

1 die

66.67%

Risk climbs steadily as dice run out, and the increments get bigger in absolute terms toward the end: 6→5 only costs 4.6 points, but each subsequent step costs more (+8.0, +12.0, +16.7, +22.2), so the last die you have is the single most dangerous one to risk, not any particular "jump" partway through.

Optimal thresholds (exact DP)

V(k, T) = expected total points this turn, playing optimally, with k dice left to roll and T already banked this turn. The rule is simply: keep rolling while T is at or below the threshold for your current dice count; bank once you're past it. Busting from any state forfeits T entirely: that asymmetry (lose the whole pile vs. gain a known expected amount) is what produces a finite, computable cutoff.

Dice remaining	Keep rolling while turn total ≤	E[turn value] from 0
6 (opening roll / hot dice)	12,900	564.4
5	3,350	359.7
4	1,000	235.1
3	400	191.0
2	200	178.4
1	250	208.5

The k<6 values in the last column are the DP's boundary condition (starting with that many dice and T=0), a reference point for the solver, not a state you'd actually begin a turn in (a turn always starts at k=6). Don't read V(1,0)=208.5 > V(3,0)=191.0 as "1 die left is a better position than 3": it isn't; see the next callout for why these numbers aren't directly comparable.

Two non-obvious shapes in this table:

2 dice left is the single most conservative point in the game (threshold 200, lower than even 1 die left). With 2 dice your bust risk (44.4%) is high but you're not yet at the "nothing to lose" extreme, and a bad outcome here forfeits a turn that's typically been built up over several rolls.
1 die left is looser than 2 dice left (250 vs 200), counter-intuitive, since 1 die busts two-thirds of the time. The reason: succeeding with your last die (1/3 chance) banks it and triggers hot dice: a full fresh 6-dice re-roll with only a 3.1% bust chance. A lone last die is effectively a cheap ticket back to the safest state in the game, which is worth the 66.7% risk of losing the turn. One important caveat on how often this actually applies: every banked die is worth at least 50 points (the cheapest legal bank is a lone 5), so reaching exactly 1 die left requires banking 5 dice over the course of the turn, which means your turn total is at least 5×50 = 250: exactly the threshold. In other words, "push with 1 die left" is only ever live in the single narrowest case (every prior bank this turn was a lone 5, totaling precisely 250); any other route to 1 die left (a 1 counted somewhere, or any triple+) puts you over 250 and the answer flips straight back to "bank." Same logic makes the 200 threshold at 2 dice left an exact floor too (4×50=200). The 1-vs-2 comparison above is real DP output, but it compares two edge cases, not two live decision ranges; §Reading your first roll shows this concretely (no opening-roll path ever reaches 1 or 2 dice left with a total anywhere near that low).
At 5 or 6 dice remaining the threshold is far above what a single roll can produce (maximum is 8,000, from six 1s, still under 12,900), but that doesn't mean the opening roll usually calls for pushing on: it only applies when the opening roll's best play actually leaves you 5–6 dice. See the next section for how often that happens.

Reading your first roll (strength → target)

The decisive factor isn't how many points your first roll scored: it's how many dice you'd have left after banking the best available combination. Grouping all first-roll outcomes (weighted by true probability) by that remaining-dice count:

After best action, dice left	P(this happens)	Range of values banked	Recommendation
0 (outright bust)	3.09%	n/a	Turn over
6: hot dice immediately	6.25%	400 – 8,000	Keep rolling
5	57.10%	50 or 100	Keep rolling
4: never happens	0%	n/a	n/a
3	9.26%	200 – 1,000	Depends (≤400 go, >400 stop)
2	10.93%	400 – 2,000	Bank now
1	13.37%	400 – 4,000	Bank now

A row is missing on purpose, and that's itself a finding: the optimal policy never deliberately leaves exactly 4 dice on the opening roll. Checked exhaustively: whenever banking exactly 2 dice (say, two lone 5s) is on offer, there's always a strictly better alternative: either bank only 1 of them and keep 5 dice live, or take a bigger combination instead. The practical rule: if your opening roll gives you two 1s or two 5s with nothing else scoring, bank only one of them: banking both and settling for 4 dice is never optimal.

Headline number: about 30.5% of opening rolls should be banked immediately, before ever using all 6 dice. The full 24.3 points of that comes from the 1- and 2-dice-left rows (where the best combination already ate 4–5 of your 6 dice, leaving only 1–2 "dead" dice whose bust risk of 44–67% isn't worth it even on turn one); the remaining 6.2 points comes from the higher-value half of the 3-dice-left row (triples worth more than 400, e.g. three 5s or three 6s, still a decent number of dice left, just already enough points banked to clear that row's threshold). This runs against a common instinct to always re-roll after a strong opening hand; it's really about what's left and how much you've already banked, not points alone. (3.1% bust immediately, 66.4% should continue, 30.5% should stop: these three sum to 100%.)

The "decline the cheap triple" finding

A genuinely surprising, DP-verified result: it is sometimes correct to ignore an available three-of-a-kind and bank only a lone 1 or 5 instead: purely to keep more dice live.

Roll	Option A: just the stray single	Option B: just the triple	Option C: triple + the stray single too	Best
2,2,2,1,3,4	bank the 1 (100) → 5 left, V=428	bank triple 2s (200) → 3 left, V=258	bank both (300) → 2 left, V=300	A: decline the triple
3,3,3,5,2,4	bank the 5 (50) → 5 left, V=392	bank triple 3s (300) → 3 left, V=330	bank both (350) → 2 left, V=350	A: decline the triple

Option C (take the triple and the stray single: the obvious "greedy" play, and the strongest real competitor) still loses to declining the triple entirely: 428 > 300 and 392 > 350. Banking the smaller amount but keeping 5 dice beats grabbing the bigger score and dropping to only 2–3 dice: the extra survivability of a near-full hand is worth more than the point difference. This only applies to the cheap triples (2s = 200, 3s = 300); triples of 4s/5s/6s and especially 1s are valuable enough that taking them is correct. The lesson generalizes: whenever a combination would strand you below ~4 dice for a modest point gain, check whether banking less and keeping more dice live is better: it often is.

Strategy comparison (150,000 simulated turns each)

DP-optimal

566.2

Bank-max heuristic

506.8

Stop <3 dice left

488.5

Stop after 1st score

398.4

Stop <2 dice left

396.7

Strategy	Mean pts / turn	Bust rate
DP-optimal (exact)	566.2	19.0%
Bank everything scoring, stop at DP thresholds	506.8	17.3%
Stop once <3 dice remain	488.5	20.0%
Stop immediately after any score	398.4	3.2%
Stop once <2 dice remain	396.7	44.4%
Never stop (push until forced)	0.0	100%

Playing it maximally safe ("stop after any score") has a low 3.2% bust rate but leaves ~30% of the expected value on the table. "Never stop" guarantees eventual ruin: with bust probability bounded away from zero every roll, the probability of surviving forever is zero.

Turn score distribution under the optimal policy (300,000 turns, independent run)

This is a separate, larger-sample simulation run from the 150,000-turn table above (different seed): it's why 564 / 19.3% here and 566.2 / 19.0% above don't match to the decimal. Turn score has a standard deviation of about 508, so the standard error on a 300,000-turn mean is about ±0.9 (±1.3 at 150,000 turns); both observed means (564.36 and 566.15) are within 1.3 standard errors of the DP's exact value, 564.44.

564

mean points / turn

19.3%

bust rate

500 / 1,200

median / p90 (nonzero turns)

1.9%

chance of a 2,000+ turn

Who actually wins games? (seat-order-balanced head-to-head races)

20,000 full races per matchup, target scores shown; first-mover advantage removed by alternating who rolls first.

DP-optimal vs.	Race to 1,000	Race to 4,000	Race to 10,000
Bank-max heuristic	55.4%	59.5%	65.2%
Stop after first score	65.8%	78.5%	89.1%
Stop once <3 dice remain	57.7%	62.8%	68.9%

Cells show the DP-optimal policy's win rate. The edge compounds over a longer race (more turns = the higher-EV strategy's advantage dominates variance more), which is exactly what you'd expect from a policy that maximizes expected value per turn. This table uses the turn-level policy on both sides with no race-awareness at all: the next section solves the race itself exactly and asks how much further that gets you.

The full race, solved exactly

The turn-level DP above maximizes expected points per turn. That is not quite the same objective as maximizing probability of winning a race to a target: the two diverge near the finish line, where guaranteeing a win is worth more than squeezing out extra expected points you'll never get to spend. To fix that, the full race was solved as its own, larger finite Markov game: state = (your banked score, opponent's banked score), both in steps of 50 up to target G = 4000. Define

F(x, y) = P(the player about to roll wins the race | own score = x, opponent's score = y)

F is a fixed point: stopping with a new total z = x+T either wins outright (z ≥ G) or hands the turn to the opponent, who then faces F(y, z), so stopping is worth 1 − F(y, z) to the active player. Busting hands the turn over with score unchanged: worth 1 − F(y, x). This couples every (x, y) to every other (y, x′) pair, so it was solved by Gauss-Seidel value iteration over the whole 80×80 score grid at once (scores 0–3,950 in steps of 50; the 81st value per axis is the absorbing "already won" boundary, handled separately, not a grid cell), with the within-turn decision vectorized across every opponent score simultaneously. Unlike the turn-level DP, this needed no arbitrary truncation ceiling: the natural absorbing boundary is the literal target score G, so the solution is exact, not approximate, up to the 50-point grid (which is exact anyway, since every achievable score is a multiple of 50). It converged to a tolerance of 10⁻⁷ in 22 sweeps, about 2.7 minutes on this machine.

Headline number

55.71%

exact P(win) for whoever rolls first, race to 4,000, both players optimal

55.72%

independent 50,000-race Monte Carlo estimate of the same quantity

Going first is worth a real, quantifiable edge (about 5.7 percentage points above a coin flip) even between two perfectly-played sides, purely from the extra roll.

Exact solve vs. direct Monte Carlo, at six representative states

Your score / opponent's score	Exact F(x,y)	Monte Carlo (N=50,000)	Difference
0 / 0 (game start)	0.55712	0.55722	0.00010
2,000 / 0 (big lead)	0.90713	0.90674	0.00039
0 / 2,000 (big deficit)	0.16057	0.15998	0.00059
3,500 / 0 (almost home)	0.99508	0.99564	0.00056
1,000 / 1,500 (500 behind)	0.44834	0.44998	0.00164
3,000 / 3,500 (500 behind, late)	0.44828	0.44748	0.00080

This table was re-run at N=50,000 (up from an initial N=10,000) after an independent audit found a too-tight numerical tolerance in the simulator that could occasionally make it play a slightly different policy than the one actually solved for; see §Caveats. The exact F column is completely unchanged by that fix (it only affected the simulator); the Monte Carlo column moved by less than its own margin of error.

Every difference is well inside its own row's 95% confidence interval (computed per-row from that row's empirical proportion: these range from about ±0.0006 for the near-certain 0.995 row up to ±0.0044 for the near-50/50 rows at this larger N, not one blanket number). The exact dynamic program and independent simulation agree everywhere they were checked: the strongest form of verification available short of a formal proof, though it's worth being precise about what it verifies: both the DP and this Monte Carlo check share the same underlying rules engine (farkle_kcd.py), so this confirms the fixed-point solver was implemented correctly, not that the scoring rules themselves are modeled correctly (that's checked separately, see §Rules modeled's validation table).

The two 0.448-ish rows above (500-point deficit, at two different points in the game) land within 0.00006 of each other; that's a genuine coincidence of this specific grid, not a hidden symmetry: the same "500 behind" gap computed at (0,500) gives 0.4553 and at (2,500/3,000) gives 0.4176, so the win probability for a fixed deficit does move around depending on absolute score, it just happens to revisit roughly the same value at these two particular points.

How much does race-awareness actually buy you?

Three policies, raced head-to-head 300,000 times each (seat-order balanced), large enough to resolve a sub-percentage-point effect with confidence:

Matchup	Race-aware exact wins	Other wins
vs. (a) pure turn-EV-max, completely race-blind	53.54% ± 0.18%	46.46%
vs. (b) turn-EV-max + the "obvious" patch: stop the instant you'd reach the target	52.80% ± 0.18%	47.20%

± values are 95% confidence intervals from N=300,000 races per matchup. (This table was re-run after an audit-found tolerance bug fix in the simulator. See §Caveats; the corrected numbers are very close to, and the conclusion is unchanged from, the first run.)

The patch moves race-aware's win rate from 53.54% to 52.80%: a drop of 0.73 ± 0.25 percentage points (95% CI), which is statistically distinguishable from zero at this sample size (an earlier, smaller run showed the same direction but was too small to tell apart from noise; this is the corrected, adequately-powered version). Measured as edge-over-a-coin-flip, pure race-blind play (a) is 3.54 points above 50%, and the patched version (b) is 2.80 points above 50%. The trivial "stop once you'd already won" patch closes only about one-fifth of that edge (2.80⁄3.54 ≈ 79% survives the patch): the remaining four-fifths comes from the dynamic programming adjusting risk tolerance throughout the whole game: pushing harder than the fixed table says while behind, banking more conservatively at low dice counts while ahead, and never banking partial progress near the finish, not just fixing the final-turn blind spot. The table below shows exactly what that broader adjustment looks like.

How the real threshold shifts with the score gap

Each cell is the race-aware "keep rolling while turn total ≤ X" threshold for that many dice remaining, at that specific (your score, opponent's score). Compare to the fixed, score-blind thresholds from §Optimal thresholds: 6→12,900 · 5→3,350 · 4→1,000 · 3→400 · 2→200 · 1→250.

Situation	k=1	k=2	k=3	k=4	k=5	k=6
Tied, early (0 / 0)	250	200	400	950	2,100	3,100
Far behind (0 / 3,000)	800	600	3,950	3,950	3,950	3,950
Far ahead (3,000 / 0)	150	150	250	950	950	950
Both near finish, tied (3,500 / 3,500)	450	450	450	450	450	450
Behind, near finish (3,000 / 3,900)	950	950	950	950	950	950
Ahead, near finish (3,900 / 3,000)	50	50	50	50	50	50

Read this before taking the table above at face value: a threshold value of exactly G − x − 50 (your remaining gap to the target, minus one grid step) is the largest representable number before the grid saturates into "already won." A cell showing that number doesn't mean "a generous cap": it means the policy never voluntarily banks short of the target at all: keep rolling for literally any value up to the point where you'd either win outright or bust trying. Four of the six rows below hit exactly this ceiling at every k (far-behind's k=3–6, far-ahead's k=4–6, and both near-finish rows across the board); check each against the arithmetic: 3,950 = 4000−0−50 is that player's own ceiling (deficit case, x=0), 950 = 4000−3000−50 (lead case, x=3,000, and separately the near-finish case, x=3,000), 450 = 4000−3,500−50, 50 = 4000−3,900−50.

With that reading in hand, four clear patterns fall out of the exact numbers:

Even tied at the very start, the race-aware thresholds for 5–6 dice are dramatically lower than the pure-EV table (2,100 and 3,100 vs. 3,350 and 12,900: genuine, non-saturated values here, since 2,100 and 3,100 are well short of 4000−0−50=3,950). Pure EV-maximization says push almost without limit with a fresh hand because rare huge turns pull the long-run average up; but in a race, a turn that big already makes you a near-certain winner, so there's nothing left to gain by risking it for a still-bigger pile of points you don't need.
Falling behind makes you stop banking safe partial progress altogether, not just push harder: at k=1–2 the numbers (800, 600) are real, elevated-but-finite thresholds; from k=3 up, the cells are saturated at 3,950, meaning with 3 or more dice in hand while 3,000 behind, the policy says roll for the whole gap in one go rather than bank anything less. Makes sense: banking a partial amount while still well behind doesn't change your underlying problem much, while a single huge turn might end the game immediately.
Holding a lead flips the same logic the other way at low k, but saturates at high k too: 150/150/250 at k=1–3 are genuine conservative thresholds (bank early with few dice, protect the lead), but 950 at k=4–6 is also a saturated ceiling (4000−3,000−50); with a big lead and 4+ dice in hand, the policy still says push for the kill rather than bank a safe partial gain, exactly the opposite of "bank early and often" in that regime.
Right at the finish, every single cell is saturated: all three near-finish rows hit their ceiling (450, 950, 50 respectively) at every k from 1 to 6. The policy is unanimous regardless of dice remaining: never bank a partial amount this close to the target: always roll for the exact win, or bust trying. That's a real, if slightly aggressive-sounding, finding: locking in modest guaranteed progress near the finish line is worse than swinging for the complete win, because busting only resets you to a position the DP already rates almost as well as the partial-bank alternative would have, while succeeding ends the game immediately.

Scope note: the exact race solve above is computed for target G = 4,000 specifically (KCD's match length varies by opponent/wager). Re-solving for a different target is a few minutes of recomputation (race_dp.py, runtime scales worse than linearly with G: roughly 2 seconds for G=300, 20s for G=1,000, 52s for G=2,000, 162s for G=4,000). Ask if a specific match target should be solved.

Practical cheat sheet

The one rule everything else below follows from: compare your running turn total so far to the threshold for however many dice you'd have left to roll next: 6→12,900 · 5→3,350 · 4→1,000 · 3→400 · 2→200 · 1→250. Keep rolling while you're at or under that number for your current dice count; bank once you're over it. It's never "N dice left → always stop" or "N dice left → always push" in isolation: dice-remaining sets the bar, but your accumulated total is what gets compared against it.
Why the opening roll so often means banking immediately despite that: if your first roll's best combination already eats 4–5 of your 6 dice, you're forced into the 1- or 2-dice-left thresholds (250 / 200). On the opening roll specifically, the cheapest way the optimal policy ever actually lands there is already worth 400+ (it would rather keep a cheap triple's dice live than bank them down to 1–2 remaining, see §Decline the triple), so landing at 1–2 dice left on the opening roll always means your total already clears the threshold: bank and stop. (3 dice left on the opening roll is a genuine toss-up: stop if you've already got >400, otherwise push. 5–6 dice left → push, essentially always, and never happens at exactly 4, see §Reading your first roll.)
The 250 / 200 thresholds at 1–2 dice left are tighter than they look; they're floors, not ranges: every legal bank is worth at least 50 points (the cheapest is a lone 5), so reaching exactly 1 die left requires having banked 5 dice already this turn, which means your total is at minimum 5×50 = 250: exactly the threshold. So "push with 1 die left" is only ever live in the single narrowest case: every earlier bank this turn was a lone 5, totaling precisely 250 (five of them, from possibly several rolls). Any 1 counted anywhere, or any triple taken, pushes you over 250 and the answer is bank, full stop. Same exact-floor situation at 2 dice left (4×50=200).
When you have 5–6 dice and face a choice between a cheap triple (2s/3s) vs. a lone 1 or 5, check whether taking the smaller score but keeping more dice live beats grabbing the triple: it often does (see §Decline the triple).
Near the finish line, use the exact race-aware thresholds, not the fixed table, and they say the opposite of "bank anything safe": the fixed thresholds above maximize long-run expected points, which is not the same as maximizing your probability of winning a race that's about to end. §The full race, solved exactly shows that once you're close to the target, the correct policy is to never bank a partial amount at all: keep rolling for the exact win (or bust trying) regardless of how many dice you have left. Locking in a safe-but-incomplete gain is worse than swinging for the finish. The same "don't bank partial progress" logic kicks in with 4+ dice in hand even while comfortably ahead by a lot (e.g. a 3,000-point lead); only with few dice (1–3) in hand does a lead call for the more familiar "bank early, protect it" instinct.

Caveats & scope

Devil's-head wildcard dice (special inventory items) are not modeled: this is the default 6-regular-dice game.
The fixed per-dice-count thresholds (§Optimal thresholds) maximize expected points per turn, a risk-neutral objective that's provably right in isolation but diverges from maximizing win probability near the end of a race, see §The full race, solved exactly for the corrected, score-aware thresholds. Quantified: full race-awareness is worth 3.54 points of win rate above a coin flip against a race-blind opponent (N=300,000, 95% CI ±0.18pp); about a fifth of that comes from the obvious "stop once you've already won" fix and the rest from deeper, statistically confirmed risk-tolerance adjustments through the whole game.
The full two-player race is solved exactly for target G=4,000; a different match length needs a few minutes of recomputation (race_dp.py) rather than a fundamentally different method.
This report's DP code and Monte Carlo validation were independently audited line-by-line (two separate reviews). The DP/Bellman recursion itself came back clean: an independent from-scratch reimplementation reproduced the solvers' values to floating-point precision, no bugs found; this is independently verifiable against farkle_dp.py and race_dp.py directly, though no separate reimplementation script is checked into this repo. The validation code had one real bug: a numerical tolerance in the race simulator (1e-9) tighter than the solver's own convergence tolerance (~8.5e-8), which could make the simulator occasionally "continue" at a handful of states where the converged policy said "stop." Fixed (raised to 1e-6) and every affected number in this report was re-run and updated; the correction moved results by less than their own margin of error and changed no conclusion.
All code (farkle_kcd.py, farkle_dp.py, farkle_sim.py, farkle_race.py, farkle_report_data.py, race_dp.py, race_compare.py) lives alongside this file and regenerates every number shown here.