How Much VRAM Do FLUX, SD 3.5 and SDXL Need? File Sizes for Every Card (2026)

Here is the 2am question I see most: I have this graphics card, can it make AI images? Forum answers range from "8 GB is plenty" to "buy a 4090". Both can be true, depending on which file you load. So I skipped the opinions and read the file sizes.

On 3 October 2026 we pulled the official file listings from Hugging Face for FLUX.1, FLUX.2, Stable Diffusion 3.5 and SDXL, plus the shrunk versions ComfyUI points to. Then we did the arithmetic. We have not run any of these models on any card. Every number below is a file size or a sum of file sizes, and the method is printed. For setup steps, see our guides to running Flux locally and running Stable Diffusion locally.

Why a model needs three files, not one

Every model here is really three models: a text encoder, a diffusion model and a VAE. The text encoder turns your prompt into numbers. The diffusion model builds the image. The VAE (variational autoencoder) turns the result into pixels. Each file has its own size.

That matters because ComfyUI doesn't keep them all on the card at once. Its own help text for the --highvram switch says: "By default models will be unloaded to CPU memory after being used." The text encoder runs, steps aside, then the diffusion model runs. So the card needs to hold the biggest single piece, while your system RAM holds the rest. Even an all-in-one checkpoint gets split: ComfyUI's docs say its checkpoint loader "splits it into three core components".

ComfyUI's own numbers back this up for one model. Its FLUX.2 klein tutorial lists 8.4 GB of VRAM for the distilled 4B model. That workflow's files add up to 12.45 GB, and its biggest file, the text encoder, is 8.04 GB. The peak tracks the biggest piece, not the total.

Full-precision file sizes, model by model

At full precision the sets run from 6.9 GB for SDXL to 100.4 GB for FLUX.2 dev. The image model alone is 23.8 GB for FLUX.1 dev and 64.5 GB for FLUX.2 dev. Text encoders add from 1.6 GB for SDXL to 35.6 GB for FLUX.2 dev.

How we read each row:

• FLUX sets add the VAE file, 0.34 GB. FLUX.2 dev's official repo stores its text encoder as ten files totaling 48.02 GB. We used ComfyUI's single 35.58 GB copy of the same encoder, which is the one you'd load in ComfyUI.
• SD 3.5 files carry the VAE but not the text encoders. ComfyUI's SD3 page says they "do not contain text encoder/CLIP weights so you must load them separately".
• SDXL ships as one 6.94 GB file. Its header splits it into a 5.13 GB UNet, 1.64 GB of text encoders and a 0.17 GB VAE.
• Licences are from each repo. The FLUX.2 klein cards say the 4B model is Apache 2.0 and the 9B model is under "a non-commercial license". Stability's Community License is free for organizations or individuals "with less than $1M in total annual revenue".

FLUX.1 dev's image model at 23.80 GB is the one that catches people. A 24 GB card holds 25.77 GB, which leaves 1.97 GB for everything else. That is why full-precision FLUX.1 sits on the edge of a 24 GB card.

fp8 and GGUF: what shrinking buys you

Shrinking the weights is how a smaller card gets in. fp8 stores each weight in 1 byte instead of 2, so it halves the file. GGUF quants go further: FLUX.1 dev's Q4_K_S is 6.81 GB, under a third of the original.

The arithmetic is simple. FLUX.1 dev holds 11,901 million weights. At 2 bytes each that's 23.80 GB, and at 1 byte it's 11.90 GB. The header of ComfyUI's fp8 checkpoint confirms it: 11.90 GB of fp8 image model, 5.01 GB of text encoders and a 0.34 GB VAE, 17.25 GB in one file.

Where each file comes from:

• fp8 files are Black Forest Labs' own (klein 4B and 9B) or ComfyUI's repackaged copies on its Comfy-Org Hugging Face account. FLUX.2 dev's "fp8mixed" file keeps some layers in BF16, which is why it's 35.46 GB and not half of 64.45.
• GGUF files are third-party quants by city96, loaded through the ComfyUI-GGUF custom node. Its README says the format allows "much lower bits per weight variable bitrate quants on low-end GPUs".
• The 4-bit FLUX.2 dev is the diffusers repo that Black Forest Labs' model card uses in an example that loads "a 4-bit quantized model with a remote text-encoder on an RTX 4090".

There is a cost. ComfyUI's Flux examples page says "fp8 degrades the quality a bit". We haven't compared image quality across formats, so we can't rank them for you. We'd start one step above the smallest file that fits.

Which card runs which model

A 12 GB card covers every model in this piece except FLUX.2 dev, once you pick a shrunk format. FLUX.2 dev needs a 24 GB card even at 4-bit. SDXL runs at full precision on all of them.

The rule is ours, so here it is in full. A setup "runs" when its biggest file plus 2 GB fits the card's memory. The 2 GB mirrors the --reserve-vram 2 example in ComfyUI's troubleshooting docs. "Tight" means the file fits with less than 2 GB spare. "Offload" means no listed setup fits, so ComfyUI has to stream weights from system RAM.

Two vendor figures sit higher than our rule, and you should know why. The FLUX.2 klein 4B card says it "fits in ~13GB VRAM", and the 9B card says "~29GB VRAM" and "RTX 4090 and above". The cards don't say how those were measured. Our rule assumes ComfyUI's default of loading one piece at a time, while the cards' own example code uses the diffusers library. If your tool keeps more than one piece on the card, plan for the vendor figure.

For specific card picks by price, our best GPU for Stable Diffusion guide goes card by card. For local AI in general, including chat models, start with the best GPU for local AI.

ComfyUI's low-VRAM settings, from its own docs

ComfyUI already manages memory for you on Nvidia cards. Its own README claims it "can run even the biggest open source models on as low as 4GB vram + 8GB ram relatively quickly". That's the project's claim, not something we checked. The launch switches below change where each piece lives.

One detail most guides miss. In current ComfyUI, --lowvram "Doesn't do anything if dynamic vram is enabled". The startup code turns dynamic VRAM on by default for Nvidia cards on PyTorch 2.8 or newer, and for AMD on ROCm 7.14 or newer. So on a recent Nvidia setup, the old --lowvram advice is a no-op. The bigger lever is the file you load.

What the docs suggest when memory runs short:

On the T5 text encoder, ComfyUI's two pages disagree. The examples page recommends the fp16 version "if you have more than 32GB ram". The docs site says "VRAM". We'd follow the examples page, since ComfyUI unloads the encoder to system RAM after use.

When renting beats upgrading

If your card can't hold FLUX.2 dev, renting one for an evening costs less than a new card. On 3 October 2026 our tracker showed an RTX 3090 (24 GB) at $0.22 an hour, an RTX 4090 (24 GB) at $0.34 and an RTX 5090 (32 GB) at $0.69 on Runpod, on demand.

That's enough for FLUX.2 dev at 4-bit, or FLUX.1 dev at fp8 with room to spare. Our cheapest cloud GPU for ComfyUI and Flux guide walks through renting one, and cost to run does the same math for chat models.

Referral link

Card too small for FLUX.2? Rent a 24 GB one

An RTX 3090 with 24 GB listed at $0.22 an hour and an RTX 5090 with 32 GB at $0.69 an hour on Runpod on demand (our tracker, 3 Oct 2026). Prices move, so check the live figure before you rent.

See live 24 and 32 GB GPU pricesCompare live prices first →

Referral link — we may earn a commission at no cost to you. Prices on our compare page are the provider's live figures, cheapest first; this never changes the ranking.

What these numbers don't tell you

They don't tell you speed. Seconds per image depend on the card, the step count and the resolution, and none of that was measured here. They don't tell you quality either. We didn't compare images across formats.

They also leave out working memory. Larger images, ControlNets and LoRAs (small add-on files that change a model's style) all need room on top of the weights. That's what the 2 GB margin is for, and a big batch can use more. Treat the scorecard as the starting point, then step down one format if you hit an out-of-memory error. For the full set of GPU tools, see /tools.