Last Roll
{{ total }}
{{ mean_display }} · σ {{ stdev_display }}
{{ successes }} successes (≥ {{ success_threshold }})
{{ dist_count }} simulations
Expr {{ dice_expr }} d{{ sides }} {{ count }} dies Mod {{ signed(modifier) }} {{ adv_mode==='adv' ? 'Advantage' : 'Disadvantage' }} Exploding Reroll 1s Drop low {{ drop_lowest }} Drop high {{ drop_highest }} Success ≥ {{ success_threshold }} {{ repeat }}× sim Seeded
die(s)
die(s)
≥
×
Field Value Copy
Total {{ total }}
Base sum {{ base_sum }}
Modifier {{ modifier }}
Kept dice {{ kept_count }}
Rolls (kept) {{ kept_rolls_display }}
Rolls (all) {{ all_rolls_display }}
Successes {{ successes }}
Mean {{ mean_display }}
Stdev {{ stdev_display }} 

                

            


        

    

                

                

                    

                        

                            Tags:
                                                            
                                    Game
                                
                                ,                                                             
                                    Randomness
                                
                                                                                    

                        

                            Export to PDF
                            Fullscreen
                        

                    

                

            

        

    


    
    

        

        

            


                

                    

                    
                


                

                

                
            

        

    


    

        

        

            

                
                
                
                
            


            
        

    



    

        

  

  

    Stylized die face with three pips.
  


  
Dice are impartial number generators that return one face per roll, and their totals represent the sum of independent results. Totals help judge difficulty and balance across rules that add, drop, or reroll values.

  
Enter a compact expression and choose optional rules such as advantage or disadvantage so the final outcome reflects your table’s style. You may also count successes above a threshold and repeat runs to see typical behavior.

  
You provide the expression and any rule toggles, and you receive a total with the kept rolls and an optional success count. With many repeats you also see average and spread, which makes side by side comparisons straightforward.

  
For a quick check, try four d six and drop the lowest die, then compare with adding a small modifier to see how the shape of results moves. If you want the same run again, set a seed first.

  
Random streaks happen and short trials can mislead, so use larger repeat counts for steadier insight. Treat high or low outliers as part of normal variation rather than proof of bias.






  
Technical Details:


  
Each die is modeled as a discrete uniform variable on the integers from 1 to sides. A pool of count dice is rolled, option rules are applied per die, selected dice are kept, and a constant modifier is added to form the total. When repeats are requested, independent totals are collected to summarize central tendency and spread.

  
The tool computes a total T from kept dice and a success count when a threshold is set. Across repeated trials it reports the arithmetic mean and the population standard deviation so you can read typical level and variability. These summaries describe the outcomes, not player skill or story impact.

  
Results do not include category bands. Interpret higher means as stronger totals and larger standard deviations as more swing. Near any threshold, results can flip with small changes, so compare distributions rather than a single run.

  
Comparisons are most valid when expressions and options match except for the rule you are testing. Seeding fixes the sequence for reproducible checks; without a seed, results differ each time by design.


  

    
      
        T
        =
        
          ∑
          i=1
        
        ri
        ·
        ki
        +
        m
      
    
  


  

    

      
      
        

          Symbol
          Meaning
          Unit/Datatype
          Source
        

      
      
        
nNumber of dice in the poolintegerInput

        
sSides per dieintegerInput

        
mModifier added to the sumintegerInput

        
riResult for die i after rerolls and explosionsintegerDerived

        
kiKeep indicator for die i (1 kept, 0 dropped)0 or 1Derived

        
tSuccess threshold per kept dieintegerInput

        
TTotal after modifierintegerDerived

        
RRepeat count for simulationsintegerInput

        
μMean of totals over repeatsnumberDerived

        
σPopulation standard deviation of totalsnumberDerived

      
    

  


  

    Worked example: Expression three d six plus two, drop lowest one, no explosions, reroll ones, threshold five, single run. Suppose rolls are [1→4], [6], [2]. Sorted values are 2, 4, 6, so drop 2 and keep 4 and 6. Base sum is 10 and the total is 12 after the modifier. One kept die meets the threshold. A different run may produce very different totals; larger repeat counts reveal the typical level.
  


  
Computation pipeline:

  
    
    
  1. Parse an expression NdS+M into count, sides, and modifier.
    2. 
    
  2. Roll each base die once; if reroll ones is on, reroll a one once and keep the new face.
    3. 
    
  3. If explosions are on, add extra rolls each time the last face equals s until it does not.
    4. 
    
  4. Mark drops by value: drop lowest and drop highest as specified.
    5. 
    
  5. Keep the remaining dice, sum kept values, then add the modifier.
    6. 
    
  6. Count successes where kept values are greater than or equal to the threshold.
    7. 
    
  7. If advantage or disadvantage is set, perform two independent totals and keep the higher or lower.
    8. 
    
  8. If repeats are requested, run independent totals R times and compute summary statistics.
    9. 
  


  
Units, precision, and rounding:

  
    
    
  • All dice quantities are integers in counts and sides.
    • 
    
  • Mean and standard deviation display with two decimal places.
    • 
    
  • Number formatting uses the decimal point character.
    • 
    
  • Ties follow the host engine’s toFixed(2) rounding behavior.
    • 
  


  
Validation & bounds extracted from code:

  

    

      
      
        

          Field
          Type
          Min
          Max
          Step/Pattern
          Error Text
          Placeholder
        

      
      
        

          Dice expression
          string
          —
          —
          ^\s*(\d*)\s*[dD]\s*(\d+)\s*(?:([+-])\s*(\d+))?\s*$
          Invalid dice expression.
          e.g., 1d20
        

        
Countinteger110001Count out of range.—

        
Sidesinteger21000001Sides out of range.—

        
Modifierinteger−10 000 00010 000 0001Modifier out of range.—

        
Drop lowestinteger0—1——

        
Drop highestinteger0—1——

        
Success thresholdinteger0—1——

        
Repeatinteger1—1——

        
Advantage modeenum——none, adv, dis——

        
Seedstring——any text——

      
    

  


  
Randomness, seeds, and reproducibility:

  
    
    
  • Without a seed, randomness uses the host environment’s generator.
    • 
    
  • With a seed, a 32‑bit FNV‑1a hash initializes a deterministic pseudo‑random generator.
    • 
    
  • Identical seeds produce identical sequences and totals.
    • 
    
  • The generator is not intended for cryptographic or wagering uses.
    • 
    
  • Sampling is with replacement across repeats, independent between trials.
    • 
  


  
I/O formats:

  

    

      
      
        

          Input
          Accepted Families
          Output
          Encoding/Precision
          Rounding
        

      
      
        

          Dice expression and options
          NdS+M string; integers for options
          Result table
          Integers; mean and stdev with two decimals
          Per toFixed(2)
        

        

          Distribution request
          Repeat ≥ 2
          Histogram
          Integer totals vs counts
          Exact counts
        

        

          Copy/download
          CSV and JSON
          CSV rows; JSON payload
          Strings, numbers, arrays
          Not applicable
        

      
    

  


  
Networking & storage behavior:

  
    
    
  • Processing occurs on the client; no server requests are made by the calculator.
    • 
    
  • Copy to clipboard writes data locally; downloads are generated locally.
    • 
  


  
Performance & complexity:

  
    
    
  • Single run time is proportional to the number of dice and explosion chains.
    • 
    
  • Repeat runs scale linearly with repeat count.
    • 
    
  • Histogram build is linear in the number of totals.
    • 
  


  
Diagnostics & determinism:

  
    
    
  • Identical inputs and seeds yield identical outputs.
    • 
    
  • Changing any option creates a distinct trial.
    • 
  


  
Security considerations:

  
    
    
  • Not suitable for cryptographic randomness or regulated gaming.
    • 
    
  • Avoid sharing sensitive seeds; seeds are plain text.
    • 
  


  
Assumptions & limitations:

  
    
    
  • Dice are assumed fair and independent.
    • 
    
  • Explosions continue while the last face equals the maximum.
    • 
    
  • Drop counts exceeding available dice are effectively limited by the pool size.
    • 
    
  • Success threshold applies after drops and rerolls.
    • 
    
  • Advantage and disadvantage apply to the entire expression.
    • 
    
  • Mean and standard deviation summarize totals only, not per‑die values.
    • 
    
  • Heads‑up Very large repeat counts can slow rendering.
    • 
    
  • Heads‑up Extremely large sides may produce wide histograms.
    • 
  


  
Edge cases & error sources:

  
    
    
  • Malformed expressions are rejected by the parser.
    • 
    
  • Out‑of‑range counts, sides, or modifier trigger explicit errors.
    • 
    
  • All dice dropped yields a total equal to the modifier.
    • 
    
  • Threshold zero disables success counting.
    • 
    
  • Reroll ones applies only once per die.
    • 
    
  • Explosions may add several extra rolls on streaks of maximum faces.
    • 
    
  • Floating point display of summaries can differ by environment.
    • 
    
  • Very small repeat counts produce volatile means and deviations.
    • 
    
  • Sorting for drops is by per‑die sum after rerolls and explosions.
    • 
    
  • Advantage or disadvantage requires two full evaluations of the same expression.
    • 
  


  
Privacy & compliance:

  
No data is transmitted or stored server‑side. Outcomes are purely random and have no monetary value.






  
Step‑by‑Step Guide:

  
Dice totals and success counts are produced from a compact expression and optional rules.

  
    
    
  1. Enter an expression NdS+M such as 3d6+2.
    2. 
    
  2. Choose advantage mode if needed.
    3. 
    
  3. Toggle explosions or reroll ones to match your rule set.
    4. 
    
  4. Set drop lowest and drop highest counts if you keep only part of the pool.
    5. 
    
  5. Enter a success threshold to count kept dice meeting the level.
    6. 
    
  6. Set repeat for simulations and add a seed for reproducible runs.
    7. 
    
  7. Run the roll and review total, kept values, successes, and summaries.
    8. 
  

  
Example: 4d6, drop lowest one, repeat 200, seed alpha. Compare with adding two to see how averages shift.

  
    
    
  • Use larger repeats for steadier averages.
    • 
    
  • Keep options the same when comparing two rules.
    • 
  






  
FAQ:


  

    Are the rolls fair?
    
Faces are sampled with equal chance per die. With a seed set, the same sequence is reproduced exactly; without a seed, each run is independent.

    Fairness refers to the sampling model, not physical dice.
  


  

    What does advantage do?
    
Two independent totals are computed and the higher one is kept. Disadvantage keeps the lower one. The option applies to the whole expression.

  


  

    How do I roll 4d6 drop lowest?
    
Enter 4d6 and set drop lowest to one. Run once for a single outcome or add repeats to see the distribution.

  


  

    How accurate are mean and stdev?
    
They are exact for the simulated totals. With small repeat counts, results vary; larger repeats reduce noise.

  


  

    Is any data stored?
    
No. Results are computed on the client and copies or downloads are created locally.

  


  

    Can I use decimals?
    
No. Dice counts, sides, modifier, and thresholds are integers. The summaries use two decimal places for display.

  


  

    How many dice can I roll?
    
Counts from 1 to 1000 are accepted. Each die must have 2 to 100000 sides. Modifier magnitude can be up to 10 000 000.

  


  

    What does a borderline result mean?
    
When a total sits near a target or a die is just below a threshold, small changes can flip outcomes. Compare full distributions, not single runs.

  






  
Troubleshooting:

  
    
    
  • Expression rejected: check NdS+M format and spacing.
    • 
    
  • Totals look too small: confirm drops are not removing most dice.
    • 
    
  • No successes: confirm threshold is not above the die’s maximum.
    • 
    
  • Chart is empty: add repeats of two or more.
    • 
    
  • Different results on rerun: set a seed to reproduce outcomes.
    • 
    
  • Slow updates: reduce repeats or sides to lighten processing.
    • 
  

  





  
Advanced Tips:

  
    
    
  •  Compare two rules by changing one option at a time.
    • 
    
  •  Use seeds to share exact scenarios for discussion.
    • 
    
  •  Thresholds transform pools into success counts for quick checks.
    • 
    
  •  Explosions increase swing; watch the standard deviation.
    • 
    
  •  Drops narrow totals; use them to stabilize outcomes.
    • 
    
  •  Advantage raises averages but also changes the tail shape.
    • 
  






  
Glossary:

  

    
NdS+M

    
Expression for count, sides, and modifier.

    
Exploding die

    
Roll again when the face equals the maximum and add it.

    
Reroll ones

    
If a one appears, reroll once and keep the new face.

    
Drop lowest/highest

    
Remove a set number of lowest or highest dice.

    
Advantage/disadvantage

    
Take the higher or lower of two independent totals.

    
Seed

    
Text that fixes the random sequence for reproducible runs.