Password Generator

How to use the Password Generator

1. Set the length first. Drag the slider or type a number between 4 and 128. Length does more for strength than any mixture of symbols: going from 12 to 16 characters adds far more guessing work than adding a symbol set to a short password.
2. Choose the character sets the site allows. All four sets give the largest alphabet to draw from. If a site forbids symbols, untick them here rather than generating with symbols and deleting some by hand — hand-editing breaks the randomness the strength figure assumes.
3. Consider excluding ambiguous characters only when a human will read it. If the password goes straight into a password manager, keep 0, O, 1, l and I in the set. If someone will read it over the phone or type it from paper, exclude them and accept the slightly smaller set.
4. Generate and read the strength line. It states the entropy estimate in bits and a plain-language label, calculated from the length and the exact size of the set you selected — change the settings and the figure moves with them.
5. Copy it straight into its home. Use the Copy button, paste the password into the account and your password manager, and do not reuse it anywhere else. If you need another, generate again — the history list keeps this tab’s recent passwords, up to 20, so a generated password is not lost when you generate the next one.

Worked example

Random output cannot be checked by eye, so this example replaces the random source with a fixed test byte sequence — the same technique the generator’s own test suite uses. With the settings below, the character set holds 88 characters, so the rejection limit is 176: any byte of 176 or more would be discarded and redrawn. Every test byte here is below 176, so each byte selects one character directly, at the position equal to the byte’s value. Byte 0 selects a, byte 26 selects A (the first uppercase letter, right after the 26 lowercase ones), byte 52 selects 0, byte 62 selects ! and byte 87 selects /, the last character in the set. Feeding the sequence through the generator’s own code produces exactly this:

Settings: length 16, all four sets selected, exclude ambiguous off
Character set size: 88
Test byte sequence: 0, 25, 26, 51, 52, 61, 62, 87, 10, 35, 60, 70, 5, 30, 55, 80
Generated password: azAZ09!/kJ8(fE3;
Entropy estimate: 103.4 bits — Very strong

Two things are worth noticing. First, the example password is published here on purpose as a worked example — never use it, or anything like it, as a real password; the value of the example is the arithmetic, not the string. Second, compare the estimate with weaker settings calculated the same way: an 8-character password drawn from lowercase letters only (a set of 26) comes to 37.6 bits, labelled Fair, while 12 characters drawn from letters and digits (a set of 62) come to 71.5 bits, labelled Strong. Nothing about the generator changed between those figures — only length and set size, the two numbers in the formula on this page. The Load sample settings button above applies the example’s settings (16 characters, all four sets) and generates a fresh password from real randomness, so yours will differ from the example string, as it should.

Where password strength actually comes from: randomness and entropy

A password’s strength against guessing is not a property of how it looks. A string full of symbols that a person chose — a favourite word with letters swapped for lookalike digits, a keyboard pattern, a name with a year added — can be weak, because attackers try those shapes early and in bulk. Strength, in the sense this tool reports it, comes from unpredictability: how many equally likely possibilities the password was drawn from. That count is expressed in bits of entropy. If a password of length L is drawn uniformly at random from a set of N characters, the entropy is L × log₂(N). Sixteen characters from a set of 88 gives about 103.4 bits, which corresponds to a space of possibilities so large that trying them one by one is not a practical attack, even with fast hardware — provided the drawing really was uniform, and provided the password is stored properly by the site on the other side.

Making the drawing uniform is an engineering detail that is easy to get quietly wrong. This generator takes its randomness only from the browser’s cryptographic source, crypto.getRandomValues. Turning a random byte (0–255) into a character index with a simple remainder is biased whenever 256 is not a multiple of the set size: some characters would be drawn slightly more often than others, and “slightly more often”, multiplied across billions of guesses, is a real advantage to an attacker. So the generator uses rejection sampling instead: it computes the largest multiple of the set size that fits in a byte — for a set of 88, that limit is 176 — accepts only bytes below it, and discards and redraws the rest. Every character then has exactly the same number of accepted byte values mapping to it.

One more design decision is worth stating plainly. The generator guarantees that a password it produces in the browser contains at least one character from each set you selected — but it does so without planting characters in chosen positions, which would bias the result. It generates a whole candidate password, checks it, and if a set is missing, discards the candidate entirely and generates a fresh one. It is also honest about the underlying fact: with uniform sampling and no such check, a short password could in principle miss a selected set altogether — with four sets and only four characters, for example, chance alone will often leave one out. Length is the cure for that as well: the longer the password, the more vanishingly unlikely a missing set becomes, check or no check.

Common errors, and the limits of this tool

The commonest error is reusing a generated password on a second site: a strong password used in three places is one breach away from being a weak password in three places. The second is generating a strong password and then storing it badly — in a notes app, a spreadsheet, an email to yourself — instead of a password manager. The third is weakening a generated password by hand: trimming it to a site’s maximum is sometimes unavoidable, but swapping characters to make it memorable destroys the uniformity the entropy figure was calculated from. And the fourth is choosing settings for the readout rather than for the account — chasing a label by adding symbols a site will reject, instead of taking the length the site allows.

The limits are these. Length is capped at 128 characters and floored at 4; most sites accept far less than 128, and the site’s own maximum, not this tool’s, governs what you can use. The entropy figure is an estimate built on the uniform-selection assumption stated next to it; it describes this generator’s output, not passwords in general, and it says nothing about how the destination site stores passwords, whether it has been breached, or whether the account is protected by a second factor — which you should turn on wherever it is offered. History is deliberately small and temporary: the last 20 passwords from this tab, in memory, gone when the tab closes, and never written to storage. That makes it a safety net against losing a password you just generated, not a vault. Nothing you generate here is uploaded — generation happens in your browser — but the device and browser you paste the password into are outside this tool’s control, as with any password you handle.

Frequently asked questions

How it works

Password Generator creates strong passwords using your browser's cryptographic random source, and nothing it generates is stored or sent anywhere. Choose a length between 4 and 128 characters and pick the character sets to draw from — for example, lowercase and uppercase letters, digits, and symbols. The tool shows an honest entropy estimate in bits, labelled as an estimate, which reflects how much unpredictability the chosen length and sets provide under uniform selection. A session-only history keeps the last 20 passwords from the current tab, in memory only, so a password you just generated can be recovered if you lose it before pasting. Closing the tab wipes that history. Generate a fresh password for each account rather than tweaking one password slightly, since small variations on a single password still fall together if that password is ever exposed.

Another worked example

A fictional user, Alex Morgan, is creating an account at example.org and wants a password that is not reused from anywhere else. Alex sets a length of 16 characters with lowercase, uppercase, digits, and symbols selected, and generates a password. Input: length 16, all four character sets. Result: a 16-character password drawn from the browser's cryptographic random source, shown with an entropy estimate of roughly 105 bits for that length and set size, and kept only in the tab's short session history. Alex copies it into a password manager, rather than writing it in a notes app or emailing it to anyone.

More limitations to know

The entropy figure is an estimate built on uniform selection: it describes this generator's output, not passwords in general, and it says nothing about how a destination site stores passwords, whether that site has been breached, or whether the account has a second factor — which should be turned on wherever offered. Length is capped at 128 and floored at 4, but most sites accept far less than 128, and the site's own maximum governs what you can use. History is deliberately small and temporary, a safety net rather than a vault, and the device and browser you paste a password into remain outside this tool's control.

More frequently asked questions