Loading your tools...
Generate Universally Unique Lexicographical Sortable Identifiers (ULID). Get the benefits of 128-bit UUID compatibility with high-performance chronological sortability. Avoid database index fragmentation with time-ordered IDs.
Loading Tool...
ULID (Universally Unique Lexicographical Sortable Identifier) is the modern answer to the database performance issues caused by random UUIDs. By combining a 48-bit timestamp with 80-bit randomness, it provides a unique ID that is naturally ordered by time.
The resulting 128-bit structure is encoded using Crockford's Base32, a human-readable alphabet that excludes ambiguous characters (I, L, O, U) to ensure double-click accessibility and URL-safety.
| Feature | ULID | UUID v7 | Snowflake |
|---|---|---|---|
| Standard | Community Spec | RFC 9562 (IETF) | Proprietary/OSS |
| Sortability | Yes (Time) | Yes (Time) | Yes (Time) |
| Decentralized | Yes | Yes | No (Worker ID req) |
| Bit Length | 128 bits | 128 bits | 64 bits |
| Alphabet | Base32 (26 chars) | Hex (36 chars) | Int64 |
A specific sorting method where characters or IDs are ordered like words in a dictionary. Because ULIDs start with a timestamp, they are naturally ordered by the time they were created, reducing B-tree fragmentation in databases.
ULID reserves 80 bits for randomness. This "Entropy" ensures that even if millions of IDs are generated at the exact same millisecond, the chance of collision is virtually zero—offering 128-bit security.
ULIDs are designed for massive distributed systems. To calculate the collision probability, we look at the 80 bits of randomness provided per millisecond. This yields 280 or approximately 1.2 x 1024 possible IDs per millisecond. For context, to have a 50% chance of a single collision, you would need to generate 1 trillion IDs per millisecond for every inhabitant on Earth.
Unlike UUIDs, ULID implementations can support "Monotonicity"—ensuring that if multiple IDs are generated within the exact same millisecond, the random part is incremented by 1 instead of being re-randomized, preserving strict sort order.
import { ulid } from 'ulid'
console.log(ulid())from ulid import ULID print(ULID())
id := ulid.MustNew(ulid.Now(), entropy)
fmt.Printf("%s", id)use ulid::Ulid; let id = Ulid::new();
ULIDs are 128-bit compatible with UUIDs but are lexicographically sortable. They offer millisecond precision timestamps and 80 bits of randomness per millisecond.