FLUX.2 Klein

FLUX.2 Klein — Bildgenerierung in unter einer Sekunde auf Clore.ai-GPUs

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

Hauptfunktionen

• unter 0,5 Sekunden Generierungszeit: 20–60× schneller als FLUX.1

• 32B DiT-Architektur: Gleichbleibende Qualität wie FLUX.1 dev

• Apache-2.0-Lizenz: Vollständige kommerzielle Nutzung

• Ollama-Unterstützung: Experimentelle Bildgenerierung über Ollama (Jan. 2026)

• Kompatibel mit ComfyUI: Direkter Ersatz für FLUX.1-Workflows

• LoRA + ControlNet: Community-Adapter verfügbar

Anforderungen

Komponente	Minimum	Empfohlen
GPU	RTX 3090 24 GB	RTX 4090 24GB
VRAM	16 GB (mit Auslagerung)	24 GB
RAM	32 GB	64 GB
Festplatte	40 GB	60 GB
CUDA	12.8+	12.8+

Empfohlene Clore.ai-GPU: RTX 4090 24 GB ($0,14–0,42/Stunde) — Generierung unter einer Sekunde

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

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 generieren!
image = pipe(
    prompt="ein Cyberpunk-GPU-Mining-Rig in einem neonbeleuchteten Serverraum, fotorealistisch",
    height=1024,
    width=1024,
    num_inference_steps=4,  # Klein braucht nur 4 Schritte!
    guidance_scale=3.5,
).images[0]

image.save("output.png")

Speichereffizienter Modus (16-GB-GPUs)

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

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

ComfyUI-Workflow

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

1. Lade den FLUX.2-Klein-Checkpoint nach ComfyUI/models/diffusion_models/

2. Ändere in deinem Workflow den Checkpoint-Knoten so, dass er auf FLUX.2 Klein verweist

3. Reduziere die Schritte auf 4 (statt 20–50 bei FLUX.1)

4. Setze die Guidance-Scale auf 3,0–4,0

# 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-Generierung

Mit Generierung unter einer Sekunde ermöglicht FLUX.2 Klein massive Batch-Verarbeitung:

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é-Interieur, warmes Licht",
    "ein Astronaut schwebt über der Erde, hyperrealistisch",
    "eine mittelalterliche Burg im Herbst, Fantasy-Kunst",
    # ... füge Hunderte weitere 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"Generiert {i+1}/{len(prompts)}")

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

LoRA-Unterstützung

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

# Eine auf der FLUX-Architektur trainierte LoRA laden
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

• König der Stapelverarbeitung: Bei 0,4 Sek./Bild kannst du auf einer RTX 4090 über 10.000 Bilder pro Stunde generieren

• Nur 4 Schritte: Nicht mehr verwenden — Klein ist für 4 Schritte optimiert (mehr verbessert die Qualität nicht)

• Dieselben LoRAs wie FLUX.1: Die meisten FLUX.1-LoRAs sind mit Klein kompatibel

• ComfyUI direkt einsetzbar: Einfach den Checkpoint austauschen, Schritte auf 4 ändern

• RTX 3090 ist brauchbar: 1,2 Sek./Bild sind bei 0,07–0,21 $/Std. immer noch großartig

Fehlerbehebung

Problem	Lösung
OOM auf 24 GB	Verwende enable_model_cpu_offload() + vae.enable_tiling()
Unscharfe Bilder	Stelle sicher num_inference_steps=4, nicht weniger. Prüfe guidance_scale 3,0–4,0
Langsame erste Generierung	Normal — das Modell wird beim ersten Aufruf geladen (~30 s). Danach: unter einer Sekunde
ComfyUI-Checkpoint-Fehler	Stelle sicher, dass du die .safetensors Datei hast, nicht das diffusers-Format

Weiterführende Lektüre

• FLUX.1-Leitfaden — ursprünglicher FLUX-Leitfaden mit Details zu LoRA und ControlNet

• ComfyUI-Leitfaden — ComfyUI-Einrichtung und Workflows

• Black Forest Labs Blog

• HuggingFace-Modell