What is a UUID?#

A Universally Unique Identifier (UUID) is a 128-bit number, composed of 16 octets and typically represented as 32 hexadecimal characters. It’s used to uniquely identify information across computer systems. The specification was originally created by Microsoft and later standardized by both the IETF and ITU.

In this article, I’ll focus specifically on UUID version 4 (UUIDv4), which is purely random generated (unlike other versions that are based on timestamps or MAC addresses).

It’s worth noting that generating a duplicate UUID is extremely unlikely.

A sample of 3.26 × 10¹⁶ UUIDs has a 99.99% chance of not containing any duplicates. At a rate of one UUID per second, generating that many would take over a billion years. — towardsdatascience

A Closer Look#

As mentioned earlier, a UUID is a 128-bit number represented in hexadecimal format. That means you can generate your own UUID by randomly changing even a single bit.

For example, if you imagine the smallest possible UUID as '0x00000000000000000000000000000000', where all bits are zero, the next one would be '0x00000000000000000000000000000001', and it goes on. Because of this vast space, collisions are almost impossible. According to Wikipedia, you’d need to generate about 2.71 quintillion UUIDs before expecting a single collision—that’s a truly massive number.

But then a question popped into my head: Can we make an identifier that’s even more unique—or at least appears more diverse—than a UUID? Let me explain :)

Tweaking the Output#

While thinking about it, I realized we could modify the final section of the UUID generation process—the part that converts the 128-bit number into a hexadecimal string. This step gives us a 32-character-long identifier. If we take that final string and convert or encode it into a different format of the same length, we essentially get a new kind of identifier.

Alphabet Character Mapping#

My first idea was to remap the hexadecimal characters. In hex, the digits 10 through 15 are represented by the letters 'a' through 'f'. So, what if we replaced 'abcdef' with a different set of six characters?

I chose to map 'abcdef' to 'uvwxyz'—the last six letters of the alphabet.

For example, the UUID '14be1be3-4818-46da-bb60-dc2b1d89c8ff' becomes '14yv1yv3-4818-46wz-yy60-wx2y1w89x8uu'.

The map_to argument in the function can be any set of 6 characters, which opens up room for customization and variety.

Random Uppercasing#

Another trick to increase uniqueness is to randomly change the case of alphabetic characters. This adds visual variety without altering the base information.

The full source code of ZUID—my custom identifier generator—is shown below:

1
# a library that generates zuid.
2

3
import random
4
from uuid import uuid4
5

6

7
class zuid:
8
    zuid = 0x000000000000000000000000000000000000
9
    def __init__(self, zuid=None):
10
        if (zuid != None and zuid != self.zuid):
11
            self.zuid = bytes(zuid, "utf-8")
12

13
    def should_upper(self):
14
        return random.randint(0, 1024) % 2 == 0
15

16
    def map(self, data, map_to):
17
        board = f"abcdef{map_to}"
18
        mapped = ""
19
        for i in data:
20
            if (i in board):
21
                mapped += board[len(board) - 1 - board.find(i)]
22
            else:
23
                mapped += i
24
        return mapped
25

26
    def generate_zuid1(self):
27
        digits = "0123456789"
28
        uuidchars = "abcdef"
29
        zuidcharacters = "uvwxyz"
30
        characters = zuidcharacters.upper()
31
        zuid_digits = digits + characters
32
        uuid = str(uuid4())
33
        template = "xxxxxxxx-xxxx-zxxx-xxxx-xxxxxxxxxxxx"
34
        zuid = ""
35
        for i in range(len(template)):
36
            if (template[i] == 'z'):
37
                zuid += 'z'
38
            elif (template[i] == '-'):
39
                zuid += '-'
40
            else:
41
                uuidchar = uuid[i]
42
                if (uuidchar in digits):
43
                    zuid += uuidchar
44
                else:
45
                    char = self.map(uuid[i], zuidcharacters)
46
                    zuid += char.upper() if  self.should_upper() else char
47
        return zuid
48

49
    def __str__(self) -> str:
50
        if (self.zuid != None):
51
            return self.zuid.decode("utf-8")
52
        else:
53
            raise Exception("ZUID is not initialized")
54

55
    def __repr__(self):
56
        if (self.zuid != None):
57
            return '%s(%r)' % (self.__class__.__name__, str(self))
58
        else:
59
            raise Exception("ZUID is not initialized")
60

61
def zuid1():
62
    return zuid(zuid().generate_zuid1())

Conclusion#

ZUID’s uniqueness builds on the reliability of UUIDv4, but adds layers of transformation—character mapping, casing, and potential encodings—to create identifiers that are visually distinct and even more customizable.

You can also roll your own variant by generating random bits or experimenting with different encodings.