How to Use a Random Word Generator (and Why Your Passphrase Has Less Entropy Than You Think)

The problem: the words are random, but the randomness has limits

A random word generator does one thing: it picks items from a list using a random number. That sounds simple enough for brainstorming and games, where it is simple. But when people use random word generators to build passphrases, the same tool that works fine for naming a character in a story can produce passwords that are weaker than they appear. The issue is not the word selection itself — it is the size of the word list, the number of words picked, and the quality of the random source. Get any of those wrong and your four-word passphrase has less entropy than a six-character password.

The tool handles word selection, filtering, and passphrase generation. Understanding what it does and does not do is the difference between a useful creative aid and a false sense of security.

Fastest path

Open the Random Word Generator, pick a mode (words, sentences, paragraphs, or passphrase), choose a word type or category if you want to narrow the pool, set the count, and click generate. For passphrases, switch to passphrase mode, set the word count (4 to 8), and the tool estimates entropy and labels the strength.

How the randomness works

The tool uses Math.random(), JavaScript's built-in pseudorandom number generator. Each call returns a float between 0 and 1, which the tool multiplies by the word list length and floors to get an index. This is uniform selection — every word in the list has equal probability of being chosen.

Math.random() is a PRNG (pseudorandom number generator), not a CSPRNG (cryptographically secure pseudorandom number generator). The difference matters depending on what you are doing. For brainstorming, game prompts, creative writing, and placeholder text, Math.random() is fine. For generating passphrases that protect real accounts, a PRNG is theoretically predictable — a sufficiently sophisticated attacker who knows the PRNG algorithm and its internal state could reproduce the output. In practice, browsers seed Math.random() from system entropy (timing events, hardware noise), making prediction extremely difficult. But "extremely difficult" is not "impossible," and security standards require CSPRNG (via crypto.getRandomValues in the browser) for anything that needs to be cryptographically unpredictable.

The tool uses Math.random() because it is a general-purpose word generator, not a dedicated password tool. If you need a cryptographic password, use the Password Generator, which uses crypto.getRandomValues.

Passphrase entropy: the math that determines strength

Passphrase strength is measured in bits of entropy. The formula is:

Entropy = wordCount × log2(wordListSize)

The tool's passphrase list has 100 words. log2(100) ≈ 6.64 bits per word. So:

4 words:  4 × 6.64 = 26.6 bits  → Weak
5 words:  5 × 6.64 = 33.2 bits  → Weak
6 words:  6 × 6.64 = 39.8 bits  → Fair
7 words:  7 × 6.64 = 46.5 bits  → Fair
8 words:  8 × 6.64 = 53.1 bits  → Strong
12 words: 12 × 6.64 = 79.7 bits → Very Strong

The tool shows these labels and bit counts directly. For comparison, a random 8-character password using lowercase, uppercase, digits, and symbols (about 6.5 bits per character) gives roughly 52 bits — about the same as 8 passphrase words. The passphrase is easier to remember but longer to type.

The Diceware method, which popularized this approach, uses a 7,776-word list (the result of rolling five dice). log2(7776) ≈ 12.9 bits per word. That is nearly double the entropy per word compared to the tool's 100-word list. Four Diceware words give 51.6 bits — as strong as 8 words from this tool's list. The word list size is the single biggest factor in passphrase strength, and it scales logarithmically: doubling the list adds 1 bit per word.

How filtering destroys entropy

The tool lets you filter words by starting letter, ending letter, and length before generation. This is useful for creative work (alliteration, rhyming, fixed-length constraints) but catastrophic for passphrase strength.

If you filter the 100-word passphrase list to words starting with "a," you might have 5 words left. log2(5) ≈ 2.3 bits per word. Four words from that filtered pool give 9.2 bits — about as strong as a two-character password. The entropy calculation in the tool assumes the full list; it does not account for your filters, because filters are applied in the word-generation mode, not the passphrase mode. But if you were to apply the same filtering logic to passphrase generation, the result would be dramatically weaker.

The principle: any constraint on the random selection reduces entropy. If you pick words that "sound good together," start with a specific letter, or avoid certain categories, you are no longer selecting from the full pool, and the entropy formula no longer applies. True random passphrases look like "apple cliff quota wrist" — four unrelated words from the full list. If your passphrase reads like a sentence, it is not random.

Sampling with and without replacement

The tool has a "unique only" option that prevents duplicate words. This changes the sampling from with replacement (each pick is independent, duplicates allowed) to without replacement (each pick removes the word from the pool).

For creative work, unique-only makes sense — you do not want the same word appearing three times in a brainstorming list. For passphrase entropy, the difference is negligible. With a 100-word list and 4 words, sampling without replacement reduces the entropy by about 0.06 bits compared to sampling with replacement. The exact formula for sampling without replacement is log2(100 × 99 × 98 × 97) ≈ 26.5 bits vs 4 × log2(100) ≈ 26.6 bits. The difference is tiny and gets even smaller as the word list grows. For practical purposes, unique-only does not meaningfully change passphrase strength.

The tool's shuffle function uses Fisher-Yates, the standard unbiased algorithm for randomizing an array. It iterates from the last element to the first, swapping each with a randomly chosen element from the remaining unshuffled portion. This produces a uniformly random permutation — every arrangement is equally likely.

Gotchas

• Math.random is not crypto-safe. The tool is fine for creative work and general-purpose word generation. For passphrases protecting sensitive accounts, use a tool that calls crypto.getRandomValues instead. The Password Generator does this.
• A 100-word list is small for passphrases. The Diceware list (7,776 words) gives nearly 13 bits per word. This tool's 100-word list gives 6.6. You need 8 words from this tool to match 4 Diceware words. The tool's entropy estimate is honest about this — it shows "Weak" for 4 words — but users may not realize the list size is the bottleneck.
• Filtered words are not random. If you use the word generation mode (not passphrase mode) with filters to build a passphrase manually, the entropy is determined by the filtered pool size, not the original list. Five words starting with "s" from a pool of 8 s-words is 5 × log2(8) = 15 bits — weaker than a 3-character password.
• Generated sentences and paragraphs are nonsense. The tool constructs sentences by picking random words, capitalizing the first, and adding a period. The result is grammatically meaningless — "Ocean whisper thunder gently." This is fine for placeholder text in design mockups but not for lorem ipsum replacements where readable filler text is needed. Use it for structure, not for content.
• Favorites and history are stored in localStorage. If you generate passphrases and they appear in history, anyone with access to your browser can see them. The tool does not encrypt or clear history automatically. Clear the history after generating sensitive passphrases, or use a dedicated password tool that does not persist output.

Summary

• The tool uses Math.random(), a pseudorandom generator. Fine for creative work, not for cryptographic security. Use the Password Generator for that.
• Passphrase entropy is wordCount × log2(wordListSize). The tool's 100-word list gives 6.6 bits per word, so you need 8+ words for a "Strong" passphrase. A 7,776-word Diceware list gives 12.9 bits per word — twice the entropy in half the words.
• Filtering by letter, length, or category reduces the effective word pool and destroys entropy. If your passphrase has a pattern (alliteration, specific length), it is weaker than the entropy estimate suggests.
• Use the Random Word Generator for brainstorming, game prompts, and creative projects. Check passphrase strength with the Password Strength Checker, and count words in generated output with the Word Counter.