How to Install Qwen-Image-2.1 on Windows & Kali Linux

Alibaba has Openweighted its Qwen 2.1 Image generation Model. File size is 33GB. You can try demo as well in this link. Qwen-Image-2.1 installs on Windows and Kali Linux through one of three routes — ComfyUI (node-based, easiest), Diffusers (Python library, for coders), or DiffSynth-Studio (ModelScope's own framework, with built-in VRAM management that claims a 7 GB minimum) — and the part almost nobody tells you up front is that the "7B" on the label describes only the image-drawing half of the model. The full BF16 download is roughly 33 GB, because the text-encoder brain sitting next to it, a Qwen3-VL 8B, is on its own bigger than the image generator you thought you were installing. Released September 20, 2026, it unifies text-to-image generation and image editing in one checkpoint, outputs real transparent PNGs with an alpha channel, accepts up to ten reference images per edit, and writes legible text into images — but it ships under a non-commercial research license that replaced Apache 2.0 from the previous Qwen-Image line, which changes who should install it at all.

What "7B" Actually Means Here — and Why the Download Is 33 GB

Every AI image model is really three programs wearing one name, and Qwen-Image-2.1 is no exception. The "7B" figure — seven billion parameters, where a parameter is one learned number inside the model, the unit you count the same way you count transistors on a chip — refers only to the diffusion transformer, the component that actually paints pixels. A diffusion transformer, often abbreviated DiT, works by starting with static noise and repeatedly refining it toward whatever the text asked for, one denoising step at a time. Qwen-Image-2.1 uses a single-stream block-causal DiT with 32 layers, which is a lighter architecture than the 20B MMDiT used in the earlier Qwen-Image and Qwen-Image 2.0 releases.

Next to it sits the text encoder, a Qwen3-VL 8B — that's an eight-billion-parameter vision-language model whose entire job is reading your prompt (and your reference images, when you edit) and turning them into numbers the DiT can act on. Eight billion is bigger than seven billion. The encoder is the larger half of this bundle at roughly 17.5 GB in BF16, while the DiT itself is about 14.2 GB.

The third piece is the VAE — short for variational autoencoder, the translator between the model's compressed internal image representation and actual pixels you can save. Qwen-Image-2.1's VAE is a 64-channel RGBA unit with 16× spatial compression, and the extra channels are exactly why the model can output real transparency without a background-removal tool. The pipeline works in a 4-channel RGBA pixel space where the 4th decoded channel is the alpha, so transparency comes from the prompt itself, not from a post-processing step.

Those file sizes come straight from the official repository listing, and they are disk storage figures — the space the files occupy on your drive — not the peak VRAM the model uses while generating. VRAM is your graphics card's own dedicated memory, and a generation run needs room for the weights plus the working image data on top, so plan for more than the file size, not less.

Jake's shop has a concrete problem this model solves: he pays a freelancer $40 per product cutout for the phone-case listings on his site. Every new color, every new case model, another $40. He did the math once and stopped — it was more than his phone bill.

"So I'm looking at a model that makes the thing I've been paying someone else to make," Jake said when Ethan first showed him the download page. "What's the catch? There's always a catch."

"Two catches," Ethan said. "The license, and your GPU. We'll get to both. But the transparent-background thing you've been paying $40 for — that's built into this one. The alpha channel is native, not bolted on."

"Meaning what, in English?"

"Meaning you ask for 'a phone case isolated on a fully transparent background' and that's what you get. No background-removal step. No edge cleanup. The model paints the transparency in the same pass as the case."

Which Qwen Image Model Is This? (2.1 vs 2.0 vs 2512 vs Edit, Untangled)

The Qwen image family has shipped enough similarly-named models that the version numbers blur together, so here is the honest map before you install the wrong one. The line runs: Qwen-Image (the original 20B, August 2025, Apache 2.0), Qwen-Image-Edit (the editing companion, built on the same 20B base, August 2025), then versioned edits like Qwen-Image-Edit-2509 and -2511, then Qwen-Image-2512, then Qwen-Image-2.0 (February 2026, which first unified generation and editing at 7B, Apache 2.0), and now Qwen-Image-2.1 (September 20, 2026, which is the version this article installs).

The critical break is the license. Every Qwen-Image model before 2.1 shipped under Apache 2.0, which let you build commercial products on the weights freely. Qwen-Image-2.1 ships under the Qwen Research License Agreement, which covers non-commercial use only. If you followed the earlier models and assumed the same terms carried forward, they did not.

Qwen-Image-2.1 is not "Qwen-Image 3.0" — no model by that name appears in any official source used here. The number after the decimal is a version within the 2.x line, not a major release. If you see a guide for "Qwen Image 3.0," check whether it is actually describing a different model or an early-access preview with a different name.

The License Nobody Mentions First

Jake read the license line twice. "Non-commercial. So the phone case mockups — is that commercial?"

"If they help sell a case, yes," Ethan said. "Look, this is the single most important paragraph in the article and most guides bury it. The model is open-weight, which means you can download and run it. Open-weight is not the same as free-for-anything. Your shop is revenue. This license doesn't cover it."

"So why are we even installing it?"

"Because the previous Qwen-Image models were Apache 2.0 — fully commercial, no strings. If you want the commercial version today, that's still Qwen-Image-2.0 or the 2512 line. But 2.1 is where the transparency is native and the editing is unified, and when they offer a commercial license for it — and they will, that's how this pattern always goes — you'll already know the tool. Learn on the research license, decide on the business."

Before You Download: Disk, VRAM, and Time

Three resources decide whether this install will be pleasant or painful: disk space, VRAM, and patience. Here is what each one costs you, using the documented file sizes rather than guesses.

Disk. The INT8 route — three files, which is what the official ComfyUI templates select by default — totals approximately 17.28 GB. The BF16 route, the less-compressed original files, totals approximately 32.44 GB. Add room on top for ComfyUI itself, its Python dependencies, your input images, and your output PNGs, which at 2048×2048 are not small. A drive with 40 GB free makes the BF16 route comfortable; 25 GB free covers the INT8 route with breathing room.

VRAM. Two different official sources give two different numbers, and both are worth knowing. The DiffSynth-Studio framework documentation states a minimum of 7 GB VRAM, with the framework automatically controlling parameter loading based on available VRAM — that is the lowest official claim for any route. Third-party hosting analyses estimate roughly 16 GB for full-precision BF16 inference. The difference is that DiffSynth-Studio's VRAM management streams components between disk, CPU, and GPU automatically, while the Diffusers and ComfyUI routes load more aggressively.

A conservative test sequence, rather than a promise, for each GPU tier:

That table is a sequence to test, not a guarantee — a specific GPU, driver version, resolution, and reference-image count all change the answer, and multi-reference editing needs more memory than plain text-to-image at the same settings. Watch your VRAM and system RAM during the first run; the stage where a failure happens (loading, text encoding, sampling, or decoding) tells you which component to shrink.

Time. One early-access reviewer, running the final release weights through a ModelScope-hosted interface, reported roughly 10–15 seconds for text-to-image and 18–23 seconds for editing — one reviewer, one hosted interface, no timer shown. Treat that as "fast on decent hardware," not as a benchmark. On a smaller card with offload enabled, expect multiples of that.

Install on Windows 11 (ComfyUI Route, Step by Step)

ComfyUI is a node-based application for generative AI — instead of writing code, you wire together boxes on a canvas, each box doing one job. For most people on Windows, it is the fastest path to a working Qwen-Image-2.1 install, and the support is native and confirmed, not inferred: ComfyUI v0.37.0 shipped dedicated Qwen-Image-2.1 nodes, official workflow templates, and a Comfy-Org-repackaged weight set on the same day the model was released. An older ComfyUI will not show the nodes — that version check is the one real trap.

ComfyUI itself runs on Windows 10 and later, and the ComfyUI Portable build — a standalone package with its own embedded Python and CUDA (NVIDIA's GPU-computing platform) baked in — is the least painful option. You do not install Python yourself, you do not manage CUDA toolkits, you extract a folder and double-click a file.

1. Pick your portable build. On the ComfyUI download page, choose the NVIDIA package that matches your card: CUDA 13.0, Python 3.13 for modern RTX-series GPUs, or CUDA 12.6, Python 3.12 for GTX 10-series and older. There are separate packages for AMD and Intel GPUs too — more on those in the FAQ.
2. Extract with 7-ZIP to a drive with at least 25 GB free. The extracted folder contains run_nvidia_gpu.bat (or run_amd_gpu.bat), a ComfyUI folder, and an embedded Python environment.
3. Update ComfyUI to v0.37.0 or newer. Close ComfyUI first. For the portable build, run update/update_comfyui.bat inside the portable folder — the dev-channel updater; the similarly named stable updater follows releases. If you use Comfy Desktop instead, use the engine update controls in the Manage panel and select Latest on GitHub if the Stable channel lacks the needed support.
4. Download the three INT8 model files from the Comfy-Org repackage of Qwen-Image-2.1 on Hugging Face: qwen_image_2.1_int8_convrot.safetensors (7.26 GB) for the diffusion model, qwen3vl_8b_int8_convrot.safetensors (9.35 GB) for the text encoder, and qwen_image_2.1_vae_bf16.safetensors (0.68 GB) for the VAE. A .safetensors file is the standard safe-format container for model weights — the numbers the model learned, saved to disk.
5. Place each file in its exact subfolder under the ComfyUI folder:

   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

   Download one version of each component — you do not need every weight file in the repository, and a whole-repository download wastes tens of gigabytes on alternatives you will never select.
6. Restart ComfyUI (run_nvidia_gpu.bat) so the new files appear in the loaders.
7. Load the official workflow template. In the sidebar, open Templates (or Workflow → Browse Workflow Templates) and search for Qwen Image 2.1. If the template is missing from your build, download the official text-to-image JSON from the Comfy-Org workflow-templates repository and drag it onto the canvas — save the raw file with its .json extension; saving a GitHub HTML page as .json does not produce a valid workflow.
8. Verify the three loaders inside the template point at your exact filenames — the diffusion-model loader, the encoder's CLIPLoader (its type should read qwen_image), and the VAELoader. Keep the dedicated 2.1 VAE selected; an older similarly-named file is not what this workflow wants.

One Windows 11 habit worth unlearning while you are here: in File Explorer, the default landing page is now Home, and the legacy right-click options live under Show more options (or Shift+F10). When you are moving multi-gigabyte model files around, that condensed menu is where "Paste" hides.

Install on Windows 10 (and the One Honest Sentence About It)

These steps are the same on both — ComfyUI's portable and desktop builds support Windows 10 and later, the same model files go in the same subfolders, and the same templates load. Nothing about the Windows 10 route differs in substance.

The honest sentence: Windows 10 reached end of support on October 14, 2025, so a stock Windows 10 machine receives no free security updates anymore — consumer Extended Security Updates (enrollable via Settings > Windows Update, running to October 2027 for enrolled devices) are the bridge, and the same GPU that runs this model will run Windows 11 on most machines that shipped in the last several years. The install works on Windows 10 today; the plan to leave it should already exist.

If you stay on Windows 10 for now, the one practical difference in this workflow is nothing at all — the CUDA 12.6 portable build covers older GTX cards that Windows 11's hardware list sometimes rejects, which is a genuine reason some readers are still on 10. Use the same steps, the same files, the same template.

Install on Kali Linux (2026.2/2026.3)

Kali's current official release is 2026.2 (while you can still install Kali linux 2026.3 as we discussed), and the good news is that the ComfyUI route works identically on Linux — ComfyUI is the same program, the model files go in the same subfolders. The part that is genuinely different on Kali is the NVIDIA driver setup, which on Windows the portable build quietly handled for you.

Two Kali habits to respect before you start: no root login by default — run privileged commands with sudo, which asks for your own password — and prefer a Python virtual environment for anything pip installs. A virtual environment (created with python3 -m venv) is a private, throwaway copy of Python for one project, so a package upgrade for this model cannot break a system tool Kali depends on.

1. Update the system and confirm the release — sudo apt update && sudo apt full-upgrade -y, then verify you are on 2026.2 / 2026.3 (check /etc/os-release or the release notes on kali.org). Kali's DEB822-format sources file needs no legacy sources.list edits for this.
2. Install the NVIDIA driver. On Kali, the packaged route is sudo apt install nvidia-driver nvidia-smi (on a hybrid laptop with Optimus, nvidia-driver plus a reboot is the standard path; Kali's docs walk through the edge cases). After a reboot, nvidia-smi should list your card and its driver version — if that command fails, stop and fix the driver before touching any model, because nothing downstream will work.
3. Install the build tools and Python venv support — sudo apt install -y python3-pip python3-venv git.
4. Get ComfyUI v0.37.0 or newer. Clone and run it directly:

   git clone https://github.com/comfyanonymous/ComfyUI
   cd ComfyUI
   python3 -m venv venv
   source venv/bin/activate
   pip install torch torchvision --index-url https://download.pytorch.org/whl/cu126
   pip install -r requirements.txt

   The --index-url line pulls the CUDA-enabled build of PyTorch — PyTorch being the machine-learning framework everything here sits on — instead of the CPU-only one pip would install by default. Match the CUDA version to what nvidia-smi reports your driver supports.
5. Download the same three INT8 files from the Comfy-Org repackage and place them in the identical subfolders (ComfyUI/models/diffusion_models/, models/text_encoders/, models/vae/).
6. Launch with python main.py inside the activated venv, then open http://127.0.0.1:8188 in a browser. Load the official Qwen Image 2.1 template exactly as on Windows.

On Kali, there is also a plain-Diffusers route (next section) and a DiffSynth-Studio route (section after that) that skip ComfyUI entirely, and for some Kali users — the ones who live in a terminal and already script everything — those are the more natural homes. The driver requirement is identical either way; no NVIDIA driver, no local generation at usable speed.

Jake's first Linux GPU install was a Saturday he still talks about. Black screen after the driver install, three hours of forum posts in two languages, and the eventual discovery that nvidia-smi — the command that asks the GPU "are you there?" — was the thing he should have run first, not last. "I was debugging the model," he told Ethan later. "The model was fine. The GPU wasn't talking to anything."

"That's the whole Linux GPU experience in one sentence," Ethan said. "Windows hides the driver from you because it has to. Linux gives you the driver and the responsibility together. Run nvidia-smi first, every time, and you'll skip the Saturday."

The Diffusers Route (For Coders, Windows and Kali Both)

Diffusers is Hugging Face's Python library for running diffusion models in code — no canvas, no nodes, just a script you can put in a loop or a cron job. Qwen-Image-2.1 got day-zero Diffusers support through a pipeline class named QwenImage21Pipeline, which handles both text-to-image and image-conditioned generation in one object.

The official requirements, stated as versions rather than vague "latest" advice:

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

Three of those four are plain pip installs, but Diffusers itself comes from git — the QwenImage21Pipeline support is newer than the last stable release at the time the model shipped, so the git install is what gets you the right code. Then the shortest working text-to-image script, straight from the model card:

import torch
from diffusers import QwenImage21Pipeline

pipe = QwenImage21Pipeline.from_pretrained(
    "Qwen/Qwen-Image-2.1", torch_dtype=torch.bfloat16
).to("cuda")

image = pipe(
    prompt='A neon shop sign that reads "QWEN IMAGE 2.1", rainy night, reflections on wet pavement',
    num_inference_steps=40,
    generator=torch.Generator("cuda").manual_seed(42),
).images[0]
image.save("t2i_example.png")

The first run downloads the weights automatically from Hugging Face — all ~33 GB of them in BF16, because the Diffusers route pulls the original repository, not the Comfy-Org INT8 repackage. If you want the smaller files on this route, the W4A8 and quantized variants are a separate exercise in pointing the pipeline at local paths.

For image editing on this route, pass an image argument to the same pipeline object — the code doesn't change, only the call:

from PIL import Image

input_image = Image.open("input.png")
image = pipe(
    prompt="Change the background to a sunset beach",
    image=input_image,
    num_inference_steps=40,
    generator=torch.Generator("cuda").manual_seed(42),
).images[0]
image.save("edit_example.png")

For multiple references — which is where this model genuinely separates from Qwen-Image-Edit and the earlier separate-model line — pass a list:

images = [Image.open(f"ref_{i}.png") for i in range(3)]
result = pipe(
    prompt="These three characters are sitting around a campfire in a forest",
    image=images,
    num_inference_steps=40,
    generator=torch.Generator("cuda").manual_seed(42),
).images[0]
result.save("multi_ref_example.png")

The DiffSynth-Studio Route (Lowest Official VRAM Claim: 7 GB)

DiffSynth-Studio is ModelScope's own open-source framework for diffusion models, and it is the route the ModelScope README documents first. Its distinguishing feature for Qwen-Image-2.1 is automatic VRAM management: the framework controls which model components sit in GPU memory, CPU memory, or disk based on how much VRAM you actually have, and the documentation states a minimum of 7 GB VRAM to run — the lowest official claim of the three routes. If you have been told an 8 GB card cannot run this model and yours has 8 GB, this is the section that answers that.

Install it from its GitHub repository:

git clone https://github.com/modelscope/DiffSynth-Studio.git
cd DiffSynth-Studio
pip install -e .

Then the quick-start code, from the official DiffSynth-Studio documentation for Qwen-Image-2.1, with the VRAM configuration that streams components automatically:

from diffsynth.pipelines.qwen_image_21 import QwenImage21Pipeline, ModelConfig
import torch
from PIL import Image

vram_config = {
    "offload_dtype": "disk",
    "offload_device": "disk",
    "onload_dtype": "disk",
    "onload_device": "disk",
    "preparing_dtype": torch.bfloat16,
    "preparing_device": "cuda",
    "computation_dtype": torch.bfloat16,
    "computation_device": "cuda",
}

pipe = QwenImage21Pipeline.from_pretrained(
    torch_dtype=torch.bfloat16,
    device="cuda",
    model_configs=[
        ModelConfig(model_id="Qwen/Qwen-Image-2.1",
                    origin_file_pattern="transformer/diffusion_pytorch_model*.safetensors", **vram_config),
        ModelConfig(model_id="Qwen/Qwen-Image-2.1",
                    origin_file_pattern="text_encoder/model*.safetensors", **vram_config),
        ModelConfig(model_id="Qwen/Qwen-Image-2.1",
                    origin_file_pattern="vae/diffusion_pytorch_model*.safetensors", **vram_config),
    ],
    processor_config=ModelConfig(model_id="Qwen/Qwen-Image-2.1",
                                  origin_file_pattern="processor/"),
    vram_limit=torch.cuda.mem_get_info("cuda")[1] / (1024 ** 3) - 0.5,
)

# Text-to-image — output is an RGBA image
prompt = "Flat anime-style illustration, a girl with long black hair, wearing a JK uniform."
image = pipe(prompt, seed=0)
image.save("image1.png")

# Image editing — the generated image is fed back as the condition
prompt = "Generate a group photo of these two characters."
edit_image = [Image.open("image1.png"), Image.open("image2.png")]
image_3 = pipe(prompt, edit_image=edit_image, seed=1)
image_3.save("image3.png")

Two details in that code are worth understanding rather than copy-pasting blindly. The vram_config dictionary is what enables the automatic management — it tells the framework to keep the heavy components on disk until they are needed, load the active piece into GPU memory in BF16 for computation, and set the VRAM limit to just under what your card actually has. The edit_image parameter is how the pipeline distinguishes text-to-image from image editing — leave it empty and you get generation, provide PIL images and you get editing, all in the same object.

The DiffSynth-Studio pipeline also exposes fine controls the other routes hide: tiled and tile_size for tiled VAE inference (decoding the image in tiles rather than all at once, which reduces peak VRAM during the decode step), and use_kv_cache (defaulting to True) for the per-layer KV cache that speeds up multi-image editing by computing the condition prefix once and reusing it.

Your First Image: The 25-Step Baseline That Actually Works

With the ComfyUI template loaded and the three files in place, the fastest route to a first result is to change exactly one thing: the prompt. Use a subject with checkable details — the shape, the count, the lighting direction — so that when something is wrong, you can name what.

1. Replace the positive prompt with a simple, verifiable subject, for example: "A studio product photograph of a cobalt-blue ceramic teapot on a warm ivory tabletop. One curved handle, one spout, and a fitted round lid. Soft window light from the left, a gentle shadow to the right, realistic glazed ceramic, uncluttered background. No lettering or logos."
2. Leave every other setting at the template defaults (1024×1024, 25 steps, CFG 1, euler, simple).
3. Click Run. When the workflow finishes, inspect the save node's result and the output folder.
4. Save a copy of the working workflow before you change anything — this is your known-good baseline to return to when experiments break.

To increase quality and resolution, change one variable at a time. First compare 25 and 40 steps at the same resolution and the same fixed seed — the seed being the number that makes a generation reproducible, so the only difference between two runs is the thing you changed. Then return to your preferred step count and raise the output size. For square native-2K output, the template's own instructions specify 1:1 and 4 megapixels, which produces 2048×2048; that is four times the pixels of 1024×1024 and does not imply an identical fourfold change in runtime or memory.

One asymmetry worth knowing: the publisher's Diffusers example uses 40 steps while the ComfyUI template starts at 25, and the DiffSynth-Studio quick start also defaults to 40. All three are documented starting points for their respective paths; none is a universal optimum. If a tutorial tells you one of them is "correct," that tutorial is overclaiming.

The supported aspect ratios, all native to the model, with their recommended pixel dimensions:

"1:1":  (2048, 2048)      "3:2":  (2528, 1696)
"4:3":  (2400, 1792)      "2:3":  (1696, 2528)
"3:4":  (1792, 2400)      "16:9": (2752, 1536)
                       "9:16": (1536, 2752)

In editing mode, the height and width parameters follow a different rule than in generation: the input image is resized to the height × width area while preserving its own aspect ratio, rather than being stretched to the exact dimensions. This is why the ComfyUI edit template exposes a resolution control set to 0 by default — zero preserves each reference's own dimensions, while a value like 1024 resizes toward that pixel area.

Image Editing with Reference Images (Where This Model Earns Its Keep)

Editing is the reason to pick Qwen-Image-2.1 over a plain text-to-image model, because generation and editing live in the same checkpoint — no separate edit model, no second download. The model accepts up to ten reference images per edit: character, product, background plate, style reference, all read by the text encoder and spliced into the sequence as VAE latents. In the DiffSynth-Studio code above, you can see the pattern — generate two characters separately, then feed both back to produce a group photo.

This is the single biggest structural change from the Qwen-Image-Edit line: where the older setup required you to run a separate editing model built on the 20B Qwen-Image base, Qwen-Image-2.1 and its predecessor 2.0 unified both tasks behind one set of weights. The editing path is no longer a different model — it is a different argument to the same pipeline.

On the ComfyUI route, start smaller than the model allows: one input image, one requested change, the official image-edit JSON. Inside the subgraph, the TextEncodeQwenImage21 node exposes the resolution control described above. Set it to 1024 for the first test so you know what the model was told to do.

Write the instruction so it names both the change and what stays: "In <image1>, change only the teapot's glaze from cobalt blue to forest green. Preserve the teapot's shape, handle, spout, lid, camera angle, tabletop, background, lighting, and shadow" Judge the output on preservation as well as change — an attractive new image can still be a poor edit if it redrew things you asked it to keep.

Transparent PNGs Without a Background Remover

This is the feature aimed squarely at Jake's $40-per-cutout problem, and no other major open model does it this way. The 64-channel RGBA VAE means the model generates the alpha channel natively — sprites, logos, icons, and product cutouts come out of the sampler ready to composite, with no background-removal node, no matting model, and no edge cleanup.

The official documentation is more specific about prompt wording than the model card suggests, and the details matter. The DiffSynth-Studio docs give explicit guidance:

• State transparency explicitly in the prompt — use phrases like "isolated on a fully transparent background," "alpha matte," "die-cut sticker," "PNG with transparency," or "no background." The model responds to what you ask for, and vague prompts get vague backgrounds.
• Avoid describing an environment (e.g., "underwater," "indoor") or the model fills the canvas. Rewrite atmosphere as attributes of the subject itself and add "nothing else in the scene."
• Save to a format that supports transparency — image.save("image.png") works; calling image.convert("RGB") or saving as JPEG discards the alpha channel.
• For harder edges on subjects with hair, ribbons, or water-like lighting (which tend to produce wide semi-transparent transitions), add "clean cut-out edges" or "crisp silhouette" to the prompt.

image = pipe(
    prompt="This is an RGBA image with transparency. A cute cartoon dragon sticker. "
           "The image has alpha channel and the background is transparent.",
    num_inference_steps=40,
    generator=torch.Generator("cuda").manual_seed(42),
).images[0]
image.save("transparent_example.png")

The model also edits transparent layers — you can feed in an RGBA image, edit it, and keep the transparency — and it can extract subjects from ordinary RGB photographs. For a phone-shop owner who needs a product on a transparent background and that same product recolored for a new case variant, that combination is the entire workflow in one checkpoint.

Low-VRAM Survival: Quantizations, Offload, and What Each One Costs

"Quantization" is the umbrella word for storing model weights in fewer bits — the same numbers, rounded to fit in less memory, at some cost in precision. BF16 (bfloat16, a 16-bit floating-point format) is the original; INT8 stores weights as 8-bit integers; W4A8 goes further, with 4-bit weights and 8-bit activations. The official Comfy-Org repackage ships one of each flavor so you can trade disk and VRAM against fidelity.

Two things that table does not say, because the honest version is more useful than the optimistic one. First, a smaller file is not automatically faster — the W4A8 encoder reduces storage and likely memory, but speed on your specific GPU depends on kernel support, and the official sources do not promise a speed gain from any quantization. Second, the w4a8 file replaces only the encoder; you still need a diffusion model and a VAE next to it.

When the weights alone will not fit, the documented escape hatch on the Diffusers route is CPU offload:

pipe = QwenImage21Pipeline.from_pretrained(
    "Qwen/Qwen-Image-2.1", torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

CPU offload keeps the model weights in system RAM and streams the active piece to the GPU as needed. The model card recommends it explicitly for GPUs with limited memory.

Jake asked the obvious question: "If offload makes it run on smaller cards, why doesn't everyone just use that and skip the expensive GPU?"

"Because offload is a bridge, not a destination," Ethan said. "System RAM is slower than VRAM by a wide margin, so you're trading 'won't run at all' for 'runs, but you'll wait.' If you use this once a week, offload is fine. If you're generating twenty mockups a day, the honest answer is a bigger card, not a cleverer setting. Buy the tool that matches the job."

A separate lever exists for the sampler: prefix KV cache reuse, built into this architecture, computes the text and condition-image prefix once at the first denoising step and reuses it for all subsequent steps — which is where much of the editing-task speedup comes from. It activates when the checkpoint carries causal_condition: true (the shipped one does), so it is on by default and not something you configure. The DiffSynth-Studio pipeline exposes it as use_kv_cache, also defaulting to True.

What About Ollama and Unsloth? (Honest Status: Not Yet)

If you arrived here expecting to run ollama pull qwen-image-2.1 the way you would for a Qwen language model, the honest answer is that Ollama has not announced Qwen-Image-2.1 support as of September 21, 2026 — one day after the model's release. Ollama specializes in local language-model serving, and its image-model support has historically lagged behind its LLM support. This may change; check Ollama's own model library before assuming either way.

The same is true for Unsloth, the optimization and quantization tool popular for running large language models on consumer hardware — no Qwen-Image-2.1 release or announcement appears in their channels as of this writing. Unsloth's image-model tooling exists for earlier models, but 2.1 is a day old and the optimization community has not caught up yet.

What does exist today: the three routes documented above (ComfyUI, Diffusers, DiffSynth-Studio), community GGUF quantizations from third parties (separate loader required), the vLLM-Omni serving path with FP8 quantization and tensor parallelism, SGLang-Diffusion with multi-GPU support, and LightX2V as an acceleration framework. If you want the "one command and it runs" experience that Ollama provides for language models, the closest equivalent for this model today is the ComfyUI Desktop app with the official template — not one command, but the closest thing to it.

Where to Try It Before You Install (and the China Option)

Not everyone needs to install locally to see what the model does, and the official sources document two hosted options worth knowing.

The vendor's demo. The Qwen repository links a hosted demo alongside the weights, and it is the honest way to evaluate the model's capabilities separately from your hardware — if your GPU cannot run it locally, this is where you find out what you are missing. Availability depends on the hosted service, and the early-access program (50 slots through ModelScope, offered September 17 before public release) has concluded.

ModelScope Civision. ModelScope's own platform supports both inference and LoRA training for Qwen-Image-2.1 in its Civision section — you can download the model, generate online, and train LoRAs there without any local install at all. This is the most complete hosted option because it includes training, not just inference.

Wuli.art for mainland China. The repository documentation notes that users in mainland China can access Qwen Image 2.1 features — including transparent-background generation — free through wuli.art, in both a Chatbox and a Canvas interface. This is the officially documented China option, not a third-party mirror.

Troubleshooting by Symptom: What Each Failure Actually Means

The stage where a run fails tells you which component to fix, which is why the advice below is organized by what you saw, not by what you might have done wrong. The single most useful habit: when a run fails, note whether it failed during loading, text encoding, sampling, or image decoding — four different components, four different fixes.

One category of "fix" to be suspicious of: if a guide tells you to switch the native templates to a GGUF file by changing a filename, that is not a complete migration. GGUF — a different quantized container format, the one popularized by local LLM tools — requires its own compatible loader and workflow; the native ComfyUI templates are configured for the listed .safetensors files. Community GGUF quantizations of Qwen-Image-2.1 exist and are usable, but a GGUF tutorial must identify its own loader and workflow rather than borrowing the native one.

The Optional Piece Most Guides Skip: Prompt Rewriting Models

The Qwen-Image-2.1 release actually contains three downloadable pieces, not one, and the other two are easy to miss: Qwen-Image-2.1-PE-T2I and Qwen-Image-2.1-PE-I2I — prompt rewriters for text-to-image and image editing respectively, each a fine-tuned Qwen3.5-VL 9B at roughly 18.8 GB. "PE" is prompt enhancement: these models take a vague instruction and rewrite it into a precise, detailed description before the image model ever sees it.

You do not need them for a first install, and adding 18.8 GB to your download for a component you may not use is a choice, not a requirement. Where they earn their disk: when your short prompts produce results that miss what you meant, the rewriter is the layer that resolves ambiguity — the repo's own description is blunt that the image model has no idea what you meant, only what your prompt literally says.

One detail in the PE-I2I system prompt is worth knowing even if you never download it, because it silently decides the language your output text renders in. The rewriter makes two separate language decisions: the prose description follows the language of your instruction, while the text actually painted into the image follows a strict priority — exact text or target language you named first, then the dominant language of text already in the input image, then your instruction's language only if neither applies. If you edit an image whose packaging is in Thai with an English instruction that names no language, the rewriter preserves Thai. For product imagery where label language matters, that rule is the difference between a usable asset and a rejected one.

When Nothing Works: The Honest Limits of This Install

Some walls are real, and naming them plainly does more for trust than pretending otherwise.

If your only GPU is integrated graphics or a card without working CUDA/ROCm support, local generation of a 7B DiT with an 8B text encoder will be impractically slow — the model's own quick start assumes a CUDA device, and the ComfyUI portable CPU batch file exists but exists for emergencies. The honest alternative for capability evaluation is the vendor's hosted demo: use it to judge what the model can do before spending hours on hardware it may not fit.

If you cannot spare 14–33 GB of disk for the weights plus working space, this is not the model for that machine — no configuration makes the files smaller than their listed sizes.

If your goal is commercial output, the research license stops you regardless of how well the install goes — that is a licensing wall, not a technical one, and no amount of VRAM moves it.

And one limit specific to this moment in time: no independent benchmark of Qwen-Image-2.1 existed as of the day after release. The vendor's blog references a Qwen-Image-Bench comparison, but those numbers are the vendor's own; the one independent early-access review is one reviewer, on an early interface, with no timer shown. Treat every quality claim — including the implicit ones in this article's descriptions of the model's features — as coming from the model card and blog until third parties have run it in public.

FAQ

Is Qwen-Image-2.1 free to use?

Free to download and run locally, yes — the weights are public on Hugging Face and ModelScope. Free to use for anything, no: the license is the Qwen Research License Agreement, which covers non-commercial purposes only, and commercial use requires a separate license from the vendor. "Open-weight" describes the download, not the permissions.

Can I use Qwen-Image-2.1 commercially?

Not under the license it ships with. The Qwen Research License states rights are granted "FOR NON-COMMERCIAL PURPOSES ONLY" and that commercial use requires a separate license requested from the vendor. This is a change from the earlier Qwen-Image line, which was Apache 2.0 — if you built on that model assuming the same terms carried forward, they did not.

How much VRAM do I actually need?

The lowest official claim is 7 GB, from the DiffSynth-Studio documentation, which manages VRAM automatically. Third-party analyses estimate roughly 16 GB for full BF16 inference on the Diffusers route. The documented file sizes are ~17.28 GB (INT8) and ~32.44 GB (BF16) on disk, with generation needing headroom above the loaded weights. Start with INT8 at 1024×1024 and watch your VRAM during the run.

Can I run it on an 8 GB GPU?

The DiffSynth-Studio route documents a 7 GB minimum with automatic VRAM management, so an 8 GB card is plausible on that route. On ComfyUI or Diffusers, expect to work for it: the W4A8 encoder plus INT8 diffusion model, CPU offload enabled, 1024×1024 output, one image at a time, no other GPU-heavy apps. Not guaranteed on every card and driver combination.

Does it work the same on Windows 10 and Windows 11?

For this install, yes — ComfyUI supports Windows 10 and later with the same portable builds, files, and templates. The caveat is about Windows 10 itself: it reached end of support on October 14, 2025, so a stock install gets no free security updates, and consumer ESU runs to October 2027 for enrolled devices.

Can I run Qwen-Image-2.1 on AMD or Intel GPUs?

Yes, with caveats. ComfyUI ships separate portable packages for AMD (ROCm) and Intel GPUs. The Qwen repository documents AMD Radeon support via ROCm plus PyTorch and Diffusers, along with broader multi-chip support through the FlagOS stack — Triton-based operators via the Torch-FL plugin, claimed to require zero code modifications from the NVIDIA path, with inference accuracy aligned across platforms. Community reports on earlier Qwen image models with ROCm describe a workable but bumpier road than NVIDIA.

Can I run it on a Mac?

Not through the officially documented Windows and Linux paths. The Diffusers code notes switching to the "mps" device for Apple devices, and people have run earlier Qwen image models on Apple Silicon with substantial unified memory, but no official Mac-specific install path or minimum-spec claim for Qwen-Image-2.1 exists in the official sources. Treat Mac as untested territory for this specific model.

What's the difference between Qwen-Image-2.1, 2.0, and the older models?

The original Qwen-Image (August 2025) was a 20B text-to-image model under Apache 2.0. Qwen-Image-Edit was its separate editing companion. Qwen-Image-2.0 (February 2026) first unified generation and editing at 7B, still Apache 2.0. Qwen-Image-2.1 (September 2026) continues at 7B with a lighter single-stream architecture, native RGBA transparency, and the Qwen Research License instead of Apache 2.0. If you want commercial rights, the older 2.0 and earlier models still carry Apache 2.0.

What's the difference between BF16, INT8, and W4A8?

They are storage precisions for the same weights. BF16 is the 16-bit original — largest files (~32.44 GB total), reference quality. INT8 stores weights as 8-bit integers (~17.28 GB total), the default the official ComfyUI templates select. W4A8 is a smaller encoder variant (~6.31 GB for that file) using 4-bit weights and 8-bit activations, bringing the total to roughly 14.24 GB when combined with the INT8 diffusion model.

Do I need the PE-T2I and PE-I2I prompt rewriting models?

No — they are optional and each adds roughly 18.8 GB to your download. They are fine-tuned Qwen3.5-VL 9B models that rewrite short prompts into detailed descriptions before the image model sees them. Install the base model first, decide whether your prompts need the help, and only then consider the rewriters.

Should I use ComfyUI, Diffusers, or DiffSynth-Studio?

ComfyUI if you want to explore visually, load official templates, and edit images through a node canvas — the fastest install. Diffusers if you write Python and want generation inside a script or batch job. DiffSynth-Studio if VRAM is your limiting factor and you want the framework to manage it automatically — it has the lowest official minimum at 7 GB. All three are officially supported paths.

Can I reuse my old Qwen-Image or Qwen-Image-Edit workflows and LoRAs?

Not directly. Qwen-Image-2.1 is a different architecture with its own text encoder and VAE, and it ships with dedicated ComfyUI templates and a separate Comfy-compatible weight repackage. An older similarly-named VAE file is explicitly not what the 2.1 workflow wants. Treat 2.1 as a fresh install with fresh files rather than an upgrade dropped into an existing folder.

How do I generate a transparent PNG?

Use the recommended prompt format — declare it is an RGBA image, describe the subject, then state the background is transparent. The official guidance adds: avoid describing an environment (which fills the canvas), save as PNG (not JPEG or RGB, which discard alpha), and add "clean cut-out edges" or "crisp silhouette" for harder edges on subjects with hair or similar semi-transparent transitions.

I'm out of memory — what should I try first?

In order: close other GPU-heavy applications; lower output resolution; reduce reference images to one; switch to INT8 if on BF16; swap the encoder to W4A8; enable CPU offload; or switch to the DiffSynth-Studio route, which manages VRAM automatically. Before all of that, note which stage failed — loading, text encoding, sampling, or decoding — because that tells you which component to shrink.

How long does one image take?

The only public figure is from one early-access reviewer using a hosted interface: roughly 10–15 seconds for text-to-image and 18–23 seconds for editing. Your number depends on your GPU, quantization, resolution, and whether offload is on. Default step counts are 40 in the Diffusers example, 25 in the ComfyUI template, and 40 in DiffSynth-Studio.

Is there an Ollama or Unsloth version?

Not as of September 21, 2026 — one day after the model's release. Neither Ollama nor Unsloth has announced Qwen-Image-2.1 support yet. Check their official channels for updates. The closest "easy install" experience today is ComfyUI Desktop with the official template.

Revision note. Written September 2026, covering Qwen-Image-2.1 as released September 20, 2026, on ComfyUI v0.37.0 and later. This model is one day old at the time of writing — expect the surrounding tooling (Ollama, Unsloth, additional quantized variants, and any permissively-licensed follow-up) to move quickly, and re-check the official repository before relying on any specific claim here. If you have been fighting driver errors, out-of-memory crashes, and a 33 GB surprise just to make one picture, take a breath — you were closer than it felt, and the fix was almost always one folder, one file, or one prompt phrase away.