# 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](#reference-images)).

:::note[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](/start-here/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](/configuration/optimization/fp8-storage/) and [SDNQ
quantization](/configuration/optimization/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](#license)) and the [PiD decoders](#pid-super-resolution-decode)
(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](#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.

:::caution[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](#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.

:::note[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](/users-guide/image-generation/advanced-topics/pid-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).

:::note[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](/configuration/optimization/low-vram-mode/#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.
:::