# UUID-generator

> Generera UUID (universellt unika identifierare) online gratis. Vårt verktyg stöder alla UUID-versioner (v1, v3-v7) och kan generera tusentals UUID samtidigt.

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

## Vad är UUID?

UUID (Universally Unique Identifier) är en 128-bitars identifierare som används i datorsystem för att unikt identifiera information. UUID är standardiserat enligt RFC 4122 och garanterar, tack vare sin enorma entropi, en praktiskt taget noll sannolikhet för kollision – vilket innebär att två oberoende genererade UUID nästan säkert kommer att vara unika.

UUID har ett standardformat: `xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx`, där varje `x` är en hexadecimal siffra (0-9, a-f), `M` anger UUID-versionen och `N` anger varianten.

## UUID-versioner

### UUID v1 (Tidsstämpel + MAC-adress)

UUID v1 är baserat på en aktuell tidsstämpel och ett slumpmässigt värde (i webbläsaren istället för en MAC-adress). Det använder 100-nanosekundsintervaller sedan den 15 oktober 1582 (Gregorianska kalendern).

**Användningsområden:**

- Situationer där du behöver kronologisk sortering av UUID
- Felsökning och loggning (UUID innehåller information om skapandetid)
- Distribuerade system med tidssynkronisering

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

**Fördelar:**

- UUID kan sorteras kronologiskt efter skapandetid
- Användbart för revision och felsökning
- Innehåller tidsstämpelinformation

**Nackdelar:**

- Potentiell säkerhetsrisk – innehåller en tidsstämpel
- Innehåller inte en verklig MAC-adress i webbläsaren (ersatt med ett slumpmässigt värde)
- Dålig DB-lokalitet (tidsstämpeln är i de lägre bitarna)

### UUID v3 (MD5 hash)

UUID v3 genereras med hjälp av en MD5-hash av en namnrymd-UUID och ett namn. Deterministiskt – samma namnrymd + namn kommer alltid att skapa samma UUID.

**Användningsområden:**

- Konvertering av URL:er, DNS-namn eller andra identifierare till UUID
- Situationer där du behöver reproducerbara UUID
- Mappning mellan olika identifieringssystem

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

**Fördelar:**

- Deterministiskt (samma input = samma output)
- Idealisk för konvertering av kända identifierare
- Ingen kollision för olika inputs

**Nackdelar:**

- MD5 är en föråldrad algoritm (föredra v5)
- Kräver namnrymd och namn
- Det går inte att återställa den ursprungliga inputen

### UUID v4 (Slumpmässigt) - REKOMMENDERAS

Den mest använda UUID-versionen. UUID v4 genereras helt slumpmässigt med hjälp av en kryptografiskt säker slumptalsgenerator (`crypto.getRandomValues()`).

**Användningsområden:**

- Primärnycklar i databaser
- Sessionsidentifierare (session-ID:n)
- Unika filnamn
- API-token
- Allmänna ändamål där du behöver garanterat unika ID:n

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

**Fördelar:**

- Maximal entropi och säkerhet
- Inget beroende av tid eller systemparametrar
- Enklaste implementeringen

**Sannolikhet för kollision:** Vid generering av 1 miljard UUID per sekund i 100 år är chansen för kollision cirka 0,00000006%.

### UUID v5 (SHA-1 hash)

UUID v5 är detsamma som v3, men använder SHA-1 istället för MD5. Ett modernare och säkrare alternativ till v3.

**Användningsområden:**

- Samma som v3, men med bättre säkerhet
- Föredras framför v3 för nya projekt
- Generering av UUID från URL:er, DNS-namn, OID, X.500 DN

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

**Fördelar:**

- Deterministiskt
- SHA-1 är mer robust än MD5
- Lämplig för mappning mellan system

**Nackdelar:**

- SHA-1 anses också vara föråldrat (men fortfarande säkrare än MD5)
- Kräver namnrymd och namn

### UUID v6 (Sorterad tidsstämpel)

UUID v6 är en förbättrad version av v1 med omordnade tidsbitar för bättre DB-indexering. Designad för att lösa lokalitetsproblem i databaser.

**Användningsområden:**

- Primärnycklar i databaser med tidsbaserad sortering
- System som kräver kronologisk sortering och DB-prestanda
- Modernare alternativ till v1

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

**Fördelar:**

- Bättre DB-lokalitet än v1 (tidsstämpel i högre ordningsbitar)
- Kronologisk sortering
- Kompatibel med UUID-standarden

**Nackdelar:**

- Mindre använt än v1/v4
- Innehåller fortfarande tidsinformation (säkerhetsrisk)

### UUID v7 (Unix tidsstämpel)

UUID v7 använder Unix tidsstämpel (millisekunder sedan 1970) + slumpmässiga bitar. Den senaste UUID-versionen med bästa DB-lokalitet.

**Användningsområden:**

- Moderna primärnycklar i databaser
- System som kräver prestanda + tidsbaserad sortering
- Ersättning för v1/v6 i nya projekt

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

**Fördelar:**

- Bästa DB-lokalitet av alla versioner
- Unix tidsstämpel är standard
- Kombinerar fördelarna med slumpmässighet och tidsbaserad sortering

**Nackdelar:**

- Relativt ny specifikation (RFC 4122bis)
- Mindre stöd i äldre system

## Vilken UUID-version ska man använda?

### Beslutsguide

**Behöver du maximal säkerhet och slumpmässighet?** → Använd **UUID v4** (vanligaste valet)

**Behöver du tidsbaserad sortering och DB-prestanda?** → Använd **UUID v7** (modernt) eller **UUID v6** (standard)

**Behöver du reproducerbara UUID från befintliga identifierare?** → Använd **UUID v5** (SHA-1) eller **UUID v3** (MD5, äldre)

**Behöver du tidsstämpel och revisionsspår?** → Använd **UUID v1** (äldre, sämre DB-prestanda)

### Databaser

**För nya projekt:** UUID v7 eller v4

- **v7** är idealisk för tidsbaserad sortering + prestanda
- **v4** för maximal slumpmässighet utan tidsinformation

**För äldre system:** UUID v1 eller v6

- **v6** har bättre DB-lokalitet än v1
- **v1** stöds brett

**Fördelar med UUID som primärnyckel:**

- **Global unikhet** – Du kan koppla ihop data från olika databaser utan konflikt
- **Säkerhet** – Till skillnad från sekventiella ID:n (1, 2, 3…) kan nästa värden inte gissas
- **Distribuerade system** – UUID kan genereras oberoende på flera servrar utan samordning
- **Databasmärgen** – Vid sammanslagning av två databaser uppstår inga konflikter

**Nackdelar:**

- Större storlek (16 byte vs 4-8 byte för heltal)
- Långsammare indexering i vissa databaser (använd v6/v7 för bättre prestanda)
- Mindre läsbart för människor

### API:er och webbtjänster

- **REST API** – Unika identifierare för resurser
- **GraphQL** – Globala identifierare för noder
- **Webhooks** – Spårning av förfrågningar och svar
- **Token** – Sessions-ID:n, refresh-token

### Filer och lagring

- **Filnamn** – Förhindrar kollisioner vid uppladdning
- **S3/Molnlagring** – Unika sökvägar till objekt
- **Cache-nycklar** – Identifierare i cache-system

### Frontend-applikationer

- **React/Vue-komponenter** – Unika nycklar för listor
- **Temporära ID:n** – ID före lagring i databasen
- **Lokal lagring** – Nycklar för sparade data
- **Offline-first applikationer** – Genererar ID utan serveranslutning

## Avancerade generatorfunktioner

### Generera UUID med anpassad tid

För tidsbaserade versioner (v1, v6, v7) kan du välja vilken tidsstämpel som helst med hjälp av datum- och tidsväljaren. Detta är användbart för:

**Testning:**

- Simulering av UUID skapade i det förflutna
- Testning av tidsbaserad sortering i databaser
- Reproducering av UUID för felsökning

**Datamigrering:**

- Generering av UUID med historiska tidsstämplar
- Efterfyllning av data med korrekta tidsstämpelvärden
- Import av data från olika tidsperioder

**Revision och efterlevnad:**

- Rekonstruktion av UUID baserat på tidpunkten för postens skapande
- Retroaktiv generering av identifierare

**Exempel på användning:**

1. Välj version v1, v6 eller v7
2. Ställ in datum och tid med hjälp av datum- och tidsväljaren
3. Generera UUID med din egen tidsstämpel

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

För deterministiska UUID kan du använda versionerna v3 (MD5) eller v5 (SHA-1):

**Hur man använder:**

1. Välj namnrymd efter typen av din identifierare
2. Ange namn/värde
3. Generera UUID

**Exempel:**

| Namnrymd | Namn (input) | Användning |
| --- | --- | --- |
| DNS | `example.com` | Konvertera domännamn till UUID |
| DNS | `google.com` | Varje webbplats har ett unikt UUID |
| URL | `https://example.com/page` | Konvertera URL till UUID |
| URL | `https://api.example.com/users/123` | API-slutpunkt som UUID |
| OID | `1.3.6.1.4.1.343` | Objektsidentifierare till UUID |
| X.500 | `CN=John Doe,O=Company` | Distinguished Name till UUID |

**Viktiga egenskaper:**

- ✅ **Deterministiskt**: Samma input = alltid samma UUID
- ✅ **Reproducerbart**: Du kan återskapa UUID när som helst
- ✅ **Konsekvent**: Samma UUID över olika system
- ❌ **Kan inte avkodas**: Den ursprungliga namnet kan inte hämtas från UUID
- ℹ️ **Ett UUID**: För v3/v5 genereras alltid bara ett UUID (samma input = samma output)

**Praktisk användning:**

```
// Exempel: Konvertera URL till UUID v5
Namnrymd: URL
Namn: https://example.com/api/users/123
Resultat: 886313e1-3b8a-5372-9b90-0c9aee199e5d

// Samma input = alltid samma UUID
Namnrymd: DNS
Namn: google.com
Resultat: alltid samma UUID för google.com
```

## Hur man använder UUID säkert?

### Kryptografisk säkerhet

Vår generator använder `crypto.getRandomValues()`, vilket är en kryptografiskt säker slumptalsgenerator. Till skillnad från `Math.random()`, som är förutsägbar och olämplig för säkerhetsändamål, ger `crypto.getRandomValues()` verklig entropi lämplig för:

- Generering av säkerhetstoken
- Sessions-ID:n
- API-nycklar
- Kryptografiska applikationer

### Jämförelse av UUID-versioner

| Version | Bas | Kollision | Tidsbaserad sortering | DB-prestanda | Användning |
| --- | --- | --- | --- | --- | --- |
| v1 | Tidsstämpel + MAC | Låg | ✅ Ja | ❌ Sämre | Äldre, revision |
| v3 | MD5 hash | Ingen (deterministisk) | ❌ Nej | ⚠️ Medel | Konverteringar (äldre) |
| v4 | Slumpmässigt | Extremt låg | ❌ Nej | ⚠️ Medel | Allmän användning |
| v5 | SHA-1 hash | Ingen (deterministisk) | ❌ Nej | ⚠️ Medel | Konverteringar (rekommenderas) |
| v6 | Sorterad tidsstämpel | Låg | ✅ Ja | ✅ Bättre | Moderna DB med tid |
| v7 | Unix tidsstämpel | Låg | ✅ Ja | ✅ Bäst | Nya projekt |

### UUID vs andra identifierare

| Typ | Storlek | Kollision | Tidsbaserad sortering | Användning |
| --- | --- | --- | --- | --- |
| Auto-increment ID | 4-8 byte | Garanterat unikt inom tabellen | ❌ | Enkla applikationer, lokal DB |
| UUID v4 | 16 byte | Praktiskt taget omöjlig | ❌ | Distribuerade system, API |
| UUID v7 | 16 byte | Praktiskt taget omöjlig | ✅ | Moderna DB med prestanda |
| ULID | 16 byte | Praktiskt taget omöjlig | ✅ | UUID + lexikografisk sortering |
| Snowflake ID | 8 byte | Garanterat unikt med korrekt konfiguration | ✅ | Twitter, distribuerade system |
| NanoID | Konfigurerbar | Beror på längd | ❌ | URL-vänliga ID:n |

## Implementering i olika språk

### JavaScript/TypeScript

```
// UUID v4 - Enklaste sättet (moderna webbläsare)
const uuid = crypto.randomUUID();

// UUID v4 - Manuell 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 - Rekommenderas för 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();
```

## Bästa praxis

### Lagring av UUID i databasen

**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 lagra UUID som `BINARY(16)` istället för `CHAR(36)` för att spara utrymme och snabbare indexering.

### 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

```
// Ta bort bindestreck
const compact = uuid.replace(/-/g, '');

// Lägg till bindestreck 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('-');
}
```

## Felsökning (Troubleshooting)

### UUID v3/v5 fungerar inte

**Problem:** Efter att ha valt v3 eller v5 genereras inget

**Lösning:**

1. ✅ Kontrollera att du har **fyllt i fältet “Namn”** - det är obligatoriskt!
2. ✅ Välj rätt namnrymd enligt typen av din input
3. ✅ Exempel på giltiga inputs:
   - DNS: `example.com`, `google.com`
   - URL: `https://example.com/page`
   - Valfri text: `min-applikation-v1`

**Tips:** Försök först med ett enkelt värde som `test` och namnrymden DNS.

### Tidsbaserat UUID (v1, v6, v7) har en konstig tid

**Problem:** Det genererade UUID:t har en oväntad tidsstämpel

**Lösning:**

1. ✅ Kontrollera datum- och tidsväljaren - är rätt tid inställd?
2. ✅ Datum- och tidsväljaren använder din lokala tidszon
3. ✅ Lämna datum- och tidsväljaren tom för aktuell tid

### UUID kan inte kopieras

**Problem:** Knappen “Kopiera alla” fungerar inte

**Lösning:**

1. ✅ Kontrollera att du har genererat UUID:n (att de inte är tomma)
2. ✅ Vissa webbläsare kräver HTTPS för clipboard API
3. ✅ Alternativt, markera texten i textrutan och kopiera manuellt (Ctrl+C)

## Vanliga frågor (FAQ)

### Kan en UUID-kollision inträffa?

Teoretiskt ja, men sannolikheten är astronomiskt liten. Vid generering av 1 miljard UUID v4 per sekund i 100 år är chansen för kollision cirka 0,00000006%. I praktiken inträffar en kollision aldrig.

### Är UUID lämpligt som primärnyckel i en databas?

Det beror på användningsfallet. UUID är idealiskt för distribuerade system och situationer där du behöver global unikhet. För enkla applikationer med en databas kan auto-increment vara effektivare.

### Är UUID som genereras av detta verktyg säkra?

Ja, vi använder Web Crypto API (\`crypto.getRandomValues()\`), som tillhandahåller kryptografiskt säkra slumpmässiga värden. Allt sker lokalt i din webbläsare.

### Vad är skillnaden mellan UUID-versioner?

\- \*\*v1\*\*: Tidsstämpel + MAC/slumpmässigt - kronologisk sortering, sämre DB-prestanda - \*\*v3/v5\*\*: Hash-baserat - deterministiskt, för konvertering av kända identifierare - \*\*v4\*\*: Slumpmässigt - säkrast, mest använt - \*\*v6\*\*: Omordnad tidsstämpel - bättre DB-prestanda än v1 - \*\*v7\*\*: Unix tidsstämpel - bästa DB-prestanda + tidsbaserad sortering

### Vilken UUID-version ska jag använda?

För de flesta fall, använd \*\*v4\*\* (slumpmässigt). För databaser med tidsbaserad sortering, använd \*\*v7\*\* (modernt) eller \*\*v6\*\* (standard). För konvertering av kända identifierare (URL, DNS), använd \*\*v5\*\* (SHA-1).

### Kan jag använda UUID för token och API-nycklar?

UUID v4 är lämpligt för sessions-ID:n och liknande token. För API-nycklar, överväg att använda längre slumpmässiga strängar (t.ex. 256-bitars värden) eller specialiserade bibliotek.

### Hur stora är UUID?

Ett UUID är 128 bitar (16 byte). I strängformat med bindestreck tar det upp 36 tecken. Utan bindestreck, 32 hexadecimala tecken.

## Alternativ till UUID

### ULID (Universally Unique Lexicographically Sortable Identifier)

- 128-bitars ID (samma som UUID)
- Lexikografiskt sorterbart efter skapandetid
- Mer kompakt representation (26 tecken istället för 36)
- Case-insensitive base32 encoding

**Exempel:** `01ARZ3NDEKTSV4RRFFQ69G5FAV`

### NanoID

- Mindre storlek än UUID (21 tecken som standard)
- URL-vänligt (inga specialtecken)
- Snabbare generering
- Konfigurerbar längd och alfabet

**Exempel:** `V1StGXR8_Z5jdHi6B-myT`

### Snowflake ID (Twitter)

- 64-bitars ID (mindre än UUID)
- Tidsbaserat sorterbart
- Innehåller worker ID och sekvensnummer
- Kräver centraliserad konfiguration

**Exempel:** `1234567890123456789`

## Prestanda och optimering

### Genereringshastighet

Vår generator kan generera:

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

### Prestandatips

1. **Batchgenerering** – Om du behöver många UUID, generera dem samtidigt istället för en i taget
2. **Lagring i DB** – Indexera UUID-kolumner för snabb sökning
3. **Komprimering** – Lagra UUID i binärt format (16 byte) istället för sträng (36 byte)
4. **Cachelagring** – I vissa fall kan du förgenerera och cachelagra UUID

## För utvecklare

### Struktur för UUID v4

```
xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|        |    |    |    |
|        |    |    |    └─ 48 bitar slumpmässig data (nod)
|        |    |    └────── 16 bitar slumpmässig data med variant (clock_seq)
|        |    └─────────── 12 bitar slumpmässig data + 4 bitar version (time_hi_and_version)
|        └──────────────── 16 bitar slumpmässig data (time_mid)
└───────────────────────── 32 bitar slumpmässig data (time_low)
```

- Version (4 bitar): alltid `0100` (binärt) = `4` (hex)
- Variant (2-3 bitar): alltid `10` (binärt) för RFC 4122

### Testning av UUID

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

## Säkerhetsaspekter

### Vad man inte ska göra med UUID

❌ **Använd inte UUID v1 för känsliga applikationer** – Det innehåller en tidsstämpel, vilket kan vara en säkerhetsrisk

❌ **Använd inte `Math.random()` för att generera UUID** – Det är inte kryptografiskt säkert

❌ **Förlita dig inte på UUID för auktorisering** – UUID kan gissas (även om sannolikheten är extremt liten)

❌ **Lagra inte UUID i cookies utan kryptering** – Använd signerade cookies eller JWT

### Vad man ska göra

✅ **Använd UUID v4 för de flesta fall** – Högsta entropi och säkerhet

✅ **Kombinera UUID med andra säkerhetsåtgärder** – För sessionshantering, använd HTTPS, HttpOnly-cookies och kort utgångstid

✅ **Validera UUID på servern** – Kontrollera alltid format och version av UUID

✅ **Använd kryptografiskt säkra slumpmässighetskällor** – `crypto.getRandomValues()` i webbläsaren, `/dev/urandom` på Linux

## Intressanta fakta

- **Antal möjliga UUID v4:** 2^122 ≈ 5.3 × 10^36 (340 undecillioner)
- **Nödvändig kollision:** För en 50% chans att kollidera måste du generera 2.71 × 10^18 UUID (2.71 kvintillioner)
- **Storlek på alla möjliga UUID:** Om vi lagrade varje UUID som 16 byte, skulle hela utrymmet uppta 85 zettabyte (85 miljarder terabyte)
- **Ursprung:** UUID standardiserades som en del av DCE (Distributed Computing Environment) 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))
- 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))
- 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))