ULID generator

Both identifiers are 128 bits with a leading 48-bit Unix millisecond timestamp, so values minted in different milliseconds sort by time. The difference is encoding and how the remaining bits are spent. A ULID is 26 Crockford Base32 characters (80 random bits, no version or variant field). UUID v7 is RFC 9562 §5.7: hyphenated hex with version nibble 7, variant 10xx, and 74 random bits. This page does not convert a ULID into a UUID or the reverse. For a v7 string, use the UUID v7 generator. For how v7 compares to v4 and v5, see UUID Versions Explained: v4 vs v1, v5, v7 and v8 (Format & Length).

This generator does not increment the 80-bit random field when Date.now() repeats, so two ULIDs from the same millisecond are not ordered by click. The v7 page also skips RFC 9562 §6.2 monotonic methods. Both encodings leak the minting millisecond. Neither string is a password, session token, or signed claim. Crockford Base32 is not RFC 4648 §6 Base32 (A–Z 2–7) or §7 base32hex (0–9 A–V) — those pages are Base32 and Base32hex.

The snippets below encode the same 128-bit layout this page mints: 48-bit Unix milliseconds as 10 Crockford Base32 characters, then 80 CSPRNG bits as 16 more. Node and CPython have no stdlib ULID API — there is no crypto.ulid and no uuid.ulid. The Node snippet uses Date.now() and crypto.randomBytes — the same POSIX-ms clock and CSPRNG family this page runs through crypto.getRandomValues(). CPython uses time.time_ns and secrets.token_bytes. There is no POSIX ULID generator. crypto.randomUUID() and CPython uuid.uuid4 are RFC 9562 v4. CPython 3.14+ uuid.uuid7 is RFC 9562 §5.7 hyphenated hex, not Crockford. For how v7 compares to v4 and v5, see UUID Versions Explained: v4 vs v1, v5, v7 and v8 (Format & Length).

const { randomBytes } = require('crypto');
const CROCKFORD = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';

function encodeTime(ms) {
  let now = ms;
  let str = '';
  for (let i = 0; i < 10; i += 1) {
    const mod = now % 32;
    str = CROCKFORD.charAt(mod) + str;
    now = (now - mod) / 32;
  }
  return str;
}

function encodeRandom80(bytes) {
  let acc = 0;
  let bits = 0;
  let out = '';
  for (let i = 0; i < bytes.length; i += 1) {
    acc = acc * 256 + bytes[i];
    bits += 8;
    while (bits >= 5) {
      bits -= 5;
      const digit = Math.floor(acc / 2 ** bits) & 31;
      acc %= 2 ** bits;
      out += CROCKFORD.charAt(digit);
    }
  }
  return out;
}

encodeTime(1469918176385)
// "01ARYZ6S41"

encodeTime(1700000000000) + encodeRandom80(Buffer.alloc(10))
// "01HF7YAT000000000000000000"

encodeTime(Date.now()) + encodeRandom80(randomBytes(10))
// 26 Crockford chars; first character is 0-7; bits 0-47 are Date.now()

import secrets
import time

CROCKFORD = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'

def encode_time(ms):
    now = int(ms)
    chars = []
    for _ in range(10):
        mod = now % 32
        chars.append(CROCKFORD[mod])
        now = (now - mod) // 32
    return ''.join(reversed(chars))

def encode_random80(data):
    acc = 0
    bits = 0
    out = []
    for b in data:
        acc = acc * 256 + b
        bits += 8
        while bits >= 5:
            bits -= 5
            digit = (acc // (2 ** bits)) & 31
            acc %= 2 ** bits
            out.append(CROCKFORD[digit])
    return ''.join(out)

encode_time(1469918176385)
# '01ARYZ6S41'

encode_time(1700000000000) + encode_random80(bytes(10))
# '01HF7YAT000000000000000000'

encode_time(time.time_ns() // 1_000_000) + encode_random80(secrets.token_bytes(10))
# 26 Crockford chars; first character is 0-7

The layout string uses ten zero bytes so the 48-bit field is visible; Generate never writes that all-zero tail. 1700000000000 is 1700000000 seconds — 2023-11-14T22:13:20.000Z. Both use the same POSIX-ms clock as Unix timestamp Milliseconds mode. Ten bytes are exactly 80 bits, so there is no remaining bit after 16 Crockford digits. This page does not increment the 80-bit field when Date.now() repeats, so two IDs from the same millisecond are not ordered by click. The first character stays in 0–7 because 26 Base32 digits can hold 130 bits and a ULID uses 128; the largest valid encoding is 7ZZZZZZZZZZZZZZZZZZZZZZZZZ. npm ulid and PyPI python-ulid are other packages, not this page, and some of those mint monotonically inside a millisecond — this generator does not. crypto.randomUUID() and uuid.uuid4 belong on the UUID v4 generator. uuid.uuid7 belongs on the UUID v7 generator. Crockford Base32 is not RFC 4648 §6 Base32 (A–Z 2–7) or §7 base32hex (0–9 A–V) — those pages are Base32 and Base32hex. There is no POSIX ULID generator; uuidgen and CPython python -m uuid write UUID v4, not Crockford. The page does not decode a pasted ULID. The high bits leak the minting millisecond; this is not a password hasher.