Best GPUs for Stable Diffusion and ComfyUI

Almost everything this site tells you about buying a GPU for AI is wrong for image generation.

For language models the guidance is memory first, bandwidth second, compute a distant third. Diffusion inverts all of it: compute is what you are buying, and VRAM is rarely the thing that stops you. A card we would call limited for local LLMs can be close to ideal here.

Understanding why makes the whole category easy to shop.

Why image generation is a different problem

The difference comes down to what the hardware actually does in each case.

A language model generating text reads its entire set of active weights out of memory to produce a single token, then does it again for the next one. The arithmetic per token is small; the reading is enormous. That makes it memory-bandwidth-bound, which is why VRAM capacity and bus width dominate our other guides.

A diffusion model generating an image loads a comparatively small network once, then runs twenty to fifty denoising steps over a latent tensor. Each step is dense arithmetic on data already sitting in fast memory. The reading is modest; the arithmetic is enormous. That makes it compute-bound.

The practical consequence: for images, the number that predicts your speed is the shader and tensor throughput, not the memory bandwidth. Doubling the CUDA cores roughly halves the time per image. Doubling the memory bandwidth does very little.

How much VRAM you actually need

Less than the language-model numbers on this site would suggest, until you hit the specific cases where it isn’t.

For SD 1.5 and SDXL, 8 GB is workable and 12 GB is comfortable. The large modern image models are the reason 16 GB has become the sensible floor, and Flux at full precision is the reason 24 GB is worth having.

Where VRAM does become the constraint

Four situations, and they are the ones that generate the “out of memory” posts:

• High resolution. Attention memory grows faster than linearly with the number of latent tokens, so generating at 2048 rather than 1024 costs far more than four times the memory. This is the most common cause of a sudden failure.
• Batch size. Generating four images at once costs roughly four times the working memory. It is also considerably faster per image than four separate runs, which is why people do it.
• ComfyUI workflows holding several models. A base model, a refiner, a ControlNet and an upscaler chained together is four models. ComfyUI will unload between stages, and keeping them resident is much faster.
• Video generation. The case where VRAM genuinely binds, and where 24 GB or more stops being optional.

The VAE decode trap

Worth knowing because it catches people at the worst moment.

The final step of generation decodes the latent back into pixels, and at high resolution that decode is a memory spike considerably larger than the generation that preceded it. People run a 30-step generation successfully and then run out of memory on the last operation.

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

The specifications

The recommendations

Best overall

This is the card that looks mediocre in our language-model guides and excellent here, and the reason is the inversion described above.

10,752 CUDA cores is roughly twice the shader throughput of the 5070 Ti, and for compute-bound diffusion work that translates almost directly into images per minute. The 16 GB that limits it to 14B-class language models is, for image generation, ample — enough for SDXL at large batch sizes and for Flux at reduced precision with room for a ControlNet.

At 360 W it is also a far easier card to build around than the 5090, and it does not need a 1,000 W supply.

If your machine is primarily for image generation, this is the sensible top of the range.

Best value

8,960 CUDA cores and the same 16 GB, at 300 W and meaningfully less money.

For language models we recommend this over the 5080 because the two are nearly identical on the specification that matters. For image generation that argument does not hold — the 5080 genuinely is faster here, because compute is what you are buying.

It remains the better value, and it will generate images perceptibly more slowly. Which matters depends on whether you generate a few images a day or run batches for an hour.

If you run Flux at full precision, or generate video

The one case where the language-model logic and the image-generation logic agree.

32 GB holds Flux at full fp16 precision without quantisation compromises, keeps an entire ComfyUI chain resident between stages, and gives video generation the headroom it needs. 21,760 CUDA cores make it the fastest consumer card per image by a wide margin.

For SDXL work it is substantial overkill — you are paying for memory the workload never touches. For the largest current models it is the card that removes every constraint at once.

Best budget

16 GB of CUDA memory at the bottom of the range, and an honest caveat.

For language models we describe this card as capacity without the bandwidth to exploit it. For image generation the bandwidth criticism largely evaporates — but a different one replaces it. At 4,608 CUDA cores it has roughly half the shader throughput of the 5070 Ti, and since diffusion is compute-bound, that is roughly half the images per minute.

So it is not the bargain here that its memory suggests. It is a perfectly capable card that will make you wait, and at 180 W it fits anywhere.

Check the variant. The 8 GB card shares the model name and is a genuinely different product.

Best used value

24 GB and 10,496 CUDA cores, at used-market prices.

For image generation it remains genuinely capable: enough memory for Flux at reduced precision with room to spare, and enough compute to be quick. The newer cards are faster per watt and support newer numeric formats that some tooling now uses, but nothing about this card is a bottleneck for mainstream diffusion work.

The usual used-market caveats apply — no warranty, unknown history, and this generation’s GDDR6X modules ran hot, so ask about thermal pad condition.

Where the CUDA gap is widest

We say elsewhere that AMD is competitive for text generation and not for images. This is the guide where that matters, so it is worth being specific about why.

Diffusion tooling lives in ComfyUI custom nodes and in a fast-moving ecosystem of samplers, optimisation extensions and quantisation kernels. Nearly all of it is written against CUDA by people with NVIDIA hardware, and much of it reaches ROCm late or not at all.

Compounding it: image generation is compute-bound and fits in 16 GB, so AMD’s usual advantage — more memory per pound — buys you nothing here. You would be giving up ecosystem support in exchange for capacity the workload does not use.

Apple silicon works through PyTorch’s Metal backend and Core ML. It generates images, more slowly than an equivalent NVIDIA card, and with the same custom-node gaps.

For image generation specifically, our recommendation is unambiguous: buy NVIDIA. The full reasoning is in NVIDIA vs AMD for Local AI.

Training LoRAs

Worth a note because it changes the memory calculation.

Training a LoRA holds the base model, the adapter weights, gradients and optimiser state simultaneously. For SDXL that is comfortable on 16 GB with sensible settings; for the 12-billion-parameter models it is not, and 24 GB becomes the practical floor.

If LoRA training is a regular part of your work rather than an occasional experiment, weight memory more heavily than this guide otherwise suggests — the calculation moves back toward the language-model logic.

Getting more from the card you have

Before buying, four things that reclaim meaningful headroom:

• Enable tiled VAE decoding. Removes the high-resolution failure described above.
• Use a quantised checkpoint. Flux at fp8 halves the memory for a quality difference most people cannot identify in normal use.
• Check your attention implementation. Modern PyTorch includes an efficient attention path by default; older installations pinned to superseded libraries leave performance unclaimed.
• Close everything else. A browser with hardware acceleration and a desktop compositor can hold a surprising amount of VRAM.

Continue your research

• Stable Diffusion GPU Requirements — the full requirements picture, including CPU and RAM
• Best GPUs for Local AI — the same cards judged for language models, where the answer differs
• NVIDIA vs AMD for Local AI — why this is the workload where the gap is widest
• Best GPUs Under $1,000 for AI — if the budget is the constraint