Guía para empezar con ComfyUI: instalación, interfaz, nodos, modelos y primera imagen

Tal vez ya escuchaste que ComfyUI es la interfaz basada en nodos más flexible para Stable Diffusion. Aun así, la primera visita al sitio oficial puede dejarte atascado: ¿Desktop, Portable o Manual? ¿En qué carpeta va el modelo? ¿Por qué la interfaz parece un lienzo lleno de cajas y líneas? Y cuando por fin lo instalas, ¿por qué el primer intento muestra null en Load Checkpoint o termina con CUDA out of memory?

Esta guía tiene un solo objetivo: ayudarte a comprobar desde el primer día que ComfyUI arranca, detecta un modelo y genera una primera imagen con el workflow predeterminado. Cubre la elección de instalación, la estructura de carpetas de modelos, los nodos principales de la interfaz, la primera ejecución de texto a imagen y una checklist para los errores más comunes. No entra en workflows avanzados, comparación de modelos ni recomendaciones de hardware; eso queda para los siguientes artículos de la serie.

Cómo elegir el método de instalación

El sitio oficial de ComfyUI ofrece cuatro caminos de instalación: Desktop, Portable, Manual y Cloud. Los tres primeros se ejecutan en local; el último funciona en la nube. La elección se reduce sobre todo a dos preguntas: ¿tienes una GPU NVIDIA? ¿Quieres administrar el entorno Python por tu cuenta?

Método de instalación	Ventajas	Desventajas	Público adecuado	Entorno Python	Uso de la unidad C	Punto de descarga
Desktop	Instalador simple, primer inicio guiado	Instalación fija en la unidad C, usa unos 5 GB; basada en la versión estable, por lo que algunas funciones nuevas pueden llegar más tarde	Principiantes que quieren empezar lo más rápido posible	Configuración automática	Unos 5 GB	Página oficial de descarga
Portable	Descomprimir y ejecutar; puede ir en cualquier unidad; incluye Python y dependencias	Hay que elegir el script de inicio manualmente; no hay asistente de instalación	Usuarios que no quieren llenar la unidad C o que ya tienen varias versiones de Python	Incluido y aislado	Depende de dónde se extraiga	GitHub Release
Manual	Control completo sobre versiones y dependencias	Debes configurar Python, PyTorch y CUDA tú mismo; más pasos	Desarrolladores con un entorno Python y necesidad de controlar versiones	Configuración manual	Depende del directorio clonado	GitHub clone
Cloud	Listo para usar, sin GPU local	Cobro por tiempo de uso o VRAM; el acceso desde China puede ser inestable	Usuarios con GPU local insuficiente o que no quieren instalar nada	No necesario	Ninguno	Opción Cloud oficial

Desktop empaqueta las dependencias en el instalador y comprueba el entorno en el primer inicio. La desventaja es el control de rutas: la aplicación queda fija en la unidad C, y la carpeta de modelos suele estar en el directorio de usuario dentro de esa misma unidad. Si la unidad C tiene poco espacio, o prefieres guardar todos los modelos en otro disco, Portable o Manual suele encajar mejor.

Portable es un paquete comprimido. Después de extraerlo, puedes colocar la carpeta donde quieras. Sus scripts separan el modo GPU NVIDIA (run_nvidia_gpu.bat) del modo CPU (run_cpu.bat), así que no necesitas configurar la versión de Python ni el backend PyTorch CUDA. Es una buena opción si quieres evitar la pelea con el entorno, pero mantener control sobre la ubicación de instalación.

Manual está pensado para desarrolladores que ya tienen Python 3.10+ y saben qué versión de PyTorch necesitan. Tiene más pasos que Desktop o Portable, pero permite clonar una rama concreta e instalar versiones específicas de dependencias. No empezaría aquí como principiante: la configuración del entorno ya es una de las partes más propensas a errores.

La opción Cloud está disponible desde el sitio oficial. En la práctica, alquila recursos de GPU en la nube para ejecutar ComfyUI. Si tu equipo no tiene una GPU NVIDIA, o solo quieres probar la interfaz rápido, puede servir. El uso prolongado tiene costo, y el acceso a servicios cloud extranjeros desde China puede ser inestable.

Pasos de instalación de Desktop

Desktop es el camino más rápido para quien quiere empezar sin complicarse. El instalador maneja Python, las dependencias y la configuración de rutas. Tú básicamente avanzas por los pasos de aceptar y continuar.

Proceso de instalación

1. Abre el sitio de ComfyUI (docs.comfy.org) y busca el enlace de descarga de Desktop en la sección Installation. Elige la versión de Windows. También hay versiones para macOS y Linux, pero esta guía usa Windows como ejemplo.

2. Haz doble clic en el instalador descargado. El asistente mostrará la ruta de instalación: por defecto, la unidad C, sin opción de cambiarla. Si necesitas controlar la ubicación, no elijas Desktop; usa Portable.

3. Termina la instalación. En el primer inicio, ComfyUI comprueba las dependencias. Si falta algún componente, el asistente lo descarga automáticamente.

4. Después del arranque, el navegador abre http://127.0.0.1:8188. La interfaz debería mostrar un grafo de nodos vacío o el workflow predeterminado.

Ubicación de la carpeta de modelos

La carpeta de modelos de Desktop no es la misma que la de Portable. Por defecto, vive dentro del directorio del usuario, no dentro del directorio de instalación. En el primer inicio está vacía, por eso el nodo Load Checkpoint muestra null.

Para encontrarla, usa el menú de ComfyUI Desktop: Help -> Open folder -> Open models folder. Ese menú abre directamente el directorio models, sin que tengas que buscar la ruta a mano.

Desktop puede descargar modelos desde la interfaz. Si falta un modelo base al iniciar, puede pedirte que hagas clic en un botón de descarga. Después, el modelo se coloca en la carpeta checkpoints correcta. Esta descarga automática solo cubre algunos modelos base recomendados oficialmente. Si quieres modelos de terceros, por ejemplo de Civitai o LiblibAI, tendrás que descargarlos manualmente y ponerlos en checkpoints.

Comprobaciones después del primer inicio

Después de arrancar, confirma tres cosas: el navegador abrió la interfaz y la barra de direcciones muestra 127.0.0.1:8188; a la derecha aparece el botón Queue Prompt; a la izquierda o arriba hay una entrada de ComfyUI-Manager. Desktop normalmente incluye Manager.

Si la interfaz abre pero Queue Prompt no responde, o si un nodo aparece en rojo, no te apresures a generar una imagen. Primero comprueba que el modelo esté en su lugar. La siguiente sección explica la ruta del modelo y cómo refrescarla.

Pasos de instalación de Portable

Portable conviene si no quieres ocupar la unidad C, si ya tienes varias versiones de Python o si quieres decidir dónde instalar ComfyUI. En esencia, es un paquete con Python y dependencias; después de extraerlo, ejecutas un script de inicio.

Descargar y extraer

1. Abre el repositorio de ComfyUI en GitHub (github.com/Comfy-Org/ComfyUI) y busca la última versión estable en Releases. Descarga el paquete Windows Portable. Suele ser un archivo 7z o zip con portable en el nombre.

2. Usa 7-Zip o la herramienta integrada de Windows para extraerlo donde quieras, por ejemplo D:\ComfyUI_portable. Mantén la ruta razonablemente corta para evitar problemas de permisos o de longitud de ruta.

3. La carpeta extraída contiene partes importantes: ComfyUI (aplicación principal y carpeta models), python_embeded (entorno Python incluido) y scripts de inicio como run_nvidia_gpu.bat y run_cpu.bat.

Elegir el script de inicio

Portable trae varios scripts para distintos tipos de GPU y modos de ejecución:

• run_nvidia_gpu.bat: úsalo si tienes una GPU NVIDIA y el controlador está instalado. Da el mejor rendimiento de arranque y generación.

• run_cpu.bat: úsalo si no tienes GPU NVIDIA o si el controlador NVIDIA falla. Es mucho más lento, pero sirve para comprobar que la instalación funciona.

• Otros scripts, como run_nvidia_gpu_lowvram.bat, son para casos de poca VRAM. No los necesitas en el primer inicio salvo que ya sepas que la VRAM es el cuello de botella.

Haz doble clic en el archivo bat correspondiente. Se abre una ventana de línea de comandos con el registro de inicio: versión de Python, backend PyTorch CUDA y resultados del escaneo de modelos. Después de unos segundos, el navegador debería abrir http://127.0.0.1:8188. Si no lo hace, escribe esa dirección manualmente.

Revisar el registro del primer inicio

El registro de la línea de comandos muestra varias señales útiles:

• Starting server: el servicio arrancó.
• To see the GUI go to: http://127.0.0.1:8188: la dirección del navegador es correcta.
• Total VRAM ...: ComfyUI detectó la memoria de la GPU.
• Resultado del escaneo de models/checkpoints: si hay un modelo, aparece su nombre de archivo; si no, solo se muestra la ruta.

Si el registro muestra un error como CUDA not available, revisa primero el controlador de la GPU. Portable ya incluye una compilación de PyTorch con soporte CUDA, pero el sistema necesita un controlador NVIDIA funcional.

Instalación Manual (opcional)

Manual es para desarrolladores que ya tienen Python 3.10+ y saben qué versión de PyTorch necesitan. Tiene más pasos que Desktop y Portable, y la configuración de dependencias se rompe con facilidad. Un principiante no debería empezar aquí.

Si aun así quieres usar Manual, el proceso básico es:

1. Ejecuta git clone https://github.com/Comfy-Org/ComfyUI.git en el directorio objetivo. Si necesitas una rama o versión concreta, haz checkout del tag correspondiente después de clonar.

2. Entra en el directorio clonado y localiza requirements.txt. Ejecuta pip install -r requirements.txt. Esto instala las dependencias principales de ComfyUI, pero no necesariamente el backend PyTorch CUDA correcto. Eso debes manejarlo aparte.

3. Instala PyTorch. Elige la versión según tu GPU. Las GPU NVIDIA necesitan una compilación de PyTorch con CUDA. Usa la guía oficial de instalación de PyTorch para obtener el comando exacto. Si instalas la versión CPU por error, ComfyUI mostrará CUDA not available.

4. Inicia ComfyUI con python main.py. El puerto predeterminado es 8188, así que abre http://127.0.0.1:8188 en el navegador.

Parámetros de inicio

La versión Manual admite varios parámetros para controlar el uso de VRAM y la red:

• --lowvram: úsalo cuando la VRAM sea limitada. Reduce el uso de memoria, pero ralentiza la generación.
• --cpu: fuerza el modo CPU.
• --port 8188: cambia el puerto de escucha. El valor predeterminado es 8188.
• --listen 0.0.0.0: permite acceso desde la red local. Por defecto, solo permite acceso desde la propia máquina.

Si tu GPU tiene menos de 4 GB de VRAM, agregar --lowvram puede reducir la probabilidad de CUDA out of memory.

Riesgo de versiones y dependencias

El principal riesgo de Manual está en alinear Python y PyTorch. La recomendación oficial es Python 3.10.x. No se garantiza compatibilidad con Python 3.11 o 3.12. PyTorch también debe coincidir con la versión de CUDA. Si el sistema tiene CUDA 12.x, pero tu PyTorch apunta a CUDA 11.x, pueden aparecer errores relacionados con CUDA.

Si el arranque falla, lee primero el registro de la línea de comandos. Los errores frecuentes incluyen ImportError: DLL load failed (versión de PyTorch incompatible), ModuleNotFoundError (dependencia faltante) y CUDA not available (PyTorch sin CUDA o problema del controlador).

Dónde colocar los modelos

La carpeta de modelos es uno de los bloqueos más comunes al empezar. ComfyUI no trae un modelo base al arrancar. Debes descargar uno y ponerlo en la carpeta correcta. Cuando Load Checkpoint muestra null, el modelo casi siempre está en el lugar equivocado.

Ubicación de la carpeta de modelos

En Portable y Manual, la carpeta de modelos está dentro del directorio de instalación:

<directorio de instalación de ComfyUI>/ComfyUI/models/

Por ejemplo, si extraes Portable en D:\ComfyUI_portable, la carpeta de checkpoints es:

D:\ComfyUI_portable\ComfyUI\models\checkpoints\

Desktop usa una carpeta distinta, normalmente dentro del directorio del usuario. No adivines la ruta: usa Help -> Open folder -> Open models folder, y ComfyUI abrirá el directorio models.

Para qué sirve cada subdirectorio

Dentro de models hay varios subdirectorios. Cada tipo de modelo tiene su lugar:

Subdirectorio	Uso	Tipos de archivo de modelo
checkpoints	Modelos base, como SD 1.5 y SDXL	.safetensors, .ckpt
loras	Modelos LoRA de fine-tuning	.safetensors, .ckpt
vae	Decodificadores VAE, que afectan color y detalle	.safetensors, .pth
embeddings	Embeddings de texto, prompts negativos y embeddings de estilo	.pt, .bin, .safetensors
controlnet	Modelos de control ControlNet	.safetensors, .pth
upscale_models	Modelos de escalado, como ESRGAN y RealESRGAN	.pth, .safetensors

Para la primera vez solo necesitas poner el modelo base en checkpoints. Los demás tipos de modelo se usan más adelante en workflows avanzados.

Formato del archivo de modelo

Los modelos base suelen venir en dos formatos: .safetensors y .ckpt. .safetensors es más reciente y más seguro, y ComfyUI lo recomienda como opción preferente. .ckpt es un formato antiguo; algunos modelos tempranos todavía lo usan. ComfyUI reconoce ambos, pero si puedes elegir, descarga .safetensors.

Puedes nombrar los archivos como quieras, pero conviene incluir el nombre y la versión del modelo para identificarlos después. Por ejemplo, sd_v1-5.safetensors o sdxl_base_1.0.safetensors.

extra_model_paths.yaml

Si tienes varias instalaciones de ComfyUI o modelos repartidos entre varios discos, puedes configurar rutas adicionales con extra_model_paths.yaml. Este archivo está en el directorio ComfyUI, usa formato YAML y permite declarar varios directorios externos de modelos. Para la primera ejecución no hace falta tocarlo; la ruta predeterminada basta.

Cómo se ve la interfaz

El núcleo de ComfyUI es el grafo de nodos. Cada nodo representa una operación, como cargar un modelo, ingresar un prompt, hacer sampling o decodificar la imagen. Los datos viajan entre nodos mediante conexiones. Entender esta estructura es la base para usar ComfyUI.

Elementos principales de la interfaz

Después de abrir la interfaz, verás estas zonas:

• Área del grafo de nodos: está en el centro de la interfaz y muestra todos los nodos y conexiones. Puedes mover nodos, hacer clic en conexiones para eliminarlas y hacer clic derecho en un nodo para ver sus opciones.

• Botón Queue Prompt: está a la derecha o arriba de la interfaz y ejecuta el workflow. Después del clic, ComfyUI recorre el grafo de nodos paso a paso y genera la imagen.

• Botón Clear: borra el grafo de nodos actual y vuelve a un estado vacío.

• Botón Save: guarda el workflow actual como archivo JSON, que luego puedes cargar directamente.

• Botón Load: carga un workflow JSON guardado.

• Botón Load Default: carga el workflow predeterminado de texto a imagen, con cinco nodos principales.

• ComfyUI-Manager: barra lateral o entrada de menú para instalar nuevos nodos, actualizar nodos existentes y buscar workflows de la comunidad. Desktop y Portable suelen incluir Manager; Manual requiere instalarlo aparte.

Los cinco nodos principales del workflow predeterminado

Después de hacer clic en Load Default, aparecen cinco nodos conectados de izquierda a derecha:

Nombre del nodo	Función	Entrada/salida
Load Checkpoint	Carga el modelo base y el codificador de texto CLIP	Salida: MODEL, CLIP, VAE
CLIP Text Encode (Prompt)	Codifica el prompt positivo	Entrada: CLIP; salida: CONDITIONING
CLIP Text Encode (Negative)	Codifica el prompt negativo	Entrada: CLIP; salida: CONDITIONING
KSampler	Sampler en latent space, el centro de la generación de imagen	Entrada: MODEL, CONDITIONING positivo, CONDITIONING negativo, VAE; salida: LATENT
VAE Decode	Convierte datos latentes en una imagen visible	Entrada: VAE, LATENT; salida: IMAGE
Save Image	Guarda la imagen en el directorio output y muestra una vista previa	Entrada: IMAGE

Las líneas entre nodos indican la dirección de los datos. Por ejemplo, la salida CLIP de Load Checkpoint se conecta a las entradas CLIP de los dos nodos CLIP Text Encode. La salida LATENT de KSampler se conecta a la entrada LATENT de VAE Decode.

Menú contextual

Haz clic derecho sobre un nodo para abrir un menú de acciones. Suele incluir:

• Add Node: agrega un nuevo nodo cerca del nodo actual.
• Remove: elimina el nodo actual.
• Bypass: omite el nodo actual sin ejecutarlo.
• Reroute: agrega un punto de redirección para ordenar conexiones.

Si haces clic derecho en una zona vacía, puedes elegir Add Node -> buscar el nombre del nodo para añadir un nodo nuevo al workflow.

Puertos de entrada y salida de los nodos

Cada nodo tiene puertos de entrada a la izquierda y puertos de salida a la derecha. Los puertos aparecen como puntos pequeños, y los colores indican tipos de datos:

• Morado: MODEL (modelo)
• Amarillo: CLIP (codificador de texto)
• Azul: VAE (decodificador)
• Verde: CONDITIONING (condicionamiento del prompt)
• Rojo: LATENT (datos de latent space)
• Blanco: IMAGE (datos de imagen)

Al conectar, el color del puerto de salida debe coincidir con el del puerto de entrada. Una salida MODEL solo puede conectarse a una entrada MODEL, no a una entrada CLIP. Si los colores no coinciden, la conexión no se crea.

Cómo usar el workflow predeterminado

El workflow predeterminado es la configuración mínima de texto a imagen que ComfyUI proporciona oficialmente. Incluye cinco nodos principales y ya está conectado en el orden correcto. Solo necesitas elegir el modelo, ingresar los prompts y hacer clic en Queue Prompt para generar la primera imagen.

Cargar el workflow predeterminado

1. Inicia ComfyUI; el navegador abre la interfaz (http://127.0.0.1:8188).

2. Busca el botón Load Default a la derecha o arriba de la interfaz. Después del clic, el grafo muestra cinco nodos: Load Checkpoint, CLIP Text Encode (positivo), CLIP Text Encode (negativo), KSampler, VAE Decode y Save Image.

3. Comprueba que todos los nodos aparezcan. Si un nodo está rojo o una conexión falta, tal vez el workflow no se cargó completo. Haz clic de nuevo en Load Default o revisa las conexiones manualmente.

Relación de conexiones entre nodos

Las conexiones del workflow predeterminado son estas:

• Load Checkpoint: produce MODEL, CLIP y VAE. MODEL se conecta a la entrada MODEL de KSampler. CLIP se conecta a las entradas CLIP de los dos nodos CLIP Text Encode. VAE se conecta a la entrada VAE de VAE Decode; en algunos workflows también se conecta a la entrada VAE de KSampler.

• CLIP Text Encode (positivo): recibe CLIP y produce CONDITIONING. Se conecta a la entrada positiva de KSampler.

• CLIP Text Encode (negativo): recibe CLIP y produce CONDITIONING. Se conecta a la entrada negativa de KSampler.

• KSampler: recibe MODEL, CONDITIONING positivo, CONDITIONING negativo y, según el workflow, VAE. Produce LATENT, que se conecta a la entrada LATENT de VAE Decode.

• VAE Decode: recibe VAE y LATENT, produce IMAGE y se conecta a la entrada images de Save Image.

• Save Image: recibe IMAGE, la guarda en la carpeta de salida y muestra una vista previa en la interfaz.

Este orden es el proceso central de texto a imagen: cargar modelo -> codificar prompt -> muestrear en latent space -> decodificar imagen -> guardar salida.

Confirmar la integridad del workflow

Después de cargar el workflow predeterminado, revisa tres puntos:

1. Selección de modelo en Load Checkpoint: haz clic en el nodo. El menú desplegable debería listar los modelos que colocaste en checkpoints. Si muestra null o está vacío, el modelo está mal ubicado o ComfyUI no se ha refrescado.

2. Todas las conexiones están completas: revisa que las entradas y salidas necesarias estén conectadas. Si una entrada queda vacía, el nodo puede no ejecutarse.

3. No hay nodos rojos: un nodo rojo indica un problema de configuración. Haz clic en el nodo para revisar los parámetros y detectar entradas faltantes.

Si estos tres puntos están bien, puedes pasar al siguiente paso: la primera generación de texto a imagen.

Primera generación de texto a imagen

El objetivo de la primera generación no es obtener una imagen perfecta. Solo buscamos comprobar que todo el proceso se ejecuta. Estos son los pasos concretos.

Checklist de pasos ejecutables

1. Elegir modelo: en el nodo Load Checkpoint, abre el menú desplegable y selecciona el modelo que colocaste en checkpoints. Si usas un modelo SD 1.5, cuyo nombre contiene v1-5 o sd1.5, puedes probar con los parámetros predeterminados. Si usas SDXL, la demanda de VRAM es mayor y puede aparecer CUDA out of memory en el primer intento.

2. Ingresar el prompt positivo: en el nodo CLIP Text Encode positivo, normalmente etiquetado como Prompt, ingresa una descripción en inglés. Por ejemplo: a cat sitting on a windowsill, soft light, simple background. No hay un límite rígido de longitud, pero para el primer test conviene usar 10 a 20 palabras.

3. Ingresar el prompt negativo: en el nodo CLIP Text Encode negativo, escribe lo que no quieres que aparezca en la imagen. Por ejemplo: blurry, low quality, watermark, text. Los prompts negativos ayudan a reducir problemas comunes.

4. Revisar los parámetros de KSampler: haz clic en el nodo KSampler y comprueba estos parámetros:

   • seed: semilla aleatoria, controla la variación de los resultados. Para el primer test puedes conservar el valor predeterminado o ingresar cualquier número.
   • steps: número de pasos de sampling, normalmente 20 por defecto. Para el primer test déjalo en 20 y no lo aumentes.
   • sampler_name: nombre del sampler, por ejemplo euler o ddim. Mantén el valor predeterminado.
   • cfg: fuerza con la que se sigue el prompt, normalmente 7 u 8. No lo cambies en el primer test.
   • denoise: intensidad de denoising, generalmente 1,0. Mantén el valor predeterminado.

El significado de estos parámetros se explicará con más detalle en artículos posteriores de la serie. Para la primera generación, no hace falta cambiarlos; valida el workflow con los valores predeterminados.

5. Hacer clic en Queue Prompt: usa el botón Queue Prompt a la derecha o arriba de la interfaz. Después del clic, el grafo de nodos empieza a ejecutarse. Verás un indicador verde alrededor de los nodos en ejecución y el progreso global a la derecha.

6. Esperar a que termine la generación: la duración depende del tamaño del modelo, la VRAM y el número de steps. Un modelo SD 1.5 suele tardar 5 a 15 segundos con VRAM media (8 a 12 GB). SDXL tarda más. Si el progreso se queda bloqueado, puede ser CUDA out of memory u otro error; usa la lista de solución de problemas de abajo.

7. Ver la imagen de salida: cuando termine, Save Image mostrará una vista previa. Con clic derecho sobre la imagen puedes elegir Open Image para verla en una ventana nueva, o Save Image para guardarla en una ruta concreta. Por defecto, la imagen se guarda en output, al mismo nivel que la carpeta models.

Situaciones comunes en la primera generación

La primera generación puede no darte la imagen esperada. Es normal. Casos frecuentes:

• Resolución demasiado baja: la resolución del workflow predeterminado se controla con el parámetro latent_image de KSampler y puede estar en 512x512 por defecto. Con SDXL, esa resolución puede ser insuficiente y la imagen puede verse borrosa. Se corrige ajustando empty_latent_image en KSampler o usando un workflow adaptado a SDXL.

• Colores extraños o aspecto gris: algunos modelos necesitan una VAE asociada para decodificar bien. Si la imagen se ve gris, apagada o sobreexpuesta, puede que la VAE no coincida. Este tema se trata en capítulos más avanzados.

• El prompt apenas influye: quizá el prompt del primer test sea demasiado genérico. Prueba con más detalles, por ejemplo a fluffy orange cat sitting on a wooden windowsill.

Manejar VRAM insuficiente

Si aparece CUDA out of memory durante la generación, prueba lo siguiente:

• Reinicia ComfyUI y agrega --lowvram (en Manual y Portable, dentro del comando o script de inicio).
• Reduce los steps, por ejemplo de 20 a 15.
• Usa un modelo con menor demanda de VRAM. SD 1.5 necesita menos VRAM que SDXL.

La demanda de memoria cambia mucho según el modelo y la configuración. No conviene prometer un número universal. Si tu GPU tiene menos de 4 GB de VRAM, prueba primero Cloud o el modo CPU.

¿Qué hacer si la imagen no se genera?

En la primera generación pueden aparecer errores. Estos son cinco grupos comunes y cómo diagnosticarlos.

1. Load Checkpoint muestra null o el desplegable está vacío

Síntoma: al hacer clic en el nodo Load Checkpoint, el menú desplegable está vacío o muestra null. Los nodos siguientes se marcan en rojo porque no se encuentra el modelo.

Pasos de diagnóstico:

• Revisa la ubicación del archivo del modelo: asegúrate de que esté dentro de checkpoints. En Desktop, usa Help -> Open models folder para verificar la carpeta real.
• Revisa el formato del archivo: debe terminar en .safetensors o .ckpt.
• Actualiza la lista de modelos: si existe el botón Refresh en la barra lateral, úsalo; si no, reinicia ComfyUI.
• Revisa el registro de inicio: la ventana de línea de comandos lista los modelos detectados. Si tu modelo no aparece, la ruta es incorrecta.

2. CUDA out of memory

Síntoma: los nodos se detienen durante la generación, y la línea de comandos o la interfaz muestra CUDA out of memory.

Pasos de diagnóstico:

• Reinicia con --lowvram.
• Reduce los pasos de sampling, por ejemplo de 20 a 10-15 en KSampler.
• Usa un modelo con menor demanda de VRAM. SD 1.5 requiere menos que SDXL.
• Comprueba si otros programas están ocupando VRAM, como muchas pestañas del navegador u otras aplicaciones de IA en segundo plano.

La demanda de VRAM varía mucho según el modelo y la configuración; los números generales no son fiables. SD 1.5 suele funcionar con VRAM media (8 a 12 GB), mientras que SDXL necesita más.

3. Error de formato del modelo o incompatibilidad de versión

Síntoma: el nodo Load Checkpoint aparece en rojo, con mensajes que contienen safetensors header o version mismatch.

Pasos de diagnóstico:

• Revisa la integridad del archivo del modelo: una descarga interrumpida puede corromperlo. Descarga el modelo de nuevo.
• Confirma que la versión del modelo coincide con tu versión de ComfyUI. Algunos modelos recientes, como SDXL, requieren una versión reciente de ComfyUI. Una versión Portable antigua puede no soportarlos.
• Revisa el origen del modelo: prioriza sitios oficiales o confiables. Algunos modelos de terceros pueden tener formatos problemáticos.

4. Dependencias faltantes o problema del entorno Python

Síntoma: al iniciar, la línea de comandos muestra ImportError o ModuleNotFoundError. Después de Queue Prompt, un nodo marca un error rojo porque falta un módulo.

Pasos de diagnóstico:

• Si usas Manual, comprueba que pip install -r requirements.txt haya terminado correctamente.
• Comprueba que PyTorch tenga CUDA correctamente instalado: ejecuta python -c "import torch; print(torch.cuda.is_available())" dentro del entorno Python. Si devuelve False, PyTorch no tiene soporte CUDA correcto.
• Reinstala dependencias: en Manual, elimina y recrea el entorno virtual; en Portable, extrae de nuevo el paquete.

Desktop y Portable suelen traer todas las dependencias y tienen menos problemas de este tipo. Manual es más propenso a dependencias faltantes.

5. Un nodo muestra error, pero el mensaje no es claro

Síntoma: un nodo está en rojo, pero al hacer clic no aparece un mensaje claro.

Pasos de diagnóstico:

• Revisa las conexiones del nodo: todas las entradas necesarias deben estar conectadas y los colores de los puertos deben coincidir.
• Revisa los parámetros del nodo: haz clic en él y comprueba que cada valor sea válido. Por ejemplo, el seed de KSampler no debe estar vacío.
• Prueba borrar y agregar de nuevo el nodo: clic derecho sobre el nodo -> Remove; luego clic derecho en una zona vacía -> Add Node -> busca el nodo correspondiente.
• Recarga el workflow: haz clic en Clear para vaciar el grafo y luego vuelve a hacer clic en Load Default.

6. Fallo de inicio: puerto ocupado o servicio no iniciado

Síntoma: el navegador no puede abrir http://127.0.0.1:8188, o la línea de comandos muestra Address already in use.

Pasos de diagnóstico:

• Comprueba si la línea de comandos sigue abierta. Si la ventana se cerró, el servicio se detuvo.
• Revisa el uso del puerto: otro programa puede estar usando el puerto 8188. Puedes iniciar con --port 8189 para usar otro puerto.
• Revisa el firewall: algunos firewalls pueden bloquear servicios locales.

Si el error no aparece en esta lista, abre primero el registro de la línea de comandos para encontrar el mensaje exacto. Después busca casos similares en GitHub Issues o Discord.

Qué aprender después

Después de completar la primera generación de texto a imagen, ya comprobaste que ComfyUI arranca, que el modelo se carga y que el workflow predeterminado se ejecuta. Luego puedes profundizar en tres direcciones.

Documentación oficial y extensiones de nodos

La documentación oficial de ComfyUI (docs.comfy.org) cubre instalación, conceptos básicos, gestión de modelos, listas de nodos y más. Si quieres entender el significado de un parámetro de un nodo o revisar la implementación oficial de una función, empieza por la documentación.

ComfyUI-Manager es la herramienta central para ampliar nodos comunitarios. Desktop y Portable suelen incluir Manager; en Manual hay que instalarlo aparte. Manager permite buscar e instalar nodos nuevos, actualizar nodos existentes, importar workflows compartidos por la comunidad y comprobar compatibilidad de versiones.

Si quieres probar funciones avanzadas como ControlNet, LoRA o AnimateDiff, Manager es el punto de entrada para instalar los nodos necesarios. Para principiantes, conviene entender primero el workflow predeterminado y luego instalar nodos nuevos de forma gradual.

Direcciones de workflows avanzados

Cuando ya entiendas el proceso predeterminado de texto a imagen, puedes explorar estas direcciones:

• Reutilización y gestión de workflows: aprender a importar archivos JSON de workflows compartidos por otros, modificar parámetros y guardar configuraciones frecuentes. Esta dirección corresponde a próximos artículos de la serie “Guía de reutilización de workflows en ComfyUI”.

• Control fino con ControlNet: usar nodos ControlNet para controlar pose, bordes, profundidad y color de la imagen. Sirve para escenarios que requieren composición precisa. Esta dirección corresponde al artículo posterior “Guía completa de ControlNet en ComfyUI”.

• Fine-tuning de modelos LoRA: usar LoRA para transferir rasgos de estilo o personaje al modelo base. Es útil para generar imágenes con un estilo o personaje específico. Esta dirección corresponde al artículo posterior “Guía práctica de modelos LoRA en ComfyUI”.

Las tres direcciones requieren nodos y modelos adicionales. Conviene probarlas paso a paso y no instalar demasiados nodos de una sola vez.

Fuentes y recomendaciones de modelos

El modelo usado para el primer test puede ser un SD 1.5 general o SDXL Base. Si quieres probar más estilos, puedes buscar en estos sitios:

• Civitai: una de las comunidades internacionales más grandes de modelos Stable Diffusion, con modelos base, LoRA, VAE, ControlNet y más. Al buscar, revisa la versión del modelo (SD 1.5 / SDXL) y el origen de los datos de entrenamiento.

• LiblibAI: plataforma china de modelos Stable Diffusion, con acceso más rápido desde China y muchos modelos y LoRA compartidos por creadores chinos.

• Hugging Face: repositorio de modelos con modelos base publicados por Stability AI y muchos modelos open source.

Al descargar un modelo, revisa tres puntos: que la versión sea compatible con tu versión de ComfyUI; que el uso del modelo esté claro (texto a imagen / imagen a imagen / ControlNet); y que, si es posible, uses formato .safetensors.

Otros artículos de esta serie

Este artículo es la página de entrada de la serie “Guía práctica de ComfyUI y Stable Diffusion”. Los artículos siguientes tratarán gestión de workflows, ControlNet, LoRA, recomendaciones de modelos y optimización de rendimiento. Si ya conoces el despliegue local de modelos, también puedes leer:

• Si quieres desplegar un LLM en local, lee la guía de Ollama para empezar con LLM local.

• Si quieres aprender técnicas de prompt, lee Prompt Engineering en práctica comercial.

• Si quieres optimizar la configuración local de GPU, lee configuración de aceleración GPU con Ollama.

• Si quieres integrar ComfyUI en procesos de automatización, lee automatización de workflows de IA en la práctica.