Is NameWheel Actually Random?
Yes — Here Is the Proof

Why "Random" Is Harder Than It Sounds

Computers are deterministic machines. Given the same inputs, they produce the same outputs every time. Genuine unpredictability requires a source of true entropy — something outside the computer's control. This is harder to achieve in software than most people realize, and most wheel spinners cut this corner in a way that matters.

The most common approach, Math.random(), is what the majority of spinner tools use. It works by running a mathematical formula that generates numbers which look random but are actually a deterministic sequence starting from a seed value. The seed is usually the current timestamp. This means:

For a classroom random name picker or a casual giveaway wheel, the practical difference for everyday use is small. But when fairness genuinely matters — for prize draws, draft orders, or any situation where someone might challenge the result — "I used a cryptographically secure algorithm" is a provably stronger claim than "I used Math.random()." NameWheel uses the stronger one because it costs nothing extra and there is no reason not to.

How NameWheel Generates Random Numbers

Every random decision NameWheel makes — the spin duration, the total rotation amount, which name wins, the order of the Fisher-Yates shuffle — uses the same core function:

Breaking this down step by step:

• new Uint32Array(1) creates a typed array capable of holding a single 32-bit unsigned integer, with a value range of 0 to 4,294,967,295 (approximately 4.3 billion possible values).
• crypto.getRandomValues(buf) fills that integer with cryptographically random bytes drawn from the operating system's entropy pool. On Windows this calls CryptGenRandom. On Linux and macOS it reads from the getrandom syscall or /dev/urandom. On iOS and Android it draws from hardware entropy sources built into the device.
• buf[0] / (0xFFFFFFFF + 1) divides the raw integer by 4,294,967,296 to produce a floating-point number in the range [0, 1). This gives a uniform distribution across the full interval with over 4 billion possible distinct values.

This is the same cryptographic foundation used by password managers to generate strong passwords, by browsers to establish TLS connections, and by operating systems to generate cryptographic session tokens. For picking a random name from a list, it is far stronger than anything you will ever need. But it costs exactly nothing extra to use, so NameWheel uses it for everything.

What Provides the Entropy?

The entropy — the actual unpredictability — comes from the operating system, not from NameWheel's code. Modern operating systems accumulate entropy continuously from low-level hardware events: the exact nanosecond timing of keyboard presses and mouse movements, network packet arrival times, storage device read latency variations, and on supported systems, a dedicated hardware random number generator (HRNG) built directly into the CPU silicon.

The window.crypto API gives JavaScript access to this entropy pool without exposing the underlying implementation. This means the randomness in your spin is ultimately grounded in physical reality — the thermal noise and timing jitter in your device's hardware at the exact moment you clicked Spin.

The Fisher-Yates Shuffle (Remove After Spin Mode)

When you enable Remove After Spin mode, you want each name to appear exactly once before any name can repeat. This is the classic "random shuffle" problem — how do you randomly order a list so that every possible ordering is equally likely?

The naive approach — pick a random name, remove it, repeat — has a subtle but real flaw. As the list shrinks, the probability of each remaining name being selected changes as a function of what has already been removed. The resulting distribution over all orderings is not uniform. You get some orderings more often than others, which violates the fairness requirement.

NameWheel uses the Fisher-Yates shuffle (also known as the Knuth shuffle, published in Donald Knuth's "The Art of Computer Programming"), which has been mathematically proven to produce a perfectly uniform distribution:

The algorithm iterates backwards from the last element to the second. At each position i, it selects a uniformly random index j between 0 and i (inclusive), then swaps the elements at those two positions. The proof that this produces a uniform distribution over all n! possible orderings has been established since Fisher and Yates published it in 1938 and Knuth formalized it in 1969.

Critically, NameWheel uses secureRandom() for every swap — not Math.random(). The Fisher-Yates algorithm is only as uniform as the random number generator it uses. By combining a provably uniform shuffle algorithm with a CSPRNG source, NameWheel guarantees that every permutation of your list has mathematically equal probability.

The Wheel Spin Physics

The spinning animation is purely visual — it does not affect the outcome in any way. But the physics are worth explaining, because they look and feel like a real spinning wheel for deliberate reasons.

Spin Duration and Rotation Amount

When you click Spin, two independent random values are generated simultaneously, before the animation begins:

• Spin duration is randomly chosen between 3,500ms and 5,000ms. This 1.5-second variance means you cannot time a spin by habit or feel to predict when it will stop. Two spins that look similar in speed may stop at very different positions.
• Total rotation is randomly chosen between 6 and 10 full rotations (2,160° to 3,600°). The extra full rotations on top of the final landing angle prevent the wheel from always stopping after "about seven spins" regardless of where the winning segment is.

These two values are fixed at the exact moment you click Spin. The winner — the final resting position — is mathematically determined right then. The animation that follows simply plays that predetermined outcome forward in time. The wheel always lands exactly where the randomizer decided before the first frame of animation rendered.

The Easing Function

A real spinning wheel does not rotate at constant speed then stop abruptly. It starts near peak speed and decelerates gradually as friction overcomes momentum. NameWheel uses a quartic ease-out function to replicate this physically accurate deceleration:

The exponent 4 creates a deceleration curve where the wheel runs at near-full speed for the first portion of the animation, then decelerates with increasing sharpness toward the end. Compare this to a linear spin (constant speed, stops instantly — looks mechanical), or a quadratic ease (gentler, less realistic deceleration), or a quadratic ease-in-out (equally gentle in both directions). The quartic ease-out matches most closely the physics of a spinning physical wheel decelerating under friction.

The easing function only affects the visual timing of how the wheel moves through animation frames. The final resting angle is predetermined and constant regardless of what easing function is used. The visual impression is simply more convincing and satisfying with a natural-looking deceleration curve.

Winner Detection

The wheel has a fixed pointer at the top (the indicator triangle). The winning segment is whichever slice is positioned under the pointer when the elapsed animation time equals the total spin duration (t = 1.0):

Each of the n names occupies exactly 2π/n radians of the wheel — an equal slice. The normalized final angle, divided by the slice size and floored, gives the winning segment's index. Equal arc sizes mean equal probability: a 10-name wheel gives every name exactly a 36-degree arc and exactly 10% probability per spin. A 20-name wheel gives 18 degrees and 5% each. The math is exact.

Your Data Never Leaves Your Browser

This is not a claim that requires you to trust NameWheel's word. It is a structural fact about how the system is built that you can verify independently.

Standard web server access logs do record your IP address, the URL you requested (not the fragment), and the timestamp — this is unavoidable for any functioning website and is disclosed in the privacy policy. What is never logged: the names in your wheel, spin results, or any content you enter into the textarea. That content never travels across the network in the first place.

You can verify this yourself: open your browser's developer tools (F12), go to the Network tab, load NameWheel, type some names, and spin. The Network tab will show requests for the HTML, CSS, JavaScript, and font files. It will show zero requests made during or after a spin. Your names never leave the browser.

Performance Architecture: The Offscreen Canvas

A 980×980 pixel canvas with radial gradients, glow effects, 8-segment color fills, peg decorations, and hub rendering is computationally non-trivial to draw. During a spin animation, the browser calls requestAnimationFrame continuously — up to 60 times per second on a 60Hz display, 120 times on a high-refresh display. Rebuilding the full wheel image every frame would cause visible stuttering on anything less than a high-end GPU.

NameWheel solves this with an offscreen canvas architecture:

• An invisible second canvas renders the complete wheel image once when names are loaded or the list changes. This is the "expensive" operation: approximately 15-30ms on a mid-range device. It happens once when needed, not per frame.
• During spin animation, only the rotation transform updates each frame. The cached offscreen image is composited onto the visible canvas with a rotation applied — an O(1) GPU operation instead of a full gradient recalculation.
• A 120ms debounce on the name input means the offscreen canvas only rebuilds after you pause typing, not on every keystroke. This keeps the textarea input responsive even while typing hundreds of names.
• A "dirty" flag tracks whether the name list has changed since the last cache build. If you spin without editing names, the cached image is reused indefinitely with no rebuild cost.

The result: smooth 60fps spin animation on a 2018 budget phone, sub-100ms response to spin clicks, and no input lag while typing long name lists.

Browser Compatibility

NameWheel's core functionality — spinning, randomizing, removing names, eliminate mode, team generation — requires only HTML5 Canvas and the Web Crypto API. Both have been available in all major browsers since 2014-2015. If your browser can run a modern website, it can run NameWheel.

Sound on iOS Safari requires a user gesture before the Web Audio API context can start — this is an Apple browser policy, not a NameWheel limitation. The first spin on a fresh iOS page load may be silent; all subsequent spins in the same session will have full audio.

NameWheel checks prefers-reduced-motion from the browser at load time and adjusts animation behavior for users who have enabled that system accessibility preference.

Accessibility Features

Random pickers should work for everyone, not just people with fast eyes or high-end hardware. NameWheel includes accessibility support built directly into the engine:

Frequently Asked Questions