# FLUX.2 Klein

FLUX.2 Klein von Black Forest Labs ist der Nachfolger von FLUX.1 und liefert dieselbe Bildqualität bei **20–60× der Geschwindigkeit**. Während FLUX.1 10–30 Sekunden pro Bild benötigte, erzeugt FLUX.2 Klein in **unter 0,5 Sekunden** auf einer RTX 4090. Es ist ein 32B Diffusion Transformer (DiT)-Modell mit Apache-2.0-Lizenz, und seit Januar 2026 wird es sogar experimentell in Ollama unterstützt.

## Hauptmerkmale

* **< 0,5 Sekunden Generierung**: 20–60× schneller als FLUX.1
* **32B DiT-Architektur**: Dieselbe Qualität wie FLUX.1 dev
* **Apache-2.0-Lizenz**: Volle kommerzielle Nutzung
* **Ollama-Unterstützung**: Experimentelle Bildgenerierung über Ollama (Jan 2026)
* **ComfyUI-kompatibel**: Drop-in-Ersatz für FLUX.1-Workflows
* **LoRA + ControlNet**: Community-Adapter verfügbar

## Anforderungen

| Komponente | Minimum               | Empfohlen     |
| ---------- | --------------------- | ------------- |
| GPU        | RTX 3090 24GB         | RTX 4090 24GB |
| VRAM       | 16GB (mit Offloading) | 24GB          |
| RAM        | 32GB                  | 64GB          |
| Festplatte | 40GB                  | 60GB          |
| CUDA       | 12.0+                 | 12.1+         |

**Empfohlene Clore.ai-GPU**: RTX 4090 24GB (\~0,5–2 $/Tag) — Sub-Sekunden-Generierung

### Geschwindigkeitsvergleich: FLUX.1 vs FLUX.2 Klein

| GPU      | FLUX.1 dev (20 Schritte) | FLUX.2 Klein | Beschleunigung |
| -------- | ------------------------ | ------------ | -------------- |
| RTX 3090 | \~25 Sek.                | \~1,2 Sek.   | 20×            |
| RTX 4090 | \~12 Sek.                | \~0,4 Sek.   | 30×            |
| RTX 5090 | \~8 Sek.                 | \~0,25 Sek.  | 32×            |
| H100     | \~5 Sek.                 | \~0,15 Sek.  | 33×            |

## Schnellstart mit diffusers

```python
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.2-klein",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")

# Bild in < 0,5 Sekunden erzeugen!
image = pipe(
    prompt="ein Cyberpunk-GPU-Mining-Rig in einem neonbeleuchteten Serverraum, fotorealistisch",
    height=1024,
    width=1024,
    num_inference_steps=4,  # Klein benötigt nur 4 Schritte!
    guidance_scale=3.5,
).images[0]

image.save("output.png")
```

### Speichereffizienter Modus (16GB GPUs)

```python
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.2-klein",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()  # Passt auf 16GB
pipe.vae.enable_tiling()         # Spart ~2GB

image = pipe("eine Berglandschaft bei Sonnenuntergang", num_inference_steps=4).images[0]
```

## ComfyUI-Workflow

FLUX.2 Klein funktioniert als Drop-in-Ersatz in bestehenden FLUX.1 ComfyUI-Workflows:

1. Lade den FLUX.2 Klein Checkpoint herunter nach `ComfyUI/models/diffusion_models/`
2. Ändere in deinem Workflow den Checkpoint-Knoten, damit er auf FLUX.2 Klein zeigt
3. Reduziere die Schritte auf 4 (statt 20–50 für FLUX.1)
4. Setze die Guidance-Skala auf 3.0–4.0

```bash
# Modell für ComfyUI herunterladen
cd ComfyUI/models/diffusion_models/
wget https://huggingface.co/black-forest-labs/FLUX.2-klein/resolve/main/flux2-klein.safetensors
```

## Batch-Erzeugung

Mit Sub-Sekunden-Generierung ermöglicht FLUX.2 Klein umfangreiche Batch-Verarbeitung:

```python
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.2-klein", torch_dtype=torch.bfloat16
).to("cuda")

prompts = [
    "ein roter Sportwagen auf einer Bergstraße, filmisch",
    "ein gemütliches Café-Innere, warme Beleuchtung",
    "ein Astronaut, der über der Erde schwebt, hyperrealistisch",
    "eine mittelalterliche Burg im Herbst, Fantasy-Kunst",
    # ... füge Hunderte mehr hinzu
]

for i, prompt in enumerate(prompts):
    image = pipe(prompt, num_inference_steps=4, guidance_scale=3.5).images[0]
    image.save(f"batch_{i:04d}.png")
    print(f"Erzeugt {i+1}/{len(prompts)}")

# Auf RTX 4090: ~100 Bilder in unter 1 Minute!
```

## LoRA-Unterstützung

```python
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.2-klein", torch_dtype=torch.bfloat16
).to("cuda")

# Lade eine auf FLUX-Architektur trainierte LoRA
pipe.load_lora_weights("your-lora/flux2-style-lora", weight_name="lora.safetensors")
pipe.fuse_lora(lora_scale=0.8)

image = pipe("ein Porträt im trainierten Stil", num_inference_steps=4).images[0]
```

## Tipps für Clore.ai-Nutzer

* **Batch-Verarbeitungs-König**: Bei 0,4 Sek./Bild kannst du auf der RTX 4090 über 10.000 Bilder pro Stunde erzeugen
* **Nur 4 Schritte**: Verwende nicht mehr — Klein ist für 4 Schritte optimiert (mehr verbessert die Qualität nicht)
* **Gleiche LoRAs wie für FLUX.1**: Die meisten FLUX.1 LoRAs sind mit Klein kompatibel
* **ComfyUI Drop-in**: Einfach den Checkpoint austauschen, Schritte auf 4 setzen
* **RTX 3090 ist brauchbar**: 1,2 Sek./Bild ist immer noch großartig bei 0,3 $/Tag

## Fehlerbehebung

| Problem                    | Lösung                                                                                    |
| -------------------------- | ----------------------------------------------------------------------------------------- |
| OOM auf 24GB               | Verwenden Sie `enable_model_cpu_offload()` + `vae.enable_tiling()`                        |
| Verschwommene Bilder       | Stelle sicher, dass `num_inference_steps=4`, nicht weniger. Prüfe guidance\_scale 3.0–4.0 |
| Langsame erste Generierung | Normal — Modell lädt beim ersten Aufruf (\~30s). Danach: Sub-Sekunden                     |
| ComfyUI Checkpoint-Fehler  | Stelle sicher, dass du die `.safetensors` Datei hast, nicht das diffusers-Format          |

## Weiterführende Lektüre

* [FLUX.1 Anleitung](https://docs.clore.ai/guides/guides_v2-de/bildgenerierung/flux) — originale FLUX-Anleitung mit LoRA- und ControlNet-Details
* [ComfyUI Anleitung](https://docs.clore.ai/guides/guides_v2-de/bildgenerierung/comfyui) — ComfyUI-Einrichtung und Workflows
* [Black Forest Labs Blog](https://blackforestlabs.ai/)
* [HuggingFace Modell](https://huggingface.co/black-forest-labs/FLUX.2-klein)