Qwen-Image 2.1 GGUF in ComfyUI: Run Normal and Turbo on 8 GB and 12 GB GPUs (2026)

Qwen-Image 2.1 is the newest open image model from Alibaba’s Qwen team, and the official ComfyUI templates assume a 16 GB card. You can still run it on an 8 GB or 12 GB GPU, in both the normal and the 8-step Turbo version, with GGUF files.

The catch is that the usual GGUF node does not load it. This guide gives you the node that works, the exact files and folders for each card, and the settings for normal and Turbo mode.

Qwen-Image 2.1, Normal vs Turbo in 30 Seconds

Qwen-Image 2.1 arrived in ComfyUI on 20 September 2026. It is a 7B diffusion transformer with a Qwen3-VL 8B text encoder, native 2K output, strong text rendering and transparent (RGBA) images.

On 9 October 2026 Alibaba added an official Turbo version that finishes in 8 steps instead of 40. Both use the same text encoder and VAE.

Have a 16 GB card? You do not need GGUF. Follow my Qwen-Image 2.1 Turbo workflow for 16 GB instead, which uses the official INT8 files. For editing photos, see the Qwen-Image 2.1 Image Edit guide.

Why city96’s GGUF Node Fails (and Which Fork Works)

Most ComfyUI users install ComfyUI-GGUF from city96, and it works for Flux, Wan and the older Qwen-Image. Qwen-Image 2.1 GGUF files are tagged with a new architecture name, qwen_image21.

I checked the loader code of each node pack on 8 November 2026:

• city96/ComfyUI-GGUF: its list of image architectures ends at qwen_image (the old 20B model). A 2.1 GGUF gives “Unknown model architecture!”.
• leejet/ComfyUI-GGUF: adds qwen_image21. leejet also made one of the main 2.1 GGUF repos and recommends this fork on its model card.
• molbal/ComfyUI-GGUF: also adds qwen_image21, plus newer models such as MiniMax H3 and Krea 2.

I recommend leejet’s fork for Qwen-Image 2.1, since it matches leejet’s own files and example workflow. Both forks keep the same node names, so old workflows that use Unet Loader (GGUF) still open.

Warning: install only one ComfyUI-GGUF pack. Two folders with the same node names conflict, and ComfyUI may load the wrong one.

Which Files for 8 GB, 12 GB and 16 GB

ComfyUI runs the text encoder first and then moves it off the GPU, so the diffusion model and encoder do not have to fit in VRAM at the same time. That is what makes 8 GB possible.

These are my estimates from the file sizes and ComfyUI’s memory behaviour, so treat the 6 to 12 GB rows as a starting point. Keep at least 32 GB of system RAM for the encoder hand-off; see how much RAM you need for local AI.

Not sure what your card has free? Check with how to check GPU VRAM usage.

Every File, Size and Folder

GGUF diffusion models

Two main uploaders publish Qwen-Image 2.1 GGUF files. Pick one repo and stick to it.

All of these go in ComfyUI/models/unet/. Check the exact file names on each repo’s Files tab, since uploaders name them slightly differently. New to quant names? See GGUF quantization explained.

Text encoder, VAE and Turbo LoRA

These come from the official Comfy-Org/Qwen-Image-2.1 repo on Hugging Face. It uses plain folders (text_encoders/, vae/, loras/), not the split_files/ layout of older Comfy-Org repos.

Note: the older Qwen-Image files (qwen_2.5_vl_7b encoder and the 254 MB qwen_image_vae) do not work with 2.1. My Qwen-Image model files guide shows which file belongs to which version.

ComfyUI/
└── models/
    ├── unet/
    │   └── qwen-image-2.1-Q4_K_M.gguf          (or your quant)
    ├── text_encoders/
    │   └── qwen3vl_8b_w4a8.safetensors
    ├── vae/
    │   └── qwen_image_2.1_vae_bf16.safetensors
    └── loras/
        └── qwen_image_2.1_turbo_lora_avg_rank_178_bf16.safetensors  (Turbo)

Portable build users: the path starts with ComfyUI_windows_portable\ComfyUI\models\. More folder questions: ComfyUI model folder cheat sheet.

Install the GGUF Node, Step by Step

1. Update ComfyUI. Portable: run update\update_comfyui.bat. Git: git pull then pip install -r requirements.txt. You need 0.37.2+ (normal) or 0.39.0+ (Turbo template). New install? See how to install ComfyUI.
2. Remove city96’s pack if you have it: delete or move ComfyUI/custom_nodes/ComfyUI-GGUF out of the folder.
3. Clone leejet’s fork:

   cd ComfyUI/custom_nodes
   git clone https://github.com/leejet/ComfyUI-GGUF
   pip install --upgrade gguf

4. Portable build: from the folder that holds run_nvidia_gpu.bat, install the dependency with the embedded Python:

   .\python_embeded\python.exe -s -m pip install --upgrade gguf

5. Restart ComfyUI fully (close the console window). You should find Unet Loader (GGUF) under the “bootleg” category.

Tip: you can also install the fork through ComfyUI Manager with “Install via Git URL” and the GitHub link above. Make sure the old city96 entry is uninstalled first.

Run the Normal Model on GGUF

1. Open the template: Workflow > Browse Templates > Image > Qwen Image 2.1: Text to Image. Close the “missing models” popup; you will swap the big files out.
2. Open the subgraph “Text to Image (Qwen Image 2.1)” by double-clicking it.
3. Replace Load Diffusion Model with Unet Loader (GGUF). Pick your GGUF and connect its MODEL output where the old loader’s output went.
4. Set Load CLIP to qwen3vl_8b_w4a8.safetensors, type qwen_image.
5. Keep Load VAE on qwen_image_2.1_vae_bf16.safetensors.
6. Set the size in ResolutionSelector to 1:1 and 1 megapixel (1024×1024).
7. Run. The KSampler defaults are 25 steps, CFG 1, euler, simple. Raise steps to 40 for final images.

leejet’s model card also links a ready GGUF workflow, qwen_image_2_1_t2i_gguf.json, if you would rather not edit the template yourself.

Note: with CFG 1 the negative prompt is ignored. Raising CFG to use it doubles the work per step, which hurts most on small cards.

Run Turbo (8 Steps) on 8 to 12 GB

There is no widely used GGUF of the Turbo checkpoint yet. The clean route is the base GGUF plus Comfy-Org’s Turbo LoRA, which is the same distillation extracted as a LoRA.

1. Download qwen_image_2.1_turbo_lora_avg_rank_178_bf16.safetensors into ComfyUI/models/loras/.
2. Open the Turbo template: Workflow > Browse Templates > Image > Qwen Image 2.1 Turbo: Text to Image (needs ComfyUI 0.39.0+). This keeps the special 8-step schedule.
3. In the subgraph, replace Load Diffusion Model with Unet Loader (GGUF) and pick your base GGUF.
4. Add a LoraLoaderModelOnly node after the GGUF loader. Pick the Turbo LoRA, strength 1.0, and connect its output to the sampler’s model input.
5. Set Load CLIP to the w4a8 encoder, type qwen_image, and run.

The Turbo template samples with SamplerCustomAdvanced: KSampler Select (euler), CFGGuider (CFG 1) and Manual Sigmas set to:

1.0, 0.978453, 0.95418, 0.926626, 0.89508, 0.845148, 0.704534, 0.414568, 0

Warning: do not swap this for a normal KSampler at 8 steps with the “simple” scheduler. The distilled weights expect this exact list, and other schedules give soft, noisy images.

Testers on the ComfyUI wiki found the full Turbo checkpoint a little better than turbo LoRAs. On 12 GB you can try the official qwen_image_2.1_turbo_int8_convrot.safetensors (7.26 GB) in Load Diffusion Model instead, as ComfyUI offloads part of it to RAM.

Want 4 or 6 steps?

• Lightning v1 LoRA (67 MB, 4 steps): works on a GGUF base too. Setup in my Lightning v2 RL guide, which also explains why v2 is not in ComfyUI yet.
• Pruna 6-step LoRA: see the Pruna P-Q-Image-2.1 guide.

Settings and Resolutions for Low VRAM

Need a big image on a small card? Generate at 1024 and upscale afterwards; my AI image upscaling guide covers the best local upscalers.

Transparent PNGs work on GGUF too. Start your prompt with “This is an RGBA format image with transparency.”, end it with “The image has an alpha channel and a transparent background.”, and save as PNG. The 16 GB Turbo guide has more RGBA and prompt tips.

Squeeze More Out of 8 GB

• Use the w4a8 encoder: it is 3 GB smaller than int8 and the quality difference is small for prompts.
• Set the Qwen Image 2.1 Cache node (inside the subgraph) to device cpu or dtype int8. Its options are auto, gpu, cpu, off and default, int8, int4.
• Leave the prompt enhancer off. It loads an extra 9.5 GB Qwen 3.5 9B model.
• Close other GPU users: games, video players and hardware-accelerated browsers all take VRAM.
• Batch size 1: make several images one after another instead of a batch.
• Two GPUs? Put the encoder on the second card; see the ComfyUI multi-GPU guide.

GGUF vs INT8: How Much Quality You Lose

Lower quants lose fine detail first: skin texture, small text and thin lines. Composition and colours hold up well down to Q4.

Comfy’s own console warning says native formats (fp8, int8, w4a8) run faster than GGUF even when they do not fully fit, because ComfyUI offloads them well. On 12 GB, try the official INT8 file first and fall back to GGUF only if you run out of memory.

Troubleshooting

“Unknown model architecture!”

You are still loading city96’s ComfyUI-GGUF. Remove that folder, install the leejet (or molbal) fork and restart ComfyUI fully.

Size mismatch error such as [136] vs [128]

Some Q8_0 uploads have this bug. Download the same quant from the other uploader, or use Q6_K.

The GGUF file is not in the dropdown

It is in the wrong folder. Move it to ComfyUI/models/unet/ and press R in ComfyUI to refresh, or restart.

Grey, washed-out or garbled images

Check the VAE is qwen_image_2.1_vae_bf16.safetensors and the encoder is a qwen3vl_8b file with type qwen_image. Keep CFG at 1.

Turbo images are blurry

The Manual Sigmas list was replaced, the Turbo LoRA is not connected, or it is below strength 1.0. Reload the Turbo template and redo the loader swap.

Out of memory (CUDA OOM)

Drop to 1024×1024, use the w4a8 encoder, set the cache node to cpu and pick a smaller quant. My CUDA out of memory fix has more options.

Very slow generation

Some forks run “_K” quants slowly. Try Q8_0 or Q5_0 if your card fits it, and check that ComfyUI is using your GPU, not the CPU.

My Take

Qwen-Image 2.1 is one of the best image models you can run on a modest card in late 2026. On 8 GB, a Q4 GGUF with the w4a8 encoder gives good 1024 images; on 12 GB, Q8_0 is close to the official files.

The only real trap is the GGUF node, so swap to leejet’s fork before anything else. Then keep two saved workflows: normal at 40 steps for keepers and Turbo LoRA at 8 steps for everything else. Remember the Qwen Research License is non-commercial.

FAQ

Can Qwen-Image 2.1 run on 8 GB VRAM?

Yes. Use a Q4 GGUF (about 4.2 GB), the qwen3vl_8b_w4a8 encoder, 1024×1024 images and the leejet ComfyUI-GGUF fork.

Why do I get “Unknown model architecture!” with Qwen-Image 2.1 GGUF?

The original city96 ComfyUI-GGUF does not support the qwen_image21 architecture. Install the leejet or molbal fork instead.

Where do Qwen-Image 2.1 GGUF files go?

In ComfyUI/models/unet/, loaded with Unet Loader (GGUF). The encoder goes in models/text_encoders/ and the VAE in models/vae/.

Is there a Qwen-Image 2.1 Turbo GGUF?

Not a widely used one yet. Use the base GGUF with the official qwen_image_2.1_turbo_lora_avg_rank_178_bf16 Turbo LoRA at 8 steps.

Which GGUF quant is best for 12 GB?

Q8_0 (about 7.6 GB) for the best quality, or Q6_K if you want more room for bigger images.

Can I use the Qwen-Image 2512 GGUF files or encoder with 2.1?

No. Qwen-Image 2.1 is a different model with its own Qwen3-VL encoder and VAE.

Does GGUF support transparent (RGBA) images?

Yes. Use the RGBA prompt wording and save as PNG; the output has a real alpha channel.

Sources

• Comfy-Org workflow templates (Qwen Image 2.1 and Turbo text-to-image JSON and notes)
• Comfy-Org/Qwen-Image-2.1 on Hugging Face
• leejet/Qwen-Image-2.1-GGUF and leejet/ComfyUI-GGUF
• unsloth/Qwen-Image-2.1-GGUF
• city96/ComfyUI-GGUF and molbal/ComfyUI-GGUF (loader architecture lists)
• ComfyUI Wiki: Qwen-Image 2.1 Turbo release
• Codersera: Qwen Image 2.1 local setup and VRAM table