Glossary

RNG (Random Number Generator)

The algorithm that produces the unpredictable numbers used to determine crash points — in provably fair systems, the RNG output is derived from cryptographic seeds rather than pseudo-random software alone.

RNG is the engine behind every crash game outcome. In traditional software, RNGs use pseudo-random algorithms seeded by system entropy — unpredictable in practice, but not independently verifiable. Provably fair crash games replace this with a cryptographic RNG based on SHA-256 and HMAC functions — auditable by any player.

Types of RNG used in crash games

Pseudo-random number generators (PRNG): Used in many non-provably-fair games. Software algorithms like Mersenne Twister produce statistically random outputs but are not independently verifiable. Players must trust the casino’s implementation.

Cryptographically secure RNGs (CSPRNG): Use hardware entropy sources or cryptographic hash functions. Harder to predict, but still not player-verifiable unless the seeds are disclosed.

Provably fair RNG (seed-based): The crash point is derived from HMAC-SHA256(server_seed, client_seed + ':' + nonce). Players contribute entropy (client seed), the server commits to its seed in advance (via hash), and the full derivation is disclosed post-round. Any player can independently reproduce the result.

How provably fair RNG maps to a crash point

The raw HMAC output is a 256-bit hexadecimal number. The game converts this to a crash multiplier via a formula — typically:

hash = HMAC_SHA256(server_seed, client_seed + ':' + nonce)

# Take first 8 hex characters as a 32-bit integer
h = int(hash[:8], 16)

# Map to crash point (simplified Bustabit-style formula)
if h % 33 == 0:
    crash_point = 1.00   # instant crash (house edge)
else:
    crash_point = max(1.00, (100 * 2**32) / (h + 1)) / 100

The exact formula varies by provider, but the principle is identical: a cryptographic hash maps to a specific crash point, deterministically, every time.

What the RNG does not control

The RNG determines the sequence of crash points. It does not determine:

  • The probability distribution — that is set by the formula
  • The house edge — baked into the formula (the % 33 == 0 check above represents ~3% instant crashes)
  • Whether your specific bet wins or loses at your chosen cash-out target

Verifying the RNG

On provably fair platforms, after each round:

  1. The server reveals the server seed
  2. You apply HMAC-SHA256(server_seed, your_client_seed + ':' + nonce)
  3. Apply the game’s crash formula to the result
  4. Confirm it equals the announced crash point

Several third-party verifiers accept seed inputs and output the crash point, making this accessible without writing code.

  • Seed — the inputs to the RNG
  • Hash — the cryptographic function the RNG is built on
  • Provably Fair — the verification system around the RNG
  • Crash Point — what the RNG output becomes

Related terms

seedhashprovably faircrash point