Hit the die and the bench pulls fresh randomness straight from your machine's cryptographic RNG — no server, no Math.random. Mint RFC 4122 v4 UUIDs with the version and variant bits lit up, Microsoft-style GUIDs in uppercase braces, or compact Nano IDs with a length dial and a live entropy readout. Generate one or a batch of 25, copy any of them in a click. Nothing is uploaded, nothing is stored.
The standard issue: a version 4, variant 1 UUID per RFC 4122 — 128 bits where 122 are pure cryptographic randomness and six are fixed markers that identify the version and variant. The spotlight lights up both marker bits so you can see exactly where they live (the 4 and the leading 8/9/a/b of the fourth group). Format it your way — upper or lower case, hyphens on or off, braces on or off — and pull a batch of up to 25 at a time.
Use it for database keyssession IDsidempotency keysdeduplication
Same 128-bit engine, different dress code. A GUID is Microsoft's name for a UUID, and by convention it's written uppercase and wrapped in braces — the form you'll see in .NET, the Windows registry, COM interfaces and Active Directory. This tool generates the identical v4 random value and simply presents it the way those systems expect, ready to paste into a C# literal or a .reg file.
Example · Microsoft convention
⚄ generate
↓
{F47AC10B-58CC-4372-A567-0E02B2C3D479}
uppercase, braced — drop it straight into new Guid("…").
Use it for .NET projectsregistry entriesCOM / ActiveXActive Directory
The compact contender. A Nano ID draws from a 64-character URL-safe alphabet (A–Z, a–z, 0–9, _ and -), so every character carries 6 bits of entropy — a default 21-character ID packs about 126 bits, slightly more than a UUID, in far fewer glyphs. Drag the length dial from 6 to 64 and watch the entropy readout tell you exactly how much randomness you still have. Safe in URLs, filenames and keys with no escaping needed.
Use it for short URLsRedis keysfrontend IDspublic tokens
Generation rules · all randomness comes from crypto.getRandomValues — your machine's cryptographic RNG, the same source your OS uses for TLS keys · UUID and GUID are version 4, variant 1: 122 random bits plus 6 fixed marker bits · a GUID is the same value as a UUID, rendered uppercase and braced per Microsoft convention · Nano IDs draw uniformly from a 64-character URL-safe alphabet via a bitmask, so the distribution is unbiased · entropy figures: UUID/GUID 122 bits, Nano ID = length × 6 bits · batches of up to 25, every ID copyable individually or all at once · nothing is transmitted and nothing is stored
The privacy promise
Mint anything. We couldn't see it even if we wanted to.
This page has no backend and no database. Every byte of randomness is drawn from your own machine's cryptographic generator, shaped into an identifier inside your browser tab, and gone the moment you close the page. The IDs never travel a single centimeter of cable — there is nothing to leak, because nothing is ever collected.
RANDOM BYTES→SHAPED IN YOUR BROWSER→READY TO USE
✕ SERVER · DATABASE · LOGS · ANALYTICS
Databasenull
Backendnone
IDs uploaded0
Session logs0
Questions
Asked often, answered plainly.
( 02 )
What's the difference between a UUID and a GUID?
Underneath, nothing — both are 128-bit values drawn from the same random space. The difference is convention: UUID is the RFC 4122 standard, usually written lowercase with hyphens; GUID is Microsoft's name for the same thing, conventionally written uppercase and wrapped in braces. This bench generates the identical v4 random value and simply dresses it differently for each tool.
Are these actually random?
They come from your browser's cryptographic random number generator (crypto.getRandomValues), which is seeded from hardware entropy and is the same source your operating system uses for TLS keys. A UUID v4 carries 122 bits of true randomness and a default Nano ID about 126. That's not "pseudo-random enough" — it's cryptographically secure for identifiers, tokens and keys.
Can two generated IDs collide?
In practice, no. The v4 space holds 2^122 values; by the birthday bound you'd need to generate roughly 2^61 — about two quintillion — identifiers before a collision became even 50% likely, and Nano IDs are in the same league. For any realistic system, from a side project to a planet-scale database, treating them as unique is safe.
Why is a Nano ID shorter than a UUID?
Because it uses a larger alphabet. A UUID speaks in hex — 16 symbols, 4 bits per character. A Nano ID speaks in 64 URL-safe symbols — 6 bits per character — so 21 characters carry about 126 bits, slightly more than a UUID's 122, in far fewer glyphs. Shorten it and the entropy readout on the bench tells you exactly what you still have.
Is my data saved anywhere?
No. Stack has no backend and no database. The identifiers are generated inside your browser tab and vanish the moment you close or refresh the page. Nothing is logged, because nothing is ever collected.