GUID vs UUID: What's the Difference and Which Should You Use?

They look the same, they work the same, but the naming causes endless confusion. Let's settle it once and for all.

The Short Answer

GUID and UUID are the same thing. They refer to the same 128-bit identifier format, the same generation algorithms, and the same data structure. The difference is purely terminological — which ecosystem you come from determines which word you use.

• UUID (Universally Unique Identifier) — the standard term defined in RFC 4122 and RFC 9562, used in most of the software world
• GUID (Globally Unique Identifier) — Microsoft's term for the same concept, used in .NET, COM, Windows APIs, and SQL Server

If someone asks you to generate a GUID, generate a UUID. If a spec says UUID, it's the same as a GUID. They are interchangeable.

The History: Why Two Names?

The concept originated at Apollo Computer in the 1980s for their Network Computing System (NCS). When the Open Software Foundation (OSF) standardized distributed computing with DCE (Distributed Computing Environment), they adopted the format and called it UUID.

Microsoft adopted the DCE UUID for COM (Component Object Model) in the early 1990s but branded it as GUID. Since Windows and COM dominated enterprise development for decades, the GUID terminology became deeply embedded in the Microsoft ecosystem.

Meanwhile, the rest of the industry — Linux, macOS, Java, Python, web standards, databases like PostgreSQL — used the RFC standard and called it UUID.

The result: two names for the same thing, split along ecosystem lines.

Format Comparison

Both use the identical format:

xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx

Where:
  x = hexadecimal digit (0-9, a-f)
  M = version (1-5, 7)
  N = variant (8, 9, a, b)

Examples:

UUID: 550e8400-e29b-41d4-a716-446655440000
GUID: 550e8400-e29b-41d4-a716-446655440000

Identical. No difference.

The Case Sensitivity Non-Difference

You'll sometimes hear that "GUIDs use uppercase and UUIDs use lowercase." This is a convention, not a rule. Microsoft tools often display GUIDs in uppercase:

550E8400-E29B-41D4-A716-446655440000

While Unix tools and most languages use lowercase:

550e8400-e29b-41d4-a716-446655440000

Both are valid. RFC 4122 says UUIDs are case-insensitive, and the canonical form is lowercase. In practice, always compare UUIDs case-insensitively.

The Curly Brace Convention

In the Microsoft world, GUIDs are sometimes wrapped in curly braces:

{550e8400-e29b-41d4-a716-446655440000}

This is a display convention used in the Windows Registry, COM class identifiers, and some Microsoft APIs. It's not part of the UUID standard. If you see braces, strip them before using the value in non-Microsoft contexts.

GUID/UUID in Different Ecosystems

Microsoft / .NET

// C# — uses "Guid"
Guid id = Guid.NewGuid();
// "550e8400-e29b-41d4-a716-446655440000"

// SQL Server — uses "uniqueidentifier"
DECLARE @id UNIQUEIDENTIFIER = NEWID();

Java

// Java — uses "UUID"
UUID id = UUID.randomUUID();
// "550e8400-e29b-41d4-a716-446655440000"

Python

# Python — uses "uuid"
import uuid
id = uuid.uuid4()
# UUID('550e8400-e29b-41d4-a716-446655440000')

PostgreSQL

-- PostgreSQL — uses "uuid" type
CREATE TABLE users (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY
);

JavaScript

// Browser/Node.js — uses "UUID"
const id = crypto.randomUUID();
// "550e8400-e29b-41d4-a716-446655440000"

Which Term Should You Use?

Use whichever term matches your context:

• In .NET/C# code: Say GUID — that's what the type is called (System.Guid)
• In SQL Server: Say GUID or uniqueidentifier
• In Java, Python, Go, Rust, JavaScript: Say UUID
• In PostgreSQL, MySQL: Say UUID
• In documentation and specs: Say UUID (it's the RFC standard term)
• In conversation: Either one — everyone will understand

If you're writing cross-platform documentation or API specs, UUID is the safer default because it's the standardized term understood across all ecosystems.

Modern Alternatives

While UUID v4 remains the dominant choice, several modern alternatives address its shortcomings:

• UUID v7: Time-sorted UUIDs (RFC 9562). Best of both worlds — unique like v4, sortable like v1, with better database performance.
• ULID: Universally Unique Lexicographically Sortable Identifier. 128 bits, Crockford Base32 encoded, sortable.
• KSUID: K-Sortable Unique Identifier by Segment. 160 bits, naturally sortable by creation time.
• nanoid: Smaller, URL-safe, customizable alphabet. Good when you need shorter IDs.
• Snowflake IDs: Twitter's approach — 64-bit, time-sorted, includes machine ID. Used by Discord and others.

For most applications, UUID v4 (or GUID, if you prefer) remains the simplest and most portable choice. When you need time-sorting or better database index performance, UUID v7 is the modern standard.

TL;DR

• GUID = UUID. Same format, same algorithms, different name.
• UUID is the RFC standard term. GUID is Microsoft's term.
• Use whichever term your ecosystem prefers.
• In cross-platform contexts, UUID is the universal standard.
• For new projects, consider UUID v7 for sortability benefits.