Random Number Generator Performance Benchmarks¶
Use the tables below as historical measurements, then profile the random operations your game actually calls. Throughput, statistical quality and replay compatibility answer different questions. A fast raw integer draw does not establish the cost or behavior of a bounded or Gaussian sample.
How the Speed column is measured¶
The ops/s columns measure generators sequentially on one machine. Machine load can change between measurements, so use them as local throughput observations rather than a universal ranking.
The Speed column uses paired comparisons against IllusionFlow, with alternating measurement order and repeated readings. When readings vary by more than 3%, the benchmark falls back to an unpaired measurement and reports that limitation. Device, backend and workload differences still matter even for a stable paired result.
Statistical quality¶
PractRand tests a byte stream up to a reported depth, such as 8 GB. TestU01 SmallCrush runs a smaller fixed set of statistical tests. Passing one does not imply passing the other, and neither proves suitability for every use. The descriptions distinguish observed outcomes from unmeasured claims. In particular, Sfc64Random has no recorded PractRand depth at either stream width; its deterministic bit-plane checks do not supply that result.
Isolated SmallCrush p-values can occur by chance. The historical comparison used a failure threshold below 1e-10; weaker deviations were recorded separately. Do not interpret a single passing statistical run as a cryptographic guarantee.
Whole-inventory SmallCrush, 2026-08-26, seed 00010203-0405-0607-0809-0a0b0c0d0e0f, 908 MB and 6.3 s of CPU per generator:
- Every generator rated
Goodor better passed. - Four recorded-weak generators failed decisively, most of their statistics at
eps:LinearCongruentialGenerator,WDoomRandom,WaveSplatRandom,XorShiftRandom. - Three recorded-weak generators passed:
DotNetRandom,SquirrelRandom,SystemRandom. SmallCrush is the shallower instrument, so that is inconclusive rather than a contradiction of their rating.
The
NextUlong,NextLongandNextDoublecolumns below predate the one-advance-per-64-bit-draw change toBlastCircuitRandom,RomuDuo,SplitMix64,WyRandomandXoshiro256StarStar, which is measured at 2.49x on Unity 6000.4.6f1 (Mono). They refresh the next timeRandomPerformanceTests.Benchmarkruns.
Summary (fastest first)¶
| Random | NextUint (ops/s) | Speed | Quality | Notes |
|---|---|---|---|---|
| LinearCongruentialGenerator | 1,238,600,000 | Fastest | Poor | Numerical Recipes 'quick and dirty' LCG (a=1664525, c=1013904223, m=2^32) returning the raw state, so bit k has period only 2^(k+1) -- measured linear complexity of bit k is 2^k+1, and bit 0 simply alternates. Cosmetic use only. |
| WaveSplatRandom | 1,126,300,000 | Very Fast | Experimental | Single-word chaotic generator; author notes period 2^64 but provides no formal test results—treat as experimental. |
| XoroShiroRandom | 1,024,600,000 | Very Fast | Good | xoroshiro128+, returning the high 32 bits -- the half its authors recommend. The discarded low half is linear (bit 0 has linear complexity exactly 128); no output bit of the returned half is. A 64-bit draw costs two state advances, because a + scrambler has no strong 64-bit word to return. Blackman & Vigna 2018 |
| BlastCircuitRandom | 1,023,900,000 | Very Fast | Good | Chaotic ARX mixer rather than a proven statistically optimal generator. Verified here: PractRand 0.95 clean through 8GB, the depth at which SystemRandom fails. |
| RomuDuo | 943,800,000 | Very Fast | Good | Published romuDuo: the ROMU multiplier with the ROTL(y,36) + ROTL(y,15) - x update. NextUint returns the low 32 bits of the 64-bit word. Overton 2020 |
| Sfc64Random | 941,700,000 | Very Fast | Very Good | sfc64 (Small Fast Chaotic): three 64-bit words plus a draw counter, seeded by the canonical twelve-draw warm-up. NextUint returns the upper half of the output word, where every mixed bit arrives. O'Neill 2018 (Doty-Humphrey's SFC) |
| SplitMix64 | 912,200,000 | Fast | Very Good | SplitMix64 mixer; Vigna reports passing TestU01 BigCrush. Vigna 2015 |
| FlurryBurstRandom | 905,800,000 | Fast | Excellent | Six-word ARX-style generator tuned for all-around use. Verified here: PractRand 0.95 clean through 8GB, the depth at which SystemRandom fails. The author reports TestU01 BigCrush passes; that run cannot be checked -- the upstream repository is offline. |
| PcgRandom | 896,800,000 | Fast | Excellent | PCG XSH RR 64/32 variant; passes TestU01 BigCrush and PractRand in published results. O'Neill 2014 |
| IllusionFlow | 871,600,000 | Fast | Excellent | Five-word rotate/xor/add generator driven by a 32-bit Weyl counter. Verified here: PractRand 0.95 clean through 8GB, the depth at which SystemRandom fails. The author reports 64GB; that run cannot be checked -- the upstream repository is offline. |
| XorShiftRandom | 862,300,000 | Fast | Fair | Classic 32-bit xorshift; known to fail portions of TestU01 and PractRand, acceptable for lightweight effects only. Marsaglia 2003 |
| StormDropRandom | 696,800,000 | Fast | Excellent | Large-state ARX generator over a 1024-word (4 KB) ring buffer with two 32-bit control words. Verified here: PractRand 0.95 clean through 8GB, the depth at which SystemRandom fails. The author's own results cannot be checked -- the upstream repository is offline. |
| Xoshiro256StarStar | 606,600,000 | Moderate | Excellent | xoshiro256** 1.0; the ** scrambler leaves no weak bit, and the native 64-bit word means NextUlong costs one state advance instead of the two every other 64-bit generator here needs. Blackman & Vigna 2018 |
| Xoshiro128StarStar | 599,100,000 | Moderate | Excellent | xoshiro128** 1.1; the ** scrambler leaves no weak bit, so NextBool and low-bit masks are as strong as the full word. Native 32-bit output, so NextUint discards nothing. Blackman & Vigna 2018 |
| WyRandom | 441,400,000 | Moderate | Very Good | Wyhash v1 .NET port; raw 64-bit draws match cocowalla's WyRng for the same ulong seed. cocowalla 2019 (Wang Yi's wyrand) |
| SquirrelRandom | 406,400,000 | Slow | Fair | Hash-based generator built on Squirrel3. Measured: fails PractRand 0.95 FPF-14+6/16 at 1GB, reproducibly across four seeds. Good equidistribution for the table lookups it was designed for; not a general-purpose stream. Squirrel Eiserloh |
| PhotonSpinRandom | 254,100,000 | Slow | Excellent | SHISHUA-inspired generator. Verified here: PractRand 0.95 clean through 8GB, the depth at which SystemRandom fails. The author reports 128GB; that run cannot be checked -- the upstream repository is offline. |
| WDoomRandom | 200,100,000 | Very Slow | Poor | Index-into-array generator over a fixed 1024-entry table of 32-bit values. One entry serves one NextUint, so the period is exactly 1024 draws. Deterministic by design, not statistically random. |
| UnityRandom | 131,000,000 | Very Slow | Fair | Mirrors UnityEngine.Random, documented by Unity as Xorshift 128; suitable for legacy compatibility but not high-stakes simulation. UnityEngine.Random |
| SystemRandom | 63,200,000 | Very Slow | Poor | Reimplements the classic .NET System.Random algorithm (Knuth subtractive lagged-Fibonacci, mod 2^31-1) so its sequence is serializable and stable across runtimes. Fails modern statistical batteries. System.Random considered harmful |
| DotNetRandom | 58,700,000 | Very Slow | Poor | Wraps System.Random, which on Mono and for seeded .NET Core is Knuth's subtractive lagged-Fibonacci generator (mod 2^31-1), not an LCG. The sequence is runtime-dependent, so do not rely on it for cross-platform determinism. System.Random considered harmful |
Detailed Metrics¶
| Random | NextBool | Next | NextUint | NextFloat | NextDouble | NextUint (Range) | NextInt (Range) |
|---|---|---|---|---|---|---|---|
| LinearCongruentialGenerator | 777,900,000 | 676,100,000 | 1,238,600,000 | 171,900,000 | 369,900,000 | 492,500,000 | 391,400,000 |
| WaveSplatRandom | 773,400,000 | 591,500,000 | 1,126,300,000 | 173,600,000 | 380,000,000 | 438,000,000 | 399,500,000 |
| XoroShiroRandom | 767,000,000 | 552,600,000 | 1,024,600,000 | 166,900,000 | 347,400,000 | 423,800,000 | 363,900,000 |
| BlastCircuitRandom | 750,900,000 | 525,800,000 | 1,023,900,000 | 166,700,000 | 580,000,000 | 410,100,000 | 339,900,000 |
| RomuDuo | 778,700,000 | 554,300,000 | 943,800,000 | 169,000,000 | 580,800,000 | 428,300,000 | 389,100,000 |
| Sfc64Random | 742,800,000 | 537,200,000 | 941,700,000 | 164,600,000 | 566,700,000 | 392,300,000 | 352,200,000 |
| SplitMix64 | 768,600,000 | 571,400,000 | 912,200,000 | 164,300,000 | 561,600,000 | 411,700,000 | 379,600,000 |
| FlurryBurstRandom | 749,300,000 | 546,800,000 | 905,800,000 | 172,000,000 | 293,200,000 | 386,100,000 | 340,300,000 |
| PcgRandom | 754,600,000 | 545,900,000 | 896,800,000 | 165,600,000 | 321,100,000 | 376,200,000 | 361,000,000 |
| IllusionFlow | 775,800,000 | 521,800,000 | 871,600,000 | 165,700,000 | 296,400,000 | 371,900,000 | 338,100,000 |
| XorShiftRandom | 756,400,000 | 620,200,000 | 862,300,000 | 173,200,000 | 364,300,000 | 424,800,000 | 365,900,000 |
| StormDropRandom | 744,600,000 | 458,000,000 | 696,800,000 | 166,600,000 | 253,600,000 | 341,900,000 | 309,800,000 |
| Xoshiro256StarStar | 738,900,000 | 461,900,000 | 606,600,000 | 175,100,000 | 539,700,000 | 354,900,000 | 320,200,000 |
| Xoshiro128StarStar | 760,000,000 | 470,300,000 | 599,100,000 | 166,300,000 | 264,900,000 | 359,300,000 | 324,800,000 |
| WyRandom | 744,200,000 | 338,400,000 | 441,400,000 | 157,900,000 | 360,200,000 | 264,600,000 | 228,100,000 |
| SquirrelRandom | 739,500,000 | 391,400,000 | 406,400,000 | 162,400,000 | 191,100,000 | 302,800,000 | 288,600,000 |
| PhotonSpinRandom | 688,600,000 | 228,800,000 | 254,100,000 | 116,300,000 | 112,800,000 | 201,700,000 | 184,000,000 |
| WDoomRandom | 698,400,000 | 210,400,000 | 200,100,000 | 138,200,000 | 105,900,000 | 207,700,000 | 200,600,000 |
| UnityRandom | 686,200,000 | 122,000,000 | 131,000,000 | 78,500,000 | 60,000,000 | 117,800,000 | 119,300,000 |
| SystemRandom | 138,300,000 | 142,900,000 | 63,200,000 | 128,400,000 | 131,100,000 | 57,800,000 | 56,800,000 |
| DotNetRandom | 531,500,000 | 54,800,000 | 58,700,000 | 44,800,000 | 27,400,000 | 53,100,000 | 44,600,000 |
Choose a generator for your game¶
Use the tables to compare the measured operations, then read the random generator guide for the current generator choices and APIs. A generator added after the recorded benchmark run may be absent from these tables. Absence is not a quality or speed rating.
The NextUint column measures raw 32-bit draws. Bounded integers, floating-point transforms, weighted selection and Gaussian draws do different work. Compare the operation your game uses, and profile it on your target device and scripting backend before changing generators for speed.
Statistical quality is separate from throughput. A clean finite test stream is not a guarantee for every seed or workload. The quality descriptions above refer to the tested 32-bit streams; a 64-bit draw can use a different part or ordering of a generator's state. These generators are not cryptographic random sources.
Raw-stream compatibility¶
A raw stream is the sequence returned by unbounded NextUint() or NextUlong() calls. It is separate from bounded sampling, which can consume more than one raw draw when rejecting a value. Changing the bounds, operation order or failure policy can therefore change later results even when the underlying raw stream stays the same.
For deterministic gameplay, record the generator type, seed or saved state, package version and call order. Save a snapshot when you need to resume partway through a stream: a seed alone does not include cached Gaussian, bit or byte state. See saving and restoring random state for the snapshot APIs.
| Generator family | Replay consideration |
|---|---|
| Package-managed generators | Keep the generator and saved state format consistent; check retained replays when upgrading. |
NativePcgRandom | Value copies preserve its state, including partially consumed bit reservoirs; it has no RandomState or protobuf API. |
UnityRandom | Follows the running Unity engine; do not assume identical engine streams or snapshot payloads across Unity versions. |
DotNetRandom | Wraps System.Random; its sequence depends on the runtime. |
WDoomRandom | Deliberately repeats a fixed table; use only when that deterministic behavior is intended. |
Raw-stream compatibility does not establish statistical quality, throughput or allocation cost. Validate each property that your game depends on, including mixed sampling calls and retained saves, on the backends you ship.
Refreshing these numbers¶
The package publishes refreshed tables after its benchmark workflow completes. To measure your own project, run RandomPerformanceTests.Benchmark in Unity's Test Runner with the package tests enabled. Keep the Unity version, backend and device with your results so later comparisons use the same environment.