license: other
license_name: qwen-research
license_link: LICENSE
base_model:
- Qwen/Qwen-Image-2.1
base_model_relation: quantized
pipeline_tag: text-to-image
library_name: diffusers
tags: - qwen-image
- qwen-image-2.1
- text-to-image
- image-editing
- gguf
- fp8
- int8
- nvfp4
- nf4
- quantized
- comfyui
- diffusers
- uncensored
ChatR Labs Uncensored Omni — Quantized
A special thank-you to Chatr AI. Training models requires significant computing resources, and Chatr AI generously provided the GPU infrastructure that made this release possible. If you would like to help us release more open-weight models, please support Chatr AI—their support directly powers our research and future community releases.
Quantized builds at adapter weight 1.0, for text-to-image generation and image editing.
This repository ships quantized transformer weights only. The model is our rank-128 Omni adapter merged into
Qwen/Qwen-Image-2.1 at LoRA strength 1.0, then quantized.
The text encoder, processor and VAE are not included; take them from the base repository.
New: Turbo LoRA — 8 steps, CFG 1.0. Add the few-step Turbo LoRA on top of any build here to generate in 8 steps without CFG, about 6–7× faster than the standard 35-step, CFG 5.0 setting, with comparable quality. See Turbo LoRA.
Download
| File | Format | Layout | Size | Runtime |
|---|---|---|---|---|
qwen-image-2.1-step90000-BF16.gguf |
GGUF BF16 | 297 | 14.23 GB | ComfyUI, Diffusers |
qwen-image-2.1-step90000-Q8_0.gguf |
GGUF Q8_0 | 297 | 7.69 GB | ComfyUI, Diffusers |
qwen-image-2.1-step90000-Q6_K.gguf |
GGUF Q6_K | 297 | 6.00 GB | ComfyUI, Diffusers |
qwen-image-2.1-step90000-Q5_K_M.gguf |
GGUF Q5_K_M | 297 | 5.21 GB | ComfyUI, Diffusers |
qwen-image-2.1-step90000-Q4_K_M.gguf |
GGUF Q4_K_M | 297 | 4.47 GB | ComfyUI, Diffusers |
qwen-image-2.1-step90000-Q4_0.gguf |
GGUF Q4_0 | 297 | 4.20 GB | ComfyUI, Diffusers |
qwen-image-2.1-step90000-FP8-comfy.safetensors |
FP8 E4M3 | 265 | 7.12 GB | ComfyUI only |
qwen-image-2.1-step90000-INT8-ConvRot-comfy.safetensors |
INT8 ConvRot | 265 | 7.26 GB | ComfyUI only |
qwen-image-2.1-step90000-NVFP4-comfy.safetensors |
NVFP4 | 265 | 4.20 GB | ComfyUI only |
qwen-image-2.1-step90000-FP8-torchao/ |
FP8 (torchao) | 297 | 7.12 GB | Diffusers only |
qwen-image-2.1-step90000-NF4-bnb/ |
NF4 (bitsandbytes) | 297 | 3.67 GB | Diffusers only |
qwen-image-2.1-step90000-INT8-bnb/ |
INT8 (bitsandbytes) | 297 | 7.12 GB | Diffusers only |
qwen-image-2.1-step90000-BF16/ |
BF16 safetensors | 297 | 14.23 GB | Diffusers; ComfyUI (see BF16 workflow below) |
File integrity information is in SHA256SUMS.
Which build should I use?
- ComfyUI, one file, both workflows -> any GGUF. It also loads in Diffusers via
from_single_file. - ComfyUI, native quant ops -> FP8, INT8 ConvRot or NVFP4.
- Diffusers, smallest download -> NF4 (needs
bitsandbytes). - Diffusers, best fidelity -> FP8 (torchao) (needs
torchao). - Maximum fidelity overall -> BF16 GGUF, BF16 safetensors or Q8_0.
- Diffusers without the
ggufpackage -> the BF16 folder (plainfrom_pretrained).
The 297 and 265 layouts use different MLP representations: 265 uses the fused img_mlp.gate_up
projection; 297 keeps the separate gate_layer / proj pair. A loader must support the selected layout.
The BF16 ComfyUI workflow below was verified with the 297-tensor safetensors file and the nativeUNETLoader in ComfyUI 0.39.0; support should not be assumed for older or different loaders.
Recommended settings
These are the values from our inference grid search for the non-distilled model.
| Setting | Starting value |
|---|---|
| Base components | Text encoder, processor and VAE from Qwen/Qwen-Image-2.1 |
| Sampling steps | 35 |
| True CFG scale | 5.0 (both text-to-image and editing) |
| Sampler | er_sde with the simple scheduler (ComfyUI) |
| Negative prompt | A single space: " " |
| Output resolution | 768 x 1152 or 1024 x 1024 |
| KV cache | Enabled |
An omitted or empty negative prompt disables true CFG even when true_cfg_scale is greater than 1. Use a single
space if you do not need a specific negative prompt. The merge itself is not few-step distilled;
for 8-step generation, add the Turbo LoRA.
Usage with ComfyUI
ComfyUI/models/
|-- diffusion_models/ qwen-image-2.1-step90000-Q5_K_M.gguf
|-- text_encoders/ <Qwen-Image-2.1 text encoder>
`-- vae/ <Qwen-Image-2.1 VAE>
- GGUF:
Unet Loader (GGUF)-> pick the file. Works for both text-to-image and editing. - Comfy native:
Load Diffusion Model-> pick a-comfy.safetensorsfile. - Editing: encode the reference image with
Text Encoder (Qwen-Image)in edit mode; the latent comes from that node. - Sampler:
er_sde, schedulersimple, 35 steps, CFG 5.0.
Text-to-image workflow: BF16 transformer, INT8 text encoder, BF16 VAE
Download workflow_example.json and drag it into ComfyUI, or open it with the
workflow Load command. This is a ComfyUI UI workflow for text-to-image generation. It uses anEmptyLatentImage and does not require reference images.
The tested environment is ComfyUI 0.39.0
(commit b0b7435),
with frontend 1.53.6. Use this version or a compatible build with the native TextEncodeQwenImage21,QwenImage21Cache and INT8 ConvRot text-encoder support. All nine nodes in this workflow are built into
the tested ComfyUI version.
Download the following three components and place them at these paths relative to your ComfyUI folder:
| Component | Download | Local path expected by the workflow |
|---|---|---|
| BF16 transformer | ChatR Labs BF16 safetensors | models/diffusion_models/chatrlabs_qwen_image21_step90000_bf16.safetensors |
| INT8 ConvRot text encoder | Comfy-Org Qwen3-VL-8B | models/text_encoders/qwen3vl_8b_int8_convrot.safetensors |
| BF16 VAE | Comfy-Org Qwen-Image-2.1 VAE | models/vae/qwen_image_2.1_vae_bf16.safetensors |
Rename the downloaded transformer from diffusion_pytorch_model.safetensors tochatrlabs_qwen_image21_step90000_bf16.safetensors; its weights are unchanged. Refresh the model lists
or restart ComfyUI, then check the selections in UNETLoader, CLIPLoader (type qwen_image) andVAELoader. Here, BF16 refers to the transformer and VAE; the text encoder is INT8 ConvRot.
| Saved setting | Value |
|---|---|
| Steps / CFG | 35 / 5.0 |
| Sampler / scheduler | er_sde / simple |
| Seed / seed control | 12347 / fixed |
| Width / height / batch size | 1728 / 1728 / 1 |
| Denoise | 1.0 |
| Negative prompt | A single space: " " |
| KV cache device / dtype | auto / default |
Edit the prompt in TextEncodeQwenImage21, set the output dimensions in EmptyLatentImage, and adjust
the seed in KSampler as needed before queuing. The saved 1728 x 1728 resolution is this example's
setting; larger images require more memory than the starting resolutions above. SaveImage writes toComfyUI/output/ with the saved prefix sample_0006_seed12347; update the prefix for your own runs.
The workflow's SHA-256 is included in SHA256SUMS.
Usage with Diffusers
GGUF
import torch
from diffusers import QwenImage21Pipeline, QwenImage21Transformer2DModel, GGUFQuantizationConfig
transformer = QwenImage21Transformer2DModel.from_single_file(
"qwen-image-2.1-step90000-Q5_K_M.gguf",
quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16),
config="Qwen/Qwen-Image-2.1",
subfolder="transformer",
torch_dtype=torch.bfloat16,
)
pipe = QwenImage21Pipeline.from_pretrained(
"Qwen/Qwen-Image-2.1", transformer=transformer, torch_dtype=torch.bfloat16,
)
pipe.enable_model_cpu_offload()
FP8 / NF4 / INT8 folders
import torch
from diffusers import QwenImage21Pipeline, QwenImage21Transformer2DModel
transformer = QwenImage21Transformer2DModel.from_pretrained(
"chatrlabs/Qwen-Image-2.1-Uncensored-Omni-Quantized",
subfolder="qwen-image-2.1-step90000-FP8-torchao",
torch_dtype=torch.bfloat16,
)
pipe = QwenImage21Pipeline.from_pretrained(
"Qwen/Qwen-Image-2.1", transformer=transformer, torch_dtype=torch.bfloat16,
)
The INT8 build stores its non-quantized tensors in FP16, so load both the transformer and the pipeline withtorch_dtype=torch.float16.
Text to image
image = pipe(
prompt="A blue ceramic mug on a wooden table by a window, soft morning light, product photography",
negative_prompt=" ",
width=1024,
height=1024,
num_inference_steps=35,
true_cfg_scale=5.0,
use_kv_cache=True,
generator=torch.Generator("cuda").manual_seed(42),
).images[0]
image.save("generated.png")
Image editing
from PIL import Image
reference = Image.open("generated.png").convert("RGBA")
image = pipe(
image=[reference],
prompt="Change the mug to green, keep everything else unchanged",
negative_prompt=" ",
width=1024,
height=1024,
output_resolution=1024,
num_inference_steps=35,
true_cfg_scale=5.0,
use_kv_cache=True,
generator=torch.Generator("cuda").manual_seed(45),
).images[0]
image.save("edited.png")
Keep VAE tiling off: tiled decoding adds visible vertical colour streaks.
Turbo LoRA (8 steps, CFG 1.0)
chatrlabs-omni-turbo-8step-fp32.safetensors is a few-step LoRA for this model. It is hosted in the Omni LoRA v0.1 repository. Load it on top of a build from this repository, and the model generates in 8 steps without CFG, about 6–7× faster than 35 steps with CFG 5.0, with comparable quality. The same file works for text-to-image and image editing.
| Setting | Value |
|---|---|
| Turbo LoRA | chatrlabs-omni-turbo-8step-fp32.safetensors, strength 1.0, loaded as an adapter (not merged) |
| Sampling steps | 8 |
| True CFG scale | 1.0 (no negative prompt needed) |
| Scheduler (Diffusers) | The pipeline default, with shift_terminal=None |
Diffusers. Build pipe with one of the loading examples above, then:
from diffusers import FlowMatchEulerDiscreteScheduler
pipe.load_lora_weights(
"chatrlabs/Qwen-Image-2.1-Uncensored-Omni-LoRA-v0.1",
weight_name="chatrlabs-omni-turbo-8step-fp32.safetensors",
adapter_name="turbo",
)
# The Turbo LoRA was distilled for this schedule: no terminal stretch of the sigmas.
pipe.scheduler = FlowMatchEulerDiscreteScheduler.from_config(pipe.scheduler.config, shift_terminal=None)
image = pipe(
prompt="A blue ceramic mug on a wooden table by a window, soft morning light, product photography",
width=1024,
height=1024,
num_inference_steps=8,
true_cfg_scale=1.0,
use_kv_cache=True,
generator=torch.Generator("cuda").manual_seed(42),
).images[0]
For editing, pass image=[reference] and output_resolution=1024 as in the editing example, with the same 8 steps and CFG 1.0.
ComfyUI. Put the file in ComfyUI/models/loras/ and add LoraLoaderModelOnly (strength 1.0) after the model loader. Sample with 8 steps and CFG 1.0. Our ComfyUI tests used the euler sampler with the Diffusers sigma schedule above, entered through ManualSigmas; other schedulers were not benchmarked.
Compatibility. The Turbo LoRA attached to all 224 adapted modules on the GGUF, FP8 (torchao), NF4 and BF16 builds in Diffusers, and on the BF16, FP8, INT8 ConvRot and NVFP4 builds in ComfyUI. The Diffusers INT8 (bitsandbytes) build produced black images in our Turbo tests; use another build with the Turbo LoRA.
Speed on our Playground server (two RTX A6000 48 GB GPUs, eight prompts at 768 × 1344 to 1344 × 768):
| Setting | Time per image |
|---|---|
| 35 steps, CFG 5.0 | 54.9 s |
| Turbo LoRA, 8 steps, CFG 1.0 | 8.1 s (6.8× faster) |
Quality. Same benchmark as below, measured with the BF16 transformer: the Turbo LoRA at 8 steps against this model alone at 35 steps and CFG 5.0. Scores are 0–100, ± one standard error; differences are paired per prompt, * marks a difference larger than two standard errors.
| Benchmark | 35 steps, CFG 5.0 | Turbo, 8 steps, CFG 1.0 | Turbo − 35 steps |
|---|---|---|---|
| Adult prompt adherence (960 images) | 89.7 ± 0.7 | 89.1 ± 0.8 | −0.6 ± 0.7 |
| Anatomy (960 images) | 69.4 ± 1.4 | 72.9 ± 1.3 | +3.5 ± 1.0 * |
| General SFW prompts (300 PartiPrompts) | 79.6 ± 2.0 | 79.0 ± 2.0 | −0.6 ± 1.8 |
| Image editing (875 edits) | 78.9 ± 1.0 | 81.6 ± 1.0 | +2.7 ± 0.8 * |
| Identity kept when editing people (754 edits) | 55.8 ± 1.1 | 72.1 ± 1.0 | +16.3 ± 0.8 * |
- Prompt adherence and general SFW quality are within noise of the 35-step model.
- Anatomy and editing improve. When editing people, the Turbo LoRA keeps the person's identity much better than the 35-step model.
- For comparison, the official 8-step Qwen-Image-2.1-Turbo scores 78.1 on adult prompt adherence and 69.5 on general SFW prompts in the same benchmark.
- Known limitation: on some adult images, skin can look over-sharpened, with small speckles. An automated check flags this more often than with the 35-step model; it is not reflected in the scores above.
Per-caption-length, per-category and per-edit-set results are in BENCHMARK.md.
Benchmark
We compared both public checkpoints from this training run with the original Qwen-Image-2.1 base model, using the same prompts, seed and settings (35 steps, CFG 5.0). This repository is step 90,000 (benchmarked as the BF16 LoRA fused at strength 1.0; the quantized files were not scored separately). Scores are 0–100, higher is better, ± one standard error.
| Benchmark | Base | Step 32,000 (LoRA v0.1) | Step 90,000 (Quantized) |
|---|---|---|---|
| Adult prompt adherence (960 images) | 85.1 ± 0.9 | 87.4 ± 0.8 | 89.7 ± 0.7 |
| Anatomy (960 images) | 70.3 ± 1.4 | 67.7 ± 1.4 | 69.4 ± 1.4 |
| General SFW prompts (300 PartiPrompts) | 79.8 ± 2.0 | 75.8 ± 2.2 | 79.6 ± 2.0 |
- Prompt adherence on adult content improves with training: +2.3 at step 32,000 and +4.6 at step 90,000 over the base model (both significant).
- On ordinary SFW prompts, step 32,000 is 4.0 points below the base model; step 90,000 is within noise of it.
- Neither checkpoint improves anatomy over the base model.
Scores come from AI judges (Qwen3.8-27B for adherence, Gemma 4 31B for anatomy) on a held-out test set that does not overlap the training data. See BENCHMARK.md for per-caption-length and per-category results, the exact judge questions, and limitations.
Memory and performance
Measured on a single RTX 5090 (32 GB), 35 steps, er_sde, 768 x 1152:
| Build | Peak VRAM | Time per image (text to image) | Time per image (edit) |
|---|---|---|---|
| BF16 | ~14 GB | ~28 s | ~32 s |
| Q5_K_M | ~8 GB | ~28 s | ~32 s |
| NVFP4 | ~4 GB | ~30 s | ~34 s |
Editing and ControlNet runs add reference and control latents; budget a few GB more. The BF16 pipeline does not
fit comfortably beside a full text encoder on a 24 GB card - use CPU offload there.
These are individual timings, not comparative quality benchmarks.
Quantization details
| Property | Value |
|---|---|
| Base | Qwen-Image-2.1 |
| Adapter | ChatR Labs rank-128 Omni LoRA, merged at strength 1.0 |
| Training checkpoint | Step 90000 |
| Adapted modules | 224 |
| Diffusers-layout tensors | 297 |
| Comfy-layout tensors | 265 |
| GGUF tool | ComfyUI-GGUF convert.py, per-block quantization |
| Comfy FP8 | TensorCoreFP8E4M3Layout, per-tensor scale, 229 modules |
| Comfy INT8 ConvRot | convrot, group size 256, 224 modules |
| Comfy NVFP4 | TensorCoreNVFP4Layout, 192 fused modules |
| Diffusers FP8 | torchao Float8WeightOnlyConfig, per-row scale |
| Diffusers NF4 | bitsandbytes 4-bit NF4 with double quantization |
| Diffusers INT8 | bitsandbytes 8-bit |
The text encoder and VAE are untouched in every build; differences between builds come from the transformer only.
About "uncensored"
The checkpoints and example code do not add a prompt filter or output safety checker. The name describes the
intended release, not a guarantee that every requested concept will be rendered. Results depend on the prompt,
the build you load, and the application running it.
Source and license
- Released by: ChatR Labs
- Base model: Qwen/Qwen-Image-2.1
- Modification: ChatR Labs merged a rank-128 adapter into the base transformer at strength 1.0 and produced
GGUF, FP8, INT8, NVFP4 and NF4 builds. This repository distributes quantized transformer weights only. - License: Qwen Research License Agreement. Use is limited to non-commercial research and
evaluation unless separately licensed by the upstream rights holder. - Checksums: SHA256SUMS
Built with Qwen. This is a community fine-tune by ChatR Labs, independent of the upstream Qwen team.
Infrastructure Support
GPU compute used for the development and evaluation of this release was provided by Chatr AI.
We thank the Chatr AI team for supporting this research release.