Generate strong, memorable passphrases (Diceware-style) from a curated English wordlist. Each word contributes exactly 10 bits of entropy from the 1024-word list; the tool surfaces the total bit-strength and a simple classification so you know at a glance whether your passphrase is strong enough for your use case.
How it works
- Pick a word count (3–20).
- Pick a separator (dash, space, dot, underscore, or none).
- Optionally capitalise first letters.
- Click Generate.
The tool lazily loads the wordlist on first click (dynamic import keeps the homepage small) and uses crypto.getRandomValues via rejection sampling to pick uniform-random words. Each word pick is independent; the output passphrase is the words joined with your chosen separator.
Entropy and strength
Entropy is calculated as words × log2(1024) = words × 10 bits. With the 1024-word list:
| Words | Bits | Strength | Example use |
|---|---|---|---|
| 3 | 30 | weak | not for anything real |
| 5 | 50 | okay | low-stakes online accounts |
| 7 | 70 | strong | most important accounts |
| 10 | 100 | very strong | key encryption, backup passphrases |
| 12 | 120 | very strong | overkill for practical purposes |
For reference: a random 8-character alphanumeric password has ~48 bits of entropy (weak by modern standards). A random 12-character alphanumeric is ~71 bits (strong). A 7-word passphrase matches that while being vastly easier to remember.
Example: 6-word passphrase
Click Generate with count=6, dash separator. Typical output: flash-window-pilot-mount-basic-river. That’s 60 bits of entropy — strong enough for most accounts, easy enough to type from memory after a handful of tries, and trivially faster to type than the equivalent random-character password.
Example: high-strength key passphrase
For encrypting a long-term secret (e.g., a gpg key passphrase or a password-manager master): 10 words = 100 bits of entropy. That’s far beyond anything practically breakable with current or foreseeable technology. Writing this one down and storing it somewhere safe is reasonable — the strength is in the randomness, not in keeping it purely in your head.
xkcd 936 reference
The canonical argument for passphrases over passwords: xkcd 936: “Password Strength” pointed out that memorising “Tr0ub4dor&3” (a password with ~28 bits of entropy) is harder than memorising “correct horse battery staple” (44 bits of entropy, from a 2048-word list). This tool is the digital version of the dice-rolling scheme the comic implicitly references.
Why not random characters?
Entropy-per-character of a memorised random string is much lower than people assume. Humans remember structure — phonemes, morphemes, meaningful chunks — not arbitrary characters. A passphrase of common words gets the structure for free: it’s a sequence of real words, which your brain is already optimised to encode. A random character string of the same bit-strength is much longer and much harder to recall correctly.
The downside: passphrases are longer to type. If that matters (mobile, frequent login), a shorter high-entropy character string stored in a password manager is the better trade-off. Passphrases shine for the one or two master secrets you actually have to remember.
What this tool does not do
It doesn’t save or sync passphrases. Each generation is standalone; nothing persists. For real password management, use a dedicated password manager (Bitwarden, 1Password, KeePass) and let it generate random characters of whatever length you need.
It doesn’t check passphrases against breach databases. A passphrase generated here won’t have been breached (it’s new), but if you’re also testing existing passphrases against leaked-password lists, use a dedicated tool like HaveIBeenPwned.
It doesn’t enforce site-specific password policies. If a system requires specific characters (uppercase, digits, symbols), a passphrase might not pass its validator even though it’s much stronger than what the policy requires. Workaround: add a digit and symbol manually, or use the character-class password generator instead.
It doesn’t use the full EFF Diceware wordlist. Our list is 1024 words (10 bits/word); the official EFF list is 7776 (~12.9 bits/word). The difference matters at the margin but rarely in practice — add one or two extra words if you want to match EFF entropy levels.
It doesn’t support non-English wordlists. Other-language Diceware lists exist (EFF publishes several); adding them would require bundling larger wordlists. For character-based passwords instead of word-based passphrases, the password generator handles length and character-class requirements.