Password Generator

What "password strength" actually measures

Strength meters that say "Weak / Medium / Strong" are estimating one underlying quantity: entropy, the number of bits of unpredictability in the password. For a password built by picking each character independently and uniformly at random from a pool, the formula is exact:

entropy (bits) = length × log2(charset size)

Example: 16 chars from the 94 printable ASCII symbols
       = 16 × log2(94)
       = 16 × 6.555
       ≈ 105 bits

Each extra bit doubles the number of guesses an attacker must make. That is why this is the only honest way to compare passwords. Two consequences surprise most people:

• Length beats complexity. Adding one character to a 94-symbol password adds ~6.55 bits. Switching a 12-character password from lowercase-only (26) to all-symbols (94) adds only ~22 bits total — about the same as adding 3 more characters.
• The formula only holds for truly random passwords. If you choose the characters yourself (a word, a date, P@ssw0rd!), the real entropy is far lower than the formula suggests, because attackers guess human patterns first.

The charset sizes used throughout this page: digits = 10, lowercase = 26, lower+digits = 36, mixed-case letters = 52, alphanumeric = 62, and full printable ASCII (letters, digits, and ~32 symbols) ≈ 94.

Entropy and estimated offline crack time by length & charset

The table below shows the entropy for several length/charset combinations and a rough, order-of-magnitude crack-time tier. Bits are computed with length × log2(charset). Crack times assume an attacker who already has the leaked password hash and runs an offline attack against a fast, unsalted hash (e.g. MD5/NTLM) at ~1 trillion (10^12) guesses per second — a realistic figure for a high-end multi-GPU rig. Time shown is to exhaust half the keyspace (the average expected number of guesses).

These are deliberately rough tiers, not precise predictions. Change the assumed guess rate and every number moves: a slow, properly salted hash like bcrypt or Argon2id caps a single GPU at roughly tens of thousands of guesses per second, making even ~52-bit passwords take years — while a future attacker with a larger cluster guesses faster than 10^12/sec. Use the entropy column, which does not depend on the attacker, as your real comparison metric.

Why a 5-word passphrase can beat a complex 8-character password

When words are chosen by a computer uniformly at random from a known list, each word contributes a fixed, calculable amount of entropy. The Electronic Frontier Foundation's large diceware list has 7,776 words, so each random word adds log2(7776) ≈ 12.9 bits.

5 random words × 12.9 bits  ≈ 65 bits
8 random "all types" chars  ≈ 52 bits

correct-horse-battery-staple-anchor   (memorable, ~65 bits)
Tq7%vR2!                              (hard to type, ~52 bits)

The catch is the word "random." A passphrase is only as strong as its selection process: words you picked yourself because they mean something to you carry almost no entropy. The strength comes entirely from a cryptographic random source choosing the words for you — which is exactly what this generator's passphrase mode does. Use passphrases for the handful of secrets you must memorize (your password-manager master password, your device login); use long random character strings, stored in the manager, for everything else.

How this generator produces randomness (and why it matters)

The entropy formula assumes every character is equally likely and unpredictable. That guarantee is only as good as the random number generator behind it. This tool uses the Web Crypto API:

• Cryptographically secure source. Characters are selected with crypto.getRandomValues(), the browser's CSPRNG seeded by the operating system. Unlike Math.random(), its output is designed to be unpredictable even to someone who has seen previous outputs.
• No modulo bias. A naive random % charsetSize skews probabilities toward lower characters when the range does not divide evenly. A correct generator rejects and re-draws out-of-range values so every character stays equally likely — preserving the full entropy.
• Nothing leaves your device.The site is a static export with no backend. Generation runs in your browser's JavaScript engine; passwords are never transmitted, logged, or stored. Close the tab and they are gone. You can confirm this in DevTools → Network: generating a password makes zero outbound requests.

A strong password is necessary but not sufficient

Most real-world account takeovers do not involve brute-forcing a strong password at all. They involve reuse, phishing, and breaches. High entropy protects you against one specific threat (offline cracking); these habits protect you against the rest:

• Use a unique password for every account. When one site is breached, attackers replay that email/password pair against banks, email, and stores — a technique called credential stuffing. A unique password contains the damage to one account.
• Use a password manager. Unique 16+ character passwords everywhere is only realistic if software remembers them. A reputable manager generates, stores, and autofills them; you memorize exactly one strong master passphrase.
• Turn on two-factor authentication (2FA). Even a perfect password can be phished or keylogged. A second factor — preferably an authenticator app or a hardware security key (FIDO2/WebAuthn) rather than SMS — blocks login without it.
• Prioritize your email and password-manager accounts. Whoever controls your email can reset most of your other passwords. Give those two the longest, most unique credentials and the strongest second factor you have.

Disclaimer: This page is general security education, not professional security advice, and the crack-time figures are rough estimates that depend heavily on attacker hardware and how the target site stores passwords (hash algorithm, salting, rate limiting). Use the entropy values for comparison and follow the published guidance of your organization or a qualified security professional for high-stakes accounts.

Frequently asked questions