Dice expression syntax

Quick reference

Constants and dice

An expression is a sum of terms. Each term is either an integer constant (K) or a dice term (NdM, possibly with a modifier). Whitespace between tokens is optional and ignored; the d can be uppercase (D) too.

• 5 — a constant 5 (degenerate "distribution" with one outcome).
• 1d6 — one six-sided die. Six equally-likely faces, mean 3.5.
• 2d6 — two d6 summed. The classic triangular distribution: 36 outcomes, mean 7, mode 7.
• 4d6 — four d6, used in 5e ability score generation. The "drop the lowest" variant is 4d6kh3 — keep the highest 3 of 4.

Additive modifiers

The most common 5e weapon-damage form: NdM plus your ability modifier. + and - are left-associative; you can chain any number of terms.

• 1d8+3 — longsword with +3 STR. Range 4–11, mean 7.5.
• 2d6+5 — greatsword with +5 STR. Range 7–17, mean 12.
• 1d12+5 — greataxe with +5 STR. Same modifier; very different shape.

For mixing different dice (e.g., weapon + sneak attack die, base damage + elemental rider), see the next section.

Mixing dice and constants — the main reason to use the engine

Anyone can compute 2d6 alone. The interesting cases combine different dice — weapon + sneak attack, base damage + elemental rider, primary swing + bonus-action attack — and the resulting distribution isn't an obvious shape. Convolving exact rationals is what this engine does well.

Add as many dice and constant terms as you want, in any order, with + or - between them. Whitespace is optional.

• 2d6 + 1d4 — pure dice mix, no constant. Range 3–16, mean 19/2 = 9.5.
• 1d8 + 1d6 + 3 — 5e rogue with a shortbow + sneak attack die + DEX modifier. Three independent terms. Range 5–17, mean 11.
• 2d6 + 1d4 - 2 — dice plus dice plus a negative constant. Useful for "deal 2d6 + 1d4 damage, target gains 2 temp HP" kind of net-damage scenarios. Range 1–14.
• 1d8 + 3 ↔ 3 + 1d8 — order doesn't matter for + terms; both produce the same distribution and the same slug encoding when you flip them through the parser.

The convolved shape is what you'd expect from the central limit theorem — adding more independent dice pulls the distribution toward a bell curve. Side by side: pure 1d8+1d6 (no modifier) vs the rogue pattern with +3 (same shape, shifted right by 3):

Exploding dice (!)

On a maximum-face roll, roll the die again and add. Recurses up to depth 20 (truncation error ~M⁻²⁰, well below floating-point noise for any practical M). Notation: append ! to the dice term.

• 1d6! — the canonical exploding die. Mean 21/5 = 4.2.
• 1d8! — slightly tighter explosion rate.
• Why this matters →

Constraint: a 1-sided die can't explode (it would loop forever). Combining ! with r on the same die is rejected — pick one modifier per die term.

Reroll once (r<K>)

If the first roll is ≤ K, roll a second time and keep the second result (whether it's higher or lower). The 5e Great Weapon Fighting style is exactly NdMr1 — reroll any 1s and 2s once. (Strict 5e GWF rerolls 1s AND 2s; the engine currently supports only an inclusive ≤ K threshold, so r2 covers both.)

• 2d6r1+5 — greatsword with GWF "reroll 1s" rule. Compare to plain 2d6+5.
• 1d12r1+5 — greataxe with the same rule.

Keep-highest / keep-lowest (kh1 / kl1)

Roll N dice, keep only the single highest (kh1) or single lowest (kl1). When N=2 this is exactly 5e advantage and disadvantage.

• 2d20kh1 — d20 with advantage. Mean 553/40 = 13.825.
• 2d20kl1 — d20 with disadvantage. Mean 287/40 = 7.175.
• Why this matters →

Generic kh<K> / kl<K> with K ≥ 1 is supported. The kept=1 case uses a closed-form recursion (max-of-N / min-of-N); kept>1 brute-enumerates sides^count outcomes (capped at 200K, which fits 4d6 / 4d20 / 5d6 / 6d6 — the realistic d-and-d ability-gen cases plus a few homebrew variants).

Attack rolls (@ AC<n> +/-<m>)

The @ postfix wraps a damage expression with an attack roll vs Armor Class. The result is a per-attempt distribution that includes a zero-mass spike on miss and a crit-doubled tail on natural-20 (or whatever crit range you set):

• 1d8+5 @ AC15 +9 — a longsword swing with +9 to-hit against an AC 15 target. Per 5e RAW: nat 1 always misses, nat 20 always hits and crits, and the modified roll vs AC handles everything else.
• 2d6+5 @ AC15 +9 — a greatsword swing under the same conditions. Same hit rate, different damage shape.
• 1d12+15 @ AC15 +4 — a Greataxe Fighter using Great Weapon Master: −5 to-hit, +10 damage. The break-even AC sits at attack-bonus + 8.

Three optional flags can follow the AC and bonus, in any order:

• adv / disadv / elven — advantage (2d20 keep highest), disadvantage (2d20 keep lowest), or Elven Accuracy (3d20 keep highest). With advantage, crit rate jumps to 1 − (19/20)² = 9.75%; with Elven Accuracy, to 1 − (19/20)³ ≈ 14.26%. 1d8+5 @ AC15 +9 adv.
• c<k> — lower the crit range. Champion Fighter is c19 (crits on 19 or 20). 1d12+5 @ AC15 +9 c19.
• Combine flags: 1d8+5 @ AC15 +9 elven c19 for the Elven Accuracy + Champion crit-fish stack.

Crit damage follows the 5e rule: roll the dice twice, add the modifier once. So a crit on 1d12+5 becomes 2d12+5, not 2(d12+5). The engine handles this automatically — you never write the doubled form by hand.

The @ postfix binds looser than + and -: 2d6+5 @ AC15 +9 parses as "the attack expression with damage = 2d6+5", not as "the attack 5 @ AC15 plus 2d6 plus 9." The damage expression is everything to the left of @.

Multi-attack (attacks N)

Postfix attacks N on an attack expression replays the same attack profile N times and convolves the per-attempt distributions. The canonical 5e use case is Extra Attack at level 5 (Fighter, Paladin, Ranger, Barbarian) — two swings with the same weapon per round.

• 1d12+5 @ AC15 +9 attacks 2 — a Greataxe Fighter at level 5 vs AC 15 with +9 to-hit. The per-round distribution is the convolution of two independent single-swing distributions: each one independently misses, hits, or crits.
• 1d12+15 @ AC15 +4 attacks 2 — same Fighter using GWM (−5 to-hit, +10 damage) on both swings. Compare to the base form to see the GWM trade across a full round, not just per-attack.
• 1d12+5 @ AC15 +9 attacks 4 — Action Surge round at level 5 (4 attacks). Mean and variance both quadruple; the distribution narrows toward normal as N grows (CLT in action).

Constraints: N must be in [1, 20]. Main-attack heterogeneity (e.g. Greatsword first attack + Shortsword second attack) isn't expressible directly — write those as a sum of separate Attack expressions, or use the comparison tool's two-side form. The bonus <attack> postfix DOES handle the "homogeneous main + one different bonus" case (PAM haft, TWF offhand, CBE bonus shot), and sneak composes with bonus for Rogue/PAM and Rogue/TWF builds. attacks N only applies after @ — it's strictly the multi-attack convolution. For "roll once and multiply the result", use the * infix operator on a damage expression: (1d4+3)*3 is a single 1d4+3 roll multiplied by 3 (uniform over {12, 15, 18, 21}), distinct from 3d4+9 which sums three independent rolls (same mean, tighter distribution).

Scalar multiplication and grouping (*, ())

The infix * operator multiplies the rolled value of an expression by an integer constant. At least one operand must be a constant — both-random (1d4*1d6) is rejected because the meaning is ambiguous (scalar mult vs. convolution). Use + to convolve independent rolls.

Grouping parentheses (…) override default precedence. Precedence is +/- (lowest), then *, then atoms — so 1d6 + 1d4*2 parses as 1d6 + (1d4*2). Parens accept an optional :tag postfix for type-tagging the whole group, equivalent to the bracket form ((1d6+5):slashing ↔ [1d6+5]:slashing; brackets require the tag, parens make it optional).

• (1d4+1)*3 — the 2014 Magic Missile shape: roll one 1d4+1 and apply it to all three darts. Mean 10.5, uniform over {6, 9, 12, 15} (4 outcomes).
• 3d4+3 — the 2024 Magic Missile shape: each dart rolls independently. Same mean (10.5), but tighter — the convolution narrows the distribution by a factor of 3 in variance.
• 1d6 + 1d4*2 — illustrates precedence: parses as 1d6 + (1d4*2), not (1d6 + 1d4)*2. Wrap in parens to force the other reading.

* is independent of the attacks N multi-attack postfix. Multi-attack is convolution (sum of N independent attack rolls); scalar mult is point-multiplication of one rolled value. Both can appear in the same expression when applicable.

Percentage attacks (@ hit <p>%)

The @ hit <p>% postfix is the alternative to @ AC<n> +<m> — a single roll against a flat hit probability instead of d20-vs-AC math. Models XCOM 2, Hard West, Pillars of Eternity, Fire Emblem, and any other tactical game where the player sees a "65%" tooltip rather than a d20 attack roll. Trailing % is optional; hit 65 and hit 65% parse identically.

Two optional postfix flags:

• crit <p>% — conditional crit chance on a successful hit. P(crit) = P(hit) · crit_chance. Crit damage doubles the damage dice (same rule as the d20 path). Cannot fire on a graze.
• graze <p>% — partial-hit bucket. P(graze) eats into the miss probability, so a 65% hit / 15% graze build has 80% chance of dealing some damage. Graze damage = floor(dmg / 2) — same div_euclid(2) as Save::Half. Invariant: hit + graze ≤ 100.

The four-way outcome split for 1d3+4 @ hit 65 crit 10 graze 15:

• P(crit) = 0.65 · 0.10 = 39/400 = 9.75%
• P(non-crit hit) = 0.65 - 0.0975 = 221/400 = 55.25%
• P(graze) = 60/400 = 15%
• P(true miss) = 1 - 0.65 - 0.15 = 80/400 = 20%

What the d20 attack flags do NOT do here. adv / disadv / elven apply only to d20 to-hit ensembles — there's no d20 to roll multiple of in the percentage path, so they're rejected by the parser. Same for c<n> (crit range — replaced by crit <p>%) and shield (defender Shield is a d20 mechanic). What DOES carry over: rider, dr, dr:type, brutal, and attacks N all work identically — they operate on the post-branch damage, not on the to-hit math.

• 1d3+4 @ hit 65 crit 10 — vanilla XCOM 2 assault rifle, no graze model.
• 1d3+4 @ hit 65 crit 10 graze 15 — same shot with graze enabled (default WotC ruleset).
• 1d3+4 @ hit 95 crit 25 — Squadsight overwatch chain, near-certain hit with high crit.
• 1d3+7 @ hit 35 crit 15 — low-percentage Sniper flank, long-tail Hail Mary.
• 1d4+5 @ hit 50 crit 10 graze 30 — Shotgun through half-cover, graze-heavy distribution.

Worked-out math, the variance picture, and what's out of scope (miss-streak protection, Hard West Luck pool) — see the XCOM 2 outcome model pillar. Pre-baked weapon panels live at /games/xcom/.

Saving throws (save +<b> DC<n> [half|zero])

The save postfix wraps a damage expression with a target's saving throw. Per RAW, the result depends on the save:

• Half on save (default — Fireball-style): full damage on fail, floor(damage/2) on success. The dice are rolled once; the same random variable is halved on save (a Fireball that rolls 30 deals 30 on fail and 15 on save — not "roll separately").
• Zero on save (use zero flag — Hold Person-style "save-or-suck"): full damage on fail, nothing on success.

Examples:

• 8d6 save +5 DC15 — Fireball at 3rd-level slot vs a CR-5 monster's DEX +5 save. P(save) = (21+5−15)/20 = 11/20 = 55%; expected damage drops from 28 (always full) to ~20.3 (55% half).
• 8d6 save +0 DC15 — same Fireball vs a target with no DEX save bonus (CR-1 humanoids, low-tier undead). P(save) = 6/20 = 30%.
• 10d6 save +5 DC17 — Fireball upcast to 5th-level slot, DC 17 (mid-tier caster). P(save) = 9/20 = 45%.
• 1d6 save +1 DC13 zero — a save-or-suck cantrip-tier effect: the 1d6 is the "damage-or-control" payload; zero flag means success means it does nothing.

5e RAW for saves: no nat-1 auto-fail or nat-20 auto-success (those rules are for attack rolls; death saves are a separate mechanic). Save probability is just clamp((21 + bonus − DC) / 20, 0, 1). The engine handles boundary cases — a save you can't make (DC 25 vs +0) collapses to the unmodified damage distribution; a save you can't fail collapses to all-zero (Zero) or all-half (Half).

Multi-target AOE (t<N>)

Postfix t<N> on a save expression extends to multi-target: the SAME damage roll applies to N independent saves. Per RAW, the dice are rolled once and each target saves separately, taking either full damage on fail or transformed damage on success. The per-cast total is the sum across targets.

• 8d6 save +5 DC15 t4 — Fireball (3rd-level slot) into a pod of 4 CR-5 monsters (DEX +5 save, P(save) = 55%). Per-cast mean ≈ 81 (4× the single-target ≈ 20).
• 8d6 save +0 DC15 t8 — Fireball into a swarm of 8 weak humanoids (no DEX save). Per-cast mean ≈ 190. This is the "DEX +0 minions are Fireball food" regime.
• 8d8 save +5 DC17 t4 — Cone of Cold (5th-level slot) into 4 mid-tier targets, DC bumped to 17.

Implementation: for each rolled damage value x and number of failed saves k (where K ~ binomial(N, P(fail))), the per-cast total is x·k + transform(x)·(N − k). Independence of damage roll and per-target save outcomes makes this a clean product-of-distributions over the support — sub-millisecond even for Cone-of-Cold-into-8 (8d8 × 9-bucket binomial = ~500 pre-mix outcomes).

Constraint: N must be in [1, 20]. t1 is the default and identical to omitting the flag. The t flag composes with half / zero in any order: 1d6 save +1 DC13 zero t3 (save-or-suck into 3 targets) parses fine.

Rider damage (rider <expr>)

The rider postfix attaches an extra damage expression that fires on every hit. On a normal hit the rider's value is added to the base damage; on a crit the rider's dice are doubled too (per RAW — the same rule that doubles the base damage dice). On a miss, no rider — the rider only fires when the swing connects.

Use this for any "extra dice on hit" mechanic that fires every time:

• Smite — Paladin spending a 1st-level slot on a longsword swing: 1d8+5 @ AC15 +9 rider 2d8.
• Hex / Hunter's Mark — flat 1d6 rider on every hit while concentration holds: 1d8+5 @ AC15 +9 rider 1d6.
• Improved Divine Smite + Extra Attack — both swings carry the same rider: 1d8+5 @ AC15 +9 rider 2d8 attacks 2.

Sneak Attack is not a rider — use sneak instead. Sneak Attack triggers once per turn, on the first qualifying hit. Using rider for it on a multi-attack chain would double-count, since rider fires on every hit. The sneak postfix on a multi-attack chain (next section) models the once-per-chain semantics correctly.

Sneak Attack chain (attacks N sneak <expr>)

The sneak postfix attaches to a multi-attack chain (attacks N) and adds extra damage to the first hit (or crit) of the chain — exactly once per round, regardless of how many attacks land. Models 5e Sneak Attack, where a Rogue gets their bonus dice once per turn on whichever swing connects first.

On a crit the sneak dice are doubled too, just like the base damage. On a no-hit chain (every attack misses), no sneak is added — chain damage is zero.

The semantic difference from rider matters as soon as N > 1:

• 1d6+3 @ AC15 +5 rider 3d6 attacks 2 — Rogue with TWO attacks each carrying 3d6 sneak dice (incorrect: doubles up the per-turn limit).
• 1d6+3 @ AC15 +5 attacks 2 sneak 3d6 — Rogue with TWO attacks where the first hit triggers 3d6 sneak (correct: the per-turn limit is enforced at the chain level).

Composes with rider on the inner attack — a Paladin/Rogue multiclass declares both, and both fire: 1d8+5 @ AC15 +9 rider 2d8 attacks 2 sneak 3d6 gives every hit Improved Divine Smite (2d8) and pours sneak dice (3d6) into whichever swing lands first.

Edge case: attacks 1 sneak X is mathematically equivalent to rider X — there's only one attack, so "first hit" and "every hit" are the same event. The engine recognises this; both forms produce the same distribution.

Bonus attack on crit (attacks N oncrit <attack>)

The oncrit postfix attaches to a multi-attack chain (attacks N) and adds a once-per-chain bonus attack that triggers when at least one of the main attacks crits. Models 5e Great Weapon Master's bonus haft attack: on a crit, you get a free bonus-action swing with a melee weapon. The kill-trigger half of GWM lives in the GWM-on-kill cascade pillar — that's the same bonus action wired into the cascade machinery instead of the per-attack chain.

The bonus is a full attack — it has its own to-hit roll, miss/hit/crit branches, and damage. Syntax requires the @ AC<n> +/-<m> postfix on the bonus expression so the parser can build a complete attack profile:

1d12+15 @ AC15 +4 attacks 2 oncrit 1d12+15 @ AC15 +4

Critical resource semantic: the bonus action is a per-turn resource, so even when both main attacks crit (a Champion's day out), the bonus fires once, not twice. This mirrors how Sneak Attack caps at one trigger per turn — and the analytic mean reflects it: bonus contribution = P(≥1 crit in N) × E[bonus per-attempt], not N × P(crit) × E[bonus per-attempt].

Composes with rider on the inner attack — Smite (rider, every-hit) plus GWM (oncrit, once-per-chain bonus attack) is a real Paladin/Fighter multiclass move: 1d12+5 @ AC15 +9 rider 2d8 attacks 2 oncrit 1d12+5 @ AC15 +9. Each main hit gets Improved Divine Smite damage, and a crit on either swing triggers a fresh bonus attack with its own to-hit.

sneak and oncrit are mutually exclusive postfixes on the same chain — the parser rejects that combination with an explicit error rather than silently producing the wrong distribution. The realistic build that would want both (Rogue / Fighter with GWM dipping) is rare enough that the explicit error is the right surface.

Bonus action attack (attacks N bonus <attack>)

The bonus postfix attaches an unconditional bonus- action attack to a multi-attack chain — the bonus always fires once per chain, regardless of main-attack outcomes. Models any "you always get one extra attack with X" feature: Polearm Master's haft, Two-Weapon Fighting's offhand, Crossbow Expert's hand-crossbow bonus shot, Monk Martial Arts.

Same parse shape as oncrit — the bonus is a full attack expression with its own @ AC<n> +/-<m> to-hit. PAM with a glaive (1d10+STR main, 1d4+STR haft) at +9 vs AC 15:

1d10+5 @ AC15 +9 attacks 2 bonus 1d4+5 @ AC15 +9

Why a postfix when + would seem to suffice? The grammar actually rejects attacks N + <attack> (the multi-attack chain returns at the top level), so prior to this construct PAM wasn't expressible at all. Stacking bonus with oncrit on the same chain builds an exclusive-mutex node — see the next section (PAM + GWM with the per-turn-bonus-action constraint enforced).

Distribution-equivalent at the math layer to a hypothetical attacks N main + bonus — both are an N-fold convolution of the main per-attempt distribution, then convolved with the bonus per-attempt. Linearity gives the closed-form mean: N · E[main per-attempt] + E[bonus per-attempt].

Mutually-exclusive bonus actions (attacks N bonus X oncrit Y)

RAW you have a single bonus action per turn. Two feats that both grant a bonus-action attack — PAM (always available) and GWM (on a crit) — are mutually exclusive in practice: the optimal play uses the GWM bonus when at least one main attack crits (bigger weapon damage), and the PAM haft otherwise.

Stacking bonus and oncrit on the same attacks N chain encodes exactly this. The two postfixes can appear in either order; the engine builds the same mixture distribution either way:

1d10+15 @ AC15 +4 attacks 2 bonus 1d4+15 @ AC15 +4 oncrit 1d10+15 @ AC15 +4

Closed-form mean is straightforward by linearity:

E[total] = N · E[main] + P(no crit) · E[PAM] + P(≥1 crit) · E[GWM]

where P(no crit) = (1 − p_crit)N. The result sits strictly between the PAM-only number (lower bound; no crit advantage taken) and the both-bonuses-fire upper bound (which would over-count the bonus-action slot).

Stacking sneak with bonus on the same chain (Rogue / PAM, Rogue / TWF — heterogeneous-chain Sneak) is supported. The Sneak Attack rider attaches to the first hit-or-crit anywhere in the (main_1, …, main_N, bonus) sequence, doubled on crit per RAW. sneak with oncrit on the same chain is mutually exclusive — the parser rejects it with an explicit error rather than silently producing the wrong distribution.

Rogue/PAM Glaive at level 5 (1d10+5 main + 1d4+5 haft + 3d6 Sneak), two main attacks vs AC 15 with +9 to hit: