DevTools Logo

IPv6 ULA Generator

IPv6 ULA Generator

Generate RFC 4193 fd00::/8 Unique Local Address /48 prefixes — cryptographically random or deterministically derived from NIC + date.

1–20 · each prefix is a /48 with a 40-bit Global ID under fd00::/8.

Derive one stable prefix from a NIC name + install date with SHA-1.

Examples

Random site prefix

Input
Count 5 · random mode
Output
fd63: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

Input
NIC eth0 · install date 2026-01-15
Output
fd49:ca60:21ab::/48

SHA-1(nic | date), least significant 40 bits — the identical prefix on every machine, derivable again years later.

Batch for provisioning

Input
Count 20 · random mode
Output
twenty fd00::/8 prefixes · Copy all

One 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

  1. 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.

  2. 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).

  3. 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.

  4. 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 / fieldValue in this tool
Prefix (8 bits)11111101 — fd00::/8 (fc00::/7 with the L bit set)
L bit1 — 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 formRFC 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