Uniform randomness and streaks

Every generator on this site draws from a pool in which each entry is exactly equally likely, and reports the size of that pool with the result. This guide is about the consequence that surprises people: the output of a uniform draw is streaky. Letters repeat, runs appear, and some letters stay away for a long time — not because anything went wrong, but because the arithmetic of independent draws says they must. Every probability below is computed at build time from the pool sizes the engine reports, and every example draw is made by the real engine from a scripted byte source chosen to show a particular outcome; the live tools draw their bytes from crypto.getRandomValues instead.

Every letter in the active pool is exactly equally likely — the engine never weights draws by English text frequency or any other distribution.

That sentence is exported from the engine source and rendered here verbatim; everything that follows is a consequence of it. The other guides cover the draw itself; this one covers what the draw looks like over many letters.

What uniform means for a single draw

The pools in use are the English alphabet (26 letters), the vowels (5 letters: A E I O U), the consonants (21 letters), the mixed-case pool (52 entries, uppercase and lowercase forms counted separately) and the Greek alphabet (24 letters). In each, one draw lands on any given entry with probability one over the pool size: 1/26 for an English letter, 1/5 for a vowel, 1/52 for a specific form in mixed case.

The engine gets there by drawing a random byte, keeping only the minimal bits that cover the pool — 5 bits for the 26-letter pool, giving 32 possible values — and throwing away any value at or beyond the pool size, which here means 6 of those 32 values, before drawing again. Nothing wraps around, so no letter inherits the discarded values. The draw guide walks through a byte becoming a letter, and the rejection-sampling guide shows why the shortcut of taking a remainder would have been biased. For this guide, one fact matters: every entry has the same probability, on every draw, with no adjustment for what came before.

The draw has no memory

With repeats allowed, each position in a sequence is drawn from fresh bytes, and the engine never consults the letters already drawn. The probability of any particular sequence is therefore the product of its per-letter probabilities: a specific sequence of n letters from a pool of p has probability (1/p)ⁿ, whatever the letters are. For 10 letters from the 26-letter pool that is 1 in 141,167,095,653,376, and it applies equally to ZZZZZZZZZZ and to QLAYERHWNC. Both were drawn at build time by the engine, the first from a byte script that repeats the index of Z and the second from varied bytes. The run looks remarkable and the other looks random, but under a uniform draw they have identical probability. This is the single fact behind every streak in this guide.

How often a sequence contains a repeat

The first letter of a sequence cannot repeat anything. The second avoids a repeat with probability (p − 1)/p, the third with (p − 2)/p, and so on, so the chance that n letters are all different is the product of those fractions, and the chance of at least one repeat is one minus that product. For 6 letters from the 26-letter pool, the repeat chance is 46%. A scripted example is Q L A U E Q, where the first and last bytes were scripted equal so the repeat is visible.

Reading the table: in the 26-letter pool a repeat becomes more likely than not at 7 letters; in the 52-entry pool at 9. Both columns are computed from the pool sizes alone.

Runs of the same letter

A run is a repeat in its purest form. If you name a letter in advance, the chance that n draws all produce it is (1/p)ⁿ. If any letter will do, the first draw sets the letter and the remaining n − 1 must match it, so the chance is (1/p)^{n − 1}. Small pools make runs common: 5 vowel draws that all come up E have probability (1/5)⁵, which is exactly 1 in 3,125, and 5 vowel draws that all match each other, whichever vowel it is, happen 1 in 625 times. The build-time example E E E E E was made from a byte script that repeats the index of E; a live draw is entitled to produce the same thing.

Adjacent doubles in a long batch follow the same arithmetic. Each neighbouring pair matches with probability 1/p, and a batch of 100 letters — the maximum the tool draws — has 99 neighbouring pairs, so it contains about 3.8 doubles on average and has at least one with probability 97.9%. A maximum-length draw with no double anywhere is the unusual result, not the double.

Letters that never show up

Streaks have a mirror image: letters that fail to appear. A named letter is absent from n draws with probability (1 − 1/p)ⁿ. Draw 26 letters from the 26-letter pool and a given letter is missing 36% of the time; the batch shows about 16.6 distinct letters on average, not all 26. Draw the maximum of 100 and a named letter is still missing 2.0% of the time, with about 25.5 distinct letters expected. In the vowel pool, 5 draws miss a named vowel 33% of the time and show about 3.4 distinct vowels.

The result some readers expect — 26 draws showing each letter exactly once — is the no-repeat case from the table carried to the full pool, and it is the least likely row in that family: the product 26/26 × 25/26 × … × 1/26 comes to about 1 in 15,264,691,107, a figure checked at build time against the exact ratio 26²⁶ / 26!. The way to get it on purpose is to ask for it: "no repeats" with a count equal to the pool size is a different procedure, and it yields a uniformly random ordering of the whole pool every time.

Why streak-free output would be less random

Suppose a tool quietly refused to show the same letter twice in a row while still claiming repeats were allowed. Over 6-letter sequences from the 26-letter pool there are 308,915,776 possible outcomes, and such a tool can produce only 253,906,250 of them — the rest, 17.8% of all sequences, get probability zero while the survivors get more than their share. Each position might still look uniform on its own, but the second letter is no longer independent of the first: knowing one tells you a letter the next cannot be. The methodology page puts the conclusion in one line — tools that never show streaks are not more random; they are less.

The honest version of "no doubles" is the declared one. With "no repeats" switched on, the engine samples without replacement using a partial Fisher–Yates shuffle driven by the same sampler: a drawn entry leaves the pool, the next draw is uniform over what remains, and the result reports the pool it started from. The same 6 scripted bytes that produced Q L A U E Q above produce Q M C X I V under that mode, with no repeat possible. A counting byte source confirms that the engine asked for exactly 6 bytes with repeats and 6 without: under "no repeats" the pool shrinks from 26 to 21 entries over 6 positions, and because every scripted byte lies below 21 none was rejected against the shrinking pool. A byte at or beyond the remaining span would have been discarded and another drawn, so a general byte script need not consume one byte per letter. Ask for more unique letters than the pool holds and the engine refuses with its actual limit — for the vowel pool the real message reads: Cannot draw 6 letters without repeats from a pool of only 5 — allow repeats, lower the count, or widen the pool. The no-repeats guide follows that procedure byte by byte.

Mixed case widens the pool

"Both cases" is a 52-entry pool — every uppercase form, then every lowercase form — with each entry at 1/52; the pool guide shows the composition order that produces it and works through the per-letter odds. For streaks the wider pool matters in two ways. The repeat chance over 6 letters falls from 46% in the 26-letter pool to 26% in the 52-entry pool, and the table above carries that difference down its two columns. And a sequence such as the scripted A a — drawn from the bytes 0 and 26, the first landing on the first entry of the pool and the second on the first entry of the lowercase half — contains no repeat at all: A and a are different entries, so under "no repeats" both can appear in one batch. The uppercase and lowercase generator exposes this pool directly.

How to read a result

Every result on this site states the pool size it was drawn from, and that number is the denominator for everything above. Find it, and the rest follows: the per-draw probability of any entry is one over the pool size; the repeat chance for your sequence length comes from the product in the table; a run of r identical letters that you did not name in advance had probability one over the pool size raised to r − 1; and a letter you expected but did not see was absent with probability (1 − 1/p)ⁿ for your count n. Counts run from 1 to 100; anything outside that range is refused rather than clamped.

It is equally useful to know what the tool does not do. It does not weight letters by English text frequency or by any other distribution — the note at the top of this page is the whole of the policy. It does not suppress, space out or otherwise edit a with-repeats draw after the fact. And as the methodology page explains, the uniformity claim rests on the construction of the sampler, not on statistical testing after the fact. A result that looks too streaky to be random is, under that construction, exactly what random looks like.

Frequently asked questions

Uniform means uniform: every entry in the active pool is drawn with equal probability, and the repeats and runs that follow are part of that guarantee — never smoothed away and never weighted by English usage. Draws happen locally in your browser and are never transmitted. Details on the methodology page.