Local Image Models: from SDXL to Qwen-Image

Generating images without going through the cloud is now within reach of a consumer graphics card. In three years we've gone from SD 1.5, which ran on as little as 6GB of VRAM, to Qwen-Image 2.1, which generates and edits images up to 2048x2048 locally. This article explains how these models work, how much VRAM you actually need, and which one to pick for your hardware.

Why generate images locally

Four practical reasons. First, cost: once installed, an image model needs no subscription and no credits, and you can generate as many images as you want with no meter. Second, availability: generation works even without a connection, on your machine, whenever you want. Third, control: your images, your prompts and your data never leave the machine. Fourth, privacy: for anyone publishing commercial content, knowing that no request passes through a third-party server is a concrete difference.

Quality is no longer a trade-off: today's open-weight models (FLUX, Qwen-Image) produce photorealism, anatomy and text rendering that rival cloud services from a year ago. The price you pay is VRAM, and that's where clarity matters.

How diffusion models work

Every model covered here belongs to the diffusion model family. The basic idea: the model learns to reverse a noising process. You start with an image, add noise until it's pure static, and the network learns to "clean" that noise step by step. At generation time you do the opposite: you start from random noise and, over a couple of dozen (or a few dozen) passes, arrive at the image.

The parameter that matters most for quality is the number of passes, called steps: more steps, a more refined image, but more time. The modern difference is architectural. Models of the SDXL generation use a U-Net, a convolutional architecture with bridge connections. Newer models, from FLUX on, use the DiT (Diffusion Transformer): instead of convolutions, they turn the image into a sequence of "tokens" that a transformer processes, exactly the way a language model processes words.

The DiT scales better: more parameters, more data, more quality. That's why FLUX (12B parameters) and Qwen-Image (20B) produce results SDXL (2.6B) can't match at equal prompt. There's a flip side: more parameters means more VRAM and more compute.

From SDXL to Qwen-Image: the timeline

SD 1.5 (2022) is the classic: 512px native, 6-8GB of VRAM, and by far the largest LoRA and ControlNet ecosystem. Even today, for fast experimentation or training customizations on little data, it's unbeatable.

SDXL 1.0 (2023) moves to 2.6B parameters, native 1024x1024, and a dual text encoder (CLIP + OpenCLIP), which in practice means: better adherence to complex prompts and more coherent scene composition. It's the standard for accessible photorealism, with a huge range of fine-tunes.

FLUX (2024) marks the architecture change. The DiT's 12B parameters bring prompt adherence, anatomy and above all text rendering to a level U-Net can't reach. It ships in two variants: [schnell], distilled to a few steps and released under Apache 2.0, and [dev], the full version for serious work.

Qwen-Image (2025) arrives from Alibaba with 20B parameters and another novelty: in-image text comprehension is excellent, and editing instructions are followed with precision. The compact Qwen-Image 2.1 (2026) condenses it all into 7B: it generates up to 2048x2048, edits using up to 10 reference images, and produces native RGBA transparency, all in a single model.

How much VRAM you actually need

Here the numbers matter more than the marketing. The values below assume 4-bit quantization (Q4_K_M, the reference format for local use) and 20-30 steps:

Model	Parameters	Native resolution	Recommended VRAM	Architecture
SD 1.5	~0.9B	512px	6-8GB	U-Net
SDXL 1.0	2.6B	1024px	12GB	U-Net
FLUX.1 [schnell]	12B	1024px	16GB	DiT
FLUX.1 [dev]	12B	1024px	16-24GB	DiT
Qwen-Image 2.1	7B	2048px	16GB	DiT

In practice: with 8GB go for quantized SDXL or full-quality SD 1.5; with 12GB SDXL is comfortable and fine-tunes run well; with 16GB quantized FLUX and Qwen-Image 2.1; with 24GB full-quality FLUX [dev]. An honest note: Qwen-Image's 2048px images need more intermediate memory per step than 1024px, so on a 16GB card keep the batch at 1-2.

Where you use them: ComfyUI, Fooocus, Diffusers

The model is only half of it. The other half is the software that runs it:

ComfyUI is the standard for node-based workflows: you plug in the model, the text encoder, the samplers and the editing blocks, and build precise pipelines. It's what you use when you want to reproduce exactly the same result.

Fooocus is the simple path: a Midjourney-style interface, a prompt and one click, and it generates with SDXL without touching any parameter. It's the fastest way to see what your hardware is capable of.

Diffusers (the Hugging Face library) is the reference for coders: a few lines of code to load SDXL, FLUX or Qwen-Image 2.1 and generate from a script, with native quantization support.

Which model to pick

Six concrete cases. Product or catalog photography: SDXL for volume, FLUX [dev] for hero shots with text. Fast creative prototyping: SD 1.5 with your LoRAs, because it's the fastest and the most customizable. Logos, icons and graphics with text: FLUX or Qwen-Image, the only ones able to write legible words into the image. Editing and retouching: Qwen-Image 2.1, because editing, transparency and multi-reference are in the model itself. Images with a transparent background to compose: Qwen-Image 2.1, the only one with native RGBA. Experimenting with little VRAM: SD 1.5 or quantized SDXL, to learn the workflows before moving to a bigger model.

The practical rule is simple: start with the model that runs comfortably on your hardware, and give FLUX or Qwen-Image a spin once text quality or editing become the point. The side-by-side comparison is in the resources page, where every model has a spec sheet, requirements and links.

Sources

The technical data is verified on the official pages: Stable Diffusion XL 1.0 (Hugging Face), FLUX.1 (Black Forest Labs), Qwen-Image 2.1 (Qwen) and the Qwen-Image technical blog.

Article generated with AI