Random Letter Sequence

Sequences for games, drills, and test data

A letter sequence is the raw material of a surprising number of activities. Word-scramble rounds hand players a fixed set of letters to build from; memory training uses progressively longer sequences to recite back; classroom cipher exercises need keys and nonsense strings that no one chose; scavenger hunts assign each team a letter string to find object-by-object; and developers reach for random letter runs as honest placeholder data that spell-checkers won’t silently "fix". The example above, QLAYER, was drawn at build time by the same tested engine, from a fixed byte script so the page is reproducible.

Mechanically, a sequence here is 6 independent draws by default — or any length from 1 to 100 — each made from the same pool by the same procedure, then joined into one string because the string is the product. The result box prints that string in bold and, beneath it, the exact size of the pool the draw came from. Everything this page says about probability follows from two facts the engine guarantees: every position is drawn uniformly from that pool, and, with repeats allowed, every position is drawn independently of the others. The sections below take those two facts apart — how a position is drawn, what the pool line means, what changes without repeats, and why the output looks the way it does.

How each position is drawn

The engine never asks the browser for "a letter". It asks for random bytes and maps them onto the pool. A byte holds 256 equally likely values; the uppercase pool holds 26. The tempting shortcut — divide by 26 and keep the remainder — is biased, because 256 is not a multiple of 26: 256 = 9 × 26 + 22, so the remainders 0–21 each occur 10 times among the 256 byte values while 22–25 occur only 9, which would make the first 22 letters about 11% more likely than the last 4. The engine does not take that shortcut. It keeps only the minimal bits that cover the pool — 5 bits for 26 letters, values 0–31 — and if the masked value lands at or beyond the pool size, 26 through 31, it is discarded and a fresh byte is drawn. Nothing wraps around, so each letter keeps exactly probability 1/26. The acceptance rate is 26/32 = 81.25%; rejection never wastes more than half the draws, so on average fewer than two bytes are spent per letter. The uniformity claim rests on this construction, not on statistical testing after the fact.

Here is that mapping with the randomness replaced by a fixed script, so the page can show it. Live draws use crypto.getRandomValues; the scripted bytes below are for illustration only, run through the real engine at build time. Feed the bytes 16, 11, 0, 24, 4, 17 to a 26-letter uppercase draw and every byte is already below 26, so none is rejected: the first byte, 16, selects index 16 of the pool, which is Q, and the 6 bytes together give QLAYER.

Now a script that includes bytes the sampler must refuse: 255, 8, 200, 30, 19, for a 3-letter sequence. The engine consumed 5 bytes to produce IIT — 2 more than the letters it returned — because 2 masked values fell at or beyond 26. Byte by byte: 255 → 31 → rejected; 8 → 8 → I; 200 → 8 → I; 30 → 30 → rejected; 19 → 19 → T. Notice that 200 was not rejected: masking keeps only its low 5 bits, which gives 8, a perfectly good index. Rejection is decided by the masked value, never by the size of the byte. The repeated letter in that result is not an artefact of the script either — see "Streaks are normal" below. The guide to how a random letter is drawn follows a single byte all the way through.

Reading the result: the pool line

Every result ends with a line of the form "Pool: 26 letters, each equally likely (uniform)". That number is the thing to read first, because every probability on this page depends on it. Uppercase or lowercase, the pool is 26 letters. Choose mixed case and the pool is not an uppercase draw followed by a coin flip for case — it is a genuine 52-entry pool, composed as A–Z followed by a–z, with each of the 52 forms at exactly 1/52. Doubling the pool changes the sampler's numbers too: 52 entries need 6 bits, values 0–63, and the rejected band becomes 52–63. The acceptance rate is 52/64, which works out to 81.25% — the same ratio as the single-case pool, because doubling the pool also doubles the span: 52/64 = 26/32. The rejected band itself is wider — 12 values against 6 for the single-case pool — but it is the same share of the span, so a mixed-case letter costs the same number of bytes on average.

Scripted illustration: the bytes 0, 26, 60, 25, 51, 7, 33 fed to a mixed-case draw of 6 produce AaZzHh. The engine consumed 7 bytes for 6 letters: byte 60 masks to 60, which is at or beyond 52, so it was rejected; byte 26 selects index 26, the first lowercase entry, a — exactly where the composition order (uppercase run, then lowercase run) puts it. A larger pool also makes repeats rarer: with repeats allowed, a 6-letter sequence has a 46% chance of containing a repeated entry from the 26-letter pool and 26% from the 52-entry pool — pool arithmetic, computed from the two pool sizes the same way: 1 − (52/52 × 51/52 × … × 47/52) for the mixed-case figure. In that pool A and a are different entries, so one of each is not a repeat.

No repeats, up to a full shuffle

With "no repeats" on, the engine switches to sampling without replacement, implemented as a partial Fisher–Yates shuffle driven by the same rejection sampler. The pool is copied into a deck. For the first position a uniform index is drawn over all 26 entries and that entry is swapped to the front; for the second, the index is drawn over the remaining 25; and so on, the span shrinking by one each step — 26, 25, 24, 23, 22, 21 for a 6-letter draw — so each position takes a uniformly chosen letter from those not yet drawn. Drawing the whole pool this way yields a uniformly random permutation: every ordering equally likely.

The same leading bytes behave differently once the deck is moving. Scripted bytes 16, 11, 0, 24, 4, 17, 9 — the first 6 identical to the script that produced QLAYER — give QMCHVO without repeats. Two things changed. Swaps rearranged the deck, so a byte that pointed at one letter in a fresh pool points at another after earlier positions were filled; and the engine consumed 7 bytes for 6 letters, 1 of them rejected, because a value that fits under a span of 26 can fall outside a smaller span and be thrown away, exactly as in the fixed-pool case. A length-26 uppercase draw without repeats is a shuffle of the entire alphabet — for instance FEDKGACNRIVBZMPOTQXSLUJYHW, again a scripted build-time draw. That is the fair way to schedule "letter of the day" rotations or assign distinct initials to players. The drawing-without-repeats guide walks through the swaps one by one.

Without replacement, the pool is a hard ceiling. Ask for 27 unique letters from the 26-letter pool and the tool refuses rather than quietly repeating or truncating; the message it prints, rendered here from a real refused call, is: "Cannot draw 27 letters without repeats from a pool of only 26 — allow repeats, lower the count, or widen the pool." Switch to mixed case and the ceiling rises to 52, where A and a count as different letters. The count bounds are enforced the same way: ask for 101 letters and the engine answers "How many: enter a whole number from 1 to 100."

Streaks are normal

The engine source exports one sentence about its distribution, and it is rendered here verbatim:

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

Uniform means the tool does nothing to make its output look random, and the consequences are arithmetic rather than opinion. With repeats allowed on the 26-letter pool, the chance that a 6-letter sequence contains at least one repeated letter is 1 − (26/26 × 25/26 × … × 21/26) = 46%; at 10 letters it is 86%, so a 10-letter sequence without a double is the unusual outcome. 3 identical letters in a row at a given spot arrive at odds of 1 in 26² = 1 in 676. And a 26-letter sequence with repeats allowed misses any particular letter with probability (25/26)²⁶ = 36% — more than a third of the time, the letter you were waiting for simply does not appear. None of this is a fault to correct. Tools that never show streaks are not more random — they are less. The guide Uniform randomness and streaks takes these calculations further.

Common misreadings

• "A double letter means the generator is stuck." It means the generator is uniform. At the default length of 6, a repeat appears 46% of the time; the scripted example IIT above contains one by honest arithmetic, not by malfunction.
• "Mixed case is an uppercase draw plus a coin flip." It is a single draw from a 52-entry pool in which every form has probability 1/52. The result line says so: "Pool: 52 letters".
• "A 26-letter sequence should contain every letter." Only with "no repeats" on. With repeats allowed, each letter is independently absent about 36% of the time, so a 26-letter sequence that covers the alphabet is the exception.
• "No repeats makes the output less random." It makes it uniform over a different set: ordered sequences of distinct letters, 165,765,600 of them at length 6, each exactly equally likely. A full draw is a uniformly random permutation.
• "A rejected byte is a bug or wasted randomness." Rejection is the mechanism that keeps every letter at exactly 1/26. Keeping those values would reintroduce the remainder bias described above.
• "The tool steers away from ugly or unpronounceable strings." It cannot see words. There are 308,915,776 uppercase sequences of length 6, and each one has probability exactly 1 in 308,915,776 — the pronounceable ones no more and no less than the rest.

Where the tool stops

The sequence tool draws uniformly from a letter pool and reports the pool — that is the whole of what it does. It never weights letters by English usage or any other distribution, never filters for pronounceable or "nice looking" strings, and never substitutes repeats or truncates a draw to satisfy a request the pool cannot meet; it refuses instead, with the messages shown above. Lengths run from 1 to 100, and without repeats the pool size is the ceiling. It draws letters only — no digits, no punctuation — from the English alphabet; Greek letters are drawn on the Greek page, and filtered pools (vowels only, consonants only, custom include and exclude lists) live on the main generator. It carries no certification and claims none: the uniformity claim rests on the construction described above and pinned by the engine's automated tests, not on statistical testing after the fact and not on anyone's say-so. The methodology page sets out the construction in full.

An honest note on passwords

Letter sequences look like passwords, but they make weak ones, and this page will not pretend otherwise. A sequence here is drawn from 26 symbols — 52 in mixed case — with no digits or punctuation, and the tool measures nothing about strength; it reports a pool size, not a security rating. These strings are for games, drills, codes you will read aloud, and test data. For real credentials, use a purpose-built tool that mixes character classes — for example the password generator on Sumvia.net, our sister calculator site.

Frequently asked questions

Uniform means uniform: all sequences of a given length and pool are equally likely — never weighted toward pronounceable strings or English letter frequency. Generation is local to your browser; nothing is transmitted. See the methodology page.