FLUX.2

FLUX.2 is Black Forest Labs’ second-generation rectified-flow transformer family. It uses a 32-channel VAE and a large language model as its text encoder. InvokeAI supports these variants and detects them on install:

Variant	Text encoder	Notes
Klein 4B	Qwen3 4B	Distilled for 4 steps
Klein 9B	Qwen3 8B	Distilled for 4 steps
Klein 4B Base / Klein 9B Base	Qwen3 4B / Qwen3 8B	Undistilled foundation models; 28 steps
FLUX.2 [dev]	Mistral Small 3.2	32B guidance-distilled transformer; 28 steps; non-commercial license

Every variant can take reference images for image editing (see Reference images).

Klein vs. Klein Base

A Klein model and its Base model have identical architectures, so InvokeAI tells them apart by the file or repository name: a name containing “base” (and not “distilled”) is identified as Base. If a model was identified wrongly, change its Variant in the model’s edit form in the Model Manager. It matters: Base models need 28 steps, distilled ones 4.

License

Model	License	Commercial use	Gated
FLUX.2 Klein 4B	Apache 2.0	Allowed	No
FLUX.2 Klein 9B	FLUX Non-Commercial License	The weights may not be used commercially; generated images may, except to train a competing model	Yes, on Black Forest Labs’ repositories
FLUX.2 [dev]	FLUX [dev] Non-Commercial License	As for Klein 9B	Yes, on Black Forest Labs’ repositories

The Qwen3 and Mistral text encoders are Apache 2.0. The FLUX.2 [dev] ControlNet Union is released under the FLUX [dev] Non-Commercial License, like FLUX.2 [dev] itself. Some repackaged copies show a different license in their metadata; the original model’s license is the one that applies.

This is a summary, not legal advice. Read the full license on the model’s HuggingFace page before using a model commercially.

Hardware

See the System Requirements table:

• Klein 4B — 12 GB VRAM and 16 GB RAM at 1024×1024; the FP8 build works with 8 GB+. The int8 build is about 4.1 GB on any supported GPU. The GGUF Q4 build runs on 6–8 GB.
• Klein 9B — 12 GB VRAM and 32 GB RAM. The int8 build is 9.5 GB on any supported GPU. The FP8 build stays about 9.5 GB too: FP8 Storage is switched on when it is installed and keeps its weights in fp8. On an RTX 40-series (or newer) card, fp8_compute can also run them on the FP8 tensor cores for speed. The Qwen3 8B encoder is about 15 GB and streams on a 12 GB card.
• FLUX.2 [dev] — the full Diffusers pipeline is about 80 GB. The NF4 Diffusers build runs on about 18 GB of VRAM with offloading, and the GGUF Q3_K_M transformer fits about 12 GB with offloading. The FP8 mixed transformer takes about 35.5 GB once loaded, more than a 24 GB card holds, so partial loading streams the rest.

See also FP8 Storage and SDNQ quantization.

Installing

The FLUX.2 bundle in the Model Manager is the quickest start. It installs FLUX.2 Klein 4B (GGUF Q4) together with the FLUX.2 VAE and the Qwen3 4B encoder, about 11 GB. All three are Apache 2.0 and ungated, so the bundle needs no HuggingFace token. Klein 9B and FLUX.2 [dev] (non-commercial, gated on Black Forest Labs’ repositories; see License) and the PiD decoders (non-commercial / research weights) are separate starter models.

A FLUX.2 model needs three components:

Component	Diffusers install	Single-file / GGUF / FP8 / int8 install
Transformer	bundled	the checkpoint itself
VAE (FLUX.2)	bundled	installed separately
Text encoder	bundled	Klein 4B: Qwen3 4B · Klein 9B: Qwen3 8B · [dev]: Mistral

Starter models that are not Diffusers pipelines install the VAE and the matching encoder as dependencies. Pick them in the Components section next to the model. InvokeAI also takes them from another installed FLUX.2 pipeline automatically, so you don’t need standalone ones:

• Klein uses a Diffusers or self-contained SDNQ pipeline: any one for the VAE, one of the same size (4B or 9B) for the encoder.
• [dev] uses Diffusers pipelines only: any FLUX.2 one for the VAE, a [dev] one for the Mistral encoder. An SDNQ [dev] install is no pipeline of its own: it needs a standalone VAE and Mistral encoder, or a Diffusers pipeline as above.

Klein starter models

Starter model	Format	Size
FLUX.2 Klein 4B (Diffusers) / 9B (Diffusers)	Diffusers pipeline	~16 GB / ~35 GB
FLUX.2 Klein 4B	bf16 single file	~8 GB
FLUX.2 Klein 4B (FP8) / 9B (FP8)	FP8 single file	~4 GB / ~9.5 GB
FLUX.2 Klein 4B (int8)	int8 single file (community repack)	~4.1 GB, same size in memory on every supported GPU
FLUX.2 Klein 9B (int8)	int8 single file (community repack)	~9.5 GB, same size in memory on every supported GPU
FLUX.2 Klein 4B (GGUF Q4 / Q8)	GGUF	~2.6 GB / ~4.3 GB
FLUX.2 Klein 9B (GGUF Q4 / Q8)	GGUF	~5.8 GB / ~10 GB
FLUX.2 Klein 4B (SDNQ dynamic 4-bit) / 9B (SDNQ dynamic 4-bit + SVD)	SDNQ Diffusers pipeline	~5 GB / ~13 GB, self-contained

Standalone Qwen3 encoders are available as starter models too: FLUX.2 Klein Qwen3 4B Encoder (~8 GB) and its FP4 mixed build (~3.6 GB download), and FLUX.2 Klein Qwen3 8B Encoder (~16 GB) with FP4 mixed (~6.3 GB download) and int8 (~9.4 GB) builds. A 4B encoder only works with Klein 4B models, an 8B encoder only with Klein 9B.

When you install an FP8 checkpoint, FP8 Storage is switched on for it automatically, which keeps the file’s fp8 weights instead of expanding them.

FLUX.2 [dev] starter models

Starter model	Format	Size
FLUX.2 [dev] (Diffusers)	Diffusers pipeline	~80 GB
FLUX.2 [dev] (Diffusers, NF4)	NF4-quantized transformer and text encoder	~18 GB VRAM with offload
FLUX.2 [dev] Transformer (GGUF Q3_K_M / Q4_K_M / Q5_K_M / Q6_K / Q8_0)	GGUF	~15.9 / 20 / 24 / 27.9 / 35.5 GB
FLUX.2 [dev] Transformer (FP8 mixed)	Comfy-Org scaled fp8 mixed single file	~35.5 GB, the same once loaded with FP8 Storage; on a 24 GB card partial loading streams about half
FLUX.2 [dev] ControlNet Union	bf16 single file; see ControlNet	~8.2 GB

The GGUF and FP8 mixed transformers need a separate Mistral encoder. Q3_K_M and Q4_K_M install the GGUF Q4 encoder, the larger quants and the FP8 mixed build the GGUF Q8 encoder. Other encoder starters are the Comfy-Org builds — FP8 (~18 GB, best quality for its size), BF16 (~35.6 GB) and FP4 mixed (~12.3 GB download) — and a GGUF IQ4_XS build (~11.1 GB). llama.cpp conversions of Mistral Small 3.2, such as unsloth’s or bartowski’s GGUFs, are the same encoder; 3.0 and 3.1 GGUFs load too, but they are different weights. These files carry no Tekken tokenizer, so their first load fetches it from the gated black-forest-labs/FLUX.2-dev repository (see below). A GGUF of the same shape that declares scaled RoPE or an attention temperature, such as Devstral Small 2, is a different model and installs as unknown.

License and access

FLUX.2 [dev] is released under a non-commercial license. Some Black Forest Labs repositories are gated on HuggingFace: if a download asks for an access token, accept the license on the model’s HuggingFace page and add your HuggingFace token under API Keys in the Model Manager.

Generation settings

Selecting a FLUX.2 model applies these defaults:

Variant	Steps	Guidance	Scheduler	Size
Klein 4B / 9B	4	—	Euler	1024×1024
Klein 4B Base / 9B Base	28	—	Euler	1024×1024
[dev]	28	3.5	Euler	1024×1024

• Guidance — the slider next to Steps sets FLUX.2 [dev]‘s distilled guidance (0–20). It has no effect on Klein models.
• Scheduler — Euler, Heun (2nd order; better quality at about twice the time per step) or LCM (for few steps).
• Size — width and height must be multiples of 16.
• Negative prompt — not available in the Generate tab or on the Canvas.

Text-to-image, image-to-image, inpainting and outpainting all work on the Canvas. FLUX.2 [dev] takes a ControlNet; Klein models take none, and FLUX.2 has no IP-Adapter support.

Reference images

Every FLUX.2 model can edit or combine images from up to five reference images. Add them on the Generate tab or the Canvas and describe the result you want in the prompt. No extra model is needed.

In the workflow editor, wrap each image in a Kontext Conditioning - FLUX node and connect it (or a collection of them) to the Reference Images input of FLUX2 Denoise.

ControlNet

The FLUX.2 [dev] ControlNet Union starter model is alibaba-pai’s Fun-ControlNet-Union for FLUX.2 [dev] (~8.2 GB, FLUX [dev] Non-Commercial License). One model handles every condition: Canny, HED, Depth, Pose, MLSD, Scribble and Gray control images, plus inpainting. The starter model installs FLUX.2-dev-Fun-Controlnet-Union-2602.safetensors, the build to use: Scribble and Gray exist only in it, and the repository’s earlier file lost FLUX.2 [dev]‘s CFG distillation during control training and performs worse, which the 2602 build restores. It works with FLUX.2 [dev] only: the Klein transformers are narrower than the one it was trained beside. With a Klein model selected, a control layer’s settings and the Invoke button say that the ControlNet is not compatible, and nothing is generated until the layer is disabled or the model changed.

On the Canvas, add a Control Layer while a FLUX.2 [dev] model is selected. Its adapter type is FLUX.2 [dev] ControlNet and its pixels are the control image; the layer’s Filter turns a raster into one of the conditions (Canny, HED, Depth Anything, DW Openpose, MLSD, Scribble or Grayscale). The layer’s Weight is the model’s control scale: it ranges from 0 to 2, starts at 0.75, and 0.65 to 0.80 is the recommended range. Step range limits the steps the control applies to. Only one FLUX.2 [dev] ControlNet layer can be used per generation, and it can be combined with reference images.

When the Canvas inpaints or outpaints with a control layer present, the ControlNet also receives the image being regenerated and the mask of the region as its inpainting condition. Without a control layer, inpainting and outpainting are guided by the inpaint mask alone.

In the workflow editor, the same thing is the FLUX.2 [dev] ControlNet node feeding the Control input of FLUX2 Denoise. Give it a control Image, an Inpaint Image together with its Inpaint Mask (white is regenerated), or both. Its Control Scale, Begin Step Percent and End Step Percent are the layer’s weight and step range. The images are resized to the generation size and encoded with the VAE connected to FLUX2 Denoise; Tiled and Tile Size tile that encode, and an untiled encode that runs out of memory is retried in tiles. FLUX2 Denoise stops with a message when the ControlNet meets a Klein model.

Memory

The ControlNet’s 8.2 GB of weights stay loaded beside the [dev] transformer for the whole generation, and its blocks add activation memory that grows with the image size and the number of reference images. On a GPU that cannot hold all of it, Invoke keeps part of the models in system RAM, and each step is slower.

Regional guidance

Regional guidance layers with a prompt are supported on the Canvas. Regional reference images are not. Regional prompts are ignored when reference images are attached; InvokeAI logs a warning when that happens.

LoRA

FLUX.2 LoRAs are labelled with the variant they were trained for, and the Generate tab only offers LoRAs that match the selected model’s variant. LoRAs patch the transformer and, where they include text-encoder layers, the Qwen3 or Mistral encoder. In workflows use Apply LoRA - Flux2 Klein or Apply LoRA - FLUX.2 [dev] (and their Collection versions). Supported layouts include LyCORIS, Diffusers/PEFT and ComfyUI/OneTrainer PEFT files whose module names start with diffusion_model.. Per-layer .alpha values in these diffusion_model. files set the LoRA scale. LyCORIS LoKr and LoHA files are supported in BFL and kohya layouts; each LoKr operand may be stored whole or as a factorized _a / _b pair.

PiD super-resolution decode

FLUX.2 Klein latents can be decoded with a PiD decoder for a 4× super-resolved image. Install PiD Decoder FLUX.2 (2K), PiD Decoder FLUX.2 (2K to 4K) or the newer PiD 1.5 Decoder FLUX.2 (2K to 4K) (also as an int8 build); see PiD Super-Resolution Decode.

Workflow nodes

Node	Purpose
Main Model - Flux2 Klein / Main Model - FLUX.2 [dev]	Loads the transformer, encoder and VAE
Prompt - Flux2 Klein / Prompt - FLUX.2 [dev]	Encodes the prompt
FLUX2 Denoise	Runs the diffusion; takes the VAE, optional reference images and, for [dev], a ControlNet
FLUX.2 [dev] ControlNet	Configures the ControlNet Union: control image and/or inpaint image with mask, scale, step range
Latents to Image - FLUX2 / Image to Latents - FLUX2	VAE decode / encode

FLUX2 Denoise also has a CFG Scale and a negative conditioning input, which the Generate tab leaves off (CFG 1.0).

Tiled VAE decode

Latents to Image - FLUX2 and Image to Latents - FLUX2 have Tiled and Tile Size fields. Without them, Invoke still tiles a decode that is too large for the GPU (auto_tiled_decode) or that ran out of memory, and force_tiled_decode tiles every decode and encode; see Tiled VAE decode and encode. A tiled result is not pixel-identical to an untiled one: the difference is fine, texture-level noise spread over the whole image, not seams, so the same seed does not reproduce an untiled image exactly. On a 1024×1024 FLUX.2 Klein image, a tiled decode differed from the untiled one by 5.6 of 255 per pixel value on average (about 2%), with no visible seams; at 2048×2048 by 3.3 of 255.