FLUX.1 texto a imagen: dev y schnell despliegue local
FLUX.1 es el modelo de texto a imagen de Black Forest Labs——una empresa fundada por antiguos miembros del equipo de Stable Diffusion. El tutorial oficial lo presenta así: uno de los mayores modelos de texto a imagen de código abierto, con 12B de parámetros y archivos originales de unos 23GB, destacado por su excelente calidad de imagen y flexibilidad, y con una arquitectura que combina lo mejor de los Transformer y los modelos de difusión.
Esta página te guía para ejecutar de principio a fin el flujo de trabajo oficial de FLUX: primero distingue las dos versiones de código abierto dev y schnell, luego genera la primera imagen con el «conjunto de cuatro archivos de la versión íntegra» y, por último, mira cómo los dispositivos con poca VRAM pueden usar la versión de un solo archivo fp8.
Qué podrás hacer al terminar
- Distinguir el posicionamiento y las licencias de los tres hermanos de FLUX.1 (Pro / dev / schnell) y saber cuál elegir para el despliegue local
- Ejecutar el flujo de trabajo de la versión íntegra de FLUX.1 dev: los cuatro archivos de modelo en su lugar, imagen en 20 pasos
- Cambiar a schnell con un clic: solo cambia el modelo de difusión, pon los pasos en 4 y genera a toda velocidad
- Usar el checkpoint de un solo archivo fp8 para ejecutar FLUX en dispositivos con poca VRAM, instalando un solo archivo de modelo
- Recordar los parámetros de hierro de FLUX: cfg 1, no escribir prompts negativos, euler + simple
Tu situación actual
- Oyes que FLUX tiene una calidad de imagen top, pero al ver que los pesos empiezan en 20GB no sabes si tu tarjeta gráfica y tu disco pueden con ello
- Descargaste la plantilla oficial, pero en los dos menús desplegables de DualCLIPLoader no sabes en qué casilla van clip_l y t5xxl
- Sigues las costumbres de SD1.5: cfg subido a 7 y prompts negativos a diestra y siniestra, pero FLUX no les hace ningún caso
Cuándo usar esta técnica
Cuando necesitas:
- Excelente calidad de imagen y un seguimiento del prompt del tipo «lo que escribes es lo que dibuja»——incluso los prompts complejos se reproducen con fidelidad
- Ejecutar localmente un modelo de código abierto de gama alta, sin depender ni pagar por APIs cerradas
- Ya sea refinar la generación (dev 20 pasos) o generar a toda velocidad (schnell 4 pasos)
Y no quieres:
- Rendirte ante los pesos de 23GB en una máquina con poca VRAM——la versión de un solo archivo fp8 del paso 6 es la solución
- Pelear con prompts negativos——el flujo de trabajo oficial de FLUX no los usa en absoluto
🎒 Preparativos antes de empezar
- Has completado la primera generación de imágenes: sabes cargar un flujo de trabajo, escribir prompts y ejecutar con
Ctrl+Enter - Tienes claras las reglas de los directorios de modelos: qué va en
diffusion_models,text_encoders,vaeycheckpoints(si lo olvidas, repasa dónde van los modelos) - Reserva unos 32GB de disco para el conjunto de cuatro archivos de la versión íntegra de dev; con la versión de un solo archivo fp8 solo necesitas espacio para un archivo
- Quieres descargar la versión dev: tu cuenta de Hugging Face ha iniciado sesión y has aceptado la licencia del repositorio FLUX.1-dev (no comercial); schnell es Apache 2.0 y no tiene este requisito
- Tu red puede conectarse a Hugging Face; si la conexión es inestable, usa el espejo nacional de ModelScope (la dirección se da en el paso 2)
- ComfyUI está actualizado a la última versión (recordatorio al inicio del tutorial oficial)
- Un vaso de agua ☕——lo que más esperarás en esta lección es la descarga de los modelos
Idea central
FLUX.1 tiene una «arquitectura híbrida». La documentación oficial indica que combina las ventajas de las redes Transformer y de los modelos de difusión: la información de texto e imagen se integra eficazmente en el modelo, la precisión de alineación entre la imagen generada y el prompt es alta, y la reproducción de prompts complejos es especialmente notable. Los 12B de parámetros capturan relaciones de patrones más complejas, produciendo imágenes más realistas y variadas, con un amplio abanico de estilos.
Reparto de los tres hermanos (en esta página se ejecutan los dos últimos):
| Versión | Licencia | Características | Cómo obtenerla |
|---|---|---|---|
| FLUX.1 Pro | de código cerrado | el buque insignia con mejor rendimiento | solo mediante llamadas a la API |
| FLUX.1 dev | de código abierto,no comercial | destilado a partir de Pro, con un rendimiento cercano al de Pro | descarga desde Hugging Face, requiere aceptar el acuerdo |
| FLUX.1 schnell | Apache 2.0 | versión destilada y acelerada,4 pasos para generar la imagen, ideal para hardware de gama baja | descarga directa desde Hugging Face |
Dos rutas de despliegue (así las divide el tutorial oficial):
| Ruta | Qué hay que instalar | Calidad de imagen | Memoria de vídeo | Adecuado para |
|---|---|---|---|---|
| Versión completa (cuatro piezas) | Modelo de difusión + dos codificadores de texto + VAE instalados por separado | La mejor | Requiere más | Con memoria de vídeo suficiente y cuando se busca la mejor adherencia al prompt |
| checkpoint fp8 de un solo archivo | Un único archivo cuantizado fp8 | Ligeramente inferior a la versión completa | Requiere menos | Con memoria de vídeo limitada y cuando se quiere ponerlo en marcha rápido |
¿Por qué el cfg está fijado en 1 y no se escriben prompts negativos? Palabras textuales del tutorial oficial: gracias a la excelente capacidad de FLUX para seguir los prompts, no se necesita ningún prompt negativo. Por eso la plantilla oficial pone a cero el condicionamiento negativo directamente con el nodo ConditioningZeroOut, y el cfg queda fijado en 1; la nota adhesiva de la plantilla de schnell incluso advierte específicamente: si configuras el cfg en 1.0, el prompt negativo se ignora.
Esqueleto del flujo de trabajo (versión completa; tiene dos loaders más que el flujo de un solo checkpoint):
UNETLoader (modelo de difusión)──────────────────────────→ KSampler ──→ VAEDecode ──→ SaveImage
DualCLIPLoader (clip_l + t5xxl)──→ CLIPTextEncode (tu prompt)──→ KSampler (positive)
└──→ ConditioningZeroOut ──→ KSampler (negative, puesto a cero)
VAELoader (VAE)──────────────────────────────────────────────→ VAEDecode
EmptySD3LatentImage (lienzo vacío de 1024×1024)───────────────────────→ KSamplerSígueme
Paso 1: cargar el flujo de trabajo oficial de FLUX
Por qué: en la biblioteca de plantillas oficial, la plantilla de texto a imagen de FLUX.1 ya tiene configurados todos los parámetros y enlaces de modelos, lo cual es mucho más rápido que conectar desde cero.
Operación: abre la biblioteca de plantillas desde Templates en la barra lateral izquierda, busca Flux.1; en esta lección usaremos esta como línea principal:
| Nombre de la plantilla | ID de la plantilla | Contenido |
|---|---|---|
| Flux.1 específico para dev: texto a imagen | flux_dev_full_text_to_image | versión completa de dev, 20 pasos |
Si no quieres usar la biblioteca de plantillas, descarga directamente el JSON y ábrelo con el menú Workflows → Open (Ctrl+O): flux_dev_full_text_to_image.json. Para ver el uso completo de la biblioteca de plantillas, consulta biblioteca de plantillas.
Deberías ver: en el lienzo hay un nodo de subgráfico llamado Text to Image (Flux.1 Dev), con los parámetros de uso habitual —prompt, ancho y alto, seed, nombre del archivo del modelo— expuestos en la superficie del nodo, y a su lado una nota adhesiva (MarkdownNote) llena de enlaces de descarga de modelos.
- Flujo de trabajo de la versión completa de dev cargado en el lienzo
Paso 2: descargar las cuatro piezas de la versión completa de dev y colocarlas en su sitio
Por qué: la versión completa no viene empaquetada en un único checkpoint; los cuatro archivos se instalan por separado; si los pones en el subdirectorio equivocado, no aparecerán en la lista desplegable del loader.
Operación: descarga los cuatro archivos desde Hugging Face (la nota adhesiva de la plantilla incluye los enlaces oficiales de descarga):
| Archivo | Tamaño | En qué subdirectorio colocarlo | Descarga |
|---|---|---|---|
flux1-dev.safetensors | 22.17 GB | models/diffusion_models/ | Hugging Face |
clip_l.safetensors | 234.7 MB | models/text_encoders/ | Hugging Face |
t5xxl_fp16.safetensors | 9.12 GB | models/text_encoders/ | Hugging Face |
ae.safetensors | 319.8 MB | models/vae/ | Hugging Face |
La estructura de directorios queda así:
ComfyUI/
├── models/
│ ├── diffusion_models/
│ │ └── flux1-dev.safetensors
│ ├── text_encoders/
│ │ ├── clip_l.safetensors
│ │ └── t5xxl_fp16.safetensors
│ └── vae/
│ └── ae.safetensors💡 Descarga desde China y alternativa para memoria de vídeo baja
- ModelScope tiene espejos oficiales: el repositorio del modelo de difusión Comfy-Org/flux1-dev y el de la VAE, Comfy-Org/Lumina_Image_2.0_Repackaged; la nota adhesiva de la plantilla incluye los enlaces de ambos.
- Con menos de 32 GB de VRAM: el tutorial oficial sugiere cambiar al codificador de texto en versión fp8 para ahorrar VRAM; en la nota de la plantilla se indica
t5xxl_fp8_e4m3fn_scaled.safetensors(4.8 GB), el resto de archivos queda sin cambios.
⚠️ la versión dev requiere aceptar primero el acuerdo de licencia
Los pesos de dev en Hugging Face requieren iniciar sesión y aceptar el acuerdo de licencia de FLUX.1-dev (no comercial) para poder descargarlos; el tutorial oficial advierte especialmente: si no puedes descargar, revisa primero estas dos cosas. schnell es Apache 2.0 y no tiene este requisito.
Una vez colocados, pulsa r en el lienzo para actualizar y selecciona el archivo correspondiente en el desplegable de modelos del subgrafo (o entra al nodo loader dentro del subgrafo). Si no está claro qué archivo va en qué casilla, revisa la tabla de correspondencias de dónde colocar los modelos.
Deberías ver: todas las advertencias rojas de archivos faltantes desaparecen y los loaders muestran los nombres de archivo correctos.
- Los cuatro archivos en su lugar, con los loaders seleccionando los archivos
Paso 3: entender los nodos y parámetros del flujo de trabajo FLUX
Por qué: el requisito previo para ajustar parámetros es saber qué hace cada nodo y por qué sus valores por defecto son esos.
Operación: haz doble clic para entrar al subgrafo y compara nodo por nodo con esta tabla:
| Nodo | Qué hace | Parámetros clave en la plantilla |
|---|---|---|
| UNETLoader (Load Diffusion Model) | Carga el modelo de difusión en sí (12B) | flux1-dev.safetensors |
| DualCLIPLoader | Carga dos codificadores de texto a la vez | Primera casilla clip_l.safetensors, segunda casilla t5xxl_fp16.safetensors, type flux |
| VAELoader (Load VAE) | Carga el VAE | ae.safetensors |
| CLIPTextEncode | Codifica el prompt en una condición | Se conecta al positive del KSampler |
| ConditioningZeroOut | Pone a cero la condición negativa | FLUX usa cfg=1, no necesita prompt negativo |
| EmptySD3LatentImage | Crea un lienzo vacío | 1024×1024, lote 1 |
| KSampler | Muestreo con eliminación de ruido | 20 pasos, cfg 1, euler, simple, denoise 1.0 |
| VAEDecode | Decodifica el espacio latente a píxeles | — |
| SaveImage | Previsualiza y guarda | El archivo se guarda en ComfyUI/output/ |
El orden de las dos casillas de DualCLIPLoader importa: en ComfyUI, la receta indicada en el código fuente es el tipo flux = clip-l, t5; en la primera casilla va clip_l, en la segunda t5xxl, y en type se elige flux.
Deberías ver: puedes explicar de izquierda a derecha la función de cada nodo, y los parámetros del KSampler coinciden con la tabla anterior.
- Puedo decir qué loader carga cada uno de los cuatro componentes y cuáles son los parámetros clave del KSampler
Paso 4: escribir un prompt y generar la primera imagen dev
Por qué: la especialidad de FLUX es el seguimiento del prompt: cuanto más específico sea el prompt, mejor se reproduce la escena, y además no necesita prompt negativo.
Operación:
- Escribe el prompt en el campo prompt del subgrafo. El ejemplo incluido en la plantilla oficial:
A fairy tale scene of a young girl with silver curly hair wearing a delicate white dress, standing among crystal butterflies and glowing glass roses. The scene is filled with soft magical light, like a dream from a fantasy world.- El tamaño por defecto es 1024×1024; para cambiar la proporción, modifica el width / height del subgrafo
- Haz clic en Run o pulsa
Ctrl+Enter
Deberías ver: la barra de progreso completa los 20 pasos y el nodo SaveImage genera la imagen, en la que aparecen los elementos descritos en el prompt: una chica de cabello plateado, vestido blanco, mariposas de cristal, rosas de vidrio luminosas, como una escena de cuento de hadas.
- Apareció en SaveImage la primera imagen generada por FLUX.1 dev
Paso 5: cambiar a schnell——4 pasos para generar imágenes rápido
Por qué: schnell ha avanzado más en la destilación: con 4 pasos ya genera buenas imágenes, y su licencia sigue siendo la permisiva Apache 2.0. El tutorial oficial indica: el flujo de trabajo de schnell solo se diferencia del de dev en los archivos de modelo.
Operación:
- Descarga adicional
flux1-schnell.safetensors(22.15 GB) y colócalo enmodels/diffusion_models/; repositorio: Comfy-Org/flux1-schnell (espejo en ModelScope). El codificador de texto y el VAE son los mismos del paso 2 (la plantilla oficial usa por defectot5xxl_fp16; la documentación también menciona que schnell puede usar la versión fp8 de t5xxl para ahorrar VRAM, y que la fp16 da mejores resultados) - Elige una de las dos formas de ejecutarlo:
Forma A: cargar la plantilla de la versión completa de schnell (recomendado)
Busca Flux.1 en la biblioteca de plantillas y elige «Flux.1 Schnell Full: texto a imagen» (flux_schnell_full_text_to_image). Su nodo de prompt es CLIPTextEncodeFlux: el prompt se divide en los campos clip_l y t5xxl; puedes escribir contenidos distintos, y el ejemplo oficial usa dos descripciones diferentes, además de un parámetro guidance con valor por defecto 3.5 en la plantilla.
Forma B: reutilizar el flujo de trabajo de dev cambiando dos puntos
Cambia el UNETLoader a flux1-schnell.safetensors y los pasos del KSampler de 20 → 4. El resto queda igual.
- Haz clic en Run
Deberías ver: la barra de progreso completa solo 4 pasos antes de generar la imagen, visiblemente más rápido. El posicionamiento oficial de schnell es precisamente una versión rápida que también funciona en hardware modesto.
- La versión schnell funciona, generando imágenes en 4 pasos
Paso 6: ¿Memoria de vídeo al límite? Usa el checkpoint de un solo archivo fp8
Por qué: la versión de un solo archivo fp8 empaqueta el modelo de difusión, el codificador de texto y el VAE en un único checkpoint cuantizado; basta un solo archivo y exige menos memoria de vídeo, a costa de una calidad de imagen ligeramente inferior a la de la versión completa. Su posicionamiento oficial es precisamente la solución de un solo archivo para dispositivos con memoria limitada.
Operación:
| Versión | Descarga | Colocar en | Nodo de carga | Pasos |
|---|---|---|---|---|
| schnell fp8 | flux1-schnell-fp8.safetensors | models/checkpoints/ | Load Checkpoint | 4 |
| dev fp8 | flux1-dev-fp8.safetensors | models/checkpoints/ | Load Checkpoint | 20 (igual que la versión completa) |
- schnell fp8 usa directamente la plantilla: busca
Flux.1en la biblioteca de plantillas y elige «Flux.1 Schnell FP8» (flux_schnell). Su estructura es justo la versión de un solo checkpoint: un nodo CheckpointLoaderSimple genera las tres salidas MODEL / CLIP / VAE, el campo del prompt negativo queda vacío, KSampler 4 pasos, cfg 1 - dev fp8 se construye manualmente según el tutorial oficial: descarga
flux1-dev-fp8.safetensorsy colócalo enmodels/checkpoints/, cárgalo con el nodo Load Checkpoint. La forma más sencilla: duplica la plantilla schnell fp8, cambia el checkpoint porflux1-dev-fp8.safetensorsy ajusta los pasos de nuevo a 20 - Haz clic en Run
⚠️ No te dejes despistar por el nombre de esta plantilla
En la biblioteca de plantillas también hay un «Flux.1 dev fp8: texto a imagen» (flux_dev_checkpoint_example); el nombre lleva fp8, pero el contenido real de la plantilla es el flujo de trabajo de cuatro piezas de la versión completa, con la misma estructura del paso 1 (también 20 pasos). Para ejecutar la versión dev de un solo archivo, modifícalo manualmente según el punto 2 anterior; no cuentes con esta plantilla.
Deberías ver: en el lienzo queda solo un checkpoint loader (ya no toda una fila de loaders), y con un solo archivo nuevo en checkpoints/ ya se generan imágenes.
- La versión de un solo archivo fp8 funciona y el archivo está en
models/checkpoints/
Punto de control ✅
- La versión completa de dev funciona: cargar la plantilla → colocar las cuatro piezas → generar imagen en 20 pasos
- schnell funciona: cambiar el modelo de difusión + 4 pasos, o usar directamente la plantilla schnell
- Sé que cfg 1 y no escribir prompt negativo es el diseño de FLUX, no que el flujo de trabajo esté roto
- El archivo de la versión de un solo archivo fp8 está en
models/checkpoints/, no endiffusion_models/ - Sé explicar la diferencia entre dev (no comercial, 20 pasos) y schnell (Apache 2.0, 4 pasos)
Advertencias sobre errores comunes
❌ Subir cfg y escribir prompts negativos sin parar
Causa: el flujo oficial de FLUX fija cfg en 1 y el condicionamiento negativo se pone a cero con ConditioningZeroOut; textualmente, la nota de la plantilla schnell dice que con cfg en 1.0 el prompt negativo se ignora. Lo correcto: mantener cfg en 1 y concentrar toda la energía en la descripción visual del prompt positivo.
❌ Descarga del modelo dev rechazada (401 / 403)
Causa: FLUX.1 dev tiene licencia no comercial; en Hugging Face hay que iniciar sesión y aceptar el acuerdo del repositorio primero. Lo correcto: inicia sesión, entra en el repositorio, acepta el acuerdo y luego descarga; o usa el espejo de ModelScope (paso 2). schnell (Apache 2.0) no tiene esta restricción.
❌ Archivo fp8 puesto en diffusion_models y no aparece en el nodo
Causa: flux1-dev-fp8.safetensors / flux1-schnell-fp8.safetensors son checkpoints empaquetados, pertenecen a models/checkpoints/ y los carga Load Checkpoint; el flux1-dev.safetensors de la versión completa sí pertenece a diffusion_models/. Lo correcto: coloca cada archivo según la tabla del paso 6; si sigue sin aparecer, consulta fallo al cargar el modelo.
❌ Memoria de vídeo insuficiente, la versión completa da OOM directamente
Causa: la versión completa debe atender a la vez un modelo de difusión de escala de 22GB y un t5xxl_fp16 de escala de 9GB. Lo correcto: primero cambia t5xxl por t5xxl_fp8_e4m3fn_scaled.safetensors (4.8 GB) según la recomendación oficial; si aún no basta, pasa por completo a la versión de un solo archivo fp8; la solución sistemática está en memoria de vídeo insuficiente.
Técnicas avanzadas (opcional)
🔧 Escribe prompts como frases largas completas: la fortaleza de FLUX es reproducir prompts complejos; los ejemplos oficiales son descripciones de escena en frases largas y completas: personajes, entorno e iluminación, todo de una vez, lo cual es más eficaz que apilar etiquetas de palabras clave.
🔧 Arrastra una imagen y obtén el flujo de trabajo: las imágenes de ejemplo del tutorial oficial llevan metadatos del flujo de trabajo; arrastra la imagen directamente a la ventana de ComfyUI (o Workflows → Open) y se reconstruye el flujo completo junto con la información de descarga de los modelos; si ves una buena imagen hecha con FLUX por otra persona, prueba primero a arrastrarla.
🔧 La familia FLUX tiene más cartas: para retocar imágenes usa FLUX.1 Kontext (consistencia de personajes, iteración en varias rondas), para repintado local y ampliación de imagen usa FLUX.1 Fill, y para la nueva generación de consistencia multi-referencia consulta FLUX.2 y FLUX.3 Klein.
Resumen de la lección
✅ El flujo de trabajo de FLUX ya funciona: versión completa de dev con las cuatro piezas en su lugar → imagen en 20 pasos; schnell cambia el modelo de difusión y ajusta los pasos a 4.
✅ Elección de versión: dev es no comercial y con rendimiento cercano al buque insignia cerrado Pro; schnell es la versión acelerada de Apache 2.0 en 4 pasos, amigable con equipos de gama baja.
✅ Parámetros memorizados: cfg 1, no escribir prompts negativos, euler + simple; dev 20 pasos, schnell 4 pasos.
✅ Con poca VRAM hay alternativas: cambia t5xxl por la versión fp8 para ahorrar la mitad del tamaño, o cambia todo por un checkpoint de un solo archivo fp8 (colócalo en checkpoints/).
Repaso de la configuración clave:
| Configuración | Valor recomendado | Explicación |
|---|---|---|
| Modelo de difusión (dev) | flux1-dev.safetensors(22.17 GB) | colócalo en models/diffusion_models/; la versión de un solo archivo fp8 usa flux1-dev-fp8.safetensors, colócala en checkpoints/ |
| Modelo de difusión (schnell) | flux1-schnell.safetensors(22.15 GB) | igual que arriba; versión fp8 flux1-schnell-fp8.safetensors |
| Codificador de texto | clip_l.safetensors + t5xxl_fp16.safetensors(9.12 GB) | colócalo en models/text_encoders/; con poca VRAM cambia a t5xxl_fp8_e4m3fn_scaled.safetensors(4.8 GB) |
| VAE | ae.safetensors(319.8 MB) | colócalo en models/vae/ |
| DualCLIPLoader | primera casilla clip_l, segunda casilla t5xxl, type flux | receta del código fuente: flux = clip-l, t5 |
| KSampler (dev) | 20 pasos, cfg 1, euler, simple, denoise 1.0 | configuración de la plantilla oficial |
| KSampler (schnell) | 4 pasos, cfg 1, euler, simple, denoise 1.0 | schnell es un modelo destilado de 4 pasos |
| Lienzo | EmptySD3LatentImage 1024×1024 | para cambiar la proporción modifica width / height |
Avance de la próxima lección
Texto a imagen es solo el punto de partida de FLUX.1. En la próxima lección, FLUX.1 Kontext lo convierte en un «motor de edición de imágenes iterativo»: das una imagen de un personaje y lo modificas ronda tras ronda con instrucciones, sin que la apariencia del personaje se desvíe. Próxima lección: FLUX.1 Kontext.
Aprenderás:
- Despliegue local de Kontext dev (pesos fp8 + codificador de texto + VAE)
- Usar el nodo «Load Image(from output)» para alimentar directamente el resultado de la ronda anterior a la siguiente
- Edición iterativa por instrucciones: consistencia de personajes, referencia de estilo
- Limitaciones de Kontext: los prompts solo admiten inglés