How real RNG checks work

Checking the RNG (random number generator) is not one "magic test," but a chain of engineering procedures. Its goal is to prove three things: (1) the flow of numbers is statistically similar to an ideal random, (2) it correctly "maps" into game events (symbols, cards, multipliers), (3) the proven version invariably spins in production. Below is how the full cycle works.

1) What exactly is checked (three levels)

1. Raw RNG outputs - pure flow statistics (no game interface).

2. RNG mapping → game events - match frequencies of combinations to declared mathematics (RTP/volatility).

3. Life cycle and integrity - that exactly the assembly that was certified works on sale, and it cannot be imperceptibly replaced.

2) Pre-release: laboratory certification

A. White box (by code and architecture)

Algorithm: PRNG/CSPRNG class, seeding method, reseeding, thread isolation, lack of common states between games.

Sources of entropy: system pool/hardware noise; sufficient bit entropy for start is checked.

State management: nonce/counter, protection against reuse, independence of streams for different games/tables.

B. Black box (by exit)

Generate very large samples (hundreds of millions to billions of bits/numbers).

Run through batteries of tests:

NIST SP 800-22: monobit, block frequencies, wound tests, zero/one imbalance, approx. entropy, linear complexity, spectral (DFT), etc.
Diehard/Dieharder: birthdays, random walks, matches, matrix ranks, etc.
TestU01 (SmallCrush/Crush/BigCrush): the strictest series; catches subtle dependencies and short periods.
Hypotheses and p-values: not "so that all are 0. 5," and so that they are evenly distributed over [0; 1]; the multiplicity of tests (correction of false positives) is taken into account.
Sliding windows: the same tests on a subset of threads (different block sizes) to catch unsteadiness.

C. Verification of game mathematics

Simulation of millions/billions of "virtual spins/distributions": empirical RTP converges to the stated (e.g. 96. 00% ± tolerance).

Check for rare events: jackpot frequencies, bonus rounds, multipliers, distribution of winnings by quantiles.

Mapping check: mapping tables "RNG number → symbol/map" without distortion, equal probability of all "deck/reel" positions.

Result: a report with RNG parameters, a list of tests/data volumes/pass thresholds, hash sums of game binaries and target RTP.

3) On sale: continuous control

Telemetry and alerts

Convergence of RTP on aggregated data (days/weeks/months) with confidence intervals.

Distribution anomalies: repeat spikes, symbol skews, variance changes.

Online health RNG: light built-in self-tests (frequency/runs) on the current stream + periodic "heavy" runs in log shots.

Sliding windows and seasonality: comparisons with "old" reference periods.

Integrity of artifacts

Verification of hash sums and digital signatures of executable files with a "golden" sample from certification.

Policy "only signed releases," double approval for the deposit, audit of the actions of admins.

Incident response

Thresholds → isolate the game, enable "maintenance," perform rollback, fix snapshot, notify the regulator/partners, prepare replay logs.

4) How key tests work (humanly)

Monobit/frequency: zeros and ones should be approximately equal.

Runs/series: consecutive lengths of 0/1 correspond to the theory.

DFT/spectral: no hidden periods/harmonics.

Linear complexity/matrix rank: flow is not described by a short linear scheme.

Birthday spacings/collisions: distribution of matches as in a perfect random.

Approx. Entropy/Serial: no redundant short patterns.

Autocorrelation: neighboring elements are independent.

Important: one "red" test does not prove the problem - they look in batches, taking into account multiple checks and repeated runs.

5) Sids, passage and independence of flows

Seed is formed from several sources of entropy; documenting the start procedure and frequency of the reseeding.

Different games/tables are different RNG states; prohibition of joint state.

nonce/counter accounting: each call is unique, resampling is excluded.

6) Mapping and presentation: where "honesty" is often confused

RNG gives the number, and the game translates it into an event. Check that the mapping table:

has no "dead" zones, evenly covers the space, fixed in the version (change = new certification).
Near-miss is the visual effect of the interface. Its share and logic are rigidly set by mathematics; it does not "tweak" the RNG.

7) Logs and reproducibility

Each round receives an ID, timestamps, sid/nonce, input parameters, RNG total and the result after mapping.

By log, the laboratory/operator can reproduce the outcome and make sure that it matches the algorithm and round data.

Logs are unchangeable, stored for years, backed up; access - according to the regulations.

8) Live games: what replaces RNG tests

Roulette/cards: equipment control (wheel run-out, balance, calibration), dealer procedures, auto-shufflers, changing decks, full video recording.

Statistical monitoring of numbers/cards in the product - catches wear/defects and human factors.

9) "Provably fair": what the player really checks

The server publishes the server seed hash in advance; after the round, reveals the sid.

The player sets the client side; the total is considered according to a documented formula (often HMAC/AES + nonce).

Anyone can recalculate and make sure that the result is not replaced after the bet.

But this is not a guarantee of high RTP - the mathematics of the game still requires a separate audit.

10) Typical mistakes and how they are caught

Poor seed initialization is → caught by early tests and anomalies in the first windows.

Repeated state/nonce reuse → duplicates/correlations, detection in Diehard/TestU01.

Drift after update (hot edit) → alert for hash/metric discrepancy.

Weak PRNG → "dips" in BigCrush, frequency bursts, structure in DFT.

Check sheets

For studio/provider

Documented RNG algorithm, siding, reseeding, thread splitting.
NIST/Dieharder/TestU01 runs with sufficient volume and p-values reports.
Game mass simulations: RTP, variance, win quantiles, rare events.
Versioning/signatures/hashes of artifacts; disallowing unsigned releases.
Post-release RTP alerts/distributions/replicates; isolation/rollback plan.

For the operator

I check RNG/game certificates and actual versions in prod (hash control).
Monitor RTP convergence and anomalies across all titles; there are thresholds and auto-alerts.
I store unchangeable logs; Quick export by ticket is ready.
Incident procedure: stop games → rollback → notifications → public report.

For the player

I look at the game info screen: RTP/rules/version/max win.
I play with operators with visible WG tools (limits/history/timeout).
In dispute, request round ID and statement; the result should play.

[The] don't confuse RNG honesty with volatility: Dry streaks are normal.

Real RNG checks are strict statistics + mapping control + version and log discipline. The laboratory confirms that the flow is equal and independent; simulations prove compliance with the declared RTP; production monitoring ensures that the tested assembly has not changed and behaves in the same way as on tests. When all three levels work together, "honesty" ceases to be a promise and becomes a property of the system.