Generar imágenes en tu PC con Stable Diffusion y ComfyUI

Generar imágenes en local con Stable Diffusion ya no es un proyecto de fin de semana con veinte errores de Python por medio. Necesitas una gráfica decente, disco libre y ComfyUI, la interfaz por nodos que se ha convertido en el estándar de facto. Aquí tienes qué hardware hace falta de verdad, cómo se monta el flujo mínimo pieza a pieza y en qué momento conviene reconocer que la nube te sale mejor.

Qué necesitas para generar imágenes en local con Stable Diffusion

La lista corta de requisitos es esta:

• Una GPU NVIDIA con CUDA. Es el camino cómodo. Todo lo demás funciona, pero con asteriscos.
• VRAM suficiente. Es el cuello de botella real. Con 8 GB haces cosas, con 12 GB vives tranquilo y con 16 GB o más dejas de pensar en ello.
• RAM del sistema. 16 GB es el mínimo razonable y 32 GB te evita atascos cuando el modelo se descarga a memoria principal.
• SSD con espacio. Un checkpoint de SDXL ocupa varios gigas. Los modelos grandes de generación reciente ocupan bastante más. Entre modelos base, LoRA y ampliadores, 100 GB desaparecen antes de lo que crees.

Con AMD la historia es distinta según el sistema: en Linux funciona por ROCm, en Windows la ruta habitual es más lenta y más frágil. En Mac con chip Apple funciona por MPS y la memoria unificada juega a favor, pero la velocidad no se acerca a la de una gráfica dedicada equivalente. Si estás decidiendo qué comprar antes de montar nada, la comparativa de qué GPU NVIDIA RTX necesitas para IA en local te ahorra el error clásico de pagar por potencia de cálculo cuando lo que te faltaba era memoria.

Una nota importante: la VRAM no se comparte. Si tienes el navegador con veinte pestañas y un juego minimizado, esa memoria no está disponible para el modelo. En una tarjeta justa, cerrar cosas es literalmente parte del flujo de trabajo.

Cómo funciona por dentro un generador de imágenes

Entender esto en cinco minutos hace que los nodos de ComfyUI dejen de parecer un jeroglífico.

El modelo no dibuja. Parte de un cuadro de ruido aleatorio y lo va limpiando paso a paso hasta que ese ruido se parece a lo que le has pedido. Cada paso es una predicción de "qué parte de esto es ruido" y una resta.

Ese proceso no ocurre sobre píxeles, sino sobre una versión comprimida de la imagen llamada espacio latente, mucho más barata en memoria. Por eso al final del flujo hay siempre un paso de decodificación: el VAE traduce ese latente a los píxeles que acabas viendo.

Y para saber hacia dónde limpiar el ruido, el modelo necesita entender tu texto. De eso se encarga el codificador de texto (CLIP en las familias clásicas, modelos de lenguaje más grandes en las generaciones recientes), que convierte tu prompt en algo que guía cada paso.

Resumido: texto codificado + ruido latente + muchos pasos de limpieza + decodificación VAE = imagen. Los nodos del flujo básico son exactamente esas piezas puestas en fila.

Instalar ComfyUI sin romperlo

Hay tres formas de instalarlo, de menos a más control.

1. Aplicación de escritorio. Un instalador normal, para no tocar terminal.
2. Paquete portable para Windows. Un comprimido con su propio Python dentro. Lo descomprimes, ejecutas el archivo de arranque de tu gráfica y listo. No ensucia el Python del sistema, que es la principal causa de desastres.
3. Instalación manual desde el repositorio. Más trabajo y más control, la que querrás si actualizas a menudo.

Para la vía manual, el guion es siempre el mismo:

# entorno aislado, con una versión reciente de Python 3
python -m venv venv

# activar el entorno
venv\Scripts\activate      # Windows
source venv/bin/activate   # Linux y Mac

# PyTorch con soporte CUDA: usa el comando que genera el selector
# oficial de PyTorch, porque el paquete por defecto puede venir
# sin aceleración

# dependencias del proyecto
pip install -r requirements.txt

# arrancar
python main.py

Al arrancar te abre una interfaz web en tu propia máquina, normalmente en el puerto 8188. No sale nada a internet salvo cuando descargas modelos o nodos nuevos.

Lo siguiente es colocar los archivos donde toca. La estructura de carpetas manda y es tan simple como esto:

ComfyUI/
  models/
    checkpoints/      modelos base
    loras/            estilos y conceptos añadidos
    vae/              decodificadores
    controlnet/       guías de composición
    upscale_models/   ampliadores
  custom_nodes/       extensiones
  output/             tus imágenes

Dos consejos que evitan la mayoría de sustos. Primero, instala ComfyUI Manager: es la extensión que gestiona nodos de terceros, detecta los que faltan al abrir un flujo ajeno y los instala por ti. Segundo, descarga siempre modelos en formato .safetensors y no .ckpt. El formato antiguo puede ejecutar código al cargarse; el nuevo no.

El flujo de nodos mínimo, nodo a nodo

Cuando abres ComfyUI por primera vez ya tienes cargado el flujo por defecto. Conviene leerlo de izquierda a derecha:

1. Load Checkpoint. Carga el modelo base y saca tres salidas: el modelo en sí, el codificador de texto y el VAE.
2. CLIP Text Encode (positivo). Aquí va lo que quieres ver.
3. CLIP Text Encode (negativo). Aquí lo que no. En modelos modernos destilados este nodo pierde relevancia y a veces se deja vacío.
4. Empty Latent Image. Define el lienzo: ancho, alto y cuántas imágenes por lote.
5. KSampler. El corazón. Recibe modelo, prompt positivo, prompt negativo y latente, y ejecuta los pasos de limpieza.
6. VAE Decode. Traduce el latente a píxeles reales.
7. Save Image. Guarda el resultado en la carpeta output.

Le das a la cola de ejecución y en unos segundos tienes imagen. La gracia del sistema es que cada nodo es una caja con entradas y salidas: puedes insertar cosas en medio, duplicar ramas o construir cadenas de varios pasos sin tocar una línea de código.

Detalle muy útil y poco conocido: los PNG que genera ComfyUI llevan el flujo entero incrustado en los metadatos. Si arrastras una imagen tuya de hace tres meses sobre la interfaz, se reconstruye el flujo exacto con el que la hiciste. Te da control de versiones sin montar nada, siempre que no pases las imágenes por un compresor que borre metadatos.

Qué modelo elegir y cuánta VRAM te va a pedir

No hay un modelo "mejor". Hay familias con compromisos distintos entre calidad, velocidad y memoria.

Las cifras son orientativas y de referencia comunitaria, no una promesa. Dependen de la resolución que pidas, del tamaño del lote y de los extras que encadenes. Si quieres el mapa completo de memoria por tipo de modelo, incluidos los de lenguaje, está desarrollado en la tabla de cuánta VRAM necesita cada modelo de IA.

Dos trucos hacen que una tarjeta modesta llegue mucho más lejos de lo que sugiere la tabla. Uno es la cuantización: versiones del modelo con menos precisión numérica (fp8, o formatos tipo GGUF con nodos específicos) que ocupan bastante menos a cambio de una pérdida de calidad que en muchos casos no vas a notar. El otro es el descargado a RAM: ComfyUI mueve partes del modelo a memoria del sistema cuando no caben en la gráfica, y existen parámetros de arranque como --lowvram para forzarlo. Funciona, pero cada intercambio entre RAM y VRAM cuesta tiempo, así que la imagen tarda más.

Los ajustes que de verdad cambian el resultado

En el KSampler hay un puñado de parámetros y solo unos pocos merecen tu atención diaria.

• Steps (pasos). Entre 20 y 30 cubre casi todo en las familias clásicas. Los modelos destilados de pocos pasos, como Schnell, están diseñados para trabajar con cuatro. Dispararlos a 80 rara vez aporta algo y multiplica el tiempo de espera.
• CFG. Cuánto obliga al modelo a obedecer tu prompt. Valores medios (alrededor de 5 a 8 en SDXL) dan resultados naturales. Muy alto quema colores y satura; muy bajo ignora lo que pediste. Flux Dev funciona distinto: se deja el CFG en 1 y se controla con un nodo de guía propio.
• Sampler y scheduler. Un dpmpp_2m con planificador karras es un punto de partida sólido para SD y SDXL. Para Flux, euler con planificador simple. Cambiar de sampler altera el resultado aunque mantengas la semilla.
• Semilla. El número que fija el ruido inicial. Fíjala cuando quieras iterar sobre una composición concreta y déjala aleatoria cuando estés explorando.
• Denoise. En generación desde texto va a 1. Cuando partes de una imagen existente, bajarla a la franja de 0,4 a 0,6 conserva la composición original y solo reinterpreta el estilo.
• Resolución. Respeta la nativa del modelo. Pedirle 512 px a SDXL da resultados pobres, y pedirle 2048 px de una tacada suele producir cuerpos duplicados y composiciones rotas. Para tamaños grandes, genera en nativo y amplía después.

LoRA, ControlNet y ampliado: cuando el flujo básico se queda corto

Aquí es donde ComfyUI se separa del resto de interfaces, porque encadenar estas piezas es cuestión de arrastrar un cable.

Un LoRA es un archivo pequeño que se aplica sobre el modelo base para enseñarle un estilo, un personaje o un objeto concreto. Se inserta con un nodo entre el checkpoint y el sampler, y se le da un peso. Varios LoRA a la vez se pelean entre sí, así que empieza con uno y con peso moderado.

ControlNet es la respuesta a "la imagen está bien pero quiero esta pose exacta". Le pasas una imagen de referencia, se extrae de ella una estructura (pose, profundidad, bordes) y el modelo genera respetándola. Es la diferencia entre pedir y dirigir. Si tu referencia está dentro de un vídeo, lo práctico es bajar el archivo con Daun y sacar el fotograma exacto que necesitas antes de meterlo en el flujo.

El ampliado es el paso final que casi todo el mundo se salta. Generas a resolución nativa, pasas la imagen por un modelo de ampliación y opcionalmente la reprocesas con un denoise bajo para recuperar detalle fino. En calidad percibida suele notarse más que cambiar de checkpoint.

Y el inpainting, repintar solo una zona con máscara, resuelve la mayoría de los casos en los que una imagen es casi perfecta salvo por una mano rara o un texto ilegible.

Qué se rompe y cuándo no merece la pena

Seamos honestos con los problemas reales:

• Error de memoria (out of memory). El más común. Baja la resolución, reduce el lote a una imagen, cierra el navegador o arranca con --lowvram. Si aun así falla, tu tarjeta no da para ese modelo.
• Imágenes negras o con manchas. Suele ser un problema de precisión numérica en el decodificador. Cargar un VAE corregido aparte, en vez del que trae el checkpoint, lo arregla casi siempre.
• Flujos ajenos que no abren. Les faltan nodos de terceros. ComfyUI Manager los detecta e instala, pero a veces la versión ya no es compatible.
• Actualizaciones que rompen cosas. Actualizar ComfyUI y treinta nodos personalizados a la vez es la forma más rápida de perder una tarde. Actualiza cuando necesites algo, no por deporte.
• El tiempo. Este es el coste oculto. Montar el entorno, encontrar los modelos y aprender a dirigir el prompt son horas. La generación en sí es barata; el aprendizaje no.

Por eso hay casos claros en los que no deberías montar nada. Si lo que necesitas es una imagen suelta cada varios días, o una portada para un vídeo, un generador en la nube te lo resuelve en un minuto sin instalar nada; el flujo concreto está en la guía de cómo generar miniaturas para YouTube con ChatGPT. Lo local gana cuando produces en volumen, cuando necesitas un estilo propio consistente, cuando trabajas con material que no quieres subir a ningún servidor o cuando quieres control fino sobre la composición.

Y si tu objetivo final no era una imagen fija sino movimiento, ten en cuenta que ComfyUI también ejecuta modelos de vídeo, con exigencias de memoria y tiempo bastante superiores. Antes de meterte en ese terreno, merece la pena ver el panorama en herramientas de IA para producir vídeo corto y decidir qué parte del proceso compensa hacer en casa.

Preguntas frecuentes

¿Puedo hacerlo con 8 GB de VRAM?

Sí, con concesiones. SD 1.5 va sobrado y SDXL funciona bien a 1024 px si generas de una en una y no encadenas demasiadas cosas. Los modelos grandes de generación reciente solo entran en versiones cuantizadas y con descarga a RAM, lo que significa esperar más por imagen. Es perfectamente usable para aprender y para producir a ritmo tranquilo.

¿Necesito conexión a internet para generar?

No. Una vez descargados los modelos y los nodos, todo el proceso ocurre en tu máquina y funciona sin red. Solo necesitas conexión para actualizar, instalar extensiones o bajar checkpoints nuevos.

¿Puedo usar comercialmente lo que genero?

Depende del modelo, no de ComfyUI. Cada familia y cada versión trae su propia licencia, y varían bastante: algunas son permisivas, otras restringen el uso comercial y otras dependen del tipo de proyecto. Léela antes de usar el resultado en un trabajo de cliente. Lo mismo aplica a los LoRA que descargues, que llevan sus propias condiciones.

¿ComfyUI o una interfaz clásica de formulario?

Si vienes de cero y solo quieres escribir un prompt y pulsar un botón, una interfaz de formulario es más amable el primer día. ComfyUI cuesta más al principio y compensa después: encadenar pasos, reutilizar flujos, generar por lotes y reproducir exactamente un resultado antiguo son cosas que ahí se hacen solas. Si vas en serio, el tiempo invertido en entender los nodos se recupera rápido.