Vowel Generator

Guide: this page fixes the first two steps of pool composition and skips the rest. How letter pools are built walks every stage — filter, include list, exclude list, case expansion — with a scripted draw and the engine's real error messages for each.

What this page draws from

Every draw on this site starts from a pool, and a pool is composed in a fixed order: alphabet, then the vowel or consonant filter, then any include list, then any exclude list, then case expansion. This page settles the first two steps and offers no controls for the next two. The alphabet is English, 26 letters, and the filter keeps only the letters the engine's own alphabet data flags as vowels: A, E, I, O, U. That leaves a pool of 5, which is the number the result's Pool line reports after every draw. The flag is data, not a setting you can change here — Y is marked as a consonant in that table, so it belongs to the Consonant Generator's pool of 21, and the main generator's include list is the place to build a different set.

The Case control picks which form of each letter the pool holds. Uppercase gives A E I O U; lowercase gives a e i o u. Either way the pool is still 5 entries. A scripted lowercase draw of the bytes 4 and 0 returns u a — the same byte-to-position mapping as the uppercase pool, with the case applied. Every letter quoted on this page was drawn at build time by the real engine from a fixed byte script, so the examples are reproducible and cannot disagree with the tool; a live draw uses crypto.getRandomValues instead.

From a random byte to a vowel

The engine asks the browser for one random byte — a value from 0 to 255, every value equally likely — and has to turn it into one of 5 letters. It does not divide and keep the remainder. It keeps the smallest number of bits that can cover the pool: 3 bits for a pool of 5, which yields the values 0 through 7. The values 0 through 4 map onto the pool in alphabet order, so 0 is A and 4 is U. The 3 remaining values — 5 through 7 — fit in 3 bits but point past the end of the pool, so the engine throws them away and draws a fresh byte. Nothing wraps around, and no value is folded onto a letter it does not belong to.

Keeping 3 bits means only the low 3 bits of each byte matter. Feed the engine the scripted bytes 8, 17, 26, 35, 44 and it keeps 0, 1, 2, 3, 4, which read off the pool as A E I O U. Rejection is just as visible. The script 13, 4, 7, 1 unfolds as 13 → 5 (rejected); 4 → 4; 7 → 7 (rejected); 1 → 1 — 2 bytes consumed and discarded, 2 letters produced: U E. A rejected byte leaves no trace in the result; the next byte simply takes its turn.

Rejection costs a little. With 5 accepted values out of 8, a candidate is accepted 62.5% of the time, so one vowel costs 1.6 bytes on average and a run of rejections dies out quickly. The acceptance rate is above half for every pool the engine builds, so the expected number of bytes per letter is always below two. What that cost buys is exactness: each vowel keeps a probability of exactly 1 in 5 by construction, and that construction is where the uniformity claim rests — not on statistical testing of the output after the fact.

Why the remainder shortcut is refused

The tempting shortcut is to take the byte, divide by the pool size, and keep the remainder. It is biased whenever the number of byte values is not a multiple of the pool size, and 256 is not a multiple of 5: 256 = 51 × 5 + 1. Count how many of the 256 byte values land on each remainder: 1 of the 5 remainders receives 52 byte values while the other 4 receive 51. Mapped onto the pool, A would be drawn about 2.0% more often than the other vowels. That is a small bias — small enough that casual use would never reveal it — and the engine refuses it anyway, because a tool whose fairness depends on nobody looking closely is not a fair tool. Rejection makes the question moot: every accepted value is exactly one letter, and there is no leftover to distribute.

Uniform only — and what that rules out

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's source and printed here unchanged. On this page it means each of A E I O U is drawn with probability exactly 1 in 5, in whichever case you choose, on every draw, independently of the draws before it. There is no option to make one vowel more likely, no "balanced" mode that nudges the next draw away from the last one, and no weighting by how often the letters turn up in English text. If a weighted pick is what you need, this is not the tool. The pool size on every result is the honest way to read what the tool did do: the chance of any particular letter is one divided by the number shown.

Streaks are what uniform looks like

Uniform randomness is streaky, and a small pool makes streaks common. With only 5 letters, the chance that 3 draws contain a repeat is already 52% — pool arithmetic: one minus 5/5 × 4/5 × 3/5. Draw 5 times and the chance that every draw is the same letter is 1 in 625; that it is one specific letter, say E every time, is 1 in 3,125. The scripted byte 1 repeated 5 times produces exactly that: E E E E E. On a live draw this is rare but not suspicious; a tool that quietly prevented it would be less random, not more. The opposite surprise is just as normal: across 10 draws, a given vowel fails to appear at all about 10.7% of the time — 4/5 raised to the power 10. Over many draws each vowel settles toward 20% of the total, but no single short run is obliged to look that way.

How to read a result

A result is a row of letters and a Pool line. The letters are the draw; the pool size is the denominator. On this page it reads 5 whether you chose uppercase or lowercase, so every letter you see had a 1 in 5 chance on its draw, and a run of n letters was one of 5ⁿ equally likely runs — 125 runs of length 3, 3,125 runs of length 5. With "no repeats" on, the denominator steps down as the pool empties: 5, then 4, down to 1 for the last letter when you draw the whole pool. Copy puts the letters on your clipboard; Reset returns the result panel to its placeholder. Nothing else is produced — no seed, no log, no history — because nothing is kept.

Drawing without repeats

With "no repeats" on, the engine samples without replacement: a drawn vowel leaves the pool, and the next draw is a uniform choice among those left. It is implemented as a partial Fisher–Yates shuffle driven by the same rejection sampler, each position swapping in a uniformly chosen letter from the undrawn remainder. Draw all 5 that way and you get a uniformly random ordering of the whole pool — one of 120 possible orderings, each equally likely — such as A I U E O, the build-time draw for the byte script 0, 1, 2, 3, 4. Draw fewer than 5 and you get a uniformly random ordered sample with no letter twice.

The mode has a hard ceiling: 5 letters cannot supply 6 distinct ones. Ask anyway and the engine does not quietly repeat or quietly stop short — it refuses, with the limit stated. For a request of 6 unique vowels, the message it returned at build time was “Cannot draw 6 letters without repeats from a pool of only 5 — allow repeats, lower the count, or widen the pool.” The count field has the same discipline: it accepts a whole number from 1 to 100, and 101 is refused with “How many: enter a whole number from 1 to 100.” rather than clamped.

Two common misreadings

The first is reading a streak as a fault, covered above. The second concerns mixed case. This page offers uppercase or lowercase; the main generator adds "both cases", and it is worth knowing what that does. It does not draw an uppercase vowel and then flip a coin for its case. It doubles the pool: for the vowel filter, a 10-entry pool — A E I O U a e i o u — with each entry at exactly 1 in 10. Uniqueness then treats A and a as different letters, so a no-repeat draw of 10 is a permutation of all 10 forms. Whichever option you use, the reported pool size tells you which pool you drew from: if it says 10, the odds per entry are 1 in 10, not 1 in 5.

Narrowing the pool, or leaving it

Exclude lists shrink the pool before any draw. On the main generator, the vowel filter with E excluded is a pool of 4 — A I O U — and the engine resizes the bit width to match: 2 bits cover a pool of 4 exactly, so no candidate is ever rejected for that pool, and each remaining vowel is drawn at 1 in 4. The How letter pools are built guide demonstrates each stage of the composition order with its own scripted draw and shows the exact error the engine returns when a list contains something that is not a letter of the alphabet. The Consonant Generator draws from the other 21 letters, the Random Letter Sequence tool renders whole strings, and the Greek Letter Generator covers the Greek alphabet, whose vowel filter keeps 7 letters (α ε η ι ο υ ω). The guides are collected at /guides/.

Frequently asked questions

Uniform means uniform: each vowel 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.