> 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-es/generacion-de-imagenes/flux2-klein.md).

# FLUX.2 Klein

FLUX.2 Klein: generación de imágenes en menos de un segundo en GPUs de Clore.ai

FLUX.2 Klein de Black Forest Labs es el sucesor de FLUX.1, ofreciendo la misma calidad de imagen a **20–60× la velocidad**. Donde FLUX.1 tardaba 10–30 segundos por imagen, FLUX.2 Klein genera en **menos de 0,5 segundos** en una RTX 4090. Es un modelo Transformer de Difusión (DiT) de 32B con licencia Apache 2.0 y, a enero de 2026, incluso cuenta con soporte experimental en Ollama.

## Características clave

* **< 0,5 segundos de generación**: 20–60× más rápido que FLUX.1
* **arquitectura DiT de 32B**: La misma calidad que FLUX.1 dev
* **Licencia Apache 2.0**: Uso comercial completo
* **Compatibilidad con Ollama**: Generación experimental de imágenes vía Ollama (ene 2026)
* **Compatible con ComfyUI**: Sustituto directo para flujos de trabajo FLUX.1
* **LoRA + ControlNet**: Adaptadores de la comunidad disponibles

## Requisitos

| Componente | Mínimo                      | Recomendado   |
| ---------- | --------------------------- | ------------- |
| GPU        | RTX 3090 24GB               | RTX 4090 24GB |
| VRAM       | 16 GB (con descarga al CPU) | 24GB          |
| RAM        | 32GB                        | 64GB          |
| Disco      | 40 GB                       | 60 GB         |
| CUDA       | 12.8+                       | 12.8+         |

**GPU recomendada de Clore.ai**: RTX 4090 de 24 GB ($0,14–0,42/h) — generación en menos de un segundo

### Comparación de velocidad: FLUX.1 vs FLUX.2 Klein

| GPU      | FLUX.1 dev (20 pasos) | FLUX.2 Klein | Aceleración |
| -------- | --------------------- | ------------ | ----------- |
| RTX 3090 | \~25 s                | \~1,2 s      | 20×         |
| RTX 4090 | \~12 s                | \~0,4 s      | 30×         |
| RTX 5090 | \~8 s                 | \~0,25 s     | 32×         |
| H100     | \~5 seg               | \~0,15 s     | 33×         |

## Inicio rápido con 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")

# ¡Genera imágenes en < 0,5 segundos!
image = pipe(
    prompt="un rig de minería de GPU cyberpunk en una sala de servidores iluminada con neón, fotorrealista",
    height=1024,
    width=1024,
    num_inference_steps=4,  # ¡Klein solo necesita 4 pasos!
    guidance_scale=3.5,
).images[0]

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

### Modo eficiente en memoria (GPUs de 16 GB)

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

image = pipe("un paisaje montañoso al atardecer", num_inference_steps=4).images[0]
```

## Flujo de trabajo de ComfyUI

FLUX.2 Klein funciona como sustituto directo en los flujos de trabajo existentes de FLUX.1 en ComfyUI:

1. Descarga el checkpoint de FLUX.2 Klein en `ComfyUI/models/diffusion_models/`
2. En tu flujo de trabajo, cambia el nodo de checkpoint para que apunte a FLUX.2 Klein
3. Reduce los pasos a 4 (en lugar de 20–50 para FLUX.1)
4. Establece la escala de guía en 3,0–4,0

```bash
# Descargar modelo para ComfyUI
cd ComfyUI/models/diffusion_models/
wget https://huggingface.co/black-forest-labs/FLUX.2-klein/resolve/main/flux2-klein.safetensors
```

## Generación por lotes

Con generación en menos de un segundo, FLUX.2 Klein permite un procesamiento por lotes masivo:

```python
import torch
from diffusers import FluxPipeline

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

prompts = [
    "un coche deportivo rojo en una carretera de montaña, cinematográfico",
    "el interior de una cafetería acogedora, iluminación cálida",
    "un astronauta flotando sobre la Tierra, hiperrealista",
    "un castillo medieval en otoño, arte de fantasía",
    # ... añade cientos más
]

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"Generadas {i+1}/{len(prompts)}")

# ¡En una RTX 4090: ~100 imágenes en menos de 1 minuto!
```

## Compatibilidad con LoRA

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

# Carga un LoRA entrenado en la arquitectura FLUX
pipe.load_lora_weights("your-lora/flux2-style-lora", weight_name="lora.safetensors")
pipe.fuse_lora(lora_scale=0.8)

image = pipe("un retrato en el estilo entrenado", num_inference_steps=4).images[0]
```

## Consejos para usuarios de Clore.ai

* **El rey del procesamiento por lotes**: Con 0,4 s/imagen, puedes generar más de 10.000 imágenes por hora en una RTX 4090
* **Solo 4 pasos**: No uses más — Klein está optimizado para 4 pasos (más no mejora la calidad)
* **Los mismos LoRAs que FLUX.1**: La mayoría de los LoRAs de FLUX.1 son compatibles con Klein
* **Sustitución directa en ComfyUI**: Solo cambia el checkpoint, cambia los pasos a 4
* **La RTX 3090 es viable**: 1,2 s/imagen sigue siendo genial a $0,07–0,21/h

## Solución de problemas

| Problema                       | Solución                                                                                           |
| ------------------------------ | -------------------------------------------------------------------------------------------------- |
| OOM en 24 GB                   | Usa `enable_model_cpu_offload()` + `vae.enable_tiling()`                                           |
| Imágenes borrosas              | Asegúrate de `num_inference_steps=4`, no menos. Comprueba guidance\_scale 3,0–4,0                  |
| Primera generación lenta       | Normal — el modelo se carga en la primera llamada (\~30 s). Las siguientes: en menos de un segundo |
| Error de checkpoint de ComfyUI | Asegúrate de tener el `.safetensors` archivo, no el formato diffusers                              |

## Lecturas adicionales

* [Guía de FLUX.1](/guides/guides_v2-es/generacion-de-imagenes/flux.md) — guía original de FLUX con detalles sobre LoRA y ControlNet
* [Guía de ComfyUI](/guides/guides_v2-es/generacion-de-imagenes/comfyui.md) — configuración y flujos de trabajo de ComfyUI
* [Blog de Black Forest Labs](https://blackforestlabs.ai/)
* [Modelo en HuggingFace](https://huggingface.co/black-forest-labs/FLUX.2-klein)


---

# 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/generacion-de-imagenes/flux2-klein.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.