ULID vs UUID vs Integer IDs – Comparison

ULID vs UUID vs Integer IDs. ULID allows you to sort them, whereas UUID does not. ULID are more efficient than UUIDs due to less storage requirement, SEO friendly, URL friendly and sort functionality.

Best Practices for Unique ID Generation

Quick answer: UULID and UUIDv7 are both best for Unique ID generation.

Companies and projects have adopted ULIDs

• GitLab: GitLab, a web-based Git repository manager, uses ULIDs for generating unique identifiers in certain parts of their system.
• Entropic: Entropic, a decentralized package registry for JavaScript modules, generates ULIDs for identifying versions of packages.
• Moltin: Moltin, an e-commerce API platform, has used ULIDs as a way to generate unique IDs for their resources.
• Minio: Minio, an open-source object storage server compatible with Amazon S3, supports ULIDs for generating unique object keys.
• Kickstarter: Kickstarter, a crowdfunding platform, has used ULIDs for generating unique identifiers in their database.

Companies and projects have adopted UUID

• Google: Google uses UUIDs in various internal systems and APIs for generating unique identifiers.
• Microsoft: Microsoft also employs UUIDs in different products and services as part of their unique identifier generation strategies.
• Amazon: Amazon Web Services (AWS) uses UUIDs in various services and APIs to ensure unique identification of resources and objects.
• Facebook: Facebook has used UUIDs in some of its services and systems for generating unique IDs.
• Twitter: Twitter has utilized UUIDs in certain aspects of its infrastructure for unique identification purposes.
• GitHub: GitHub, a popular web-based hosting service for version control using Git, uses UUIDs for generating unique identifiers for repositories, issues, and other resources.
• Apache Cassandra: Apache Cassandra, a distributed NoSQL database, supports UUIDs as one of its primary key types for uniquely identifying rows.
• PostgreSQL: PostgreSQL, a powerful open-source relational database, has built-in support for UUID data type and functions.

People may choose to move from using traditional UUIDs to ULIDs

depending on their specific use cases and requirements. Some of the reasons for adopting ULIDs over UUIDs include:

• Sortability: Unlike UUIDs, which are random and do not provide any inherent sorting, ULIDs are designed to be lexicographically sortable. This means that when ULIDs are sorted, they also represent a chronological order of generation. In certain scenarios where sorting is crucial, ULIDs can be more efficient and straightforward to work with.
• Collision Avoidance: While traditional UUIDs are highly unlikely to collide due to their vast address space, collisions can still occur in distributed systems with a high volume of concurrent requests. ULIDs, with their time-based component, can reduce the likelihood of collisions, especially in scenarios with rapid ID generation.
• Compactness: ULIDs are generally more compact than standard UUIDs, which are represented in hexadecimal form with dashes. The base32 representation of ULIDs is more space-efficient, which can be beneficial in scenarios where space optimization is important.
• Lower Entropy: Some argue that the high entropy of traditional UUIDs might not always be necessary, and using ULIDs, which have a portion based on the current time, could provide sufficient uniqueness while being more predictable.
• Readability: ULIDs, being base32 encoded and containing a timestamp component, can be more human-readable than traditional UUIDs. This can be advantageous in certain contexts, such as debugging or logging.
• Deterministic Generation: Generating ULIDs does not require a centralized authority or coordination, as is the case with certain versions of UUIDs. This makes them easier to generate in distributed systems without worrying about contention or synchronization.
• Consistency in Distributed Systems: Because ULIDs have a time-based component, they can lead to a more consistent ordering of events in distributed systems, making it easier to reason about causality and chronology.

It is critical to highlight that the decision to switch from UUIDs to ULIDs should be based on the system’s specific requirements as well as the benefits that ULIDs provide in the given context. Not all systems will require or benefit from the change, and UUIDs will continue to be a widely accepted and established option for creating unique identities in many applications.

Comparison of different identifier types, ULID vs UUID vs Integer IDs

* – Within the same moment, random bits are sequentially increased.

Format	Sortable	Monotonic	Randomness
ULID	Yes	Yes	80 bits*
UUIDv4	No	No	122 bits
UUIDv7	Yes	Yes	80 bits*

• ULID (Universally Unique Lexicographically Sortable Identifier):
  • ULID combines the benefits of UUIDs and sortable time-based identifiers.
  • It provides lexicographical sorting, allowing for efficient sorting based on the time they were generated.
  • ULIDs are designed to be compact and efficient in terms of storage requirements.
  • They are considered URL-friendly and can be used as part of a URL path.
• UUID (Universally Unique Identifier):
  • UUIDs are standardized 128-bit identifiers designed to be globally unique.
  • While UUIDs ensure uniqueness, they are not lexicographically sortable, meaning they don’t have an inherent chronological order.
  • UUIDs are represented as strings, which can result in a larger storage requirement compared to ULIDs.
• Integer IDs:
  • Integer IDs are simple numerical identifiers often represented as 32-bit or 64-bit integers.
  • They are easy to generate and can be used for indexing and querying in databases.
  • Integer IDs, however, do not provide lexicographical sorting or inherent uniqueness without additional considerations like auto-incrementing.

When compared to UUID and integer IDs, ULID looks to give advantages in terms of efficient storage, lexicographical sorting, and URL-friendliness. It is vital to note that the type of identifier used relies on the application’s specific requirements, such as uniqueness, sorting requirements, and database efficiency. Each identifier type has advantages and disadvantages, and the ideal option will depend on the use case.

Read also: Deploy Laravel Project with Nginx on Linux

Examples of ULID, UUID and Integer IDs

Sure, let’s provide examples for each type of identifier:

ULID (Universally Unique Lexicographically Sortable Identifier) examples

• Like a UUID, a ULID is a 128-bit label. Similar to UUIDv7, it is monotonically rising, sortable and has millisecond precision.
• 01ES8M1EYQNCPG8P0ZQSYZ75RP
• 01ES8MBQAKTZWTGSZMZP48T0DA
• 01ES8MCA2N8DRJDW86XQRZPD96
• 01ES8MEVDTRN3H04J9FVWQ56B7
• 01ES8MH69Q8ET3HYTM88D5BT5T
• 01ES8MK0P4FGVPD9J3TAVGFCV0

UUID (Universally Unique Identifier) examples

• f47ac10b-58cc-4372-a567-0e02b2c3d479
• d8e92261-1040-46c3-b85e-774d8a143a02
• 5f71fe9e-7385-4c42-89e9-61a8c24b25c5
• 92e26f80-0b6f-4cf4-b52a-5b3b7f5e1a49
• b7e646d3-e618-4e75-9546-8fc081a4fb2b

Integer IDs examples

• 12345
• 2
• 12456
• 65875

Here are some considerations regarding the performance of ULIDs:

• Generation: ULIDs require a combination of timestamp and randomness for uniqueness and sorting. The process of generating ULIDs might be slightly more involved compared to simple integer IDs.
• Storage: ULIDs are represented as 128-bit identifiers, which means they can require more storage compared to integer IDs (32-bit or 64-bit) or even UUIDs (128-bit). This could impact database storage and performance, especially in large-scale systems.
• Indexing: While ULIDs are sortable, the lexicographical sorting may not be as efficient as sorting integers. In some cases, indexing and searching by ULIDs might not be as performant as using integer IDs.
• Collision Avoidance: ULIDs use randomness to minimize the risk of collisions, but they are not entirely collision-proof. Although the probability of collisions is extremely low, it’s still a consideration when choosing identifier types.

GitHub repositories for ULID (Universally Unique Lexicographically Sortable Identifier)

GitHub repositories that provided implementations of ULID (Universally Unique Lexicographically Sortable Identifier) generation in various programming languages.

• Go: The original ULID specification was written in Go. You can find the official repository here: github.com/oklog/ulid
• JavaScript: For JavaScript/Node.js, there are several repositories available. One of the popular ones is: github.com/ulid/javascript
• Python: Python also has multiple implementations of ULID. Here is one of the widely used repositories: github.com/mdipierro/ulid
• Java: For Java, you can find implementations like this one: github.com/huxi/sulky
• C#/.NET: If you’re working with C#, you might want to check out this repository: C# github.com/ultimicro/netulid and .NET/C# github.com/Cysharp/Ulid
• Ruby: For Ruby enthusiasts, there are repositories like: github.com/rafaelsales/ulid-ruby
• PHP: If you prefer PHP, here’s one implementation: github.com/robinvdvleuten/php-ulid
• Laravel: Laravel default provide ULID for database migration and ULID creation. for migration $table->ulid('id'); forign ULID $table->foreignUlid('user_id'); and to create a ULID use command Str::ulid()

Conclusion

ULIDs are slower than their conventional equivalents. For me, the advantages of a sortable globally unique identity outweigh the disadvantages.

Finally, the sort of identifier you choose, whether ULID, UUID, or integer ID, is determined by your individual application requirements. If sorting by time is necessary and the performance tradeoff is tolerable, ULIDs may be an appropriate solution. However, before making this selection, it is critical to consider the overall system architecture, database design, and performance requirements. Benchmarking and testing several identifier types in your unique use case might assist you in making an informed decision.