Qwen-Image-2.1-Turbo-Quantized

Qwen-Image-2.1 Turbo Quantized

<div align="center">

</div> <p align="center"> <img src="./assets/Qwen-Image-2.1-Benchmark.png" alt="Qwen-Image-2.1 benchmark comparison" width="1010"> </p>

The base model, Qwen-Image-2.1-Turbo, natively supports uncensored image generation. No built-in safety checker or content filter is applied, and no special settings are needed.

1024 × 1024 generation takes approximately 10–20 seconds on GPU after warm-up, depending on hardware.

• Base Model: Qwen/Qwen-Image-2.1-Turbo · 7B visual generation architecture
• Turbo Generation: 8 denoising steps · upstream default CFG = 1
• Available Formats: GGUF · FP8 / INT8 ConvRot / NVFP4 Safetensors · MLX 4-bit / 6-bit / 8-bit

Turbo Quantized Files

Choosing a format: Start with Q4_K_M for GGUF or INT8 ConvRot for ComfyUI Safetensors. See Usage for runtime instructions and model setup.

Text Encoders & VAE

Companion model files packaged for ComfyUI:

Usage

Recommended Turbo baseline: Euler · CFG 1.0 · 8 steps with the official sigma schedule · 1024 × 1024 · batch 1. Keep the seed fixed when comparing results. Start with Q4_K_M for GGUF or INT8 ConvRot for Safetensors.

<details> <summary><b>ComfyUI — GGUF &amp; Safetensors</b></summary>

Update ComfyUI and open Qwen Image 2.1 Turbo — Text to Image in the Template Library (official workflow JSON). Use the Turbo template to keep its correct sampling schedule.

Download one diffusion model, the text encoder, and the VAE from the tables above:

Restart ComfyUI after adding the files. Open the template's subgraph to access its internal loaders if needed.

Safetensors

1. In Load Diffusion Model (UNETLoader), select your Turbo .safetensors file and leave weight_dtype at default.
2. In Load CLIP, select the text encoder and set type: qwen_image. Select the VAE in Load VAE.
3. Enter your prompt and run. Leave optional prompt enhancement off for the initial setup.

GGUF

Install leejet/ComfyUI-GGUF using ComfyUI's Python environment, then restart:

git clone https://github.com/leejet/ComfyUI-GGUF custom_nodes/ComfyUI-GGUF
python -m pip install -r custom_nodes/ComfyUI-GGUF/requirements.txt

1. Replace Load Diffusion Model with Unet Loader (GGUF) and select your .gguf file.
2. Reconnect its MODEL output to the same downstream input, keeping the template's Qwen Image 2.1 Cache and sampler chain.
3. Select the same text encoder and VAE as above, then run. The text encoder still uses the regular Load CLIP node with type: qwen_image.

Keep the cache at auto / default. Try 2048 × 2048 for more detail once the initial setup works. It needs more memory and time; model file size is not total VRAM use. If memory is insufficient, reduce resolution or use a smaller GGUF; --lowvram is another option.

FP8: The included file has corrected scaling keys and was tested with the standard ComfyUI loader and stable-diffusion.cpp. Keep weight_dtype at default in ComfyUI.

</details> <details> <summary><b>Turbo sampling — the exact eight-step schedule</b></summary>

Keep ManualSigmas → SamplerCustomAdvanced from the official template:

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

Nine sigma values define eight steps. Setting a regular KSampler to eight steps with simple does not reproduce this schedule. At CFG 1, negative prompts have no effect. The full Turbo checkpoint needs no additional Turbo or Lightning LoRA.

</details> <details> <summary><b>Command-line usage — GGUF &amp; Safetensors</b></summary>

1. Install the runtime

Use a current stable-diffusion.cpp release for your operating system, or build it from source. The Bash commands below build the NVIDIA CUDA version; install Git, CMake, a C++ compiler, and the CUDA Toolkit first:

git clone --recursive https://github.com/leejet/stable-diffusion.cpp
cd stable-diffusion.cpp
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DSD_CUDA=ON
cmake --build build --config Release -j

On Apple Silicon, replace -DSD_CUDA=ON with -DSD_METAL=ON. For a CPU-only build, omit that option.

2. Download the three required files

Choose one Turbo diffusion model, the text encoder, and the VAE from the tables above. Put them inside the runtime directory:

stable-diffusion.cpp/
├── build/bin/sd-cli
└── models/
    ├── qwen-image-2.1-turbo-Q4_K_M.gguf
    ├── qwen3vl_8b_int8_convrot.safetensors
    └── qwen_image_2.1_vae_bf16.safetensors

3. Generate an image

Run from stable-diffusion.cpp/:

./build/bin/sd-cli \
  --diffusion-model models/qwen-image-2.1-turbo-Q4_K_M.gguf \
  --llm models/qwen3vl_8b_int8_convrot.safetensors \
  --vae models/qwen_image_2.1_vae_bf16.safetensors \
  --sigmas qwen-image-2.1-turbo \
  --steps 8 --cfg-scale 1.0 --sampling-method euler \
  --width 1024 --height 1024 --seed 42 \
  --offload-to-cpu \
  -p "A natural light portrait photograph" -o output.png

The result is saved as output.png in the current directory. Replace the prompt with your description. On Windows, the built executable is typically build\bin\Release\sd-cli.exe; it accepts the same arguments.

4. Switch to Safetensors

Download qwen-image-2.1-turbo-int8_convrot.safetensors into models/ and change only the --diffusion-model filename. Keep the text encoder, VAE, and Turbo sampling settings unchanged.

</details> <details> <summary><b>MLX — MFLUX (4 / 6 / 8-bit)</b></summary>

Use MFLUX with these MLX weights. This is a separate workflow from ComfyUI. The preparation below uses this repository's selected quantized transformer and downloads the text encoder, VAE, and configuration files from the official Turbo checkpoint.

1. Install MFLUX

Use Python 3.11 or newer in a supported MLX environment: Apple Silicon / macOS 14+, or Linux with CUDA 13 support. Create an environment:

python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install mflux==0.24.0

2. Prepare the local model once

Set bits to 4, 6, or 8 below. The first run also downloads the companion components; the MLX file size in the table covers the transformer only. This step arranges the files and adds loader metadata without re-quantizing the weights.

python - <<'PY'
import json, shutil
from pathlib import Path
from huggingface_hub import hf_hub_download, snapshot_download

bits = 4
assert bits in (4, 6, 8)
root = Path("qwen-turbo-mlx")
snapshot_download(
    "Qwen/Qwen-Image-2.1-Turbo", local_dir=root,
    allow_patterns=["model_index.json", "processor/**", "scheduler/*.json",
                    "transformer/config.json", "text_encoder/**", "vae/**"],
)
source = hf_hub_download(
    "abenzerps/Qwen-Image-2.1-Turbo-Quantized",
    f"qwen-image-2.1-turbo-MLX-{bits}bit.safetensors",
)
with open(source, "rb") as src:
    header = json.loads(src.read(int.from_bytes(src.read(8), "little")))
    header["__metadata__"] = {**header.get("__metadata__", {}),
                              "quantization_level": str(bits)}
    raw = json.dumps(header, separators=(",", ":")).encode()
    raw += b" " * (-len(raw) % 8)
    target = root / "transformer/model.safetensors"
    temporary = target.with_suffix(".tmp")
    with temporary.open("wb") as dst:
        dst.write(len(raw).to_bytes(8, "little"))
        dst.write(raw)
        shutil.copyfileobj(src, dst, 16 * 1024 * 1024)
    temporary.replace(target)
print(f"Ready: {root}")
PY

3. Generate an image

mflux-generate-qwen-2.1 \
  --model ./qwen-turbo-mlx \
  --base-model qwen-image-2.1-turbo \
  --prompt "A natural light photograph of a red ceramic cup" \
  --width 1024 --height 1024 --steps 8 --seed 42 \
  --low-ram --output output.png

The image is saved as output.png in the current directory. Allow extra time for model loading and compilation before sampling starts. Later runs need only the generation command with the environment activated. Keep the Turbo defaults of 8 steps and guidance 1. To change precision, repeat preparation with another bits value; the generation command stays the same.

</details>

Credits & License

• Original model — Qwen: Developed Qwen-Image-2.1-Turbo and released the original model weights.

• Companion models — Comfy-Org: Provided the ComfyUI-ready text encoder and VAE files.

• ComfyUI workflow — ComfyUI & ComfyUI-GGUF: The node-based generation interface and GGUF model loader used in this guide.

• Command-line generation & GGUF tools — stable-diffusion.cpp: Tools for model conversion, GGUF quantization, and standalone image generation.

• MLX generation — MFLUX: The MLX inference implementation used to load and run the 4/6/8-bit files in this guide.

• Quantization support — comfy-kitchen: Quantization tools and ComfyUI’s FP8/NVFP4 backend.

• Model license — Qwen Research License

File integrity: SHA256SUMS