> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/bildgenerierung/sd-webui-forge.md).

# SD WebUI Forge

SD WebUI Forge ist ein optimierter Fork der klassischen AUTOMATIC1111 Stable Diffusion WebUI, entwickelt vom lllyasviel-Team. Es bietet deutlich besseres VRAM-Management (ermöglicht SDXL auf 4-GB-GPUs), native FLUX-Modellunterstützung, schnellere Generierungsgeschwindigkeiten und volle Abwärtskompatibilität mit allen A1111-Erweiterungen und -Modellen. CLORE.AI's flexibler GPU-Marktplatz lässt dich die perfekte GPU für Forge wählen — von budgetfreundlichen Karten bis hin zu Spitzenmodellen wie A100.

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Serveranforderungen

| Parameter  | Minimum              | Empfohlen          |
| ---------- | -------------------- | ------------------ |
| RAM        | 8 GB                 | 16 GB+             |
| VRAM       | 4 GB                 | 12 GB+             |
| Festplatte | 30 GB                | 200 GB+            |
| GPU        | NVIDIA GTX 1650 4GB+ | RTX 3090, RTX 4090 |

{% hint style="info" %}
Der Hauptvorteil von Forge ist sein VRAM-Optimizer: Er kann SDXL bereits mit nur 4 GB VRAM ausführen (bei langsamerer Geschwindigkeit). Für FLUX-Modelle sind 12 GB VRAM praktisch das Minimum, für volle Qualität und Geschwindigkeit 24 GB.
{% endhint %}

## Schnelle Bereitstellung auf CLORE.AI

**Docker-Image:** `nykk3/stable-diffusion-webui-forge:latest`

**Ports:** `22/tcp`, `7860/http`

**Umgebungsvariablen:**

| Variable           | Beispiel               | Beschreibung                  |
| ------------------ | ---------------------- | ----------------------------- |
| `CLI_ARGS`         | `--xformers --medvram` | Zusätzliche CLI-Argumente     |
| `COMMANDLINE_ARGS` | `--api --listen`       | Alternative CLI-Args-Umgebung |

## Schritt-für-Schritt-Einrichtung

### 1. Mieten Sie einen GPU-Server auf CLORE.AI

Gehe zu [CLORE.AI Marketplace](https://clore.ai/marketplace):

* **Budget SD1.5**: GTX 1660/2060 (6 GB) — ausreichend für 512/768px
* **SDXL-fähig**: RTX 3080/3090 (10–24 GB)
* **FLUX-fähig**: RTX 4090/A6000 (24+ GB)
* **Maximale Qualität**: A100 80GB für Batch-Generierung

### 2. SSH auf Ihren Server

```bash
ssh -p <PORT> root@<SERVER_IP>
```

### 3. Erstelle Speicherverzeichnisse

```bash
mkdir -p /root/sd-forge/{models,outputs,extensions,configs}
mkdir -p /root/sd-forge/models/{Stable-diffusion,VAE,Lora,ControlNet,embeddings,ESRGAN}
```

### 4. Ziehe und starte SD WebUI Forge

**Standardstart:**

```bash
docker run -d \
  --name sd-forge \
  --gpus all \
  -p 7860:7860 \
  -v /root/sd-forge/models:/app/stable-diffusion-webui/models \
  -v /root/sd-forge/outputs:/app/stable-diffusion-webui/outputs \
  -v /root/sd-forge/extensions:/app/stable-diffusion-webui/extensions \
  nykk3/stable-diffusion-webui-forge:latest
```

**Mit aktivierter API und zusätzlichen Performance-Flags:**

```bash
docker run -d \
  --name sd-forge \
  --gpus all \
  -p 7860:7860 \
  -v /root/sd-forge/models:/app/stable-diffusion-webui/models \
  -v /root/sd-forge/outputs:/app/stable-diffusion-webui/outputs \
  -v /root/sd-forge/extensions:/app/stable-diffusion-webui/extensions \
  -e CLI_ARGS="--api --xformers --enable-insecure-extension-access" \
  nykk3/stable-diffusion-webui-forge:latest
```

**Low-VRAM-Modus (4–6 GB GPUs):**

```bash
docker run -d \
  --name sd-forge \
  --gpus all \
  -p 7860:7860 \
  -v /root/sd-forge/models:/app/stable-diffusion-webui/models \
  -v /root/sd-forge/outputs:/app/stable-diffusion-webui/outputs \
  -e CLI_ARGS="--api --medvram-sdxl --opt-sdp-attention" \
  nykk3/stable-diffusion-webui-forge:latest
```

**Maximale Leistung (24+ GB VRAM):**

```bash
docker run -d \
  --name sd-forge \
  --gpus all \
  -p 7860:7860 \
  -v /root/sd-forge/models:/app/stable-diffusion-webui/models \
  -v /root/sd-forge/outputs:/app/stable-diffusion-webui/outputs \
  -e CLI_ARGS="--api --xformers --no-half-vae" \
  nykk3/stable-diffusion-webui-forge:latest
```

### 5. Starte Überwachung

```bash
docker logs -f sd-forge
```

Achten Sie auf:

```
Running on local URL:  http://0.0.0.0:7860
```

Der Start dauert beim ersten Mal typischerweise 2–5 Minuten.

### 6. Auf die Weboberfläche zugreifen

Ihre CLORE.AI http\_pub-URL für Port 7860:

```
https://<order-id>-7860.clore.ai/
```

### 7. Modelle hinzufügen

**Methode 1: In der Web-UI über CivitAI herunterladen**

* Gehe zu **Extensions → Installed → Models** (einige Versionen)
* Oder benutze den URL-Downloader in den Einstellungen

**Methode 2: Direkt auf dem Server herunterladen**

```bash
# SDXL-Basismodell herunterladen
cd /root/sd-forge/models/Stable-diffusion
wget -O "sd_xl_base_1.0.safetensors" \
  "https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors"

# FLUX.1-schnell herunterladen (schnelles FLUX-Modell)
wget -O "flux1-schnell.safetensors" \
  "https://huggingface.co/black-forest-labs/FLUX.1-schnell/resolve/main/flux1-schnell.safetensors"
```

**Methode 3: HuggingFace CLI**

```bash
docker exec -it sd-forge bash -c "
pip install huggingface_hub
huggingface-cli download stabilityai/stable-diffusion-xl-base-1.0 \
  sd_xl_base_1.0.safetensors \
  --local-dir /app/stable-diffusion-webui/models/Stable-diffusion/
"
```

***

## Beispielanwendungen

### Beispiel 1: Text-zu-Bild über die Web-UI

1. Öffne die Forge-UI an deiner CLORE.AI-URL
2. Wähle dein Modell aus dem **Checkpoint** Dropdown
3. Gib Prompt ein: `"cinematic portrait of a warrior, golden hour, 8k photography"`
4. Setzen Sie den negativen Prompt: `"blurry, low resolution, watermark, ugly"`
5. Setze Breite/Höhe: `1024x1024` für SDXL, `512x768` für SD1.5
6. Setze Schritte: 20–30, CFG: 7
7. Klicken Sie **Generieren**

### Beispiel 2: FLUX-Generierung

FLUX-Modelle funktionieren anders — kein negativer Prompt, höhere Qualität:

1. Wähle FLUX-Checkpoint (flux1-dev.safetensors)
2. Unter **Forge**, wähle entsprechendes **Unet** und **VAE** falls separate Dateien
3. Gib Prompt ein (kein negativer Prompt nötig):

   ```
   Eine atemberaubende Landschaft bei Sonnenuntergang, Berge, die sich in einem makellosen See spiegeln,
   fotorealistisch, ultra-detailreich, professionelle Fotografie
   ```
4. Schritte: 20, CFG: 1.0 (FLUX verwendet niedrigere CFG)
5. Sampler: `Euler` oder `DPM++ 2M`

### Beispiel 3: ControlNet-geführte Generierung

1. Installiere die ControlNet-Erweiterung (falls nicht vorinstalliert):
   * Gehe zu **Extensions → Available → Load from**
   * Suche nach „ControlNet“ und installiere es
2. Lade ControlNet-Modelle nach `/root/sd-forge/models/ControlNet/`
3. Erweitere in txt2img **ControlNet** Abschnitt
4. Lade Referenzbild hoch (Pose, Tiefe, Canny-Kanten)
5. Wähle Preprocessor und Modell passend zum Referenztyp
6. Generieren — Ausgabe folgt der Referenzstruktur

### Beispiel 4: API-Nutzung

Mit `--api` Flag gibt Forge eine REST-API frei:

```python
import requests
import base64
import io
from PIL import Image

BASE_URL = "http://localhost:7860"  # oder CLORE.AI http_pub-URL

# Text zu Bild
payload = {
    "prompt": "a serene Japanese garden with cherry blossoms, watercolor style",
    "negative_prompt": "ugly, blurry, low quality",
    "steps": 25,
    "cfg_scale": 7,
    "width": 1024,
    "height": 1024,
    "sampler_name": "DPM++ 2M",
    "batch_size": 1,
}

response = requests.post(f"{BASE_URL}/sdapi/v1/txt2img", json=payload)
result = response.json()

# Speichere das Bild
for i, img_b64 in enumerate(result["images"]):
    img_data = base64.b64decode(img_b64)
    img = Image.open(io.BytesIO(img_data))
    img.save(f"output_{i}.png")
    print(f"Saved output_{i}.png")
```

### Beispiel 5: Batch-Generierungsskript

```python
import requests
import base64
import io
from PIL import Image
import os

BASE_URL = "http://localhost:7860"

prompts = [
    ("cyberpunk city at night, neon lights, rain", "cyberpunk"),
    ("ancient forest, mystical fog, fantasy art", "fantasy"),
    ("minimalist logo design, geometric shapes, white background", "logo"),
    ("portrait of an elderly sailor, weathered face, oil painting", "portrait"),
]

os.makedirs("batch_output", exist_ok=True)

for prompt_text, filename in prompts:
    print(f"Generating: {filename}...")
    response = requests.post(
        f"{BASE_URL}/sdapi/v1/txt2img",
        json={
            "prompt": prompt_text,
            "negative_prompt": "low quality, blurry, watermark",
            "steps": 25,
            "cfg_scale": 7,
            "width": 1024,
            "height": 1024,
        },
    )
    
    if response.status_code == 200:
        img_b64 = response.json()["images"][0]
        img = Image.open(io.BytesIO(base64.b64decode(img_b64)))
        img.save(f"batch_output/{filename}.png")
        print(f"  Saved batch_output/{filename}.png")
    else:
        print(f"  Error: {response.status_code}")
```

***

## Konfiguration

### Wichtige CLI-Argumente

| Argument                             | Beschreibung                                                  |
| ------------------------------------ | ------------------------------------------------------------- |
| `--api`                              | REST-API aktivieren                                           |
| `--listen`                           | Auf allen Schnittstellen lauschen (erforderlich für CLORE.AI) |
| `--port 7860`                        | Port ändern                                                   |
| `--xformers`                         | xFormers-Attention aktivieren (schneller, weniger VRAM)       |
| `--medvram`                          | Medium-VRAM-Modus (SD1.5 auf 6 GB)                            |
| `--medvram-sdxl`                     | Medium-VRAM für SDXL (SDXL auf 8 GB)                          |
| `--lowvram`                          | Low-VRAM-Modus (sehr langsam, jede GPU)                       |
| `--no-half`                          | Nutze float32 (mehr VRAM, stabiler)                           |
| `--no-half-vae`                      | VAE in float32 belassen (verhindert schwarze Bilder)          |
| `--opt-sdp-attention`                | PyTorch scaled dot product attention                          |
| `--enable-insecure-extension-access` | Erlaube Installation von Erweiterungen                        |
| `--skip-version-check`               | Python/torch Versionschecks überspringen                      |

### Forge-spezifische Einstellungen

Forge fügt ein **Forge** Panel in der UI hinzu mit:

* **Forge Unet**: Auswahl des Optimierungs-Backends (default, bnb, etc.)
* **Diffusers Torch-Kompilierung**: Aktivieren für 20–30% schnellere Generierung (erster Lauf kompiliert)
* **GPU-Gewichte**: Wie viel auf der GPU gegenüber der CPU gehalten wird

***

## Leistungs-Tipps

### 1. Verwende xFormers für 20–30% weniger VRAM

```bash
--xformers
```

Verbessert automatisch die Leistung auf den meisten GPUs.

### 2. Forges VRAM-Optimizer

Forge verwaltet VRAM automatisch besser als A1111. Verwende einfach das `--medvram-sdxl` Flag für SDXL auf 8–12 GB GPUs und lass es den Rest handhaben.

### 3. Torch-Kompilierung aktivieren (Ampere+)

Aktiviere im Forge-Reiter in der UI **Diffusers Torch-Kompilierung**. Die erste Generierung benötigt 2–3 Minuten zum Kompilieren, danach sind die folgenden 20–30% schneller.

### 4. Optimale Schritte/Sampler-Kombinationen

| Ziel            | Sampler            | Schritte | CFG |
| --------------- | ------------------ | -------- | --- |
| Geschwindigkeit | `DPM++ SDE Karras` | 15-20    | 7   |
| Qualität        | `DPM++ 2M Karras`  | 25-35    | 7   |
| Künstlerisch    | `Euler a`          | 20-30    | 5-7 |
| FLUX            | `Euler`            | 20       | 1   |

### 5. Verwende Tile VAE für 2K+ Auflösungen

Für ultra-hohe Auflösungen (2048×2048+) aktiviere **Tiled VAE** im SD-Reiter, um VAE-OOM-Fehler zu vermeiden.

### 6. Lokal mit der API batchen

Anstatt einzeln in der UI zu generieren, nutze die API mit `batch_size` für höheren Durchsatz:

```python
payload = {
    "prompt": "...",
    "batch_size": 4,  # Erzeuge 4 Bilder auf einmal
    "n_iter": 2,      # Führe 2 Iterationen aus = insgesamt 8 Bilder
}
```

***

## Fehlerbehebung

### Problem: Schwarze oder grüne Bilder

VAE-Präzisionsproblem. Füge Flag hinzu:

```bash
--no-half-vae
```

Oder benutze das `sdxl-vae-fp16-fix.safetensors` VAE.

### Problem: "CUDA out of memory"

Versuche der Reihe nach:

1. `--medvram-sdxl` (für SDXL)
2. `--medvram` (für SD1.5)
3. Reduziere die Bildauflösung
4. `--lowvram` (letzte Option, sehr langsam)

### Problem: Erweiterungen werden nicht geladen

```bash
# Erlaube Erweiterungszugriff
-e CLI_ARGS="--enable-insecure-extension-access"
```

Dann aus dem Extensions-Tab in der UI installieren.

### Problem: Start dauert zu lange

Normal beim ersten Start — PyTorch und Modell-Hashes werden berechnet. Nachfolgende Starts sind schneller.

```bash
docker logs -f sd-forge  # Fortschritt beobachten
```

### Problem: Kann nicht aus dem Browser auf die UI zugreifen

Stelle sicher, dass der Forge-Prozess an `0.0.0.0`:

* Fügen Sie `--listen` an CLI\_ARGS bindet
* Überprüfe, ob Port 7860 in deiner CLORE.AI-Bestellungsliste von Ports vorhanden ist

### Problem: Modell wird nicht im Dropdown angezeigt

Nachdem du `.safetensors` Dateien in den richtigen Ordner gelegt hast, klicke **🔄 Aktualisieren** neben dem Checkpoint-Dropdown.

***

## Links

* [GitHub (Forge)](https://github.com/lllyasviel/stable-diffusion-webui-forge)
* [GitHub (A1111 Basis)](https://github.com/AUTOMATIC1111/stable-diffusion-webui)
* [Docker Hub (nykk3)](https://hub.docker.com/r/nykk3/stable-diffusion-webui-forge)
* [CivitAI (Modelle)](https://civitai.com)
* [FLUX-Modelle](https://huggingface.co/black-forest-labs)
* [CLORE.AI Marketplace](https://clore.ai/marketplace)

***

## Clore.ai GPU-Empfehlungen

| Anwendungsfall    | Empfohlene GPU  | Geschätzte Kosten auf Clore.ai |
| ----------------- | --------------- | ------------------------------ |
| Entwicklung/Tests | RTX 3090 (24GB) | \~$0.12/gpu/hr                 |
| Produktion        | RTX 4090 (24GB) | \~$0.70/gpu/hr                 |
| Großmaßstab       | A100 80GB       | \~$1.20/gpu/hr                 |

> 💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf [Clore.ai](https://clore.ai/marketplace) GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/bildgenerierung/sd-webui-forge.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.