Qwen-Image-2.1

Qwen-Image-2.1

Qwen-Image-2.1 is a 7B text-to-image model from the Qwen team with strong text rendering. It is a different model from Qwen Image (2512 and Edit 2511), not an update you can swap in: it encodes prompts with the Qwen3-VL 8B model, the same encoder Ideogram 4 uses, and decodes with its own 64-channel VAE, which can produce images with a transparent background.

Two variants are available, and the variant is detected on install:

• Qwen-Image-2.1 — the base model. 40 steps by default.
• Qwen-Image-2.1 Turbo — distilled for 8 steps on a fixed schedule of its own.

Text-to-image, image-to-image, inpainting and outpainting on the Canvas are supported, as are LoRAs and edits from reference images. Regional guidance is not supported yet.

License

Qwen-Image-2.1 is released under the Qwen Research License, which allows use for research and evaluation only. Commercial use needs a separate license from Alibaba’s Tongyi Lab. The same license covers the Comfy-Org and community repackages of the weights.

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

Installing Qwen-Image-2.1

The Diffusers starter models install the complete folders, which carry the transformer, the VAE and the Qwen3-VL 8B encoder:

• Qwen/Qwen-Image-2.1 — the base model, ~31 GB.
• Qwen/Qwen-Image-2.1-Turbo — the Turbo variant, ~30 GB.

You can also paste either repo ID into the Model Manager’s HuggingFace / URL field.

GGUF and single files

A GGUF or single-file transformer carries only the transformer. Pick the other two parts in the Components section next to the model; until both are set, the Invoke button tells you which one is missing:

• VAE — the Qwen-Image-2.1 VAE, from Comfy-Org’s vae/qwen_image_2.1_vae_bf16.safetensors or the vae folder of a Diffusers download. The VAEs of Qwen Image, Wan and FLUX do not fit and are not offered.
• Qwen3-VL Encoder — the Qwen3-VL 8B encoder, for example the Qwen3-VL 8B Encoder starter model, which Ideogram 4 uses as well. The 4B encoder Krea-2 uses does not work and is not offered. A llama.cpp GGUF of the 8B encoder works too, and reads reference images when you also select its mmproj file as the Vision Tower (a “Qwen3 VL Vision Tower” model, see Reference images); see Qwen3-VL GGUF encoders.

The Qwen-Image-2.1 (Q4_K_M GGUF) starter model, from unsloth/Qwen-Image-2.1-GGUF, installs the VAE and the 8B encoder with it, ~15 GB in all. Other quantization levels from that repository load the same way.

The Qwen-Image-2.1 (int8) and Qwen-Image-2.1 Turbo (int8) starter models, Comfy-Org’s int8_convrot builds (~7.3 GB each), install the same VAE and 8B encoder. Their int8 layers stay int8 on every supported GPU, and int8 Compute can run them on NVIDIA int8 tensor cores.

Single-file transformers in bf16, scaled fp8 or int8_convrot (ComfyUI repackages) load as well. nvfp4 files, torchao-quantized files (such as unsloth’s FP8 build), and int8 files without ComfyUI’s int8_convrot marker, are refused at install. GGUF files with int8 layers (ComfyUI-GGUF’s Q8_CR) are refused too.

The Turbo variant is recognized from the filename: a single file or GGUF whose name contains turbo installs as Turbo, anything else as the base model. If a file was detected as the wrong variant, edit the model in the Model Manager and change its Variant. The default settings were chosen at install, so also set Steps under Default Settings: 8 for Turbo, 40 for the base model.

Memory and speed

Measured on an RTX 4090 at 1024×1024:

Transformer	Resident	Time per image
bf16 (Diffusers)	13.9 GB during denoising	0.62 s per step, about 25 s for 40 steps
GGUF Q4_K_M	4.0 GB	about 40 s for 40 steps
int8 (int8_convrot)	7.3 GB	about 37 s for 40 steps

The text encoder runs first and is unloaded from the GPU when the transformer needs the room. At 2048×2048 the bf16 transformer needs 15.5 GB and 3.7 s per step.

The VAE needs about 8 GB of working memory to decode a 1024×1024 image, and is priced the same to encode one for image-to-image, inpainting or outpainting (twice that with precision: float32). When an image is too large for the card to handle in one piece, Invoke decodes and encodes it in tiles; see Large decodes. Invoke picks 1024-pixel tiles, and 768 or 512 only on cards with less memory: measured at 2048×2048, 1024-pixel tiles came close to an untiled decode (47.7 dB PSNR), while the 256-pixel tiles other VAEs default to left visible seams (35.6 dB).

Reference images

With a Qwen-Image-2.1 model, add up to four images with Add reference image in the Guidance section (see Adding reference images) and say in the prompt what to do with them, for example put the jacket from the first image on the person in the second or the same cat, as a watercolor. The model reads each reference twice: its Qwen3-VL encoder looks at it alongside the prompt, and the transformer sees it as clean latents next to the image it generates.

• The encoder needs a vision tower. The Qwen3-VL vision tower reads the images. The Diffusers model’s own encoder has one, and so does a non-GGUF Qwen3-VL 8B encoder such as the starter Qwen3-VL 8B Encoder, so a single-file, int8 or GGUF transformer offers reference images once that encoder is selected under Components. A GGUF Qwen3-VL encoder has none of its own: llama.cpp keeps the tower in a separate mmproj-*.gguf file (from Qwen/Qwen3-VL-8B-Instruct-GGUF, mmproj-Qwen3VL-8B-Instruct-F16.gguf, about 1.1 GB). Install that file as a model, where it appears as a Qwen3 VL Vision Tower (the Qwen3-VL 8B Vision Tower starter model installs it), and select it as the Vision Tower under Components beside the GGUF encoder. Without it Generate shows why the section is unavailable, and on a Diffusers model the references refuse to run while a GGUF Qwen3-VL Encoder is selected. Only the 8B tower pairs with the 8B encoder, and the tower runs on the encoder’s device, so when the encoder is set to CPU Only in the Model Manager, set the tower to CPU Only too, and the field is refused beside any other encoder, which brings its own tower. If an encoder file turns out to carry no vision tower, the run stops and says so.
• Size. Each reference is read at about one megapixel at its own aspect ratio, whatever its size. The generated image takes the size set in the panel; Use size on a reference’s thumbnail matches it.
• Transparency. The encoder sees a transparent reference over white, as the model was trained; its latents keep the transparency.
• At most four. A graph or API request with more than four references is refused with an error.
• Memory. The encoder’s vision tower, about 1.1 GB, is loaded only for generations with references and joins the encoder while it reads them; plain prompts never load it, and the encoder itself is not loaded again when you switch between edits and plain prompts. Each reference adds about 4,100 tokens to the start of the sequence, which the model keeps for the whole generation: about 2 GB per reference, twice that with CFG above 1. Where that would take more than half of the GPU, Invoke reprocesses the references at every step instead of keeping them, which uses less memory but takes noticeably longer. Reading the references also needs encoder memory that grows quickly with their number: about 7 GB beyond its weights for four, so on a 24 GB card part of the encoder then runs from system memory.
• Reproducing an edit. Keeping the references and reprocessing them give slightly different images from the same seed, and which one runs depends on the GPU’s memory. The image’s metadata records which one ran, as qwen_image_2_1_prefix_kv_cache: true when the references were kept, false when they were reprocessed. Generations without references record it too.

Transparent images

The Qwen-Image-2.1 VAE decodes an alpha channel along with the colors, so a prompt such as a sticker of a red fox on a transparent background produces a cut-out image. An image is saved with transparency only when it has some: when more than 0.1% of its pixels are noticeably transparent. Opaque images are saved as ordinary RGB, so the faint edges tiled decoding leaves in the alpha channel never turn an opaque image transparent.

Image-to-image, inpainting and outpainting read the colors of the input image and treat it as fully opaque, whatever its alpha channel holds.

LoRAs

Qwen-Image-2.1 LoRAs install like any other and appear under Concepts in the Generate panel. Files from ComfyUI (keys starting diffusion_model.), diffusers/PEFT trainers (transformer.) and Kohya-style trainers (lora_unet_) all load. ComfyUI’s builds fuse each block’s two MLP input projections into one gate_up layer; Invoke splits a LoRA on it to match the diffusers model.

• LoRAs for Qwen Image (2512, Edit 2511) do not fit Qwen-Image-2.1 and are not offered for it, nor its LoRAs for them.
• They work on every format, except that DoRA layers do not run on an int8 transformer: a generation with one there stops with a message before it starts. On GGUF, int8 and fp8 transformers the LoRA runs alongside the packed weights rather than being merged into them. Full weight differences on the attention and text norms, which ComfyUI’s Turbo LoRA carries, are merged on every format.
• A LoRA trained on the base model also applies to Turbo; how well it holds up at Turbo’s 8 steps depends on the LoRA.
• Low-rank (lora_A/lora_B or lora_down/lora_up), DoRA, LoKR and LoHA LoRAs are recognized, and so are full weight differences (diff). On ComfyUI’s fused gate_up only low-rank, PEFT DoRA and full layers work: a LoKR, LoHA or LyCORIS DoRA layer there mixes the two halves Invoke splits it into.
• A LoRA is recognized as a Qwen-Image-2.1 one only if all of it applies: every layer it targets exists in Qwen-Image-2.1, is complete, has the shape of the Qwen-Image-2.1 weight it changes and, on gate_up, can be split. A file with any part that does not apply installs as an unknown model and does not appear under Concepts.
• A FLUX.2 Klein 9B LoRA on nothing but its double blocks’ image attention has the same layer names and shapes as a Qwen-Image-2.1 one, and installs as one. One that also targets its proj_out or norm_out.linear is told apart by their shapes and is not recognized as a Qwen-Image-2.1 LoRA.

Generation settings

• Steps — 40 for the base model and 8 for Turbo. Turbo’s schedule is tuned for 8 steps; other step counts are spread over the same curve and work, but 8 is what it was distilled for.
• CFG — 1 by default, which runs one prompt per step. Above 1, the negative prompt is used and each step costs about twice as long.
• There is no scheduler setting: both variants use their own schedule.
• Denoising strength (image-to-image, inpainting) — on the base model a strength changes the image about as much as on Qwen-Image or Z-Image. Turbo’s 8-step schedule spends most of its steps at high noise, so there a strength sets the starting noise level directly (0.5 starts at noise level 0.5): the same value changes the image less on Turbo than on the base model.

Image size and the noise schedule

The base model puts more of its steps at high noise the larger the image, up to the area of about 1448×1448 (2.1 megapixels). Larger images keep that schedule. Without the limit, an image-to-image pass at strength 0.5 would start at 77% noise on a 2048×2048 image and at 95%, almost pure noise, on a 4096×4096 one, so it would replace the image instead of refining it; with it, both start at 70%. Text-to-image above that size uses the held schedule too, so it differs from diffusers’ QwenImage21Pipeline there, and base-model images made at those sizes with an earlier Invoke version don’t reproduce exactly with the same seed. Turbo’s fixed schedule does not depend on the image size.