How much VRAM do you need for AI image and video models in 2026?

Key takeaways

• 8GB still runs SDXL and the new INT8 build of FLUX 3 Image Klein, but most other current models need quantized files or offloading at that size.

• 16GB is the sensible floor for a new card in 2026. The 16GB RTX 5060 Ti launched at $429, $120 less than the 12GB RTX 5070.

• Local video is where VRAM bites. Wan 2.2's 5B model officially wants 24GB, and its 14B models want 80GB in the reference code.

• Official minimums assume everything sits on the GPU. ComfyUI's offloading brings many of them down a long way, at a cost in speed.

• The 32GB RTX 5090 has the most memory of any consumer card on sale. NVIDIA hasn't announced any higher-memory RTX 50 Super cards.

The short answer on VRAM for local AI

The amount of video memory on your graphics card decides which models you can run locally and how much you'll have to compromise to run them. Here's how it breaks down in late 2026:

• 8GB: SDXL, FLUX 3 Image Klein in INT8 and FramePack for video. Bigger image models need heavy quantization.

• 12GB: most image models with fp8 or GGUF files, including FLUX.1 [dev]. Video works, slowly, with offloading.

• 16GB: comfortable for nearly every image model short of FLUX.2 [dev] and Qwen-Image at full quality, plus the smaller video models without much fuss.

• 24GB: where local video stops feeling like a workaround, and where most LoRA training guides assume you are.

• 32GB and up: the big models (FLUX.2 [dev], Wan 2.2 14B) with less offloading, and room for higher resolutions.

Why official VRAM numbers and real-world numbers disagree

Model makers usually publish the memory needed to run their reference code with the whole model loaded on the GPU. Tools like ComfyUI don't work that way. They keep part of the model in system RAM and stream it to the GPU as needed, so the same model fits on a much smaller card.

The gap can be huge. Alibaba's Wan 2.2 repository says the 5B video model needs "at least 24GB". ComfyUI's Wan 2.2 guide says the same model "should fit well on 8GB vram" with its native offloading. FLUX 3 Image Klein shows the same split: its model card measures 25GB to 31GB at peak with the reference code, while Black Forest Labs says the INT8 build runs on 8GB cards in ComfyUI.

Neither number is wrong. Offloading trades memory for time, and it leans on system RAM to do it. One ComfyUI reader reported running FLUX.2 [dev] on a 12GB RTX 3060 with about 70GB of system RAM in use. If your card is small, plenty of system RAM counts for almost as much as VRAM.

VRAM needed for popular image models

A few notes on that table. GGUF file sizes are a rough guide to VRAM, not an exact figure, since the text encoder and VAE need room too. FLUX.2 [dev] is the outlier: it pairs a 32B image model with a 24B text model, and ComfyUI recommends 24GB or more for high-resolution work even with weight streaming. For a FLUX-family model that fits a midrange card without compromise, Klein is the current pick. Our FLUX 3 explainer covers what it can do and how its license works.

VRAM needed for local video models

Video is hungrier than images because the model has to hold many frames at once, and longer or higher-resolution clips push memory up quickly. The newest Wan versions are missing because Wan 2.5 and later haven't been released as open weights, so they only run through hosted services.

Ways to fit a bigger model on a smaller card

• fp8 checkpoints. Roughly halve the size of a 16-bit model. ComfyUI says the quality of its fp8 FLUX.1 files is "slightly reduced compared to the full version", and NVIDIA calls FLUX.2's fp8 build "comparable". It's the first thing to try.

• GGUF quantization. Shrinks the model further in steps from Q8 down to Q2. The ComfyUI-GGUF author notes that transformer models such as FLUX "seem less affected by quantization" than older UNet models, which is why Q5 and Q4 files are common. Hugging Face's quantization benchmarks found a Q4 FLUX.1 [dev] took about twice as long as the full model.

• NF4 (bitsandbytes). In the same Hugging Face tests, NF4 cut FLUX.1 [dev]'s peak memory from 36.2GB to 17.3GB with no slowdown, and to 12.4GB with model offloading added.

• Offloading. Model-level offloading costs some speed. Sequential offloading saves the most memory, but the diffusers docs call it "extremely slow".

• Tiled VAE decoding. Splits the final decode step into tiles so it doesn't spike memory at the end of a generation. Diffusers notes it can cause slight tone shifts between tiles.

Which GPU to buy for local AI in 2026

VRAM on NVIDIA's comparison page; prices are launch MSRPs, and street prices vary.

For image and video generation, memory usually matters more than raw speed, which makes the 16GB RTX 5060 Ti the value pick in NVIDIA's lineup. It costs less than the RTX 5070 and has 4GB more memory. The RTX 5070 Ti and 5080 add speed but not memory, so they only make sense if you already know 16GB is enough for your work. The 5090 is the only consumer card with more than 24GB.

Used RTX 3090s were long the budget route to 24GB, but prices climbed through 2026 with the memory shortage and now sit above the RTX 5080's $999 launch price. Rumors of RTX 50 Super cards with 18GB and 24GB keep circulating, but NVIDIA hasn't announced them.

AMD became a realistic choice this year. ComfyUI added official ROCm support for supported Radeon cards on Windows in January 2026, so a card like the RX 9070 XT no longer means switching to Linux. Intel's Arc B580 runs ComfyUI natively and is the cheapest 12GB card here.

Apple's Macs and NVIDIA's DGX Spark take a different route, with large pools of unified memory shared between the processor and graphics. A Mac Studio with an M5 Max can be configured with up to 128GB, enough for models no consumer GPU can hold, and ComfyUI supports Apple Silicon through Metal. The DGX Spark has 128GB for $4,699, up from $3,999 at launch, but it's slow for this work. BFL's own chart shows it taking 43.8 seconds per 1-megapixel Klein Base image at 50 steps.

VRAM for LoRA training

Training a LoRA needs more memory than generating with the same model. The kohya FLUX training guide gives settings for each card size: 24GB trains a FLUX.1 LoRA at batch size 2 with basic settings, while 16GB, 12GB, 10GB and 8GB each work with progressively more block swapping (moving parts of the model to system RAM during training) and, at 10GB and 8GB, an fp8 text encoder. Each step down is slower. SDXL LoRAs can be trained on 8GB, with 10GB recommended.

The ai-toolkit trainer is built around 24GB for most models. Its example configs for FLUX.1 and Wan 2.2 14B LoRAs target 24GB, Qwen-Image needs 3-bit quantization to fit in 24GB, and its HiDream config calls for 48GB.

VRAM FAQ

Is 8GB of VRAM enough for AI image generation?

Yes, for SDXL and for FLUX 3 Image Klein's INT8 build, and for FLUX.1 [dev] with a Q4 GGUF file. Expect slower generation than on a bigger card, and expect larger models like Qwen-Image and FLUX.2 [dev] to be impractical.

Is 12GB enough for FLUX?

For FLUX.1 [dev], yes, with fp8 or Q8 GGUF files. FLUX 3 Image Klein fits at 12GB with its FP8 or INT8 build. FLUX.2 [dev] needs weight streaming and lots of system RAM at that size.

How much VRAM does Wan 2.2 need?

Alibaba lists 24GB for the 5B model and 80GB for the 14B models. ComfyUI's offloading brings the 5B model down to about 8GB, at a cost in speed.

Does system RAM matter for AI image generation?

Yes, once you rely on offloading. ComfyUI and diffusers move model weights into system RAM when VRAM runs out, so a small card with lots of RAM can run models a small card with little RAM can't.

Can you run Stable Diffusion and FLUX on a Mac?

Yes. ComfyUI runs on Apple Silicon through Metal, and unified memory means a Mac with 64GB or 128GB can hold models that don't fit on any consumer GPU.