Wan-Animate-2 Locally: What It Needs on 12GB, 16GB and 24GB

Short answer: full precision is 32.79GB and out of reach — but the distilled GGUF builds run from 6.50GB (Q2_K) to 18.14GB (Q8_0), so 12GB is the realistic floor, 16GB is comfortable, and 24GB lets you skip GGUF entirely and use the official 16.65GB int8 build. Sub-12GB is not a real path. And whichever quant you pick, you need three companion files plus clip_vision_h.safetensors — and a specific custom loader, or your driving video gets silently ignored.

Wan-Animate-2 is character animation by motion transfer: a reference image of your character, a driving video of a performance, and the model renders one doing the other. Wan-AI released the inference code and both Base and Distillation weights on 7 August 2026, Apache 2.0. When we checked in mid-August 2026 the Comfy-Org repack was showing roughly 182,000 downloads in a rolling 30-day window — a figure that moves daily, but one that tells you this is a workflow people are actually running, not a curiosity.

---

VRAM tiers and the exact quant to use

All sizes below are byte-exact file sizes read from the repository listings on 18 August 2026, converted to GB. They are not estimates and they are not the approximate figures printed in the model card's own table — more on that discrepancy in a moment.

Full GGUF ladder, byte-exact, all from the distilled ("TURBO") conversions:

That middle column is why you should plan against the left one. The model card's own size table is consistently optimistic against the actual file sizes — Q4_K_M is listed at ~9.8 GB and is really an 11.34GB file. If you budgeted a 12GB card off the card's table, you are about 1.5GB short of where you thought you were. Use the byte-exact figures.

One structural point that saves people a lot of confusion: these numbers are not concurrent. ComfyUI encodes your prompt with umt5, then frees it, then loads the diffusion model, then decodes with the VAE. Peak VRAM is roughly the largest single stage plus your latents, not the sum of the files. That is why a 12GB card can host an 8.58GB model and a 6.74GB encoder without exploding — but it is also why VAE decode at the very end is where you OOM.

For how this sits against the rest of the family, our Wan VRAM requirements by GPU page maps every Wan model to every card, and Wan video generation guide covers the text-to-video and image-to-video side that this model is not.

---

The four files everyone forgets

The GGUF replaces only the diffusion model. Three more files are required and one of them — clip_vision_h — is the one people miss.

If clip_vision_h is missing, your reference image never gets encoded properly and the whole point of the model evaporates. It is 1.26GB. Download it first.

---

The silent loader failure

If you load a Wan-Animate-2 GGUF with ComfyUI's stock GGUF loader, your driving video is ignored and nothing tells you.

This is documented explicitly on the GGUF model card, and it is the most valuable thing on this page. The mechanism, in the author's words: ComfyUI selects this architecture from a config blob in the safetensors __metadata__ that sets model_type: "animate2", and GGUF has no equivalent field — so any GGUF of this model loads as a plain Wan 2.1 image-to-video model.

What that looks like from your chair: the model loads. Sampling runs to completion. A video appears with your reference character in it. The motion is invented and has nothing to do with your driving video. No error, no warning. People burn an evening tweaking prompts and denoise strength chasing a bug that is entirely in the loader.

The fix, per the model card:

1. Install ComfyUI-GGUF (city96) and the Rebels W3A8 Loader custom node.
2. Use GGUF Unet Loader + model_type (Rebels) in place of the stock Unet Loader (GGUF).
3. Set model_type to animate2.
4. Leave the rest of the standard Wan-Animate-2 workflow alone.

Then check the console on load:

[Rebels GGUF] loaded <file> | model_type=animate2 | model class=WAN_Animate2

model class=WAN_Animate2 is your proof. Anything else and you are in the silent-failure case. Check this before your first real render, not after your tenth.

Or sidestep it completely: if you have 24GB, use wan_animate_2_int8_convrot.safetensors (16.65GB) from the Comfy-Org repack. It is safetensors, it carries the metadata, and the whole problem does not exist.

---

Setup, corrected

Heads up: the download commands printed on the GGUF model card do not work as written. They reference a repository id and filenames that do not match the actual repository, and the Comfy-Org commands use a split_files/ path prefix that is not present in that repo's file tree. We checked the listings directly. Here are commands built from the real paths:

# Diffusion model — pick one quant. Files live under Distilled/ and are named TURBO.
hf download realrebelai/Wan-Animate-2_GGUFs \
  "Distilled/Wan-Animate-2-14B-TURBO-Q4_K_M.gguf" \
  --local-dir ComfyUI/models/diffusion_models

# Companion files from the Comfy-Org repack
hf download Comfy-Org/Wan-Animate-2 text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors \
  --local-dir ComfyUI/models
hf download Comfy-Org/Wan-Animate-2 vae/Wan2_1_VAE_bf16.safetensors \
  --local-dir ComfyUI/models
hf download Comfy-Org/Wan-Animate-2 clip_vision/clip_vision_h.safetensors \
  --local-dir ComfyUI/models

# 24GB path — official int8 repack, no custom loader required
hf download Comfy-Org/Wan-Animate-2 diffusion_models/wan_animate_2_int8_convrot.safetensors \
  --local-dir ComfyUI/models

Node wiring, per the model card:

1. Unet Loader (GGUF) — or the Rebels variant with model_type=animate2 — pointed at your .gguf
2. Load CLIP — umt5_xxl_fp8_e4m3fn_scaled.safetensors, type wan
3. Load VAE — Wan2_1_VAE_bf16.safetensors
4. Load CLIP Vision — clip_vision_h.safetensors
5. Reference image and driving video into the Wan Animate nodes, then sample

The GGUF repository also ships Distilled/WORKFLOW (GGUF).json — a ready-made workflow, which is the fastest route to a first render. You need a recent ComfyUI with native Wan-Animate-2 support; if yours is older, our ComfyUI complete guide covers updating cleanly.

---

Distilled vs base — and why your settings matter more than your quant

Every GGUF in that repository is a conversion of the distilled weights, so use distilled settings. The files are literally named TURBO and live in a Distilled/ folder. (The model card's own base-vs-distillation section still has an unfilled {base | distillation} placeholder in it, which is the kind of thing worth checking rather than assuming.)

From Wan-AI's official inference examples, the two profiles are:

• Base: standard step count with classifier-free guidance. The diffusers example runs 40 inference steps at the small 640×800 frame size it ships with, exporting at 24fps.
• Distillation: 10 steps, guidance scale 1.0 (no CFG), Euler solver. The repository's own CLI example passes --sample_guide_scale 1.0 and --step 10.

Run distilled weights at base settings — 40 steps with CFG 7 — and the output degrades regardless of how good your quant is. The model card makes the same point: use the settings the base model documents for the distilled schedule, not your normal Wan settings.

And the single biggest quality lever is not a setting at all: the reference image must roughly match the driving video's opening pose. A front-facing portrait against a side-on driving video loses context and the model falls back to inventing motion. Frame the reference the way the performance starts.

---

Failure modes

Four things go wrong, in roughly this order of frequency:

1. Driving video ignored. The loader problem above. Check for model class=WAN_Animate2 in the console.
2. OOM at VAE decode. Everything runs, then it dies at the last step. Decode is the memory spike, not sampling. Reduce frame count or resolution before you reduce quant — and check that ComfyUI's tiled VAE decode is available in your build.
3. Face drift across the clip. Identity slowly wanders over a long sequence. Shorter clips hold identity better; a reference image framed like the opening pose helps materially.
4. Missing clip_vision_h. Reference conditioning falls apart. 1.26GB, easy to miss, easy to fix.

If you are hitting VRAM walls generally rather than on this model specifically, our low-VRAM local video generation guide covers the offload and tiling tactics that apply across the whole ComfyUI video stack.

---

What we could not verify

Stated plainly, because guessing here would cost you real time:

• Generation times. We have no measured seconds-per-frame or minutes-per-clip on any consumer card. The upstream repository says its default settings are tuned for 8× A800 GPUs at 720P, with 480P tested on 2× A800 — which tells you the authors' baseline, not yours. We are not extrapolating consumer timings from that.
• Quality comparisons between quants. The tiers in the table above ("very good", "excellent", "quality drops sharply") are the model card author's characterisations, not our side-by-side evaluation.
• A sample clip of our own. We have not published one yet. When we do, it goes here with the exact settings attached.
• Wan-Animate-2-Lite. The official model card's introduction describes an efficient variant that "reduces inference latency to real-time thresholds for streaming character animation". It does not appear in the release notes or the repository's to-do list as shipped, so treat it as announced-in-paper, not downloadable.
• Apple Silicon performance. File sizes fit comfortably in 32GB+ of unified memory, but video diffusion on Metal is a different performance story to CUDA and we have not measured it on this model.

---

Verdict

Wan-Animate-2 is genuinely runnable at home, and the reason is the distilled GGUF ladder, not the model itself. At bf16 it is a 32.79GB file the authors ran on multi-GPU A800 nodes. At Q4_K_M it is an 11.34GB file that fits a 16GB card.

Three decisions and you are done:

1. 24GB or more? Use the official int8_convrot build at 16.65GB. Skip GGUF, skip the loader problem.
2. 12-16GB? Q3_K_M or Q4_K_M, fp8 text encoder, and the Rebels loader with model_type=animate2. Verify the console line before your first serious render.
3. Under 12GB? This is not the model for your card yet. Lower-VRAM video options will treat you better, and if you are shopping, the best GPU for video generation is the page to read first.

Then spend your effort on the reference image, not the quant. Matching the opening pose does more for your output than two extra bits of precision.

---

FAQ