Stable Diffusion GPU Requirements

Almost every “how much VRAM do I need” answer for image generation is out of date, because the models changed shape.

For years the answer was “8 GB is fine”, and for Stable Diffusion 1.5 and SDXL it still is. Then the 12-billion-parameter models arrived and the answer became “it depends what you are running, at what resolution, and at what precision” — which is less satisfying and considerably more useful.

This page is the arithmetic.

VRAM by model family

The weights themselves, at the precision each is normally distributed in:

Add roughly 1–2 GB for the runtime, the CUDA context and — if the card also drives your monitors — the desktop itself. A 4K display with a browser open can hold half a gigabyte.

So the practical floors: SD 1.5 on 4 GB, SDXL on 8 GB, Flux at reduced precision on 12 GB, Flux at full precision on 24 GB.

What resolution does

The part that surprises people, because it is not proportional to pixel count.

Diffusion models work in a compressed latent space, typically eight times smaller than the image in each dimension. A 512×512 image is a 64×64 latent; a 1024×1024 image is a 128×128 latent — four times the latent positions.

Memory grows with those latent positions, and the growth is worse than linear. With older attention implementations, self-attention memory scaled with the square of the number of latent tokens, which is why high-resolution generation used to fail dramatically. Modern PyTorch includes a memory-efficient attention path that flattens most of that, so the failure is now gradual rather than catastrophic — but activation memory still climbs faster than the pixel count suggests.

The practical guidance: generate at the model’s native resolution and upscale. SDXL is trained at 1024×1024; asking it for 2048 directly costs disproportionate memory and usually produces worse results than generating at 1024 and running a dedicated upscaler.

Batch size

Linear, and worth knowing because it is the cheapest speed improvement available.

Generating four images at once costs roughly four times the working memory, and is meaningfully faster per image than four separate runs — the model weights are read once and shared across the batch.

If you have memory to spare, raising the batch size is free throughput. If you are near the ceiling, this is the first setting to reduce.

The VAE decode spike

The failure that catches people at the worst possible moment, and the one most worth knowing about.

After the denoising steps finish, the latent has to be decoded back into pixels. That decode produces a full-resolution activation tensor in one pass, and at high resolution it is a memory spike considerably larger than the generation that preceded it.

The result is a 30-step generation that runs perfectly and then fails on the final operation.

Every mainstream interface offers tiled VAE decoding, which processes the image in sections. It is marginally slower and it removes the ceiling entirely. Turn it on before you need it rather than after.

Where compute becomes the limit instead

Once a model fits, image generation stops being a memory problem and becomes a compute one — which is the opposite of how language models behave.

A diffusion model runs twenty to fifty denoising steps, each a full forward pass over a comparatively small network. The weights are already resident; the work is dense arithmetic. So shader and tensor throughput predicts your images per minute, and memory bandwidth barely does.

This is why a card with modest bandwidth can be perfectly good here while being poor for language models, and it is the whole basis of our image generation buying guide.

Realistic expectations by VRAM

Reclaiming headroom before you buy hardware

Five settings that between them are frequently worth more than a card upgrade.

Enable tiled VAE decoding. Removes the high-resolution failure described above. Costs a little speed.

Use a quantised checkpoint. Flux at fp8 halves the memory, and the quality difference is not something most people identify in normal use. GGUF-quantised versions go further still.

Check your attention implementation. Current PyTorch includes an efficient attention path by default. Installations pinned to superseded libraries leave both memory and speed unclaimed — this is a common state for setups that have been upgraded in place over a couple of years.

Turn on model CPU offload. The diffusers library and the mainstream interfaces can move components — the text encoder, the VAE — to system RAM between stages, keeping only the active part on the GPU. It is slower and it is the difference between running and not running.

Close everything else. A browser with hardware acceleration, a video call and a desktop compositor can collectively hold a surprising amount of VRAM.

CPU, RAM and storage

Less demanding than the GPU, with two caveats worth knowing.

CPU: barely matters. It handles text encoding and orchestration. Any modern processor is adequate. The exception is if you use CPU offload, where the offloaded components run at CPU speed and a faster processor with faster memory genuinely helps.

System RAM: 16 GB minimum, 32 GB comfortable. It matters more than you would expect during model loading, and a great deal if you use CPU offload — the offloaded parts live there.

Storage: capacity rather than speed. Checkpoints are large. SDXL is around 7 GB; Flux at fp16 is around 24. LoRAs are small individually and accumulate. A working library reaches several hundred gigabytes without any single download feeling large — budget 1 TB if you experiment. Speed affects load time only. See Best NVMe SSDs for AI Workloads.

Apple silicon and AMD

Apple silicon works through PyTorch’s Metal backend. Images generate, more slowly than on an equivalent NVIDIA card, and unified memory means capacity is rarely the constraint — a 64 GB Mac has more addressable memory than any consumer graphics card. What it lacks is the ecosystem: a meaningful share of ComfyUI custom nodes and optimisation extensions assume CUDA.

AMD works through ROCm on Linux and with more friction on Windows. The same custom-node gap applies, and more acutely — this is the workload where the CUDA advantage is widest, because diffusion tooling moves fast and lands on NVIDIA first.

Since image generation is compute-bound and fits in 16 GB, AMD’s usual advantage of more memory per pound buys nothing here. Our NVIDIA vs AMD comparison covers the reasoning.

Video generation changes everything

Worth flagging because it is the one case where all of the above stops applying.

Video models operate over many frames simultaneously, and memory scales with frame count as well as resolution. Where image generation made 16 GB comfortable, video makes 24 GB a starting point and rewards more.

If video generation is anywhere in your plans, size for it rather than for still images — it is a genuinely different requirement, and the card that comfortably runs Flux may not run video at all.

Continue your research

• Best GPUs for Stable Diffusion — which card to buy, and why the answer inverts
• How Much VRAM Do You Need for Local AI? — the language-model version of this arithmetic
• NVIDIA vs AMD for Local AI — why this workload is the hardest case for AMD
• Best NVMe SSDs for AI Workloads — a checkpoint library grows quickly