What if one gaming GPU could make a finished blog thumbnail for about a tenth of a cent? Qwen-Image 2.1 is Alibaba's new open image model. It draws pictures from text, and it edits real photos. The paid cloud models charge per image. This one runs on our own card.
In this blog, we will look at the best image from each test first, and the places where it breaks. Then we will learn how much memory Qwen-Image 2.1 needs at 8-bit and 4-bit, how fast it runs, and what one image costs next to GPT Image 2 and Nano Banana Pro.
What Is Qwen-Image 2.1?
Qwen-Image 2.1 is an image model built from three parts. Each part has one job.
- The DiT (diffusion transformer) has 7.1B parameters. It starts from random noise and cleans it, step by step, into an image.
- The text encoder is Qwen3-VL 8B. It reads our prompt and turns it into numbers the DiT can follow.
- The VAE has 0.34B parameters. It turns the DiT's small internal picture into real pixels.
In simple words, the text encoder understands the request, the DiT paints, and the VAE develops the photo.
In bf16, the download is 33.1 GB. Our RTX 5090 has 34.19 GB of VRAM, so the full model does not fit next to a Windows desktop. So, here comes quantization to the rescue. Quantization stores each weight with fewer bits, so the model takes less memory. We quantized the model as it loads and kept every weight on the GPU, with no CPU offload.
Our Test Setup
Let me tabulate the setup for your better understanding:
| Item | Setting |
|---|---|
| GPU | RTX 5090, 34.19 GB of VRAM, driver 610.88 |
| OS | Windows 11 |
| Weights | Qwen/Qwen-Image-2.1, revision 790c926 |
| 8-bit | fp8 weights with fp8 activations (torchao), on the DiT and the text encoder |
| 4-bit | NF4 (bitsandbytes), on the DiT and the text encoder |
| Sampling | seed 11, 40 steps, about 1 megapixel |
The test was small on purpose. We used one prompt per task. The tasks covered blog thumbnails, technical diagrams, text, cartoons, transparent PNGs, prompt following, and edits of a real portrait.
We keep three kinds of numbers apart in this post:
- Measured on our rig: every time, VRAM figure, energy reading and score.
- Published list prices: the cloud prices for GPT Image 2 and Nano Banana Pro.
- Derived: the local cost per image. It is our measured GPU energy times an assumed electricity rate of $0.15 per kWh.
What Are the Best Images From Each Test?
Below is the best result from each task. This is a showcase, not a success rate.
Blog Thumbnails
We described the kgptalkie thumbnail layout in words and asked for it at 1920x1088. The model drew the two-panel violet and cream design, the K logo tile, the category pill and a three-line title. OCR found 7 of the 8 requested strings exactly in every thumbnail we scored. The one miss was the tagline. OCR also misses it on the real, hand-made thumbnail, so that miss is the OCR's limit, not the model's.
One caveat on the 4-bit thumbnail: its chart card labels both bars "8-bit", although the prompt asked for "8-bit" and "4-bit". It got the headline text right and the small chart label wrong.
Technical Diagrams
The QKV dot-product diagram came back with every label and number correct: "it's Q", both keys, 0.483 and 0.510. OCR matched all 10 strings at both 8-bit and 4-bit. The Transformer block had the right order and both residual arrows.
Text on Slides and Posters
The slide ("Why Quantize a Model?" plus three bullets) matched every string at both precisions. The workshop poster was clean too.
Cartoons and Style
The three-panel comic kept the same robot in panels 1 and 3. The violet K mascot followed the brand colour.
Transparent PNGs
The model outputs a real alpha channel. The alpha channel is the part of a PNG that stores how see-through each pixel is. The sticker is 57% transparent pixels at 4-bit, and the glass sphere is partly transparent. We show both on a checkerboard so the see-through parts are visible.
Editing a Real Portrait
This was the strongest area. We gave the model one photo of the author and asked for new looks. We measured identity with the SFace face-recognition model. A score of 1.0 means the same face, and 0.363 is its same-person threshold. As a ceiling, the original photo against its own cutout scores 0.95.
| Edit | Face similarity to the original |
|---|---|
| Corporate headshot, navy blazer | 0.96 |
| Traditional kurta, festive lights | 0.96 |
| Data-centre background | 0.95 |
| Holding a GPU | 0.94 |
| T-shirt with the kgptalkie logo (two reference images, 4-bit) | 0.95 |
| YouTube thumbnail, "LOCAL AI" text (text matched by OCR) | 0.80 |
| 2D cartoon | 0.53 |
Here, we can see that the realistic edits score as high as the photo's own cutout. The cartoon scores lower because the face is redrawn as a cartoon. It still clears the same-person threshold.
Where Does It Break?
- Code in images: a six-line Python snippet came out garbled at both precisions. OCR found 4 of the 6 lines at 8-bit and 1 of 6 at 4-bit, and both versions invented extra lines. Keep code as text.
- Exact counting: asked for exactly four graphics cards, the 4-bit run drew eight.
- Some edits: the suit edit put a second copy of the person on the stage screen. The "remove the background" edit returned a faded cutout. A 16:9 banner request copied the logo's aspect ratio instead (2048x512).
- Several reference images at 8-bit: with two reference images, the 8-bit setup needs a 26.1 GB peak. It ran out of memory while background apps (the Windows compositor and Norton) held 6.1 GB, and it worked when they held 3.4 GB. Ten reference images did not fit at 8-bit. At 4-bit, the two-reference edit peaked at 20.5 GB.
How Much VRAM Does It Need at 8-bit and 4-bit?
Here, we can see that 4-bit needs 6.4 to 7.7 GB less memory at every stage.
- Weights on the GPU: 17.8 GB at 8-bit, 11.4 GB at 4-bit.
- Peak for a 1024x1024 image: 22.8 GB at 8-bit, 16.3 GB at 4-bit.
- Peak for a 2048x2048 image: 24.3 GB at 8-bit, 16.5 GB at 4-bit.
We did not test a 24 GB card. But a 16.5 GB peak suggests that 4-bit would fit one, as long as the desktop leaves enough memory free.
How Fast Is It at 8-bit and 4-bit?
Here, we can see that the two precisions run at nearly the same speed. 4-bit stays within 7% of 8-bit.
- 1024x1024: 19.3 s at 8-bit, 19.2 s at 4-bit.
- 1920x1088 blog thumbnail: 42.5 s at 8-bit, 45.2 s at 4-bit.
- 2048x2048: 115.7 s at 8-bit, 118.8 s at 4-bit.
The image size decides the wait. Four times the pixels costs six times the time. Why? Because the attention cost grows with the square of the token count, and a bigger image means more tokens. On our Windows setup, 4-bit gave up almost no speed for its smaller memory footprint.
What Does One Image Cost Next to GPT Image 2 and Nano Banana Pro?
The cloud prices are published list prices, checked on 21 September 2026:
- Nano Banana Pro: $0.134 per 1K/2K image (Google's Gemini API pricing page).
- Nano Banana 2: $0.067 per 1K image (same page).
- GPT Image 2: $0.053 (medium) and $0.211 (high) per 1024x1024 image. These come from a third-party calculator built on OpenAI's published token rate of $30 per million image-output tokens.
The local side is measured energy turned into a derived cost. The GPU used 2.60 Wh for a 1024x1024 image and 6.43 Wh for a 1920x1088 thumbnail, measured by NVML at 8-bit. At an assumed $0.15 per kWh, that is $0.0004 and $0.0010 per image. Here, we can see that a local 1024x1024 image is 136 times cheaper than GPT Image 2 medium and 343 times cheaper than Nano Banana Pro.
Let's say a blog makes 300 thumbnails a month. Nano Banana Pro would cost $40.20 and GPT Image 2 high $63.30, against about $0.29 of GPU electricity locally. These are derived figures. They leave out the price of the GPU, the rest of the PC's power draw, and the retries a user makes with either option.
Note
This is a cost comparison only. We did not run the same prompts through GPT Image 2 or Nano Banana Pro, so this post makes no side-by-side quality claim against them.
Limitations
- One seed per prompt for the 4-bit run and the showcase. The 8-bit set used 3 seeds, but we show seed 11.
- There is no bf16 baseline. Everything was 8-bit or 4-bit on purpose, so we cannot say what quantization costs against full precision.
- Speed is for one GPU on Windows, at stock diffusers settings (no torch.compile; Triton is not available on Windows).
- The energy figure is GPU board power only, not the whole PC.
Conclusion
At 4-bit, Qwen-Image 2.1 runs entirely on one consumer GPU with a 16.5 GB peak, at nearly the same speed as 8-bit. It produced thumbnails, diagrams, slides, comics, transparent stickers and identity-preserving photo edits that are good enough to publish. It makes a blog thumbnail in 45.2 s for about a tenth of a cent in electricity. Code snippets, exact counts and a few edit types still need a human check. For a site that makes images every week and already owns the GPU, the cost saving over paid APIs is two orders of magnitude.
This is how Qwen-Image 2.1 performs on one RTX 5090. We started with its best images and the places it breaks, then we saw the memory it needs at 8-bit and 4-bit, and that 4-bit costs almost no speed. Finally, we measured what one image costs next to GPT Image 2 and Nano Banana Pro.
Note
How we kept the numbers clean. A guard capped PyTorch below the VRAM that other processes left free and re-checked it before every image. It also logged Windows shared GPU memory, so any spill into system RAM would be flagged, and every result in this post ran with no spill. We discarded two earlier runs: one had an untiled VAE decode, and in the other a large image spilled into system RAM. We also dropped an unfinished int8 run, and we cut a planned sweep over seven quantization setups down to fp8 and NF4. The VAE decodes in 768 px tiles on the GPU (LPIPS 0.0001 against an untiled decode). fp8 uses per-tensor scaling because per-row scaling is not supported on this Windows build, and NVFP4 was not run because its kernels need Triton. Software: torch 2.11.0+cu128, diffusers 0.41.0.dev0 (git main), transformers 5.17.0, torchao 0.18.0 and bitsandbytes 0.50.2. OCR splits a label wrapped over two lines, so the RAG diagram scored only 2 of 7 exact matches even though its labels are visibly correct. We do not show it as a result.
