ComfyUI (I): Tu primer workflow con SDXL — guía paso a paso
- josejotxe
- 1 nov
- 8 Min. de lectura
Empezamos una nueva serie de artículos sobre la IA y la generación de imágenes en local. En esta serie vamos a ver cómo trabajar con ComfyUI, explorando diferentes workflows y técnicas paso a paso para que puedas generar fácilmente tus propias imágenes en local.
En esta primera entrega vamos a construir, ejecutar y entender un workflow básico de generación de imágenes con SDXL en ComfyUI. Nos centraremos en el uso de la interfaz y en el flujo de datos entre nodos.
Si necesitas ayuda con la instalación del ComfyUI, puedes revisar nuestro artículo "Generación de imágenes con IA en Local (IV): ComfyUI".
🎯 Qué vas a lograr
Crear un workflow simple para generar imágenes usando modelos SDXL.
También podrías cargar el workflow preconfigurado para SDXL.
Entender qué hace cada nodo y cómo se conectan entre sí.
Modificar parámetros clave (prompts, resolución, pasos, CFG, seed) y generar tu primera imagen.
Guardar y previsualizar el resultado desde ComfyUI.
🧩 Requisitos
ComfyUI instalado y funcionando en tu equipo (GPU recomendada).
Un checkpoint SDXL (por ejemplo, uno del estilo “juggernautXL…” o cualquier SDXL compatible) y su VAE correspondiente.
🗂️ Crear o cargar el workflow en ComfyUI
Abrimos ComfyUI, esperamos a que se cargue toda la interfaz y...
Opción A: partir de un workflow vacio e ir añadiendo y configurándolos los nodos uno a uno siguiendo los pasos indicados en el siguiente apartado.
En ComfyUI: menú Workflow - New
Opción B: es cargar el workflow ya creado
Descargamos el archivo .JSON ("WF_SDXL_simple.json") con el workflow que hemos creado a modo de ejemplo a tu equipo
Menú Workflow → Load (o File → Load según versión) y selecciona el archivo que acabamos de descargar: " WF_SDXL_simple.json".
Verás aparecer un conjunto de nodos conectados. Haz zoom con la rueda del ratón y arrastra el lienzo para explorarlos.
NOTA: al cargar el workflow te puede indicar que te falta algún nodo o algún modelo.
En caso de que te falte algún nodo, podrás indicar que te instale los nodos que faltan directamente.
En caso de que te falte un modelo, tendrás que descargar ese modelo, instalarlo en la carpeta correspondiente y luego volver a cargar el workflow.
🛠️ Entendiendo el workflow nodo a nodo
A continuación, una explicación de los bloques principales que aparecen en el flujo.
1) Nodo Load Checkpoint(modelo + CLIP + VAE)
Qué hace: Carga el checkpoint del modelo base SDXL, su CLIP y el VAE. Estos tres elementos salen por salidas separadas para alimentar otros nodos.
Qué tocar: En el widget del nodo, selecciona tu checkpoint SDXL (.safetensors/.ckpt). Si usas otro SDXL, cámbialo aquí. El VAE suele venir embebido en muchos modelos SDXL; si no, carga el que corresponda.
Nota: Los checkpoints son los modelos entrenados que utiliza SDXL para generar imágenes. Puedes descargarlos fácilmente desde plataformas como HuggingFace o Civit.ai, donde encontrarás múltiples versiones y estilos que podrás descargar gratuítamente.
Una vez descargado el modelo (formato .safetensors o .ckpt), cópialo en la carpeta correspondiente dentro del directorio de ComfyUI, normalmente ubicada en:
..\pinokio\api\comfy.git\app\models\checkpoints
En nuestro ejemplo vamos a usar el modelo "juggernautXL_v8Rundiffusion.safetensors", modelo que ocupa 6,8Gb y que hemos descargado de este link "https://civitai.com/models/133005/juggernaut-xl". Ahí vemos el modelo, sus características y podemos descargarlo.
2) Nodo CLIPTextEncode (Prompt positivo)
Qué hace: Convierte tu texto positivo (lo que quieres ver) en una condición que guía la generación.
Qué tocar: Escribe tu prompt. Empieza por algo sencillo y concreto. Ejemplo: “beautiful scenery nature glass bottle landscape, purple galaxy bottle”. Ajusta el estilo y los detalles a tu gusto.
En páginas como civit.ai, puedes explorar una galería repleta de imágenes generadas por otros usuarios. Cada creación incluye su prompt, el modelo utilizado y los parámetros empleados, lo que te permite aprender de los ejemplos, experimentar con variaciones propias y modificar los ajustes directamente para obtener tus propias versiones.
Nota: CLIP (Contrastive Language–Image Pre-training) es el componente encargado de traducir el texto del prompt a un lenguaje que el modelo pueda entender. En otras palabras, analiza las palabras y las transforma en vectores numéricos que representan conceptos, estilos o elementos visuales. Estos vectores guían al modelo SDXL durante el proceso de generación para que la imagen final refleje, en la medida de lo posible, lo descrito en el texto. Cuanto más claro y bien estructurado sea el prompt, más fiel será el resultado visual.
3) CLIPTextEncode (Prompt negativo)
Qué hace: Define qué no quieres que aparezca (artefactos, marcas de agua, desenfoque…).
Qué tocar: Por ejemplo: “text, watermark, low quality, blurry”. Manténlo corto y útil.
Tanto este nodo como el anterior, reciben su entrada desde el LoadCheckpoint, que le proporciona el modelo CLIP necesario para procesar el texto. A su vez, su salida se conecta al KSampler, que usará la información del prompt para guiar la generación de la imagen según las condiciones establecidas.
4) Nodo: EmptyLatentImage (tamaño del lienzo)
Qué hace: Inicializa un espacio latente con el ancho y alto deseados en la imagen de salida.
El parámetro "batch_size" indica cuantas imágenes se generarán.
Qué tocar: Elige la resolución de salida. Empieza con 832×1152 (vertical) o 1024×1024. Subir la resolución incrementa el consumo de VRAM y el tiempo de muestreo.
Conexiones del nodo: Este nodo se conecta directamente al KSampler, al que proporciona la imagen latente inicial sobre la que el modelo aplicará el proceso de difusión. No recibe entradas previas, ya que genera un espacio latente vacío que servirá como punto de partida para la generación de la imagen.
Espacio latente es un concepto fundamental en los modelos de difusión como SDXL. Un espacio latente es una representación matemática de una imagen en forma comprimida: en lugar de trabajar directamente con píxeles, el modelo traduce las características visuales (formas, colores, texturas) a un conjunto de valores numéricos llamados latentes. Estos valores permiten al modelo manipular la imagen de forma más eficiente, aplicando transformaciones, añadiendo detalles o eliminando ruido. Durante el proceso de generación, el modelo comienza con un latente lleno de ruido y, paso a paso, lo va “limpiando” hasta convertirlo en una imagen coherente y reconocible. Por eso, el nodo EmptyLatentImage crea ese lienzo inicial de valores sobre el cual el modelo trabajará.
5) Nodo KSampler (muestreador principal)
Qué hace: Con el modelo, los prompts y el espacio latente como entradas, realiza el muestreo (denoising) para producir el espacio latente final.
Parámetros clave:
Seed (semilla): fija resultados reproducibles. Déjala aleatoria para explorar; fija una semilla cuando consigas algo que te guste.
Steps (pasos): 20–40 es un buen rango inicial. Más pasos no siempre significa mejor.
CFG (Classifier Free Guidance): cuánto caso hace el modelo al prompt (p. ej., 6–9). Demasiado alto puede forzar artefactos; demasiado bajo difumina la intención.
Sampler: prueba con Euler, DPM++ 2M, UniPC, etc. Cambiar sampler altera el “sabor” del resultado.
Scheduler / Denoise: déjalo por defecto para empezar; ajusta más adelante si te interesa el control fino.
Conexiones del nodo: Este nodo recibe varias entradas clave: el modelo procedente de CheckpointLoaderSimple, los prompts codificados (positivo y negativo) de los nodos CLIPTextEncode, y la imagen latente inicial del nodo EmptyLatentImage. Con todos estos elementos, el KSampler aplica el proceso de muestreo o difusión para generar un nuevo espacio latente que representa la imagen final. Su salida se conecta directamente al nodo VAEDecode, que será el encargado de transformar ese latente en una imagen visible.
6) Nodo VAEDecode (de latente a imagen)
Qué hace: Decodifica el espacio latente resultante en una imagen RGB.
Convierte el espacio latente generado por el KSampler en una imagen visible en formato RGB. En este paso, el modelo utiliza el VAE (Variational Autoencoder) para traducir los valores numéricos del espacio latente en píxeles reales que forman la imagen final. Este proceso es esencial, ya que transforma la representación abstracta en una imagen que podemos ver, guardar o seguir procesando.
¿Qué es el VAE? El VAE (Variational Autoencoder) es el componente que traduce entre píxeles y latentes. Durante el entrenamiento se usan dos partes (encoder y decoder). En generación con SDXL nos interesa, sobre todo, el decoder, que convierte el latente final en una imagen RGB.
Qué tocar: Normalmente, nada. Asegúrate de que el VAE que entra sea el correcto.
7) Nodos SaveImage y PreviewImage (salida)
Ahora que el proceso ha terminado y el VAE Decode ha transformado el espacio latente en una imagen visible, llega el momento de visualizar el resultado. ComfyUI ofrece dos opciones muy útiles para ello, que te permiten guardar o revisar la imagen directamente desde la interfaz:
Nodo SaveImage: guarda la imagen en la carpeta de salida (por defecto, suele ser ComfyUI/output).
Nodo PreviewImage: muestra un preview dentro del lienzo para chequear el resultado rápidamente.
▶️ Ejecutar y generar tu imagen
Verifica que LoadCheckpoint apunta a tu checkpoint SDXL válido.
Ajusta prompts (positivo/negativo).
Define resolución en EmptyLatentImage.
En KSampler, revisa Steps, CFG, Sampler y Seed.
Pulsa Run (o ejecuta el nodo final / selecciona todo y ejecuta). Cuando termine, verás la previsualización y la imagen guardada en la carpeta de salida.
Consejo: si te sale una imagen que “casi” te gusta, fija la seed y vuelve a iterar cambiando solo 1–2 parámetros cada vez.
🔧 Variaciones rápidas para explorar
Resolución: prueba 1024×1024, 1152×832, 1344×768…
Sampler: alterna entre Euler, DPM++ 2M, DPM++ SDE, UniPC.
Steps/CFG: sube o baja en saltos de 2–4 unidades para ver su impacto.
Prompts: añade atributos de estilo, luz, composición o materiales.
Batch size: comienza en 1. Si tienes VRAM, aumenta para generar variaciones en paralelo.
🧯 Problemas frecuentes (y cómo resolverlos)
“No encuentra el modelo/CLIP/VAE” → Revisa la ruta y el nombre del checkpoint. Vuelve a cargar el workflow tras mover los archivos.
“CUDA OOM / falta de VRAM” → Reduce resolución, batch size y/o steps; cierra otras apps que usen GPU.
“Resultados borrosos” → Revisa el negativo (evita listas larguísimas), prueba otro sampler y ajusta CFG.
“Cambios de prompt no se notan” → Sube CFG ligeramente, aumenta pasos o cambia seed.
🌐 Recursos útiles
Aquí tienes algunos enlaces imprescindibles para ampliar tu biblioteca de modelos y recursos de ComfyUI:
🌍 Hugging Face: uno de los mayores repositorios de IA del mundo, donde encontrarás miles de modelos —incluidos los compatibles con Stable Diffusion y ComfyUI— listos para descargar y usar.
🎨CivitAI: plataforma comunitaria donde los usuarios comparten modelos, estilos, LoRAs y nodos específicos para ComfyUI, clasificados por categoría, versión y nivel de complejidad.
🧠 En Lozkorp:
Descubre el artículo previo de esta serie donde introdujimos ComfyUI dentro del ciclo “Generación de imágenes con IA en local (IV)”:🔗 Generación de imágenes con IA en local (IV) — ComfyUI
Archivo JSON de este ejemplo "WF_SDXL_simple.json"
🗺️ Conclusión
Con este primer artículo hemos aprendido a crear un flujo completo de generación de imágenes con ComfyUI y SDXL, entendiendo qué hace cada nodo y cómo se conectan entre sí. Este workflow simple es base para entender todos los proyectos que construiremos en los siguientes capítulos de la serie.
El objetivo es que domines el entorno y te familiarices con el proceso de prompting, el manejo del espacio latente y la ejecución del flujo para generar tus propias imágenes en local.
¿Qué workflow te gustaría que exploremos a continuación? Cuéntanoslo en comentarios.
¡tu opinión nos ayuda a decidir el siguiente paso de la serie!
Comentarios