Wan 2.2 VRAM Requirements by GPU: What Every Card Can Actually Generate

Wan 2.2 runs on an 8GB GPU — if you match the variant to your card. The TI2V-5B model officially targets 24GB (an RTX 4090 renders a 5-second 720p clip in under 9 minutes, per the official repo), but ComfyUI's docs state it "should fit well on 8GB vram" with native offloading, and its Q8_0 GGUF is a 5.4GB file. The 14B T2V/I2V models officially want an 80GB GPU at full FP16 (even with the repo's offload flags on) — yet the FP8 builds (14.3GB per expert) put them on 24GB cards, and Q5_K_M GGUF (10.8GB per expert) is community-reported working on 16GB at 720p. And if you searched "Wan 2.7 VRAM requirements": there is nothing to size, because Wan 2.7 has no open weights — the official open line still stops at Wan 2.2.

This page is the "what runs on my card" reference for the Wan family: a variant-by-precision table with real file sizes, the exact files to download per VRAM tier, the official commands with the offload flags explained, and a straight answer on why the numbers you see elsewhere contradict each other. Every figure below comes from the official Wan2.2 repo, the ComfyUI Wan 2.2 docs, or the Hugging Face file listings linked inline — nothing is guessed.

What Can Your GPU Actually Generate?

Here is the verdict table before the detail. "Expert" refers to the 14B models' two-part design, explained below — you need both files on disk, but only one sits in VRAM at a time.

Two headline facts frame everything else. First, the TI2V-5B is a genuinely good budget option, not a consolation prize: it does both text-to-video and image-to-video at 720p/24fps (1280×704, 5-second clips) per the official repo. Second, the 14B models' quality advantage is real but the official requirement — "a GPU with at least 80GB VRAM" for the unquantized single-GPU command (which already includes the repo's offload flags) — is a baseline, not a wall; quantization is what makes them consumer-hardware models at all.

Wan 2.2 VRAM Requirements by Variant and Precision

This is the core matrix. File sizes are from the Comfy-Org repackaged repo and QuantStack's GGUF listings (A14B, TI2V-5B). A useful rule of thumb carried over from our FLUX VRAM guide: a GGUF file's size on disk is close to the VRAM its weights occupy, so you can pre-screen any file against your card before downloading. Video adds activation memory on top that grows with resolution and frame count, so leave headroom.

Three attribution notes, because the tiers matter. The 24GB and 80GB figures are official statements from the Wan2.2 README. The 8GB claim for the 5B is a direct quote from the ComfyUI docs: "The Wan2.2 5B version should fit well on 8GB vram with the ComfyUI native offloading." The 16GB/720p figure for the 14B at Q5_K_M is community-reported — consistent across user reports, but not an official spec, so treat it as a starting point. The 8.19GB figure for the older 1.3B is official, from the Wan2.1 repo, which also notes it generates a 5-second 480p video in about 4 minutes on an RTX 4090 without quantization — still the strongest official low-VRAM number in the whole family.

Why the Numbers Online Contradict Each Other

Search "wan 2.2 vram" and you will find pages claiming 8GB and pages claiming 80GB+. Both are quoting real numbers. Three things reconcile them:

1. "Wan 2.2" is three different models. The TI2V-5B is a 5-billion-parameter dense model; the T2V-A14B and I2V-A14B are Mixture-of-Experts models with 27B total parameters (14B active), per the official repo. A page benchmarking the 5B and a page quoting the 14B baseline are describing hardware requirements roughly an order of magnitude apart while using the same product name. Always check which Wan 2.2 a requirements claim is about.

2. Official numbers are for unquantized FP16; real workflows quantize. The repo's "at least 80GB" is attached to a single-GPU command that already runs with --offload_model True and --convert_model_dtype (its OOM note suggests adding --t5_cpu on top) — so offloading alone does not close the gap. What closes it is quantization: FP8 cuts each expert from 28.6GB to 14.3GB and GGUF goes lower still, while ComfyUI's more aggressive memory management shuttles the rest between VRAM and system RAM. That combination is why an 8GB card can technically run a model whose official requirement says 24GB.

3. The 14B's two experts never need VRAM at the same time. The A14B models split the denoising run between a high-noise expert (early steps, overall layout) and a low-noise expert (later steps, fine detail), per the official repo's MoE design. They execute in sequence, so the workflow holds one ~14.3GB FP8 expert in VRAM at a time, not both — ComfyUI's native 14B workflow literally chains two model loaders. That is why "28.6GB of FP8 files" fits a 24GB card: your VRAM budget is one expert plus the text encoder, VAE, and activations.

Once you know those three facts, every number you meet on this topic slots into place.

Wan VRAM by GPU Card — What Actually Fits

The same information mapped to actual hardware:

If you have a 24GB card, it is the sweet spot of this entire table — both the official 5B path and the practical 14B FP8 path land on it, which is a big part of why we rate it so highly for local AI generally: see the model lineup a 4090 unlocks in best AI models for the RTX 4090. Shopping for a card with video generation in mind? The best GPUs for AI ranking covers the field, and if you are speccing a whole machine, the Local AI Build Kit ($49) includes a 72-row model-fit matrix built from machines that were actually assembled and measured — the same "will it fit" method this page applies to Wan.

Which Exact Files Should You Download per VRAM Tier?

Every Wan 2.2 ComfyUI setup needs support files alongside the diffusion model, per the ComfyUI docs and the Comfy-Org file listings:

• Text encoder: umt5_xxl_fp8_e4m3fn_scaled.safetensors (6.74 GB) → ComfyUI/models/text_encoders/ (an FP16 version exists at 11.4 GB; the FP8 is the sensible default)
• VAE: wan2.2_vae.safetensors (1.41 GB) for the 5B; wan_2.1_vae.safetensors (254 MB) for the 14B models → ComfyUI/models/vae/

Then pick your tier:

• 8 GB: TI2V-5B. Easiest path: the official ComfyUI route with wan2.2_ti2v_5B_fp16.safetensors (10 GB) in models/diffusion_models/ and let native offloading handle the overflow. Smaller-footprint path: the Q8_0 GGUF (5.4 GB) in models/unet/ with city96's ComfyUI-GGUF custom node loading it.
• 12 GB: TI2V-5B FP16 (10 GB). No GGUF node needed, no quality compromise within the 5B.
• 16 GB: A14B GGUF Q5_K_M — download both expert files (high-noise and low-noise, 10.8 GB each) into models/unet/, loaded via ComfyUI-GGUF. Q4_K_M (9.65 GB each) buys a little more headroom at some quality cost.
• 24 GB: A14B FP8 — wan2.2_t2v_high_noise_14B_fp8_scaled.safetensors and wan2.2_t2v_low_noise_14B_fp8_scaled.safetensors (14.3 GB each; i2v equivalents for image-to-video) into models/diffusion_models/. No custom node required.
• 80 GB: the FP16 pair (28.6 GB each) — at that point you are running the official baseline and this guide is beneath your hardware.

Disk-space note before you start: a 14B FP8 setup totals roughly 36 GB of downloads (two experts + encoder + VAE), and a Q5 GGUF setup about 29 GB. For the workflow graphs and node-by-node walkthrough once files are in place, our complete ComfyUI guide and the dedicated Wan video generation guide take over where this page stops.

The Official Commands (and What the Flags Do)

If you prefer the repo's own generate.py to ComfyUI, these are the official examples from the Wan2.2 README, verified August 2026. The 5B on a single consumer GPU:

python generate.py --task ti2v-5B --size 1280*704 \
  --ckpt_dir ./Wan2.2-TI2V-5B \
  --offload_model True --convert_model_dtype --t5_cpu \
  --prompt "Your prompt here"

The 14B with memory optimizations on:

python generate.py --task t2v-A14B --size 1280*720 \
  --ckpt_dir ./Wan2.2-T2V-A14B \
  --offload_model True --convert_model_dtype \
  --prompt "Your prompt here"

And the previous-generation 1.3B, still the official pick for the tightest cards (480p only):

python generate.py --task t2v-1.3B --size 832*480 \
  --ckpt_dir ./Wan2.1-T2V-1.3B \
  --offload_model True --t5_cpu \
  --sample_shift 8 --sample_guide_scale 6 \
  --prompt "Your prompt here"

What the three memory flags actually do: --offload_model True moves model weights out to system RAM when they are not actively needed, --convert_model_dtype casts the model parameters to a lighter dtype, and --t5_cpu keeps the large T5 text encoder off the GPU entirely. One practical consequence of offloading that trips people up: the weights have to go somewhere, so system RAM becomes the second constraint — spilling 28GB of expert weights into a 16GB-RAM machine will page to disk and crawl. 32GB of system RAM is a sensible floor for the 14B offload path.

What About Wan 2.7 VRAM Requirements?

There are none to list, because Wan 2.7 does not exist as an open release. We verified the official Hugging Face organization again for this article (August 2026): the newest open-weight video models remain the Wan 2.2 family — no 2.3, 2.5, 2.6, or 2.7 weights are published there. Wan 2.5 and 2.6 reportedly shipped API-first with no open weights, and the "Wan 2.7 download" sites are SEO fabrications with no official release behind them — we documented that whole mess in Is Wan 2.7 open source?. Any page quoting "Wan 2.7 VRAM requirements" is quoting a spec sheet for a model you cannot download. The honest translation of the query is this article: the requirements for the newest Wan you can actually run.

If a later Wan does go open-weight, the table above extends naturally — check the official org first, and expect this page to be updated shortly after.

How Long Does Wan Generation Take?

The two figures worth planning around are both official. The TI2V-5B generates a 5-second 720p video in under 9 minutes on a single consumer-grade GPU (the repo's example card is the RTX 4090), per the Wan2.2 README. The older Wan 2.1 T2V-1.3B generates a 5-second 480p video in about 4 minutes on an RTX 4090 without quantization, per the Wan2.1 README.

Everything else scales off those anchors, in the wrong direction: quantized 14B runs on 16GB cards go slower than the 5B numbers, and the moment offloading starts swapping experts or spilling to system RAM, generation time can multiply. Local video is not an interactive medium yet — queue prompts, walk away, come back. If those timings are a dealbreaker on your card, our low-VRAM text-to-video guide covers the lighter alternatives.

Honest Limitations

Things this page cannot promise, so you should not assume:

• There is no official consumer-card figure for the 14B models. The 16GB/Q5_K_M number is community consensus, not a spec. Your exact fit depends on resolution, frame count, and what else is holding VRAM.
• File size is the floor, not the total. Video diffusion's activation memory grows with frames × resolution — a workflow that fits at 480p can OOM at 720p with the same model file. When that happens, drop resolution or frames first, quant level second.
• Offloading rescues fit, not speed. Every tier below the official one pays in generation time. The 8GB paths work; nobody would call them pleasant.
• Quantization costs quality. FP8 holds up well; by Q4 the degradation is visible in fine detail and motion coherence. Q5 is the sensible floor for the 14B if quality is the point.
• This is a moving target. File sizes and claims were verified against the linked sources in August 2026. Community quants iterate fast; if a figure matters to your purchase decision, click through to the linked listing and re-check it.

FAQ

Can I run Wan 2.2 on 8GB of VRAM?

Yes — the TI2V-5B variant. The ComfyUI docs state the 5B "should fit well on 8GB vram with the ComfyUI native offloading," and the Q8_0 GGUF shrinks the weights file to 5.4 GB. You get both text-to-video and image-to-video at 720p/24fps. The 14B models can technically reach 8GB via aggressive GGUF quants plus CPU offloading, but generation gets very slow — the 5B is the right call at this tier.

What are the Wan 14B VRAM requirements?

Officially, "at least 80GB" for the unquantized single-GPU command — which already includes the repo's offload flags — per the Wan2.2 repo. Practically: 24GB cards run the FP8 builds (14.3 GB per expert), and 16GB cards run Q5_K_M GGUF quants (10.8 GB per expert) at 720p per community reports. The key architectural fact is that the two experts (high-noise and low-noise) execute sequentially, so only one needs VRAM at a time.

What are Wan 2.7 VRAM requirements?

Wan 2.7 has no open weights — it does not exist on the official Hugging Face org or GitHub as of August 2026, and sites offering "Wan 2.7 downloads" are SEO fabrications. The newest open release is Wan 2.2, and its requirements are the ones in this guide: 8GB minimum for the 5B, 16-24GB for a good 14B experience.

Do I need to download both 14B expert files?

Yes — both on disk, one at a time in VRAM. The high-noise expert handles the early denoising steps and the low-noise expert the later ones, so ComfyUI's workflow loads them sequentially. Budget disk for two files (2× 14.3 GB at FP8, 2× 10.8 GB at Q5_K_M) but VRAM for one.

Is the Wan 2.2 5B better than the old Wan 2.1 1.3B for low VRAM?

For most people, yes: the 5B does 720p at 24fps and handles both T2V and I2V in one model, while the 1.3B tops out at 480p. The 1.3B's counterargument is that its 8.19 GB requirement is an official figure with an official ~4-minute generation time on a 4090 — the most predictable low-VRAM experience in the family. If your card is 6-8GB and you value reliability over resolution, the 1.3B is still a legitimate pick.

Key Takeaways

1. Match the variant to the card: TI2V-5B for 8-12GB, 14B GGUF Q5_K_M for 16GB, 14B FP8 for 24GB. The official 80GB figure applies only to unquantized FP16 inference.
2. The 8GB and 80GB claims are both true — different variants, different precisions. The 5B-on-8GB claim is from ComfyUI's own docs; the 80GB baseline is from the official repo.
3. The 14B's two experts run sequentially, so VRAM must hold one expert (14.3 GB at FP8), not both — that single fact is why a 24GB card runs a 27B-parameter model.
4. File size ≈ weights VRAM, plus video's activation overhead. Pre-screen any GGUF against your card by its download size, then leave headroom for resolution × frames.
5. Ignore every "Wan 2.7" spec sheet. No open weights exist beyond Wan 2.2 as of August 2026 — verified against the official Hugging Face org for this article.

Next Steps

• Ready to install? The Wan video generation guide walks the full ComfyUI setup, and the complete ComfyUI guide covers the tool itself.
• On a tight card? The low-VRAM text-to-video guide compares Wan against the lighter options.
• Doing images too? The companion FLUX VRAM requirements by GPU applies this same method to image generation.
• Choosing hardware for video work? Start with best GPUs for AI.