简体中文
English
Website review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is dice.run?
dice.run is an online dice roller built for tabletop RPGs and game design. It parses standard dice notation, rolls with a full audit trail, and shows the probability distribution behind an expression rather than just a single result.
What you can do with it
- Roll in standard notation. Type a dice expression and get a result, with the rolls recorded so you can check how the number was produced.
- See the odds as you type. The probability panel reports the mean, range and full distribution for the expression, so you can judge whether a roll is swingy or reliable before it matters at the table.
- Author dice programs. The Studio area lets you build reusable dice programs with live distributions, useful for game design work rather than one-off rolls.
- Browse community rolls and packs. Shared material includes system packs, such as a D&D 5e (2024) pack grouping attack rolls, damage, saves and class-feature rolls by what you are trying to compute.
Who it suits
A GM checking whether a homebrew damage expression is too punishing, or a designer comparing two resolution mechanics, gets more from dice.run than from a plain roller because the distribution is visible. A player who just wants a quick d20 result can use it too, but the audit trail and distribution view are the parts that distinguish it. If your group needs character sheets, campaign logs or rules lookup, this is a rolling and analysis tool rather than a full virtual tabletop.
A practical next step
Take the expression you use most — say a multi-attack sequence or a saving throw with advantage — and enter it to see the distribution. That tells you whether the modifier you were about to add shifts the odds meaningfully or just moves the average. For a broader set of tabletop utilities, Roll20 and AnyDice cover adjacent needs: the former for running games, the latter for deeper probability scripting.
How do I roll dice with advantage or disadvantage?
On dice.run, advantage and disadvantage are handled inside the dice expression rather than as a separate toggle on the result. The site's D&D 5e pack describes a "Roll mode switch — normal / advantage / disadvantage," so the intended workflow is to pick the mode as part of the roll setup, then read the outcome from the audit trail.
dice.run is a dice roller for tabletop RPGs and game design that parses standard notation, keeps full audit trails, and shows probability distributions as you type.
The practical loop
- Enter a dice expression in the input field.
- Set the roll mode to normal, advantage, or disadvantage.
- Check the distribution panel, which shows the mean, the range, and the full distribution for that expression.
- Roll and use the audit trail to confirm which die was kept and which was dropped.
What the mode changes
| Mode | Dice rolled | Result kept | Effect on the odds |
|---|---|---|---|
| Normal | One d20 | That die | Baseline distribution |
| Advantage | Two d20s | Higher | Shifts the curve upward; mid-range results become far more likely |
| Disadvantage | Two d20s | Lower | Shifts the curve downward; the same mid-range clustering applies in reverse |
The distribution view is what makes this useful beyond a single roll. If you are deciding whether a rogue should attack with advantage or spend the turn on something else, or whether an enemy's disadvantage is worth imposing, you can see the actual shape of the outcome instead of reasoning about it abstractly.
A concrete scenario
A DM is running a stealth check where the party's rogue has advantage from a distraction but disadvantage from heavy armor. Rather than adjudicating on the fly, enter the check's dice expression, switch between the three modes, and compare the distributions side by side. The audit trail then documents which die counted, which matters if a player later questions the result.
For anything more elaborate — multi-attack sequences, attack plus damage with a crit on a 20, or saves grouped separately — the D&D 5e (2024) pack on the site already bundles those patterns, so you can import an existing roll instead of rebuilding the notation from scratch. The site's docs hold the full reference for the expression grammar if you need to write something the packs don't cover.
Can I simulate complex dice expressions for game design?
Yes. dice.run is built specifically for this: it parses standard dice notation, rolls with a full audit trail, and shows the exact probability distribution — mean, range, and the full curve — updating as you type. For game design, that combination matters more than the roller itself: you can test whether a mechanic produces the spread you intended, not just whether it produces a number.
What "complex" can mean here
- Standard notation — the usual
NdX+Mforms, so existing habits transfer. - Composed expressions — the page evidence points to things like multi-attack as an array and attack + damage with a crit on a 20, meaning several dice pools can be evaluated together rather than one at a time.
- Conditional modifiers — a roll-mode switch for normal / advantage / disadvantage, which is exactly the kind of mechanic whose true distribution is hard to reason about by hand.
- Custom programs — Studio is described as a place to author dice programs with live distributions, which is the path for mechanics that don't reduce to a single expression.
Where a distribution view earns its keep
Suppose you're designing a "risky attack": on a hit you roll damage, but a natural 1 costs you a resource. Rolling it once tells you nothing. You want the probability of the bad branch, the mean and spread of the good branch, and how both shift when you grant advantage. Typing the expression and reading the distribution as it updates answers that in seconds, and the audit trail lets you show a collaborator exactly which roll produced an outlier during playtesting.
The trade-off is scope. This is a tabletop-focused tool, so it suits designers working in dice-shaped mechanics — RPG systems, board game combat, probability-driven abilities. If your design uses continuous curves, card draws, or resource economies, you'll still need a spreadsheet or a scripting environment; dice.run won't replace those, and its community packs (the page shows D&D 5e 2024 examples grouped by what you're computing — attacks and damage, saves, class features) are organized around that tabletop frame.
A useful next step: open Studio, enter the mechanic you're least sure about — the one with a reroll, a crit, or a conditional — and check whether the mean and range match your design intent before you commit it to a rulebook. If the distribution surprises you, that's the finding.
For broader probability work alongside it, AnyDice covers similar distribution analysis with a different expression language, and Role-playing Games Stack Exchange is where designers often sanity-check whether a mechanic's odds behave as intended.
What probability distributions can I analyze for tabletop RPGs?
dice.run is built around exactly that question: you enter a dice expression, and the tool shows the exact odds — mean, range, and the full probability distribution — as you type. So the practical answer is "any distribution your expression can describe," and the useful part is knowing which ones are worth computing at the table.
Distributions you can actually analyze
- Single-die uniform results — a d20, d6 or d100 where every face is equally likely. Useful for sanity checks, not for much else.
- Sums of dice (bell curves) — 3d6, 2d10, 4d6 drop the lowest. These are the ones players usually care about, because the middle of the range is far more likely than the edges.
- Dice pools and success counting — how many dice beat a target number, as in many d6 and d10 systems. The distribution here is binomial rather than a simple sum.
- Keep/drop and advantage mechanics — "roll twice, take the higher" is a skewed distribution, not a flat one, and it is worth seeing how much it actually shifts your odds.
- Composite rolls — attack plus damage plus a critical, evaluated together rather than as separate steps.
A concrete use case
Imagine a character who attacks twice per round, hits on a 12 or better, and crits on a 20. Rolling the whole sequence as one expression tells you the distribution of total damage per round, not just the average. That is the difference between "about 14 damage" and "you have a real chance of doing nothing this round, and a slim chance of doing 40." The second framing changes how you plan a fight.
Choosing what to compute
| What you want to know | What to set up |
|---|---|
| Average outcome and spread | Sum expression, e.g. a standard damage roll |
| Chance of hitting a threshold | Success-counting pool, or a sum with a target number |
| How much a mechanic helps | Compare the same expression with and without the modifier |
| Worst-case and best-case risk | Look at the tails of the distribution, not the mean |
The trade-off is straightforward: exact distributions are more informative than averages, but they take longer to read mid-session. Use them when you are designing a character, tuning an encounter or writing a house rule; skip them when you just need a number right now.
If you want to see worked examples rather than build them yourself, the site's community packs group common 5e computations — attack and damage together, saves separately, class features on their own — which is a faster way to learn the notation. For the underlying grammar, the documentation is the reference. If you also want a general-purpose roller for quick table use, Roll20 covers that side, though it is a virtual tabletop rather than a probability tool.
How do I create and share custom dice programs?
Creating and sharing a custom dice program on dice.run means writing a dice expression in the roller, checking its probability distribution, then saving it into Studio so others can import it. The site separates two things: rolling (quick one-off expressions) and authoring (Studio, where programs live and can be discovered and imported by the community).
The basic loop
- Type a standard dice expression into the roller — the page's own example is an attack plus damage with a crit on a 20, and it notes that mean, range, and the full distribution appear as you type.
- Adjust the expression until the distribution matches what you intend. This is the real value of authoring here rather than at a physical table: you see the odds before you commit to a mechanic.
- Open the expression in Studio to turn it into a saved program with a live distribution.
- Publish it so it appears in Discover, where other players can import it.
What "sharing" looks like in practice
The Community picks section shows how this plays out. The most imported item is a system pack, "D&D 5e (2024)," with 7 imports, credited to dicerun. Its structure is instructive for anyone building their own pack:
- Group expressions by what the player is trying to compute — attack rolls and damage together, saving throws separately, class-feature one-offs on their own.
- Provide variants rather than one universal roll: the pack lists "Multi-attack as an array," "Attack + damage with crit on a 20," and a "Roll mode switch — normal / advantage / disadvantage."
- Tag it so it is findable (its tags are
dnd5e,dnd,system-pack).
A useful next step: before authoring, decide whether you are sharing a single expression or a pack. A one-off is best for a house rule you want to hand to one table; a pack is worth the effort when your group keeps re-deriving the same set of rolls.
Choosing between a roll and a program
| You want to… | Use | Why |
|---|---|---|
| Resolve one roll right now | The roller | Fastest path; distribution still shows as you type |
| Check whether a mechanic is fair | The roller, then read the distribution | Mean and range tell you if the curve is what you meant |
| Reuse the same roll every session | Studio | Saved, versioned, and importable |
| Hand your whole table's rolls to a new player | A published pack | Groups related expressions and carries tags for discovery |
Practical criteria when authoring
Write expressions so the name explains the intent, not the notation — "Attack + damage with crit on a 20" tells a player when to reach for it; a raw formula does not. Keep a pack's internal grouping consistent, as the D&D 5e pack does, so someone importing it can find saves without reading every entry. If your expression is meant to be switched between normal, advantage, and disadvantage, expose that as a mode rather than three near-identical entries.
For the full expression grammar, the site's own Docs page is the reference to work from. If you also play systems beyond D&D, dice.run is the authoring home for these programs, while general tabletop discussion and system communities elsewhere can help you sanity-check whether a distribution matches the rules as written.
What dice notation does dice.run support?
dice.run parses standard tabletop dice notation and evaluates it live, showing the exact probability distribution as you type. The page describes a full grammar reference in its Docs section, so treat the notation below as the practical shape of what the tool handles rather than an exhaustive list.
Notation you can expect to work
- Basic rolls:
XdYform — roll X dice with Y sides, e.g.3d6for three six-sided dice. - Modifiers: flat arithmetic on the total, e.g.
2d8+3,1d20-1. - Multiple dice groups: combine pools in one expression, e.g.
1d20+2d6+4for an attack plus damage plus a bonus. - Keep/drop and advantage-style mechanics: the community pack for D&D 5e (2024) includes a "roll mode switch — normal / advantage / disadvantage," which is the kind of thing normally expressed as roll-two-take-highest or lowest in notation.
- Crit and repeat constructs: the same pack lists "attack + damage with crit on a 20" and "multi-attack as an array," indicating expressions can encode conditional or repeated rolls rather than just a single sum.
Why the distribution view matters more than the notation
The distinguishing feature is that every expression returns mean, range and the full distribution, not just a number. That changes how you use notation:
| Goal | What to enter | What you get back |
|---|---|---|
| Quick result at the table | 1d20+5 |
One roll plus the odds of each total |
| Compare two builds | 2d6+4 vs 1d12+1 |
Overlapping distributions, so you see which is swingier |
| Check a house rule | 4d6 keep highest 3 |
Whether the average matches what you intended |
For a concrete case: a DM deciding whether a +2 weapon is too strong can type the attack expression with and without the bonus and read the shift in the curve directly, rather than reasoning about it abstractly.
A practical next step
Open the Docs page for the exact grammar before writing anything complex, then test your expression in the roller and confirm the distribution matches your intent. If you are running D&D 5e (2024), start from the community system pack instead of building expressions from scratch — it already groups attack rolls, damage, saves and class-feature one-offs by what you are trying to compute, and it is the most imported pack on the site.
Cloudflare
User reviews (0)