ComfyUI se ha convertido en 2026 en la forma estándar de generar imágenes con IA en tu propio ordenador. Es gratuito, de código abierto y funciona conectando nodos en un grafo visual, lo que al principio asusta y al cabo de una tarde se agradece: ves exactamente qué hace cada paso y puedes tocarlo. Esta guía va desde la instalación en limpio hasta un workflow de FLUX.2 funcionando, con los requisitos reales de VRAM, los nodos que de verdad importan, cómo llamarlo por API desde otro equipo y los errores con los que todo el mundo tropieza. Todo lo que hay aquí está probado en una RTX 4070 de portátil.
Respuesta rápida: ComfyUI es una interfaz de nodos, gratuita y open source, para ejecutar modelos de difusión en local. Se instala descargando el paquete portable de Windows o clonando el repositorio; el primer nodo personalizado que hay que instalar siempre es ComfyUI Manager. Con FLUX.2 [klein] 4B cuantizado en GGUF Q4_K_M necesitas unos 2,6 GB de modelo y una GPU de 8 GB; la variante 9B pide 16 GB en FP16 o 10-12 GB en GGUF Q4. El repositorio superó las 114.000 estrellas en GitHub en mayo de 2026 y publica una versión nueva cada dos semanas aproximadamente.
Qué es ComfyUI y por qué se ha impuesto
ComfyUI es una interfaz gráfica para modelos de difusión donde cada paso del proceso —cargar el modelo, codificar el texto, samplear, decodificar la imagen— es un nodo que conectas con cables a los demás. En lugar de un formulario con un botón, montas una tubería.
Esa decisión de diseño explica por qué ha desplazado a las alternativas más amigables. Cuando sale un modelo nuevo, ComfyUI suele soportarlo el mismo día, porque no hace falta rediseñar una interfaz: basta con añadir un nodo. Y como todos los pasos internos están expuestos, puedes hacer cosas que una interfaz cerrada no permite, como cambiar el sampler a mitad de generación o reutilizar un latente entre workflows.
El precio a pagar es la curva de entrada. La primera vez que abres ComfyUI y ves veinte cajas conectadas, la reacción normal es cerrarlo. La buena noticia es que un workflow de FLUX tiene ocho nodos y, una vez entiendes esos ocho, el resto es variación sobre el mismo tema.
Requisitos previos: VRAM y GPU que necesitas
Lo que manda aquí es la VRAM, la memoria de la tarjeta gráfica, no la RAM del sistema ni el procesador. Si el modelo no cabe en la GPU, o va por tandas a velocidad de tortuga o directamente no arranca.
| Modelo | Precisión | Tamaño en disco | VRAM necesaria | Pasos típicos |
|---|---|---|---|---|
| FLUX.2 [klein] 4B | GGUF Q4_K_M | ~2,6 GB | 8 GB | 4-8 |
| FLUX.2 [klein] 9B | GGUF Q4 | ~6 GB | 10-12 GB | 8-14 |
| FLUX.2 [klein] 9B | FP16 | ~18 GB | 16 GB | 8-14 |
| FLUX.1 [dev] | FP8 | ~12 GB | 12-16 GB | 20-28 |
La regla práctica que funciona: prueba primero en FP8 y baja a GGUF Q4 solo si no te cabe. Para tarjetas de 6 a 8 GB, la cuantización GGUF es lo que hace la diferencia entre poder y no poder; elige Q4_K_S en 6-8 GB y sube a Q5_K_S o Q8_0 si tienes algo más de margen.
En cuanto a tarjetas, para empezar sin gastar mucho una ASUS Dual RTX 5060 de 8 GB mueve klein 4B con soltura, que es donde la mayoría va a vivir. El salto realmente útil es a 16 GB: la ASUS Dual RTX 5060 Ti de 16 GB es la opción más barata que te quita el problema de la VRAM de encima, y la Gigabyte RTX 5070 Ti Gaming OC de 16 GB añade bastante velocidad de generación. En AMD, la Sapphire Pulse RX 9070 XT de 16 GB funciona, aunque el soporte de nodos personalizados va siempre un paso por detrás del de NVIDIA. Y si esto es tu trabajo y no tu hobby, la Gigabyte RTX 5090 de 32 GB te permite cargar el modelo en FP16 sin pensar. Tenemos la comparativa completa en la guía de mejores GPU para IA en local.
Antes de comprar: los precios de memoria y almacenamiento están disparados en 2026 y eso arrastra también a las gráficas, porque la GDDR sigue la misma curva. Lee nuestro análisis de la crisis de precios de RAM y SSD antes de encargar nada: en algunos casos compensa bajar un escalón de gama y meter el dinero en VRAM.
Paso 1: instalar ComfyUI
Hay dos caminos y la elección depende de tu sistema operativo.
Windows: paquete portable
Es la vía recomendada y no requiere instalar Python ni nada previo. Descarga el paquete portable desde las releases del repositorio oficial, descomprímelo donde tengas espacio (ocupa unos 5 GB antes de meter modelos) y arranca con el .bat correspondiente a tu tarjeta:
run_nvidia_gpu.bat # tarjetas NVIDIA
run_cpu.bat # sin GPU, muy lento, solo para probarSe abrirá el navegador en http://127.0.0.1:8188. Si ves el grafo de ejemplo, ya está funcionando.
Linux y macOS: clonar el repositorio
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
python main.pyEn macOS con Apple Silicon funciona por Metal, pero cuenta con generaciones bastante más lentas que en una NVIDIA equivalente.
Paso 2: ComfyUI Manager y nodos esenciales
Esto no es opcional. ComfyUI Manager es el primer nodo personalizado que debes instalar, siempre. Añade un gestor de paquetes integrado que te deja buscar, instalar, actualizar y eliminar los más de mil paquetes de nodos de la comunidad sin tocar la línea de comandos.
cd ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-ManagerReinicia ComfyUI y aparecerá un botón «Manager» en el panel lateral. A partir de ahí, cuando abras un workflow ajeno al que le falten nodos, el Manager te ofrece instalarlos automáticamente en vez de dejarte con un grafo lleno de cajas rojas.
Para lo que vamos a hacer aquí, el único paquete adicional imprescindible es ComfyUI-GGUF, que aporta el nodo UnetLoaderGGUF necesario para cargar modelos cuantizados. Instálalo desde el Manager buscando «GGUF».
Consejo: resiste la tentación de instalar veinte paquetes de nodos el primer día. Cada uno añade dependencias de Python y los conflictos entre versiones son la causa número uno de que ComfyUI deje de arrancar. Instala solo lo que un workflow concreto te pida.
Paso 3: descargar FLUX.2 y colocar los archivos
FLUX.2 no es un único archivo: son tres piezas que van en tres carpetas distintas. Este es el punto donde más gente se atasca, así que conviene tenerlo claro.
| Pieza | Qué es | Carpeta destino |
|---|---|---|
flux-2-klein-4b-Q4_K_M.gguf | El modelo de difusión (UNet) cuantizado | models/unet/ |
qwen_3_4b.safetensors | El codificador de texto que interpreta el prompt | models/clip/ |
flux2-vae.safetensors | El VAE que convierte el latente en píxeles | models/vae/ |
Un despiste habitual es dejar el .gguf en models/checkpoints/, que es donde van los modelos clásicos de Stable Diffusion. Ahí no lo encontrará: FLUX se carga con UnetLoaderGGUF, no con Load Checkpoint, y ese nodo solo mira en models/unet/.
Paso 4: el workflow FLUX nodo a nodo
Aquí está el grafo mínimo que genera una imagen con FLUX.2 [klein]. Son ocho nodos y cada uno hace una sola cosa:
- UnetLoaderGGUF — carga el modelo cuantizado desde
models/unet/. - CLIPLoader — carga el codificador de texto. Importante: el tipo debe ser
flux2, no el de Stable Diffusion. - VAELoader — carga el VAE de FLUX.2.
- CLIPTextEncode — convierte tu prompt en el tensor que entiende el modelo.
- EmptyFlux2LatentImage — crea el lienzo vacío con el ancho y alto de salida.
- KSampler — el que hace el trabajo: recibe modelo, prompt, latente y semilla, y ejecuta los pasos de difusión.
- VAEDecode — convierte el latente resultante en una imagen de verdad.
- SaveImage — la escribe en
output/.
Dos detalles del KSampler que no son obvios y que arruinan el resultado si los pones mal. El primero: con FLUX el CFG va a 1.0, no a los 7-8 habituales de Stable Diffusion; si lo subes, las imágenes salen quemadas. El segundo: klein está destilado para trabajar con muy pocos pasos, entre 4 y 8, y pasar de ahí no mejora la imagen, solo gasta tiempo. La combinación que mejor funciona es sampler euler con scheduler simple.
Como FLUX no usa prompt negativo real, la entrada negative del sampler se conecta al mismo nodo de texto que la positiva. Sorprende la primera vez, pero es lo correcto.
Si tu tarjeta tiene 8 GB o menos: reinicia ComfyUI cada 10-15 generaciones. La fragmentación de memoria se acumula y llega un punto en que el mismo workflow que funcionaba empieza a dar errores de memoria sin que hayas cambiado nada.
Paso 5: usar ComfyUI por API desde otro equipo
Esta es la parte que casi nadie cuenta y que más partido da. ComfyUI expone una API HTTP, así que la máquina que tiene la GPU no tiene por qué ser la misma en la que trabajas. En Arkaia generamos las imágenes de los artículos exactamente así: un script en Python que se ejecuta en una máquina virtual Linux sin GPU y encola trabajos contra el ComfyUI de un equipo Windows con una RTX 4070.
Para que sea accesible desde la red local hay que arrancarlo escuchando en todas las interfaces, porque por defecto solo atiende a 127.0.0.1:
python main.py --listen 0.0.0.0 --port 8188Y abrir el puerto en el firewall de Windows. A partir de ahí, tienes tres endpoints que cubren todo el ciclo:
| Endpoint | Método | Para qué sirve |
|---|---|---|
/system_stats | GET | Comprobar que está vivo y ver qué GPU tiene |
/prompt | POST | Encolar un workflow en JSON; devuelve un prompt_id |
/history/{id} | GET | Consultar si terminó y con qué imágenes |
/view | GET | Descargar la imagen generada |
El flujo es: haces POST del workflow, guardas el prompt_id, consultas /history/{id} cada dos segundos hasta que aparezcan las salidas, y descargas el resultado por /view. Se hace con la librería estándar de Python, sin instalar nada:
import json, urllib.request
cuerpo = json.dumps({"prompt": workflow}).encode()
req = urllib.request.Request(
"http://192.168.1.50:8188/prompt", data=cuerpo,
headers={"Content-Type": "application/json"})
pid = json.loads(urllib.request.urlopen(req).read())["prompt_id"]El JSON del workflow no hay que escribirlo a mano: en ComfyUI, activa «Enable Dev Mode Options» en los ajustes y aparecerá un botón Save (API Format) que exporta exactamente esa estructura. Si prefieres trabajar contra una API en la nube en vez de montar esto, tenemos el tutorial de la API de FLUX 3 y el análisis del modelo FLUX 3.
Errores comunes y cómo resolverlos
«CUDA out of memory» a mitad de generación
El modelo no cabe. Baja a una cuantización menor (de Q8 a Q5, o de Q5 a Q4), reduce la resolución de salida o cierra el navegador y los juegos, que también consumen VRAM. Si aparece después de varias generaciones correctas, es fragmentación: reinicia ComfyUI.
El nodo aparece en rojo y dice que no existe
Te falta el paquete de nodos personalizados que lo aporta. Abre el Manager, pulsa «Install Missing Custom Nodes» y te los instalará leyendo el propio workflow. Reinicia después.
Las imágenes salen quemadas o con colores imposibles
Casi siempre es el CFG. Con FLUX tiene que estar a 1.0. Si lo has dejado en el valor por defecto de Stable Diffusion, ese es el problema.
El modelo no aparece en el desplegable del loader
Está en la carpeta equivocada. Repasa la tabla del paso 3: el .gguf va en models/unet/, no en checkpoints. Después de mover archivos hay que refrescar la página del navegador.
Genera, pero tarda muchísimo
Comprueba que está usando la GPU y no la CPU. El endpoint /system_stats te dice qué dispositivo ha detectado; si ves cpu donde debería haber cuda:0, arrancaste con el .bat equivocado o falta el driver.
Material recomendado para generar imágenes en local
Más allá de la gráfica, hay dos componentes que se notan mucho más de lo que la gente espera. El primero es la RAM del sistema: ComfyUI descarga capas del modelo a memoria principal cuando no caben en la GPU, y con 16 GB eso se convierte en un cuello de botella inmediato. Un kit de 32 GB DDR5 a 6000 MHz CL30 es el mínimo cómodo, y si vas a encadenar varios modelos o trabajar con vídeo, los 64 GB en kit de 2×32 se agradecen.
El segundo es el almacenamiento, y aquí la gente subestima el problema: entre modelos base, VAEs, codificadores de texto y LoRAs, una instalación seria de ComfyUI se planta en varios cientos de gigas sin despeinarse, y cada carga de modelo lee gigabytes del disco. Un WD_BLACK SN850X de 2 TB con disipador es la opción segura, y el Samsung 990 EVO Plus de 2 TB cumple igual por algo menos. Ver precio actual en Amazon en cada enlace, que en 2026 cambian de semana en semana.
Preguntas frecuentes sobre ComfyUI
¿Qué es ComfyUI y para qué sirve?
ComfyUI es una interfaz gráfica gratuita y de código abierto para ejecutar modelos de difusión —generadores de imágenes por IA— en tu propio ordenador. Funciona conectando nodos en un grafo visual, donde cada nodo es un paso del proceso: cargar el modelo, codificar el prompt, samplear y decodificar la imagen. Se ha convertido en el frontend dominante en 2026 porque soporta los modelos nuevos el mismo día que salen.
¿Cuánta VRAM necesito para usar ComfyUI con FLUX?
Con FLUX.2 [klein] 4B cuantizado en GGUF Q4_K_M bastan 8 GB de VRAM, porque el modelo ocupa solo unos 2,6 GB. La variante de 9B necesita 16 GB en FP16 o entre 10 y 12 GB si la cuantizas a GGUF Q4. Para tarjetas de 6 a 8 GB, la cuantización GGUF es lo que marca la diferencia entre poder ejecutarlo o no.
¿ComfyUI es gratis?
Sí, es software libre y gratuito, y los modelos open weights como FLUX.2 [klein] también se descargan sin coste. Lo único que pagas es el hardware y la electricidad. No hay suscripción, ni límite de generaciones, ni las imágenes salen de tu equipo.
¿Por qué mi modelo GGUF no aparece en ComfyUI?
Porque casi con seguridad está en la carpeta equivocada. Los archivos .gguf de FLUX van en models/unet/ y se cargan con el nodo UnetLoaderGGUF, no en models/checkpoints/ con Load Checkpoint, que es donde van los modelos clásicos de Stable Diffusion. También necesitas tener instalado el paquete ComfyUI-GGUF desde el Manager.
¿Se puede usar ComfyUI desde otro ordenador?
Sí. Arráncalo con --listen 0.0.0.0 --port 8188 y abre ese puerto en el firewall; por defecto solo escucha en 127.0.0.1 y no lo ve nadie más. Después puedes usar tanto la interfaz web desde cualquier navegador de la red como la API HTTP: POST a /prompt para encolar, /history/{id} para consultar el estado y /view para descargar la imagen.
¿Qué CFG y cuántos pasos hay que poner con FLUX?
CFG a 1.0 y entre 4 y 8 pasos con klein. Es el error más frecuente al venir de Stable Diffusion, donde lo normal es CFG 7-8 y 20-30 pasos: si aplicas esos valores a FLUX, las imágenes salen quemadas y tardas el triple para nada. El sampler euler con scheduler simple es la combinación que mejor funciona.
¿Merece la pena ComfyUI frente a una web de pago?
Depende del volumen. Si generas cuatro imágenes al mes, una web de pago sale más barata y más cómoda. Si generas a diario, necesitas control fino sobre el proceso o trabajas con material que no quieres subir a un servidor ajeno, ComfyUI compensa desde el primer mes. Además no tiene censura de prompts ni límites de uso.
¿ComfyUI funciona con tarjetas AMD?
Sí, mediante ROCm en Linux y con soporte parcial en Windows, pero el ecosistema está claramente orientado a NVIDIA: muchos nodos personalizados asumen CUDA y tardan en dar soporte a AMD, cuando lo dan. Si tu objetivo principal es generar imágenes en local, una NVIDIA te ahorrará bastantes tardes de depuración.
Conclusión
ComfyUI parece intimidante durante la primera hora y deja de serlo en cuanto entiendes que un workflow de FLUX son ocho nodos encadenados. Lo importante es acertar con tres cosas: que el modelo quepa en tu VRAM —con GGUF Q4 casi cualquier tarjeta de 8 GB sirve—, que cada archivo esté en su carpeta, y que el KSampler vaya a CFG 1.0 con pocos pasos.
Y cuando lo tengas funcionando, no te quedes en la interfaz web. Abrirlo a la red y llamarlo por API convierte tu PC con GPU en un servicio de generación de imágenes al que puedes pedirle trabajo desde cualquier script, cualquier equipo y cualquier sistema operativo. Es, con diferencia, lo que más rendimiento saca a la inversión en hardware.
Este artículo contiene enlaces afiliados a Amazon con el tag webmasteroson-21. Si compras a través de estos enlaces, Arkaia puede recibir una comisión sin coste adicional para ti. Nuestra valoración editorial es independiente y no varía según los ingresos por afiliación.
Comentarios
Inicia sesion para dejar un comentario
Acceder
