Model Overview

Description:

The NVIDIA Qwen-Image-Flash model generates images from text prompts using a four-step, DMD2-distilled version of Qwen/Qwen-Image. The distillation used DMD2 from NVIDIA FastGen, NVIDIA Model Optimizer, and NVIDIA AutoModel while retaining the base model architecture. The packaged scheduler is configured for the four-step, shift-3 trajectory.

Showcase

All showcase images were generated with nvidia/Qwen-Image-Flash.

This model is ready for commercial or non-commercial use.

License/Terms of Use:

Governing Terms: Use of this model is governed by the NVIDIA Open Model Agreement([https://www.nvidia.com/en-us/agreements/enterprise-software/nvidia-open-model-agreement/])) .

Additional Information: Apache License 2.0.

Deployment Geography:

Global

Use Case:

Developers and researchers evaluating few-step text-to-image generation, including creative-content prototyping and latency-sensitive image-generation workflows. Image editing, image understanding, and safety- or life-critical decision-making are outside the intended scope of this checkpoint.

Release Date:

Hugging Face 07/23/2026 via nvidia/Qwen-Image-Flash

Reference(s):

• Qwen-Image model card
• Qwen-Image Technical Report
• Improved Distribution Matching Distillation for Fast Image Synthesis (DMD2)
• NVIDIA Model Optimizer
• NVIDIA FastGen
• NVIDIA NeMo AutoModel

Model Architecture:

Architecture Type: Diffusion Transformer (MMDiT)

Network Architecture: QwenImageTransformer2DModel in a QwenImagePipeline

Base Model: Qwen/Qwen-Image

Number of Model Parameters: 20.43B parameters in the denoising transformer; 28.85B learned parameters in the full pipeline when the text encoder and VAE are included.

The full pipeline contains a Qwen2.5-VL text encoder, Qwen tokenizer, 60-layer Qwen-Image transformer, Qwen-Image VAE, and FlowMatch Euler scheduler. The transformer has the same architecture as the base Qwen-Image transformer; its weights are replaced by the distilled student weights.

Input:

Input Type(s): Text

Input Format(s): String

Input Parameters: One-Dimensional (1D) sequence

Other Properties Related to Input: The release was distilled with English captions. Any inherited Chinese-language capability has not been evaluated for this model. The pipeline allows at most 1,024 prompt tokens and defaults to 512.

Output:

Output Type(s): Image

Output Format: Red, Green, Blue (RGB)

Output Parameters: Two-Dimensional (2D)

Other Properties Related to Output: The pipeline returns generated images, typically as Python Imaging Library (PIL) images. The tested output setting is 1024 × 1024 pixels. Use width and height values divisible by 16 to avoid automatic resizing.

Our AI models are designed and/or optimized to run on NVIDIA GPU-accelerated systems. By leveraging NVIDIA hardware and software frameworks such as CUDA and PyTorch, the model can achieve faster inference than CPU-only execution.

Software Integration:

Supported Runtime Engine(s):

• Hugging Face Diffusers 0.38.0 with Transformers 5.12.1
• SGLang Diffusion: lmsysorg/sglang:nightly-dev-cu13-20260721-8905cbd4
• vLLM-Omni: vllm/vllm-omni:v0.24.0
• TensorRT-LLM VisualGen: nvcr.io/nvidia/tensorrt-llm/release:1.3.0rc21

Supported Hardware Microarchitecture Compatibility:

• NVIDIA Hopper H100
• NVIDIA Blackwell B200

Preferred Operating System(s):

• Linux

The integration of foundation and fine-tuned models into AI systems requires additional testing using use-case-specific data to ensure safe and effective deployment. Following the V-model methodology, iterative testing and validation at both unit and system levels are essential to mitigate risks, meet technical and functional requirements, and ensure compliance with safety and ethical standards before deployment.

Model Version(s):

Qwen-Image-Flash was distilled with NVIDIA Model Optimizer 0.45.0.

Training and Evaluation Datasets:

Training Dataset:

Source Prompt Dataset: ProGamerGov/synthetic-dataset-1m-dalle3-high-quality-captions, dataset is comprised of AI-generated images sourced from various websites and individuals, primarily focusing on Dalle 3 content.

Image Generator: Qwen/Qwen-Image

Internal Training Dataset Identifier: qwen-image-synthetic-dalle3-1m

Data Modality: Text, Image

Text Training Data Size: [Less than a Billion Tokens]

Image Training Data Size: [Less than a Million Images]

Data Collection Method by dataset: Hybrid: Automated, Synthetic

Labeling Method by dataset: Automated

Properties: Only text prompts from the ProGamerGov dataset were used; its original images were not used for training. Each prompt was passed to the original Qwen-Image model to generate a new synthetic image. The resulting dataset contains 1,000,000 English prompt–image pairs processed at 1024 × 1024, and a subset was used for Distribution Matching Distillation (DMD2) training.

Evaluation Dataset:

Link: Qwen-Image-Bench, OneIG-Bench-EN

Data Collection Method by dataset: Manually-collected

Labeling Method by dataset: Automated

Properties: Qwen-Image-Bench: 1,000 prompts; OneIG-Bench-EN: 1,120 English prompts across five categories.

Inference:

Acceleration Engine: Hugging Face Diffusers, SGLang Diffusion, vLLM-Omni, and TensorRT-LLM VisualGen

Test Hardware: NVIDIA GB200

DMD2 Distillation

Qwen-Image-Flash was trained using multi-step DMD2 (Distribution Matching Distillation) to approximate the output distribution of Qwen-Image in four denoising steps. The student retains the base transformer's architecture and parameter count. The four-step design reduces the number of transformer evaluations but does not reduce the checkpoint's parameter count or memory requirements.

The teacher target used classifier-free guidance (CFG) 4.0 during distillation. That guidance is internalized by the student, so inference uses true_cfg_scale=1.0 to avoid applying guidance a second time. The packaged static shift-3 FlowMatch Euler scheduler produces effective sigmas [1.0, 0.9, 0.75, 0.5, 0.0] over the required four steps.

Usage

Diffusers

Tested container: vllm/vllm-omni:v0.24.0 (diffusers==0.38.0, transformers==5.12.1)

import torch
from diffusers import QwenImagePipeline

pipe = QwenImagePipeline.from_pretrained(
    "nvidia/Qwen-Image-Flash",
    torch_dtype=torch.bfloat16,
).to("cuda")

image = pipe(
    prompt="A red fox in a snowy pine forest at golden hour, photorealistic, sharp focus, soft bokeh",
    width=1024,
    height=1024,
    num_inference_steps=4,
    true_cfg_scale=1.0,
    guidance_scale=None,
    negative_prompt=None,
    generator=torch.Generator(device="cuda").manual_seed(42),
).images[0]

image.save("qwen-image-flash-diffusers.png")

SGLang Diffusion

Tested container: lmsysorg/sglang:nightly-dev-cu13-20260721-8905cbd4

docker run --rm --gpus all --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 -e HF_TOKEN -v qwen-image-hf-cache:/root/.cache/huggingface -v "$PWD:/workspace" -w /workspace lmsysorg/sglang:nightly-dev-cu13-20260721-8905cbd4 sglang generate --model-path nvidia/Qwen-Image-Flash --prompt "A red fox in a snowy pine forest at golden hour, photorealistic, sharp focus, soft bokeh" --width 1024 --height 1024 --num-inference-steps 4 --guidance-scale 1.0 --true-cfg-scale 1.0 --seed 42 --save-output --output-file-path qwen-image-flash-sglang.png

vLLM-Omni

Tested container: vllm/vllm-omni:v0.24.0

# Server
docker run --rm --gpus all --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 -e HF_TOKEN -p 8091:8091 -v qwen-image-hf-cache:/root/.cache/huggingface vllm/vllm-omni:v0.24.0 vllm serve nvidia/Qwen-Image-Flash --omni --host 0.0.0.0 --port 8091

# Client
curl -fsS http://127.0.0.1:8091/v1/images/generations -H 'Content-Type: application/json' -d '{"prompt":"A red fox in a snowy pine forest at golden hour, photorealistic, sharp focus, soft bokeh","n":1,"size":"1024x1024","response_format":"b64_json","num_inference_steps":4,"true_cfg_scale":1.0,"guidance_scale":1.0,"seed":42}' -o qwen-image-flash-vllm-omni-response.json
set -o pipefail; jq -er '.data[0].b64_json' qwen-image-flash-vllm-omni-response.json | base64 --decode > qwen-image-flash-vllm-omni.png

TensorRT-LLM

Tested container: nvcr.io/nvidia/tensorrt-llm/release:1.3.0rc21

from tensorrt_llm import VisualGen


def main():
    visual_gen = VisualGen(model="nvidia/Qwen-Image-Flash")
    try:
        params = visual_gen.default_params
        params.width = 1024
        params.height = 1024
        params.num_inference_steps = 4
        params.guidance_scale = 1.0
        params.negative_prompt = None
        params.seed = 42

        output = visual_gen.generate(
            inputs="A red fox in a snowy pine forest at golden hour, photorealistic, sharp focus, soft bokeh",
            params=params,
        )
        output.save("qwen-image-flash-tensorrt-llm.png")
    finally:
        visual_gen.shutdown()


if __name__ == "__main__":
    main()

Evaluation

The following results compare Qwen-Image-Flash with Qwen-Image and Qwen-Image-Lightning:

Evaluation was performed at 1024 × 1024 resolution on an NVIDIA B200 GPU.

* OneIG-Bench-EN publishes no aggregate score; the value shown is the unweighted mean of its five dimensions (alignment, text, reasoning, style, diversity), each scored over the full 1,120-prompt EN set.

Ethical Considerations

NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. Developers should work with their internal model team to ensure this model meets requirements for the relevant industry and use case and addresses unforeseen product misuse.

For more detailed information on ethical considerations for this model, please see the Model Card++ Explainability, Bias, Safety & Security, and Privacy Subcards below.

Please report model quality, risk, security vulnerabilities or NVIDIA AI Concerns here.

SUBCARDS:

Explainability

Additional Information: Apache License 2.0.) |

Bias

Safety & Security

Additional Information: Apache License 2.0 , and applicable law. Image editing, image understanding, high-stakes decisions, and illegal or abusive content generation are outside the intended scope. | | Model and Dataset Restrictions | The Principle of least privilege (PoLP) is applied limiting access for dataset generation and model development. Restrictions enforce dataset access during training, and dataset license constraints adhered to. |

Privacy