# UUID generator

> Generer universelt unikke identifikatorer (UUID'er) gratis online. Understøtter alle UUID-versioner v1, v3-v7 og genererer tusindvis på én gang.

URL: https://acrafto.com/da/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.

## Hvad er en UUID?

UUID (Universally Unique Identifier) er en 128-bit identifikator, der bruges i computersystemer til unikt at identificere information. UUID er standardiseret i henhold til RFC 4122, og takket være dens enorme entropi garanterer den en praktisk talt nul sandsynlighed for kollision – hvilket betyder, at to uafhængigt genererede UUID’er næsten helt sikkert vil være unikke.

UUID’er har et standardformat: `xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx`, hvor hvert `x` er et hexadecimalt ciffer (0-9, a-f), `M` angiver UUID-versionen, og `N` angiver varianten.

## UUID-versioner

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

UUID v1 er baseret på et aktuelt tidsstempel og en tilfældig værdi (i browseren i stedet for MAC-adresse). Den bruger 100-nanosekund intervaller fra den 15. oktober 1582 (Gregoriansk kalender).

**Anvendelse:**

- Situationer hvor du har brug for kronologisk sortering af UUID’er
- Debugging og logning (UUID indeholder information om oprettelsestidspunkt)
- Distribuerede systemer med tidssynkronisering

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

**Fordele:**

- UUID’er kan sorteres kronologisk efter oprettelsestidspunkt
- Nyttigt til revision og debugging
- Indeholder tidsstempelinformation

**Ulemper:**

- Potentiel sikkerhedsrisiko – indeholder tidsstempel
- I browseren indeholder den ikke en rigtig MAC-adresse (erstattes af en tilfældig værdi)
- Dårlig DB-lokalitet (tidsstempel er i low-order bits)

### UUID v3 (MD5-hash)

UUID v3 genereres ved hjælp af MD5-hash af et namespace UUID og et navn. Deterministisk – samme namespace + navn vil altid skabe den samme UUID.

**Anvendelse:**

- Konvertering af URL’er, DNS-navne eller andre identifikatorer til UUID’er
- Situationer hvor du har brug for reproducerbare UUID’er
- Mapping mellem forskellige identifikationssystemer

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

**Fordele:**

- Deterministisk (samme input = samme output)
- Ideel til konvertering af kendte identifikatorer
- Ingen kollision for forskellige inputs

**Ulemper:**

- MD5 er en forældet algoritme (foretræk v5)
- Kræver namespace og navn
- Kan ikke gendanne originalt input

### UUID v4 (Tilfældig) - ANBEFALET

Den mest anvendte UUID-version. UUID v4 genereres rent tilfældigt ved hjælp af en kryptografisk sikker tilfældighedsgenerator (`crypto.getRandomValues()`).

**Anvendelse:**

- Primære nøgler i databaser
- Sessions-ID’er
- Unikke filnavne
- API-tokens
- Generelle formål, hvor du har brug for et garanteret unikt ID

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

**Fordele:**

- Maksimal entropi og sikkerhed
- Ingen afhængighed af tid eller systemparametre
- Den enkleste implementering

**Sandsynlighed for kollision:** Ved generering af 1 milliard UUID’er pr. sekund i 100 år er chancen for kollision ca. 0,00000006%.

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

UUID v5 er det samme som v3, men bruger SHA-1 i stedet for MD5. Et mere moderne og sikkert alternativ til v3.

**Anvendelse:**

- Samme som v3, men med bedre sikkerhed
- Foretrukket frem for v3 til nye projekter
- Generering af UUID fra URL’er, DNS-navne, OID, X.500 DN

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

**Fordele:**

- Deterministisk
- SHA-1 er mere robust end MD5
- Velegnet til mapping mellem systemer

**Ulemper:**

- SHA-1 betragtes også som forældet (men stadig sikrere end MD5)
- Kræver namespace og navn

### UUID v6 (Sorteret tidsstempel)

UUID v6 er en forbedret version af v1 med omarrangerede tidsbits for bedre DB-indeksering. Designet til at løse lokalitetsproblemer i databaser.

**Anvendelse:**

- Primære nøgler i databaser med tidsbaseret sortering
- Systemer der kræver både kronologisk sortering og DB-ydeevne
- Et mere moderne alternativ til v1

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

**Fordele:**

- Bedre DB-lokalitet end v1 (tidsstempel i high-order bits)
- Kronologisk sortering
- Kompatibel med UUID-standarden

**Ulemper:**

- Mindre brugt end v1/v4
- Indeholder stadig tidsinformation (sikkerhedsrisiko)

### UUID v7 (Unix-tidsstempel)

UUID v7 bruger Unix-tidsstempel (millisekunder siden 1970) + tilfældige bits. Den nyeste UUID-version med den bedste DB-lokalitet.

**Anvendelse:**

- Moderne primære nøgler i databaser
- Systemer der kræver ydeevne + tidsbaseret sortering
- Erstatning for v1/v6 i nye projekter

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

**Fordele:**

- Bedste DB-lokalitet af alle versioner
- Unix-tidsstempel er standard
- Kombinerer fordelene ved tilfældighed og tidsbaseret sortering

**Ulemper:**

- Relativt ny specifikation (RFC 4122bis)
- Mindre understøttet i ældre systemer

## Hvilken UUID-version skal du bruge?

### Beslutningsguide

**Har du brug for maksimal sikkerhed og tilfældighed?** → Brug **UUID v4** (det mest almindelige valg)

**Har du brug for tidsbaseret sortering og DB-ydeevne?** → Brug **UUID v7** (moderne) eller **UUID v6** (standard)

**Har du brug for reproducerbare UUID’er fra eksisterende identifikatorer?** → Brug **UUID v5** (SHA-1) eller **UUID v3** (MD5, ældre)

**Har du brug for et tidsstempel og revisionsspor?** → Brug **UUID v1** (ældre, dårligere DB-ydeevne)

### Databaser

**Til nye projekter:** UUID v7 eller v4

- **v7** er ideel til tidsbaseret sortering + ydeevne
- **v4** for maksimal tilfældighed uden tidsinformation

**Til ældre systemer:** UUID v1 eller v6

- **v6** har bedre DB-lokalitet end v1
- **v1** er bredt understøttet

**Fordele ved UUID som primærnøgle:**

- **Global unikhed** – Du kan forbinde data fra forskellige databaser uden konflikt
- **Sikkerhed** – I modsætning til sekventielle ID’er (1, 2, 3…) kan næste værdier ikke gættes
- **Distribuerede systemer** – UUID’er kan genereres uafhængigt på flere servere uden koordinering
- **Sammenfletning af databaser** – Ved sammenlægning af to databaser opstår der ingen konflikter

**Ulemper:**

- Større størrelse (16 bytes vs 4-8 bytes for integer)
- Langsommere indeksering i nogle databaser (brug v6/v7 for bedre ydeevne)
- Mindre læselig for mennesker

### API og webtjenester

- **REST API** – Unikke identifikatorer for ressourcer
- **GraphQL** – Globale identifikatorer for noder
- **Webhooks** – Sporing af anmodninger og svar
- **Tokens** – Sessions-ID’er, refresh-tokens

### Filer og lagring

- **Filnavne** – Forebyggelse af kollisioner ved upload
- **S3/Cloud Storage** – Unikke stier til objekter
- **Cache-nøgler** – Identifikatorer i cache-systemer

### Frontend-applikationer

- **React/Vue-komponenter** – Unikke nøgler til lister
- **Midlertidige ID’er** – ID’er før lagring i databasen
- **Lokal lagring** – Nøgler til gemte data
- **Offline-first applikationer** – Generering af ID’er uden serverforbindelse

## Avancerede generatorfunktioner

### Generering af UUID med brugerdefineret tid

For tidsbaserede versioner (v1, v6, v7) kan du vælge et vilkårligt tidsstempel ved hjælp af en dato-tid-vælger. Dette er nyttigt til:

**Test:**

- Simulering af UUID’er oprettet i fortiden
- Test af tidsbaseret sortering i databaser
- Reproduktion af UUID’er til debugging

**Datamigration:**

- Generering af UUID’er med historiske tidsstempler
- Tilbagefyldning af data med korrekte tidsstempelværdier
- Import af data fra forskellige tidsperioder

**Revision og compliance:**

- Rekonstruktion af UUID’er baseret på oprettelsestidspunkt for posten
- Retroaktiv generering af identifikatorer

**Eksempel på brug:**

1. Vælg version v1, v6 eller v7
2. Indstil dato og tid ved hjælp af dato-tid-vælgeren
3. Generer UUID med dit eget tidsstempel

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

For deterministiske UUID’er kan du bruge version v3 (MD5) eller v5 (SHA-1):

**Sådan bruges:**

1. Vælg namespace baseret på typen af din identifikator
2. Indtast navn/værdi
3. Generer UUID

**Eksempler:**

| Namespace | Navn (input) | Anvendelse |
| --- | --- | --- |
| DNS | `example.com` | Konverter domænenavn til UUID |
| DNS | `google.com` | Hvert websted har et unikt UUID |
| URL | `https://example.com/page` | Konverter URL til UUID |
| URL | `https://api.example.com/users/123` | API-slutpunkt som UUID |
| OID | `1.3.6.1.4.1.343` | Objektidentifikator til UUID |
| X.500 | `CN=John Doe,O=Company` | Distinguished Name til UUID |

**Vigtige egenskaber:**

- ✅ **Deterministisk**: Samme input = altid samme UUID
- ✅ **Reproducerbar**: Du kan genskabe UUID’et når som helst
- ✅ **Konsekvent**: Samme UUID på tværs af forskellige systemer
- ❌ **Kan ikke afkodes**: Kan ikke gendanne det originale navn fra UUID’et
- ℹ️ **Én UUID**: For v3/v5 genereres altid kun én UUID (samme input = samme output)

**Praktisk anvendelse:**

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

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

## Hvordan bruges UUID’er sikkert?

### Kryptografisk sikkerhed

Vores generator bruger `crypto.getRandomValues()`, som er en kryptografisk sikker tilfældighedsgenerator. I modsætning til `Math.random()`, som er forudsigelig og uegnet til sikkerhedsformål, giver `crypto.getRandomValues()` ægte entropi, der er egnet til:

- Generering af sikkerhedstokens
- Sessions-ID’er
- API-nøgler
- Kryptografiske applikationer

### Sammenligning af UUID-versioner

| Version | Basis | Kollision | Tidsbaseret sortering | DB-ydeevne | Anvendelse |
| --- | --- | --- | --- | --- | --- |
| v1 | Tidsstempel + MAC | Lav | ✅ Ja | ❌ Dårligere | Ældre, revision |
| v3 | MD5-hash | Ingen (deterministisk) | ❌ Nej | ⚠️ Medium | Konverteringer (ældre) |
| v4 | Tilfældig | Ekstremt lav | ❌ Nej | ⚠️ Medium | Generel anvendelse |
| v5 | SHA-1-hash | Ingen (deterministisk) | ❌ Nej | ⚠️ Medium | Konverteringer (anbefalet) |
| v6 | Sorteret tidsstempel | Lav | ✅ Ja | ✅ Bedre | Moderne DB med tid |
| v7 | Unix-tidsstempel | Lav | ✅ Ja | ✅ Bedst | Nye projekter |

### UUID vs. andre identifikatorer

| Type | Størrelse | Kollision | Tidsbaseret sortering | Anvendelse |
| --- | --- | --- | --- | --- |
| Auto-increment ID | 4-8 bytes | Garanteret unik inden for tabel | ❌ | Simple applikationer, lokal DB |
| UUID v4 | 16 bytes | Praktisk talt umuligt | ❌ | Distribuerede systemer, API |
| UUID v7 | 16 bytes | Praktisk talt umuligt | ✅ | Moderne DB med ydeevne |
| ULID | 16 bytes | Praktisk talt umuligt | ✅ | UUID + leksikografisk sortering |
| Snowflake ID | 8 bytes | Garanteret unik med korrekt konfiguration | ✅ | Twitter, distribuerede systemer |
| NanoID | Konfigurerbar | Afhænger af længde | ❌ | URL-venlige ID’er |

## Implementering i forskellige sprog

### JavaScript/TypeScript

```
// UUID v4 - Den nemmeste måde (moderne browsere)
const uuid = crypto.randomUUID();

// UUID v4 - Manuel implementering
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 - Anbefales til 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();
```

## Bedste Praksis

### Lagring af UUID’er i databaser

**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
);
```

**Tip:** I MySQL skal du gemme UUID’er som `BINARY(16)` i stedet for `CHAR(36)` for at spare plads og opnå hurtigere indeksering.

### Validering af UUID’er

```
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 af UUID’er

```
// Fjern bindestreger
const compact = uuid.replace(/-/g, '');

// Tilføj bindestreger igen
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('-');
}
```

## Fejlfinding (Troubleshooting)

### UUID v3/v5 virker ikke

**Problem:** Efter valg af v3 eller v5 genereres intet

**Løsning:**

1. ✅ Kontroller, at du har **udfyldt feltet “Navn”** - det er obligatorisk!
2. ✅ Vælg det korrekte namespace baseret på typen af dit input
3. ✅ Eksempler på gyldige inputs:
   - DNS: `example.com`, `google.com`
   - URL: `https://example.com/page`
   - Enhver tekst: `min-applikation-v1`

**Tip:** Prøv først en simpel værdi som `test` og namespace DNS.

### Tidsbaseret UUID (v1, v6, v7) har en mærkelig tid

**Problem:** Den genererede UUID har et uventet tidsstempel

**Løsning:**

1. ✅ Kontroller dato-tid-vælgeren - er den korrekte tid indstillet?
2. ✅ Dato-tid-vælgeren bruger din lokale tidszone
3. ✅ Lad dato-tid-vælgeren være tom for aktuel tid

### UUID kan ikke kopieres

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

**Løsning:**

1. ✅ Kontroller, at du har genereret UUID’er (de er ikke tomme)
2. ✅ Nogle browsere kræver HTTPS for clipboard API’en
3. ✅ Alternativt, vælg teksten i textarea og kopier manuelt (Ctrl+C)

## Ofte stillede spørgsmål (FAQ)

### Kan der opstå en UUID-kollision?

Teoretisk set ja, men sandsynligheden er astronomisk lille. Ved generering af 1 milliard UUID'er v4 pr. sekund i 100 år er chancen for kollision ca. 0,00000006%. I praksis vil en kollision aldrig ske.

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

Det afhænger af brugssituationen. UUID er ideel til distribuerede systemer og situationer, hvor du har brug for global unikhed. For simple applikationer med en enkelt database kan auto-increment være mere effektivt.

### Er UUID'er genereret med dette værktøj sikre?

Ja, vi bruger Web Crypto API (\`crypto.getRandomValues()\`), som leverer kryptografisk sikre tilfældige værdier. Alt foregår lokalt i din browser.

### Hvad er forskellen mellem UUID-versionerne?

\- \*\*v1\*\*: Tidsstempel + MAC/tilfældig - kronologisk sortering, dårligere DB-ydeevne - \*\*v3/v5\*\*: Hash-baseret - deterministisk, til konvertering af kendte identifikatorer - \*\*v4\*\*: Tilfældig - sikreste, mest brugte - \*\*v6\*\*: Omarrangeret tidsstempel - bedre DB-ydeevne end v1 - \*\*v7\*\*: Unix-tidsstempel - bedste DB-ydeevne + tidsbaseret sortering

### Hvilken UUID-version skal jeg bruge?

I de fleste tilfælde skal du bruge \*\*v4\*\* (tilfældig). For databaser med tidsbaseret sortering skal du bruge \*\*v7\*\* (moderne) eller \*\*v6\*\* (standard). For konvertering af kendte identifikatorer (URL, DNS) skal du bruge \*\*v5\*\* (SHA-1).

### Kan jeg bruge UUID'er til tokens og API-nøgler?

UUID v4 er egnet til sessions-ID'er og lignende tokens. For API-nøgler skal du overveje at bruge længere tilfældige strenge (f.eks. 256-bit værdier) eller specialiserede biblioteker.

### Hvor store er UUID'er?

En UUID er 128 bit (16 bytes). I string-format med bindestreger fylder den 36 tegn. Uden bindestreger 32 hexadecimale tegn.

## Alternativer til UUID

### ULID (Universally Unique Lexicographically Sortable Identifier)

- 128-bit ID (ligesom UUID)
- Leksikografisk sorterbar efter oprettelsestidspunkt
- Mere kompakt repræsentation (26 tegn i stedet for 36)
- Case-insensitive base32-kodning

**Eksempel:** `01ARZ3NDEKTSV4RRFFQ69G5FAV`

### NanoID

- Mindre størrelse end UUID (21 tegn som standard)
- URL-venlig (uden specialtegn)
- Hurtigere generering
- Konfigurerbar længde og alfabet

**Eksempel:** `V1StGXR8_Z5jdHi6B-myT`

### Snowflake ID (Twitter)

- 64-bit ID (mindre end UUID)
- Tidsbaseret sorterbar
- Indeholder worker ID og sekvensnummer
- Kræver centraliseret konfiguration

**Eksempel:** `1234567890123456789`

## Ydeevne og optimering

### Genereringshastighed

Vores generator kan generere:

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

### Tips til ydeevne

1. **Batchgenerering** – Hvis du har brug for mange UUID’er, generer dem på én gang i stedet for én ad gangen
2. **DB-lagring** – Indekser UUID-kolonner for hurtig søgning
3. **Komprimering** – Gem UUID’er i binær form (16 bytes) i stedet for som en streng (36 bytes)
4. **Caching** – I nogle tilfælde kan du forgenerere og cache UUID’er

## Til udviklere

### Struktur af UUID v4

```
xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|        |    |    |    |
|        |    |    |    └─ 48 bits tilfældige data (node)
|        |    |    └────── 16 bits tilfældige data med variant (clock_seq)
|        |    └─────────── 12 bits tilfældige data + 4 bits version (time_hi_and_version)
|        └──────────────── 16 bits tilfældige data (time_mid)
└───────────────────────── 32 bits tilfældige data (time_low)
```

- Version (4 bits): altid `0100` (binært) = `4` (hex)
- Variant (2-3 bits): altid `10` (binært) for RFC 4122

### Test af UUID’er

```
// 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);
  });
});
```

## Sikkerhedsaspekter

### Hvad man ikke skal gøre med UUID’er

❌ **Brug ikke UUID v1 til følsomme applikationer** – Den indeholder et tidsstempel, hvilket kan udgøre en sikkerhedsrisiko

❌ **Brug ikke `Math.random()` til generering af UUID’er** – Det er ikke kryptografisk sikkert

❌ **Stol ikke på UUID’er til autorisation** – UUID’er kan gættes (selvom det er med en ekstremt lille sandsynlighed)

❌ **Gem ikke UUID’er i cookies uden kryptering** – Brug signed cookies eller JWT

### Hvad man skal gøre

✅ **Brug UUID v4 i de fleste tilfælde** – Højeste entropi og sikkerhed

✅ **Kombiner UUID’er med andre sikkerhedsforanstaltninger** – Brug HTTPS, HttpOnly-cookies og kort udløbstid til session management

✅ **Valider UUID’er på serveren** – Kontroller altid formatet og versionen af UUID’er

✅ **Brug kryptografisk sikre kilder til tilfældighed** – `crypto.getRandomValues()` i browseren, `/dev/urandom` på Linux

## Interesante fakta

- **Antal mulige UUID v4:** 2^122 ≈ 5.3 × 10^36 (340 undecillioner)
- **Nødvendig kollision:** For at have 50% chance for en kollision skal du generere 2.71 × 10^18 UUID’er (2.71 quintillioner)
- **Størrelse af alle mulige UUID’er:** Hvis vi gemte hver UUID som 16 bytes, ville hele pladsen fylde 85 zettabyte (85 milliarder terabytes)
- **Oprindelse:** UUID blev standardiseret som en del af 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))
- Suomi (fi): [UUID-generaattori](https://acrafto.com/fi/uuid-generaattori/) ([Markdown](https://acrafto.com/fi/uuid-generaattori/index.md))
- Norsk (no): [UUID-generator](https://acrafto.com/no/uuid-generator/) ([Markdown](https://acrafto.com/no/uuid-generator/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))