Guides

The generators on this site do one thing: they draw letters. These guides explain what happens between pressing Generate and reading the result — where the random bytes come from, how a byte becomes a letter without bias, how the pool is assembled before any draw, what changes when repeats are forbidden, and what "uniform" does and does not promise. They are written to the same standard as the methodology page: every figure is computed from the engine at build time, and every worked draw is run through the real engine from a scripted byte source and labelled as such. The generators themselves draw live from crypto.getRandomValues; scripted bytes appear only so a page can show a reproducible example.

The guides also mark where the engine stops: one pool at a time, every entry exactly equally likely, and that is the whole claim. The sentence the engine exports for page copy, 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. Each guide below elaborates one part of that sentence; none of them contradicts it.

How a random letter is drawn

The path from a random byte to a letter on screen. The engine fills a one-byte buffer from the Web Crypto API, keeps the lowest 5 bits for the 26-letter English pool, and either accepts the value as a position in the pool or throws it away and draws again. The guide walks through that path with scripted bytes — 0, 7, 25 produce A H Z, the same illustration the methodology page uses — and includes a byte that is rejected and redrawn. It also pins down what "cryptographically uniform" means here: cryptographic-quality input bytes mapped to letters by a construction that preserves uniformity, nothing more.

Rejection sampling, explained

Why the engine rerolls instead of taking a remainder. A byte holds 256 values, which is not a multiple of 26: dividing and keeping the remainder gives the first 22 letters 10 byte values each and the last 4 only 9, so A–V would be about 11% more likely than W–Z. The guide computes those counts from 256 and the pool size, then shows the fix: keep 5 bits (values 0–31), reject 26–31, and redraw. For the English pool that accepts 81.25% of candidates, so a letter costs 1.23 draws on average and never wraps around. The uniformity claim rests on that construction, not on statistical testing after the fact.

How letter pools are built

The fixed order in which a pool is composed before any byte is drawn: alphabet, then the vowel or consonant filter, then the include list as an intersection, then the exclude list as a subtraction, then case expansion. The guide runs the engine at each stage and prints the pool size it reports — 5 vowels, 21 consonants, 52 entries once both cases are expanded. That last figure is the common misreading: "both cases" is a genuine 52-entry pool with each form at 1/52, not an uppercase draw followed by a coin flip. Include and exclude lists are validated against the selected alphabet — a character outside it is an error, never silently dropped — and an empty pool is reported, not drawn from. The guide renders those error messages from real rejected calls.

Drawing without repeats

What "no repeats" switches on: sampling without replacement, implemented as a partial Fisher–Yates shuffle driven by the same rejection sampler. Each position swaps in a uniformly chosen letter from those not yet drawn, so drawing the whole pool yields a uniformly random permutation of it. The guide steps through the shuffle with scripted bytes so every swap can be followed, and shows the refusal the engine issues when the count exceeds the pool — asking for 6 distinct vowels from a 5-letter pool, for instance — quoting the engine's actual message and limit.

Uniform randomness and streaks

Uniform randomness is streaky, and this guide puts figures on it using nothing but pool arithmetic. The chance that a 6-letter sequence from the 26-letter pool contains at least one repeated letter is 1 − ∏(1 − k/26) for k from 0 to 5, about 46%. The odds that 5 vowel draws all come up the same letter are (1/5)^5, exactly 1 in 3,125. It also computes the chance of a specific letter never appearing in a run, and ends on the methodology page's one-line point: tools that never show streaks are not more random — they are less.

The Greek alphabet table

The 24 letters the Greek generator draws from, Alpha through Omega, each with its uppercase form, lowercase form, and name, rendered on the guide from the engine's own data rather than retyped. It covers the one detail that trips up include and exclude lists: lowercase sigma is stored as the medial form σ, and the final form ς is accepted in those lists as Sigma. It also lists what the automated tests pin — exactly 24 entries, the full name sequence, distinct glyphs, no Latin look-alike characters standing in for Greek ones — and shows how a Greek include list narrows the pool. It stays within what the engine knows about these letters.

From the guides back to the generators

Every guide describes the engine behind the main generator, which carries all the options — 1 to 100 letters, either alphabet, any case, filters, include and exclude lists, repeats on or off — and behind the focused pages: the Vowel Generator, the Consonant Generator, the Random Letter Sequence, the Uppercase & Lowercase Letters page, and the Greek Letter Generator. The methodology page is the condensed account of the same material, and the about page says who publishes the site and what it declines to claim.

Uniform means uniform: every guide here describes one engine, in which each letter of the active pool is drawn with equal probability — never weighted by English usage. Draws happen locally in your browser and are never transmitted. Details on the methodology page.