# 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](/guides/guides_v2-de/bildgenerierung/flux.md) — originale FLUX-Anleitung mit LoRA- und ControlNet-Details
* [ComfyUI Anleitung](/guides/guides_v2-de/bildgenerierung/comfyui.md) — ComfyUI-Einrichtung und Workflows
* [Black Forest Labs Blog](https://blackforestlabs.ai/)
* [HuggingFace Modell](https://huggingface.co/black-forest-labs/FLUX.2-klein)


---

# Agent Instructions: 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/flux2-klein.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.