SDXL vs Flux Locally: Image Generation Speed and Quality

Run both locally and the verdict is clear. On an RTX 4090, SDXL renders a 1024px image in about 3-5 seconds using roughly 8GB of VRAM, while Flux.1 dev takes about 18 seconds on the same card and must be quantized to FP8 just to fit in 24GB. In exchange, Flux beats SDXL on prompt adherence, text rendering, and photorealism. SDXL wins on speed and ecosystem; Flux wins on quality and prompt accuracy.

In one line: pick SDXL for fast iteration and LoRAs, pick Flux for text, complex composition, and realism (FP8 on a 4090).

First, the terms. SDXL (Stable Diffusion XL) and Flux.1 are both open diffusion models that turn text into images. A diffusion model builds a picture by starting from noise and cleaning it up over many steps. More steps and a bigger model mean sharper results but longer runs. VRAM is the dedicated memory on your graphics card, the space that holds the model and the image; run short of it and the model either fails to load or falls back to a slow path.

Why is the speed gap so large?#

Because Flux uses a larger transformer architecture. At the same step count, Flux takes 3-5x longer per image than SDXL. SDXL typically runs 20-30 steps in 3-5 seconds on a 4090; Flux.1 dev needs 20-28 steps and about 18 seconds. The underlying metric is it/s (denoising steps per second): a 20 it/s GPU finishes a 20-step image in 1 second, a 10 it/s GPU in 2. So model size and GPU it/s together decide the final time.

Put simply, total time equals "steps divided by steps-per-second (it/s)." As the diagram shows, the same 20 steps take far longer when each step runs on a heavier model.

How much VRAM do you need?#

SDXL needs about 8-10GB at 1024px, comfortable even on a 12GB card. Flux.1 dev, however, is 30-33GB at native BF16, so it does not fit whole on a 24GB RTX 4090. On a 4090 you run an FP8 checkpoint or a GGUF Q8 build, which drops VRAM to roughly 10-12GB at a small quality cost. On a 16GB card, Flux effectively requires FP8/quantization while SDXL runs with headroom.

Quantization lowers the model weights from BF16 (16-bit) to FP8 (8-bit) or below, roughly halving the memory footprint. The bars below show where each setup lands against the 4090's 24GB ceiling.

How do quality and license differ?#

Quality depends on the task. Text rendering, prompt adherence, and realism favor Flux, while SDXL has a far larger ecosystem of LoRAs, ControlNets, and community tools, making it stronger for style customization and batch work. License matters too: Flux.1 schnell is Apache-2.0 and free for commercial use, but Flux.1 dev carries a non-commercial license you must check before shipping a product. SDXL uses OpenRAIL++ and is widely used.

So the choice splits three ways. If you ship commercially, license filters first; then your card's VRAM; and finally speed versus quality decides the rest.

How do you measure it yourself?#

Match conditions in ComfyUI and measure.

• Run SDXL and Flux at the same resolution (1024px), same seed, and same steps, then compare the console it/s and total seconds.
• If you are short on VRAM, switch Flux to an fp8 checkpoint or a GGUF build and leave SDXL as is.
• For quality, run the same 10 prompts (including text, complex composition, and people) through both and compare by eye.

Reference links

• SDXL paper (Podell et al., 2023)
• Stability generative-models (SDXL)
• FLUX.1 (Black Forest Labs)
• ComfyUI (workflow runner)
• GPU image-gen benchmarks (Tom's Hardware)

Note: figures are 2025-2026 ComfyUI/community measurements (1024px, RTX 4090) and vary with sampler, scheduler, resolution, and quantization. Measure your own with the method above. Models and licenses change often, so this is reviewed quarterly.