Si trabajas en VFX y te pica la curiosidad por llevar tus flujos de imagen generativa a otro nivel, ComfyUI es un imprescindible. Su enfoque por nodos, la modularidad y la potencia que añade FLUX lo convierten en un entorno ideal para explorar desde text2img de alta fidelidad hasta pipelines complejos con ControlNet, IP-Adapter o entrenamiento de LoRA. ComfyUI para VFX: instalación y flujos FLUX explicados.
En esta guía encontrarás, de forma ordenada, todo lo que necesitas: qué es un workflow en ComfyUI, cómo guardarlo y compartirlo, cómo instalar FLUX paso a paso, qué hardware necesitas, y una explicación clara de los flujos más usados (Txt2Img, Img2Img, Inpainting, LoRA, ControlNet, NF4, IPAdapter y escalado latente). También verás alternativas como FP8, NF4 o GGUF para reducir VRAM, recursos para usar Flux en la nube, y una instalación de ComfyUI optimizada para Windows con consejos prácticos.
Qué es un flujo de trabajo en ComfyUI
Un workflow es la representación visual del proceso de generación que construyes uniendo nodos. Puedes imaginarlo como un tablero de piezas tipo Lego: cada nodo cumple una función (cargar modelos, codificar texto, muestrear, decodificar, etc.) y las conexiones describen la ruta que sigue la información hasta obtener la imagen final.
El ecosistema es enorme: imagen fija, vídeo, audio y hasta 3D conviven gracias a la comunidad open source. La contrapartida es que hay curva de aprendizaje, porque conviene conocer qué hace cada bloque y cómo combinarlo bien para evitar cuellos de botella o resultados inconsistentes.
Para empezar rápido, lo ideal es mirar flujos oficiales y básicos (text2img e img2img) y avanzar después a nodos más complejos. La documentación comunitaria y los ejemplos oficiales de ComfyUI se actualizan con frecuencia, de modo que es fácil retomar o revisar workflows que cambian con nuevas versiones.
Un detalle relevante: ComfyUI puede incrustar el workflow en la propia imagen final (PNG) como metadata. Eso te permite compartir solo la imagen y recuperar el grafo completo arrastrándola de nuevo a la interfaz.
Cómo aprender y progresar con los workflows
Mi consejo es arrancar con ejemplos sencillos publicados en recursos tipo wiki y galerías de la comunidad. Una progresión lógica es: Txt2Img, Img2Img y, después, ControlNet o LoRA. Conforme entiendas entradas, salidas y cómo los planificadores afectan al muestreo, te será natural incorporar nodos de guía, máscaras y condicionamientos adicionales.
Si quieres ver topologías variadas, existen repositorios de flujos públicos y páginas con ejemplos reproducibles donde descargar imágenes con metadata o archivos .json. Es buena práctica importar, ejecutar tal cual, y luego iterar parámetros para entender el impacto de cada bloque sin romper el conjunto.
En plataformas en la nube también encontrarás entornos preconfigurados para ejecutar pipelines sin pelearte con dependencias locales. La ventaja es que precargan nodos y modelos pesados, aunque conviene revisar versiones y VRAM disponibles para que los resultados se ajusten a lo esperado.
Guardar, importar y exportar workflows en ComfyUI
ComfyUI soporta dos vías principales de guardado: imagen con metadata (PNG) o archivo Json del grafo. La primera es la más cómoda para compartir en foros; la segunda te da control explícito del archivo, útil para versionado.
Para importar, basta con arrastrar el PNG o el Json a la interfaz, o usar el atajo Ctrl (Command) + O. Para exportar, puedes guardar la imagen generada o usar el menú Export para el Json. Ojo si comprimes o transfieres imágenes: algunos métodos de compresión y ciertos canales eliminan metadata, con lo que perderías el workflow embebido.
Debido a la constante evolución de ComfyUI, no todos los Json antiguos funcionan en versiones nuevas. Si algo falla, abre el flujo, sustituye nodos obsoletos o reinstala dependencias con su versión compatible; usando ComfyUI-Manager es mucho más ágil detectar y resolver faltantes.
FLUX en ComfyUI: qué es y por qué importa
FLUX.1 es una familia de modelos de Black Forest Labs centrada en texto a imagen de alta fidelidad. Su arquitectura híbrida con aproximadamente 12 mil millones de parámetros está optimizada para adherencia a la prompt, manejo de escenas complejas y generación de texto legible dentro de la imagen, una tarea donde otros modelos suelen flaquear.
Otra baza: su versatilidad. Desde fotorrealismo a estilos artísticos, FLUX.1 destaca por la coherencia visual y el detalle, incluida la representación de manos, un clásico punto débil en generativos. No extraña que se compare con soluciones como Stable Diffusion o Midjourney, saliendo muy bien parado en facilidad de uso y calidad.
Black Forest Labs nace de la mano de Robin Rombach, figura clave que pasó por el núcleo de Stability AI. Si quieres echar un vistazo de primera mano, su web oficial está en blackforestlabs.ai.
FLUX.1 se distribuye en tres variantes: Pro, Dev y Schnell. Pro ofrece la máxima calidad para entornos profesionales; Dev está pensada para uso no comercial con un excelente equilibrio; Schnell se centra en velocidad y ligereza, y es open source bajo licencia Apache 2.0.
Requisitos de hardware por versión de FLUX
Para FLUX.1 Pro, se recomienda GPU tipo NVIDIA RTX 4090 con 24 GB de VRAM, 32 GB de RAM y SSD rápido. Utiliza FP16 para evitar OOM y conviene emplear el encoder de texto en fp16 para máxima calidad.
En FLUX.1 Dev, una RTX 3080/3090 con 16 GB de VRAM funciona bien, con 16 GB de RAM y unos 25 GB de disco. Acepta fp16 e incluso fp8 en algunos casos, según tu GPU.
Para FLUX.1 Schnell, RTX 3060/4060 con 12 GB de VRAM es suficiente, 8 GB de RAM y 15 GB de disco. Está diseñada para ir rápido sacrificando algo de techo de calidad respecto a Pro/Dev.
Si vas justo de memoria, la comunidad ofrece alternativas como FP8, NF4 o GGUF que rebajan mucho la VRAM necesaria, con configuraciones que arrancan desde 6 a 12 GB dependiendo del flujo.
Instalar FLUX en ComfyUI: pasos imprescindibles
Antes de nada, asegúrate de usar la versión más reciente de ComfyUI. Las integraciones de FLUX requieren nodos y funciones que se actualizan con frecuencia.
Descarga los codificadores de texto y CLIP: clip_l.safetensors y uno de los T5 XXL, t5xxl_fp16.safetensors (si tienes mucha VRAM/RAM) o t5xxl_fp8_e4m3fn.safetensors (si vas más justo). Colócalos en la carpeta ComfyUI/models/clip/. Si usaste SD3 Medium, quizá ya tengas estos archivos.
VAE: descarga ae.safetensors y muévelo a ComfyUI/models/vae/. Renómbralo si quieres a flux_ae.safetensors para localizarlo mejor. Este VAE mejora la decodificación final y es clave para calidad.
UNET: elige entre flux1-dev.safetensors o flux1-schnell.safetensors según tu memoria, y colócalo en ComfyUI/models/unet/. Con esto, tienes la base para correr flujos FLUX en local.
Guía práctica de workflows FLUX en ComfyUI
Txt2Img con FLUX
Arranca cargando los componentes: UNETLoader, DualCLIPLoader y VAELoader. El nodo CLIPTextEncode codifica tu prompt; EmptyLatentImage crea la latente inicial; BasicGuider guía el proceso combinando el condicionado con el UNET de FLUX.
Selecciona muestreador con KSamplerSelect, genera ruido con RandomNoise y define la rampa de sigmas con BasicScheduler. SamplerCustomAdvanced unifica todo: ruido, guía, muestreador, sigmas y latente. Finalmente VAEDecode convierte la latente en imagen y con SaveImage guardas el resultado.
Img2Img con FLUX
El pipeline suma una imagen de partida: LoadImage + ImageScale ajustan tamaño, y VAEEncode la pasa a latente. La prompt se codifica con CLIPTextEncode y se ajusta la fuerza con FluxGuidance. ModelSamplingFlux controla reespaciado y dimensiones, mientras que KSamplerSelect, RandomNoise y BasicScheduler gestionan el muestreo. SamplerCustomAdvanced fusiona el condicionado con la latente de entrada y VAEDecode produce la salida.
LoRA con FLUX
Para afinar estilo o rasgos, añade LoraLoaderModelOnly junto a UNETLoader, DualCLIPLoader y VAELoader. Tras codificar el texto y aplicar FluxGuidance, creas la latente con EmptyLatentImage, defines sampling con ModelSamplingFlux y ejecutas SamplerCustomAdvanced. Con VAEDecode obtienes la imagen ya influida por la LoRA. Ejemplo típico: realism_lora.safetensors sobre flux1-dev.
ControlNet con FLUX
Dos casos muy útiles para VFX: profundidad y bordes Canny. Para profundidad, preprocesa con MiDaS-DepthMapPreprocessor, carga el ControlNet de profundidad y aplícalo con ApplyFluxControlNet. Con XlabsSampler generas la latente condicionada y luego VAEDecode produce la imagen.
Para Canny, usa CannyEdgePreprocessor, carga el ControlNet de Canny y repite el esquema: ApplyFluxControlNet → XlabsSampler → VAEDecode. Este control adicional da precisión sobre forma y composición.
Inpainting con FLUX
Carga UNET, VAE y CLIP, y prepara prompts positivos y negativos. LoadAndResizeImage trae la imagen y la máscara; suaviza la transición con ImpactGaussianBlurMask. InpaintModelConditioning combina condicionamientos, imagen y máscara. Tras configurar muestreador, ruido y sigmas, SamplerCustomAdvanced reconstruye la región enmascarada. VAEDecode integra el parche de forma coherente con el resto.
FLUX NF4
Con cuantización NF4 se reduce memoria. Carga componentes con CheckpointLoaderNF4 y define altura/anchura con nodos primitivos. ModelSamplingFlux fija parámetros; EmptySD3LatentImage crea la latente; BasicScheduler y RandomNoise organizan el denoise. SamplerCustomAdvanced genera la latente y VAEDecode la traduce a imagen. Para escalar, UltimateSDUpscale junto a UpscaleModelLoader y un prompt positivo adicional marca la diferencia.
IPAdapter con FLUX
Cuando quieras condicionar por imagen de referencia, usa LoadFluxIPAdapter y ApplyFluxIPAdapter junto a clip_vision_l.safetensors. Escala la imagen de referencia con ImageScale, prepara prompts y ejecuta XlabsSampler. Con VAEDecode verás la salida influida por la estética o rasgos de la imagen guía.
Entrenador de LoRA para FLUX
Para entrenar una LoRA directamente en ComfyUI, el flujo incluye FluxTrainModelSelect, OptimizerConfig y TrainDatasetGeneralConfig. InitFluxLoRATraining inicializa, FluxTrainLoop ejecuta pasos, y FluxTrainValidate genera validaciones periódicas.
Con VisualizeLoss sigues la pérdida; ImageBatchMulti e ImageConcatFromBatch agrupan validaciones; FluxTrainSave guarda checkpoints y FluxTrainEnd cierra el proceso. Si quieres, sube el resultado a Hugging Face con UploadToHuggingFace y compártelo.
Flux Latent Upscaler
Para escalar con detalle, define el tamaño con SDXLEmptyLatentSizePicker+ y encadena LatentUpscale y LatentCrop. Con máscaras creadas por SolidMask y FeatherMask, LatentCompositeMasked mezcla la latente escalada con la original. InjectLatentNoise+ refuerza el detalle antes de VAEDecode, y un retoque con ImageSmartSharpen+ culmina el proceso. Nodos de cálculo como SimpleMath+ ayudan a cuadrar proporciones.
Versiones alternativas: FP8, NF4 y GGUF para bajar la VRAM
Si vas justo de recursos, tienes opciones. Los checkpoints FP8 de Comfy ORG y de autores como Kijai permiten usar FLUX con un único archivo en ComfyUI/models/checkpoints/. Es recomendable renombrar o separar en carpetas para distinguir variantes dev y schnell.
Con NF4 (bitsandbytes), instala el plugin ComfyUI_bitsandbytes_NF4 y usa flux1-dev-bnb-nf4-v2 en models/checkpoints. Esta versión mejora detalles respecto a la primera iteración.
La cuantización GGUF de City96, junto con el plugin ComfyUI-GGUF, baja aún más el listón: descarga el modelo FLUX GGUF, el encoder t5-v1_1-xxl-encoder-gguf, clip_l.safetensors y ae.safetensors, y colócalos en sus carpetas. Hay casos de uso cómodos con 6 GB de VRAM.
Usar FLUX.1 en la nube y otros recursos
Si prefieres no instalar nada, puedes probar FLUX en Hugging Face Spaces: FLUX.1-dev y FLUX.1-schnell. También en Replicate, Mystic.ai o fal.ai. Son opciones útiles para validar prompts y configuraciones antes de bajar modelos locales.
Para inspiración y flujos listos, revisa ejemplos oficiales de ComfyUI y galerías de workflows como OpenArt. Recuerda que muchas imágenes llevan metadata, así que puedes arrastrarlas a ComfyUI para recuperar el grafo.
Más material: colecciones de LoRA para FLUX como RealismLora o recopilaciones en XLabs-AI; ControlNet para FLUX como collections y Union; IP-Adapter en XLabs-AI. Para entrenar LoRA con baja VRAM, prueba fluxgym o el trainer de Replicate de Ostris; hay guía DreamBooth para FLUX.1 dev en el repo de diffusers.
Instalar ComfyUI en Windows 11 con rendimiento sólido
Si te apetece una instalación limpia, este es un camino probado. Funciona muy bien con tarjetas NVIDIA serie 40/50 y te evita errores típicos.
1) Instala la app de NVIDIA y el controlador Studio desde nvidia.com. Reinicia. 2) CUDA Toolkit desde developer.nvidia.com (opcional pero útil para evitar avisos con Triton si no usas venv). 3) ffmpeg desde el repo de BtbN y añade C:\ffmpeg\bin al Path. 4) Git para Windows desde git-scm.com. 5) Python 3.12 x64 desde python.org, con py launcher para todos los usuarios y añadir a variables de entorno.
5.5) Si optas por venv, créalo con python -m venv CUVenv y actívalo con CUVenv\Scripts\activate.bat. A partir de ahí, cualquier pip o git relevante ejecútalo dentro del venv. Tu script de arranque puede activar el entorno y ejecutar ComfyUI de un tirón.
6) Clona ComfyUI con git clone https://github.com/comfyanonymous/ComfyUI.git D:\CU. 7) Entra en D:\CU y ejecuta pip install -r requirements.txt. 8) Si pip avisa de scripts fuera de Path, añade la ruta de Scripts de Python a las variables de sistema y reinicia. 9) Instala PyTorch CUDA 12.8 con pip install torch torchvision torchaudio –index-url https://download.pytorch.org/whl/cu128. Si algo va raro, desinstala torch y vuelve a instalarlo con el mismo comando.
9 bis) Lanza ComfyUI con python main.py y abre 127.0.0.1:8188. 10) Instala Triton para Windows con pip install -U triton-windows. 11) Acelera atención con Sage Attention 2.2: descarga la wheel compatible cu128/torch2.8 para cp312, instálala con pip e inicia ComfyUI con el flag –use-sage-attention.
12) Instala ComfyUI-Manager: en ComfyUI/custom_nodes ejecuta git clone https://github.com/ltdrdata/ComfyUI-Manager comfyui-manager. 13) Crea un .bat de arranque con las líneas: cd D:\CU y python main.py –use-sage-attention. Al iniciar, Manager tardará un poco la primera vez; comprueba que aparece la pestaña Manager en la interfaz.
14) Coloca los modelos en carpetas correctas (checkpoints, clip, unet, vae) y abre tus flujos. Si un workflow trae su propio nodo de Sage, puedes omitirlo si ya arrancas con el flag. Consejos: evita tener programas pesados abiertos, configura memoria virtual de Windows si vas justo y revisa discusiones de rendimiento en el repo de ComfyUI. Si recibes avisos de memoria, plantéate usar la variante FP8 de archivo único.
Si prefieres un manual descargable, hay un PDF útil en este enlace. Algunas guías han sido revisadas para simplificar instalación y proponer venv; cuando uses venv, recuerda ejecutar siempre pip y git dentro del entorno.
Consejos de uso, compatibilidad y buenas prácticas
Importa flujos arrastrando PNGs con metadata o Json y comprueba versiones de nodos con Manager. Cuando compartas imágenes, evita compresiones que borren metadata. Si un Json rompe en una versión nueva, sustituye nodos obsoletos o instala versiones compatibles.
Para trabajar con varias LoRA de FLUX, hay informes de alto consumo en builds recientes de ComfyUI; prueba GGUF o loaders específicos para minimizar VRAM. En ControlNet, empieza por profundidad o Canny para asentar un rig de composición estable.
Al desplegar en nube, revisa la VRAM y las colas de ejecución. En local, un SSD rápido y drivers al día marcan la diferencia. Documenta tu pipeline por secciones: carga de modelos, condicionamientos, sampling, decodificación y post. Te facilitará el debug cuando algo se rompa.
Con todo lo anterior ya puedes montar un pipeline de VFX con ComfyUI realmente robusto: entiendes qué es un workflow y cómo guardarlo sin perder metadata, puedes instalar FLUX y sus variantes (Dev, Schnell y opciones FP8, NF4, GGUF), sabes ejecutar los flujos clave de la práctica diaria (Txt2Img, Img2Img, Inpainting, ControlNet, LoRA, IPAdapter y Upscale) y cuentas con una instalación de Windows optimizada con Triton, Sage Attention y ComfyUI-Manager para mantener el sistema fino, estable y rápido.