Qwen-Image 2.1 Lightning v2 RL: 4-Step Setup, Files, VRAM and ComfyUI Status (2026)

Qwen-Image 2.1 makes beautiful images, but 40 steps per picture is slow on a home GPU. The LightX2V team has now shipped Lightning v2 RL, a 4-step version refined with reinforcement learning.

It is not another LoRA. It is a full replacement transformer, and that changes how you download it, how you run it and whether ComfyUI can load it today.

This guide covers what changed from v1, the exact files, a working Diffusers script, VRAM needs, the current ComfyUI status, and the 4-step route you can use in ComfyUI right now.

What Is Lightning v2 RL?

Lightning v2 RL is a speed-distilled copy of Qwen-Image 2.1, Alibaba’s 7B text-to-image and editing model. It was published on Hugging Face by LightX2V (ModelTC), the team behind the popular Wan and Qwen “Lightning” speed-ups.

The idea is simple. The base model needs about 40 denoising steps. The distilled model learns to get a similar picture in 4 steps, roughly a 10x cut in sampling time.

The “RL” part is new. After distillation, the team ran a reinforcement-learning stage with their open lightx2v_rl code to push quality back towards the 40-step teacher. Only this RL-refined checkpoint is public; the pre-RL v2 weights were not released.

It handles three jobs:

• Text-to-image: a prompt in, a 1024×1024 image out.
• Single-reference editing: pass one image and describe the change.
• Multi-reference generation: pass several images and refer to them in the prompt as <image1>, <image2> and so on.

Lightning v1 LoRA vs v2 RL: What Changed

The first Qwen-Image 2.1 Lightning came out on 13 October 2026. It was a small LoRA you added on top of the normal model. Version 2 takes a different route.

The schedule change is the interesting bit. v2 spends most of its effort in the high-noise steps, where layout and composition are decided. That usually helps structure and prompt following, which is where 4-step models tend to fall apart.

Note: LightX2V shows side-by-side examples against 40-step Qwen-Image 2.1, but publishes no benchmark scores. Treat quality claims as “selected examples”, not measured results.

Files, Sizes and What You Download

The repo only holds the transformer. The text encoder, VAE and processor come from the base Qwen/Qwen-Image-2.1 pipeline, which Diffusers downloads for you.

Download only what you need with the Hugging Face CLI:

pip install -U "huggingface_hub[cli]"
hf download lightx2v/Qwen-Image-2.1-Lightning-v2-RL \
  diffusion_pytorch_model.safetensors config.json inference_config.json \
  --local-dir ./qwen21-lightning-v2-rl

Tip: the first run also pulls the base Qwen-Image 2.1 text encoder and VAE into your Hugging Face cache. Check you have 60 GB or more of free disk before you start.

VRAM and RAM You Need

LightX2V does not publish VRAM figures. The numbers below are my estimates from the file sizes, so treat them as a starting point.

• 24 GB or more (RTX 4090, 5090, 3090): run with enable_model_cpu_offload(). The encoder and transformer take turns on the GPU.
• 16 GB (RTX 5080, 4080, 4070 Ti Super): CPU offload is required, and it will be tight. Keep 32 GB+ system RAM, ideally 64 GB.
• 12 GB and below: use enable_sequential_cpu_offload() (slow) or wait for an fp8/GGUF build. The v1 LoRA in ComfyUI is the better option for now.

For the bigger picture on how VRAM splits between model, encoder and activations, see my how much VRAM do I need for AI guide.

How to Run It With Diffusers (Step by Step)

The model card’s quick start swaps the Lightning transformer into the base Qwen-Image 2.1 pipeline and passes the stored sigmas. Here is the same approach as a full script.

1. Create a clean Python environment. Python 3.11 or 3.12 and a CUDA build of PyTorch.
2. Install the libraries. The pipeline class is new, so Diffusers must come from git.

   pip install git+https://github.com/huggingface/diffusers
   pip install "transformers>=5.17.0" accelerate safetensors pillow

3. Download the transformer with the hf download command above.
4. Save the script below as lightning_v2.py and run it.

import json, torch
from diffusers import QwenImage21Pipeline, QwenImage21Transformer2DModel

repo = "./qwen21-lightning-v2-rl"
cfg = json.load(open(f"{repo}/inference_config.json"))

transformer = QwenImage21Transformer2DModel.from_pretrained(
    repo, torch_dtype=torch.bfloat16)

pipe = QwenImage21Pipeline.from_pretrained(
    "Qwen/Qwen-Image-2.1", transformer=transformer,
    torch_dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()   # needed on 16-24 GB cards

sigmas = [1.0, 0.95418, 0.89508, 0.704534]  # from inference_config.json

image = pipe(
    prompt="a cosy reading nook by a rainy window, warm lamp light, photo",
    width=1024, height=1024,
    sigmas=sigmas,
    true_cfg_scale=1.0,
    generator=torch.Generator("cuda").manual_seed(42),
).images[0]
image.save("lightning_v2.png")

Three settings matter more than anything else:

• Sigmas: pass the four values from inference_config.json. Do not just set num_inference_steps=4.
• No extra shift: the sigmas are already shifted, so dynamic shifting must stay off. The card configures the FlowMatchEulerDiscreteScheduler from inference_config["scheduler"].
• CFG 1.0: higher values burn the image, as with every distilled model.

Editing and multi-reference prompts

For a single-image edit, load your picture with Pillow and pass it as image= with an instruction prompt such as “change the jacket to red leather”.

For multi-reference, pass a list of images in the same order your prompt names them, for example “the woman from <image1> holding the mug from <image2>”. Keep width and height multiples of 32.

Warning: class and argument names come from the model card at launch and from a git build of Diffusers. If an import fails, check the card’s quick start for any rename before reporting a bug.

Can You Use It in ComfyUI?

Two things block a simple drop-in today:

• Key names: Diffusers transformer keys differ from the layout ComfyUI’s Qwen-Image 2.1 loader expects, so the file has to be converted first.
• The schedule: even after conversion, you need the exact four sigmas. ComfyUI can do that with a SamplerCustomAdvanced graph and a manual sigmas node (for example from KJNodes), but nobody has published a tested workflow yet.

When Comfy-Org or the community posts a converted file, it will almost certainly go in ComfyUI/models/diffusion_models/ and load with the Load Diffusion Model node, like other Qwen-Image 2.1 checkpoints. I will update this guide when that happens.

4-Step Qwen-Image 2.1 in ComfyUI Today (v1 LoRA Setup)

If you live in ComfyUI, the v1 Lightning LoRA gives you 4-step generation right now. You need the normal Qwen-Image 2.1 files plus one small LoRA.

1. Update ComfyUI so the Qwen-Image 2.1 nodes are present (Manager > Update ComfyUI, or git pull in the ComfyUI folder).
2. Load the official Qwen-Image 2.1 template from Workflow > Browse Templates.
3. Add a LoraLoaderModelOnly node between Load Diffusion Model and the sampler, pick the Lightning LoRA, strength 1.0.
4. Set the KSampler to 4 steps, CFG 1.0, sampler euler, scheduler simple.
5. Queue a 1024×1024 test and compare with the 40-step template on the same seed.

Not sure where a file goes? My ComfyUI model folder cheat sheet and the Qwen-Image model files guide list every path.

Lightning v2 RL vs Turbo vs Pruna 6-Step

Qwen-Image 2.1 now has several fast options. Here is how they line up.

For editing work in ComfyUI, my Qwen-Image 2.1 edit guide covers multi-image edits and edit LoRAs.

Troubleshooting

ImportError: cannot import name ‘QwenImage21Pipeline’

Your Diffusers is a PyPI release that predates the class. Reinstall from git with pip install -U git+https://github.com/huggingface/diffusers, then restart Python.

Images look soft, washed out or noisy

This is almost always the schedule. Make sure you pass the four sigmas and that the scheduler is not shifting them again. Running num_inference_steps=4 with default sigmas gives visibly worse results.

Over-saturated or “burnt” images

CFG is above 1.0. Distilled models expect true_cfg_scale=1.0; negative prompts have no effect at that value.

CUDA out of memory on a 16 GB card

Load in BF16, not FP32, and call pipe.enable_model_cpu_offload() before generating. If it still fails, try enable_sequential_cpu_offload() or drop to 768×768. My CUDA out of memory fix guide has more options.

ComfyUI error when loading the file

Errors like “missing keys” or “unknown model type” mean you tried the raw Diffusers file in Load Diffusion Model. It is not converted for ComfyUI. Use the v1 LoRA route above until a converted checkpoint appears.

Small text or hands come out wrong

The card itself warns that fine text, anatomy and object counts may need checking. Re-roll the seed, or use the 40-step base model for posters with small lettering.

Licence and Limits

• Licence: the card says the model is derived from Qwen-Image 2.1 and is subject to the Qwen Research License, including its non-commercial terms. Do not use it for client work without checking.
• No benchmarks: only qualitative side-by-sides are published.
• No hosted API: no inference provider serves it yet; there is a demo Space (hugging-apps/qwen-image-2-1-lightning-v2-rl).
• Apps: Hugging Face lists Draw Things and DiffusionBee as local app options for Mac users.

My Take

Lightning v2 RL is the most interesting speed-up for Qwen-Image 2.1 so far, because the front-loaded schedule and RL stage target the exact weakness of 4-step models: messy layouts.

For most of my readers, though, the practical answer today is the v1 LoRA in ComfyUI, or Turbo at 8 steps on a 16 GB card. A 28.5 GB FP32 file is not friendly to home GPUs until someone publishes an fp8 or GGUF conversion.

If you already use Diffusers, it is worth a test right now. Everyone else should bookmark this page; the ComfyUI conversion usually follows within days for LightX2V releases.

FAQ

What is Qwen-Image 2.1 Lightning v2 RL?

A 4-step distilled version of Alibaba’s Qwen-Image 2.1, refined with reinforcement learning by LightX2V. It does text-to-image, editing and multi-reference generation at CFG 1.0.

Is Lightning v2 RL a LoRA?

No. It is a full replacement transformer (28.5 GB in FP32). The v1 Lightning release was the 67 MB LoRA.

Does Lightning v2 RL work in ComfyUI?

Not at launch. There are no ComfyUI-format weights. Use the v1 LoRA with 4 steps and CFG 1 in ComfyUI until a conversion is published.

How much VRAM does Lightning v2 RL need?

No official figure exists. In BF16 the transformer is about 14 GB plus a large text encoder, so plan on 24 GB, or 16 GB with CPU offload and 64 GB system RAM.

What sampler settings does it use?

Four steps with sigmas 1.0, 0.95418, 0.89508 and 0.704534, a FlowMatch Euler scheduler with no extra shifting, and CFG 1.0.

Can I use Lightning v2 RL commercially?

The card says it follows the Qwen Research License, including non-commercial terms. Check that licence before any paid use.

Is it better than Qwen-Image 2.1 Turbo?

It is faster (4 vs 8 steps), but there are no published benchmarks comparing them. Turbo works in ComfyUI today, which makes it the easier choice for most people.

Sources

• Hugging Face: lightx2v/Qwen-Image-2.1-Lightning-v2-RL model card
• ComfyUI Wiki: Lightning v2 RL news
• ComfyUI Wiki: Qwen-Image 2.1 Lightning (v1)
• GitHub: ModelTC/LightX2V
• Hugging Face: Qwen/Qwen-Image-2.1