Abres ComfyUI por primera vez y ves un lienzo lleno de bloques conectados por cables. Parece complejo, pero hay un patrón que se repite en casi todos los workflows de generación de imágenes: cinco nodos, conectados siempre en el mismo orden.
Esta guía te lleva desde ese lienzo vacío hasta generar tu primera imagen de calidad, con los ajustes exactos para tu GPU. Si aún no tienes ComfyUI instalado, empieza por la guía de instalación en Windows.
🏗️ Workflow Universal: SDXL & Flux
🎨 El workflow básico: 5 nodos, una imagen
Todo workflow de text-to-image en ComfyUI sigue este flujo:
CheckpointLoaderSimple → CLIPTextEncode (×2) → KSampler → VAEDecode → SaveImageCheckpointLoaderSimple — carga el modelo (el .safetensors que descargaste). Su salida conecta al KSampler (MODEL), a los encoders de texto (CLIP) y al VAE (VAE).
CLIPTextEncode — convierte tu prompt de texto al lenguaje que entiende el modelo. Necesitas dos: uno para el prompt positivo (lo que quieres) y otro para el negativo (lo que quieres evitar). Ambos conectan al KSampler (CONDITIONING).
EmptyLatentImage — define el tamaño del lienzo en espacio latente. Conecta al KSampler (LATENT). Aquí estableces la resolución antes de generar.
KSampler — el núcleo del workflow. Toma el modelo, los dos condicionamientos y el latente vacío, y genera la imagen paso a paso eliminando ruido. Su salida (LATENT) va al VAEDecode.
VAEDecode — convierte el resultado del KSampler del espacio latente a píxeles RGB que puedes ver. Su salida va al SaveImage.
SaveImage — guarda la imagen en ComfyUI/output/. También puedes usar PreviewImage si solo quieres ver el resultado sin guardarlo.
Para ejecutar: pulsa Queue o Ctrl + Enter.
🎨 Elegir modelo según tu VRAM
La elección del modelo es la primera decisión. Depende directamente de cuánta VRAM tiene tu GPU.
🎨 SDXL (Stable Diffusion XL)
SDXL es el punto de entrada más equilibrado. Genera imágenes a 1024×1024 con buena calidad en hardware modesto.
| VRAM | Configuración |
|---|---|
| 4 GB | SDXL con --lowvram, resolución 512×512 |
| 6 GB | SDXL estándar, resolución hasta 768×768 |
| 8 GB | SDXL completo, resolución 1024×1024 |
| 12 GB+ | SDXL + refiners, 1024×1024 o superior |
Para lanzar ComfyUI con soporte de VRAM baja, añade el flag al iniciar:
python main.py --lowvramLas resoluciones óptimas para SDXL no son arbitrarias. El modelo fue entrenado con aspectos específicos:
1024 × 1024(cuadrado)1152 × 896(horizontal)896 × 1152(vertical/retrato)1344 × 768(panorámico)768 × 1344(retrato largo)
Usar resoluciones fuera de estas proporciones puede generar artefactos o composiciones extrañas.
🎨 Flux (Black Forest Labs)
Flux es el modelo de nueva generación. Genera imágenes más detalladas y sigue instrucciones de texto con más precisión que SDXL, especialmente para prompts complejos. El precio: necesita más VRAM.
Flux existe en varias versiones según cuánta VRAM tienes:
| Versión | VRAM necesaria | Calidad | Dónde colocarla |
|---|---|---|---|
| FP16 completo | 24 GB+ | Máxima | models/diffusion_models/ |
| FP8 | ~11 GB | Excelente | models/diffusion_models/ |
| GGUF Q4 | ~8 GB | Muy buena | models/unet/ |
| GGUF Q3 | ~6 GB | Buena | models/unet/ |
| GGUF Q2 | ~4 GB | Aceptable | models/unet/ |
Las versiones GGUF requieren el nodo especial GGUF Loader (instálalo desde ComfyUI Manager). Además de la versión GGUF del modelo base, Flux necesita tres archivos adicionales:
ae.safetensors— VAE oficial de Black Forest Labs → enmodels/vae/clip_l.safetensors— encoder de texto CLIP → enmodels/clip/t5xxl_fp8_e4m3fn.safetensors— encoder T5 en FP8 → enmodels/clip/
Un RTX 3070 de 8GB puede generar con Flux GGUF Q4 a unos 10 segundos por paso.
🎨 Ajustes del KSampler
El KSampler tiene seis parámetros que controlan cómo se genera la imagen. Aquí están los valores de partida recomendados y qué hace cada uno.
🎨 Steps (pasos)
Número de iteraciones de eliminación de ruido. Más pasos = más detalle, pero más tiempo de generación.
- SDXL: 20-30 pasos es el rango útil. Por encima de 35 el retorno es marginal.
- Flux Schnell: 4-8 pasos (está diseñado para ser rápido).
- Flux Dev: 20-30 pasos.
Empieza en 20. Si el resultado tiene mucho ruido o falta detalle, sube a 25-30.
🎨 CFG Scale
Controla cuánto sigue la imagen al prompt. Un CFG alto fuerza el prompt pero puede producir colores saturados o anatomía rara. Demasiado bajo y la imagen ignora el texto.
- SDXL: entre 6 y 8. El valor por defecto (8) es un buen punto de partida.
- Flux: entre 1.0 y 3.5. Flux sigue el prompt con mucha más fidelidad que SDXL, por eso necesita CFG mucho más bajo. Con CFG 7 en Flux obtienes resultados sobreexpuestos y saturados.
🎨 Sampler
El algoritmo que elimina el ruido paso a paso. Cada uno produce un resultado ligeramente diferente.
- euler — rápido, algo aleatorio. Bueno para explorar variaciones.
- euler_ancestral — más creativo que euler, produce más variación entre seeds.
- dpmpp_2m — suave y estable. Bueno para retratos y fotografía realista.
- dpmpp_sde — similar a dpmpp_2m pero con algo más de textura.
Para empezar: dpmpp_2m con SDXL, euler con Flux.
🎨 Scheduler
Controla el ritmo al que se elimina el ruido a lo largo de los pasos.
- karras — el más utilizado. Funciona bien con dpmpp_2m y dpmpp_sde. Bueno para detalle y realismo.
- normal — estándar, sin ajuste de ritmo.
- sgm_uniform — recomendado específicamente para Flux.
Combinación recomendada para SDXL: dpmpp_2m + karras.
Combinación recomendada para Flux: euler + sgm_uniform.
🎨 Denoise
Solo relevante en workflows de image-to-image. Para generación desde cero (text-to-image) déjalo siempre en 1.0.
🎨 Seed
El número que inicializa el proceso aleatorio. Misma seed + mismos ajustes = misma imagen. Cambia la seed para obtener variaciones. Usa -1 para que sea aleatoria en cada ejecución.
🎨 Prompts que funcionan
ComfyUI no tiene opinión sobre tu prompt. Lo que escribes es exactamente lo que recibe el modelo.
Para SDXL, un prompt efectivo tiene esta estructura:
[sujeto], [contexto/escena], [estilo], [calidad técnica]Ejemplo:
a fox sitting on a mossy log in a forest, golden hour light,
photorealistic, sharp focus, 8k, highly detailedPrompt negativo básico para SDXL:
blurry, low quality, deformed, ugly, bad anatomy, watermark,
text, cropped, worst quality, jpeg artifactsPara Flux, los prompts negativos tienen menos efecto porque el modelo los procesa diferente. Puedes simplificar el negativo o dejarlo vacío en pruebas iniciales.
Un ajuste que marca diferencia: describe la imagen como si ya existiera, no como instrucciones. En vez de “make a portrait of a woman” prueba “portrait of a woman with dark hair, soft studio lighting, professional photography”.
🎨 SDXL vs Flux: cuándo usar cada uno
No hay un ganador universal. Depende de qué generas y qué GPU tienes.
Usa SDXL si:
- Tienes 4-8 GB de VRAM y quieres la mejor calidad sin complicaciones.
- Generas en grandes cantidades (es más rápido por imagen).
- Trabajas con LoRAs: el ecosistema de LoRAs para SDXL es enorme. Puedes aprender a usarlas con nuestra guía de LoRAs en ComfyUI.
- Quieres resultados predecibles y controlables.
Usa Flux si:
- Tienes 8+ GB de VRAM o puedes usar una versión GGUF cuantizada.
- Necesitas que el modelo siga instrucciones complejas al pie de la letra.
- Trabajas con composiciones de múltiples elementos o texto dentro de la imagen. Para control preciso de composición, la guía de ControlNet Union es el complemento ideal.
- Priorizas calidad de detalle sobre velocidad.
En la práctica: SDXL para workflows productivos y experimentación rápida, Flux para imágenes finales donde el detalle importa.
🎨 Resolución de problemas comunes
La imagen tiene manchas de color o parece quemada — CFG demasiado alto. Bájalo a 6-7 para SDXL, o a 1-2 para Flux.
La imagen tiene ruido visible — pocos pasos. Sube de 20 a 25-30.
Error de VRAM al cargar el modelo — añade --lowvram al iniciar ComfyUI, o elige una versión GGUF más agresiva (Q2/Q3 en vez de Q4).
La imagen no parece seguir el prompt — CFG demasiado bajo. Sube a 7-9 para SDXL. Para Flux, un CFG de 3.5 ya es bastante directivo.
El resultado es siempre idéntico — la seed está fija. Cámbiala a -1 para aleatorio, o ponla en modo aleatorio en el KSampler.
El siguiente paso lógico: los 10 nodos esenciales de ComfyUI si quieres entender qué hace exactamente cada bloque, la guía de prompts para dominar la ponderación y el CFG Scale, la guía de img2img para transformar imágenes existentes, o la guía de vídeo con AnimateDiff si ya controlas la generación de imágenes y quieres animar tus resultados.
Para profundizar en el control de personajes, revisa la guía de LoRAs y IMG2IMG.
Para corregir fallos en las manos, consulta nuestra guía de Inpainting y Outpainting.
Para transferencia de estilo avanzada, la guía de IP-Adapter permite replicar el look de cualquier imagen de referencia. Para llevar tus generaciones a resolución profesional, la guía de upscaling 4K cubre el proceso completo. Si buscas modelos sin restricciones, consulta el top de modelos gratuitos sin censura. Y si quieres explorar más allá de las imágenes, cómo generar audio con ComfyUI completa el ecosistema multimedia.
Preguntas frecuentes
- ¿Qué modelo de Stable Diffusion es mejor para empezar?
- Para principiantes, Stable Diffusion 1.5 es ideal porque funciona bien con 4 GB de VRAM y tiene la mayor cantidad de tutoriales disponibles. Cuando te sientas cómodo, puedes probar SDXL para mayor calidad.
- ¿Cuánta VRAM necesito para generar imágenes con SDXL?
- SDXL requiere un mínimo de 6 GB de VRAM para funcionar, aunque 8 GB es lo recomendado para resoluciones estándar (1024x1024). Con 4 GB puedes usar la versión Turbo con optimizaciones de VRAM.
- ¿Por qué mis imágenes generadas se ven borrosas o con artefactos?
- Las causas más comunes son: usar muy pocos pasos de muestreo (prueba con 20-30), un CFG Scale demasiado alto o bajo (empieza con 7), o una resolución no soportada por el modelo. Asegúrate de usar las resoluciones nativas del modelo.
