# UUID-generator

> Generer universelt unike identifikatorer (UUID) online gratis. Verktøyet vårt støtter alle UUID-versjoner (v1, v3-v7) for å generere tusenvis samtidig.

URL: https://acrafto.com/no/uuid-generator/

Tools are interactive browser apps; there is no public API, no endpoints to call and no server-side processing. To use a tool, open its HTML page in a browser.

## Hva er UUID?

UUID (Universally Unique Identifier) er en 128-bits identifikator som brukes i datasystemer for å unikt identifisere informasjon. UUID er standardisert under RFC 4122, og takket være sin enorme entropi garanterer den praktisk talt null sannsynlighet for kollisjon – noe som betyr at to uavhengig genererte UUID-er nesten helt sikkert vil være unike.

En UUID har et standardformat: `xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx`, hvor hver `x` er et heksadesimalt siffer (0-9, a-f), `M` angir UUID-versjonen, og `N` angir varianten.

## UUID-versjoner

### UUID v1 (Tidsstempel + MAC-adresse)

UUID v1 er basert på gjeldende tidsstempel og en tilfeldig verdi (i nettleseren i stedet for MAC-adresse). Den bruker 100-nanosekunders intervaller fra 15. oktober 1582 (Gregoriansk kalender).

**Bruk:**

- Situasjoner der du trenger kronologisk sortering av UUID-er
- Feilsøking og logging (UUID inneholder informasjon om opprettelsestidspunktet)
- Distribuerte systemer med tidssynkronisering

**Eksempel:** `6ba7b810-9dad-11d1-80b4-00c04fd430c8`

**Fordeler:**

- UUID-er kan sorteres kronologisk etter opprettelsestidspunkt
- Nyttig for revisjon og feilsøking
- Inneholder tidsstempelinformasjon

**Ulemper:**

- Potensiell sikkerhetsrisiko – inneholder tidsstempel
- I nettleseren inneholder den ikke en faktisk MAC-adresse (erstattet med en tilfeldig verdi)
- Dårlig DB-lokalitet (tidsstempel er i laveste ordens biter)

### UUID v3 (MD5-hash)

UUID v3 genereres ved hjelp av en MD5-hash av et navneområde-UUID og et navn. Deterministisk – samme navneområde + navn vil alltid generere samme UUID.

**Bruk:**

- Konvertering av URL-er, DNS-navn eller andre identifikatorer til UUID-er
- Situasjoner der du trenger reproduserbare UUID-er
- Kartlegging mellom forskjellige identifikasjonssystemer

**Eksempel:** `a3bb189e-8bf9-3888-9912-ace4e6543002`

**Fordeler:**

- Deterministisk (samme input = samme output)
- Ideell for konvertering av kjente identifikatorer
- Ingen kollisjon for forskjellige inputs

**Ulemper:**

- MD5 er en foreldet algoritme (foretrekk v5)
- Krever navneområde og navn
- Kan ikke gjenopprette original input

### UUID v4 (Tilfeldig) - ANBEFALT

Den mest brukte UUID-versjonen. UUID v4 genereres rent tilfeldig ved hjelp av en kryptografisk sikker tilfeldig tallgenerator (`crypto.getRandomValues()`).

**Bruk:**

- Primærnøkler i databaser
- Sesjonsidentifikatorer (session IDs)
- Unike filnavn
- API-token
- Generelle formål der du trenger en garantert unik ID

**Eksempel:** `f47ac10b-58cc-4372-a567-0e02b2c3d479`

**Fordeler:**

- Maksimal entropi og sikkerhet
- Ingen avhengighet av tid eller systemparametere
- Enkleste implementasjon

**Sannsynlighet for kollisjon:** Ved generering av 1 milliard UUID-er per sekund i 100 år er sjansen for kollisjon omtrent 0,00000006%.

### UUID v5 (SHA-1-hash)

UUID v5 er det samme som v3, men bruker SHA-1 i stedet for MD5. Et mer moderne og sikrere alternativ til v3.

**Bruk:**

- Samme som v3, men med bedre sikkerhet
- Foretrukket fremfor v3 for nye prosjekter
- Generering av UUID-er fra URL-er, DNS-navn, OID, X.500 DN

**Eksempel:** `886313e1-3b8a-5372-9b90-0c9aee199e5d`

**Fordeler:**

- Deterministisk
- SHA-1 er mer robust enn MD5
- Egnet for kartlegging mellom systemer

**Ulemper:**

- SHA-1 regnes også som foreldet (men fortsatt sikrere enn MD5)
- Krever navneområde og navn

### UUID v6 (Sortert tidsstempel)

UUID v6 er en forbedret versjon av v1 med omorganiserte tidsbiter for bedre DB-indeksering. Designet for å løse problemer med lokalitet i databaser.

**Bruk:**

- Primærnøkler i databaser med tidsbasert sortering
- Systemer som krever både kronologisk sortering og DB-ytelse
- Et mer moderne alternativ til v1

**Eksempel:** `1ec9414c-232a-6b00-b3c8-9e6bdeced846`

**Fordeler:**

- Bedre DB-lokalitet enn v1 (tidsstempel i høyeste ordens biter)
- Kronologisk sortering
- Kompatibel med UUID-standarden

**Ulemper:**

- Mindre brukt enn v1/v4
- Inneholder fortsatt tidsinformasjon (sikkerhetsrisiko)

### UUID v7 (Unix-tidsstempel)

UUID v7 bruker Unix-tidsstempel (millisekunder fra 1970) + tilfeldige biter. Den nyeste UUID-versjonen med best DB-lokalitet.

**Bruk:**

- Moderne primærnøkler i databaser
- Systemer som krever ytelse + tidsbasert sortering
- Erstatning for v1/v6 i nye prosjekter

**Eksempel:** `017f22e2-79b0-7cc3-98c4-dc0c0c07398f`

**Fordeler:**

- Best DB-lokalitet av alle versjoner
- Unix-tidsstempel er standard
- Kombinerer fordelene med tilfeldighet og tidsbasert sortering

**Ulemper:**

- Relativt ny spesifikasjon (RFC 4122bis)
- Mindre støttet i eldre systemer

## Hvilken UUID-versjon skal jeg bruke?

### Beslutningsguide

**Trenger du maksimal sikkerhet og tilfeldighet?** → Bruk **UUID v4** (det vanligste valget)

**Trenger du tidsbasert sortering og DB-ytelse?** → Bruk **UUID v7** (moderne) eller **UUID v6** (standard)

**Trenger du reproduserbare UUID-er fra eksisterende identifikatorer?** → Bruk **UUID v5** (SHA-1) eller **UUID v3** (MD5, eldre)

**Trenger du tidsstempel og revisjonsspor?** → Bruk **UUID v1** (eldre, dårligere DB-ytelse)

### Databaser

**For nye prosjekter:** UUID v7 eller v4

- **v7** er ideell for tidsbasert sortering + ytelse
- **v4** for maksimal tilfeldighet uten tidsinformasjon

**For eldre systemer:** UUID v1 eller v6

- **v6** har bedre DB-lokalitet enn v1
- **v1** er bredt støttet

**Fordeler med UUID som primærnøkkel:**

- **Global unikhet** – Du kan koble data fra forskjellige databaser uten konflikt
- **Sikkerhet** – I motsetning til sekvensielle ID-er (1, 2, 3…) kan ikke neste verdier gjettes
- **Distribuerte systemer** – UUID-er kan genereres uavhengig på flere servere uten koordinering
- **Slå sammen databaser** – Ved sammenslåing av to databaser oppstår det ingen konflikter

**Ulemper:**

- Større størrelse (16 byte vs 4-8 byte for integer)
- Saktere indeksering i noen databaser (bruk v6/v7 for bedre ytelse)
- Mindre lesbar for mennesker

### API-er og webtjenester

- **REST API** – Unike identifikatorer for ressurser
- **GraphQL** – Globale identifikatorer for noder
- **Webhooker** – Sporing av forespørsler og svar
- **Tokener** – Sesjons-ID-er, refresh-token

### Filer og lagring

- **Filnavn** – Forebygging av kollisjoner ved opplasting
- **S3/Cloud Storage** – Unike baner til objekter
- **Cache-nøkler** – Identifikatorer i cachesystemer

### Frontend-applikasjoner

- **React/Vue-komponenter** – Unike nøkler for lister
- **Midlertidige ID-er** – ID-er før lagring i database
- **Lokal lagring** – Nøkler for lagrede data
- **Offline-først applikasjoner** – Generering av ID-er uten servertilkobling

## Avanserte funksjoner i generatoren

### Generere UUID med tilpasset tid

For tidsbaserte versjoner (v1, v6, v7) kan du velge et hvilket som helst tidsstempel ved hjelp av datovelgeren. Dette er nyttig for:

**Testing:**

- Simulering av UUID-er opprettet i fortiden
- Testing av tidsbasert sortering i databaser
- Reproduksjon av UUID-er for feilsøking

**Datamigrering:**

- Generering av UUID-er med historiske tidsstempler
- Etterfylling av data med korrekte tidsstempelverdier
- Import av data fra forskjellige tidsperioder

**Revisjon og compliance:**

- Rekonstruksjon av UUID-er basert på opprettelsestidspunktet for en post
- Retroaktiv generering av identifikatorer

**Eksempel på bruk:**

1. Velg versjon v1, v6 eller v7
2. Angi dato og klokkeslett ved hjelp av datovelgeren
3. Generer UUID-er med ditt eget tidsstempel

### Hash-basert UUID (v3, v5)

For deterministiske UUID-er kan du bruke versjon v3 (MD5) eller v5 (SHA-1):

**Slik bruker du det:**

1. Velg navneområde i henhold til typen av din identifikator
2. Skriv inn navnet/verdien
3. Generer UUID

**Eksempler:**

| Navneområde | Navn (input) | Bruk |
| --- | --- | --- |
| DNS | `example.com` | Konvertering av domenenavn til UUID |
| DNS | `google.com` | Hver nettside har en unik UUID |
| URL | `https://example.com/page` | Konvertering av URL til UUID |
| URL | `https://api.example.com/users/123` | API-endepunkt som UUID |
| OID | `1.3.6.1.4.1.343` | Objektidentifikator til UUID |
| X.500 | `CN=John Doe,O=Company` | Distinguished Name til UUID |

**Viktige egenskaper:**

- ✅ **Deterministisk**: Samme input = alltid samme UUID
- ✅ **Reproducerbar**: Du kan gjenskape UUID-en når som helst
- ✅ **Konsistent**: Samme UUID på tvers av forskjellige systemer
- ❌ **Kan ikke dekodes**: Originalt navn kan ikke gjenopprettes fra UUID
- ℹ️ **Én UUID**: For v3/v5 genereres alltid bare én UUID (samme input = samme output)

**Praktisk bruk:**

```
// Eksempel: Konverter URL til UUID v5
Namespace: URL
Navn: https://example.com/api/users/123
Resultat: 886313e1-3b8a-5372-9b90-0c9aee199e5d

// Samme input = alltid samme UUID
Namespace: DNS
Navn: google.com
Resultat: alltid samme UUID for google.com
```

## Hvordan bruke UUID trygt?

### Kryptografisk sikkerhet

Vår generator bruker `crypto.getRandomValues()`, som er en kryptografisk sikker tilfeldig tallgenerator. I motsetning til `Math.random()`, som er forutsigbar og uegnet for sikkerhetsformål, gir `crypto.getRandomValues()` ekte entropi som er egnet for:

- Generering av sikkerhetstoken
- Sesjons-ID-er
- API-nøkler
- Kryptografiske applikasjoner

### Sammenligning av UUID-versjoner

| Versjon | Grunnlag | Kollisjon | Tidsbasert sortering | DB-ytelse | Bruk |
| --- | --- | --- | --- | --- | --- |
| v1 | Tidsstempel + MAC | Lav | ✅ Ja | ❌ Dårligere | Eldre, revisjon |
| v3 | MD5-hash | Ingen (deterministisk) | ❌ Nei | ⚠️ Middels | Konverteringer (eldre) |
| v4 | Tilfeldig | Ekstremt lav | ❌ Nei | ⚠️ Middels | Generell bruk |
| v5 | SHA-1-hash | Ingen (deterministisk) | ❌ Nei | ⚠️ Middels | Konverteringer (anbefalt) |
| v6 | Sortert tidsstempel | Lav | ✅ Ja | ✅ Bedre | Moderne DB med tid |
| v7 | Unix-tidsstempel | Lav | ✅ Ja | ✅ Best | Nye prosjekter |

### UUID vs. andre identifikatorer

| Type | Størrelse | Kollisjon | Tidsbasert sortering | Bruk |
| --- | --- | --- | --- | --- |
| Auto-increment ID | 4-8 byte | Garantert unik innenfor tabell | ❌ | Enkle applikasjoner, lokal DB |
| UUID v4 | 16 byte | Praktisk talt umulig | ❌ | Distribuerte systemer, API |
| UUID v7 | 16 byte | Praktisk talt umulig | ✅ | Moderne DB med ytelse |
| ULID | 16 byte | Praktisk talt umulig | ✅ | UUID + leksikografisk sortering |
| Snowflake ID | 8 byte | Garantert unik ved riktig konfigurasjon | ✅ | Twitter, distribuerte systemer |
| NanoID | Konfigurerbar | Avhenger av lengde | ❌ | URL-vennlige ID-er |

## Implementering i forskjellige språk

### JavaScript/TypeScript

```
// UUID v4 - Den enkleste måten (moderne nettlesere)
const uuid = crypto.randomUUID();

// UUID v4 - Manuell implementasjon
function generateUUIDv4() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
    const r = (crypto.getRandomValues(new Uint8Array(1))[0] & 0x0f) >> (c === 'x' ? 0 : 2);
    const v = c === 'x' ? r : (r & 0x3) | 0x8;
    return v.toString(16);
  });
}

// UUID v7 - Anbefalt for databaser
function generateUUIDv7() {
  const timestamp = Date.now();
  const timeHi = (timestamp >> 16).toString(16).padStart(8, '0');
  const timeLow = (timestamp & 0xFFFF).toString(16).padStart(4, '0');

  const randomBytes = crypto.getRandomValues(new Uint8Array(10));
  const randomHex = Array.from(randomBytes)
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');

  return `${timeHi}-${timeLow}-7${randomHex.substr(0, 3)}-${randomHex.substr(3, 4)}-${randomHex.substr(7)}`;
}
```

### Python

```
import uuid

# UUID v4
uuid_v4 = str(uuid.uuid4())
# Output: '6ba7b810-9dad-11d1-80b4-00c04fd430c8'

# UUID v1
uuid_v1 = str(uuid.uuid1())
```

### Java

```
import java.util.UUID;

// UUID v4
String uuidV4 = UUID.randomUUID().toString();
```

### PHP

```
// UUID v4 (PHP 7+)
function generateUUID() {
    return sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
        mt_rand(0, 0xffff), mt_rand(0, 0xffff),
        mt_rand(0, 0xffff),
        mt_rand(0, 0x0fff) | 0x4000,
        mt_rand(0, 0x3fff) | 0x8000,
        mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
    );
}
```

### C#

```
using System;

// UUID v4
Guid uuid = Guid.NewGuid();
string uuidString = uuid.ToString();
```

## Beste praksis

### Lagre UUID-er i database

**PostgreSQL:**

```
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT NOW()
);
```

**MySQL 8.0+:**

```
CREATE TABLE users (
    id BINARY(16) PRIMARY KEY DEFAULT (UUID_TO_BIN(UUID())),
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
```

**Tips:** I MySQL lagrer du UUID-er som `BINARY(16)` i stedet for `CHAR(36)` for å spare plass og for raskere indeksering.

### Validering av UUID

```
function isValidUUID(uuid) {
  const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
  return regex.test(uuid);
}
```

### Konvertering av UUID

```
// Fjerning av bindestreker
const compact = uuid.replace(/-/g, '');

// Legge til bindestreker igjen
function formatUUID(compactUuid) {
  return [
    compactUuid.substring(0, 8),
    compactUuid.substring(8, 12),
    compactUuid.substring(12, 16),
    compactUuid.substring(16, 20),
    compactUuid.substring(20, 32)
  ].join('-');
}
```

## Feilsøking

### UUID v3/v5 fungerer ikke

**Problem:** Ingenting genereres etter å ha valgt v3 eller v5

**Løsning:**

1. ✅ Kontroller at du har **fylt ut “Navn”-feltet** - det er obligatorisk!
2. ✅ Velg riktig navneområde i henhold til inndatatypen
3. ✅ Eksempler på gyldige inndata:
   - DNS: `example.com`, `google.com`
   - URL: `https://example.com/page`
   - Enhver tekst: `min-applikasjon-v1`

**Tips:** Prøv først en enkel verdi som `test` og navneområde DNS.

### Tidsbasert UUID (v1, v6, v7) har en merkelig tid

**Problem:** Den genererte UUID-en har et uventet tidsstempel

**Løsning:**

1. ✅ Kontroller datovelgeren - er riktig tid angitt?
2. ✅ Datovelgeren bruker din lokale tidssone
3. ✅ La datovelgeren stå tom for å bruke nåværende tid

### UUID kan ikke kopieres

**Problem:** “Kopier alt”-knappen fungerer ikke

**Løsning:**

1. ✅ Kontroller at du har generert UUID-er (at de ikke er tomme)
2. ✅ Noen nettlesere krever HTTPS for utklippstavle-API
3. ✅ Alternativt, velg teksten i tekstområdet og kopier manuelt (Ctrl+C)

## Ofte stilte spørsmål (FAQ)

### Kan en UUID-kollisjon oppstå?

Teoretisk sett ja, men sannsynligheten er astronomisk liten. Ved generering av 1 milliard UUID v4 per sekund i 100 år er sjansen for kollisjon omtrent 0,00000006%. I praksis vil en kollisjon aldri skje.

### Er UUID egnet som primærnøkkel i en database?

Det kommer an på bruksområdet. UUID er ideell for distribuerte systemer og situasjoner der du trenger global unikhet. For enkle applikasjoner med én database kan auto-increment være mer effektivt.

### Er UUID-ene generert av dette verktøyet sikre?

Ja, vi bruker Web Crypto API (\`crypto.getRandomValues()\`), som gir kryptografisk sikre tilfeldige verdier. Alt skjer lokalt i nettleseren din.

### Hva er forskjellen mellom UUID-versjonene?

\- \*\*v1\*\*: Tidsstempel + MAC/tilfeldig - kronologisk sortering, dårligere DB-ytelse - \*\*v3/v5\*\*: Hash-basert - deterministisk, for konvertering av kjente identifikatorer - \*\*v4\*\*: Tilfeldig - sikrest, mest brukt - \*\*v6\*\*: Omorganisert tidsstempel - bedre DB-ytelse enn v1 - \*\*v7\*\*: Unix-tidsstempel - best DB-ytelse + tidsbasert sortering

### Hvilken UUID-versjon bør jeg bruke?

For de fleste tilfeller, bruk \*\*v4\*\* (tilfeldig). For databaser med tidsbasert sortering, bruk \*\*v7\*\* (moderne) eller \*\*v6\*\* (standard). For konvertering av kjente identifikatorer (URL, DNS), bruk \*\*v5\*\* (SHA-1).

### Kan jeg bruke UUID for token og API-nøkler?

UUID v4 er egnet for sesjons-ID-er og lignende token. For API-nøkler bør du vurdere lengre tilfeldige strenger (f.eks. 256-bit verdier) eller spesialiserte biblioteker.

### Hvor store er UUID-er?

En UUID er 128 bit (16 byte). I strengformat med bindestreker tar den 36 tegn. Uten bindestreker 32 heksadesimale tegn.

## Alternativer til UUID

### ULID (Universally Unique Lexicographically Sortable Identifier)

- 128-bits ID (samme som UUID)
- Leksikografisk sorterbar etter opprettelsestidspunkt
- Mer kompakt representasjon (26 tegn i stedet for 36)
- Case-insensitiv base32-koding

**Eksempel:** `01ARZ3NDEKTSV4RRFFQ69G5FAV`

### NanoID

- Mindre størrelse enn UUID (standard 21 tegn)
- URL-vennlig (uten spesialtegn)
- Raskere generering
- Konfigurerbar lengde og alfabet

**Eksempel:** `V1StGXR8_Z5jdHi6B-myT`

### Snowflake ID (Twitter)

- 64-bits ID (mindre enn UUID)
- Tidsbasert sorterbar
- Inneholder worker ID og sekvensnummer
- Krever sentralisert konfigurasjon

**Eksempel:** `1234567890123456789`

## Ytelse og optimalisering

### Genereringshastighet

Vår generator kan generere:

- **1 UUID:** < 1 ms
- **100 UUID:** ~10-20 ms
- **1000 UUID:** ~100-200 ms

### Tips for ytelse

1. **Batch-generering** – Hvis du trenger mange UUID-er, generer dem samtidig i stedet for én om gangen
2. **Lagring i DB** – Indekser UUID-kolonner for raskt søk
3. **Komprimering** – Lagre UUID-er i binær form (16 byte) i stedet for streng (36 byte)
4. **Caching** – I noen tilfeller kan du forhåndsgenerere og cache UUID-er

## For utviklere

### Struktur av UUID v4

```
xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|        |    |    |    |
|        |    |    |    └─ 48 biter med tilfeldige data (node)
|        |    |    └────── 16 biter med tilfeldige data med variant (clock_seq)
|        |    └─────────── 12 biter med tilfeldige data + 4 biter versjon (time_hi_and_version)
|        └──────────────── 16 biter med tilfeldige data (time_mid)
└───────────────────────── 32 biter med tilfeldige data (time_low)
```

- Versjon (4 biter): alltid `0100` (binært) = `4` (heksadesimalt)
- Variant (2-3 biter): alltid `10` (binært) for RFC 4122

### Testing av UUID

```
// Jest test
describe('UUID Generator', () => {
  test('generates valid UUID v4', () => {
    const uuid = generateUUIDv4();
    const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
    expect(regex.test(uuid)).toBe(true);
  });

  test('generates unique UUIDs', () => {
    const uuid1 = generateUUIDv4();
    const uuid2 = generateUUIDv4();
    expect(uuid1).not.toBe(uuid2);
  });
});
```

## Sikkerhetsaspekter

### Hva du ikke skal gjøre med UUID

❌ **Ikke bruk UUID v1 for sensitive applikasjoner** – Inneholder tidsstempel, noe som kan være en sikkerhetsrisiko

❌ **Ikke bruk `Math.random()` for å generere UUID-er** – Er ikke kryptografisk sikker

❌ **Ikke stol på UUID for autorisasjon** – UUID-er kan gjettes (selv om sannsynligheten er ekstremt liten)

❌ **Ikke lagre UUID-er i informasjonskapsler uten kryptering** – Bruk signerte informasjonskapsler eller JWT

### Hva du skal gjøre

✅ **Bruk UUID v4 for de fleste tilfeller** – Høyest entropi og sikkerhet

✅ **Kombiner UUID med andre sikkerhetstiltak** – For sesjonshåndtering, bruk HTTPS, HttpOnly-informasjonskapsler og kort utløpstid

✅ **Valider UUID-er på serveren** – Kontroller alltid formatet og versjonen av UUID

✅ **Bruk kryptografisk sikre kilder for tilfeldighet** – `crypto.getRandomValues()` i nettleseren, `/dev/urandom` på Linux

## Kuriosa

- **Antall mulige UUID v4:** 2^122 ≈ 5.3 × 10^36 (340 undecillioner)
- **Nødvendig kollisjon:** For 50% sjanse for kollisjon må du generere 2.71 × 10^18 UUID-er (2.71 quintillioner)
- **Størrelsen på alle mulige UUID-er:** Hvis vi lagret hver UUID som 16 byte, ville hele plassen tatt opp 85 zettabyte (85 milliarder terabyte)
- **Opprinnelse:** UUID ble standardisert som en del av DCE (Distributed Computing Environment) i 1990

## Other languages

- Čeština (cs): [Generátor UUID](https://acrafto.com/cs/generator-uuid/) ([Markdown](https://acrafto.com/cs/generator-uuid/index.md))
- Slovenčina (sk): [UUID generátor](https://acrafto.com/sk/generator-uuid/) ([Markdown](https://acrafto.com/sk/generator-uuid/index.md))
- English (en): [UUID Generator](https://acrafto.com/en/uuid-generator/) ([Markdown](https://acrafto.com/en/uuid-generator/index.md))
- Deutsch (de): [UUID Generator](https://acrafto.com/de/uuid-generator/) ([Markdown](https://acrafto.com/de/uuid-generator/index.md))
- Français (fr): [Générateur UUID](https://acrafto.com/fr/generateur-uuid/) ([Markdown](https://acrafto.com/fr/generateur-uuid/index.md))
- Español (es): [Generador de UUID](https://acrafto.com/es/generador-uuid/) ([Markdown](https://acrafto.com/es/generador-uuid/index.md))
- Italiano (it): [Generatore UUID](https://acrafto.com/it/generatore-uuid/) ([Markdown](https://acrafto.com/it/generatore-uuid/index.md))
- Português (pt): [Gerador de UUID](https://acrafto.com/pt/gerador-uuid/) ([Markdown](https://acrafto.com/pt/gerador-uuid/index.md))
- Nederlands (nl): [UUID generator](https://acrafto.com/nl/uuid-generator/) ([Markdown](https://acrafto.com/nl/uuid-generator/index.md))
- Polski (pl): [Generator UUID](https://acrafto.com/pl/generator-uuid/) ([Markdown](https://acrafto.com/pl/generator-uuid/index.md))
- Română (ro): [Generator UUID](https://acrafto.com/ro/generator-uuid/) ([Markdown](https://acrafto.com/ro/generator-uuid/index.md))
- Magyar (hu): [UUID generátor](https://acrafto.com/hu/uuid-generator/) ([Markdown](https://acrafto.com/hu/uuid-generator/index.md))
- Ελληνικά (el): [Γεννήτρια UUID](https://acrafto.com/el/gennitria-uuid/) ([Markdown](https://acrafto.com/el/gennitria-uuid/index.md))
- Български (bg): [UUID генератор](https://acrafto.com/bg/uuid-generator/) ([Markdown](https://acrafto.com/bg/uuid-generator/index.md))
- Hrvatski (hr): [Generator UUID](https://acrafto.com/hr/generator-uuid/) ([Markdown](https://acrafto.com/hr/generator-uuid/index.md))
- Slovenščina (sl): [UUID generator](https://acrafto.com/sl/generator-uuid/) ([Markdown](https://acrafto.com/sl/generator-uuid/index.md))
- Eesti (et): [UUID generaator](https://acrafto.com/et/uuid-generaator/) ([Markdown](https://acrafto.com/et/uuid-generaator/index.md))
- Latviešu (lv): [UUID ģenerators](https://acrafto.com/lv/uuid-generator/) ([Markdown](https://acrafto.com/lv/uuid-generator/index.md))
- Lietuvių (lt): [UUID generatorius](https://acrafto.com/lt/uuid-generatorius/) ([Markdown](https://acrafto.com/lt/uuid-generatorius/index.md))
- Svenska (sv): [UUID-generator](https://acrafto.com/sv/uuid-generator/) ([Markdown](https://acrafto.com/sv/uuid-generator/index.md))
- Dansk (da): [UUID generator](https://acrafto.com/da/uuid-generator/) ([Markdown](https://acrafto.com/da/uuid-generator/index.md))
- Suomi (fi): [UUID-generaattori](https://acrafto.com/fi/uuid-generaattori/) ([Markdown](https://acrafto.com/fi/uuid-generaattori/index.md))
- Українська (uk): [Генератор UUID](https://acrafto.com/uk/henerator-uuid/) ([Markdown](https://acrafto.com/uk/henerator-uuid/index.md))
- Русский (ru): [Генератор UUID](https://acrafto.com/ru/generator-uuid/) ([Markdown](https://acrafto.com/ru/generator-uuid/index.md))
- Српски (sr): [UUID generator](https://acrafto.com/sr/uuid-generator/) ([Markdown](https://acrafto.com/sr/uuid-generator/index.md))
- Македонски (mk): [UUID генератор](https://acrafto.com/mk/uuid-generator/) ([Markdown](https://acrafto.com/mk/uuid-generator/index.md))
- Bosanski (bs): [Generator UUID-a](https://acrafto.com/bs/generator-uuid/) ([Markdown](https://acrafto.com/bs/generator-uuid/index.md))
- Shqip (sq): [Gjenerator UUID](https://acrafto.com/sq/gjenerator-uuid/) ([Markdown](https://acrafto.com/sq/gjenerator-uuid/index.md))
- Türkçe (tr): [UUID oluşturucu](https://acrafto.com/tr/uuid-uretici/) ([Markdown](https://acrafto.com/tr/uuid-uretici/index.md))
- 日本語 (ja): [UUID生成ツール](https://acrafto.com/ja/uuid-generator/) ([Markdown](https://acrafto.com/ja/uuid-generator/index.md))
- 한국어 (ko): [UUID 생성기](https://acrafto.com/ko/uuid-generator/) ([Markdown](https://acrafto.com/ko/uuid-generator/index.md))
- العربية (ar): [مولد UUID](https://acrafto.com/ar/uuid-generator/) ([Markdown](https://acrafto.com/ar/uuid-generator/index.md))
- हिन्दी (hi): [UUID जनरेटर](https://acrafto.com/hi/uuid-generator/) ([Markdown](https://acrafto.com/hi/uuid-generator/index.md))
- Bahasa Indonesia (id): [Generator UUID](https://acrafto.com/id/generator-uuid/) ([Markdown](https://acrafto.com/id/generator-uuid/index.md))
- Tiếng Việt (vi): [Trình tạo UUID](https://acrafto.com/vi/uuid-generator/) ([Markdown](https://acrafto.com/vi/uuid-generator/index.md))
- ไทย (th): [สร้าง UUID](https://acrafto.com/th/uuid-generator/) ([Markdown](https://acrafto.com/th/uuid-generator/index.md))
- עברית (he): [מחולל UUID](https://acrafto.com/he/uuid-generator/) ([Markdown](https://acrafto.com/he/uuid-generator/index.md))