GUID Generator

What Is a GUID?

A GUID (Globally Unique Identifier) is Microsoft's implementation of the UUID standard - a 128-bit random identifier used to uniquely identify objects across software systems, databases, and Windows services. Structurally, a GUID is identical to a UUID v4: 32 hexadecimal digits arranged in five groups separated by hyphens, covering a total address space of 2¹²² unique values (approximately 5.3 × 10³⁶ possibilities). The only practical differences are cosmetic - GUIDs are conventionally displayed in uppercase and often wrapped in curly braces in Windows and .NET contexts.

A typical GUID looks like: {550E8400-E29B-41D4-A716-446655440000}. Remove the braces and lowercase the characters, and you have a standard UUID: 550e8400-e29b-41d4-a716-446655440000. They represent the same 128-bit value.

GUID vs UUID - Are They the Same?

Technically, yes - a GUID and a UUID are the same thing. Microsoft introduced the term "GUID" in the early 1990s as part of the Component Object Model (COM) and Distributed COM (DCOM) specifications. Simultaneously, the Open Software Foundation (OSF) was developing UUID for the Distributed Computing Environment (DCE). Both converged on the same 128-bit format.

RFC 4122 (published 2005) formally unified the two terms. Section 3 states explicitly: the terms "GUID" and "UUID" are used interchangeably. In practice, the terminology split is purely ecosystem-based:

How to Generate a GUID - Code Examples in 5 Languages

Our free online GUID generator handles bulk generation in-browser with zero server calls. But if you need to generate GUIDs programmatically inside your application, here are production-ready examples across the most common languages and platforms.

C# / .NET — System.Guid

// C# — Generate a GUID using System.Guid
using System;

// Basic generation
Guid id = Guid.NewGuid();
Console.WriteLine(id); // 550e8400-e29b-41d4-a716-446655440000

// Format specifiers
Console.WriteLine(id.ToString("D")); // 550e8400-e29b-41d4-a716-446655440000  (default)
Console.WriteLine(id.ToString("B")); // {550e8400-e29b-41d4-a716-446655440000} (braces)
Console.WriteLine(id.ToString("N")); // 550e8400e29b41d4a716446655440000      (no hyphens)
Console.WriteLine(id.ToString("P")); // (550e8400-e29b-41d4-a716-446655440000) (parentheses)
Console.WriteLine(id.ToString("X")); // {0x550e8400,0xe29b,0x41d4,...}         (hex struct)

// Uppercase (Windows Registry / COM format)
Console.WriteLine(id.ToString("B").ToUpper()); // {550E8400-E29B-41D4-A716-446655440000}

// Parse a GUID from string
Guid parsed = Guid.Parse("{550E8400-E29B-41D4-A716-446655440000}");
bool isValid = Guid.TryParse(userInput, out Guid result); // safe parse

// Use as database primary key (Entity Framework)
public class Order
{
    public Guid OrderId { get; set; } = Guid.NewGuid(); // auto-generate on create
    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
}

SQL Server - UNIQUEIDENTIFIER

-- SQL Server — Generate GUIDs with built-in functions

-- 1. NEWID() — Random GUID (UUID v4 equivalent)
--    Causes index fragmentation on clustered indexes (random order)
SELECT NEWID();
-- Result: 6F9619FF-8B86-D011-B42D-00C04FC964FF

-- 2. NEWSEQUENTIALID() — Sequential GUID (column default only)
--    Monotonically increasing, reduces index fragmentation
CREATE TABLE Orders (
    OrderId    UNIQUEIDENTIFIER DEFAULT NEWSEQUENTIALID() PRIMARY KEY,
    CustomerId INT              NOT NULL,
    Total      DECIMAL(10,2)   NOT NULL,
    CreatedAt  DATETIME2       DEFAULT GETUTCDATE()
);

-- 3. Insert with a pre-generated GUID (best practice for distributed systems)
INSERT INTO Orders (OrderId, CustomerId, Total)
VALUES (NEWID(), 1001, 299.99);

-- 4. Query by GUID
SELECT * FROM Orders
WHERE OrderId = '6F9619FF-8B86-D011-B42D-00C04FC964FF';

-- 5. Convert GUID to string and back
SELECT CAST(NEWID() AS NVARCHAR(36));                          -- to string
SELECT CAST('6F9619FF-8B86-D011-B42D-00C04FC964FF' AS UNIQUEIDENTIFIER); -- to GUID

-- PRO TIP: For new projects, generate UUID v7 client-side and store as UNIQUEIDENTIFIER.
-- UUID v7 is time-ordered (like NEWSEQUENTIALID) but works across distributed systems
-- and doesn't reset on server restart like NEWSEQUENTIALID does.

Python - uuid Module

import uuid

# Generate a GUID (UUID v4) in Python
guid = uuid.uuid4()
print(guid)                    # 550e8400-e29b-41d4-a716-446655440000
print(str(guid).upper())       # 550E8400-E29B-41D4-A716-446655440000
print(f"{{{str(guid).upper()}}}")  # {550E8400-E29B-41D4-A716-446655440000} (Windows format)
print(guid.hex)                # 550e8400e29b41d4a716446655440000 (no hyphens)

# Parse a GUID from string
parsed = uuid.UUID('{550E8400-E29B-41D4-A716-446655440000}')
print(parsed.version)  # 4

# Bulk generate GUIDs
guids = [str(uuid.uuid4()).upper() for _ in range(10)]
for g in guids:
    print(f"{{{g}}}")

JavaScript / Node.js - crypto module

// JavaScript (Browser) — Web Crypto API (same as this generator uses)
function generateGUID() {
  return crypto.randomUUID().toUpperCase(); // built-in, no dependencies
}
console.log(generateGUID()); // 550E8400-E29B-41D4-A716-446655440000

// With curly braces (Windows format)
function generateWindowsGUID() {
  return `{${crypto.randomUUID().toUpperCase()}}`;
}

// Node.js — crypto module (v14.17+)
const { randomUUID } = require('crypto');
const guid = randomUUID();               // 550e8400-e29b-41d4-a716-446655440000
const windowsGuid = `{${randomUUID().toUpperCase()}}`;

// Bulk generate (Node.js)
const guids = Array.from({ length: 10 }, () => randomUUID().toUpperCase());
console.log(guids);

// Using 'uuid' npm package (older Node.js versions)
// npm install uuid
const { v4: uuidv4 } = require('uuid');
const id = uuidv4(); // 550e8400-e29b-41d4-a716-446655440000

PowerShell - [System.Guid]

# PowerShell — Generate GUIDs using .NET System.Guid

# Basic GUID generation
[System.Guid]::NewGuid()
# Output: 550e8400-e29b-41d4-a716-446655440000

# Windows Registry format (uppercase + braces)
"{$([System.Guid]::NewGuid().ToString().ToUpper())}"
# Output: {550E8400-E29B-41D4-A716-446655440000}

# Short version
[guid]::NewGuid().ToString("B").ToUpper()

# Bulk generate 10 GUIDs
1..10 | ForEach-Object { [guid]::NewGuid().ToString("B").ToUpper() }

# Generate and copy to clipboard
[guid]::NewGuid().ToString("B").ToUpper() | Set-Clipboard

GUIDs in the .NET Ecosystem

In C# and .NET, System.Guid is a first-class value type (struct) - not a class - which means it is stack-allocated, zero-overhead for garbage collection, and inherently immutable. This makes it ideal for use as a primary key type in high-throughput applications. Guid.NewGuid() internally calls the Windows CoCreateGuid API, which is backed by CryptGenRandom - the same CSPRNG used for TLS certificates and cryptographic key generation. It is fully cryptographically secure and appropriate for security-sensitive identifiers.

Entity Framework Core automatically maps Guid properties to UNIQUEIDENTIFIER columns in SQL Server, uuid columns in PostgreSQL, and CHAR(36) or BINARY(16) in MySQL - type across all major .NET-supported databases.

GUIDs in SQL Server - Performance Considerations

SQL Server's UNIQUEIDENTIFIER type stores GUIDs as 16 bytes — the most compact binary representation possible. However, using NEWID() (random GUID) as a clustered primary key introduces index fragmentation because each new row inserts at a random position in the B-tree index, causing frequent page splits. For write-heavy tables, this can reduce insert performance by 30–40% compared to sequential integer keys.

The three approaches and their tradeoffs:

For modern SQL Server applications, generating a UUID v7 client-side and inserting it as a UNIQUEIDENTIFIER gives you the best of all approaches: time-ordered (sequential) insertion order, cross-distributed-system compatibility, and no server-restart resets. UUID v7 is specified in RFC 9562 (2024) and is supported natively in PostgreSQL 17, MySQL 9.0, and MariaDB 10.7+.

GUIDs in Windows Registry and COM

GUIDs are the foundational identity mechanism of the Windows operating system. The Component Object Model (COM), introduced with Windows NT 3.1, uses four distinct types of GUIDs to identify every software component registered on the system:

• CLSID (Class ID) - Identifies a COM class implementation. Stored under HKEY_CLASSES_ROOT\CLSID\{GUID}. Every ActiveX control, Shell extension, and in-process server has a CLSID.

• IID (Interface ID) - Identifies a COM interface definition. Every interface (IUnknown, IDispatch, etc.) has a unique IID that is identical across all Windows systems worldwide.

• LIBID (Library ID) - Identifies a type library (.tlb file). Used by Visual Basic 6, early VBA, and legacy automation tools.

• APPID (Application ID) - Identifies a DCOM server application and its activation and security settings.

When you install software on Windows, the MSI installer registers CLSIDs in the registry and assigns a ProductCode GUID (stored in HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\{GUID}) that uniquely identifies the product and version across all machines worldwide.

GUID Format Reference - All Supported Formats

Our online GUID generator supports all standard Microsoft formats. Use the Uppercase and Wrap in Quotes options to match your target platform's convention.

Common Use Cases for GUIDs

GUIDs are the default identifier type for a wide range of Microsoft-ecosystem and enterprise systems:

• SQL Server primary keys - UNIQUEIDENTIFIER columns with NEWID() or pre-generated client-side GUIDs. The most common GUID use case in enterprise applications.

• .NET Entity Framework - Guid properties automatically map to UNIQUEIDENTIFIER in SQL Server, uuid in PostgreSQL, and binary in MySQL.

• Azure services - Azure Resource Manager (ARM), Azure Active Directory (Entra ID), Azure Service Bus, and virtually all Azure APIs use GUIDs as resource identifiers and tenant/subscription IDs.

• MSI installer packages - Every Windows installer has a ProductCode GUID identifying the product and a UpgradeCode GUID linking versions together for upgrades.

• Visual Studio project files - Every .csproj, .vbproj, and .sln file contains GUIDs to uniquely identify projects and solution configurations across developer machines.

• ASP.NET session and anti-forgery tokens - GUID-based tokens for CSRF protection and distributed session management.

• SignalR connection IDs - GUIDs identify WebSocket connections in real-time .NET applications.

• Microsoft 365 / SharePoint - List items, documents, site collections, and user accounts all use GUID identifiers internally.

GUID Collision Probability - Is It Actually Unique?

A GUID v4 contains 122 bits of cryptographic randomness (6 bits are fixed for the version and variant markers). The total number of possible GUIDs is 2¹²² ≈ 5.3 × 10³⁶. To put that in perspective:

• If every person on Earth (8 billion people) generated 1 billion GUIDs per second, it would take approximately 85 years before a collision became statistically likely - and even then, the probability would be roughly 50% only after that timeframe.

• In practice, generating even 1 trillion GUIDs produces a collision probability of approximately 1 in 5.3 × 10²⁴ - effectively zero for any real-world system.

GUID uniqueness relies entirely on the quality of the underlying CSPRNG. This generator uses the browser's crypto.getRandomValues() API - the same cryptographically secure random number generator used for TLS key generation - making collision probability negligibly small for any practical workload.

When to Use GUID vs UUID v7 vs ULID

Rule of thumb: Use GUID for existing Windows/.NET/SQL Server systems where UNIQUEIDENTIFIER is already the standard. For new projects — especially those running across distributed services or microservices — consider UUID v7 which is time-ordered (better index performance), RFC-standardized, and natively supported by PostgreSQL 17, MySQL 9, and MariaDB 10.7+. Use ULID when you need URL-safe, human-sortable identifiers.