Flux Image Generation on Cloud GPUs: VRAM Requirements, Speed and Cost Per Image (2026)
Flux.1 Dev in FP8 needs 18–23 GB VRAM and generates in 9–10 seconds on an RTX 4090 at $0.39/hr. Full VRAM table for Flux.1 Schnell, Dev, FLUX.2 [klein] 4B and 9B, and every precision level. Real cost per image at packet.ai rates.
packet.ai Team
July 27, 2026
Flux.1 Dev in FP8 needs 18–23 GB of VRAM and generates an image in 9–10 seconds on an RTX 4090. At packet.ai’s $0.39/hr, that works out to roughly $0.11 per 100 images. The L40S 48GB runs Flux.1 Dev at full BF16 quality (30–33 GB), the only sub-$1/hr cloud GPU that does. This guide maps every Flux variant to a GPU, a precision level, and a real cost per image.
What are the GPU requirements for Flux?
Flux.1 Dev at FP8 needs 18–23 GB of VRAM and runs on a 24 GB RTX 4090. Flux.1 Dev at full BF16 precision needs 30–33 GB and requires a 48 GB L40S or A100 80GB. Flux.1 Schnell at FP8 needs ~12 GB. FLUX.2 [klein] 4B needs ~13 GB at FP16, the most accessible full-quality Flux model in 2026, running at native precision on a 16 GB GPU.
Key takeaways
RTX 4090 (24 GB, $0.39/hr on packet.ai) is the sweet spot for Flux.1 Dev FP8: fits at 18–23 GB, generates in 9–10 seconds, and costs roughly $0.11 per 100 images.
L40S 48GB ($0.92/hr on packet.ai) is the only sub-$1/hr cloud GPU that runs Flux.1 Dev at full BF16 quality (30–33 GB). Choose it for batch production, complex multi-ControlNet pipelines, or overnight rendering queues.
FLUX.2 [klein] launched January 2026 with a 4B model (~13 GB FP16) and a 9B model (~29 GB FP16). The 4B generates in ~1 second on an RTX 4090, delivering Schnell-class speed at better quality.
Flux LoRA training on a 24 GB cloud GPU takes 1–3 hours and costs $0.39–$1.17 at packet.ai RTX 4090 rates. Kohya’s fused backward pass (v0.9+) makes it viable on 16 GB GPUs.
FP8 is the practical default in 2026: half the VRAM of FP16, undetectable quality difference at standard output sizes, recommended for any GPU under 32 GB.
Flux from Black Forest Labs has become the dominant open-weight image generation model in 2026. It uses a 12B-parameter Diffusion Transformer (DiT) architecture that is significantly more VRAM-hungry than SDXL’s UNet. This guide covers the exact VRAM requirements for every Flux variant, generation speed benchmarks across the RTX 4090, L40S, and A100 80GB, and the real cost per image at packet.ai rates.
For full VRAM requirements across LLM inference, fine-tuning, and image generation, see the packet.ai VRAM requirements guide. For ComfyUI setup on a cloud GPU, the ComfyUI GPU guide covers Docker installation and workflow configuration. For a fully managed image and video generation environment, packet.ai’s Pixel Factory runs Flux models without any infrastructure setup.
Flux.1 vs FLUX.2 [klein] vs SDXL: Which Model Should You Run in 2026?
Flux.1 Dev and FLUX.2 [klein] are the quality benchmarks for open-weight image generation in 2026. SDXL remains relevant for its ecosystem: thousands of community LoRAs, mature ControlNet support, and an 8 GB VRAM floor that Flux cannot match. If you need a specific SDXL LoRA or ControlNet that has no Flux equivalent, SDXL is still correct. For everything else, Flux produces better images.
Model
Architecture
Min VRAM
Steps
License
Best for
SDXL 1.0
UNet
8 GB
20
Open
Large LoRA ecosystem, budget GPU
Flux.1 Schnell
DiT 12B
12 GB (FP8)
4
Apache 2.0
Fast iteration, commercial use
Flux.1 Dev
DiT 12B
18 GB (FP8)
20–28
Non-commercial
Best quality single model, 2026 standard
FLUX.2 [klein] 4B
DiT 4B
13 GB (FP16)
4
Apache 2.0
Fast + commercial, runs on 16 GB GPU
FLUX.2 [klein] 9B
DiT 9B
17 GB (FP8)
4
Non-commercial
Best FLUX.2 [klein] quality, needs 24 GB+
FLUX.2 [klein] (January 2026) matters specifically because the 4B variant is Apache 2.0 licensed, generates in about 1 second on an RTX 4090, and needs only 13 GB at FP16. For commercial licensing and speed, FLUX.2 [klein] 4B on an RTX 4090 is now the default choice.
Flux VRAM Requirements in 2026: Every Variant and Precision Level
VRAM usage for Flux is not just the model weight size. During generation, the GPU holds the diffusion backbone, the VAE decoder, two text encoders (CLIP-L and T5-XXL), and working memory for the attention states. VRAM also scales with resolution: at 2048x2048, expect 30–40% more VRAM than at 1024x1024.
FP8 quantization halves the Flux model weight memory from ~24 GB to ~12 GB with minimal quality loss. Community benchmarks confirm the quality delta from BF16 to FP8 is undetectable at standard output sizes (1024x1024). On any GPU under 32 GB, FP8 is the correct precision for Flux.1 Dev. GGUF Q4 fits on 8 GB cards but introduces visible quality degradation in fine detail and text rendering. Use it only when FP8 is not an option.
Each ControlNet adds 1–3 GB to the total VRAM budget. An IP-Adapter adds 2–4 GB. On a 24 GB RTX 4090 running Flux.1 Dev FP8 at 18–23 GB, adding one ControlNet brings total usage to 20–26 GB, at the limit. On an L40S 48 GB, the same pipeline runs with 16–26 GB of headroom, eliminating all VRAM management during complex multi-ControlNet ComfyUI workflows.
RTX 4090 vs L40S vs A100 for Flux: Speed, VRAM Ceiling and Cost Per Image
Diffusion model inference is memory-bandwidth-bound: each denoising step reads the full weight tensor from VRAM. The RTX 4090’s 1,008 GB/s GDDR6X bandwidth gives it a throughput advantage over the L40S’s 864 GB/s GDDR6 for single-image generation at the same precision. The L40S’s advantage is its 48 GB VRAM ceiling, which enables BF16 quality and batch sizes the RTX 4090 cannot reach.
Flux.1 Dev, 20 steps, 1024×1024: RTX 4090 at FP8, L40S and A100 at BF16 (best practical precision per GPU)
For single-image Flux.1 Dev FP8, the RTX 4090 is cheapest per image. For BF16 quality, batch production, or concurrent ControlNet pipelines, the L40S is the correct card. The $0.53/hr gap pays back immediately when BF16 precision is a requirement, since the RTX 4090 cannot run Flux.1 Dev at BF16 at all.
Flux LoRA Training on Cloud GPUs: VRAM and Real Cost
Kohya’s fused backward pass (v0.9+) reduced peak VRAM for Flux.1 LoRA training to 16 GB for standard 1024x1024 images. On a 24 GB RTX 4090, a Flux.1 LoRA with 20–30 captioned images at rank 16 takes 1–3 hours. For LLM LoRA fine-tuning costs on the same GPU, see the LLM fine-tuning cost guide.
The minimum practical GPU for Flux.1 Dev is 24 GB VRAM (RTX 4090) at FP8 quantization, using 18–23 GB and generating in 9–10 seconds per image at 20 steps. For Flux.1 Dev at full BF16 quality (30–33 GB), the minimum is the L40S 48GB at $0.92/hr on packet.ai. FLUX.2 [klein] 4B needs only 16 GB at FP16.
Flux.1 Dev at FP8 uses 18–23 GB of VRAM at 1024x1024. At full BF16 precision it needs 30–33 GB. At GGUF Q4 it fits in 7 GB with quality tradeoffs. FP8 is the recommended precision for any GPU under 32 GB: half the VRAM of FP16 with undetectable quality difference at standard output sizes.
Flux.1 at GGUF Q4 fits in 7–8 GB of VRAM, but quality degrades significantly, particularly in text rendering and fine details. In 2026, 8 GB GPUs are a practical dead end for serious Flux work. The minimum for quality Flux is 16 GB (FLUX.2 [klein] 4B at FP16, or Flux.1 FP8 with model offloading). For cloud usage, the cheapest path is an RTX 4090 at $0.39/hr with full FP8 quality.
Schnell is a 4-step distilled model (2–4 seconds per image on RTX 4090), licensed Apache 2.0 for commercial use. Dev requires 20–28 steps (9–10 seconds per image), produces noticeably better quality in complex compositions and fine detail, but is non-commercially licensed. Both use the same 12B DiT architecture. Schnell for prompt exploration and iteration. Dev for final production renders.
FLUX.2 [klein] 4B needs ~13 GB at FP16, fits on a 16 GB GPU, generates in about 1 second at 4 steps, and is Apache 2.0 licensed for commercial use. FLUX.2 [klein] 9B needs ~29 GB at FP16 or ~17 GB at FP8, requires a 24 GB RTX 4090 (FP8) or L40S 48GB (FP16), and is non-commercially licensed. Both models launched January 2026.
With Kohya’s fused backward pass (v0.9+), Flux.1 LoRA training runs on 16 GB of VRAM at rank 16. A 24 GB RTX 4090 is comfortable at standard settings. A 1–3 hour LoRA run on packet.ai RTX 4090 costs $0.39–$1.17 total. For high-rank training (rank 64+) or large datasets, 48 GB on the L40S is the practical choice.
On packet.ai RTX 4090 at $0.39/hr: Flux.1 Schnell at 4 steps costs approximately $0.04 per 100 images. Flux.1 Dev FP8 at 20 steps costs approximately $0.11 per 100 images. These figures are for single-image generation at 1024x1024. Batch workflows with model caching reduce per-image cost by eliminating model reload overhead.
