Generate a strong random password on your own device
Generating a strong random password means picking each character independently from a large pool using a cryptographically secure random source, so the result cannot be predicted or reconstructed. This page does that on your device with crypto.getRandomValues, with selectable character sets and length; the password is never transmitted, logged, or stored anywhere. Ambiguous look-alike characters such as l, 1, O, and 0 are excluded from the pools so the result survives being read aloud or retyped.
How it works
Every character of the password is chosen by crypto.getRandomValues(), the Web Crypto API's secure random generator. Unlike Math.random() — a fast pseudo-random generator whose entire future output can be reconstructed from a small amount of observed state — getRandomValues is fed by the operating system's entropy pool (interrupt timings, hardware noise sources such as RDRAND), the same source used to mint TLS session keys. The generator fills a buffer of 32-bit integers, and each integer is mapped to one character of your chosen pool using rejection sampling: values that would land in the "remainder" range at the top of the integer space are discarded and redrawn, so every pool character is exactly equally likely and no modulo bias creeps in.
The pools are deliberately trimmed of ambiguous characters. Lowercase drops l (25 letters remain), uppercase drops I and O (24 remain), digits drop 0 and 1 (8 remain), and the symbol set contributes 24 punctuation marks that are safe in most password fields. In print or in fonts like Arial, l/1/I and O/0 are close to indistinguishable; excluding them costs a negligible fraction of a bit per character and eliminates a whole class of "the password doesn't work" support problems.
Password strength is measured in bits of entropy: entropy = log₂(poolSize) × length. Each character drawn uniformly from a pool of N contributes log₂(N) bits, and independent choices add up. With all four sets enabled the pool is 25 + 24 + 8 + 24 = 81 characters, so each character is worth log₂(81) ≈ 6.34 bits. A 16-character password therefore carries 6.34 × 16 ≈ 101 bits — an attacker running a very fast offline rig at 10¹² guesses per second would need on the order of 10¹¹ years to search half the space. Drop to 10 lowercase-only characters (pool 25, 4.64 bits each) and you get 46 bits, which the same rig exhausts in under a day. Length beats cleverness: every added character multiplies the attacker's work by the pool size.
Nothing about the result is retained. There is no network request in the generation path, no cookie, no localStorage write, and no server that could keep logs — the entire operation is a few hundred bytes of arithmetic in your browser's memory. The page works identically with the network cable unplugged.
Worked example: sizing a password for an email account
Suppose you are replacing the password on a primary email account. You enable all four character sets (pool = 81) and set the length to 16. The generator draws 16 secure random integers and maps them to something like vR7&kQm4#tXz9!Wp (this printed example is now public — generate your own). Entropy: log₂(81) ≈ 6.34 bits per character × 16 = 101.4 bits, or about 2.9 × 10³⁰ possible passwords. Against an online attack limited to 100 guesses per second, expected time to crack exceeds the age of the universe by many orders of magnitude; even against an offline GPU cluster testing a trillion guesses per second, the expected search time is around 46 billion years. By comparison, an 8-character password from the same pool yields only 50.7 bits — the same cluster covers that space in about 20 minutes. The practical lesson from the arithmetic: going from 8 to 16 characters buys you a factor of 81⁸ (about 1.8 × 10¹⁵) in attacker effort.
Frequently asked questions
Is this password generator actually random?
Yes, in the cryptographic sense. It uses crypto.getRandomValues, which draws from your operating system's secure random source, the same one used to generate encryption keys. It is not the predictable Math.random generator used for games and animations.
Can anyone see or store the passwords generated here?
No. The password is created in your browser's memory and displayed on screen; there is no network request, no analytics event, and no storage of any kind. If you generate one and close the tab without copying it, it is gone permanently.
How long should a random password be in 2026?
Aim for at least 80 bits of entropy, which means about 14 characters from a mixed pool or 18 lowercase-plus-digit characters. For anything protecting money or email, 16 characters from all four sets, roughly 101 bits, is a comfortable margin against offline cracking.
Why are characters like 0, O, 1 and l missing from my passwords?
The pools deliberately exclude ambiguous characters: lowercase l, digit 1, capital I, capital O, and digit 0. They look nearly identical in many fonts, which causes errors when a password is read aloud, printed, or retyped. The tiny entropy loss is under half a bit per character.
Is a random password better than a passphrase of words?
Per character typed, yes; per unit of memorability, no. A 16-character mixed password has about 101 bits of entropy, while a six-word Diceware passphrase has about 77 bits and is far easier to remember. Use random passwords inside a password manager and a passphrase for the manager itself.
Does generating a password offline make it safer?
It removes one class of risk: interception or server-side logging. This page works identically offline because the generation is pure client-side code. The bigger risks remain reusing the password across sites and storing it somewhere unencrypted.