FREE WEBINAR X NetApp
You launch a new AI video workflow on a 24GB GPU. The model loads, the first clip starts rendering, and then the job crashes with an out-of-memory error when you increase the resolution, frame count, or batch size. The problem is not the model alone. Your actual memory footprint also includes text encoders, VAEs, activations, precision, runtime buffers, and any optimization or offloading strategy you use.
That is why How much VRAM does this model need? rarely has one universal answer.
This guide maps SD 3.5, FLUX, Qwen-Image, Wan, LTX-2, HunyuanVideo, and MiniMax H3 to practical VRAM and GPU tiers, so you can avoid both production OOM failures and paying for GPU capacity you do not need.
Quick Answer – VRAM for AI Image and Video Generation
For current generative-media workloads:
- 24–32GB: optimized image inference and selected aggressively optimized or offloaded video workloads.
- 48GB: strong general-purpose capacity for image generation, development, and many video inference pipelines.
- 80–96GB: large video models, higher-memory inference, training, reduced offloading, and greater production headroom.
- 141GB+: very large pipelines where fuller residency matters, or where 80–96GB still requires significant component offloading.
These are sizing recommendations, not universal model requirements.
The most important rule is:
Fits in VRAM does not mean recommended for production.
Practical GPU VRAM Tiers
| VRAM tier | Practical Positioning | GPUs Example |
|---|---|---|
| 24GB | Quantized image models and selected optimized video models | NVIDIA L4 |
| 48GB | Broad image and video inference | L40S, RTX A6000, RTX 6000 Ada |
| 80GB | Large video models, high-bandwidth workloads, training | A100 80GB |
| 96GB | High-headroom multimodal and video deployments | RTX PRO 6000 Blackwell |
| 141GB+ | Fuller residency for exceptionally large pipelines and high-memory production workloads | H200 141GB-class GPUs |
Where Can You Access These GPU Tiers in India?
Once you know the VRAM tier your workload needs, compare how you can access that GPU in India.
- IndiaAI Compute: Consider this first if you qualify for subsidized capacity. Current portal pricing varies by GPU, reservation period, and approved subsidy.
- AceCloud: Provides India-hosted NVIDIA GPU infrastructure across 24GB, 48GB, 80GB, 96GB, and 141GB classes, including L4, L40S, A100, H100, RTX PRO 6000, and H200.
- JarvisLabs: Offers India-based on-demand GPU access with options including L4, A100, H100, H200, and RTX PRO 6000 Blackwell, with minute-level billing.
- Cyfuture Cloud: Competes in the Indian GPU cloud market with H100, A100, L40S, RTX-class GPUs, and multi-GPU infrastructure for AI training and inference.
Do not compare these options on GPU-hour pricing alone. Check the exact GPU SKU, availability, CPU and RAM allocation, networking, storage, billing model, support, data residency, and whether access requires eligibility approval or a longer commitment.
What are the VRAM Requirements for Leading Image and Video Models?
The table below prioritizes official model documentation and reproducible framework measurements. Read every number together with its workload, precision, and optimization method rather than treating it as a universal model minimum.
| Model | Reference workload | Baseline / measured VRAM | Lowest validated fit | How lower VRAM is achieved | Offload / host-memory dependency | Practical production positioning | Evidence type |
|---|---|---|---|---|---|---|---|
| SD 3.5 Medium | 1024×1024 | ~20.1 GiB peak | Runtime-specific | Runtime optimization | Low to medium | 24GB | vLLM-Omni framework measurement |
| SD 3.5 Large | 1024×1024 | ~31.6 GiB peak | Runtime-specific | Runtime optimization / precision choices | Low to medium | 48GB | vLLM-Omni framework measurement |
| SD 3.5 Large | 2048×2048 | ~45.5 GiB peak | ~45.5 GiB in documented configuration | Same vLLM-Omni configuration | Low | 48GB fits, but leaves little headroom; larger preferred for production | vLLM-Omni framework measurement |
| FLUX.1-dev | 1024×1024 | ~33.9 GiB peak | <16GB documented optimized path | Quantization + CPU offloading | Medium to high | 24GB optimized; 48GB for less constrained deployment | vLLM-Omni + Hugging Face Diffusers |
| FLUX.2 Klein 4B, official/vendor fit | Image generation/editing | ~13GB official fit | ~13GB | Vendor-supported runtime; reference Diffusers path supports model CPU offload | Implementation-dependent; CPU offload supported | Consumer-GPU class; 16 to 24GB practical, with 24GB providing more headroom | Black Forest Labs official model card |
| FLUX.2 Klein 4B, vLLM-Omni unoptimized reference | 1024×1024, batch size 1 | ~72.7 GiB peak | N/A; not presented as a minimum-VRAM target | None in the reported benchmark; basic single-card path without acceleration or optimization | Low in the measured reference path | Do not treat 72.7 GiB as the model minimum; use it as a runtime-specific, unoptimized reference peak | vLLM-Omni framework measurement |
| FLUX.2 Klein 4B Base | Base model | Comparable universal peak N/V | ~13GB official fit | Model CPU offload supported | Medium | Consumer-GPU class; 16 to 24GB practical | Official model card |
| FLUX.2 Klein 9B | Image generation/editing | ~37.1 GiB peak in current vLLM-Omni measurement | ~29GB official fit | Runtime/component placement | Medium | 48GB | Official model card + framework measurement |
| FLUX.2 dev 32B | 1024×1024 / Diffusers deployment | ~65.7 GiB peak in vLLM-Omni with CPU offload; model weights exceed 80 GiB | ~18GB documented optimized path | 4-bit transformer + remote text encoder | High at low VRAM | 24 to 32GB optimized; 80GB still offloaded; H200/B200-class for full component residency | BFL + vLLM-Omni |
| Qwen-Image | 1024×1024 | ~60.0 GiB peak | 14.93GB with NF4 4-bit quantization | Transformer + text encoder quantized to NF4 | Medium | 24GB optimized; 48GB+ for less constrained deployment | Hugging Face Diffusers + vLLM-Omni |
| Wan2.2 TI2V-5B | 1280×704, 720p | Universal native peak N/V | 24GB official configuration | Model offload + dtype conversion + T5 on CPU | High | 24GB optimized; 48GB+ for greater headroom | Official Wan2.2 repository |
| Wan2.2 T2V/I2V-A14B | 720p single-GPU reference | At least 80GB official reference | 80GB-class official path | Model-specific offload options available | Medium | 80GB+ | Official Wan2.2 repository |
| LTX-2.5 inference | 22B audio-video transformer + Gemma 4 12B encoder | Comparable universal peak N/V | Pipeline-specific | FP8, CPU/disk offload and other runtime optimizations | Pipeline-dependent | Benchmark the exact pipeline; do not infer from checkpoint size alone | Official LTX-2.5 / LTX pipeline docs |
| LTX-2.5 LoRA training | Standard trainer configuration | 80GB recommended for standard configuration | 32GB tested low-VRAM training path | INT8 quantization, 8-bit optimizer, reduced rank and memory optimizations | Medium to high at 32GB | 32GB is the validated low-VRAM tier; 80GB recommended for standard training. Do not infer sub-32GB support | Official LTX trainer |
| HunyuanVideo 1.5 | Video inference | Resident peak N/V | 14GB documented minimum | Model offloading | High at minimum tier | 24GB+ practical | Official Tencent repository |
| MiniMax H3 | Datacenter: 1344×768, 124 frames, 50 steps; consumer result uses a different 4090 workload | 83,578MB/GPU BF16; 51,926MB/GPU FP8 on documented 8×B300 FL2VA setup | ~18GB peak demonstrated on a 24GB RTX 4090 for a different 1344×768, 107-frame, 20-NFE workload | Heavy layerwise offloading; consumer path can also use INT8 | Very high | Large-memory/multi-GPU for high-throughput deployment; 24GB possible only with significant architectural trade-offs | SGLang benchmark |
Important Decision Note: The lowest validated fit is not automatically the best production configuration. A 24GB deployment that continually transfers model layers from CPU memory can have a very different latency, host-RAM requirement, and cost per completed output than a 48GB, 80GB, 96GB, or 141GB deployment.
Precision and Quantization Support: Do Not Treat Every 4-Bit Format as the Same
| Model | FP8 | NF4 / Other 4-bit | INT8 | NVFP4 | MXFP4 | Important Note |
|---|---|---|---|---|---|---|
| SD 3.5 | Runtime-specific FP8 paths exist | N/V | N/V | N/V | N/V | Do not infer peak savings without matching benchmark |
| FLUX.1-dev | Supported by optimized runtimes | 4-bit paths documented | Runtime-specific | N/V | N/V | Quantization + offloading can take the pipeline below 16GB |
| FLUX.2 Klein 4B | FP8 variants available | Runtime-specific | Runtime-specific | N/V | N/V | Official model-card fit is ~13GB |
| FLUX.2 Klein 9B | FP8 variants available | Runtime-specific | Runtime-specific | NVFP4 checkpoint/path exists | N/V | Do not label NVFP4 as MXFP4 |
| FLUX.2 dev | Runtime-specific | 4-bit path documented | 8-bit can be considered for intermediate 40–48GB configurations | Runtime-specific | N/V | BFL documents 4-bit for 24–32GB |
| Qwen-Image | Runtime-specific | NF4 4-bit validated at 14.93GB | Runtime-specific | N/V | N/V | NF4 is 4-bit but is not INT4 |
| Wan2.2 | Runtime-specific | Runtime-specific | Runtime-specific | N/V | N/V | Publish only configuration-specific measurements |
| LTX-2.5 | FP8 Cast and FP8 Scaled MM supported | Trainer supports INT4 options, but do not confuse this with the tested 32GB preset | 32GB low-VRAM trainer preset uses INT8 | Supported for LTX-2.5 inference on Blackwell | N/V | Precision support ≠ validated universal peak VRAM |
| HunyuanVideo 1.5 | FP8 GEMM supported | N/V | N/V | N/V | N/V | Official 14GB minimum depends on offloading |
| MiniMax H3 | Documented FP8 datacenter path | N/V | Consumer INT8 path documented | N/V | N/V | Consumer and datacenter benchmark workloads differ |
LTX-2.5’s current tooling supports FP8 optimization and added NVFP4 support for Blackwell-generation inference. Its trainer also supports several quantization modes, but its documented 32GB low-VRAM training configuration specifically uses INT8, not INT4.
Precision note: NF4, INT4, NVFP4, and MXFP4 are not interchangeable labels. A checkpoint or runtime validated for one should not be moved into another precision column merely because both use approximately four bits per value.
How Much VRAMDoes Stable Diffusion 3.5 Need?
Stability AI identifies Stable Diffusion 3.5 Medium as a 2.5-billion-parameter model and Stable Diffusion 3.5 Large as an 8.1-billion-parameter model. Large Turbo is distilled from Large and generates in four inference steps.
For SD 3.5 Large, vLLM-Omni reports peak memory of approximately 31.6 GiB at 1024×1024 and 45.5 GiB at 2048×2048, with guidance_scale=4.5. The framework specifically notes that its 2048×2048 workload fits inside a 48GB-class GPU but leaves little headroom.
Treat those figures as vLLM-Omni configuration measurements, not universal SD 3.5 requirements.
How Much VRAM Does FLUX Need?
FLUX spans several very different memory classes.
The current vLLM-Omni reference table reports 33.9 GiB peak VRAM for FLUX.1-dev at 1024×1024, with 31.4 GiB of model weights, under its basic single-card unoptimized configuration.
Hugging Face separately demonstrates a sub-16GB FLUX.1-dev path using quantization and memory-saving techniques.
FLUX.2 Klein
Black Forest Labs’ current FLUX.2 Klein 4B model card states that the model can run with approximately 13GB VRAM on consumer hardware. The 4B Base model likewise lists approximately 13GB VRAM, while the 9B family lists approximately 29GB VRAM.
For the main sizing table, use ~13GB as the official model-card fit for FLUX.2 Klein 4B. If you discuss an 8GB configuration, tie it to the exact runtime, quantization, and component-placement method that achieved it.
FLUX.2-dev
FLUX.2-dev belongs to a very different memory class. Black Forest Labs documents 24–32GB GPU operation with 4-bit quantization, including a configuration using a 4-bit transformer and remote text encoder that can reach approximately 18GB VRAM.
But that does not make 24GB equivalent to a high-memory deployment.
BFL’s own documentation states that even an 80GB H100 cannot hold the text encoder, transformer, and VAE simultaneously. At that tier, CPU offloading is still used. The same documentation says that on H200, B200, or larger cards, all components can fit together.
The lesson is more useful than any single FLUX number:
Quantization and offloading can change the GPU tier, but they also change the deployment architecture, latency profile, host-memory requirement, and potentially output characteristics.
Can Qwen-Image Run on 24GB VRAM?
Yes, with a validated quantized configuration.
Hugging Face’s current Diffusers Quickstart reports 14.93GB GPU memory after quantizing Qwen-Image’s transformer and text encoder to 4-bit NF4. Adding model CPU offloading reduces the documented example to approximately 12.54GB.
By comparison, current vLLM-Omni reports 60.0 GiB peak VRAM at 1024×1024, with 53.7 GiB of model weights, in its basic unoptimized reference configuration.
This is why optimized minimum VRAM and resident production VRAM should remain separate fields.
Can Wan2.2 Run on 24GB VRAM?
For Wan2.2 TI2V-5B, yes.
The official Wan2.2 repository states that its TI2V-5B model supports 720p video at 24 FPS. Its documented single-GPU command uses 1280×704 resolution and can run on a GPU with at least 24GB VRAM when model offloading, dtype conversion, and T5 CPU placement are enabled.
The larger variants belong to a different memory tier. The same official repository states that the single-GPU T2V-A14B configuration requires at least 80GB VRAM, and its I2V-A14B configuration also requires at least 80GB.
Therefore, ‘Wan2.2 needs 24GB’ and ‘Wan2.2 needs 80GB’ can both be correct depending on the exact variant and configuration.
How Much VRAM Does LTX-2.5Need?
LTX-2.5 uses a 22B video/audio transformer together with a custom Gemma 4 12B text encoder.
For inference, the official pipeline supports FP8 Cast, FP8 Scaled MM, CPU offload, and disk offload. Because the current documentation does not provide one comparable universal inference peak across those paths, the safer reference-table entry is N/V, not an invented estimate.
Training has clearer hardware guidance. The official LTX trainer recommends 80GB VRAM for its standard configuration and provides a tested 32GB low-VRAM configuration.
Therefore, the 32GB configuration optimized training minimum using INT8 and memory optimizations, not under an INT4 VRAM claim.
How Much VRAM Does HunyuanVideo 1.5 Need?
Tencent’s official HunyuanVideo 1.5 repository lists 14GB as the minimum GPU-memory requirement with model offloading enabled. Tencent explicitly notes that users with sufficient GPU memory can disable offloading for improved inference speed.
The repository also documents FP8 GEMM support for the transformer through SGL-Kernel.
Treat the 14GB figure as an optimized minimum with offloading, not recommended native VRAM.
How Much VRAM Does MiniMax H3 Need?
MiniMax H3 is particularly useful for demonstrating why a low GPU-VRAM number can hide a much larger infrastructure requirement.
Datacenter configuration
In SGLang’s documented 8× NVIDIA B300 benchmark, a 1344×768, 124-frame workload at 50 denoising steps reached:
- 83,578MB/GPU in BF16 for the FL2VA auto/fold configuration.
- 51,926MB/GPU in FP8 for the equivalent auto/fold configuration.
Consumer 24GB configuration
SGLang also documents an RTX 4090 24GB single-GPU path that stayed at roughly 18GB peak GPU memory, but this is not the same workload as the B300 benchmark.
The documented 4090 run used 1344×768, 107 frames, and 20 denoising evaluations, with heavy layerwise offloading.
Therefore, the 18GB and 83GB figures should never appear as though they are directly comparable precision results.
How Much VRAM Can FP8 and 4-bit Quantization Save?
Lower precision primarily reduces the memory occupied by model weights. It does not automatically reduce total runtime VRAM by the same ratio because activations, VAEs, text encoders, latent tensors, temporary buffers, and some layers may remain at higher precision.
Qwen-Image illustrates this directly: Hugging Face reduces its documented configuration to 14.93GB with 4-bit NF4 and approximately 12.54GB when CPU offloading is added.
Similarly, Hugging Face demonstrates a sub-16GB FLUX.1-dev configuration using FP8/Quanto plus CPU offloading.
For MXFP4, do not derive VRAM values mathematically. Unless the exact image/video model and runtime have a validated MXFP4 deployment, mark the cell N/V, not validated.
Why Can the Same Model Use Different Amounts of VRAM?
Resolution alone can materially change peak memory.
In vLLM-Omni’s documented SD 3.5 Large setup, peak VRAM rises from 31.6 GiB at 1024×1024 to 45.5 GiB at 2048×2048.
Video generation adds further variables such as frame count and temporal processing. Wan2.2’s 24GB TI2V-5B example, for instance, depends on explicit model offloading and CPU placement. MiniMax H3 can likewise reach a low GPU-memory footprint only by moving substantial parts of the workload elsewhere.
A credible VRAM benchmark should therefore state at least:
Model + variant + precision + resolution + frames + runtime + optimization method + concurrency
beside the number.
Which GPU Should You Choose for 24GB, 48GB, 80GB, or 96GB Workloads?
VRAM determines whether a workload can fit. But memory bandwidth, architecture, supported precision, Tensor Core generation, CPU offload behavior, concurrency, and workload latency determine how well it runs.
| GPU | VRAM | Memory Bandwidth | Recommended Workload Fit |
|---|---|---|---|
| NVIDIA L4 | 24GB | 300GB/s | Quantized image models and lighter/offloaded video |
| RTX A6000 | 48GB | 768GB/s | Memory-heavy development and workstation workloads |
| L40S | 48GB | 864GB/s | Strong general-purpose visual AI inference with FP8 support |
| RTX 6000 Ada | 48GB | 960GB/s | Newer-generation 48GB creative and GenAI workloads |
| A100 80GB PCIe / SXM | 80GB | 1,935 / 2,039GB/s | Large video, bandwidth-heavy inference, training |
| NVIDIA RTX PRO 6000 Blackwell Server Edition | 96GB GDDR7 ECC | 1,597GB/s | High-capacity Blackwell AI inference, visual computing, rendering, and enterprise server workloads |
| H200 NVL / H200-class | 141GB | up to 4.8TB/s depending on platform | Very large models, fuller component residency and high-memory AI workloads |
This is why 48GB is a capacity class, not a performance class.
Three GPUs may all offer 48GB but differ materially in memory bandwidth, Tensor Core generation, FP8 support, power profile, and deployment environment.
The cheapest GPU per hour is also not necessarily the cheapest deployment. If aggressive CPU offloading doubles or triples time-to-output, a higher-memory GPU may deliver lower cost per completed image or video.
For infrastructure buyers, compare:
GPU price × generation time × utilization × concurrency
rather than hourly GPU price alone.
If you are deploying in India, also separate subsidized compute from unrestricted commercial GPU cloud. IndiaAI can materially reduce GPU-hour costs for approved users, while commercial providers such as AceCloud, JarvisLabs, and Cyfuture can offer different advantages in immediate availability, GPU choice, billing flexibility, support, and production deployment. Compare the effective cost of completing your workload, not just the advertised cost of keeping a GPU active for one hour.
Talk to an expert to compare 24GB, 48GB, 80GB, and 96GB configurations for your actual pipeline.
What Should You Check Before Choosing a GPU?
A reliable sizing decision should answer seven questions:
- Which exact model and variant are you running?
- Is the workload inference, LoRA fine-tuning, or full training?
- What image resolution or video resolution, duration, and frame count do you need?
- Which precision and quantization implementation will you use?
- Which text encoders, VAEs, decoders, or model layers will remain on GPU?
- Will CPU offloading or disk offloading be required?
- How much system RAM does the offloaded configuration require?
- Could storage or PCIe transfers become a latency bottleneck?
- How much concurrency or batching must production support?
- What latency, throughput, and cost-per-output target must the deployment meet?
- Which runtime and framework version will production actually use?
- How much VRAM headroom do you want beyond the measured peak?
The correct GPU is not simply the smallest one that avoids an OOM error. It is the smallest configuration that consistently satisfies quality, latency, throughput, and cost requirements.
Size Your AI Workload Right with AceCloud
The right GPU is not simply the one that can load your image or video model. It needs enough VRAM and enough surrounding CPU, RAM, storage, and bandwidth capacity to support your exact model variant, precision, resolution, frame count, offloading strategy, and production concurrency without unnecessary overprovisioning.
Whether your workload fits an optimized 24–32GB configuration, benefits from a flexible 48GB tier, requires 80–96GB of high-memory capacity, or moves into 141GB-class infrastructure for fuller model residency, the decision should be based on the complete pipeline rather than theoretical checkpoint size alone.
AceCloud provides access to NVIDIA GPU infrastructure across these workload classes, including L4, L40S, RTX A6000, RTX 6000 Ada, A100, RTX PRO 6000 Blackwell, and high-memory H200-class configurations.
Instead of sizing infrastructure around a theoretical minimum, choose a configuration built for reliable production performance and acceptable cost per completed output.
Book a free consultation with AceCloud to map your image or video model to the right GPU and VRAM tier.
Frequently Asked Questions
For most AI image generation workloads, 24–32GB VRAM is a practical starting point. 48GB provides more headroom for larger models, higher resolutions, less CPU offloading, and production workloads.
AI video generation typically needs 24GB to 80GB+ VRAM. Optimized pipelines can run on 24–32GB, while larger models, higher resolutions, longer videos, training, and reduced offloading often require 80GB or more.
Yes, with optimization. FLUX.2-dev can run at around 18GB VRAM using 4-bit quantization and a remote text encoder, while Qwen-Image reaches 14.93GB with NF4 4-bit quantization.
Yes. Wan2.2 TI2V-5B can run on 24GB VRAM using model offloading and CPU placement. Larger Wan2.2 A14B variants require at least 80GB VRAM for documented single-GPU configurations.
It can. 4-bit quantization reduces model-memory usage, but quality impact varies by model, quantization method, and runtime. Compare quantized outputs against a higher-precision baseline before using them in production.
No. System RAM cannot directly replace GPU VRAM, but CPU offloading can store model components in RAM and move them to the GPU when required. This reduces VRAM usage but can increase latency.
No. Two 48GB GPUs do not automatically provide one shared 96GB VRAM pool. The model must support sharding or distributed execution, and communication between GPUs can introduce additional performance overhead.
