Video generation model

Self-host Wan, starting on one 24GB card

Wan2.2 is one of the very few frontier video models that genuinely produces 720P@24fps on a consumer card. TI2V-5B renders a 5-second clip on an RTX 4090 in under 9 minutes — $0.540/GPU-hour here, billed per second.

Wan · self-hosted

Get the version lines straight first, because this is where most Wan self-hosting attempts go wrong. Alibaba runs two parallel tracks. One is the Apache 2.0 open-weights track, living at Wan-Video/Wan2.2 on GitHub and under the Wan-AI org on Hugging Face. The other is a closed, API-only track on Model Studio: wan2.5-t2v-preview, wan2.6-i2v, wan2.7-t2v. The 2-to-15-second durations, 1080P output and native synchronised audio only exist behind that API. There are no official wan2.5 weights on Hugging Face and no Wan2.5 repo on GitHub, and there will not be. If you want to deploy locally, keep everything on your own infrastructure, or wire this into your own pipeline, Wan2.2 is the ceiling of what you can actually download.

The good news is that the open track has not stalled. The core T2V-A14B, I2V-A14B and TI2V-5B landed in July 2025, followed by the audio-driven S2V-14B in August and the character animation/replacement Animate-14B in September. Then on 13 July 2026 came Wan-Dancer-14B for long-form music-driven dance video, and on 7 August 2026 Wan-Animate-2-14B, which removes the intermediate motion extractor entirely and feeds the driving video straight into a redesigned DiT — shipping alongside a distilled variant that runs in 10 steps at guidance_scale 1.0. All Apache 2.0, all commercially usable.

What actually determines which card you need is Wan2.2's MoE design. A14B is not a 14B model. It is 27B total parameters with 14B active per step, split across two experts: a high-noise expert that handles overall layout in the early denoising steps and a low-noise expert that refines detail later, with the handoff triggered at a signal-to-noise threshold. On disk that is two 14B checkpoints; in VRAM that is where the README's blunt "at least 80GB VRAM" comes from. TI2V-5B takes the other road entirely — it swaps in the Wan2.2-VAE with a 4×16×16 compression ratio (4×32×32 effective after patchification, 64× overall), trading a much more aggressive latent space for 24GB feasibility, at the cost of being pinned to 1280×704 / 704×1280, 24fps, 5 seconds. The table below prices out both roads.

01 —

Every Wan open-weights release

All Apache 2.0. VRAM figures come from the official READMEs, model cards and community quantisation repos.

Version	Parameters	VRAM	Context	Notes
Wan2.2-TI2V-5B	5B (dense, not MoE)	bf16 single-card floor is 24GB (the README names the RTX 4090); ComfyUI's native offloading reportedly fits it into 8GB	1280×704 / 704×1280, 24fps, 5 seconds	Unified text-to-video and image-to-video. Billed as one of the fastest 720P@24fps models available; under 9 minutes per clip on a 4090. The only member using Wan2.2-VAE — its VAE file is not interchangeable with A14B's.
Wan2.2-T2V-A14B	27B total / 14B active (high-noise + low-noise two-expert MoE)	Official single-card floor 80GB; fp8 is roughly 14GB per expert (14B × 1 byte); GGUF Q4_K_M ~9.65GB/expert, Q8_0 ~15.4GB/expert, Q2_K ~5.3GB/expert	480P and 720P	The text-to-video workhorse. Trained on 65.6% more images and 83.2% more video than Wan2.1, with curated aesthetic labels for lighting, composition, contrast and colour tone you can steer directly from the prompt. Uses wan_2.1_vae.
Wan2.2-I2V-A14B	27B total / 14B active (same two-expert MoE)	Same class as T2V-A14B: 80GB officially, or down to the 32GB tier via fp8_scaled / GGUF with expert swapping	480P and 720P	Image-to-video, and the most reliable option for first-frame control — product stills into motion, storyboards into shots. In the official ComfyUI workflow the high-noise and low-noise weights are two separate safetensors; download both.
Wan2.2-S2V-14B	14B	Official single-card floor 80GB; supports FSDP + DeepSpeed Ulysses for multi-GPU sharding	480P / 720P, commonly 1024×704, length follows the audio automatically	Audio-driven cinematic generation — speech and singing both work. --pose_video makes it follow a given pose sequence while staying in sync with the audio. Longer audio means proportionally longer runs, so preview with --num_clip first.
Wan2.2-Animate-2-14B (plus Distilled)	14B	Repo defaults are tuned for 8× A800 at 720P; 480P was tested on 2× A800. No single-card recipe is documented — you edit the parallel config in the YAML	720P / 480P, from a reference image + driving video + text prompt	Second-generation character animation, released 7 August 2026. End-to-end consumption of the driving video with no intermediate motion extractor, plus text-driven viewpoint control that decouples camera from the driving clip. The distilled variant runs 10 steps, guidance_scale 1.0, Euler.
Wan2.1-T2V-1.3B	1.3B	8.19GB — the README's words are that it fits almost all consumer-grade GPUs	480P, 5 seconds	Last generation's small model, still the cheapest way to validate a pipeline: about 4 minutes for a 5-second 480P clip on an RTX 4090, with no quantisation. Build your scheduler, prompt templates and queue against this, then swap in Wan2.2.

02 —

Pick a card by how you actually run it

NexGPU list rates. Metered per second, priced per hour, no minimum and no setup fee.

Validate the pipeline first — Wan2.1-T2V-1.3B for prompt tuning, scheduling and queue tests
RTX 3090 24GB$0.193/GPU-hr
The 1.3B model needs only 8.19GB, so a 24GB card is generous, and this is our cheapest 24GB option — getting the plumbing right costs almost nothing.
Single-card 720P@24fps output with Wan2.2-TI2V-5B and the official generate.py
RTX 4090 24GB$0.540/GPU-hr
The exact card the README names as the baseline. 24GB clears the floor, a 5-second 720P clip lands in under 9 minutes, and that works out to roughly 8 cents per clip.
Running the A14B two-expert setup in ComfyUI via fp8_scaled or GGUF quants
RTX 5090 32GB$0.723/GPU-hr
At fp8 each expert is around 14GB, so a 24GB card thrashes swapping them in and out. 32GB keeps the umt5 text encoder, the VAE and the active expert resident at once.
Running A14B / S2V-14B at bf16 exactly as scripted, or Animate-2 in multi-GPU parallel
A100 SXM4 80GB$1.088/GPU-hr
This is the 80GB tier the README is written against, and Animate-2's default config targets 8× A800 — same generation, same VRAM, drop-in. Up to 14 GPUs per node here.

03 —

Four steps to running on NexGPU

Worked through with Wan2.2-TI2V-5B on one card; A14B and multi-GPU pick up at step four.

01
Spin up an instance and clone the repo
Pick an RTX 4090 24GB at console.nexgpu.net and start from the prebuilt PyTorch image — ComfyUI and vLLM images are also sitting in the 2,000+ image library. Wan requires torch >= 2.4.0, which the prebuilt images already satisfy. If flash_attn fails to build, follow the README's own advice and install the other packages first, then flash_attn on its own.
```
git clone https://github.com/Wan-Video/Wan2.2.git && cd Wan2.2 && pip install -r requirements.txt
```
02
Pull the weights
The TI2V-5B checkpoint directory bundles the 5B DiT, the umt5-xxl text encoder and the Wan2.2-VAE, so one pull gets everything. Note that A14B uses wan_2.1_vae while TI2V-5B uses wan2.2_vae — mixing them is the single most common source of errors in ComfyUI workflows.
```
huggingface-cli download Wan-AI/Wan2.2-TI2V-5B --local-dir ./Wan2.2-TI2V-5B
```
03
Render your first clip on one card
The official recipe for a 24GB card is three flags together: --offload_model True to swap idle modules out to host RAM, --convert_model_dtype to convert parameter precision, and --t5_cpu to move the text encoder entirely onto the CPU. All three are what make 24GB viable, so don't under-spec system RAM on the instance.
```
python generate.py --task ti2v-5B --size 1280*704 --ckpt_dir ./Wan2.2-TI2V-5B --offload_model True --convert_model_dtype --t5_cpu --prompt "Two anthropomorphic cats in boxing gear fight under a spotlight"
```
04
Move to A14B and scale across GPUs
Once the output quality is confirmed, switch to an 80GB card for full-precision A14B. For multi-GPU, --dit_fsdp shards the DiT, --t5_fsdp shards the text encoder, and --ulysses_size sets sequence parallelism. NexGPU offers up to 14 GPUs per node and a maximum node VRAM of 2,152GB, so Animate-2's 8-GPU default config runs unmodified.
```
torchrun --nproc_per_node=8 generate.py --task t2v-A14B --size 1280*720 --ckpt_dir ./Wan2.2-T2V-A14B --dit_fsdp --t5_fsdp --ulysses_size 8 --prompt "..."
```

What one real render session costs

Take TI2V-5B on an RTX 4090 24GB at $0.540/GPU-hour. Instance start, dependency install and weight download run about 0.5 hours: $0.540 × 0.5 = $0.27. The official benchmark is under 9 minutes for a 5-second 720P clip, so 0.15 hours per clip, or $0.540 × 0.15 ≈ $0.081 each. Generate 40 candidates and that is 40 × 0.15 = 6 hours, $0.540 × 6 = $3.24. Whole session: 6.5 hours × $0.540 = $3.51. Pulling 40 short 720P clips down is on the order of 0.2GB, so egress is 0.2 × $0.0081 ≈ $0.002 — noise. If you want to keep the weights instead of re-downloading, a 60GB volume at the $0.414/GB-month median is $24.84/month, roughly $0.83/day. Remember that compute billing stops the second the instance stops, while storage keeps billing until the volume is destroyed — so destroy the volume when a short project wraps. For comparison, the same session at full-precision A14B runs on an A100 SXM4 80GB at $1.088/GPU-hour: rent one hour, see the 720P output, then decide whether it's worth scaling to eight cards. Considerably cheaper than buying the answer up front.

04 —

FAQ

Are Wan2.5 / Wan2.6 / Wan2.7 open source? Can I run them locally?

No. All three are API-only. wan2.5-t2v-preview covers 480P/720P/1080P at 5 or 10 seconds; wan2.6 and the 2026-06-12 snapshot of wan2.7-t2v widen that to 2–15 seconds with native audio tracks. But the Wan-AI org has never published matching weights and there is no Wan2.5 repo on GitHub. The occasional third-party "Wan-2.5" upload on Hugging Face is not official. The ceiling for anything you can genuinely self-host is the Wan2.2 line plus Wan-Animate-2 and Wan-Dancer — and that line starts on NexGPU at $0.193/GPU-hour on an RTX 3090.

How much VRAM does Wan2.2 A14B really need, and why does the README say 80GB?

Because A14B is not a single 14B model. It is a 27B two-expert MoE — two separate 14B checkpoints on disk, switched by signal-to-noise ratio during sampling — and on top of that you pay peak memory for 720P latents and attention. Hence the 80GB safety line. Two ways to cut it: ComfyUI's fp8_scaled builds are roughly 14GB per expert, and the community GGUF set (QuantStack's, paired with city96's ComfyUI-GGUF node) gives Q4_K_M at ~9.65GB/expert and Q8_0 at ~15.4GB/expert. Run the official script as-is on an A100 SXM4 80GB at $1.088/GPU-hour, or take the quantised route on an RTX 5090 32GB at $0.723 — both are one click away on NexGPU, metered per second.

Can I run Wan on just 24GB of VRAM?

Yes, if you pick the right variant. TI2V-5B was designed for exactly this — the README names the RTX 4090 24GB, with the --offload_model True --convert_model_dtype --t5_cpu trio. Wan2.1-T2V-1.3B needs only 8.19GB and runs on almost anything. A14B on 24GB means GGUF quants plus constant expert swapping, and the speed will hurt. We list four 24GB cards at four price points: RTX 3090 at $0.193, Tesla P40 at $0.214, A10 at $0.414 and RTX 4090 at $0.540 — pick according to your patience.

Why does my ComfyUI workflow blow up as soon as it loads the VAE?

Almost always the wrong VAE. Only TI2V-5B uses the new wan2.2_vae.safetensors (4×16×16 compression, 4×32×32 effective after patchification); T2V-A14B and I2V-A14B still use wan_2.1_vae.safetensors, and they are not interchangeable. The other frequent trap is that A14B's high-noise and low-noise weights are two separate files — download only one and sampling dies partway through. ComfyUI is a prebuilt image in our 2,000+ library, so you can boot straight into it and just point the official workflow at the right files instead of debugging an environment.

With S2V-14B, how long does a 3-minute voiceover take to render?

S2V's output length tracks the audio, so runtime grows with it, and Alibaba publishes no benchmark at the 3-minute mark — do not extrapolate linearly from short-clip timings when budgeting. The right move is --num_clip for a short preview to confirm lip sync and framing, then open it up to full length, using --pose_video to lock the pose and cut re-runs. Its single-card floor is also 80GB, and it natively supports FSDP + DeepSpeed Ulysses sharding. NexGPU gives you up to 14 GPUs per node and 2,152GB max node VRAM, so long audio just scales sideways.

Once the render finishes and I stop the instance, am I still being charged?

Compute billing stops the moment the instance stops — metered per second, priced per hour, no minimum, no setup fee, no quota request to file. The only thing that keeps accruing is storage, at the $0.414/GB-month median, until the volume is destroyed. Since Wan weights run to tens of gigabytes, destroy the volume after a short project and keep it only when re-downloading would cost you more time than it saves. NexGPU spans 51 countries and regions, 1,175 verified rentable nodes, 2,498 GPUs and 75 GPU models, reachable over SSH, Jupyter, web terminal, REST API and CLI, with bilingual support on Telegram and no ticket queue.

Start building on NexGPU

Enterprise R&D team or solo developer — either way, your first job can be running in minutes.