Pruna P-Q-Image-2.1: Qwen Image 2.1 in 6 Steps With ComfyUI LoRAs (v0.2 Guide)

Qwen Image 2.1 is one of the best open image models for text rendering and editing, but at 40 steps with CFG it is slow on a home GPU. Pruna AI’s P-Q-Image-2.1 LoRAs cut that to 6 steps with CFG off, and Pruna says the result is up to 6.3x faster. Version 0.2 adds two 6-step adapters, one of which has Qwen’s prompt enhancer built in, and the official ComfyUI repo ships ready workflows for both text-to-image and image editing. This guide covers which file to pick, where every file goes, the exact ManualSigmas values you must use, editing with up to three reference images, and what to expect on a 16 GB card.

What Is P-Q-Image-2.1?

P-Q-Image-2.1 is a set of LoRA adapters from Pruna AI, a company that specialises in making AI models smaller and faster. The adapters sit on top of Qwen Image 2.1 and teach it to make and edit images in far fewer steps, with classifier-free guidance switched off. The text encoder, VAE and pipeline stay exactly the same, so it is not a standalone model. You still need the Qwen Image 2.1 base files.

There are two repos:

• PrunaAI/P-Q-Image-2.1: the original adapters for diffusers, with benchmarks.
• PrunaAI/P-Q-Image-2.1-Comfy: the same adapters with ComfyUI key names, plus six ready workflows.

Each LoRA is rank 64 across 232 linear layers, trained with alpha 128. The 2x alpha scale is already folded into the weights, which is why strength must stay at exactly 1.0.

The Four LoRAs: Which One to Use

What “upsampled” means: Qwen recommends running your prompt through a prompt enhancer (an LLM that rewrites a short prompt into a long, detailed one) before generating. That is an extra model call. The upsampled LoRA has learned that rewrite step, so a short prompt like “a cat on a windowsill at sunset” behaves more like a carefully written long one, and you skip the extra call. Pruna notes it may not match the real enhancer exactly.

My pick: start with the v0.2 6-steps-upsampled LoRA for text-to-image and the plain v0.2 6-steps LoRA for editing. Use v0.1 only if you already have workflows built around it.

Files and Folder Paths

The LoRAs

Download from PrunaAI/P-Q-Image-2.1-Comfy (the loras/ folder). Pick the files with comfyui in the name:

• ComfyUI/models/loras/p_q_image_2.1_6_steps_v0.2_comfyui_bf16.safetensors
• ComfyUI/models/loras/p_q_image_2.1_6_steps_upsampled_v0.2_comfyui_bf16.safetensors
• ComfyUI/models/loras/p_q_image_2.1_8_steps_v0.1_comfyui_bf16.safetensors (optional)
• ComfyUI/models/loras/p_q_image_2.1_5_steps_v0.1_comfyui_bf16.safetensors (optional)

The Qwen Image 2.1 base files

From Comfy-Org/Qwen-Image-2.1. Use the base checkpoint, not the Turbo one:

• ComfyUI/models/diffusion_models/qwen_image_2.1_int8_convrot.safetensors (or qwen_image_2.1_bf16.safetensors if you have the VRAM)
• ComfyUI/models/text_encoders/qwen3vl_8b_int8_convrot.safetensors
• ComfyUI/models/vae/qwen_image_2.1_vae_bf16.safetensors

Your tree should look like this:

ComfyUI/
  models/
    diffusion_models/qwen_image_2.1_int8_convrot.safetensors
    text_encoders/qwen3vl_8b_int8_convrot.safetensors
    vae/qwen_image_2.1_vae_bf16.safetensors
    loras/p_q_image_2.1_6_steps_v0.2_comfyui_bf16.safetensors
    loras/p_q_image_2.1_6_steps_upsampled_v0.2_comfyui_bf16.safetensors

No custom nodes are needed. Everything uses core ComfyUI nodes, so just make sure ComfyUI is up to date for Qwen Image 2.1 support.

Load the Official Workflows

The Comfy repo’s workflows/ folder has six files:

Download the one you want and drag it onto the ComfyUI canvas. The v0.2 workflows load the plain 6-steps LoRA. To use the upsampled version, change lora_name in the LoraLoaderModelOnly node to the upsampled file. The sigma schedule stays the same for both v0.2 files.

Settings and ManualSigmas

The sigma schedule is the part most people get wrong. Each version was trained on its own schedule, and mixing them gives soft or broken images. Paste the exact values into a ManualSigmas node:

v0.2, 6 steps:  1.0, 0.961054, 0.918949, 0.769302, 0.545554, 0.222292, 0
v0.1, 8 steps:  1.0, 0.933333, 0.857143, 0.769231, 0.666667, 0.545455, 0.4, 0.222222, 0
v0.1, 5 steps:  1.0, 0.94, 0.857143, 0.666667, 0.4, 0

The node chain looks like this:

Load Diffusion Model (qwen_image_2.1_int8_convrot)
  -> LoraLoaderModelOnly (p_q_image_2.1_6_steps_v0.2, strength 1.0)
  -> SamplerCustom (euler, CFG 1, sigmas from ManualSigmas)
  -> VAE Decode (qwen_image_2.1_vae_bf16)

Load only one Pruna LoRA at a time. Stacking two step-distill LoRAs does not make it faster; it just breaks the schedule.

Text-to-Image Tips

• Short prompt? Use the upsampled LoRA. It fills in the detail a prompt enhancer would add.
• Long, detailed prompt? Either LoRA works. The plain 6-steps one follows your exact words more literally.
• Text in images: Qwen Image 2.1’s strength is lettering. Put the text in quotes, for example: A glowing neon shop sign that reads "QWEN IMAGE 2.1", mounted on a brick wall in a narrow city alley at night. Heavy rain, wet pavement reflecting pink and blue light, shallow depth of field, cinematic photograph. That is Pruna’s own test prompt.
• Stay near 1024×1024. 2K may work but is outside the training range. Upscale afterwards instead.
• v0.1 needs good prompts. Short or vague prompts give weaker results with the older adapters.

Image Editing With Up to 3 References

The v0.2 6-steps LoRA is especially good at edits where the rest of the image must stay the same. Load pruna_q_image_2.1_v0.2_6step_image_edit.json, load your input image, and write the change as an instruction:

• Change the background to a sunset beach
• Make the jacket red and keep everything else the same
• Replace the text on the sign with "OPEN 24 HOURS"

You can feed up to three reference images, for example a person, a product and a background, and describe how to combine them. More than three is outside the training range and quality may drop.

If you also do inpainting or element-level edits, our ComfyArt guide shows a design canvas that runs Qwen Image 2.1 edits for you, and the MOSS-Image Edit LoRA is a lighter Apache-licensed alternative.

Speed: Up to 6.3x Faster

Pruna’s headline figure is “up to 6.3x faster”. Its benchmarks ran on one NVIDIA H100 80 GB in bf16 at batch size 1, timing the whole request: prompt encoding, reference image processing, denoising and VAE decode. For v0.1, the base model ran 40 steps against 5 or 8 for the adapters. Pruna adds that the timings “do not imply equal image quality”.

The speed comes from two things: 6 steps instead of 40, and CFG 1, which skips the second (negative) model pass at every step. Prompt encoding and VAE decode do not get faster, which is why the end-to-end gain is smaller than the raw step reduction.

Estimate for a 16 GB card like the RTX 5080: with the int8 convrot base and ComfyUI’s offloading, expect roughly 10 to 20 seconds per 1024×1024 image with the 6-step LoRA, compared with well over a minute for the base model at 40 steps with CFG. Edits with several reference images take longer. This is an estimate, not a measured result.

Running It on a 16 GB GPU

• Use the int8 convrot files. qwen_image_2.1_int8_convrot.safetensors and qwen3vl_8b_int8_convrot.safetensors are the low-memory versions. The bf16 base needs much more VRAM.
• Let ComfyUI offload the text encoder. It runs once per prompt, so moving it to system RAM costs little time. 32 GB of system RAM is a comfortable minimum.
• Stay at 1024px. Larger sizes need more VRAM and are outside training anyway.
• Limit edit references. Each extra reference image adds tokens and memory. Pruna even had to turn off KV caching for 2048×2048 edits with three references on an 80 GB card.

Our Qwen Image 2.1 guide for 16 GB cards has more memory tips that apply here too.

Using It in Diffusers

Pruna’s original repo targets diffusers. It needs a specific diffusers commit for the QwenImage21Pipeline:

pip install 'torch>=2.4.0' 'transformers>=5.17' accelerate peft pillow
pip install git+https://github.com/huggingface/diffusers@6256aa7666cedd47443adc8f82da9a10e110b09c

import torch
from diffusers import FlowMatchEulerDiscreteScheduler, QwenImage21Pipeline

pipe = QwenImage21Pipeline.from_pretrained("Qwen/Qwen-Image-2.1", torch_dtype=torch.bfloat16).to("cuda")
pipe.load_lora_weights("PrunaAI/P-Q-Image-2.1", weight_name="p_q_image_2.1_6_steps_v0.2.safetensors")
pipe.scheduler = FlowMatchEulerDiscreteScheduler.from_config(
    pipe.scheduler.config, use_dynamic_shifting=True, shift_terminal=None)

image = pipe(prompt="A cosy reading nook with a window seat, soft morning light",
             width=1024, height=1024, num_inference_steps=6,
             sigmas=[1.0, 0.925, 0.85, 0.625, 0.375, 0.125],
             true_cfg_scale=1.0, use_kv_cache=True).images[0]
image.save("pq_image.png")

The sigma list here differs from the ComfyUI one because diffusers applies dynamic shifting on top. Do not copy diffusers sigmas into ComfyUI, or the other way round.

Pruna LoRA vs Qwen Image 2.1 Turbo

If you already keep the base model for full-quality work, the Pruna LoRA is the lighter way to add a fast mode: one small file and a different sigma schedule. If you only ever want fast output, a dedicated Turbo checkpoint is the simpler setup. See our Qwen Image 2.1 Turbo workflow to compare.

Limitations

• Not a finished release. Pruna says to expect the weights to change in future versions.
• Not full base quality. Distillation does not guarantee identical outputs. Use the base model when you need its full quality.
• Fixed settings only. Only the stated step counts, sigma schedules and CFG 1 are supported.
• 1K training. 2K and above may work but quality varies.
• Three references max for editing.
• Non-commercial. The adapters are derivatives of Qwen Image 2.1 under the Qwen Research License Agreement.

FAQ

Can I change the LoRA strength?

No. The alpha scale is folded into the weights, so 1.0 is the trained setting. Other values break the distillation.

Why do I need ManualSigmas?

The adapters were trained on specific noise levels. A normal scheduler with 6 steps gives different noise levels and softer or broken images.

Can I use it with the Qwen Image 2.1 Turbo checkpoint?

No. Use the base checkpoint. The LoRA was trained on the base model.

Can I use the images commercially?

The Qwen Research License restricts commercial use. Read the licence in the repo before any commercial work.

Does it need custom nodes?

No. LoraLoaderModelOnly, ManualSigmas and the sampler nodes are all core ComfyUI.

Which is faster, 5 steps or 6 steps?

The v0.1 5-step LoRA is slightly faster, but its images are visibly worse. The v0.2 6-step LoRA is the better trade.

Final Thoughts

Pruna’s P-Q-Image-2.1 v0.2 LoRAs are a simple way to make Qwen Image 2.1 practical on a home GPU. One LoRA file, one ManualSigmas node, CFG 1, and you get 6-step generation and editing with the prompt enhancer built in if you want it. Remember the strict settings, stay near 1024px, and treat it as a fast mode next to the base model rather than a full replacement. For quick drafts, thumbnails and edits, it is a big time saver.

More AI image guides:

• Best Qwen Image 2.1 Turbo Workflow for 16 GB
• Krea 2 Turbo in 3 Steps: The 3-Step Distill LoRA
• ComfyArt: Free Local AI Design Canvas for ComfyUI
• Best Open-Source Text-to-Image Models

Sources

• Hugging Face: PrunaAI/P-Q-Image-2.1-Comfy (files, workflows and settings, read November 1, 2026)
• Hugging Face: PrunaAI/P-Q-Image-2.1 (benchmarks, LoRA details, diffusers usage)
• ComfyUI Wiki: Pruna 6-step LoRAs for ComfyUI
• Hugging Face: Qwen/Qwen-Image-2.1