byteshape/Qwen-Image-2512-GGUF

Qwen-Image-2512 GGUF (ShapeLearn Quantized)

This is a GGUF-quantized version of the Qwen-Image-2512 diffusion transformer, produced with ByteShape's ShapeLearn, which learns the optimal datatype per tensor to maintain high quality even at very low bitlengths.

Six sizes are available, from 16.87 GB (6.61 bpw) down to 7.77 GB (3.04 bpw). All variants generate high-quality images.

These files run in ComfyUI (via the ComfyUI-GGUF extension) and in stable-diffusion.cpp.

Looking for more speed? We also publish a vLLM-Omni build of the same model with optimized Humming kernels, roughly 2-3x faster per step. See byteshape/Qwen-Image-2512-Humming.

To learn more about ShapeLearn, and for the full setup walkthrough with screenshots and downloadable ComfyUI workflows, visit our blog.

If you have questions or want to share feedback, reach us on Reddit.

A Note on Speed

Unlike the decoding stage of an LLM, diffusion inference is not heavily constrained by memory bandwidth. Compressing the model therefore does not necessarily make image generation faster. Quantization here buys you VRAM headroom, not throughput. Backend optimization is what moves the needle.

GGUF supports the widest range of platforms and hardware, but the current backend kernels are not highly optimized for these layers. On an NVIDIA RTX 5090, each diffusion step takes roughly 1.2 seconds, so a 20-step image with CFG enabled samples in about 24 seconds.

Backend	Time per step (RTX 5090)	Time for 20 steps
GGUF (this repo)	~1.2 s	~24 s
vLLM-Omni	~0.5 s	~10 s

For measured peak VRAM and end-to-end times for every size at four output resolutions, with and without CPU offload, see the VRAM and speed table in the blog post.

What Do the Sizes Look Like?

Quality does not fall off a cliff as the bits come off. Every piece of text (HP 100/100, Gold 250, WEAPONS, INN) renders cleanly at every bit-width, 3.04 bpw included. What drifts is scene detail: the fountain keeps its twin arcs down to 3.46 bpw and collapses to a single stream at 3.04, where the shop sign also trades its crossed sword-and-axe for two axes and the hard pixel edges soften into painterly shading. Differences like these are subtle and highly prompt-dependent, and the row above is one prompt out of 24.

Judge for yourself: the blog post walks through the full set, and the interactive comparison explorer lets you A/B any two variants across 24 curated prompts at full resolution, with a slider, zoom, and a curator note for each prompt. If you read the outputs differently, tell us on Reddit.

Available Models

The sizes below are for the diffusion model only. In ComfyUI you also load a text encoder (~5.1 GB with the recommended GGUF encoder) and the VAE (~0.25 GB). ComfyUI offloads whatever does not fit to system RAM, so smaller cards still work; they just run slower.

Model ID	Bits/Weight	Model Size	Download
GGUF-1	3.04	7.77 GB	Qwen-Image-2512-Q3_K_S-3.04bpw.gguf
GGUF-2	3.46	8.83 GB	Qwen-Image-2512-Q3_K_M-3.46bpw.gguf
GGUF-3	3.98	10.17 GB	Qwen-Image-2512-Q4_K_S-3.98bpw.gguf
GGUF-4	4.45	11.35 GB	Qwen-Image-2512-Q4_K_M-4.45bpw.gguf
GGUF-5	5.10	13.03 GB	Qwen-Image-2512-Q5_K_S-5.10bpw.gguf
GGUF-6	6.61	16.87 GB	Qwen-Image-2512-Q6_K-6.61bpw.gguf

Selection rule: take the largest model that comfortably fits your VRAM alongside the text encoder. Since compression does not speed up diffusion, there is little reason to go smaller than your card allows.

Quick Start (ComfyUI)

1. Set up the environment

Create a Python environment, install ComfyUI, and add the ComfyUI-GGUF extension:

conda create -y -n comfy python=3.13
conda activate comfy

git clone https://github.com/Comfy-Org/ComfyUI.git
cd ComfyUI
pip install -r requirements.txt

cd custom_nodes
git clone https://github.com/city96/ComfyUI-GGUF
cd ComfyUI-GGUF
pip install -r requirements.txt

Return to the root of the ComfyUI repository before downloading the models.

2. Download the models

Qwen-Image needs three separate components: the main diffusion model (this repo), a VAE, and a text encoder.

Main diffusion model

Pick a quantization from the table above and download it into models/unet:

curl -L -C - -o models/unet/Qwen-Image-2512-Q3_K_S-3.04bpw.gguf \
  https://huggingface.co/byteshape/Qwen-Image-2512-GGUF/resolve/main/Qwen-Image-2512-Q3_K_S-3.04bpw.gguf

VAE

A small model that decodes images from latent space into pixel space:

curl -L -C - -o models/vae/qwen_image_vae.safetensors \
  https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI/resolve/main/split_files/vae/qwen_image_vae.safetensors

Text encoder

The text encoder conditions Qwen-Image on your prompt. Qwen-Image uses Qwen2.5-VL-7B-Instruct for this.

We did not quantize the text encoder ourselves: the model is mature, several high-quality quantizations already exist, and it contributes little to overall inference time. Choose one of the following.

Recommended: Bartowski Q4_K_L (5.1 GB). This is what our workflow template expects:

curl -L -C - -o models/text_encoders/Qwen2.5-VL-7B-Instruct-Q4_K_L.gguf \
  https://huggingface.co/bartowski/Qwen_Qwen2.5-VL-7B-Instruct-GGUF/resolve/main/Qwen_Qwen2.5-VL-7B-Instruct-Q4_K_L.gguf

Alternative (ComfyUI BF16):

curl -L -C - -o models/text_encoders/qwen_2.5_vl_7b.safetensors \
  https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI/resolve/main/split_files/text_encoders/qwen_2.5_vl_7b.safetensors

Alternative (Unsloth UD-Q4_K_XL, 4.8 GB):

curl -L -C - -o models/text_encoders/Qwen2.5-VL-7B-Instruct-UD-Q4_K_XL.gguf \
  https://huggingface.co/unsloth/Qwen2.5-VL-7B-Instruct-GGUF/resolve/main/Qwen2.5-VL-7B-Instruct-UD-Q4_K_XL.gguf

3. Run ComfyUI

From the root of the ComfyUI repository:

python main.py

Once it starts, open a browser and go to http://127.0.0.1:8188 to reach the ComfyUI interface. If ComfyUI runs on a different machine, use that machine's address instead of 127.0.0.1.

4. Load the example workflow

If you are new to ComfyUI, download our ready-made workflow (byteshape-Qwen-Image-2512-GGUF-3.04bpw.json) from the blog post, then press Ctrl+O in ComfyUI and select the JSON file.

The workflow lets you select the three models, enter positive and negative prompts, and choose the output dimensions. The sampler node in the center controls the random seed, the number of sampling steps, and the other generation parameters. Reasonable starting points are 20 steps at 1024 x 1024.

The blog post has annotated screenshots of the loaded workspace.