Quick answer: Flux.2’s transformer is ~64GB of BF16 weights, so the only consumer path is the 4-bit build (~16GB) with the text encoder kept off the card. That makes 24GB the real floor: an RTX 4090 at ~$2,200, or a used RTX 3090 at ~$820 if you care more about fitting than speed. Black Forest Labs released Flux.2 in May 2026 at 32B parameters — roughly 2.7x larger than Flux.1 Dev. NVIDIA’s May 2026 RTX AI Garage announcement of an FP8 checkpoint is widely read as bringing the model to 16GB cards; it does not, because half of 64GB is still 32GB.
NVIDIA GeForce RTX 4090
24GB GDDR6X24GB runs the 4-bit Flux.2 build with the text encoder offloaded — the configuration Black Forest Labs documents. Around 9s per 1024px image, at roughly half the price of a 5090.
Affiliate links — we may earn a commission at no extra cost to you. Amazon ships globally; Shopee SG covers Singapore & ASEAN.
Who this is for
This guide is for image-generation users deciding which GPU to buy specifically for Flux.2 — the new 32B-parameter model that launched in May 2026. If you already own a 16GB card that struggled with Flux.1 Dev in FP16, the short version is that Flux.2 is harder on it, not easier. If you can already run Flux.1 fine and you’re wondering whether to upgrade, the honest answer at the bottom may surprise you. Worth flagging up front: the T2I landscape shifted again on 2026-06-22 when Krea 2 was open-sourced and immediately took the #1 spot on Artificial Analysis’ T2I leaderboard — it competes with Flux.2 in the same VRAM tiers, so the GPU picks in this guide translate cleanly if you end up running Krea 2 instead. And Black Forest Labs has already moved the goalposts again — FLUX 3 launched July 23 as a unified image-video-audio model, so factor that in if you’re buying for the long haul.
Why Flux.2 is less accessible than Flux.1, not more
Flux.1 Dev is a 12B-parameter model and its released weights file, flux1-dev.safetensors, is 23.8GB — which is why 24GB became the comfortable target for it. Flux.2 ships at 32B, and its transformer is ~64GB of BF16. At full precision it is not a harder version of the same problem; it is off the consumer scale entirely. (For the head-to-head between the two flagships on Flux.2, see our RTX 5090 vs 4090 for Flux.2 comparison.)
NVIDIA’s RTX AI Garage post and the ComfyUI nodes do ship an FP8 Flux.2 checkpoint tuned for Blackwell and Ada tensor cores, and the quality case for FP8 is sound — the differences from BF16 are hard to see. What FP8 does not do on this model is reach a 16GB card. Half of 64GB is 32GB, which clears the RTX 5090’s 32GB only if nothing else needs memory, and the text encoder does. The precision step that actually lands on consumer hardware is 4-bit.
So the direction of travel between the two models is the opposite of the usual story. Until May 2026, “best GPU for Flux” guides (including my Flux.1 buyer’s guide) said 24GB was the comfortable target for Flux.1. For Flux.2, 24GB is not comfortable — it is the floor, and what runs there is a quantized build.
What Flux.2’s 32B actually costs in VRAM
| Precision | Transformer weights | What can hold it |
|---|---|---|
| BF16 (as released) | ~64GB | Datacenter only |
| FP8 | ~32GB | Nothing consumer, once the encoder and activations are added |
| 4-bit | ~16GB | 24GB card with the text encoder kept off the GPU |
These are measured from the weights themselves, not estimated. The FLUX.2-dev repository ships the transformer as seven BF16 shards totalling ~64GB — which is exactly 32 billion parameters at 2 bytes each, matching the model card’s “32 billion parameter rectified flow transformer”. Halving for FP8 gives ~32GB; 4-bit gives ~16GB. The text encoder is a separate component on top of all three.
That is why Black Forest Labs’ own local-deployment example is narrow: a 4-bit quantized model with a remote text encoder on an RTX 4090. Not FP8, and with the encoder moved off the card entirely.
So the widely repeated “Flux.2 runs in 16GB on the FP8 path” does not survive the file listing. FP8 is ~32GB of transformer before anything else loads. What actually fits a 16GB card is the 4-bit build, and even then 16GB of weights in 16GB of VRAM leaves nothing for activations — which is why BFL’s own example uses a 24GB card. 4-bit with the encoder offloaded is the consumer path, not a budget compromise. Expect softer fine detail and weaker prompt adherence at 4-bit, most visibly on rendered text and small faces. For how these tiers map onto VRAM choices across the Flux family, see how much VRAM you need for Flux workflows.
What each card can actually run
Precision below is what the card can hold, given the weight sizes above. Times are rough relative estimates for the 4-bit path at 1024x1024 and 20 steps, modelled from memory bandwidth (methodology) rather than measured — treat the ordering as reliable and the absolute seconds as indicative:
| GPU | VRAM | Precision used | Time per image | Price |
|---|---|---|---|---|
| RTX 5090 | 32GB | 4-bit with real headroom for ControlNet | ~6 s | ~$4,900 |
| RTX 4090 | 24GB | 4-bit, encoder offloaded — BFL’s own example | ~9 s | ~$2,200 |
| RTX 3090 (used) | 24GB | Same, slower | ~14 s | ~$820 used |
| RTX 5080 | 16GB | 4-bit only, no room left over | ~11 s | ~$1,400 |
| RTX 5070 Ti | 16GB | 4-bit only, no room left over | ~13 s | ~$1,050 |
| RTX 4070 Ti Super | 16GB | 4-bit only, no room left over | ~16 s | ~$800 |
| RTX 4060 Ti 16GB | 16GB | 4-bit, expect swapping | ~28 s | ~$425 |
No consumer card runs Flux.2 at BF16, and none holds FP8 either once the encoder and activations are counted. Every card here is running the 4-bit build; the difference between tiers is how much room is left afterwards, which is what ControlNet, IP-Adapter and higher resolutions consume.
Check NVIDIA GeForce RTX 4090 on Amazon→Buy on Shopee SG→Which GPU should YOU buy for Flux.2?
- You’re running Flux.2 daily, want fast iteration, no LoRA training: RTX 4090 at ~$2,200, or a used RTX 3090 at ~$820 if speed matters less than fitting. 24GB is what leaves room for a ControlNet after the model is loaded, instead of making you choose.
- You need ControlNet stacking, IP-Adapter, or higher resolutions: RTX 5090 at ~$4,900. Control modules and adapters are extra resident weights on top of the 16GB the 4-bit transformer already costs, and 24GB runs out quickly.
- You train Flux.2 LoRAs or do serious fine-tuning research: RTX 5090 32GB is the practical floor. For broader training and fine-tuning hardware advice including multi-GPU setups, see my best GPU for AI research guide — it covers the bandwidth and VRAM math for research-grade workloads where Flux.2 is just one of several models in rotation.
- You’re on a budget and just want to generate occasional images: RTX 4060 Ti 16GB at ~$425 runs the 4-bit build, but 16GB of weights in a 16GB card means constant swapping. Expect ~28s per image at best, and consider whether Flux.1 Dev on the same card serves you better.
- You already own an RTX 3090: Keep it. Its 24GB puts it in the same tier as a 4090 for Flux.2 — both run the 4-bit build with the encoder offloaded, and the 4090 is simply faster at it. Moving to a 16GB 5080 would be a downgrade in capability despite the newer silicon.
- You can run Flux.1 Dev comfortably already: Honestly, hold. Flux.2 produces visibly better hands and text, but the prompt-adherence delta is smaller than the marketing suggests. If your Flux.1 workflow is working, this isn’t a must-upgrade — wait for prices on the 5080/5090 to settle later in 2026. (Same logic if you’re eyeing Stable Diffusion 3.5 — see our Flux.2 vs SD 3.5 hardware comparison for the head-to-head on which flagship fits your GPU budget.)
For workflow setup once you’ve picked a card, my best GPU for ComfyUI guide covers node configuration, model loading order, and the FP8 toggle that some people miss on first install.
Common mistakes with Flux.2
- Expecting FP8 to make Flux.2 a 16GB model. FP8 halves 64GB to 32GB — still more than any consumer card, before the text encoder. The setting that actually fits is 4-bit with the encoder offloaded, and on a 16GB card that leaves nothing spare.
- Assuming Flux.2 needs the same setup as Flux.1. The tokenizer, the text encoder pairing, and the recommended sampler all changed. Copy-pasting your Flux.1 ComfyUI workflow will produce broken or weirdly-blurry images. Start from the official Flux.2 example workflow (also flagged in NVIDIA’s May 2026 RTX AI Garage announcement).
- Buying a 12GB card for Flux.2. RTX 4070 (non-Ti), RTX 3060 12GB, and similar cards do not have enough VRAM for Flux.2 even in FP8 once you account for ControlNet and the text encoder. 16GB is the real floor.
- Mixing Flux.1 LoRAs with Flux.2. The model architecture changed enough that Flux.1-trained LoRAs do not transfer cleanly. Wait for Flux.2-specific LoRA releases or retrain — and if you do retrain, the AI research GPU recommendations for VRAM-heavy fine-tuning apply directly here.
Final verdict
| Budget | GPU | Flux.2 capability |
|---|---|---|
| ~$425 | RTX 4060 Ti 16GB | Q4 only, slow (~28s), softer detail |
| ~$800 | RTX 4070 Ti Super | 4-bit only, nothing spare, ~16s per image |
| ~$820 used | RTX 3090 24GB | Cheapest card with room after the model loads |
| ~$1,050 | RTX 5070 Ti | 4-bit only, nothing spare, ~13s |
| ~$1,400 | RTX 5080 16GB | Fastest 16GB option at ~11s, but holds less than the $820 3090 |
| ~$2,200 | RTX 4090 | 24GB unlocks ControlNet stacking and FP16 with care |
| ~$4,900 | RTX 5090 | 32GB FP16 native, LoRA training comfortable, future-proof |
NVIDIA GeForce RTX 3090
24GB GDDR6X24GB used for ~$820 — the least you can spend and still run Flux.2 4-bit without constant swapping. Blackwell tensor cores keep gen time around 11s per image — and you save $800 vs the 4090 without losing usable Flux.2 capability.
Affiliate links — we may earn a commission at no extra cost to you. Amazon ships globally; Shopee SG covers Singapore & ASEAN.
For most Flux.2 users in 2026, 24GB is the buy: a used RTX 3090 at ~$820 if budget leads, an RTX 4090 at ~$2,200 if speed does. Step up to the RTX 5090 only if you need ControlNet stacking, LoRA training, or higher resolutions — otherwise FP8 has genuinely flattened the price curve.
Flux.2 is the first major image model where 4-bit is not a budget compromise but the default consumer path — a 32B transformer simply does not fit any consumer card any other way.
Frequently asked questions
How much VRAM does Flux.2 need?
More than most guides say. The transformer ships as ~64GB of BF16 weights, so FP8 is ~32GB and 4-bit ~16GB, with the text encoder on top of each. The only consumer setup is 4-bit with the encoder offloaded, which Black Forest Labs documents on a 24GB RTX 4090. A 16GB card holds those weights with nothing to spare, and a 12GB card does not hold them at all, with noticeably softer detail. For comfortable headroom with ControlNet and IP-Adapter stacking, 24GB or more is the practical target.
Can the RTX 4060 Ti 16GB run Flux.2?
Only at 4-bit, and only just — those weights are about 16GB against the card’s 16GB, so it swaps. Expect generation times in the high-20-second range per 1024px image and visibly softer detail compared to a 24GB card with room to spare on a 5080. It’s a working option for budget hobbyists, not for production work or anything involving multiple control modules.
Is Flux.2 worth upgrading from Flux.1?
Honestly, only if your current card is already showing limits. Flux.2 has visibly better hands, text rendering, and prompt adherence, but the gap is smaller than the marketing implies. If Flux.1 Dev is running fine on your hardware, you can comfortably wait. If you’re buying a new GPU anyway, target a Flux.2-capable card.
What’s the difference between Flux.2 FP8 and FP16?
FP8 uses exactly half the VRAM of FP16, with minimal quality difference in typical generation — most users can’t reliably tell them apart in blind comparison. FP16 retains slight advantages in fine detail and color gradients, but on 16GB cards FP8 is the right choice. Only the RTX 5090 runs Flux.2 in FP16 comfortably for normal workflows.
Does Flux.2 work on AMD or Apple Silicon GPUs?
Support is limited as of mid-2026. The official FP8 optimizations target NVIDIA tensor cores (Ada and Blackwell), and the ComfyUI ecosystem around Flux.2 is NVIDIA-first. AMD ROCm and Apple MPS paths exist but tend to lag in quality and stability — if Flux.2 is your priority workload, NVIDIA is the practical choice.