UUID vs GUID: is there any difference?

Short answer: they are the same thing. GUID is Microsoft's name for a UUID — an identical 128-bit identifier. The differences that actually bite are formatting conventions and one byte-order trap in .NET.

By the Withuse team · Updated August 25, 2026

Where the two names came from

UUID (Universally Unique Identifier) comes from the Open Software Foundation's DCE in the early 1990s and is standardized today in RFC 9562. Microsoft adopted the same design for COM in the Windows world and branded it GUID (Globally Unique Identifier). The bits are identical; only the vocabulary differs by ecosystem.

Convention differences (not real differences)

	UUID convention	GUID convention (Microsoft)
Case	lowercase canonical (`550e8400-…`)	often uppercase (`550E8400-…`)
Braces	none	registry/COM style `{550E8400-…}`
Typical home	web APIs, PostgreSQL, Java, Python	.NET, SQL Server, Windows registry
SQL type name	`uuid` (PostgreSQL)	`uniqueidentifier` (SQL Server)

Every parser worth using accepts all of these forms — and our generator can output braces or uppercase directly if you need registry-style GUIDs.

The one real difference: .NET byte order

Textually identical, but in raw byte layout Microsoft historically stores the first three fields little-endian. The same identifier 00112233-4455-6677-8899-aabbccddeeff serializes as:

RFC 9562 (network order):   00 11 22 33  44 55  66 77  88 99 aa bb cc dd ee ff
.NET Guid.ToByteArray():    33 22 11 00  55 44  77 66  88 99 aa bb cc dd ee ff
                            └─ swapped ─┘└swap┘ └swap┘  └── identical ──┘

This bites when you exchange binary UUIDs between .NET and anything else (Java, Python, PostgreSQL bytea). Two fixes:

// .NET 8+ — ask for RFC order explicitly
guid.ToByteArray(bigEndian: true);

# Python — both layouts are built in
uuid.UUID(s).bytes      # RFC big-endian
uuid.UUID(s).bytes_le   # matches .NET's default layout

As strings, none of this matters — which is why the rule of thumb is: exchange UUIDs as strings across ecosystems, or pin down the byte order explicitly.

Which term should you say?

UUID — standards, web APIs, cross-platform docs, PostgreSQL, Java/Python/Go/JS ecosystems.
GUID — .NET code (System.Guid), SQL Server, COM/Windows contexts, where it is the native vocabulary.

Nobody will misunderstand either term. Just don't let anyone tell you they are different formats.

Frequently asked questions

Is a GUID the same as a UUID?

Yes. GUID stands for Globally Unique Identifier and is Microsoft's name for what the IETF calls a UUID, a Universally Unique Identifier. Both denote the same 128-bit value with the same 8-4-4-4-12 text layout, the same version and variant bits, and the same generation algorithms defined in RFC 9562. Any valid GUID is a valid UUID and the reverse holds too, so a value created by System.Guid.NewGuid() in .NET is indistinguishable from one created by uuid.uuid4() in Python. The split is historical: UUID came out of the Open Software Foundation's DCE work in the early 1990s, and Microsoft adopted the design for COM under its own name. Only conventions and one byte-order detail differ.

Can I use a GUID from C# in a system that expects UUIDs?

As a string, always — the canonical text form is identical across platforms, so passing it through JSON or a database column works without conversion. As raw bytes, be careful. .NET's Guid.ToByteArray() serialises the first three fields in little-endian order, while RFC 9562 defines a big-endian layout, so the same identifier produces different byte sequences on either side. The value 00112233-4455-6677-8899-aabbccddeeff becomes 00 11 22 33 44 55 66 77 … under the RFC and 33 22 11 00 55 44 77 66 … in .NET. On .NET 8 and later, Guid.ToByteArray(bigEndian: true) gives you the RFC ordering; on earlier versions reorder the first eight bytes yourself.

Are GUIDs uppercase and UUIDs lowercase?

That is convention, not specification. RFC 9562 states that implementations should output lowercase but must accept either case on input, so both forms are valid everywhere. Microsoft tooling has historically printed uppercase and often wrapped the value in braces, as in {550E8400-E29B-41D4-A716-446655440000}, a style that comes from the Windows registry and COM. The practical consequence is that any validator you write should carry the case-insensitive flag, and any comparison you make should normalise case first — otherwise the same identifier arriving from a .NET service and a Node service will look like two different values. Databases with a native UUID type handle this for you by normalising on insert.

Which term should I use, UUID or GUID?

Match the vocabulary of the ecosystem you are writing in. Use UUID for standards documents, web APIs, and anything cross-platform, and in the PostgreSQL, Java, Python, Go and JavaScript worlds where the type and functions carry that name. Use GUID inside Microsoft technologies, where the type really is called System.Guid, the SQL Server column type is uniqueidentifier, and the surrounding documentation says GUID throughout. Nobody will misunderstand either word, and no conversion is implied by switching between them. What matters more than the label is being explicit about version and byte order when two systems exchange identifiers, since those are the differences that actually cause bugs.

Generate either style instantly — lowercase UUIDs or braced uppercase GUIDs — with our free UUID generator. Related: UUID v4 vs v7 · UUID vs ULID