Qwen-Image-2.1 VRAM Calculator

Qwen-Image-2.1 is three models: a 7B diffusion transformer, the Qwen3-VL-8B text encoder and a VAE. Pick the file you run for each, where the text encoder lives, and the image size, and see the peak VRAM range and which GPUs fit.

– estimated peak VRAM

Weights on the GPU at once: – (exact file sizes). Working memory on top is the range measured on real GPUs below.

GPU memory8 GB12 GB16 GB24 GB32 GB
Result–––––

“Tight”: fits only at the low end of the range, as in ComfyUI, which can also move part of the model to system RAM (slower). Leave about 0.5–1 GB for the desktop if the GPU drives your screen.

Common setups at 1024×1024

SetupWeights on GPUPeak range8 GB12 GB16 GB24 GB32 GB
Full precision (diffusers default) 30.8 GB 32.9 GB–35.5 GB NoNoNoNoNo
ComfyUI INT8 ConvRot set 16.1 GB 18.2 GB–20.8 GB NoNoNoFitsFits
ComfyUI INT8 set, encoder unloaded 9.3 GB 11.4 GB–14.0 GB NoTightFitsFitsFits
FP8 DiT + FP8 encoder (unsloth) 16.0 GB 18.1 GB–20.7 GB NoNoNoFitsFits
GGUF Q8_0 + encoder Q8_0 15.9 GB 18.0 GB–20.6 GB NoNoNoFitsFits
GGUF Q4_K_M + encoder INT8 13.2 GB 15.3 GB–17.9 GB NoNoTightFitsFits
GGUF Q4_K_M + encoder Q4_K_M 9.2 GB 11.3 GB–13.9 GB NoTightFitsFitsFits
GGUF Q4_K_M, encoder on CPU 4.5 GB 6.1 GB–6.9 GB FitsFitsFitsFitsFits

Every GGUF file of the DiT, with its exact size

All GGUF quants of the Qwen-Image-2.1 DiT in the unsloth, leejet (stable-diffusion.cpp) and gguf-org repositories, largest first. The peak is for a 1024×1024 image with the text encoder on the CPU and the BF16 VAE, the setup where the DiT file decides the card (with the encoder on the GPU, the 4.7 GB Q4_K_M encoder outweighs every file from Q5_K_S down). The last column is the smallest of 8, 12, 16, 24 and 32 GB it fits at the top of the range.

QuantFileSizeBytes1 MP peak, encoder on CPUSmallest card
F16 qwen-image-2.1-F16.gguf
unsloth/Qwen-Image-2.1-GGUF
13.3 GB 14,230,275,808 15.5 GB–16.3 GB 24 GB
Q8_0 qwen_image_2.1-Q8_0.gguf
leejet/Qwen-Image-2.1-GGUF
7.2 GB 7,687,155,744 9.4 GB–10.2 GB 12 GB
Q8_0 qwen-image-2.1-Q8_0.gguf
unsloth/Qwen-Image-2.1-GGUF
7.1 GB 7,640,860,384 9.3 GB–10.1 GB 12 GB
Q6_K_XL qwen-image-2.1-Q6_K_XL.gguf
unsloth/Qwen-Image-2.1-GGUF
6.3 GB 6,718,506,720 8.5 GB–9.3 GB 12 GB
Q6_K qwen-image-2.1-Q6_K.gguf
unsloth/Qwen-Image-2.1-GGUF
5.8 GB 6,271,551,200 8.1 GB–8.9 GB 12 GB
Q6_K qwen_image_2.1-Q6_K.gguf
leejet/Qwen-Image-2.1-GGUF
5.6 GB 5,996,851,232 7.8 GB–8.6 GB 12 GB
Q5_K_M qwen-image-2.1-Q5_K_M.gguf
unsloth/Qwen-Image-2.1-GGUF
5.0 GB 5,390,223,072 7.2 GB–8.0 GB 12 GB
Q5_0 qwen_image_2.1-Q5_0.gguf
leejet/Qwen-Image-2.1-GGUF
4.7 GB 5,069,910,048 6.9 GB–7.8 GB 8 GB
Q5_K_S qwen-image-2.1-Q5_K_S.gguf
unsloth/Qwen-Image-2.1-GGUF
4.2 GB 4,501,948,128 6.4 GB–7.2 GB 8 GB
Q4_K_M qwen-image-2.1-Q4_K_M.gguf
unsloth/Qwen-Image-2.1-GGUF
3.9 GB 4,199,565,024 6.1 GB–6.9 GB 8 GB
Q4_K qwen_image_2.1-Q4_K.gguf
leejet/Qwen-Image-2.1-GGUF
3.9 GB 4,197,494,816 6.1 GB–6.9 GB 8 GB
Q4_0 qwen_image_2.1-Q4_0.gguf
leejet/Qwen-Image-2.1-GGUF
3.9 GB 4,197,494,816 6.1 GB–6.9 GB 8 GB
NVFP4 qwen-image-2.1-nvfp4.gguf
gguf-org/qwen-image-2.1-gguf
3.8 GB 4,050,555,040 6.0 GB–6.8 GB 8 GB
Q4_K_S qwen-image-2.1-Q4_K_S.gguf
unsloth/Qwen-Image-2.1-GGUF
3.6 GB 3,906,356,960 5.9 GB–6.7 GB 8 GB
Q3_K_XL qwen-image-2.1-Q3_K_XL.gguf
unsloth/Qwen-Image-2.1-GGUF
3.4 GB 3,612,493,536 5.6 GB–6.4 GB 8 GB
Q3_K qwen_image_2.1-Q3_K.gguf
leejet/Qwen-Image-2.1-GGUF
3.0 GB 3,270,553,632 5.3 GB–6.1 GB 8 GB
Q3_K_M qwen-image-2.1-Q3_K_M.gguf
unsloth/Qwen-Image-2.1-GGUF
3.0 GB 3,168,290,528 5.2 GB–6.0 GB 8 GB
Q3_K_S qwen-image-2.1-Q3_K_S.gguf
unsloth/Qwen-Image-2.1-GGUF
2.5 GB 2,724,742,880 4.8 GB–5.6 GB 8 GB
Q2_K qwen_image_2.1-Q2_K.gguf
leejet/Qwen-Image-2.1-GGUF
2.4 GB 2,561,716,256 4.6 GB–5.4 GB 8 GB
Q2_K qwen-image-2.1-Q2_K.gguf
unsloth/Qwen-Image-2.1-GGUF
2.3 GB 2,466,137,824 4.5 GB–5.3 GB 8 GB

Byte sizes read from the Hugging Face API on . FLUX.2, Wan 2.2 and LTX-2 in the same terms: the image and video model VRAM calculator.

Low-VRAM setups for 8, 12 and 16 GB

Each row is a mix of the files above at 1024×1024. The three phase columns are the weights on the GPU while the prompt is encoded, while the image is denoised and while the VAE decodes it: exact file sizes. The peak adds the working memory measured in real runs, 1.6–2.4 GB with the text encoder on the CPU.

CardDiT + text encoderText encoder PromptDenoiseVAE decode PeakResultTry it
8 GB GGUF Q4_K_M + GGUF Q4_K_M
+ tiled VAE decode
On the CPU 0.6 GB4.5 GB4.5 GB 6.1 GB–6.9 GB Fits Try it
8 GB GGUF Q5_K_M + GGUF Q4_K_M
+ tiled VAE decode
On the CPU 0.6 GB5.6 GB5.6 GB 7.2 GB–8.0 GB Tight Try it
8 GB GGUF Q3_K_M + GGUF Q3_K_M
An RTX 3070 8GB ran out of memory in VAE decode with this pair (both on the GPU).
Everything on the GPU 7.4 GB7.4 GB7.4 GB 9.5 GB–12.1 GB No Try it
12 GB GGUF Q8_0 + GGUF Q4_K_M
+ tiled VAE decode
On the CPU 0.6 GB7.7 GB7.7 GB 9.3 GB–10.1 GB Fits Try it
12 GB GGUF Q4_K_M + GGUF Q4_K_M Unloaded after the prompt 5.3 GB4.5 GB4.5 GB 7.4 GB–10.0 GB Fits Try it
12 GB INT8 ConvRot (ComfyUI) + FP8 Unloaded after the prompt 9.4 GB7.4 GB7.4 GB 11.5 GB–14.1 GB Tight Try it
16 GB INT8 ConvRot (ComfyUI) + INT8 ConvRot (ComfyUI) Unloaded after the prompt 9.3 GB7.4 GB7.4 GB 11.4 GB–14.0 GB Fits Try it
16 GB GGUF Q6_K + GGUF Q4_K_M Everything on the GPU 11.2 GB11.2 GB11.2 GB 13.3 GB–15.9 GB Fits Try it
16 GB GGUF Q4_K_M + INT8 ConvRot (ComfyUI) Everything on the GPU 13.2 GB13.2 GB13.2 GB 15.3 GB–17.9 GB Tight Try it

On Windows, “runs on 8 GB” can mean 18 GB

NVIDIA’s Windows driver moves what does not fit into shared system memory instead of failing (System Memory Fallback, since driver 536.40), so a job finishes but runs from system RAM. One RTX 3070 8GB owner saw the INT8 set use 7.3 GB of dedicated VRAM plus 11.2 GB of shared memory. On the same card, the Q4_K_M DiT on the GPU with the Q4_K_M encoder on the CPU peaked at 6.9 GB, and Q3_K_M files for both, together 6.8 GB, ran out of memory while decoding. If Task Manager shows “Shared GPU memory” climbing during a run, it does not fit; setting “CUDA - Sysmem Fallback Policy” to “Prefer No Sysmem Fallback” in the NVIDIA Control Panel makes that an out-of-memory error instead.

On a Mac (unified memory)

A public report from an M5 Max 48 GB shows Unsloth Desktop on macOS using about 34 GB after loading and about 42 GB while generating with the Q4_K_M DiT, far more than the CUDA figures on this page; a follow-up gives the settings: 1024×1024, 40 steps, 3 min 14 s. On a Mac, Unsloth Studio runs the pipeline with diffusers on MPS in BF16. The GGUF DiT stays packed (each layer is dequantized only while it runs), and the FP8/INT8 text-encoder casts are CUDA-only, so the encoder stays at BF16 and the weights come to 22.4 GB (Q4_K_M DiT, BF16 encoder and BF16 VAE, in decimal GB). On top of that, Studio budgets 8 GiB of working memory per megapixel, and on MPS it sets PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0, which removes the allocator’s cap: a job that does not fit pushes macOS into swap instead of failing. The 34 and 42 GB are Activity Monitor readings; whether they are the whole Mac, macOS and other apps included, or the app alone has not been confirmed. The ranges here come from CUDA runs (ComfyUI and diffusers) and may underestimate Mac paths such as MPS or MLX. macOS also lets the GPU use only part of the RAM by default, logged at about two thirds to three quarters, so leave headroom on a 48 GB Mac; in the same thread, the user’s 8-bit MLX build in MLX Serve peaked at about 20 GB. stable-diffusion.cpp runs GGUF files on Metal, but we have no Mac measurement of it.

Settings that do this

  • ComfyUI: --disable-dynamic-vram --lowvram runs the text encoders on the CPU (with dynamic VRAM on, --lowvram does nothing); the “VAE Decode (Tiled)” node decodes in tiles; --reserve-vram 1 keeps 1 GB free for the desktop; --novram is the last resort when --lowvram is not enough.
  • stable-diffusion.cpp: --backend te=cpu runs the text encoder on the CPU (it replaces the deprecated --clip-on-cpu); --vae-tiling decodes in tiles; --diffusion-fa uses flash attention in the DiT; --offload-to-cpu keeps the weights in system RAM and copies them to the GPU when needed; --max-vram cuda0=6 caps what it plans to use.

Flags checked on 2026-09-29 in ComfyUI’s cli_args.py and nodes.py, and stable-diffusion.cpp’s performance, backend and Qwen Image 2.1 docs.

Peak VRAM people measured

GPUAppFilesImagePeakSource
RTX 3090 24GBComfyUIDiT GGUF Q4_K_M + encoder INT8 ConvRot + VAE BF161024×102415.39 GiB github.com 2026-09-21
RTX 3090 24GBComfyUIsame2048×115216.83 GiB github.com 2026-09-21
RTX 3090 24GBComfyUIsame, image editing1024×102417.15 GiB github.com 2026-09-21
RTX 3090 24GBComfyUI --lowvramsame, encoder on CPU, tiled VAE1024×10246.14 GiB github.com 2026-09-21
RTX 4060 Ti 16GBComfyUIDiT INT8 ConvRot + encoder INT8 + VAE BF16not stated~15 GB huggingface.co 2026-09-22
RTX 4070 12GBComfyUIDiT INT8 ConvRot + encoder FP8 + VAE BF16, editing2048×204811.28 GiB note.com 2026-09-24
RTX 5090 32GBdiffusersDiT + encoder FP8 (torchao), all resident1024×102421.3 GB huggingface.co 2026-09-22
RTX 5090 32GBdiffuserssame2048×204822.6 GB huggingface.co 2026-09-22
RTX 5090 32GBdiffusersDiT + encoder NF4 (bitsandbytes)1024×102415.2 GB huggingface.co 2026-09-22
RTX 3070 8GBnot statedDiT GGUF Q4_K_M on the GPU, encoder Q4_K_M on the CPU1024×1024, 40 steps6.9 GB x.com 2026-09-26
RTX 3070 8GBnot statedINT8 set, spilling into shared system memorynot stated7.3 GB dedicated + 11.2 GB shared x.com 2026-09-26
RTX 3070 8GBnot statedDiT GGUF Q3_K_M + encoder Q3_K_M, both on the GPUnot statedout of memory in VAE decode x.com 2026-09-26
Apple M5 Max 48GBUnsloth (macOS)DiT GGUF Q4_K_M (kept packed); encoder BF16 (Studio casts it to FP8 only on CUDA); VAE not stated1024×1024, 40 steps~34 GB loaded, ~42 GB generating github.com 2026-09-29

File sizes read from Hugging Face on : Comfy-Org/Qwen-Image-2.1, unsloth/Qwen-Image-2.1-GGUF, unsloth/Qwen-Image-2.1-FP8, gguf-org/qwen-image-2.1-gguf, unsloth/Qwen3-VL-8B-Instruct-GGUF, Qwen/Qwen-Image-2.1. For language models, see the LLM VRAM calculator. How the site’s estimates compare with real runs: predicted vs measured.

How to use

  1. Pick the diffusion model (DiT) file: BF16, FP8, INT8 or a GGUF quant.
  2. Pick the text encoder file and where it runs: on the GPU the whole time, unloaded after the prompt (ComfyUI does this when memory is short), or on the CPU.
  3. Choose the image size, or editing with reference images.
  4. Read the peak range and the GPU table. "Tight" means it fits only at the low end of the measured range.

Frequently asked questions

How much VRAM does Qwen-Image-2.1 need?

The full-precision files take 30.8 GB (BF16 DiT 13.3 GB, BF16 Qwen3-VL-8B encoder 16.3 GB, FP32 VAE 1.3 GB). ComfyUI's INT8 ConvRot set takes 16.1 GB, and a GGUF Q4_K_M DiT with the INT8 encoder and BF16 VAE 13.2 GB. Generating adds roughly 2–6 GB, depending on the image size and the app.

Why do guides say anything from 6 GB to 30 GB?

They count different things. The text encoder is bigger than the image model, so whether it stays on the GPU decides most of the answer: with the encoder on the CPU, a Q4_K_M DiT ran 1024×1024 images in 6.1 GB on an RTX 3090; with everything in BF16 on the GPU, the weights alone are 30.8 GB.

Can Qwen-Image-2.1 run on a 12 GB or 16 GB GPU?

Yes, with quantized files and the text encoder unloaded after the prompt or kept on the CPU. An RTX 4070 12GB edited 2048×2048 images at 11.3 GB peak with the INT8 DiT and FP8 encoder in ComfyUI; an RTX 4060 Ti 16GB peaked near 15 GB with both in INT8.

Which text encoder does Qwen-Image-2.1 use?

Qwen3-VL-8B (Qwen3VLForConditionalGeneration), not Qwen2.5-VL. The 9B Qwen3.5 "prompt enhancer" files in the Comfy-Org repository are an optional extra model, not the text encoder, and are not counted here.

Is GB here GB or GiB?

GiB, the unit nvidia-smi and GPU memory sizes use, as everywhere on this site. The diffusers measurements were reported in GB by their authors and are shown as given.

More calculators

Updated