# ComfyUI

Knotenbasierte Oberfläche für Stable Diffusion mit maximaler Flexibilität auf CLORE.AI-GPUs.

{% 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       | 16GB         | 32GB+     |
| VRAM      | 8 GB (SDXL)  | 12GB+     |
| Netzwerk  | 500Mbps      | 1Gbps+    |
| Startzeit | 5–10 Minuten | -         |

{% hint style="warning" %}
**Startzeit:** Beim ersten Start werden Abhängigkeiten und Modelle heruntergeladen (5–10 Minuten je nach Netzwerkgeschwindigkeit). HTTP 502 in dieser Zeit ist normal.
{% endhint %}

{% hint style="danger" %}
**Wichtig:** ComfyUI mit FLUX-Modellen benötigt 16 GB+ VRAM. Für SDXL mit ControlNet sollten mindestens 10 GB VRAM vorhanden sein.
{% endhint %}

## Warum ComfyUI?

* **Knotenbasierter Workflow** - Visuelle Programmierung zur Bildgenerierung
* **Maximale Kontrolle** - Feinabstimmung jedes Schrittes der Pipeline
* **Effizient** - Niedrigerer VRAM-Verbrauch als Alternativen
* **Erweiterbar** - Großes Ökosystem an benutzerdefinierten Knoten
* **Workflow-Sharing** - Import/Export als JSON

## Schnelle Bereitstellung auf CLORE.AI

**Docker-Image:**

```
yanwk/comfyui-boot:cu126-slim
```

**Ports:**

```
22/tcp
8188/http
```

**Umgebung:**

```
CLI_ARGS=--listen 0.0.0.0
```

### Überprüfen, ob es funktioniert

Nach der Bereitstellung finden Sie Ihre `http_pub` URL in **Meine Bestellungen**:

```bash
# Prüfen, ob die UI erreichbar ist (kann beim ersten Start 5–10 Min dauern)
curl https://your-http-pub.clorecloud.net/
```

{% hint style="info" %}
Wenn Sie länger als 15 Minuten HTTP 502 erhalten, prüfen Sie:

1. Server hat 16GB+ RAM
2. Server hat 8 GB+ VRAM für SDXL, 16 GB+ für FLUX
3. Netzwerkgeschwindigkeit ist ausreichend zum Herunterladen von Modellen
   {% endhint %}

## Zugriff auf Ihren Dienst

Wenn auf CLORE.AI bereitgestellt, greifen Sie auf ComfyUI über die `http_pub` URL:

* **Weboberfläche:** `https://your-http-pub.clorecloud.net/`
* **API:** `https://your-http-pub.clorecloud.net/prompt`
* **WebSocket:** `wss://your-http-pub.clorecloud.net/ws`

{% hint style="info" %}
Alle `localhost:8188` Die untenstehenden Beispiele funktionieren, wenn über SSH verbunden. Für externen Zugriff ersetzen Sie durch Ihre `https://your-http-pub.clorecloud.net/` URL.
{% endhint %}

## Installation

### Verwendung von Docker (empfohlen)

```bash
docker run -d --gpus all \
  -p 8188:8188 \
  -v comfyui-data:/root \
  -e CLI_ARGS="--listen 0.0.0.0" \
  yanwk/comfyui-boot:cu126-slim
```

### Manuelle Installation

```bash
# Repository klonen
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

# Virtuelle Umgebung erstellen
python -m venv venv
source venv/bin/activate

# PyTorch mit CUDA installieren
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124

# Anforderungen installieren
pip install -r requirements.txt

# Ausführen
python main.py --listen 0.0.0.0
```

## Verzeichnisstruktur

```
ComfyUI/
├── models/
│   ├── checkpoints/     # SD-Modelle (.safetensors)
│   ├── loras/           # LoRA-Modelle
│   ├── vae/             # VAE-Modelle
│   ├── controlnet/      # ControlNet-Modelle
│   ├── upscale_models/  # Upscaler
│   └── clip/            # CLIP-Modelle
├── input/               # Eingabebilder
├── output/              # Generierte Bilder
└── custom_nodes/        # Erweiterungen
```

## Modelle herunterladen

### Stable Diffusion Checkpoints

```bash
cd ComfyUI/models/checkpoints

# SDXL Basis
wget https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors

# SDXL Refiner
wget https://huggingface.co/stabilityai/stable-diffusion-xl-refiner-1.0/resolve/main/sd_xl_refiner_1.0.safetensors

# SD 1.5 (kleiner, schneller)
wget https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned.safetensors

# Realistic Vision (fotorealistisch)
wget https://huggingface.co/SG161222/Realistic_Vision_V6.0_B1_noVAE/resolve/main/Realistic_Vision_V6.0_B1_fp16.safetensors
```

### VAE

```bash
cd ComfyUI/models/vae

# SDXL VAE
wget https://huggingface.co/stabilityai/sdxl-vae/resolve/main/sdxl_vae.safetensors

# SD 1.5 VAE (bessere Farben)
wget https://huggingface.co/stabilityai/sd-vae-ft-mse-original/resolve/main/vae-ft-mse-840000-ema-pruned.safetensors
```

### LoRAs

```bash
cd ComfyUI/models/loras

# Herunterladen von CivitAI oder HuggingFace
# Legen Sie .safetensors-Dateien hier ab
```

## Grundlegender Workflow

### Text zu Bild

1. Knoten hinzufügen:
   * **Checkpoint laden** → Modell auswählen
   * **CLIP Text Encode** (x2) → positive & negative Prompts
   * **Leeres latentes Bild** → Abmessungen einstellen
   * **KSampler** → alles verbinden
   * **VAE-Decodierung** → latent zu Bild
   * **Bild speichern** → Ausgabe
2. Verbinden:

```
[Checkpoint] → MODEL → [KSampler]
[Checkpoint] → CLIP → [CLIP Text Encode +]
[Checkpoint] → CLIP → [CLIP Text Encode -]
[Checkpoint] → VAE → [VAE Decode]
[Text Encode +] → CONDITIONING → [KSampler]
[Text Encode -] → CONDITIONING → [KSampler]
[Empty Latent] → LATENT → [KSampler]
[KSampler] → LATENT → [VAE Decode]
[VAE Decode] → IMAGE → [Save Image]
```

### Bild zu Bild

Ersetzen **Leeres latentes Bild** mit:

1. **Bild laden** → Ihr Quellbild
2. **VAE-Enkodierung** → in Latent umwandeln
3. Anpassen **entrauschen** im KSampler (0.5–0.8)

## ComfyUI Manager

ComfyUI Manager ist eine **essentielle Erweiterung** die eine GUI zum Installieren, Aktualisieren und Verwalten benutzerdefinierter Knoten hinzufügt. Es ist der Standardweg, ComfyUI zu erweitern.

### Installation

```bash
cd ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git
# ComfyUI neu starten — ein "Manager"-Button erscheint in der Werkzeugleiste
```

### Verwendung von ComfyUI Manager

Nach dem Neustart erscheint ein **Manager** Button oben rechts in der ComfyUI-Oberfläche.

**Hauptfunktionen:**

| Funktion                               | Wie zuzugreifen ist                    |
| -------------------------------------- | -------------------------------------- |
| Benutzerdefinierte Knoten installieren | Manager → Install Custom Nodes         |
| Alle Knoten aktualisieren              | Manager → Update All                   |
| Knoten deaktivieren/aktivieren         | Manager → Custom Nodes Manager         |
| Fehlende Knoten installieren           | Manager → Install Missing Custom Nodes |
| Modellinformationen abrufen            | Manager → Model Manager                |
| Snapshot wiederherstellen              | Manager → Snapshot Manager             |

**Workflow: Installation eines neuen Node-Pakets**

1. Klicken **Manager** Schaltfläche
2. Auswählen **Install Custom Nodes**
3. Nach Name suchen (z. B. "FLUX", "AnimateDiff")
4. Klicken **Installieren** auf dem gewünschten Paket
5. Klicken **Neustarten** wenn dazu aufgefordert
6. Neue Knoten erscheinen im Rechtsklick-Hinzufügen-Menü

**Fehlende Knoten automatisch installieren:** Wenn Sie ein Workflow-JSON importieren, das Knoten verwendet, die Sie nicht haben, erkennt Manager diese und bietet an, sie automatisch zu installieren via **Install Missing Custom Nodes**.

### Knoten aktuell halten

```bash
# Von der CLI (Alternative zur GUI):
cd ComfyUI/custom_nodes/ComfyUI-Manager
git pull

# Oder verwenden Sie Manager → Update All in der UI
```

***

## FLUX-Workflow in ComfyUI

FLUX verwendet eine andere Knotenstruktur als Standard-SD-Modelle. Unten ist ein vollständiger FLUX.1-dev-Workflow.

### Erforderliche Dateien

Laden Sie vor dem Ausführen des Workflows herunter:

```bash
# FLUX-Modell (dev oder schnell)
cd ComfyUI/models/unet
wget https://huggingface.co/black-forest-labs/FLUX.1-dev/resolve/main/flux1-dev.safetensors

# Text-Encoder
cd ../clip
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/clip_l.safetensors
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/t5xxl_fp16.safetensors

# VAE
cd ../vae
wget https://huggingface.co/black-forest-labs/FLUX.1-dev/resolve/main/ae.safetensors
```

### FLUX.1-dev Workflow JSON

Speichern als `flux_dev_workflow.json` und importieren via **Laden** Button in ComfyUI:

```json
{
  "last_node_id": 12,
  "last_link_id": 20,
  "nodes": [
    {
      "id": 1,
      "type": "UNETLoader",
      "pos": [100, 100],
      "size": [300, 60],
      "inputs": [],
      "outputs": [{"name": "MODEL", "type": "MODEL", "links": [1]}],
      "properties": {},
      "widgets_values": ["flux1-dev.safetensors", "default"]
    },
    {
      "id": 2,
      "type": "DualCLIPLoader",
      "pos": [100, 200],
      "size": [350, 80],
      "inputs": [],
      "outputs": [{"name": "CLIP", "type": "CLIP", "links": [2, 3]}],
      "properties": {},
      "widgets_values": ["clip_l.safetensors", "t5xxl_fp16.safetensors", "flux"]
    },
    {
      "id": 3,
      "type": "CLIPTextEncode",
      "pos": [500, 150],
      "size": [425, 180],
      "inputs": [{"name": "clip", "type": "CLIP", "link": 2}],
      "outputs": [{"name": "CONDITIONING", "type": "CONDITIONING", "links": [4]}],
      "properties": {},
      "widgets_values": ["A stunning photorealistic landscape, golden hour lighting, 8K"]
    },
    {
      "id": 4,
      "type": "EmptySD3LatentImage",
      "pos": [100, 350],
      "size": [300, 100],
      "inputs": [],
      "outputs": [{"name": "LATENT", "type": "LATENT", "links": [5]}],
      "properties": {},
      "widgets_values": [1024, 1024, 1]
    },
    {
      "id": 5,
      "type": "ModelSamplingFlux",
      "pos": [500, 350],
      "size": [300, 80],
      "inputs": [{"name": "model", "type": "MODEL", "link": 1}],
      "outputs": [{"name": "MODEL", "type": "MODEL", "links": [6]}],
      "properties": {},
      "widgets_values": [1.15, 0.5, 1024, 1024]
    },
    {
      "id": 6,
      "type": "KSampler",
      "pos": [850, 250],
      "size": [350, 240],
      "inputs": [
        {"name": "model", "type": "MODEL", "link": 6},
        {"name": "positive", "type": "CONDITIONING", "link": 4},
        {"name": "negative", "type": "CONDITIONING", "link": 7},
        {"name": "latent_image", "type": "LATENT", "link": 5}
      ],
      "outputs": [{"name": "LATENT", "type": "LATENT", "links": [8]}],
      "properties": {},
      "widgets_values": [42, "fixed", 20, 3.5, "euler", "simple", 1.0]
    },
    {
      "id": 7,
      "type": "CLIPTextEncode",
      "pos": [500, 500],
      "size": [300, 60],
      "inputs": [{"name": "clip", "type": "CLIP", "link": 3}],
      "outputs": [{"name": "CONDITIONING", "type": "CONDITIONING", "links": [7]}],
      "properties": {},
      "widgets_values": [""]
    },
    {
      "id": 8,
      "type": "VAELoader",
      "pos": [100, 500],
      "size": [300, 60],
      "inputs": [],
      "outputs": [{"name": "VAE", "type": "VAE", "links": [9]}],
      "properties": {},
      "widgets_values": ["ae.safetensors"]
    },
    {
      "id": 9,
      "type": "VAEDecode",
      "pos": [1250, 300],
      "size": [210, 46],
      "inputs": [
        {"name": "samples", "type": "LATENT", "link": 8},
        {"name": "vae", "type": "VAE", "link": 9}
      ],
      "outputs": [{"name": "IMAGE", "type": "IMAGE", "links": [10]}],
      "properties": {}
    },
    {
      "id": 10,
      "type": "SaveImage",
      "pos": [1500, 300],
      "size": [300, 270],
      "inputs": [{"name": "images", "type": "IMAGE", "link": 10}],
      "outputs": [],
      "properties": {},
      "widgets_values": ["flux_output"]
    }
  ],
  "links": [
    [1, 1, 0, 5, 0, "MODEL"],
    [2, 2, 0, 3, 0, "CLIP"],
    [3, 2, 0, 7, 0, "CLIP"],
    [4, 3, 0, 6, 1, "CONDITIONING"],
    [5, 4, 0, 6, 3, "LATENT"],
    [6, 5, 0, 6, 0, "MODEL"],
    [7, 7, 0, 6, 2, "CONDITIONING"],
    [8, 6, 0, 9, 0, "LATENT"],
    [9, 8, 0, 9, 1, "VAE"],
    [10, 9, 0, 10, 0, "IMAGE"]
  ],
  "groups": [],
  "config": {},
  "extra": {"ds": {"scale": 0.8, "offset": [0, 0]}},
  "version": 0.4
}
```

### FLUX.1-schnell Workflow (4 Schritte)

Für schnell ändern Sie die KSampler-Einstellungen im obigen JSON:

* `num_inference_steps`: `4`
* `cfg`: `1.0`
* `scheduler`: `"simple"`
* Modell-Datei: `flux1-schnell.safetensors`

Oder per UI einstellen: KSampler → steps: **4**, cfg: **1.0**, sampler: **euler**, scheduler: **simple**

### Wesentliche Knotenunterschiede: FLUX vs SD

| Knoten           | SD/SDXL              | FLUX                            |
| ---------------- | -------------------- | ------------------------------- |
| Modell-Loader    | Checkpoint laden     | UNETLoader                      |
| Text-Encoder     | CLIPTextEncode       | DualCLIPLoader + CLIPTextEncode |
| Latent           | Leeres latentes Bild | EmptySD3LatentImage             |
| Extra            | —                    | ModelSamplingFlux               |
| Negativer Prompt | Erforderlich         | Optional (leer lassen)          |

***

## Wesentliche benutzerdefinierte Knoten

### Empfohlene Node-Pakete

| Node-Paket               | GitHub                                  | Einsatzgebiet                                |
| ------------------------ | --------------------------------------- | -------------------------------------------- |
| **ComfyUI-Manager**      | ltdrdata/ComfyUI-Manager                | Alle anderen Knoten installieren & verwalten |
| **ComfyUI-FLUX**         | XLabs-AI/x-flux-comfyui                 | FLUX ControlNet-Knoten                       |
| **was-node-suite**       | WASasquatch/was-node-suite-comfyui      | 100+ Hilfsknoten                             |
| ComfyUI-Impact-Pack      | ltdrdata/ComfyUI-Impact-Pack            | Gesichtserkennung, SAM, ADetailer            |
| ComfyUI-Inspire-Pack     | ltdrdata/ComfyUI-Inspire-Pack           | Erweiterte Sampler, Workflows                |
| ComfyUI-AnimateDiff      | Kosinkadink/ComfyUI-AnimateDiff-Evolved | Video-/Animationsgenerierung                 |
| ComfyUI-VideoHelperSuite | Kosinkadink/ComfyUI-VideoHelperSuite    | Video I/O-Verarbeitung                       |
| ComfyUI-GGUF             | city96/ComfyUI-GGUF                     | Quantisierte GGUF-Modelle ausführen          |
| ComfyUI-KJNodes          | kijai/ComfyUI-KJNodes                   | Hilfs- & Maskenknoten                        |
| rgthree-comfy            | rgthree/rgthree-comfy                   | Workflow-Hilfen, bessere UI                  |

### ComfyUI-FLUX (XLabs-AI)

Fügt ControlNet-Unterstützung für FLUX innerhalb von ComfyUI hinzu:

```bash
cd ComfyUI/custom_nodes
git clone https://github.com/XLabs-AI/x-flux-comfyui
cd x-flux-comfyui
pip install -r requirements.txt
```

Fügt Knoten hinzu: `Apply ControlNet (FLUX)`, `Load ControlNet Model (FLUX)`, `XFlux Sampler`

### was-node-suite

Über 100 Hilfsknoten für fortgeschrittene Workflows:

```bash
cd ComfyUI/custom_nodes
git clone https://github.com/WASasquatch/was-node-suite-comfyui
cd was-node-suite-comfyui
pip install -r requirements.txt
```

Wichtige Knoten: Image Batch, Text Operations, Image Analyze, Cache Node, Bus Node, Upscale, Mask-Operationen

### Über Manager installieren

1. Klicken **Manager** Schaltfläche
2. **Install Custom Nodes**
3. Suchen und installieren
4. ComfyUI neu starten

## Erweiterte Workflows

### ControlNet

```bash
# ControlNet-Modelle herunterladen
cd ComfyUI/models/controlnet

# Canny
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_canny.pth

# Depth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11f1p_sd15_depth.pth

# OpenPose
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_openpose.pth
```

Workflow:

1. Bild laden → Canny-Kantendetektor
2. Apply ControlNet → KSampler
3. Mit Pose-/Kantenführung generieren

### Upscaling

```bash
# Upscaler herunterladen
cd ComfyUI/models/upscale_models
wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth
```

Workflow:

1. Bild in niedrigerer Auflösung erzeugen (768x768)
2. Upscale Image (Model)-Knoten
3. Optional: img2img-Pass für Details

### SDXL + Refiner

1. Mit SDXL-Basis erzeugen (Schritte 1–20)
2. Latent an SDXL-Refiner weitergeben (Schritte 21–30)
3. Finales Ergebnis mit VAE decodieren

## Tastaturkürzel

| Taste              | Aktion                                |
| ------------------ | ------------------------------------- |
| `Strg+Enter`       | Prompt in die Warteschlange           |
| `Strg+Shift+Enter` | Prompt vorrangig in die Warteschlange |
| `Strg+Z`           | Rückgängig                            |
| `Strg+Y`           | Wiederholen                           |
| `Strg+S`           | Workflow speichern                    |
| `Strg+O`           | Workflow laden                        |
| `Strg+A`           | Alles auswählen                       |
| `Entfernen`        | Auswahl löschen                       |
| `Strg+M`           | Knoten stummschalten                  |
| `Strg+B`           | Knoten umgehen                        |

## API-Nutzung

### Prompt in die Warteschlange

```python
import json
import urllib.request

# Für externen Zugriff verwenden Sie Ihre http_pub-URL:
SERVER = "your-http-pub.clorecloud.net"
# Oder via SSH: SERVER = "localhost:8188"

def queue_prompt(prompt, server=SERVER):
    data = json.dumps({"prompt": prompt}).encode('utf-8')
    req = urllib.request.Request(f"https://{server}/prompt", data=data)
    urllib.request.urlopen(req)

# Workflow-JSON laden und in die Warteschlange stellen
with open("workflow.json") as f:
    workflow = json.load(f)
queue_prompt(workflow)
```

### WebSocket für Fortschritt

```python
import websocket
import json

# Für externen Zugriff verwenden Sie wss:// mit Ihrer http_pub-URL
ws = websocket.WebSocket()
ws.connect(f"wss://{SERVER}/ws")

while True:
    msg = json.loads(ws.recv())
    if msg['type'] == 'progress':
        print(f"Step {msg['data']['value']}/{msg['data']['max']}")
    elif msg['type'] == 'executed':
        print("Fertig!")
        break
```

## Performance-Tipps

1. **--lowvram aktivieren** für <8 GB VRAM
2. **Verwenden Sie fp16** Modelle wenn möglich
3. **Batch-Größe 1** für begrenzten VRAM
4. **Gekacheltes VAE** für hochauflösende Bilder
5. **Vorschau deaktivieren** für schnellere Generierung

## GPU-Anforderungen

| Modell            | Minimaler VRAM | Empfohlener VRAM | Min. RAM |
| ----------------- | -------------- | ---------------- | -------- |
| SD 1.5            | 4GB            | 8GB              | 16GB     |
| SDXL              | 8GB            | 12GB             | 16GB     |
| SDXL + ControlNet | 10GB           | 16GB             | 16GB     |
| FLUX              | 16GB           | 24GB             | 32GB     |

## GPU-Voreinstellungen

### RTX 3060 12GB (Budget)

```bash
# Start mit Optimierungen
python main.py --lowvram --force-fp16

# Empfohlene Einstellungen:
# - SDXL: 768x768, Batch 1
# - SD 1.5: 512x512, Batch 4
# - VAE-Tiling verwenden
# - 20–30 Schritte
```

**Am besten geeignet für:** SD 1.5, SDXL (mit Einschränkungen)

### RTX 3090 24GB (Optimal)

```bash
# Standardstart
python main.py --force-fp16

# Empfohlene Einstellungen:
# - SDXL: 1024x1024, Batch 2
# - FLUX schnell: 1024x1024, Batch 1
# - ControlNet + SDXL funktioniert gut
# - 30–50 Schritte
```

**Am besten geeignet für:** SDXL, ControlNet-Workflows, moderates FLUX

### RTX 4090 24GB (Performance)

```bash
# Volle Geschwindigkeit starten
python main.py

# Empfohlene Einstellungen:
# - SDXL: 1024x1024, Batch 4
# - FLUX dev: 1024x1024, Batch 1-2
# - Komplexe Workflows mit mehreren ControlNets
# - 50+ Schritte für Qualität
```

**Am besten geeignet für:** FLUX, komplexe Workflows, Batch-Generierung

### A100 40GB/80GB (Produktion)

```bash
# Maximale Leistung
python main.py --highvram

# Empfohlene Einstellungen:
# - SDXL: 1024x1024, Batch 8+
# - FLUX: 1024x1024, Batch 2-4
# - Mehrere Modelle gleichzeitig geladen
# - Hochauflösende Ausgaben (2048x2048)
```

**Am besten geeignet für:** Produktions-Workloads, FLUX, hochauflösende Generierung

## Kostenabschätzung

Typische CLORE.AI-Marktplatzpreise:

| GPU      | VRAM | Preis/Tag  | SDXL Geschwindigkeit |
| -------- | ---- | ---------- | -------------------- |
| RTX 3060 | 12GB | $0.15–0.30 | \~15 Sek./Bild       |
| RTX 3090 | 24GB | $0.30–1.00 | \~8 Sek./Bild        |
| RTX 4090 | 24GB | $0.50–2.00 | \~4 Sek./Bild        |
| A100     | 40GB | $1.50–3.00 | \~3 Sek./Bild        |

*Preise in USD/Tag. Die Tarife variieren je nach Anbieter — prüfen Sie* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *auf aktuelle Preise.*

## Fehlerbehebung

### HTTP 502 über lange Zeit

1. **Prüfe RAM:** Server muss 16GB+ RAM haben
2. **Prüfe VRAM:** 8GB+ für SDXL, 16GB+ für FLUX
3. **Abhängigkeiten herunterladen:** Erster Lauf dauert 5–10 Min.
4. **Modell-Download:** Große Modelle dauern länger

### Kein Speicher mehr

```bash
# Mit Low-VRAM-Modus ausführen
python main.py --lowvram

# Oder fp16 erzwingen
python main.py --force-fp16
```

### Schwarze Bilder

* Überprüfe, dass VAE geladen ist
* Probiere verschiedene VAE aus
* Bildgröße reduzieren

### Langsame Generierung

* CUDA aktivieren
* fp16-Modelle verwenden
* Schritte reduzieren (20–30 sind oft ausreichend)

## Workflow-Beispiele

Importiere diese JSON-Workflows in ComfyUI:

* [Einfaches txt2img](https://comfyworkflows.com)
* [SDXL + Refiner](https://comfyworkflows.com)
* [ControlNet Canny](https://comfyworkflows.com)
* [AnimateDiff Video](https://comfyworkflows.com)

## Nächste Schritte

* [ControlNet Anleitung](https://docs.clore.ai/guides/guides_v2-de/bildverarbeitung/controlnet-advanced)
* [Real-ESRGAN-Upscaling](https://docs.clore.ai/guides/guides_v2-de/bildverarbeitung/real-esrgan-upscaling)
* [Kohya Training](https://docs.clore.ai/guides/guides_v2-de/training/kohya-training) - Eigene LoRAs trainieren
* [Fooocus](https://docs.clore.ai/guides/guides_v2-de/bildgenerierung/fooocus-simple-sd) - Einfachere Alternative