Perl 6, 26 bytes

{sum {roll 1..$_:}...*-$_}

Try it online!

Explanation

{                        } # Anonymous block

                  ...      # Sequence constructor

     {roll 1..$_:}         #   Next elem is random int between 1 and n

                           #   (Called as 0-ary function with the original

                           #   $_ for the 1st elem, then as 1-ary function

                           #   with $_ set to the previous elem which

                           #   equals n.)

                     *-$_  #   Until elem not equal to n (non-zero difference)

 sum                       # Sum all elements

Python 2, 66 64 bytes

f=lambda n,c=0:c*(c<n)or c+f(n,randint(1,n))

from random import*

Try it online!

The previous roll is stored in c, allowing us to access it multiple times without having to store it to a variable, which can't be done in a Python lambda. Each recursion, we check if we rolled exploding dice.

c is initialised to zero. While c<n does evaluate to True in the first iteration, luckily the multiplication by c makes it falsey again, allowing the lambda to recurse for the first time.

J, 16 bytes

[(]+$:@[)^:=>:@?

Try it online!

Explanation

The function is a fork of three verbs:

  ┌─ [                   

  │           ┌─ ]       

  │           ├─ +       

  │      ┌────┤     ┌─ $:

──┼─ ^: ─┤    └─ @ ─┴─ [ 

  │      └─ =            

  │                      

  │      ┌─ >:           

  └─ @ ──┴─ ?  

The rightmost verb:>@? performs the dice roll: 1 + a random number in the range $[0,n)$.

The central verb performs the loop check: (]+$:@[)^:=. ^: is the Power conjunction; in this case, because of [, this gets called dyadically, as n (f^:g) roll. When used dyadically, f^:g calls f on both arguments n g roll times. = will yield 1 when roll is n. f (another fork in this case, ] + $:@[) performs the check to reiterate. It adds the roll (] +) to the function called again ($:) with the same input (@[).

Pyth - 12 11 bytes

Uses functional while. I feel like there should be a smarter answer that just simulates the distribution.

-.W!%HQ+hOQ



-         (Q)         Subtract Q. This is because we start Z at Q to save a char

 .W                   While, functionally

  !                   Logical not. In this case, it checks for 0

   %HQ                Current val mod input

  +     (Z)           Add to current val

   h                  Plus 1

    OQ                Random val in [0, input)

Try it online.

R, 41 bytes

function(n)n*rgeom(1,1-1/n)+sample(n-1,1)

Try it online!

Explanation: for a die with $n$ sides, the number of explosions follows a $mathrm{Geometric}left(1-frac{1}{n}right)$ distribution (number of successes before the first failure, where probability of success is $1-frac1n$), which each bring $n$ to the total. The final roll follows a $mathrm{Uniform}(1,2,ldots,n-1)$ distribution which we add to the total.

x86 Machine Code (for Intel Ivy Bridge and later), 17 bytes

31 C9 0F C7 F0 31 D2 F7 F6 42 01 D1 39 F2 74 F2 C3

The above bytes of code define a function that simulates an exploding die. It takes a single input, passed in the ESI register, indicating the maximum number of the die. It returns a single value in the ECX register, which is the result of the rolls.

Internally, it uses the RDRAND instruction to generate a random number. This uses a random number generator (RNG) that is built into the hardware on Intel Ivy Bridge processors and later (some AMD CPUs also support this instruction).

The logic of the function is otherwise quite straightforward. The generated random number is scaled to lie within the desired range using the standard technique ((rand % dieSize) + 1), and then it is checked to see if it should cause an explosion. The final result is kept in an accumulator register.

Here is an annotated version showing the assembly language mnemonics:

           unsigned int RollExplodingDie(unsigned int dieSize)

31 C9        xor     ecx, ecx    ; zero-out ECX, which accumulates the final result

           Roll:

0F C7 F0     rdrand  eax         ; generate a random number in EAX

31 D2        xor     edx, edx    ; zero-out EDX (in preparation for unsigned division)

F7 F6        div     esi         ; divide EDX:EAX by ESI (the die size)

                                 ;   EAX receives the quotient; EDX receives the remainder

42           inc     edx         ; increment the remainder

01 D1        add     ecx, edx    ; add this roll result to the accumulator

39 F2        cmp     edx, esi    ; see if this roll result should cause an explosion

74 F2        jz      Roll        ; if so, re-roll; otherwise, fall through

C3           ret                 ; return, with result in ECX register

I am cheating a bit. All standard x86 calling conventions return a function's result in the EAX register. But, in true machine code, there are no calling conventions. You can use any registers you want for input/output. Using ECX for the output register saved me 1 byte. If you want to use EAX, insert a 1-byte XCHG eax, ecx instruction immediately before the ret instruction. This swaps the values of the EAX and ECX registers, effectively copying the result from ECX into EAX, and trashing ECX with the old value of EAX.

Try it online!

Here's the equivalent function transcribed in C, using the __builtin_ia32_rdrand32_step intrinsic supported by GCC, Clang, and ICC to generate the RDRAND instruction:

#include <immintrin.h>



unsigned int RollExplodingDie(unsigned int dieSize)

{

    unsigned int result = 0;

Roll:

    unsigned int roll;

    __builtin_ia32_rdrand32_step(&roll);

    roll    = ((roll % dieSize) + 1);

    result += roll;

    if (roll == dieSize)   goto Roll;

    return result;

}

Interestingly, GCC with the -Os flag transforms this into almost exactly the same machine code. It takes the input in EDI instead of ESI, which is completely arbitrary and changes nothing of substance about the code. It must return the result in EAX, as I mentioned earlier, and it uses the more efficient (but larger) MOV instruction to do this immediately before the RET. Otherwise, samezies. It's always fun when the process is fully reversible: write the code in assembly, transcribe it into C, run it through a C compiler, and get your original assembly back out!

R, 47 42 bytes

function(n){while(!F%%n)F=F+sample(n,1)

F}

Try it online!

Credit to ArBo's approach.

Still a byte longer than Robin Ryder's, go upvote his!

Wolfram Language (Mathematica), 50 bytes

R@#//.x_/;x~Mod~#==0:>x+R@#&

R=RandomChoice@*Range

Try it online!

Python 3, 80 bytes

import random as r,math

lambda n:int(-math.log(r.random(),n))*n+r.randint(1,n-1)

Try it online!

Ruby, 35 bytes

->n,s=0{s+=x=1+rand(n);x<n||redo;s}

Try it online!

Python 3, 81 72 bytes

from random import*

def f(x,a=0):

 while a%x<1:a+=randint(1,x)

 return a

Try it online!

-9 bytes thanks to ArBo

Explanation

import random             #load the random module              

def explodeDice(num):     #main function

    ans = 0                     #set answer to 0

    while a % num != 0:         #while a isn't a multiple of the input

        ans += random.randint(1, num) #add the next dice roll to answer

    return ans                  #return the answer

JavaScript (ES6), 39 bytes

f=n=>(x=Math.random()*n+1|0)<n?x:x+f(n)

Try it online! or See the distribution for n=4

><>, 90 bytes

0&  v

v:::<             <

v/1>{1-:?!v}

>x0^v10~  <

 ^

5=?v>:@}}*{+{2*l

&n;>,*:1%-1+:&+&=?^

Try it online!

The whitespace on the second line is bugging me. I'll work on golfing that out.

><> doesn't have a nice method for producing uniform random integers. This approach generates, for input $N$, a random number produced by generating $N$ random bits, then taking the resulting binary integer and dividing it by $2^N$. This process is repeated until $N$ is not generated by this process.

Attache, 30 bytes

f:=${If[x=y,f@x+y,y]}#1&Random

Try it online!

Direct implementation of the process.

Alternatives

36 bytes: ${NestWhile[{_+Random[1,x]},x&`|,0]}

37 bytes: ${NestWhile[{_+Random[1,x]},{x|_},0]}

C (gcc), 36 bytes

f(n,x){x=rand()%n+1;x=x-n?x:x+f(n);}

Try it online!

Here a Test with 100k d4

Excel VBA, 108 bytes

Function z(i)

v = Int((i * Rnd) + 1)

z = v

Do While v = i

v = Int((i * Rnd) + 1)

z = z + v

Loop

End Function

Perl 6, 26 bytes

{[+] {^$_ .roll+1}...$_>*}

Try it online!

Python 3, 80 bytes

This is pretty much just a tail-call recursive version of @Artemis Fowl's answer, but I liked doing it without unrolling into a while loop.

Uses an accumulator parameter to return the total rolled value once the exploding stops.

from random import*

def r(n,a=0):v=randint(1,n);a+=v;return r(n,a)if v==n else a

PowerShell, 49 bytes

for($a=$l="$args";$a-eq$l){$o+=$l=1..$a|Random}$o

Try it online!

Iterative method. Sets the input $args to $a and the $last roll (done so we enter the loop at least once). Then, so long as the last roll is -equal to the input, we keep rolling. Inside the loop we accumulate into $o the last roll, which is updated by creating a range from 1 to input $a and picking a Random element thereof. (Honestly, I'm a little surprised that $o+=$l= works.) Once we're out of the loop, we leave $o on the pipeline and output is implicit.

Forth (gforth), 72 bytes

include random.fs

: f >r 0 begin i random 1+ >r i + r> i < until rdrop ;

Try it online!

Code Explanation

include random.fs       include library file for random

: f                     start a new word definition

  >r                    stick the input on the return stack (for easy access)

  0                     add a counter to hold the sum

  begin                 start an indefinite loop

    i random 1+         generate a random number from 1 to n

    >r i + r>           add the result to the counter, use the return stack to save a few bytes

    i <                 check if result was less than n

  until                 end the loop if it was, otherwise go back to begin

  rdrop                 remove n from the return stack

;                       end the word definition

Charcoal, 17 bytes

ＮθＷ⁼Ｌυ№υθ⊞υ⊕‽θＩΣυ

Try it online! Link is to verbose version of code. Explanation:

Ｎθ

Input n.

Ｗ⁼Ｌυ№υθ

Repeat while the predefined empty list only contains ns (i.e. its length equals its count of ns)...

⊞υ⊕‽θ

... push a random integer from 1 to n to the list.

ＩΣυ

Print the total.

Batch, 70 bytes

@set t=0

:g

@set/at+=d=%random%%%%1+1

@if %d%==%1 goto g

@echo %t%

Takes input n as a command-line parameter %1. d is the current roll, t the cumulative total. Simply keeps rolling until d is not equal to n.

Jelly, 9 bytes

x⁹X€Ä%ƇµḢ

Try it online!

A monadic link that takes n as its argument and returns a number generated by an exploding n-sided die. This generates 256 numbers from 1 to n and returns the first cumulative sum that is not a multiple of n. In theory this could return 256n, but even for a 2-sided die this would happen only one every $2^{256}$ times.

An alternative that doesn’t have this limitation is:

Jelly, 10 bytes

X³X¤+¥³ḍ¥¿

Try it online!

Note both TIO links generate 400 numbers to show the distribution.

C# (Visual C# Interactive Compiler), 60 bytes

int f(int n,int k=1)=>(k=new Random().Next(n)+1)<n?k:k+f(n);

Saved 4 bytes thanks to @ExpiredData!

Try it online!

Haskell, 77 76 bytes

import System.Random

f x=randomRIO(1,x)>>=(x!)

x!y|y<x=pure y|0<1=(y+)<$>f x

Try it online!

Thanks to killmous for one byte.

Haskell, 94 bytes

import System.Random

f n=do

  i<-randomRIO(1,n)

  if i<n

    then return i

    else (i+)<$>f n

Try it online!

Quite similar to @dfeur's, but using do notation.

perl -Minteger -pe, 34 bytes

$s+=1+rand$_;$s%$_||redo;$_=$s

TI-BASIC, 28 23 bytes

-5 bytes thanks to this meta post!

Ans→N:0:Repeat fPart(Ans/N:Ans+randInt(1,N:End:Ans

Input is in Ans.

Output is in Ans and is implicitly printed.

Examples:

4

              4

prgmCDGF11

              5

6

              6

prgmCDGF11

              3

Explanation:

Ans→N:0:Repeat fPart(Ans/N:Ans+randInt(1,N:End:Ans   ;full logic



Ans→N                                                ;store the input in "N"

      0                                              ;leave 0 in "Ans"

        Repeat fPart(Ans/N                 End       ;loop until the sum

                                                     ; is not a multiple of

                                                     ; the input

                               randInt(1,N           ;generate a random

                                                     ; integer in [1,N]

                           Ans+                      ;then add it to "Ans"

                                               Ans   ;leave the sum in "Ans"

                                                     ;implicitly print "Ans"

Notes:

• TI-BASIC is a tokenized language. Character count does not equal byte count.

Jelly, 7 bytes

X+ß}¥=¡

Try it online!

Uses recursion. Runs the program again (ß) and adds (+) if (¡) the random number (X) is equal (=) to the program input. } makes ß act on the program input and ¥ combines +ß} into a single link for ¡ to consume.

Here a distribution of 1000 outputs for n=6 which I collected using this program. Plotted with python/matplotlib.

Here is a 5000 data points from n=3 on a semilog plot which shows the (approximately?) exponential distribution.

APL (Dyalog Unicode), 15 14 bytes

{×r←?⍵:r⋄⍵+∇⍵}

Try it online!