Greek Letter Generator

What this page draws

One fixed pool: the 24 letters of the modern Greek alphabet, Alpha through Omega, exactly as the engine’s data table lists them. Every result pairs each drawn glyph with its name, because each row of that table holds an uppercase form, a lowercase form and a name, and a draw returns the name with the character — the scripted draw in the intro, Α Π Ω, comes back as Alpha, Pi, Omega. The case control decides which forms make up the pool (uppercase, lowercase, or both as separate entries), “No repeats” switches the engine to drawing without replacement, and the count runs from 1 to 100 letters per draw. Nothing on this page is weighted and nothing is filtered; the sections below explain how a random byte becomes one of those 24 letters and how to read the pool size that every result reports.

The full alphabet, from the engine’s own data

The table below renders directly from the same data table the generator draws from — the one the automated tests check for completeness (24 letters, correct names, no Latin look-alikes). The 7 vowels are α ε η ι ο υ ω; the other 17 letters are consonants.

• Α α — Alpha
• Β β — Beta
• Γ γ — Gamma
• Δ δ — Delta
• Ε ε — Epsilon
• Ζ ζ — Zeta
• Η η — Eta
• Θ θ — Theta
• Ι ι — Iota
• Κ κ — Kappa
• Λ λ — Lambda
• Μ μ — Mu
• Ν ν — Nu
• Ξ ξ — Xi
• Ο ο — Omicron
• Π π — Pi
• Ρ ρ — Rho
• Σ σ — Sigma
• Τ τ — Tau
• Υ υ — Upsilon
• Φ φ — Phi
• Χ χ — Chi
• Ψ ψ — Psi
• Ω ω — Omega

Guide: for the letter-by-letter table — each name with its uppercase and lowercase form, the sigma note, what the automated tests pin, and how the main generator’s include and exclude lists accept Greek input — read The Greek alphabet table. The rest of this page explains how a letter is drawn from that table and how to read what comes back. Guides to the other parts of the engine are listed at /guides/.

How a Greek letter is drawn

Every draw begins as one random byte from the Web Crypto API (crypto.getRandomValues), the same operating-system-backed source browsers use for encryption keys and secure tokens. A byte holds 256 equally likely values; this pool holds 24. The engine keeps only the minimal bits that cover the pool — 5 bits for 24 letters, giving values 0 through 31 — and then checks the result against the pool size. A value from 0 to 23 is accepted and indexes the alphabet table in order: byte 0 is Alpha, 15 is Pi, 23 is Omega — exactly the scripted draw Α Π Ω shown in the intro. A value from 24 to 31 — 8 of the 32 possible masked values — is thrown away entirely and a fresh byte is drawn. Nothing wraps around.

Two scripted calls show the two things that can happen to a byte. First, masking: a byte of 200 keeps only its low 5 bits, which read as 8, and the engine returns Ι (Iota). Second, rejection: fed the bytes 255, 56, 7 in that order, the engine masks the first two to 31 and 24, finds both at or beyond 24, discards them, and accepts the third, returning Θ (Theta) after reading 3 bytes for a single letter. Rejection is the price of exactness: with 24 of 32 masked values accepted, the acceptance rate is 75%, so the engine reads on average 1.33 bytes per letter.

Why not take the remainder of the byte divided by 24 instead? Because 256 is not a multiple of 24: it is 10 × 24 + 16. Remainders 0 through 15 would each occur 11 times among the 256 byte values while 16 through 23 occur only 10, so Alpha through Pi would be about 10% more likely than Rho through Omega. The rejection step removes that bias by construction, which is why the uniformity claim here rests on how the sampler is built rather than on statistical testing after the fact. Every scripted draw on this page is produced at build time by the real engine from fixed bytes, so the page is reproducible; the live tool above uses crypto.getRandomValues instead.

Reading a result: the pool size

Every result reports the exact number of entries it was drawn from. On this page that number is 24 when the case is upper or lower and 48 when it is “Both”; the scripted three-letter draw above reports a pool of 24, and the mixed-case draw below reports 48. Pools are composed in a fixed order — alphabet, then the vowel or consonant filter, then the include list, then the exclude list, then case expansion — and this page fixes the alphabet to Greek with no filter and no lists, so only the case step can change the count. If you need the 7-vowel or 17-consonant Greek pools, or a hand-built subset, the main generator composes them and reports each resulting size; the per-letter probability is always one divided by the number reported.

“Both” is a 48-entry pool, not a coin flip

Choosing “Both” does not draw a letter and then decide its case afterwards. Case expansion is the last step of pool composition, so the engine builds one pool of 48 entries — the 24 uppercase forms first, then the 24 lowercase forms — and draws from it directly, each entry at 1/48. A scripted call with the bytes 3, 27, 47, 20 returns Δ δ ω Φ (Delta, Delta, Omega, Phi) and reports a pool of 48: byte 27 lands past the 24 uppercase entries at lowercase position 3, which is why it produces δ rather than Δ. The sampler widens to 6 bits for this pool, giving values 0 through 63 and rejecting 16 of them, for an acceptance rate of 75%.

Each letter now occupies 2 of the 48 entries, so the chance of drawing some form of a given letter is 2/48, the same 1/24 as a single-case draw — the difference shows elsewhere. With “No repeats” on, Α and α are distinct entries, so a draw can contain both and the limit becomes 48 rather than 24. And the pool size reported with every result tells you which pool was in force; if it reads 48, no coin was flipped after the fact.

No repeats, up to a full permutation

“No repeats” switches the engine to 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 a letter leaves the pool the moment it is drawn. Draw all 24 letters this way and the result is a uniformly random ordering of the whole alphabet, such as Ζ Ε Δ Λ Η Α Γ Ξ Σ Ι Χ Β Μ Ν Κ Ο Θ Ρ Υ Τ Ψ Φ Π Ω — a build-time draw from a fixed byte script, reproducible on every build. There are 24! such orderings, about 6.2 × 10²³, and every one of them is exactly equally likely.

Ask for more unique letters than the pool holds and the engine refuses rather than quietly repeating or quietly truncating. A scripted request for 25 unique letters from the single-case pool returns this message, verbatim: “Cannot draw 25 letters without repeats from a pool of only 24 — allow repeats, lower the count, or widen the pool.” The count itself is bounded the same way — a request for 101 letters, with or without repeats, returns: “How many: enter a whole number from 1 to 100.” Both messages come from the engine, not from page copy, so they cannot drift from what the tool actually does. The permitted range is 1 to 100 letters per draw.

Uniform only — and what that looks like

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. It rules out any weighting of Greek letters by usage or by any other distribution; there is no setting that would add one. A consequence worth stating plainly is that uniform randomness is streaky. A scripted lowercase call that feeds the same byte three times returns σ σ σ (Sigma, Sigma, Sigma), and while that result was scripted for illustration, nothing in a live draw prevents it: whatever the first letter is, the second matches it with probability 1/24, so a 3-letter draw comes up all one letter about once in every 576 such draws. Pool arithmetic from the 24-letter pool gives the rest. The chance that a 6-letter draw with repeats allowed avoids every repeat is 24/24 × 23/24 × 22/24 × 21/24 × 20/24 × 19/24 — each factor the share of the pool not yet drawn — so such a draw contains at least one repeated letter about 49% of the time. And (1 − 1/24)²⁴ is the chance that a specific letter — Omega, say — fails to appear at all in 24 consecutive draws: about 36% of the time. Tools that never show streaks are not more random — they are less. (The example also shows the lowercase sigma the engine uses: the medial form σ, because it draws letters, not words.)

The common misreadings follow from forgetting this. A run of the same letter is not evidence of bias; it is what independent draws at 1/24 produce at the rate given above. A letter that has not appeared in a long session is not missing from the pool; the table above is the pool, and the reported size confirms it. A mixed-case result is not an uppercase draw with a coin flip after it, as the previous section shows. And a lowercase σ in the middle of a run is not a mistake for ς; the engine never outputs the final form, because it does not draw words.

Where this tool stops

It draws uniformly from the 24 modern Greek letters, in upper, lower, or both cases, with or without repeats, 1 to 100 at a time — and nothing else. There is no weighting option and there never will be. It covers the modern alphabet only, not archaic letters or accented forms, and it draws letters rather than words, so sigma is always σ. The uniformity claim rests on the sampler’s construction, described above and on the methodology page, not on any certification or audit; this site makes no such claims. For Latin letters, mixed pools, or vowel and consonant filtering across either alphabet, the main generator has every option in one form; sequences of any length live at Random Letter Sequence. Draws are static-page JavaScript with no server behind them — nothing is logged or stored, and you can confirm in your browser’s Network tab that generating sends no request.

Frequently asked questions

Uniform means uniform: every Greek letter has probability exactly 1/24 per draw (1/48 in mixed case) — no weighting by usage in mathematics or anywhere else. Draws are local to your browser and never transmitted. See the methodology page.