---
title: Qwen-Image-2.1-Turbo-Quantized
canonical_url: "https://www.modelscope.cn/models/abenzerps/Qwen-Image-2.1-Turbo-Quantized"
md_url: "https://www.modelscope.cn/models/abenzerps/Qwen-Image-2.1-Turbo-Quantized.md"
repository: abenzerps/Qwen-Image-2.1-Turbo-Quantized
last_updated: 2026-11-04
license: other
pipeline_tag: text-to-image-synthesis
tasks:
  - text-to-image-synthesis
base_model:
  - Qwen/Qwen-Image-2.1-Turbo
base_model_relation: quantized
parameters: 40.8B
tensor_type:
  - BF16
  - U32
  - F8_E4M3
  - F32
  - U8
  - I8
library_name:
  - mlx
  - safetensors
  - gguf
  - pytorch
frameworks:
  - pytorch
downloads: 637
stars: 0
tags:
  - gguf
  - qwen
  - image-generation
  - comfyui
  - comfyui-gguf
  - mlx
  - fp8
  - nvfp4
---

# Qwen-Image-2.1-Turbo-Quantized

> Qwen-Image-2.1-Turbo-Quantized - abenzerps 在 ModelScope 开源的模型。Qwen-Image-2.1 Turbo Quantized

abenzerps/Qwen-Image-2.1-Turbo-Quantized 是 ModelScope 魔搭社区上的 40.8B 参数text-to-image-synthesis模型，采用 other 许可，基于 Qwen/Qwen-Image-2.1-Turbo 构建。

- **Repository**: abenzerps/Qwen-Image-2.1-Turbo-Quantized
- **License**: other
- **Tasks**: text-to-image-synthesis
- **Parameters**: 40.8B
- **Base model**: Qwen/Qwen-Image-2.1-Turbo
- **Tags**: gguf, qwen, image-generation, comfyui, comfyui-gguf, mlx, fp8, nvfp4
- **Downloads**: 637
- **Stars**: 0
- **Last updated**: 2026-11-04

Source: https://www.modelscope.cn/models/abenzerps/Qwen-Image-2.1-Turbo-Quantized

---

# Qwen-Image-2.1 Turbo Quantized

<div align="center">

[![Model Requests](https://img.shields.io/badge/Model_Requests-Submit-f59e0b?logo=huggingface&logoColor=white)](https://abenzerps.com/request-a-model/)
[![GitHub](https://img.shields.io/badge/GitHub-Follow-181717?logo=github&logoColor=white)](https://github.com/abenzerps)

</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](https://huggingface.co/Qwen/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](https://huggingface.co/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

| **Quantization** | **File** | **Size** |
| --- | --- | ---: |
| FP8 | [**qwen-image-2.1-turbo-fp8.safetensors**](https://huggingface.co/abenzerps/Qwen-Image-2.1-Turbo-Quantized/blob/main/qwen-image-2.1-turbo-fp8.safetensors) | 7.13 GB |
| INT8 ConvRot | [**qwen-image-2.1-turbo-int8_convrot.safetensors**](https://huggingface.co/abenzerps/Qwen-Image-2.1-Turbo-Quantized/blob/main/qwen-image-2.1-turbo-int8_convrot.safetensors) | 7.26 GB |
| NVFP4 | [**qwen-image-2.1-turbo-NVFP4.safetensors**](https://huggingface.co/abenzerps/Qwen-Image-2.1-Turbo-Quantized/blob/main/qwen-image-2.1-turbo-NVFP4.safetensors) | 4.20 GB |
| MLX 4-bit | [**qwen-image-2.1-turbo-MLX-4bit.safetensors**](https://huggingface.co/abenzerps/Qwen-Image-2.1-Turbo-Quantized/blob/main/qwen-image-2.1-turbo-MLX-4bit.safetensors) | 4.00 GB |
| MLX 6-bit | [**qwen-image-2.1-turbo-MLX-6bit.safetensors**](https://huggingface.co/abenzerps/Qwen-Image-2.1-Turbo-Quantized/blob/main/qwen-image-2.1-turbo-MLX-6bit.safetensors) | 5.78 GB |
| MLX 8-bit | [**qwen-image-2.1-turbo-MLX-8bit.safetensors**](https://huggingface.co/abenzerps/Qwen-Image-2.1-Turbo-Quantized/blob/main/qwen-image-2.1-turbo-MLX-8bit.safetensors) | 7.56 GB |
| Q8_0 | [**qwen-image-2.1-turbo-Q8_0.gguf**](https://huggingface.co/abenzerps/Qwen-Image-2.1-Turbo-Quantized/blob/main/qwen-image-2.1-turbo-Q8_0.gguf) | 7.59 GB |
| Q6_K | [**qwen-image-2.1-turbo-Q6_K.gguf**](https://huggingface.co/abenzerps/Qwen-Image-2.1-Turbo-Quantized/blob/main/qwen-image-2.1-turbo-Q6_K.gguf) | 5.88 GB |
| Q5_K_M | [**qwen-image-2.1-turbo-Q5_K_M.gguf**](https://huggingface.co/abenzerps/Qwen-Image-2.1-Turbo-Quantized/blob/main/qwen-image-2.1-turbo-Q5_K_M.gguf) | 4.94 GB |
| Q4_K_M | [**qwen-image-2.1-turbo-Q4_K_M.gguf**](https://huggingface.co/abenzerps/Qwen-Image-2.1-Turbo-Quantized/blob/main/qwen-image-2.1-turbo-Q4_K_M.gguf) | 4.05 GB |
| Q4_0 | [**qwen-image-2.1-turbo-Q4_0.gguf**](https://huggingface.co/abenzerps/Qwen-Image-2.1-Turbo-Quantized/blob/main/qwen-image-2.1-turbo-Q4_0.gguf) | 4.05 GB |

**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:

| **Type** | **File** | **Precision** | **Size** |
| --- | --- | --- | ---: |
| Text Encoder | [**text_encoders/qwen3vl_8b_bf16.safetensors**](https://huggingface.co/abenzerps/Qwen-Image-2.1-Turbo-Quantized/blob/main/text_encoders/qwen3vl_8b_bf16.safetensors) | BF16 | 17.53 GB |
| Text Encoder | [**text_encoders/qwen3vl_8b_int8_convrot.safetensors**](https://huggingface.co/abenzerps/Qwen-Image-2.1-Turbo-Quantized/blob/main/text_encoders/qwen3vl_8b_int8_convrot.safetensors) | Int8 | 9.35 GB |
| VAE | [**vae/qwen_image_2.1_vae_bf16.safetensors**](https://huggingface.co/abenzerps/Qwen-Image-2.1-Turbo-Quantized/blob/main/vae/qwen_image_2.1_vae_bf16.safetensors) | BF16 | 0.68 GB |

## Usage

| I want to use… | Choose… |
| :--- | :--- |
| **ComfyUI** | **GGUF** or **FP8 / INT8 ConvRot / NVFP4 Safetensors** |
| **A command-line runtime** | **GGUF** or supported **Safetensors** with **stable-diffusion.cpp** |
| **MLX / MFLUX** | **MLX 4/6/8-bit**; follow the setup below |

**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](https://github.com/Comfy-Org/ComfyUI) and open **Qwen Image 2.1 Turbo — Text to Image** in the Template Library ([official workflow JSON](https://github.com/Comfy-Org/workflow_templates/blob/main/templates/image_qwen_image_2_1_turbo_t2i.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:

| Component | File | Folder inside ComfyUI |
| :--- | :--- | :--- |
| Diffusion — choose one | `qwen-image-2.1-turbo-Q4_K_M.gguf` **or** `qwen-image-2.1-turbo-int8_convrot.safetensors` | `models/diffusion_models/` |
| Text encoder | `qwen3vl_8b_int8_convrot.safetensors` | `models/text_encoders/` |
| VAE | `qwen_image_2.1_vae_bf16.safetensors` | `models/vae/` |

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](https://github.com/leejet/ComfyUI-GGUF) using ComfyUI's Python environment, then restart:

```bash
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:

```text
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](https://github.com/leejet/stable-diffusion.cpp/releases) 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:

```bash
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:

```text
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/`:

```bash
./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:

```bash
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.

```bash
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**

```bash
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](https://huggingface.co/Qwen/Qwen-Image-2.1-Turbo):** Developed Qwen-Image-2.1-Turbo and released the original model weights.
- **Companion models — [Comfy-Org](https://huggingface.co/Comfy-Org/Qwen-Image-2.1):** Provided the ComfyUI-ready text encoder and VAE files.
- **ComfyUI workflow — [ComfyUI](https://github.com/Comfy-Org/ComfyUI) & [ComfyUI-GGUF](https://github.com/leejet/ComfyUI-GGUF):** The node-based generation interface and GGUF model loader used in this guide.
- **Command-line generation & GGUF tools — [stable-diffusion.cpp](https://github.com/leejet/stable-diffusion.cpp):** Tools for model conversion, GGUF quantization, and standalone image generation.
- **MLX generation — [MFLUX](https://github.com/mflux-community/mflux):** The MLX inference implementation used to load and run the 4/6/8-bit files in this guide.
- **Quantization support — [comfy-kitchen](https://github.com/Comfy-Org/comfy-kitchen):** Quantization tools and ComfyUI’s FP8/NVFP4 backend.

- **Model license — [Qwen Research License](https://huggingface.co/abenzerps/Qwen-Image-2.1-Turbo-Quantized/blob/main/LICENSE)**

**File integrity:** [SHA256SUMS](https://huggingface.co/abenzerps/Qwen-Image-2.1-Turbo-Quantized/blob/main/SHA256SUMS)
