Stop Buying Too Little VRAM for FLUX and ComfyUI

The most expensive mistake in a ComfyUI build is not buying the wrong brand of GPU. It is buying a card that looks fast on a spec sheet but runs out of memory the moment your workflow becomes interesting.

FLUX made that problem more obvious. It is a serious image model family, and Black Forest Labs describes the public FLUX.1 models as 12B-parameter transformer-based flow models. That is the kind of model that can make a local image box feel worth building. It is also the kind of model that punishes small VRAM pools, especially once you add higher resolutions, LoRAs, ControlNet-style conditioning, upscalers, batches, and a browser tab full of half-finished ideas.

This guide is not a benchmark. TokenByte has not measured every card below in a controlled lab run. Treat this as researched buying guidance for a home-lab builder trying to choose a GPU tier before spending money. The practical answer is simple: 24GB is still the comfortable local FLUX target, 16GB can be useful if you accept compromises, 12GB is a patience test, 8GB should not be your new FLUX plan, and 32GB is where the annoying edge cases start to relax.

Affiliate disclosure: TokenByte may earn a commission when you buy through links on this site. That never changes the price you pay, and it does not change the recommendation: buy enough VRAM for the workflow you actually want to run.

Why FLUX changes the GPU conversation

Older Stable Diffusion builds taught people to think about GPU choice as a speed problem. A faster card made images arrive sooner. A slower card made you wait. That was true enough for many SD 1.5 and SDXL workflows, but FLUX pushes more buyers into a capacity problem.

Capacity problems feel different. A slow GPU is irritating. A too-small GPU turns your workflow into a list of workarounds: load the FP8 checkpoint, reduce resolution, avoid batching, unload other models, skip the upscaler, move the VAE to CPU, close the LLM server, and hope ComfyUI can juggle memory well enough to finish the graph.

The official and community-facing model pages back up the direction of travel. Black Forest Labs positions FLUX.1 dev as an open-weight non-commercial model and FLUX.1 schnell as the faster Apache 2.0 option for local development and personal use. Comfy-Org publishes ComfyUI-oriented single-file checkpoints, including an FP8 schnell checkpoint and a dev checkpoint described as working better for ComfyUI users with less than 24GB of VRAM.

That last phrase matters. "Less than 24GB" is not the same as "8GB is fine." It means the ecosystem has made helpful compromises for smaller cards. It does not mean a small card suddenly has room for every workflow.

If you are still planning the rest of the box, use the TokenByte build picker first, then come back to this article when you are choosing the exact GPU tier.

The short version

If you want a local ComfyUI box mainly for FLUX, buy 24GB if the budget allows. Used RTX 3090 cards and RTX 4090-class cards remain attractive because 24GB changes the daily feel of ComfyUI more than a small speed improvement does.

If you are building new and want headroom, 32GB on an RTX 5090-class card gives you more breathing room for heavier graphs. NVIDIA lists the GeForce RTX 5090 with 32GB of GDDR7 memory. That does not magically remove every bottleneck, but it is the first consumer GeForce tier in this lane that feels meaningfully less cramped than 24GB.

If you already own 16GB, do not panic. NVIDIA lists the RTX 5080 at 16GB of GDDR7, and 16GB cards can still be useful for ComfyUI. The catch is that FLUX work on 16GB should be planned around FP8 checkpoints, lower batch counts, careful resolution choices, and fewer extras loaded at the same time.

If you are shopping for 12GB because it is cheaper, pause. A 12GB card can be useful for SDXL, smaller models, learning ComfyUI, and occasional FLUX experiments, but it is a weak default choice for a new FLUX-centered build.

If you are on 8GB, treat FLUX as a bonus experiment, not the reason to buy the card. For a fresh local AI purchase, 8GB is better aimed at lighter image workflows, video editing acceleration, gaming, or general CUDA tinkering.

What VRAM is actually holding

VRAM is not just "the model." A ComfyUI graph needs space for several things at once:

• The diffusion model weights.
• Text encoders and tokenization pieces.
• The VAE.
• Latents and intermediate tensors.
• LoRAs, adapters, ControlNet-style models, or detailers.
• Upscalers and post-processing models.
• Batch size and preview overhead.
• Other local AI services still sitting on the GPU.

That is why a checkpoint file size is useful context but not a full VRAM estimate. During research for this article, Hugging Face headers showed the Comfy-Org FLUX.1 dev FP8 checkpoint at about 17.2GB on disk and the non-FP8 single-file dev checkpoint at about 23.8GB on disk. Those numbers are not the same as runtime VRAM use, but they explain why "just download the big one" is not a great plan on smaller cards.

ComfyUI also has memory-management flags, and the current ComfyUI CLI source includes options such as --highvram, --lowvram, --novram, FP8 UNet/text-encoder flags, and --cpu-vae. These are useful levers. They are not magic upgrades. If a card has too little memory, the workaround usually shifts pain elsewhere: CPU RAM, system storage, launch complexity, or generation time.

8GB: good learning box, bad FLUX buying target

An 8GB GPU can still be useful in a home lab. It can teach ComfyUI. It can run smaller Stable Diffusion workflows. It can handle utility jobs, light LoRA experiments, and CUDA projects. It can also be the card you already own, which is always cheaper than a card you have to buy.

But if the reason you are shopping is "I want to run FLUX locally," 8GB is the wrong target. The moment you use memory-saving modes heavily, the system may spend more time managing memory than letting you explore images. You will likely reduce resolution, avoid batch generation, skip heavier extras, and chase model variants that fit rather than workflows that make sense.

There is nothing noble about turning a creative workflow into a survival exercise. If 8GB is what you have, use it. If 8GB is what you are about to buy for FLUX, redirect the money toward a better used card, a higher-VRAM new card, or a hosted image service until the budget changes.

For a general home-lab plan that mixes image generation with other local AI tasks, the recommended gear page is a better starting point than chasing the cheapest GPU listing.

12GB: workable for learning, cramped for ownership

The 12GB tier is tempting because it often looks like the rational middle ground. It is not tiny. It may be efficient. It can be a fine gaming card. It can run many non-FLUX local AI tasks. It may be exactly what fits in a small case or a limited power budget.

For a FLUX-first ComfyUI machine, though, 12GB is where you should be honest about your temperament. Are you comfortable treating every workflow as a memory puzzle? Are you fine with one image at a time? Will you avoid stacking models? Do you enjoy reading issue threads and trying flags? If yes, 12GB can be a learning platform. If no, it will feel like the GPU is saying no to you all afternoon.

The bigger trap is resale math. A cheaper 12GB card can become expensive if you replace it quickly. If you know you want FLUX, LoRAs, upscalers, and repeatable workflows, it is usually better to buy once into 16GB or 24GB than to buy 12GB and immediately start planning the next upgrade.

16GB: the compromise tier

Sixteen gigabytes is the practical compromise tier. It is not luxurious, but it is not hopeless. If you are careful, a 16GB card can be a useful ComfyUI machine for FLUX experiments and lighter production workflows.

This is where FP8 matters. Comfy-Org's FLUX.1 schnell page says its FP8 weights make ComfyUI use less memory, and its dev page points lower-VRAM users toward a more ComfyUI-friendly checkpoint. On a 16GB card, those are not minor conveniences. They are often the difference between a workflow worth using and a workflow that constantly needs trimming.

The right way to own a 16GB FLUX box is to build habits around the limit:

• Use FP8 checkpoints when appropriate.
• Keep batch size low.
• Start at conservative resolutions.
• Add LoRAs and upscalers only after the base workflow is stable.
• Avoid running Ollama, Open WebUI, and ComfyUI on the same GPU at the same time unless you have planned the memory split.
• Keep plenty of system RAM, because CPU fallback is less painful when the rest of the machine is not starved.

If your workflow is occasional image generation, 16GB may be enough. If your workflow is "I want a daily ComfyUI workstation," 16GB is the tier where you save money up front and pay with more constraint later.

The ComfyUI GPU guide is still useful here because it separates the GPU decision from the rest of the build: power, thermals, storage, case layout, and remote access all matter once the card is installed.

24GB: the sane default for serious local FLUX

Twenty-four gigabytes is the tier I would start from for a serious local FLUX machine. It does not mean every graph will fit. It does not mean you can ignore workflow design. It does mean you have enough room that ComfyUI stops feeling like a constant negotiation.

NVIDIA lists the RTX 4090 with 24GB of GDDR6X memory. Older RTX 3090 cards also brought 24GB to the used market, which is why they remain so interesting for home-lab AI builders. Speed, warranty, power draw, thermals, and used-card risk all matter, but for FLUX and ComfyUI the 24GB pool is the headline feature.

This tier makes more sense if you want to do normal local-AI things at the same desk:

• Keep a FLUX workflow ready without unloading everything constantly.
• Add a LoRA or detailer without immediately rethinking the graph.
• Generate at practical resolutions without treating each setting as a threat.
• Use the machine as a shared image box from a Mac Mini or laptop.
• Leave room for the workflow to grow over the next year.

If you are using a Mac Mini as the front end and a separate GPU box as the image engine, read the Mac Mini local AI guide before you buy. The GPU choice is only half the experience. Remote desktop, file sync, networking, model storage, and power management decide whether the setup feels clean.

32GB: the headroom tier

Thirty-two gigabytes is not necessary for every hobbyist. It is the tier for people who know they will keep expanding the graph.

NVIDIA lists the RTX 5090 with 32GB of GDDR7 memory. That extra headroom matters because advanced ComfyUI workflows rarely stay simple. You start with a prompt and a checkpoint. Then you add a style LoRA. Then a control image. Then an upscaler. Then a face/detail pass. Then a second model. Then you want to keep the browser, model manager, and another local service open.

The honest reason to buy 32GB is not that a single basic FLUX generation needs it. The reason is that your workflow will stop being basic.

There are still tradeoffs. RTX 5090-class builds need serious power, airflow, case clearance, and budget discipline. A 32GB card in a hot, cramped, loud case is not a premium local AI workstation. It is an expensive problem with fans. If you are choosing this tier, budget for the supporting parts, not just the GPU.

Do not ignore system RAM and storage

VRAM gets the attention, but a FLUX-capable ComfyUI box also needs a balanced platform. If you rely on memory-saving modes, CPU offload, or large model libraries, system RAM and storage become part of the user experience.

For system RAM, 64GB is a more comfortable target than 32GB if the machine will run ComfyUI plus other services. If you are also running local LLMs, Open WebUI, containers, browsers, and sync tools, 128GB can make sense. The TokenByte RAM guide covers that decision in more detail.

For storage, do not put your model library on a tiny boot drive and call it done. FLUX checkpoints, SDXL checkpoints, LoRAs, upscalers, downloaded examples, and output folders pile up quickly. A fast internal NVMe drive is ideal for active models. External SSDs or a NAS can still be useful for archive and overflow, but active model paths should not feel like a network science project.

Also leave enough free disk space for updates and experiments. A full model drive has a way of turning every test into housekeeping.

What I would buy by use case

For learning ComfyUI: use whatever GPU you already have, even 8GB, and do not pretend it is a final FLUX workstation. Spend as little as possible until you know whether you enjoy node-based image workflows.

For occasional FLUX experiments: 16GB can be reasonable if the card is priced well, power efficient, and you are happy using FP8-oriented workflows. This is the "I want to try it seriously, but it is not my whole lab" tier.

For a daily FLUX box: buy 24GB. This is the most sensible default for a TokenByte-style home lab where the machine needs to be useful after the first weekend.

For a heavy image workstation: consider 32GB if the budget allows and the rest of the build is equally strong. Do not pair a flagship GPU with bargain-bin cooling, a marginal PSU, or a case that cannot breathe.

For a mixed Ollama plus ComfyUI box: prioritize VRAM even more carefully. Running an LLM server and image workflows on one GPU is possible, but it needs scheduling discipline. The one-GPU VRAM scheduling guide is the next read if you want both services on the same card.

The buying rule

If FLUX is the reason for the purchase, do not buy the smallest card that can be made to work. Buy the smallest card that will still feel useful after you add the second and third thing you know you will add.

That usually means skipping 8GB, being careful with 12GB, accepting 16GB only as a compromise, treating 24GB as the serious default, and looking at 32GB when your workflows are already complex enough to justify it.

Local AI is more fun when the machine is not fighting you. VRAM is the part of the GPU spec that decides how often that fight starts.

Before you order parts, cross-check your whole build against how TokenByte tests local AI gear. A GPU that fits the model but breaks your power, noise, storage, or maintenance plan is still the wrong GPU.