# GUID Generator - Full Documentation

> Complete developer reference, agentic browser automation guide, and programming language handbook for GUID Generator (https://guidgenerator.app).

---

## 1. Project Overview & Capabilities

GUID Generator is a client-first, high-performance web application designed to generate standard RFC 4122 / RFC 9562 Version 4 random GUIDs (Globally Unique Identifiers) / UUIDs (Universally Unique Identifiers).

### Key Features
- **Instant Client Generation**: Uses the browser's cryptographic pseudo-random number generator (`crypto.randomUUID()`) for zero-latency, cryptographically strong random IDs.
- **Bulk Generation**: Generates batches of 1 to 3,000 GUIDs in a single click.
- **11 Formatting Toggles**: Instant real-time transformation of uppercase, stripped hyphens, double/single quotes, parentheses, curly braces, square brackets, angle brackets, commas, semicolons, and JavaScript array notation.
- **Privacy Guaranteed**: Runs completely in-memory on the client. No database logs, no tracking cookies, no server-side retention of generated IDs.
- **Accessibility & Agent-Friendliness**: Built with semantic HTML, unique `id` attributes, standard ARIA labels, and responsive layout.

---

## 2. Agentic Browser Automation & DOM Reference

Autonomous agents (Playwright, Puppeteer, browser-use, OpenAI Operator, MultiOn, Claude Computer Use) navigating `https://guidgenerator.app` can interact with the DOM using the following selectors:

### Single GUID Generation Elements
- **Display Result**: `div#generatedGuid` (class `.guid-result.font-mono`)
  - Contains the active single GUID formatted according to enabled options.
  - Read via element text content.
- **New GUID Button**: `button.btn-primary` with `aria-label="Generate new GUID"`
  - Triggers generation of a brand-new GUID.
- **Copy GUID Button**: `button.btn-success` with `aria-label="Copy GUID to clipboard"`
  - Copies the text in `#generatedGuid` to the clipboard and triggers a toast notification.

### Formatting Options (Checkboxes)
All toggles react immediately on change:
- `input#opt-uppercase`: Hexadecimal characters rendered in uppercase (`A-F`).
- `input#opt-hyphens`: Strip hyphens (32-character hexadecimal string).
- `input#opt-double-quotes`: Surround with double quotes (`"..."`).
- `input#opt-single-quotes`: Surround with single quotes (`'...'`).
- `input#opt-parentheses`: Surround with parentheses (`(...)`).
- `input#opt-curly`: Surround with curly brackets (`{...}`).
- `input#opt-brackets`: Surround with square brackets (`[...]`).
- `input#opt-angles`: Surround with angle brackets (`<...>`).
- `input#opt-comma`: Append comma at the end (`,`).
- `input#opt-semicolon`: Append semicolon at the end (`;`).
- `input#opt-js-array`: Format multiple GUIDs as a JavaScript array (`['guid1', 'guid2']`).

### Bulk Generation Elements
- **Count Input**: `input#noOfGuids` (`type="text"`, `inputmode="numeric"`, `maxlength="4"`)
  - Valid range: 1 to 3000. Default: 5. Values > 3000 are clamped to 3000.
- **Bulk Output Area**: `textarea#generatedGuids` (`readonly`, `name="GeneratedGuids"`)
  - Contains all generated GUIDs, one per line (or formatted as a JS array).
- **Generate Bulk Button**: `button.btn-primary` with `aria-label="Generate multiple GUIDs"`
- **Copy Bulk Button**: `button.btn-success` with `aria-label="Copy all generated GUIDs to clipboard"`

### Theme Toggle
- **Toggle Button**: `button.theme-toggle-btn` (aria-label "Switch to light theme" or "Switch to dark theme").
- Stores value `'dark'` or `'light'` in `localStorage.getItem('theme')`.

---

## 3. Programming Language Implementation Guides

### C# / .NET

Canonical Page: `https://guidgenerator.app/how-to-generate-a-guid-in-csharp`

#### Generating a GUID in C#
```csharp
using System;

namespace GuidExample
{
    class Program
    {
        static void Main(string[] args)
        {
            Guid guid = Guid.NewGuid();
            Console.WriteLine("Your GUID is: " + guid.ToString());
        }
    }
}
```

#### Parsing / Converting String to GUID in C#
```csharp
using System;

namespace GuidExample
{
    class Program
    {
        static void Main(string[] args)
        {
            string guidAsString = "032c99b2-d17e-41f6-9259-1f70958dc106";
            Guid guid = new Guid(guidAsString);
            Console.WriteLine("Parsed GUID is: " + guid.ToString());
        }
    }
}
```

---

### Java

Canonical Page: `https://guidgenerator.app/how-to-generate-a-uuid-in-java`

#### Generating a UUID in Java
```java
import java.util.UUID;

public class GenerateUUID {
    public static void main(String[] args) {
        UUID uuid = UUID.randomUUID();
        System.out.println("Generated UUID: " + uuid.toString());
    }
}
```

#### Parsing / Converting String to UUID in Java
```java
import java.util.UUID;

public class ParseUUID {
    public static void main(String[] args) {
        String uuidString = "032c99b2-d17e-41f6-9259-1f70958dc106";
        UUID uuid = UUID.fromString(uuidString);
        System.out.println("Parsed UUID: " + uuid.toString());
    }
}
```

---

### Python

Canonical Page: `https://guidgenerator.app/how-to-generate-a-uuid-in-python`

#### Generating a UUID in Python
```python
import uuid

guid = uuid.uuid4()
print(guid)
```

#### Parsing / Converting String to UUID in Python
```python
import uuid

uuid_string = '449947c4-7106-45da-be62-d76c13d141b3'
uuid_object = uuid.UUID(uuid_string)
print(uuid_object)
```

---

### Go (Golang)

Canonical Page: `https://guidgenerator.app/how-to-generate-a-uuid-in-go`

#### Generating a UUID in Go
```go
package main

import (
    "fmt"
    "github.com/google/uuid"
)

func main() {
    id := uuid.New()
    fmt.Printf("Generated UUID: %s\n", id.String())
}
```

#### Parsing / Converting String to UUID in Go
```go
package main

import (
    "fmt"
    "github.com/google/uuid"
)

func main() {
    uuidStr := "032c99b2-d17e-41f6-9259-1f70958dc106"
    parsedUUID, err := uuid.Parse(uuidStr)
    if err != nil {
        fmt.Println("Error parsing UUID:", err)
        return
    }
    fmt.Println("Parsed UUID:", parsedUUID)
}
```

---

### JavaScript

Canonical Page: `https://guidgenerator.app/how-to-generate-a-guid-in-javascript`

#### Generating a GUID in Modern JavaScript (Browser & Node 19+)
```javascript
// Native modern standard:
const guid = crypto.randomUUID();
console.log("Your GUID is: " + guid);
```

#### Fallback RFC 4122 v4 Generator for Older Environments
```javascript
function generateUUID() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
    const r = Math.random() * 16 | 0;
    const v = c === 'x' ? r : (r & 0x3 | 0x8);
    return v.toString(16);
  });
}
console.log(generateUUID());
```

---

### TypeScript

Canonical Page: `https://guidgenerator.app/how-to-generate-a-uuid-in-typescript`

#### Generating and Strongly Typing a UUID in TypeScript
```typescript
type UUID = string & { readonly __brand: unique symbol };

function generateUUID(): UUID {
  return crypto.randomUUID() as UUID;
}

const id: UUID = generateUUID();
console.log(`Generated UUID: ${id}`);
```

---

### Ruby

Canonical Page: `https://guidgenerator.app/how-to-generate-a-uuid-in-ruby`

#### Generating a UUID in Ruby
```ruby
require 'securerandom'

uuid = SecureRandom.uuid
puts "Generated UUID: #{uuid}"
```

---

### PHP

Canonical Page: `https://guidgenerator.app/how-to-generate-a-uuid-in-php`

#### Generating a UUID in Modern PHP (Native)
```php
<?php
function generateUuidV4(): string {
    $data = random_bytes(16);
    $data[6] = chr(ord($data[6]) & 0x0f | 0x40); // set version to 0100
    $data[8] = chr(ord($data[8]) & 0x3f | 0x80); // set bits 6-7 to 10
    return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));
}

echo generateUuidV4();
?>
```

---

### Visual Basic .NET (VB.Net)

Canonical Page: `https://guidgenerator.app/how-to-generate-a-guid-in-vb-net`

#### Generating a GUID in VB.NET
```vb
Imports System

Module Program
    Sub Main()
        Dim g As Guid = Guid.NewGuid()
        Console.WriteLine("Your GUID is: " & g.ToString())
    End Sub
End Module
```

---

## 4. UUID Version 4 Specification & Mathematical Analysis

- **Specification**: Defined by RFC 4122 (superseded by RFC 9562 in 2024).
- **Structure**: 128-bit integer rendered as 32 hexadecimal digits in five groups separated by hyphens: `8-4-4-4-12`.
  - Format: `xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`
  - Position 13 contains the version digit `4` (`0100` in binary).
  - Position 17 contains the variant nibble `y` (`8`, `9`, `a`, or `b`, representing bits `10xx`).
- **Entropy**: 122 bits of cryptographically secure random data.
- **Uniqueness Probability**:
  - Total combinations: 2^122 ≈ 5.3169 × 10^36.
  - Generating 1 billion UUIDs per second for 85 consecutive years yields a 50% probability of a single collision.
  - A one-in-a-billion (10^-9) collision chance requires generating approximately 103 trillion UUIDs.

---

## 5. Endpoints & Operational Details

- Web Application: `https://guidgenerator.app/`
- Health Check: `https://guidgenerator.app/health` (Returns `{ status: "healthy", service: "guidgenerator", timestamp: "..." }`)
- Sitemap: `https://guidgenerator.app/sitemap.xml`
- Robots Instructions: `https://guidgenerator.app/robots.txt`
- Concise LLM Index: `https://guidgenerator.app/llms.txt`
- Full Reference: `https://guidgenerator.app/llms-full.txt`