text:
Simulating Exploding Dice
Your task is to make a program that takes in an integer n > 1, and outputs the roll of a single n-sided die. However, this dice follows the rules for exploding dice.
When you roll the die, check what value you rolled. If you got the maximum for that kind of die (on a standard d4 that would be 4, or 6 on a d6, etc.), roll again and add the new roll to that total. Each roll continues adding to the total, until you don't roll the max number anymore. That final number is still added though.
Your program should take in a single integer n, and roll the exploding n-sided die. Here's an example distribution to show what it should look like for n=4. Note that you should never output any multiples of n, since they will always explode.
You can assume the stack size for any recursion you do is infinite, and your random function must meet our standards for randomness (built-in random generator or time/date). Your random function should also be as uniform as possible, vs. something like a geometric distribution, since these are dice we're talking about.

does the program have to be perfect? Like can its distribution be off by some extremely low amount?

To: Riker; RE: @Maltysen's comment above; or extremely high amount?

@ArtemisFowl See our standards for randomness. Also, here.

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, 39 bytes
n=scan();n*rgeom(1,1-1/n)+sample(n-1,1)

Try it online!
Explanation: this solution avoids recursion/while loops by directly calculating the distribution of the number of explosions that will occur. Let \$n\$ be the number of sides on the die. If you denote success as rolling an \$n\$ and failure as rolling anything else, then you have probability \$\frac1n\$ of success. The total number of explosions is the number of successes before the first failure. This corresponds to a \$\mathrm{Geometric}\left(1-\frac{1}{n}\right)\$ distribution (see the wikipedia page, which defines success and failure the other way round). Each explosion brings \$n\$ to the total. The final roll follows a \$\mathrm{Uniform}(1,2,\ldots,n-1)\$ distribution which we add to the total.

very nice! Gotta love the builtin distributions for [tag:random] challenges!

Does sample meet the standards for randomness, given its bias?

@Xi'an Pretty sure it does: it is the built-in random generator for discrete random variables.

I know, I know, but check the link I put: the discretisation inherent to sample leads to a lack of uniformity that gives a ratio of max to min probability as high as 1.03... Shocking, isn't it?!

Yes, it is shocking. But then again, how often do you use sample with $m\approx 2^{31}$? ;-)

Python 2, 66 64 61 bytes
-3 bytes thanks to xnor
f=lambda n,c=0: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, so c%n is falsey there. In the next iterations, it will only be falsey if exploding dice were rolled.
Python 2, 55 bytes
f=lambda n:randint(1,n)%n or n+f(n)
from random import*

Try it online!
My other answer seems to be a bit overengineered, since this appears to work as well... I'll leave it anyway.

Recursive functions where the breaking condition is based on randomness will always have a non-zero chance of stack overflow. Statistically insignificant chance, but still...

Typically, stack size is assumed to be infinite in code golfing challenges in my experience. As the stack size increases to infinity, the likelihood of stack overflow quickly converges to zero.

ArBo do @mypetlion before you type in your comment so you can ping the user

I think c*(c<n) can be c%n.

@xnor Of course, I'm an idiot...

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

Nice, my own solution was {sum roll(*,1..$_)...$_>*}

J, 16 11 bytes
(+$:)^:=1+?

Try it online!
Explanation
TL;DR 1+? performs the die roll, (+$:)^:= reiterates only when it equals the input.

The function is a train of 4 verbs:
             ┌─ +
         ┌───┴─ $:
  ┌─ ^: ─┴─ =
  │
──┤      ┌─ 1
  └──────┼─ +
         └─ ?

A train is when 2 or more verbs are concatenated. Here, the answer is of the form f g h j:
(+$:)^:=  1  +  ?
    f     g  h  j

A so-called "4-train" is parsed as a hook and a fork:
f g h j   ⇔   f (g h j)

Thus, the answer is equivalent to:
(+$:)^:= (1 + ?)

Hooks: (f g) x and x (f g) y
A monadic (one-argument) hook of two verbs, given an argument x, the following equivalence holds:
(f g) x   ⇔   x f (g x)

For example, (* -) 5 evaluates to 5 * (- 5), which evaluates to _25.
This means that our 4-train, a hook of f and (g h j), is equivalent to:
(f (g h j)) x   ⇔   x f ((g h j) x)

But what does f do here? (+$:)^:= is a conjunction of two verbs using the Power conjunction ^:: another hook ((+$:)) and a verb (=). Note here that f is dyadic—it has two arguments (x and (g h j) x). So we have to look at how ^: behaves. The power conjunction f^:o takes a verb f and either a verb or a noun o (a noun is just a piece of data) and applies f o times. For example, take o = 3. The following equivalences holds:
(f^:3) x     ⇔   f (f (f x))
x (f^:3) y   ⇔   x f (x f (x f y))

If o is a verb, the power conjunction will simply evaluate o over the arguments and use the noun result as the repeat count.
For our verb, o is =, the equality verb. It evaluates to 0 for differing arguments and to 1 for equal arguments. We repeat the hook (+$:) once for equal arguments and no times for differing ones. For ease of notation for the explanation, let y ⇔ ((g h j) x). Remember that our initial hook is equivalent to this:
x   (+$:)^:=   ((g h j) x)
x   (+$:)^:=   y

Expanding the conjunction, this becomes:
x ((+$:)^:(x = y)) y

If x and y are the same, this becomes:
x (+$:)^:1 y   ⇔   x (+$:) y

Otherwise, this becomes:
x (+$:)^:0 y   ⇔   y

Now, we've seen monadic forks. Here, we have a dyadic fork:
x (f g) y   ⇔   x f (g y)

So, when x and y are the same, we get:
x (+$:) y   ⇔   x + ($: y)

What is $:? It refers to the entire verb itself and allows for recursion. This means that, when x and yare the same, we apply the verb toyand addx` to it.
Forks: (g h j) x
Now, what does the inner fork do? This was y in our last example. For a monadic fork of three verbs, given an argument x, the following equivalence hold:
(g h j) x   ⇔   (g x) h (j x)

For this next example, suppose we have verbs named SUM, DIVIDE, and LENGTH, which do what you suppose they might. If we concatenate the three into a fork, we get:
(SUM DIVIDE LENGTH) x   ⇔   (SUM x) DIVIDE (LENGTH x)

This fork evaluates to the average of x (assuming x is a list of numbers). In J, we'd actually write this as example as +/ % #.
One last thing about forks. When the leftmost "tine" (in our symbolic case above, g) is a noun, it is treated as a constant function returning that value.
With all this in place, we can now understand the above fork:
(1 + ?) x   ⇔   (1 x) + (? x)
            ⇔   1 + (? x)

? here gives a random integer in the range \$[0,x)\$, so we need to transform the range to represent dice; incrementing yields the range \$[1, x]\$.
Putting it all together
Given all these things, our verb is equivalent to:
((+$:)^:=1+?) x   ⇔   ((+$:)^:= 1 + ?) x
                  ⇔   ((+$:)^:= (1 + ?)) x
                  ⇔   x ((+$:)^:=) (1 + ?) x
                  ⇔   x ((+$:)^:=) (1 + (? x))
                  ⇔   x (+$:)^:(x = (1 + (? x))
(let y = 1 + (? x))
if x = y          ⇒   x + $: y
otherwise         ⇒   y

This expresses the desired functionality.

(+$:)^:=1+?

@ngn Thanks! Incorporated.

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.

Nice plots! The distribution you get is a geometric distribution (see my R answer), which is closely related to the exponential distribution.

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.

Japt, 12 bytes
It may be shorter than dana's solution, but it's a hell of a lot uglier. I'm only posting it 'cause it seems like forever since we had a Japt solution that started with an empty line.

ö
>°V©VªV+ß
Try it

JavaScript (ES6),  39  30 bytes
Saved 9 bytes thanks to @tsh!
f=n=>Math.random()*n|0||n+f(n)

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

30 bytes, f=n=>Math.random()*n|0||n+f(n)

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!

There's a slight chance for failure if r.random() happens to return 0. 1-r.random() should work, though.

Though technically that chance is 0

A rare case where import ... as _ is shortest!

@xnor indeed! The only other time I remember that winning out in an answer of mine is here

05AB1E, 10 bytes
[ILΩDIÊ#}O

Try it online or verify the lists.
10 bytes alternative:
[LΩDˆÊ#}¯O

Try it online or verify the lists.
Although I like the top one more because it got the 'word' DIÊ in it, which suits the challenge.
Explanation:
[         # Start an infinite loop:
 IL       #  Create a list in the range [1, input]
   Ω      #  Pop and push a random value from this list
    D     #  Duplicate it
     IÊ   #  If it's NOT equal to the input:
       #  #   Stop the infinite loop
}O        # After the loop: sum all values on the stack
          # (which is output implicitly as result)

[         # Start an infinite loop
 L        #  Create a list in the range [1, (implicit) input]
  Ω       #  Pop and push a random value from this list
   Dˆ     #  Add a copy to the global_array
     Ê    #  If it's NOT equal to the (implicit) input:
      #   #   Stop the infinite loop
}¯        # After the loop: push the global_array
  O       # Pop and push its sum
          # (which is output implicitly as result)

Was trying to think of a way to use .Γ or something.

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!

Interesting, I reworked this to a recursive if for 46 bytes, but ended up getting a 52 on one roll which shouldn't be possible with n=4, so I don't know if there's a weird low recursion limit thing happening, but I think it may be buggy. Try it online!

I tried a recursive and got a 54 byte solution. Then tried something similar to yours for 44 Try it online!

Wolfram Language (Mathematica), 50 bytes
R@#//.x_/;x~Mod~#==0:>x+R@#&
R=RandomChoice@*Range

Try it online!

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

Try it online!

Save a byte by dropping the x variable: 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.
If <|> were in the prelude, we could do better with MonadComprehensions:
Haskell, non-competing, 66 bytes
import System.Random
f x=do y<-randomRIO(1,x);[y|y<x]<|>(y+)<$>f x

Try it online!

You can save a byte if you define g as an infix function.

@killmous, thanks. At first glance I figured that would be the same or worse, but it's better.

Haskell, 94 81 78 bytes
import System.Random
f n=do i<-randomRIO(1,n);last$((i+)<$>f n):[return i|i<n]

Try it online!

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

-13 bytes by removing whitespace, thanks to @dfeuer
-3 bytes thanks to this

81 bytes

Wuups, fixed the typo! And thanks for the suggestion :)

APL (Dyalog Unicode), 15 14 bytes
{×r←?⍵:r⋄⍵+∇⍵}

Try it online!

Python 2, 53 bytes
f=lambda n:random()*n//1or n+f(n)
from random import*

Try it online!
Uses the or short-circuiting idea from ArBo's answer. The expression random()*n//1 generates a number from 0 to n-1, with 0 taking the place of a roll of n. The or takes the that number, except if it's zero (Falsey) it continues on to n+f(n).

It seems your answer was already up when I edited in my shorter one... I didn't see this, but if you want me to delete it because it's quite alike I will.

@ArBo Not at all, independently duplicated answers are fine.

Japt, 13 bytes
ö)g@¶°X?X+ß:X

Try it
Port of Arnauld's answer. Figured out how to make a recursive call ;)
Transpiled JS:
// U: Implicit input
// ö: generate a random number [0,U)
(U.ö())
  // g: run the result through a function
  .g(function(X, Y, Z) {
    // increment the result and compare to input
    return U === (++X)
      // if they are the same, roll again and add to current roll
      ? (X + rp())
      // if they are different, use current roll
      : X
   })

Very nice use of N.g(f) :)

Took a stab at this meself and ended up with 12 bytes but I don't want to post it 'cause I like your solution too much!

Post it as a different answer :)

It may be shorter, but it's a hell of a lot uglier than yours: https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=CvYKPrBWqVaqVivf&input=Ng

I see - yeah I was trying to come up with a way not to pollute U. Skipping a line seems to work as well. That's a good trick :)

When ETH first added support for multi-line programmes, starting a programme with an empty line used to be a lot more common. If I remember rightly, Oliver was particularly fond of that trick.

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

You can save 1 byte by using from random import* instead.

You can get this down to 74 bytes using this recursive solution

@squid You can save 1 byte like this.

@orthoplex and then you can shorten the if/else, and make it a one-liner. Starts to look like my solution then ;)

@ArBo Yea that's why I didn't change to recursive, didn't want to just copy you.

@squid [see above] ... should've said that, slipped my mind sorry

@ArtemisFowl Thanks for that... if you want, here's a non-recursive golf of your answer :)

@ArBo Added, explanation coming later,

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

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.

Since startTmr is no longer necessary, this submission will now work for versions of TI-BASIC earlier than the TI-84+

Excel VBA, 46 bytes
Thanks to @TaylorRaine
Do:v=-Int(-[A1]*Rnd):t=t+v:Loop While[A1]=v:?t

Executed in the command window.
As a user-defined function.
Excel VBA, 108 67 bytes
Function z(i)
Do
v=Int((i*Rnd)+1)
z=z+v
Loop While v=i
End Function

You can get this down quite a bit by using a do..loop while loop, and converting the function into an immediate window function. - Do:v=-Int(-[A1]*Rnd):t=t+v:Loop While[A1]=v:?t - 46 Bytes

@TaylorScott Thanks, I forgot that Do x While y existed in Excel VBA.

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.

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.

SmileBASIC 3, 49 bytes
Function D N OUT R implements exploding dice rolls recursively.
DEF D N OUT R
R=RND(N)+1IF R==N THEN R=R+D(N)
END

Ungolfed
DEF D N OUT R  'N is sides and R is output param (shorter than using RETURN in this case)
 R=RND(N)+1  'random number in [1, N]
 IF R==N THEN R=R+D(N)  'if roll is same as N then roll again and add
END

Note that in SmileBASIC, functions can have multiple return values. If a function has one return value then fun in OUT var and var = fun(in) are exactly the same, which is why we can define the function in OUT form and also call it in an expression in the function body itself. If I had defined the function as DEF D(N) I would have to explicitly state RETURN R in the function body; mixing both syntaxes saved me bytes.

PowerShell, 43 bytes (Iterative method)
param($n)do{$x+=1..$n|random}until($x%$n)$x

Try it online!

PowerShell, 48 bytes (recursive method)
filter f{if($_-eq($x=1..$_|random)){$x+=$_|f}$x}

Try it online!

Jelly, 7 bytes
X=Ð¿⁸S_

A monadic Link accepting an integer, n, which yields an integer.
Try it online! Or see the counts of \$10^5\$ runs
How?
X=Ð¿⁸S_ - Link: integer, n
  Ð¿    - Collect up while...
 =  ⁸   - ...condition: equal to chain's left argument, n
X       - ...next value: random number in [1..n]
     S  - sum
      _ - subtract n (since the collection starts with [n])

SmileBASIC, 41 bytes
INPUT N@L
S=S+RND(N)+1ON S MOD N GOTO@L?S

After reading:

Note that you should never output any multiples of n, since they will always explode.

I realized that rather than checking if a dice roll was n, you can just repeat while the sum is a multiple of n.

Octave/MATLAB with Statistics Package/Toolbox, 30 bytes
@(n)geornd(1-1/n)*n+randi(n-1)

Try it online!
How it works
This is an anonymous function which takes n as input and produces a number obtained as follows. The function generates a geometric random variable with parameter 1-1/n (this models the number of rolls that produce n), multiplies by n, and adds a random variable uniformly distributed from 1 to n-1 (this models the last roll).

AnyDice, 36 bytes
Almost a built-in in the language:
function:f I:n{result: [explode dI]}

For this to be correct I have to abuse the infinite recursion depth assumption.
AnyDice limits the recursion depth with a global property maximum function depth.
the explode builtin however uses it's own; explode depth - which defaults to 2.
set "explode depth" to 99

Would add another 25 bytes; and would not really match the requirements since it's theoretically possible for a dice to explode more than 99 times.
The output of the function is a die, ie. an AnyDice built-in type that is a paring of results and probabilities for the result.

I think I'm OK with it not exploding much, the 36 byte one is fine by me. I didn't say no builtins and I'm ok with having them here, since it's not like your 1 or 0 byte answer is winning. But welcome to the site!

CJam, 19 bytes
qi{__mr)_T+:T;=}g;T

Explanation:
T is pre-set to 0

qi{__mr)_T+:T;=}g;T - whole code
qi                  - read input as integer (n) | Stack: n
  {            }    - block
   __               - Duplicate twice | Stack: n n n
     mr)            - Choose a random number from 1 to n (r). Since 'mr' picks a
                      number from 0 to n-1, the number has to be incremented with ')'
                      Stack: n n r
        _           - Duplicate |  Stack: n n r r
         T          - push T | Stack: n n r r T
          +         - add the random number to T (t) | Stack: n n r t
           :T;      - pop the value and store in T | Stack: n n r
              =     - are the top two stack values the same (c) | Stack: n c
               }
                g   - do while loop that pops the condition from the stack after each
                      iteration | Stack: n
                 ;  - pop the top stack element and discard | Stack: T
                  T - push T | Stack: T
                    - implicit output

Or in pseudocode:
input n
var sum = 0
do {
    var random_number = pick random number from 1 to n
    sum = sum + random_number
} while (random_number == n)
output n

As a flowchart:

Try it online!

Excel (pure), 43 bytes
=A1*INT(-LOG(RAND(),A1))-INT(RAND()*(1-A1))

Takes input from A1, outputs in the cell you put this formula.
Explanation
This uses the observation from Robin Ryder's R solution that the requested distribution is the sum of n times a Geom(1-1/n) and an independent Uniform(1..n-1) distribution. The clever bit is that
INT(-LOG(RAND(),A1))

uses a logarithm to scale a Uniform(0,1) distribution exactly to the desired geometric distribution: for instance, with A1=6, the LOG maps the interval (1/6,1) to the interval (-1,0), the interval (1/36,1/6) to the interval (-2, -1), and so on. I also save a +1 on the uniform distribution by scaling a random number "backwards" to (1-A1, 0), then subtracting the floor of this negative number.

Vyxal, 25  10 bytes
λ?:ɾ℅~=[x+

Try it Online!
-15 thanks to Aaron Miller. This is a fully functional program as lambdas are automatically called at the end.

recursion would probably make this simpler.

@Razetime Yes probably, I'll try

11 bytes with recursion

@AaronMiller  10  as you can close the if in the footer.

Ok, I wasn't sure. I haven't really done many submissions that were just functions. Thanks for saying so!

@Ausername I don't think a function submission in Vyxal is allowed to use auto-closing. It looks like a lambda is even incomplete without closing ;, so the current submission should be 12 bytes. A function should be reusable, which is not satisfied until it is actually pushed to the stack and more commands are allowed to come after it.

@Bubbler I'll ask lyxal

@Bubbler Ok, edited

Now that lambdas are ran automatically when being printed, this is a valid full program submission for 10 bytes.

@AaronMiller Thanks

><>, 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.

Compression to 72 bytes.

C (gcc), 36 32 bytes
-4 bytes thanks to Ben Voigt
f(n,x){x=rand()%n;x=x?x:n+f(n);}

Try it online!
Here a Test with 100k d4

Shouldn't srand(time(0)) be included in the byte count?  AFAIK rand() will always return the same value if it was never seeded

I'm not entirely sure, but I remember the meta consensus being that using an unseed PRNG is acceptable @Tau

@ConorO'Brien i was looking on the meta and i found this: https://codegolf.meta.stackexchange.com/questions/15025/what-are-the-standard-requirements-for-answering-a-random-challenge

@GiacomoGarabello I'm 100% ok with a non-seeded PRNG, and it's allowed by our rules on randomness I believe.

This is not even close to being C code.  Your recursive call has the wrong number of parameters, and you are missing a return.

Also, +1 and comparison to n aren't needed, this is perfectly valid: f(n){int x=rand()%n;return x?x:n+f(n);}

@BenVoigt that is the exact reason why I love to golf in C. If you try with your GCC compiler (or the TIO link) you can see it works correctly! Also, thanks for the tip!

Even on gcc it returns 0 all the time (if compiled with -O3) or total garbage (if compiled with -O1).  If you have optimization-unstable code that depends on particular compile settings, that should be mentioned.

@BenVoigt unless mentioned in the post, it is assumed compilers use default options. The default for gcc is -O0, which works perfectly fine for this code. The purpose of codegolfing is to write code in as few bytes as possible, not write functional, production-ready code. If it works, it works.

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]}

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

I don’t think python does tail-call optimization, does it?  Regardless, good answer anyways!

Unfortunately not. I've heard that Guido doesn't want python to turn into a functional language

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.

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!

60 bytes

@ExpiredData Using new Random() gives it the same seed if you call it again, which doesn't make it truly random

Nah it's a new seed, run my tio a few times. But even if it was same seed random() isn't true random anyway it's a prng....

I've noticed when running on TIO, you either get values less than n or way, way, higher. I think creating a new Random in a tight loop causes the same seed to be used? In any case, this might save a byte? int f(int n,int k=1)=>(k+=new Random().Next(n))<n?k:k+f(n);

This is longer, but seems to give better results? var r=new Random();int k;int f(int n)=>(k=r.Next(n)+1)<n?k:k+f(n);

Perl 6, 25 bytes
{sum {.rand+|0+1}...$_>*}

Try it online!

F#, 83 bytes
let r=System.Random()
let e d=
 let mutable t=0
 while t%d=0 do t<-t+r.Next(d)+1
 t

Try it online! The first argument in the TIO program is the number of sides on the die, the second is the amount of tests to make. The output is printed to the console and shows each total and the number of times it has been rolled.
The random number generator r is initialised outside of the function. Initialising it within the function, combined with calling this function many times in succession, will cause it to return the same random numbers over and over again (try it for yourself!)
For the life of me I could not figure out how to write this without using mutable, especially since the last roll must be counted (Seq.takeWhile would not include the terminating element). I thought about using Seq.mapFold but it seems like it evaluates the input sequence first, which was a no-go for me.

You're implementing so many extra things.  They don't appear to be in the code you're counting, though, so...okay.

What do you mean by extra things?

"shows ...the number of times it has been rolled", not a requirement.

..You need to roll one exploding die.  Not 10,000.  I'm not sure this is valid...?

The submission does only roll one die. The TIO program demonstrates the function being run 10000 times to show that its results are distributed similar to the example distribution. It's common to have a TIO to show the function being used and that its output is valid. And that is not included in the byte count.

C# (.NET Core), 155 153 145 144 bytes
using C=System.Console;class A{static void Main(){int i=int.Parse(C.ReadLine()),j=0;while((j+=new System.Random().Next(i)+1)%i<1){}C.Write(j);}}

Try it online!
This code instantiates a new RNG every time, but that uses time as a seed anyway so it should still satisfy randomness requirements.
I wonder if console input is cheaper in the long run.

Saved 2 bytes by using [0,i)+1 rather than [1,i+1)

Saved 8 bytes by forgoing principles about RNG and just making a new one in the loop.

Saved one byte w/ <1 instead of ==0

Funky, 38 bytes
f=n=>ifn==x=math.random(n)f(n)+x elsex

Try it online!

Clojure, 63 bytes
#(loop[n 0](let[r(+ n(rand-int %)1)](if(<(- r n)%)r(recur r))))

A naive solution to the problem.
Expanded:
(defn exploding-die [sides]
  (loop [total 0]
    (let [new-total (+ total (rand-int sides) 1)]
      (if (< (- new-total total) sides) new-total
        (recur new-total)))))

Ruby, 28 bytes
f=->n{(a=rand n)>0?a:n+f[n]}

Try it online!

Java (JDK), 61 bytes
int f(int n){int r=1;r+=Math.random()*n;return r<n?r:r+f(n);}

Try it online!

VTL-2, 54 53 51 bytes
1 A=?
2 C=C+B
3 B='/A*0+%+1
4 #=B=A*2
5 ?=C+B

Line 1 takes input into variable A, this will be our die's sidedness. Line 2 does what it appears to, though it's important to note that in VTL-2, referencing a variable that hasn't been initialized assumes 0, so for the first pass, this is C=0+0. Line 3 divides a random number by our dice sides (' is the system variable for a random number) and then turns this into a roll - % is the remainder of the last division operation; add 1 and put this in B. Line 4 is a little cryptic: B=A is evaluated first. It evaluates to 1 if the two are equal (if our die roll is the same as its number of sides), otherwise it evaluates to 0. This result is multiplied by two (*2), and then the final value here is handed to #=, which is equivalent to a GOTO. If this is given a zero, it ignores it; otherwise we GOTO 2, adding the roll to the total and rolling again. Line 6 prints the total of C+B.
Had an epiphany right after posting this, and golfed off one byte. I was doing 3 B='/A and 4 B=%+1 because % is a system variable with the remainder of the last division operation; you need to do a division operation to get that value. But it occurred to me that I could do the division and then multiply that by zero since I don't need it. But since I've done it, the remainder is now in % and so I can add that to the zero I just made, and add 1 to get the die roll. This is long, but still shorter than two lines - line numbers always take two bytes in VTL-2, plus a space to separate the line number, plus a CR.
Second edit, did my math wildly wrong on byte count both times. Eesh. Third, golfed off two leftover parens.

Is this the language from the Altair systems? Google seems to imply so. But this is really cool!

@Rɪᴋᴇʀ Yup! Stumbled across it recently while looking for some totally unrelated 680 info. I'm running the interpreter in an 8800 emulator. It's a very interesting language, a lot of fun design decisions were made to fit it in ~1KB (VTL-1 was closer to ~700B!).

Huh, that's pretty cool. I'm glad you decided to answer my challenge in that language, of all things.

MMIX, 40 bytes (10 instrs)
Assumes TRAP 82,78,71¹ gets a randomly-generated uint64_t, by some method the OS knows about, but we don't have to.
(jxd -T)
00000000: e3010000 f7010000 00524e47 1effff00  ẉ¢¡¡ẋ¢¡¡¡RNGœ””¡
00000010: feff0006 220101ff 22010100 43fffffb  “”¡©"¢¢”"¢¢¡C””»
00000020: 26000100 f8010000                    &¡¢¡ẏ¢¡¡

Disassembled:
expl    SETL $1,0
        PUT  rD,0
0H      TRAP 82,78,71       // loop: tmp = sysrand()
        DIVU $255,$255,0
        GET  $255,rR        // tmp = tmp % n
        ADDU $1,$1,$255
        ADDU $1,$1,$0       // t += tmp + n
        BZ   $255,0B        // if(!tmp) goto loop
        SUBU $0,$1,$0
        POP  1,0            // return t - n

The main hack here is to treat every roll as being in the range \$[n,2n-1]\$, then subtracting \$n\$ once after everything is over.
¹ Yes, those numbers were carefully picked.

Ly, 16 bytes
00ns[p+1l?l=]p+u

Try it online!
This one is pretty much a direct translations of the rules of the challenge.
00n              # Push "0", "0" and the input number on the stack
   s             # Save the input number in the backup cell
    [       ]    # Loop, quits when the random number doesn't match the die size
     p+          # Delete loop iterator check, add the remain two entries
                 # (The stack holds the accumulated value and the last roll)
       1l?       # Generate a random number between 1 and die size, inclusive
          l=     # Compare the random roll to the saved die size
             p+u # Add the last role and print as a number

Thunno 2 s, 6 bytes
($=;$ɼ

Attempt This Online!
Explanation
($=;$ɼ  # Implicit input
(       # (while)
 $=     #   equals input
   ;    # (do)
    $ɼ  #   random item from [1..input]
        # Implicit output of summed stack

Perl 5 -Minteger -p, 25 bytes
1until($\+=1+rand$_)%$_}{

Try it online!

authors: Xi'an ні війні