IPv6 ULA Generator
Generate RFC 4193 fd00::/8 Unique Local Address /48 prefixes — cryptographically random or deterministically derived from NIC + date.
Examples
Random site prefix
Count 5 · random modefd63:cb94:e248::/48 (one of five)Five CSPRNG-drawn Global IDs, one per site — collision odds between any two networks stay below one in a trillion.
Deterministic prefix
NIC eth0 · install date 2026-01-15fd49:ca60:21ab::/48SHA-1(nic | date), least significant 40 bits — the identical prefix on every machine, derivable again years later.
Batch for provisioning
Count 20 · random modetwenty fd00::/8 prefixes · Copy allOne click produces the whole batch as a newline list ready for an IaC variables file or a spreadsheet.
About this tool
IPv6 hands every site more address space than it could ever use, and RFC 4193 sets aside fc00::/7 for the private half of it: Unique Local Addresses, the IPv6 successor to RFC 1918's 10.x.x.x and 192.168.x.x ranges. A ULA prefix is 48 bits long, written fd00:xxxx:xxxx::/48, with a 40-bit Global ID in the middle that you are expected to choose at random. The IPv6 ULA Generator draws those bits for you the way the RFC intends — from a cryptographic random source, entirely inside your browser, with nothing sent to any server.
Random mode uses crypto.getRandomValues, the browser's cryptographically secure random source, to draw five fresh bytes per prefix — that is the 40-bit Global ID, delivered with the required fd prefix and L-bit set. With space that large, RFC 4193's own analysis puts the odds of two independently generated prefixes colliding at less than one in a trillion per pair of networks; generating up to twenty prefixes per click for a lab, a campus or a multi-site rollout stays comfortably inside that budget. Each generated prefix comes out in RFC 5952-compressed form — fd49:ca60:21ab::/48, never padded or expanded — ready for router configs, subnets at /64 inside it, or an address plan spreadsheet.
Deterministic mode implements the RFC's second option, section 3.2.2: instead of fresh randomness, it SHA-1 hashes a key you control — the NIC name plus an install date — through the Web Crypto API and keeps the least significant 40 bits of the 160-bit digest as the Global ID. The result is the whole point of the deterministic path: the same NIC name and date yield the identical fd00:…::/48 prefix on every machine, forever, with no registry and no coordination. Derive the prefix again years later during an audit, share the recipe in a runbook, and every branch office can reconstruct the exact same prefix independently.
ULA addresses are for organizational internals: they do not route on the public internet, they coexist with global unicast addresses on the same interfaces, and they are not the same thing as link-local addresses (fe80::/10), which nodes self-assign per link and never leave the segment. When you are ready to route, the WireGuard Config Generator will tunnel sites that each carry one of these prefixes; the Subnet Calculator works out the /64 subnet grid inside a /48; and the IPv6 Expander shows any compressed ULA in full uncompressed form.
What this tool does not do
- Generates /48 prefixes only — subnetting them into /64s is the Subnet Calculator's job, and per-host interface IDs are assigned later by each node.
- Deterministic mode uses NIC name + install date as its hash key — a documented local stand-in for the RFC's NTP-time + EUI-64 recipe, so the value is reproducible but not a licensed allocation.
- Generation is local and offline; prefixes are not registered with any RIR or registry, which is exactly how RFC 4193 is meant to work.
How to use this tool
Pick a count
Choose how many /48 prefixes you need — between 1 and 20. Each one gets its own independently drawn 40-bit Global ID in random mode.
Choose the mode
Leave deterministic off for fresh random prefixes; switch it on to derive one stable prefix from a NIC name and install date via SHA-1 (RFC 4193 §3.2.2).
Generate and review
Click Generate — random mode fills the list immediately; deterministic mode hashes your inputs and always returns the same fd00:…::/48 for the same NIC + date.
Copy the prefixes
Copy each prefix individually or copy all of them as a newline-separated list for configs, address plans or provisioning files.
Use cases
Numbering multi-site internal networks
Give each office or datacenter its own fd00::/8 /48 so internal routing stays stable no matter what happens to your public prefixes.
Reproducible lab prefixes
Use deterministic mode so everyone rebuilding the lab from the runbook gets the exact same ULA prefix without sharing a database.
Isolating management planes
Carve one ULA /48 for out-of-band management and another for production internals — unreachable from the internet by construction.
Anatomy of a generated ULA /48
| Bits / field | Value in this tool |
|---|---|
| Prefix (8 bits) | 11111101 — fd00::/8 (fc00::/7 with the L bit set) |
| L bit | 1 — locally assigned, per RFC 4193 |
| Global ID (40 bits) | crypto.getRandomValues bytes (random) or last 40 bits of SHA-1 (deterministic) |
| Subnet ID (16 bits) | 0000 — the /48 leaves 65,536 subnets for your /64s |
| Interface ID (64 bits) | Assigned later per host, outside this generator |
| Compressed form | RFC 5952: fd49:ca60:21ab::/48 — lowercase, minimal zeros |
Subnets live at /64 inside each /48: fd49:ca60:21ab::/64, fd49:ca60:21ab:1::/64, and so on.
Common mistakes
Mistake:Hand-picking a Global ID like fd00::/48 and using it everywhere.
Fix:The all-zero fd00 Global ID is the RFC's canonical example, not an assignment — two organizations that both use it will collide on merges and VPNs. Generate real random or deterministic bits instead.
Mistake:Confusing ULAs with link-local addresses.
Fix:fe80::/10 link-locals self-assign per link and never cross a router; fd00::/8 ULAs are routed inside your organization. Different ranges, different jobs — generate ULAs for site-wide numbering.
Mistake:Treating a ULA prefix as anonymous on the public internet.
Fix:ULAs do not route globally, but they are not secrets — combine them with firewalls and, for remote sites, encrypted tunnels such as WireGuard.
Frequently asked questions
What is a ULA and how is it different from a public IPv6 address?
A Unique Local Address is an IPv6 address under fc00::/7 — in practice fd00::/8 — reserved by RFC 4193 for private organizational routing, the way RFC 1918 reserved 10.0.0.0/8 and 192.168.0.0/16 for IPv4. ULAs are not allocated by any registry, do not route on the public internet, and can coexist with global unicast addresses on the same interfaces. They give a site stable internal numbering that survives changes to its public prefixes.
Why is a random 40-bit Global ID safe to use without a registry?
RFC 4193 analyzed this directly: with a 40-bit random space and honest CSPRNG draws, the expected collision rate between any two independently generated prefixes is well under one in a trillion, and it stays negligible even for many networks. crypto.getRandomValues in your browser is exactly such a source — the same entropy backbone used for keys and tokens. The realistic failure mode is not collision but hand-picking memorable values like fd00::/48, which thousands of organizations copy and which is why the RFC says to randomize instead.
When should I use deterministic mode instead of random?
Deterministic mode is for when the prefix must be reconstructible rather than merely unique: you derive it from a NIC name plus an install date, SHA-1 hash that key, and keep the least significant 40 bits per RFC 4193 §3.2.2. The same inputs give the identical fd00:…::/48 on every machine, so a runbook can document the recipe and any teammate can re-derive the exact prefix years later with no shared database. Prefer random mode for one-off networks and deterministic mode for documented, reproducible infrastructure.
Are ULAs the same thing as link-local addresses?
No, and mixing them up causes real confusion. Link-local addresses under fe80::/10 are self-assigned by every IPv6 interface, valid only on a single link, and never forwarded by routers. ULAs under fd00::/8 are routed across your whole organization, assigned deliberately from a /48 you generate, and are the correct choice for multi-subnet internal numbering. The tool generates ULAs; link-locals appear on their own without any generation step.
How do I subnet the generated /48 prefix?
A /48 leaves 16 bits for subnetting, so you carve 65,536 /64s out of it by incrementing the fourth group: fd49:ca60:21ab::/64, fd49:ca60:21ab:1::/64, and so on. The standard practice is one /64 per subnet, since /64 is the smallest prefix most IPv6 features — SLAAC, neighbor discovery — assume. For sizing the grid and checking host counts inside each /64, the Subnet Calculator handles the arithmetic once you have picked the /48 here.
Does generating prefixes here send anything to a server?
No. Random mode draws its bytes from your browser's own crypto.getRandomValues and deterministic mode hashes locally through the Web Crypto API, so every prefix is produced inside your tab. No value is transmitted, logged or stored on any server, and nothing requires connectivity — the tool works fully offline. The count input persists only in your browser's local storage between visits, and its Clear control removes the saved copy.
References & standards
Related tools
IPv6 Address Expander
Expand a compressed IPv6 address to its full 8-group form and compress it back per RFC 5952 — with validation, embedded-IPv4 support, and a per-group breakdown
Subnet Calculator
Calculate IPv4 and IPv6 subnets from CIDR notation — network address, broadcast, usable host range, subnet mask, wildcard mask, and a visual bit map
WireGuard Config Generator
Generate WireGuard client and server configurations
MAC Address Lookup
Find the manufacturer behind a MAC address from its OUI prefix, using a bundled offline subset of the IEEE registry (292 vendors, 12,925 prefixes).