Unique ID Generator (Twitter Snowflake)

# Python 3.10+ — thread-safe Twitter Snowflake generator
import time, threading

class SnowflakeGenerator:
    EPOCH_MS       = 1288834974657   # 2010-11-04T01:42:54.657Z (Twitter's epoch)
    SEQUENCE_BITS  = 12
    NODE_BITS      = 10
    NODE_SHIFT     = SEQUENCE_BITS               # 12
    TS_SHIFT       = NODE_BITS + SEQUENCE_BITS   # 22
    SEQ_MASK       = (1 << SEQUENCE_BITS) - 1    # 4095
    MAX_NODE       = (1 << NODE_BITS) - 1        # 1023

    def __init__(self, node_id: int):
        if not 0 <= node_id <= self.MAX_NODE:
            raise ValueError(f"node_id must be 0..{self.MAX_NODE}")
        self.node_id  = node_id
        self._seq     = 0
        self._last_ts = -1
        self._lock    = threading.Lock()   # the GIL alone is NOT enough

    def _now(self) -> int:
        return int(time.time() * 1000)

    def next_id(self) -> int:
        with self._lock:
            ts = self._now()
            if ts < self._last_ts:                    # CLOCK DRIFT GUARD
                raise RuntimeError(f"clock moved back {self._last_ts - ts}ms")
            if ts == self._last_ts:
                self._seq = (self._seq + 1) & self.SEQ_MASK
                if self._seq == 0:                   # all 4096 slots used this ms
                    ts = self._til_next_ms(self._last_ts)
            else:
                self._seq = 0
            self._last_ts = ts
            return ((ts - self.EPOCH_MS) << self.TS_SHIFT) \
                 | (self.node_id << self.NODE_SHIFT)  \
                 | self._seq

    def _til_next_ms(self, last: int) -> int:
        ts = self._now()
        while ts <= last:
            ts = self._now()
        return ts

// C++20 — thread-safe Snowflake, explicit int64_t packing
#include <chrono>
#include <mutex>
#include <stdexcept>

class Snowflake {
    static constexpr int64_t EPOCH_MS = 1288834974657LL;  // 2010-11-04 (Twitter)
    static constexpr int SEQUENCE_BITS = 12, NODE_BITS = 10;
    static constexpr int NODE_SHIFT = SEQUENCE_BITS;              // 12
    static constexpr int TS_SHIFT   = NODE_BITS + SEQUENCE_BITS;  // 22
    static constexpr int64_t SEQ_MASK = (1LL << SEQUENCE_BITS) - 1;  // 4095
    static constexpr int64_t MAX_NODE = (1LL << NODE_BITS) - 1;      // 1023

    int64_t nodeId_, seq_ = 0, lastTs_ = -1;
    std::mutex mu_;

    static int64_t nowMs() {
        using namespace std::chrono;
        return duration_cast<milliseconds>(
                   system_clock::now().time_since_epoch()).count();
    }
    int64_t tilNextMs(int64_t last) {
        int64_t ts = nowMs();
        while (ts <= last) ts = nowMs();
        return ts;
    }

public:
    explicit Snowflake(int64_t nodeId) : nodeId_(nodeId) {
        if (nodeId < 0 || nodeId > MAX_NODE)
            throw std::invalid_argument("nodeId must be 0..1023");
    }

    int64_t nextId() {
        std::lock_guard<std::mutex> lock(mu_);
        int64_t ts = nowMs();
        if (ts < lastTs_)                          // CLOCK DRIFT GUARD
            throw std::runtime_error("clock moved backwards");
        if (ts == lastTs_) {
            seq_ = (seq_ + 1) & SEQ_MASK;
            if (seq_ == 0) ts = tilNextMs(lastTs_);  // 4096/ms ceiling
        } else seq_ = 0;
        lastTs_ = ts;
        // sign bit stays 0 -> always a positive int64
        return ((ts - EPOCH_MS) << TS_SHIFT) | (nodeId_ << NODE_SHIFT) | seq_;
    }
};

// Java — note: long is SIGNED, so bit 63 must stay 0
public final class Snowflake {
    private static final long EPOCH_MS      = 1288834974657L; // 2010-11-04
    private static final long SEQUENCE_BITS = 12L;
    private static final long NODE_BITS     = 10L;
    private static final long NODE_SHIFT    = SEQUENCE_BITS;             // 12
    private static final long TS_SHIFT      = NODE_BITS + SEQUENCE_BITS; // 22
    private static final long SEQ_MASK = (1L << SEQUENCE_BITS) - 1;   // 4095
    private static final long MAX_NODE = (1L << NODE_BITS) - 1;       // 1023

    private final long nodeId;
    private long sequence      = 0L;
    private long lastTimestamp = -1L;

    public Snowflake(long nodeId) {
        if (nodeId < 0 || nodeId > MAX_NODE)
            throw new IllegalArgumentException("nodeId must be 0.." + MAX_NODE);
        this.nodeId = nodeId;
    }

    public synchronized long nextId() {
        long ts = System.currentTimeMillis();
        if (ts < lastTimestamp)                    // CLOCK DRIFT GUARD
            throw new IllegalStateException(
                "Clock moved backwards by " + (lastTimestamp - ts) + "ms");
        if (ts == lastTimestamp) {
            sequence = (sequence + 1) & SEQ_MASK;
            if (sequence == 0) ts = tilNextMillis(lastTimestamp);
        } else {
            sequence = 0L;
        }
        lastTimestamp = ts;
        return ((ts - EPOCH_MS) << TS_SHIFT)
             | (nodeId << NODE_SHIFT)
             | sequence;
    }

    private long tilNextMillis(long last) {
        long ts = System.currentTimeMillis();
        while (ts <= last) ts = System.currentTimeMillis();
        return ts;
    }
}

// Go — mutex-guarded generator returning (int64, error)
package snowflake

import (
    "errors"
    "fmt"
    "sync"
    "time"
)

const (
    epochMS      = int64(1288834974657) // 2010-11-04 (Twitter)
    sequenceBits = 12
    nodeBits     = 10
    nodeShift    = sequenceBits            // 12
    tsShift      = nodeBits + sequenceBits // 22
    seqMask      = int64(1)<<sequenceBits - 1 // 4095
    maxNode      = int64(1)<<nodeBits - 1     // 1023
)

type Generator struct {
    mu     sync.Mutex
    nodeID int64
    seq    int64
    lastTS int64
}

func New(nodeID int64) (*Generator, error) {
    if nodeID < 0 || nodeID > maxNode {
        return nil, errors.New("nodeID must be 0..1023")
    }
    return &Generator{nodeID: nodeID, lastTS: -1}, nil
}

func (g *Generator) NextID() (int64, error) {
    g.mu.Lock()
    defer g.mu.Unlock()

    ts := time.Now().UnixMilli()
    if ts < g.lastTS { // CLOCK DRIFT GUARD
        return 0, fmt.Errorf("clock moved back %dms; refusing", g.lastTS-ts)
    }
    if ts == g.lastTS {
        g.seq = (g.seq + 1) & seqMask
        if g.seq == 0 { // 4096 IDs exhausted this millisecond
            for ts <= g.lastTS {
                ts = time.Now().UnixMilli()
            }
        }
    } else {
        g.seq = 0
    }
    g.lastTS = ts
    return ((ts-epochMS)<<tsShift) | (g.nodeID<<nodeShift) | g.seq, nil
}

// TypeScript — MUST use BigInt: IDs exceed Number.MAX_SAFE_INTEGER (2^53-1)
const EPOCH_MS      = 1288834974657n;              // 2010-11-04 (Twitter)
const SEQUENCE_BITS = 12n;
const NODE_BITS     = 10n;
const NODE_SHIFT    = SEQUENCE_BITS;              // 12n
const TS_SHIFT      = NODE_BITS + SEQUENCE_BITS;  // 22n
const SEQ_MASK      = (1n << SEQUENCE_BITS) - 1n; // 4095n
const MAX_NODE      = (1n << NODE_BITS) - 1n;     // 1023n

export class Snowflake {
  private seq    = 0n;
  private lastTs = -1n;

  // Node runs one event loop per process, so no lock is needed here.
  // With worker_threads / cluster, give EACH worker its own nodeId.
  constructor(private readonly nodeId: bigint) {
    if (nodeId < 0n || nodeId > MAX_NODE)
      throw new RangeError('nodeId must be 0n..1023n');
  }

  /** Returns a STRING — JSON.parse would silently round a 19-digit number. */
  nextId(): string {
    let ts = BigInt(Date.now());
    if (ts < this.lastTs)                       // CLOCK DRIFT GUARD
      throw new Error(`Clock moved back ${this.lastTs - ts}ms`);

    if (ts === this.lastTs) {
      this.seq = (this.seq + 1n) & SEQ_MASK;
      if (this.seq === 0n) {                    // 4096/ms ceiling hit
        while (ts <= this.lastTs) ts = BigInt(Date.now());
      }
    } else {
      this.seq = 0n;
    }
    this.lastTs = ts;

    const id = ((ts - EPOCH_MS) << TS_SHIFT)
             | (this.nodeId << NODE_SHIFT)
             | this.seq;
    return id.toString();          // ← never return a raw number
  }
}