A password is not “strong” because it looks busy. Under an ideal random draw, strength is mostly an **entropy budget**: how large the search space is for a given **length** and **character pool**. This guide owns that framing, a verified Everyday-16 vs PIN twin, a fixed-pool **length ladder**, and local **CSPRNG** generation. Open the Password Generator for the live entropy twin, charset peel, and ladder.
What this guide owns
- Entropy budget versus character-class policy.
- Charset peel (classes + filters → pool size).
- Length ladder on a fixed pool.
- Local CSPRNG generation and policy-only Share links.
It is not a paint buy-list shelf and not a one-rep-max formula twin.
Entropy budget vs character policy
pool_size = unique characters after class toggles + filters entropy_bits ≈ length × log2(pool_size) band = map(bits) → weak / modest / solid / strong
Band thresholds used by the tool (educational sketches):
| Band | Entropy bits | |---|---| | Weak | under 40 | | Modest | 40 to under 60 | | Solid | 60 to under 80 | | Strong | 80 and up |
Character classes (lower, upper, digits, symbols) grow the pool. Filters such as **exclude ambiguous** shrink it on purpose for readability. Length multiplies whatever pool remains. Once classes are already on, **length is usually the cheapest way to raise bits**.
The toy “crack time” line on the calculator is a fantasy guess-rate sketch (about 10¹² guesses/s). Real attacks use leaked password lists, throttling, and hash specifics. Do not treat it as a lab guarantee.
Charset peel
The peel counts how many glyphs remain in each class after filters, then the combined unique pool.
Ambiguous glyphs filtered when that option is on (tool alphabet): characters that often confuse humans (`i`, `l`, `1`, `L`, `o`, `0`, `O`, and a couple of look-alikes). Brackets can be excluded separately when sites or scripts choke on them.
**Exclude ambiguous on vs off** (same Everyday classes, length 16):
| Filter | Pool size | Entropy bits (approx.) | Band | |---|---:|---:|---| | Ambiguous excluded | 85 | ~102.6 | Strong | | Ambiguous included | 94 | ~104.9 | Strong |
The bit delta is small. Ambiguous exclusion is mostly a usability choice. Length and “digits-only PIN” mistakes move the band far more.
Verified twin: Everyday 16 vs PIN sketch
**Everyday 16** (all classes, ambiguous excluded):
length = 16 pool ≈ 85 bits ≈ 16 × log2(85) ≈ 102.6 → strong sketch
**PIN sketch** (6 digits only):
length = 6 pool = 10 bits ≈ 6 × log2(10) ≈ 19.9 → weak sketch
| Policy | Pool | Bits | Band | |---|---:|---:|---| | Everyday 16 | ~85 | ~102.6 | Strong | | PIN 6 digits | 10 | ~19.9 | Weak |
That is the twin: same tool, same entropy math, opposite bands. A busy-looking short digit string is still a tiny search space. Rerun both presets on the Password Generator to confirm.
Length ladder (fixed pool)
Hold the Everyday pool (~85) fixed and change length only:
| Length | Entropy bits (approx.) | Band | |---:|---:|---| | 8 | ~51.3 | Modest | | 12 | ~76.9 | Solid | | 16 | ~102.6 | Strong | | 20 | ~128.2 | Strong | | 24 | ~153.8 | Strong |
Climbing 8 → 16 on the same pool roughly doubles the bits. Adding a fourth character class after three are already enabled usually helps less than adding four more characters of length.
Other presets for comparison:
| Preset | Sketch | |---|---| | Alphanumeric 20 | No symbols, longer; pool ~55 → ~115.6 bits (strong) | | High entropy 24 | Full pool ~94 → ~157.3 bits (strong) |
Local CSPRNG, not Math.random
Generation uses **`crypto.getRandomValues`** in the browser (see MDN), with rejection sampling for uniform picks. Enabled classes get at least one character when length allows, then the string is shuffled. Nothing is sent to a server to create the password.
**Share / Copy link** writes length and charset **policy flags only**. The generated secret stays in page memory until you copy it yourself. Never put passwords in URLs, tickets, or chat.
How to run a clean generation
- Pick a scene preset (Everyday 16, Alphanumeric 20, High 24) or set length and classes.
- Read the charset peel and entropy / band twin.
- Scan the length ladder; tap a rung if you want more bits on the same pool.
- Generate locally; copy into a password manager.
- Share the **policy** link only if you want someone else to regenerate under the same rules, not the secret itself.
Sibling technology literacy: Data size, Download time, Binary / hex. For general randomness demos (not secrets), see the Random number generator.
Policy literacy (NIST / OWASP direction)
Modern guidance (see NIST SP 800-63B and OWASP Authentication Cheat Sheet) emphasizes:
- Prefer **longer** secrets over clever composition rules alone.
- Allow paste so managers work.
- Check new passwords against known-breached lists where the service supports it.
- Use **unique** passwords per account; reuse is the quiet failure mode.
- Prefer MFA on important accounts; a generator does not replace a second factor.
Site rules that force short maximum lengths or ban paste are site policy friction, not a reason to reuse one short password everywhere.
Common failure modes
- Treating a toy crack-time label as a real attack model.
- Shipping a 6-digit PIN mindset into account passwords.
- Reusing one “strong” password across banks, mail, and shopping.
- Putting the generated string in a Share URL or screenshot.
- Using `Math.random` / brain-made patterns and calling them random.
- Expecting this page to store, sync, or audit your vault.
When not to rely on this page alone
- Enterprise SSO, hardware keys, or regulated identity systems.
- Recovering a breached account (change secrets elsewhere; monitor recovery channels).
- Designing an authentication product (follow current standards and threat models).
- Situations where a full password manager + MFA is the actual control, and generation is only the first step.
FAQ
How does the generator work?
It builds a character pool from enabled classes and filters, estimates entropy as length × log2(pool size), and draws passwords in your browser with a CSPRNG. Share links store policy only, never the secret.
What is the entropy twin?
Entropy bits estimate search-space size under an ideal random draw. The strength band maps those bits into weak / modest / solid / strong sketches. Literacy, not a lab grade of your account risk.
What is the length ladder?
It keeps your character pool fixed and shows entropy at 8, 12, 16, 20, and 24 characters so length’s effect is visible without guessing.
Is the crack-time number real?
No. It is a toy sketch at a fixed fantasy guess rate. Real attacks use leaked lists, throttling, and hash specifics.
Are passwords put in the URL?
No. Share / Copy link writes policy flags only. The generated password stays in page memory until you copy it.
Is this a password manager?
No. It does not store, sync, autofill, or audit reused passwords. Prefer a reputable manager for long-term secrets.
Bottom line
Build a pool, multiply by length, read the band, then generate locally with a CSPRNG. Run the Everyday-16 vs PIN twin and the length ladder on the Password Generator, store the secret in a manager, and keep Share links policy-only.