Back to Developer
Pronounceable password generator (CVCV, memorable + secure)

Pronounceable password generator (CVCV, memorable + secure)

Generate **pronounceable** passwords by alternating **consonant + vowel** so the result reads as syllables — `Karipo23`, `MofeJivo` — much easier to remember than `x7@K!w`. Configurable length (4–32 chars), 0–4 trailing digits, optional symbol suffix, optional capitalisation of every syllable's first letter. Uses **`crypto.getRandomValues`** under the hood for cryptographically strong randomness and displays the entropy (search-space bits) for each password. Generate up to 50 candidates at once and pick the one you like.

How to use

Generate **pronounceable passwords** by alternating consonants and vowels — `Karipo23`, `MofeJivo` — so the result reads as syllables and stays memorable. Adjust length (4–32), trailing digits (0–4), an optional trailing symbol, capitalisation of each syllable's first letter, and the count to generate (1–50). Randomness comes from **`crypto.getRandomValues`** (Web Crypto API, cryptographically secure — no `Math.random`). **Entropy** is shown per password and colour-coded: <40 bit = weak, 40–60 = fair, 60–80 = strong, 80+ = very strong. Great for Wi-Fi keys, initial PINs, or any password a human has to read aloud.

In depth

Pronounceable passwords and their unique exposure path

Pronounceable passwords are designed for situations where a human reads them aloud, types them from a sticky note, or dictates them over a phone call. Guest Wi-Fi credentials, onboarding PINs, conference-room door codes — these are the natural uses. The operational goal is accurate human transmission, not just cryptographic strength.

The distinctive risk of pronounceable passwords is that their ease of transmission multiplies the number of times they travel through the world. They get re-used longer than random passwords; more people tend to know them. If the generation step itself involves a round-trip to a server, the password’s exposure starts before the first use.

What online generators send to their servers

Online pronounceable password generators make a network request to produce the result. The generated password travels in the HTTP response body and can land in server access logs or application logs. HTTPS protects the data in transit, but the server operator sees the full request and response.

Pronounceable passwords used for Wi-Fi or shared access codes tend to have long lifespans — the same credential stays in use for months. A password captured in a server log at generation time remains valid long after; when that log leaks in a future breach, the credential is still live. Fully random passwords, which are typically rotated more aggressively, face a shorter exposure window.

Static CV table plus crypto.getRandomValues

This tool bundles a static consonant list (b/c/d/f/g/h/j/k/l/m/n/p/q/r/s/t/v/w/x/y/z, 21 characters) and a vowel list (a/e/i/o/u, 5 characters) as page-local data. Random selection uses crypto.getRandomValues() from the Web Crypto API, which draws from the OS entropy pool — unlike Math.random(), which is a PRNG explicitly documented as unsuitable for security use. Rejection sampling removes modulo bias when mapping random bytes to these small character sets.

Generated passwords live only in page memory. No network request fires during generation or copy. Open DevTools Network before generating a batch: the tab stays empty. The source is on GitHub, where the absence of external API calls is auditable at the implementation level.

When to use pronounceable versus fully random

Fully random passwords win on entropy per character (~6.6 bit/char for a 94-character pool). Pronounceable patterns produce around 4.4 bit/char. For server-to-server API keys, certificate private keys, and database credentials, use password-generate with the full character set.

For credentials a human will type, read aloud, or write on a whiteboard, pronounceable passwords reduce transcription errors and support the case where accurate transmission matters more than squeezing maximum entropy per character. NIST SP 800-63B explicitly accounts for memorability. The 12-letter plus 2-digit default reaches roughly 45 bits; bump length to 16+ if the threat model needs more.

Pronounceable password algorithms: FIPS 181 and the CVCV model

Automatic generation of pronounceable passwords has a longer history than one might expect. FIPS 181 (Automated Password Generator, published 1993, withdrawn in 2015) defined the most widely cited approach: (a) a probability table of English phoneme digrams and trigrams, (b) a Markov-chain-style state machine that emits English-like syllables, (c) randomness drawn from ANSI X3.92 (DES-based) primitives. NIST retired FIPS 181 itself in favour of guidance in SP 800-63B (2017), which moved memorability into the recommendation for passphrases via EFF’s Diceware approach.

This tool uses a simpler CVCV model — alternating consonant and vowel — rather than the FIPS 181 English-phoneme distribution. With 21 consonants and 5 vowels, each CV pair has 105 possible values, giving log2(105) ≈ 6.71 bits of entropy per pair, or 6.71 × N bits total for N pairs. Because each position is uniformly sampled rather than weighted toward English phoneme statistics, the output is less English-like than FIPS 181 but also less vulnerable to dictionary-style attacks that exploit phoneme distributions. The CVCV model deliberately trades a small amount of pronounceability for resistance to corpus-based guessing.

Comparison with Diceware passphrases and hybrid strategies

A widely used alternative is Diceware (the EFF wordlist): 7,776 carefully selected English words (= 6^5, five dice rolls), from which six to eight are chosen uniformly at random and concatenated to form passphrases like correct horse battery staple (the XKCD 936 example). Each word contributes log2(7776) ≈ 12.92 bits, so six words give about 77 bits — comparable to a 12-character output from this tool (~80 bits). A Japanese-language Diceware list exists (maintained by Tatsuhiko Matsuzaki).

Passphrase strengths: (a) word-level units cut down on transmission errors when read aloud, (b) typing is fast, (c) recall is strong. Weaknesses: (d) length limits in legacy systems (some still cap at 16 characters) make them impossible to enter, (e) some systems disallow spaces, (f) personalised word choices (favourite movies, internal slang) erode entropy because they aren’t uniformly random anymore. CVCV passwords from this tool work where length caps apply and fit operational needs like Wi-Fi WPA2 PSKs or short voice-transmitted codes. The two approaches are complementary rather than competing: use this tool for short, voice-friendly secrets that go into a password manager, and reserve Diceware for a few master credentials that must live in human memory. To grade the entropy of the chosen output, password-strength-check runs the analysis locally.

FAQ

Is my input uploaded?
No. Everything runs in your browser. Generated passwords are only shown on screen and copied via clipboard — nothing is logged or sent anywhere.
Why pronounceable passwords?
**Easier to memorise and dictate.** `x7@K!w` is hopeless to read out over a phone call; `MofeJivo23` becomes `mo-fe-ji-vo-twenty-three`. Ideal for guest Wi-Fi credentials, onboarding new staff, conference-room codes — anywhere a human is doing the actual typing.
Is it secure?
**Randomness**: `crypto.getRandomValues` (Web Crypto API), not `Math.random`. **Entropy**: 12 letters + 2 digits at default settings is ~45 bits (35 trillion combinations) — enough to survive normal offline attacks for a while. For crypto-key territory aim for 80+ bits. Note: pronounceable patterns are weaker per character (~4.4 bit/char) than fully random ASCII (~6.6 bit/char in `password-generate`), so size up if you want stronger.
What's the CV pattern?
**Consonant–Vowel alternation**: pick C, then V, then C, then V… Vowels are a/e/i/o/u (5). Consonants are b/c/d/f/g/h/j/k/l/m/n/p/q/r/s/t/v/w/x/y/z (21). Awkward consonant clusters (`rl`, `sk`, `tn`) never appear because we strictly alternate.
Why digits and a symbol at the end?
**Policy compliance** — many sites require at least one digit and one symbol. They're appended (not prefixed) so the pronounceable body stays intact. Set digits to 0 and the symbol off if you want a pure CV string.
What does 'capitalise' do?
Capitalises **the first letter of every 2-syllable group** (`KaRiPoMu`) — adds visual variety without breaking pronounceability. Off → all lowercase (`karipomu`).
Recommended length?
**3–4 syllables (6–8 letters) + 2–4 digits** is the sweet spot for memorability vs entropy. `MofeJivo + 2347` ≈ 60 bits. Generate 5–10 candidates at a time and pick the most pleasant-sounding one.
Isn't fully random always safer?
**Per character, yes**, but humans can't memorise it and end up writing it down (where leaks happen). For human-handled passwords, pronounceable forms are often *operationally* safer (NIST SP 800-63B specifically weighs memorability). Use fully random for service-to-service keys, pronounceable for anything a human will type.
Can I reproduce results with a seed?
**No — by design.** A reproducible seed would let an attacker reconstruct every password if they knew or guessed the seed, which destroys security. We pull fresh entropy from the OS each call.

How to verify nothing is uploaded

This tool never sends your input outside your browser. The pages below explain how it works, how to audit it, and how the site is run.

Related tools

Password generator — strength, char sets, length

Password generator — strength, char sets, length

Generate strong random passwords in batches of 1–25. Pick length, character sets, and toggle look-alike exclusion. Backed by crypto.getRandomValues and runs entirely in your browser.

developersecuritygenerate
Password Strength Check (zxcvbn score / crack time / feedback)

Password Strength Check (zxcvbn score / crack time / feedback)

Runs Dropbox's `zxcvbn-ts` (MIT) inside your browser to estimate password strength: a 0–4 score, log2 entropy, raw guess count, estimated crack time under four attack scenarios (online throttled, online unthrottled, offline slow hash, offline fast hash), and the detected weakness patterns (dictionary, sequence, repeat, date, keyboard, l33t). Feedback (warning + suggestions) is shown in your locale. Input is masked by default with an eye-toggle and an option to highlight look-alike characters (i/l/1/L/o/0/O). Nothing is uploaded — analysis runs entirely in your browser.

developersecurity
UUID generator — v4 / v7 batch generation

UUID generator — v4 / v7 batch generation

Generate UUID v4 (random) or UUID v7 (timestamp-prefixed) in batches of 1–100. Backed by crypto.getRandomValues and runs entirely in your browser.

developergenerate
1D Barcode Generator — EAN, UPC, Code 128, Code 39 (PNG / SVG)

1D Barcode Generator — EAN, UPC, Code 128, Code 39 (PNG / SVG)

Free online 1D barcode generator. Create EAN-13 / EAN-8, UPC-A, Code 128, Code 39, ITF, Codabar (NW-7), MSI, JAN barcodes from numbers or text and export as PNG or SVG. Tune bar width, height, color, margin, and human-readable label. Check digits validated automatically. Everything is generated inside your browser — the value you enter never leaves your device.

developergenerateimage