Skip to content

FLUX.2: consistencia multirreferencia de Dev y versión ligera Klein ​

FLUX.2 es el modelo de imágenes de nueva generación de Black Forest Labs: salida fotográfica de hasta 4 MP, con mejoras integrales en luz, piel, tejidos y detalles de las manos. Eleva la «una imagen de referencia» de FLUX.1 a la consistencia multirreferencia—hasta 10 imágenes de referencia—manteniendo coherentes personajes, geometría de producto, materiales y vestuario a lo largo de múltiples salidas; el renderizado de texto también alcanza nivel profesional, capaz de escribir tipografía limpia y legible en capturas de UI, infografías y contenido multilingüe.

ComfyUI ofrece aquí dos opciones: FLUX.2 Dev (versión completa de código abierto, con los mejores resultados) y FLUX.2 [Klein] (versión ligera, una sola arquitectura que unifica texto-a-imagen y retoque, la versión destilada de 4B genera en 4 pasos y usa unos 8.4 GB de memoria de vídeo). Esta página ejecuta ambos flujos de trabajo FLUX.2.

Qué podrás hacer al terminar ​

  • Ejecutar el flujo de trabajo multirreferencia de FLUX.2 Dev: carga de plantilla → colocación del trío → edición con consistencia multirreferencia y generación de imágenes
  • Colgar múltiples imágenes de referencia en la condición con la cadena ReferenceLatent: boceto de diseño + foto de producto → estampar el diseño sobre el objeto real
  • Cambiar a la versión ligera FLUX.2 Klein 4B: generación en 4 pasos con la versión destilada, ejecutable en local con memoria de vídeo a nivel de 8 GB
  • Distinguir los dos sistemas de pesos: el nivel de cuantización fp8mixed de Dev vs los tipos base y distilled de Klein 4B/9B, para no volver a descargar el archivo equivocado
  • Recordar las diferencias de nodos entre FLUX.2 y FLUX.1: el CLIPLoader de un solo codificador (type flux2) sustituye al DualCLIPLoader

Tu situación actual ​

  • Quieres cambiar el embalaje de un producto: un boceto de diseño y una foto de producto, pero la imagen-a-imagen normal solo «promedia» las dos imágenes en algo irreconocible
  • Generas 10 imágenes del mismo personaje y en cada una cambian la cara, el vestuario y el estilo: la consistencia depende de la suerte
  • Has oído que FLUX.2 da buenos resultados, pero al ver que el modelo pesa 33 GB, no sabes si tu tarjeta podrá con él

Cuándo usar esta técnica ​

Cuando necesitas:

  • Consistencia multirreferencia: combinar en una sola imagen múltiples referencias de personaje + vestuario + escenario, tomando lo mejor de cada una
  • Renderizado de texto profesional: tipografía grande de póster, interfaces UI y marcas de envases deben ser limpias y legibles
  • Colores de marca hex exactos: especificar el código de color sin que la paleta de salida se desvíe
  • La calidad de FLUX.2 también con hardware modesto: Klein 4B funciona con 8.4 GB de memoria de vídeo

Y además no quieres:

  • Perder las características de las imágenes de referencia cada vez—la referencia única de FLUX.1 Kontext no aguanta la composición multirreferencia
  • Pagar una API en la nube por una sola imagen—Dev y Klein son de código abierto y se ejecutan en local

🎒 Preparativos antes de empezar ​

  • Has completado texto-a-imagen con FLUX.1: el patrón de loaders de la familia FLUX y el consenso de «no usar prompt negativo» están en esa lección
  • Sabes cargar plantillas y ejecutar con Ctrl+Enter (si no lo recuerdas, revisa la primera generación)
  • Ya dominas las reglas del directorio de modelos: colocarlos en el subdirectorio correspondiente bajo models/ (revisa dónde van los modelos)
  • ComfyUI actualizado a 0.4.0 o superior (la versión mínima indicada en la plantilla oficial de FLUX.2 Dev; la plantilla de Klein exige 0.3.72 o superior)
  • Espacio en disco reservado: la versión completa de Dev ocupa unos 66 GB (incluidos 33 GB de codificadores de texto); cambiando a codificadores de texto fp8 para ahorrar espacio, unos 50 GB; solo Klein 4B, unos 12 GB
  • Red con acceso a Hugging Face; si la conexión es inestable, usa el espejo nacional de ModelScope (direcciones en el paso 2)
  • Una taza de agua ☕—la descarga del modelo de Dev es la mayor espera de esta lección

Idea central ​

FLUX.2 se divide en dos ramas a nivel de modelo, y el flujo de trabajo también se divide en dos conjuntos:

RamaPosicionamientoModelo de difusiónPasos
FLUX.2 Dev (código abierto, completo)Techo de calidad: fotográfico a 4MP, consistencia multirreferencia, renderizado profesional de texto(flux2_dev_fp8mixed, 33.02GB, pesos cuantizados en fp8; los pesos completos están en el repositorio original de BFL)20
FLUX.2 [Klein] (ligero)Interactivo y de baja latencia: una sola arquitectura unifica texto-a-imagen y ediciónEn dos niveles, 4B / 9B, cada uno con dos variantes: base (sin destilar) y distilled (destilada)Destilada 4 pasos, base 20 pasos

FLUX.2 Pro es la versión API de Black Forest Labs, no es de código abierto; lo que se puede ejecutar localmente son las dos ramas de la tabla anterior.

Cómo se integra la consistencia multirreferencia en el flujo de trabajo: el nodo ReferenceLatent codifica las imágenes de referencia en un latent y lo «cuelga» en la cadena de condicionamiento (conditioning). La condición sale de FluxGuidance, pasa por ReferenceLatent y entra en BasicGuider; para añadir una segunda imagen de referencia, se encadena otro ReferenceLatent desde la salida de condición del anterior. A nivel de modelo se admiten hasta 10 imágenes de referencia, y así personajes, geometría de productos, materiales y ropa se mantienen consistentes entre salidas.

Comparado con la cadena de nodos que viste en FLUX.1 texto-a-imagen, FLUX.2 cambia tres piezas clave:

EtapaFLUX.1 (plantilla Dev texto-a-imagen)FLUX.2 (plantilla Dev de edición)
Codificador de textoDualCLIPLoader: dos archivos, clip_l + t5xxlCLIPLoader: un solo archivo mistral, type se elige flux2
Muestreo/programaciónKSampler un nodo lo cubre todoFlux2Scheduler (pasos + ancho y alto) + SamplerCustomAdvanced configurados por separado
Latent vacíoEmptySD3LatentImageEmptyFlux2LatentImage
Imagen de referenciaKontext una sola imagen de referenciaReferenceLatent en cadena, varias (hasta 10)

Datos de rendimiento oficiales de Klein (RTX 5090):

VersiónPasosMemoria de vídeoTiempo de extremo a extremo
Klein 4B distilled48.4GB~1.2s
Klein 4B base209.2GB~17s

Selección en una frase: si buscas calidad, usa Dev; si buscas velocidad, Klein distilled; si quieres hacer tu propio fine-tuning, Klein base.

Hazlo conmigo ​

Paso 1: cargar la plantilla oficial de FLUX.2 Dev ​

Por qué: la plantilla oficial ya trae configurados la cadena de nodos, los parámetros y los enlaces de modelos; solo tenemos que poner el material dentro.

Operación: abre la biblioteca de plantillas desde Templates en la barra lateral izquierda, busca FLUX.2 y elige «FLUX.2 Dev» (nombre de plantilla image_flux2, requiere ComfyUI 0.4.0 o superior). Si no quieres usar la biblioteca de plantillas, también puedes descargar image_flux2.json y abrirlo manualmente. El uso completo de la biblioteca de plantillas se explica en biblioteca de plantillas.

En el lienzo hay una cadena principal de tres tramos: LoadImage → (ImageScaleToTotalPixels primero escala la imagen a 1MP) → subgrafo «Image Edit (FLUX.2 Dev)» → SaveImage. Sube la imagen de ejemplo oficial image_flux2_input_image.png (la foto de una señora) al nodo LoadImage 46, o reemplázala directamente por tu propia imagen.

Deberías ver: cuando faltan modelos, los nodos del subgrafo se marcan en rojo y la pestaña Errors de la derecha lista los modelos pendientes de descarga; no te preocupes, en el paso 2 se irán completando uno a uno.

  • Plantilla cargada con éxito; en LoadImage puedes ver la imagen que subiste

Paso 2: descargar los tres componentes del flujo de trabajo de FLUX.2 y colocarlos en su sitio ​

Por qué: la plantilla solo referencia nombres de archivo; hay que descargar los archivos de modelos uno mismo y colocarlos en el subdirectorio correspondiente de models/ para que los nodos no se marquen en rojo.

Operación: descarga según la siguiente lista (nombres de archivo y tamaños copiados tal cual de la anotación Model links en el lienzo de la plantilla):

ArchivoUbicaciónTamañoEnlace de descarga
flux2_dev_fp8mixed.safetensorsmodels/diffusion_models/33.02 GBHugging Face
mistral_3_small_flux2_bf16.safetensorsmodels/text_encoders/33.14 GBHugging Face
full_encoder_small_decoder.safetensorsmodels/vae/238 MBHugging Face
Flux_2-Turbo-LoRA_comfyui.safetensors (opcional)models/loras/2.57 GBHugging Face

¿Hugging Face no conecta bien? Los tres archivos del Dev están en el repositorio de Comfy-Org, usa el espejo nacional: ModelScope: Comfy-Org/flux2-dev. También puedes hacer clic uno por uno en Download en la pestaña Errors a la derecha de la plantilla.

⚠️ Con el VAE, no copies sin más la lista de la página del tutorial oficial

La lista de Model links de la página del tutorial oficial indica flux2-vae.safetensors (320.6MB), pero la plantilla FLUX.2 Dev en realidad carga full_encoder_small_decoder.safetensors (238MB, del repositorio FLUX.2-small-decoder de BFL). La lista de descargas debe basarse en la nota Model links dentro del lienzo de la plantilla; de lo contrario, no podrás seleccionar el archivo en el menú desplegable de VAELoader. flux2-vae.safetensors es el que se usa más adelante en las plantillas Klein y Product Mockup.

Opción para ahorrar espacio: el codificador de texto se puede sustituir por la versión fp8 mistral_3_small_flux2_fp8.safetensors (16.8GB, 16GB menos de disco; la plantilla Product Mockup del paso 6 usa precisamente esa); basta con seleccionar el nombre de archivo correspondiente en CLIPLoader.

Deberías ver: en los menús desplegables de los tres loaders (UNETLoader / CLIPLoader / VAELoader) se puede seleccionar el archivo correspondiente y los nodos ya no se marcan en rojo.

  • Los tres archivos en su sitio, la plantilla sin errores en rojo

Paso 3: entiende la cadena de nodos de FLUX.2 ​

Por qué: sabiendo la posición de cada nodo en la cadena, cuando haya un error sabrás dónde buscar; además, este es el eslabón con mayor diferencia entre FLUX.2 y FLUX.1.

Operación: haz doble clic en el subgrafo «Image Edit (FLUX.2 Dev)» para entrar en su interior y, comparando con la tabla de diferencias de la idea central, localiza las cuatro ramas:

  • Zona del modelo: UNETLoader (modelo de difusión) + CLIPLoader (mistral, con type en flux2) + VAELoader
  • Cadena de condicionamiento: CLIPTextEncode (prompt positivo) → FluxGuidance (4) → ReferenceLatent → BasicGuider
  • Imagen de referencia: en el lienzo, la imagen de entrada primero se reduce con ImageScaleToTotalPixels a 1MP, y al entrar en el subgrafo VAEEncode la codifica como latent y la conecta a la entrada latent de ReferenceLatent
  • Tamaño y planificación: GetImageSize lee el ancho y alto de la imagen de entrada y los pasa a la vez a EmptyFlux2LatentImage (latent vacío) y a Flux2Scheduler (20 pasos, salida SIGMAS) — el tamaño de salida sigue a la imagen de entrada

Dentro del subgrafo hay además un interruptor «Enable 8 steps lora» (desactivado por defecto): al activarlo, se monta automáticamente el Turbo LoRA descargado en el paso 2 y los pasos pasan de 20 a 8; se usará en la sección de técnicas avanzadas.

Deberías ver: que puedes señalar con tus propias manos las dos entradas de ReferenceLatent — el conditioning viene de FluxGuidance y el latent recibe el VAEEncode de la imagen de referencia.

  • Que puedes decir el orden de la cadena de condicionamiento: prompt → FluxGuidance → ReferenceLatent → BasicGuider

Paso 4: escribe el prompt y genera una imagen editada con consistencia ​

Por qué: el prompt de edición de FLUX.2 Dev es descriptivo — describe directamente la imagen final que quieres y luego declara las partes a conservar, a diferencia del retoque tradicional por instrucciones del tipo «añade el gorro».

Operación: el prompt de ejemplo oficial ya está rellenado en la plantilla; obsérvalo para captar su estructura:

text
The woman is wearing a small pale yellow knitted beanie, with a white fabric
patch on the front right, embroidered with big gray text "FLUX.2 COMFY."
Keep the face

Desglosado son tres partes: describir el objeto nuevo (gorro de lana amarillo claro + parche de tela blanco + letras grandes grises) → indicar la posición (front right) → fijar lo que se conserva (Keep the face). El renderizado de texto es el punto fuerte de FLUX.2, y el «FLUX.2 COMFY» del parche será realmente legible.

Ejecuta con Ctrl+Enter.

Deberías ver: la barra de progreso completa los 20 pasos, y en la salida la señora lleva un gorro de lana amarillo claro, el texto «FLUX.2 COMFY» del parche es claramente legible y el rostro coincide con la imagen original.

¿Quieres montar una segunda imagen de referencia (multi-referencia de verdad)? Encadena otro ReferenceLatent desde la salida de condicionamiento del ReferenceLatent existente, y conecta el puerto latent del nuevo nodo al VAEEncode de la segunda imagen. Si no quieres conectar cables a mano, la plantilla Product Mockup del paso 6 ya tiene las dos imágenes de referencia conectadas; mira directamente cómo lo hace.

  • En la imagen de salida, el objeto nuevo, el texto y el rostro conservado se cumplen los tres a la vez

Paso 5: cambia a Klein 4B versión ligera (versión destilada, imagen en 4 pasos) ​

Por qué: los tres archivos del Dev ocupan unos 66GB y generar en 20 pasos es lento; la versión destilada de Klein 4B ocupa unos 12GB de disco, con 4 pasos y 8.4GB de VRAM, ideal para vistas previas rápidas y retoque interactivo.

Operación: busca FLUX.2 Klein en la biblioteca de plantillas y elige «FLUX.2 [Klein] 4B Distilled: Image Edit» (nombre de plantilla image_flux2_klein_image_edit_4b_distilled, requiere ComfyUI 0.3.72 o superior). Los tres archivos de Klein y los del Dev son completamente distintos:

ArchivoUbicaciónTamañoEnlace de descarga
flux-2-klein-4b-fp8.safetensorsmodels/diffusion_models/3.79 GBHugging Face
qwen_3_4b.safetensorsmodels/text_encoders/7.49 GBHugging Face · ModelScope
flux2-vae.safetensorsmodels/vae/320.6 MBHugging Face · ModelScope

Ten en cuenta que esta vez el VAE es flux2-vae.safetensors: es el que usa la plantilla Klein. El modelo de difusión está en el repositorio de BFL, y la nota de la plantilla no indica un espejo nacional; tanto el codificador de texto como el VAE pueden descargarse desde ModelScope.

La plantilla incluye ejemplos oficiales: handbag_white.png (nodo 76, bolso blanco) y comfy_logo_blue.png (nodo 81, logo azul de Comfy). La plantilla trae dos rutas preconectadas:

  • Habilitada por defecto (cambio de color con una sola imagen de referencia): prompt Change the bag color to blue., el bolso se vuelve azul
  • En bypass por defecto (múltiples referencias con dos imágenes): prompt stylize the handbag in image1 with the colours and logo from image 2: se usan image1 / image 2 para referirse a las dos imágenes de referencia, aplicando la paleta de colores y el logo de la etiqueta azul al bolso blanco

Primero ejecuta la ruta por defecto con Ctrl+Enter; si quieres ver el efecto de múltiples referencias, cambia la ruta en bypass de vuelta a habilitada y vuelve a ejecutar. El planificador es Flux2Scheduler: 4 pasos, ancho y alto por defecto 1024×1024, muestreo euler.

Deberías ver: el muestreo de 4 pasos se completa en segundos (dato oficial: en 5090, extremo a extremo en unos 1.2s), el bolso blanco se vuelve azul; tras habilitar la segunda ruta, el bolso de salida incorpora los colores y el logotipo de la marca azul de Comfy.

  • Klein 4B versión destilada genera imágenes en 4 pasos con éxito, al menos una de las dos rutas se ejecutó

Paso 6 (opcional): ejecutar Product Mockup, maqueta de producto ​

Por qué: un boceto de diseño y una foto de producto; la plantilla Product Mockup ya tiene conectadas ambas imágenes de referencia, y es una aplicación directa para escenarios de e-commerce.

Cómo hacerlo: busca Product Mockup en la biblioteca de plantillas y elige «Product Mockup(FLUX.2 Dev FP8)» (nombre de plantilla image_flux2_fp8, requiere 0.4.0 o superior). Dos imágenes de entrada: image_flux2_input_Illustration.png (nodo 46, boceto de diseño) y image_flux2_input_ref_image.png (nodo 42, foto de producto).

El prompt ya está rellenado:

text
Apply the design from Reference Image 1 onto objects in Reference Image 2.

La configuración de modelos de esta plantilla difiere ligeramente de la del paso 2: el codificador de texto usa la versión fp8 de mistral_3_small_flux2_fp8.safetensors (16.8GB), el VAE usa flux2-vae.safetensors (320.6MB), e incluye además un LoRA Turbo Flux2TurboComfyv2.safetensors (2.57GB, el interruptor «Enable 8steps LoRA» está desactivado por defecto). 20 pasos, 1024×1024.

Deberías ver: el patrón del boceto de diseño se aplica al objeto real de la foto de producto, manteniendo la composición y la geometría del producto sin cambios; el tutorial oficial posiciona esta plantilla precisamente para maquetas de productos como empaques y tazas.

Para el flujo completo orientado a e-commerce (cambio de fondo, prueba virtual, vídeo de producto), consulta maqueta de producto.

  • (Opcional) Cada imagen de referencia aporta lo suyo: el patrón del boceto de diseño + la forma de la foto de producto aparecen a la vez en la salida

Punto de control ✅ ​

  • Flujo de trabajo de múltiples referencias de Dev ejecutado con éxito: plantilla + trío de modelos + cadena ReferenceLatent
  • Puedes escribir la estructura de tres partes del prompt descriptivo: objeto nuevo + posición + parte a conservar (Keep the face)
  • Sabe explicar el cambio en CLIPLoader: FLUX.2 usa un solo codificador + type flux2, ya no es DualCLIPLoader
  • Klein 4B versión destilada genera imágenes en 4 pasos con éxito
  • (Opcional) Product Mockup, maqueta de producto, ejecutada con éxito: el patrón del boceto de diseño + la forma de la foto de producto aparecen a la vez en la salida

Advertencias sobre errores comunes ​

❌ VAE con archivo incorrecto descargado: la página del tutorial oficial y la nota de la plantilla no coinciden ​

El VAE listado en Model links de la página del tutorial oficial es flux2-vae.safetensors, pero el VAELoader de la plantilla FLUX.2 Dev (image_flux2) en realidad indica full_encoder_small_decoder.safetensors.

  • Síntoma: descargaste el flux2-vae.safetensors de 320.6MB, pero en el menú desplegable de VAELoader no aparece el archivo que pide la plantilla
  • Solución correcta: la lista de descargas se rige por la nota Model links del lienzo de la plantilla: la plantilla Dev usa full_encoder_small_decoder.safetensors (238MB), y flux2-vae.safetensors se reserva para las plantillas Klein y Product Mockup

❌ Versión de ComfyUI demasiado antigua, al cargar la plantilla se informa de nodos faltantes ​

Las plantillas de la serie FLUX.2 Dev (image_flux2 / image_flux2_text_to_image / image_flux2_fp8) requieren 0.4.0 o superior, y las plantillas de la serie Klein requieren 0.3.72 o superior: nodos como Flux2Scheduler y ReferenceLatent necesitan la nueva versión de comfy-core.

  • Síntoma: al cargar la plantilla se indica que el nodo no existe, o la ejecución falla directamente con un error
  • Solución correcta: actualiza primero ComfyUI y luego carga la plantilla

❌ Mezclar los modelos de Dev y Klein ​

Los codificadores de texto de las dos plantillas son completamente distintos: Dev usa mistral (33 GB), y Klein 4B usa qwen_3_4b (7.49 GB). Aunque el type de CLIPLoader se elige flux2 en ambos, los archivos no son intercambiables.

  • Síntoma: error al cargar, o calidad de imagen desplomada
  • Forma correcta: al cambiar de plantilla, cambia también el modelo. Los nombres de archivo de ambas son distintos, así que pueden coexistir en el mismo directorio models/ sin necesidad de borrarlos una y otra vez

❌ Conectar la imagen de referencia al puerto de entrada equivocado de ReferenceLatent ​

ReferenceLatent tiene dos puertos de entrada: conditioning (la cadena de condiciones, que viene de FluxGuidance o de un ReferenceLatent anterior) y latent (conectado al VAEEncode de la imagen de referencia).

  • Síntoma: el latent de la imagen de referencia no está conectado al puerto latent — este puerto es una entrada opcional y la ejecución funciona sin él, por lo que no hay error pero la imagen de referencia no surte ningún efecto (LATENT tampoco puede conectarse al puerto conditioning: el tipo no coincide y se rechaza directamente)
  • Forma correcta: LoadImage → (escalar) → VAEEncode → puerto latent; el puerto conditioning solo enlaza la cadena de condiciones

Técnicas avanzadas (opcional) ​

Activar el Turbo LoRA: Dev 20 pasos → 8 pasos ​

La plantilla Dev incluye el interruptor «Enable 8 steps lora» (desactivado por defecto). Al activarlo, el muestreo monta automáticamente el Flux_2-Turbo-LoRA_comfyui.safetensors descargado en el paso 2, y el número de pasos pasa de 20 a 8 — suficiente para previsualizar la composición; para la generación final, desactívalo y vuelve a los 20 pasos. Ten en cuenta que el interruptor equivalente de la plantilla Product Mockup usa otro archivo LoRA, Flux2TurboComfyv2.safetensors (del repositorio Comfy-Org/flux2-dev), no lo descargues por error.

Escribir el color hex de la marca en el prompt ​

FLUX.2 admite control del color de marca a nivel de código hex (una de sus características clave oficiales). Al crear material de marca, escribe directamente el código hex del color de marca en la descripción y la paleta de salida no se desviará — algo crucial para escenarios de packaging o carteles donde «el color debe coincidir con el manual de identidad visual».

Klein también está en 9B ​

Además de 4B, Klein también existe en 9B, igualmente en dos variantes base / distilled: el codificador de texto se cambia por qwen_3_8b_fp8mixed.safetensors (8.07 GB), y la programación es igualmente 4 pasos en distilled / 20 pasos en base. El modelo de difusión de 9B está en el repositorio de BFL, y oficialmente se indica que hay que aceptar el acuerdo en la página del repositorio antes de descargarlo. La generación más reciente de Klein ya llegó a FLUX.3, ver la siguiente lección.

Resumen de esta lección ​

En esta lección pusimos en marcha dos flujos de trabajo FLUX.2; tu situación actual:

  • ✅ Flujo Dev de múltiples referencias funcionando: plantilla → los tres archivos en su lugar → cadena de condiciones de ReferenceLatent → generación en 20 pasos
  • ✅ Recuerda las diferencias de nodos: CLIPLoader (type flux2) sustituye a DualCLIPLoader, y Flux2Scheduler gestiona pasos + ancho y alto
  • ✅ Sabes escribir prompts de edición descriptiva: describe la imagen final + declara con Keep the face qué partes conservar
  • ✅ Generación en 4 pasos con la versión distilled de Klein 4B funcionando, y sabes elegir entre base / distilled
  • ✅ Sabes elegir según tus necesidades: para el techo de calidad, Dev; para priorizar velocidad, Klein distilled; para fine-tuning, Klein base

Repaso de los campos de configuración clave:

Campo / nodoValor recomendadoExplicación
CLIPLoader typeflux2Forma de cargar el codificador único de FLUX.2, común para Dev y Klein
Flux2Scheduler stepsDev 20 / Klein distilled 4 / Klein base 20Los pasos dependen de la plantilla, no cambies de nivel por descuido
FluxGuidance4Valor por defecto de la plantilla Dev
Samplereuler (KSamplerSelect)Por defecto en todas las plantillas
Archivo VAEPlantilla Dev full_encoder_small_decoder / plantillas Klein y Product Mockup flux2-vaeEl archivo que más fácil es descargar mal
Tamaño de salidaSigue la imagen de entrada (GetImageSize → latent vacío + scheduler)Para cambiar el tamaño, cambia primero la imagen de entrada

Avance de la próxima lección ​

En la próxima lección ejecutaremos FLUX.3 Klein: el FLUX de código abierto más reciente en local.

Aprenderás:

  • El flujo de texto a imagen y de edición de FLUX.3 Klein con los mismos pesos, sin dividirlo en dos modelos
  • Las posibilidades de programación de la versión distilled en 4–16 pasos
  • <ref_image_N> Cómo escribir prompts con múltiples marcadores de referencia
  • Los límites de uso de la FLUX Kommunity License (¿se puede usar comercialmente?, ¿se puede publicar un fine-tune?)

Apéndice: referencia del código fuente ​

::: Haz clic en details para desplegar y ver la ubicación del código fuente

Fecha de actualización: 2026-11-05 (ComfyUI v0.43.2)

ContenidoArchivo
Tutorial oficial de FLUX.2 Dev (múltiples referencias, Product Mockup, enlaces de modelos)sources/comfyui/docs/tutorials/flux/flux-2-dev.mdx
Tutorial oficial de FLUX.2 Klein (4B/9B, base/distilled, datos de rendimiento)sources/comfyui/docs/tutorials/flux/flux-2-klein.mdx
JSON de la plantilla de edición Dev (hilo principal de esta lección)sources/comfyui/repo-notes/templates/image_flux2.json
JSON de la plantilla Product Mockupsources/comfyui/repo-notes/templates/image_flux2_fp8.json
JSON de la plantilla distilled de Klein 4Bsources/comfyui/repo-notes/templates/image_flux2_klein_image_edit_4b_distilled.json
Índice de plantillas (versión mínima de ComfyUI para cada plantilla)sources/comfyui/repo-templates/templates/index.json

Nodos y campos de configuración clave:

  • CLIPLoader: clip_name + type flux2 (sustituye a DualCLIPLoader de FLUX.1)
  • Flux2Scheduler: steps / width / height → SIGMAS (la resolución sigue a la imagen de entrada)
  • ReferenceLatent: conditioning encadena la cadena de condiciones, latent recibe la imagen de referencia de VAEEncode, se pueden encadenar varias imágenes
  • FluxGuidance: 4 (valor predeterminado de la plantilla Dev)
  • EmptyFlux2LatentImage: latent vacío específico para FLUX.2 (equivalente a EmptySD3LatentImage de FLUX.1)

:::

gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.