Qwen-Image-2.1

Qwen-Image-2.1 is an open-weights image model from Alibaba's Qwen team that handles text-to-image generation and image editing in a single checkpoint. It is not a language model and does not generate text, it takes text prompts (and optionally reference images) as input and produces images as output. The headline number is 7.12B parameters, all of which sit in the visual generation component: a dense, 32-layer Single-Stream Diffusion Transformer.

That parameter count is the story. Competing open image models at this quality tier generally run 8B to 20B, and most of them split generation and editing into separate checkpoints. Qwen-Image-2.1 collapses both into one ~7B model and adds something the others largely don't do natively: transparent RGBA output. If you are building local image pipelines and your constraint is VRAM rather than absolute peak fidelity, this is a model worth evaluating seriously.

Specs at a glance:

• Parameters: 7.12B (dense, visual generation component)
• Architecture: 32 Single-Stream DiT layers
• Input: text prompts, up to 10 reference images for editing
• Output: regular or transparent RGBA images, up to 2752×1536
• License: Qwen Research License Agreement
• Weights: Hugging Face (Qwen/Qwen-Image-2.1), ModelScope

The license matters before you go further. The Qwen Research License Agreement is not Apache 2.0, review the terms carefully if you intend to ship this in a commercial product rather than use it for research and internal work.

The "Single-Stream" designation describes how text and image tokens are handled. Rather than running separate transformer weight sets for text and image streams and cross-attending between them (the MMDiT approach used by SD3.5 and FLUX), Qwen-Image-2.1 concatenates text and image tokens into one sequence and processes them through the same 32 DiT blocks. Fewer distinct parameters are required for a given depth, which is part of how it lands at 7.12B without collapsing in quality.

Two optimizations do the heavy lifting in practice:

• Mixed-granularity attentionattention is not applied uniformly across the sequence, reducing the quadratic cost that otherwise dominates at high resolutions.
• Prefix KV cache reusethe prompt-side key/value tensors are computed once and reused rather than recomputed. This helps two ways: across denoising steps within a single render, and across requests that share a prompt. Batch-generating variations from one prompt amortizes prompt encoding to near zero.

Because the model is denseevery one of the 7.12B parameters activates on every forward pass. There is no expert routing. That means no surprise VRAM spikes, no need to hold a large pool of inactive experts in memory, and quantization behaves predictably, but you also get no "big model capacity at small model compute" trick. What you see is what you pay.

Context length is not published for this release. For a diffusion model this is less consequential than for an LLM: the real token budget is dominated by image latents, not prompt text. Attention cost scales with the square of the combined text-plus-image sequence, so a 2752×1536 render is dramatically more expensive than 1024×1024 even though the prompt is identical.

Text-to-image generation. The model is built for prompt-faithful rendering with improved typography, the release examples include legible quoted text inside generated signage, which has historically been the failure mode of open image models. Portrait lighting and fine texture detail are also called out as improved over the prior generation.

Native transparency. This is the differentiator. Qwen-Image-2.1 generates RGBA images directly, edits existing transparent layers, and extracts subjects from photographs into cutouts. Concrete uses: game and app assets, icon sets, sticker packs, product cutouts for compositing, UI mockups, and layered graphic design, all without a separate matting model in the pipeline.

Instruction-based editing. Up to 10 reference images can be supplied in a single edit. Local edits can be specified with circles, painted annotations, or separate masks. Identity preservation for people and products is a stated target, which makes it viable for catalog work, swap a background, restyle a garment, or composite a model into a new scene without redrawing the subject.

Where it doesn't fit. Anything requiring text generation, reasoning, or chat. It also does not do video or audio. And note that "tokens per second" is not a meaningful metric here, throughput is measured in images per second or seconds per iteration. If your workload needs an LLM alongside an image model, plan on running two models.

Weight footprints, before the text encoder, VAE, and attention activations:

Treat the right-hand column as the number that actually matters. A 2048×2048 render at 40 steps allocates large attention buffers on top of the weights, and those scale with resolution. Q4_K_M is the sensible default for most people: it fits 8–12 GB cards and the quality loss on a diffusion model is far less punishing than on an LLM, because you are not compounding errors across thousands of autoregressive steps.

• RTX 4090 / 5090 (24–32 GB): BF16 or FP8, full 2752×1536 output, no compromises.
• RTX 3090 (24 GB): same, slower per step.
• RTX 4070 Ti Super / 4080 (16 GB): FP8 or Q8 at moderate resolutions; step up batch size or resolution carefully.
• RTX 3060 12 GB / 4060 Ti 16 GB: Q4_K_M at 1024–1536px. Expect it to work, not to be fast.
• Apple Silicon (M4 Max, 64 GB unified): FP8/Q8 with generous headroom, but MPS throughput for DiT attention lags NVIDIA by a wide margin, fine for interactive work, not for batch rendering.

Ollama is not the shortest path here. Ollama targets LLM inference and does not run diffusion pipelines. The fastest routes are:

• ComfyUInative day-0 support, with official weights at Comfy-Org/Qwen-Image-2.1 and ready-made text-to-image and editing workflows.
• DiffusersQwenImage21Pipeline, alongside transformers and torch>=2.4.0.
• vLLM-Omni / SGLangif you need serving-grade throughput. Both landed day-0 support with prefix KV caching, CUDA Graph decoding, FP8 quantization, and TP/Ulysses parallelism. This is the path for multi-user or batch generation, where the cache reuse is worth the operational complexity.

Budget roughly 30–60 seconds per 1024px image at 40 steps on a 24 GB card, scaling up with resolution and down with quantization. Independent throughput benchmarks are not yet widely published, measure on your own target resolution before committing to a hardware purchase.

vs. FLUX.1-dev (12B, non-commercial license). FLUX.1-dev is the default reference point for open text-to-image work and generally has the edge in raw aesthetic polish on complex scenes. It is roughly 1.7× the parameter count, which shows up directly in VRAM and step latency, and it does not generate native RGBA or handle multi-reference editing in the same unified way. Take Qwen-Image-2.1 when you need transparent output, reference-image editing, or a smaller memory footprint. Take FLUX.1-dev when pure generation fidelity on single-shot prompts is the only thing that matters.

vs. Stable Diffusion 3.5 Large (8B). Comparable parameter count, but SD3.5 Large is generation-only and its ecosystem splits editing out into separate control and inpainting pipelines. Qwen-Image-2.1 gives you generation, masked editing, up to 10 reference images, and transparency in one checkpoint, less VRAM for the whole pipeline, not just the base model. SD3.5 retains the advantage of a much larger fine-tune and LoRA ecosystem, and a more permissive license at lower revenue thresholds.

The deciding question is usually pipeline complexity. If your workflow is prompt-to-image and nothing else, the alternatives are competitive. If it involves cutouts, layers, reference-conditioned edits, or multiple models duct-taped together, Qwen-Image-2.1 replaces most of that stack with one 7.12B checkpoint.