WAN 2.2 in ComfyUI: The Open Video King

Run WAN 2.2 — the open-source MoE video model — locally in ComfyUI. High/low-noise experts, I2V & T2V, GGUF VRAM tiers, Lightning, one-command install.

by artokun · June 16, 2026 · wan · video · ComfyUI · model highlight

Most open video models make you choose: cinematic motion or a GPU you can actually afford. WAN 2.2 refuses the trade. It’s the Apache-2.0 model that brought a Mixture-of-Experts design to video diffusion — two 14B experts that hand off mid-denoise — and it runs locally in ComfyUI, no API key, no per-second cloud fee. This is the next entry in our model-highlight series after Ideogram 4, and it earns its own spotlight: by most open-weight measures, WAN 2.2 is the cinematic-motion king you can self-host today.

Below: how the high-noise and low-noise experts actually work (the part everyone gets wrong), I2V vs T2V vs longer-video stitching, how it stacks up against LTX-2.3, the VRAM tiers from the pack’s 24 GB default down to under 12 GB, and the fastest way to run it — a one-command install with comfyui-mcp and the sidebar Panel, instead of hand-downloading dozens of GB of GGUFs and wiring two samplers by hand.

TL;DR — one-command setup. Install comfyui-mcp, apply the wan-longer-videos pack (apply_manifest --path packs/wan-longer-videos/manifest.yaml, or run the generated installer), and drive the graph from your own Claude session via the Panel. Jump to Install.

What is WAN 2.2?

WAN 2.2 is the open-source video generation family from the Wan-AI (Alibaba) team, released under Apache 2.0 — genuinely open source, commercial use included, no gated download and no baked-in license trap. The flagship is the A14B series: a dual-expert Mixture-of-Experts with a high-noise expert and a low-noise expert at roughly 14B parameters each (≈27B total, but only ~14B active per step, so inference cost and VRAM stay close to a single 14B model). There’s also a smaller dense TI2V-5B for lighter rigs. (Wan-AI on HuggingFace, Wan2.2 GitHub)

Why it’s the open video king right now:

• Cinematic motion, not “AI float.” WAN 2.2 was trained with curated aesthetic labels (lighting, composition, contrast, color tone) and, per the team, on +65.6% more images and +83.2% more videos than WAN 2.1 — which shows up as weighty, controllable camera work and steadier subjects. (Wan2.2 README)
• Truly open license. Apache 2.0 means you can ship commercial work, fine-tune, and redistribute. Contrast that with open-weight models that carry non-commercial terms.
• A massive ecosystem. Lightning distill LoRAs, FusionX, remix checkpoints, and thousands of community LoRAs already target the 2.2 hi/lo split — more than any other open video model.

A fair scope note: “best open video model” is a motion-and-realism claim widely echoed by reviewers, not a single audited benchmark. Speed-first rivals beat it on raw throughput (see the comparison below). We scope the win to cinematic I2V/T2V quality on consumer hardware.

WAN 2.2 vs LTX-2.3 and the alternatives

There’s no single “best” — pick by the job:

Pick…	When you need…
WAN 2.2	Cinematic motion realism, image-to-video from a reference still, flexible VRAM (FP8/GGUF down to consumer cards), the largest LoRA/remix ecosystem
LTX-2.3	Raw speed and volume — reviewers cite it as dramatically faster per clip, stable at 720p, with one-pass audio for quick drafts
WAN 2.2 TI2V-5B	A lighter dense model for lower-VRAM rigs and faster iteration when you don’t need the full A14B quality

The recurring take from 2026 round-ups: LTX-2.3 wins throughput and built-in audio; WAN 2.2 wins cinematic motion and image-to-video fidelity, and its MoE + FP8/GGUF path fits 16 GB cards where a dense model can’t. (WaveSpeed: LTX-2.3 vs WAN 2.2, Thunder Compute: WAN 2.2 in ComfyUI) Treat the “18x faster” style figures as vendor/blog benchmarks, not independently audited — they vary wildly with resolution, steps, and hardware. Each rival gets its own post: LTX-2.3 and WAN Animate are elsewhere in the series.

Licensing

WAN 2.2 is Apache 2.0 — commercial use included, no revenue threshold, no seat count, no separate agreement to sign. The Wan-AI/Wan2.2-T2V-A14B model card states it directly: the models in the repository are licensed under Apache 2.0. The license does carry ordinary use restrictions (no illegal content, no misuse of personal information, no targeting vulnerable groups), which is a conduct clause, not a commercial gate.

That makes it one of the genuinely permissive open video models — worth contrasting with LTX-2.3, which is open-weight but gates commercial use on a $10M revenue threshold.

The LoRAs and upscaler the pack pulls are separate projects under their own terms; check those before shipping if you redistribute them.

System & VRAM requirements

WAN 2.2 A14B is VRAM-hungry — two 14B experts plus a UMT5-XXL encoder, a VAE decode, and (in the longer-video chain) RIFE interpolation running back to back. The fix is GGUF quantization. The pack ships one tier and the other two are a manual swap:

GGUF tier	VRAM target	Notes
Q4_K_S	under 12 GB	Smallest quant, some quality trade; a manual swap
Q5_K_S	12–24 GB	Balanced middle tier; a manual swap
Q8_0	24 GB+	What this pack ships — the manifest, both installer scripts, and workflow.json all point at -Q8_0.gguf

Plan for 24 GB. wan-longer-videos pins Q8_0: manifest.yaml downloads the four -Q8_0.gguf experts, and workflow.json loads them by that exact filename. On a 12 GB card this pack will OOM as shipped — that is not a tuning problem, it is the wrong tier for the GPU.

To run it smaller, swap the four unet/Wan2.2-*-Q8_0.gguf files for the -Q5_K_S or -Q4_K_S builds from the same Aitrepreneur/FLX repo and re-point the UnetLoaderGGUF nodes at the new filenames. Nothing else in the graph changes.

The -96gb variants are not the higher-quality GGUF step — they load wan2.2_*_14B_fp16.safetensors, full fp16 weights, which is why they are named for a 96 GB card. Going from Q8_0 to -96gb moves up in VRAM, not down.

To reduce OOM risk at the shipped tier, the pack launches ComfyUI with --reserve-vram 2 so the GGUF UNet, VAE decode, and RIFE pass don’t collide.

Install WAN 2.2 in ComfyUI

The manual route works: update ComfyUI, clone the needed custom nodes (ComfyUI-GGUF, VideoHelperSuite, Frame-Interpolation, KJNodes, rgthree, Easy-Use), and download every GGUF, the UMT5-XXL encoder, the WAN 2.1 VAE, the Lightning + FusionX LoRAs, and the ClearReality upscaler into the right folders. That’s a lot of files in a lot of exact places.

File	Folder
Wan2.2-I2V-A14B-HighNoise-Q8_0.gguf / -LowNoise-Q8_0.gguf	models/unet/
Wan2.2-T2V-A14B-HighNoise-Q8_0.gguf / -LowNoise-Q8_0.gguf	models/unet/
umt5-xxl-encoder-Q5_K_S.gguf (text encoder)	models/text_encoders/
wan_2.1_vae.safetensors	models/vae/
wan2.2_{t2v,i2v}_lightx2v_4steps_lora_*_{high,low}_noise + Wan2.1_T2V_14B_FusionX_LoRA	models/loras/
4x-ClearRealityV1.pth	models/upscale_models/

The fast way — comfyui-mcp + the Panel

Pulling all of that to the right folders and wiring two samplers by hand is exactly the busywork the comfyui-mcp wan-longer-videos pack removes. One declarative manifest installs the custom nodes and pulls every model to the correct folder — and the same manifest drives both an MCP-native install and the generated installer script:

# MCP-native (from a Claude Code session, with COMFYUI_PATH set)
apply_manifest --path packs/wan-longer-videos/manifest.yaml

# or run the generated installer from your ComfyUI root
# (the folder containing custom_nodes/ and models/) — it is non-interactive
# and fetches the Q8_0 tier the workflow expects
packs\wan-longer-videos\install-windows.bat   # Linux/RunPod: install-runpod.sh

Then restart ComfyUI and load packs/wan-longer-videos/workflow.json (the first RIFE run auto-downloads rife49.pth). Because the pack ships with the plugin, your own Claude session can drive the live graph through the Panel — add/wire nodes, set the hi/lo split, swap LoRAs, and iterate on prompts conversationally, with full Ctrl+Z undo and no extra API keys. Every model URL in the pack is CI-validated for reachability and size, so a link never quietly rots (here’s why that matters).

How the high-noise and low-noise experts work

This is the part worth slowing down for, because it’s the thing that makes WAN 2.2 different from a normal single-model diffusion video pipeline — and the thing that breaks if you wire it wrong.

Diffusion denoises a video from pure noise to a clean result over N steps. WAN 2.2 splits that journey between two specialist experts, switching once partway through based on the noise level (signal-to-noise ratio):

• High-noise expert — early steps. Runs first, while the latent is still mostly noise. It establishes overall layout, composition, motion, and camera structure — the “what moves where” of the shot.
• Low-noise expert — late steps. Takes over for the back half, when the rough structure exists. It refines texture, detail, and fidelity — the “make it sharp and real” pass.

Because only one expert is active at a time, you get the capacity of a ~27B model at roughly the compute and VRAM of a 14B one. (Wan2.2-I2V-A14B model card)

The hi/lo split at sampling

In ComfyUI native graphs you implement the handoff with two KSamplerAdvanced nodes in a two-pass chain, one per expert. The high pass denoises the first portion of the steps and returns the leftover noise; the low pass picks up exactly where it left off and finishes:

UNETLoader (HighNoise) → ModelSamplingSD3 (shift) → [Lightning LoRA Hi] → MODEL_HI
UNETLoader (LowNoise)  → ModelSamplingSD3 (shift) → [Lightning LoRA Lo] → MODEL_LO

KSamplerAdvanced (Hi: MODEL_HI, steps 0→2, add_noise=enable,  return_leftover=enable)
  → noisy LATENT
KSamplerAdvanced (Lo: MODEL_LO, steps 2→4, add_noise=disable, return_leftover=disable)
  → final LATENT  → VAEDecode → VHS_VideoCombine → MP4

The non-negotiable rules:

• You must use both experts. WAN 2.2 was trained as a split-noise model; running a single model for all steps produces broken, low-quality output. (This is the #1 mistake people port over from WAN 2.1.)
• The split point is where the experts swap. With 4 Lightning steps the swap is at step 2 (the Hi pass runs steps 0→2, the Lo pass 2→4). With 20 standard steps, swap at step 10.
• ModelSamplingSD3 on both models. WAN 2.2 uses flow matching; apply the shift to each UNET — shift 5 for Lightning/distilled, shift 8 for the standard 20-step path.
• Both passes share the same conditioning. Positive/negative (and, for I2V, the WanFirstLastFrameToVideo outputs) feed both samplers.

LoRAs and Lightning apply to BOTH experts

This trips up newcomers constantly: a WAN 2.2 LoRA isn’t one file, it’s a paired hi/lo set, and you load the high-noise variant on the Hi path and the low-noise variant on the Lo path. That’s true for:

• Lightning 4-step distill LoRAs — the speed trick that drops a clip from ~5–10 minutes (20 steps) to roughly ~70 seconds (4 steps). Hi LoRA → Hi model, Lo LoRA → Lo model.
• FusionX, style, and concept LoRAs — same rule, match the variant to the pass.

The wan-longer-videos pack ships the matched pairs already — the official lightx2v 4-step LoRAs from Comfy-Org/Wan_2.2_ComfyUI_Repackaged: wan2.2_i2v_lightx2v_4steps_lora_v1_high_noise / _low_noise for I2V and the wan2.2_t2v_lightx2v_4steps_lora_v1.1_high_noise / _low_noise pair for T2V, plus the Wan2.1_T2V_14B_FusionX_LoRA. Mismatch the halves and you’ll get muddy structure or mushy detail — the symptom maps directly to which expert got the wrong LoRA.

I2V, T2V, and longer-video extend

WAN 2.2 A14B ships as two separate expert pairs — one for image-to-video, one for text-to-video — and the wan-longer-videos pack installs all four GGUFs so you can do either without re-downloading.

• I2V / first-last-frame (FLF). Feed a start image (and optionally an end image) and WAN animates between them. This path adds CLIPVisionEncode and WanFirstLastFrameToVideo, and is the strongest open option for “take this still and make it move.” Default resolution 480×720 portrait or 832×480 landscape, 81 frames at 16 fps ≈ 5 seconds. See the wan-flf-video skill.
• T2V. Pure text → video. No image nodes — it uses EmptyHunyuanLatentVideo for the initial latent and text-only conditioning. Describe motion and temporal progression (“camera slowly pans”, “petals drift in the breeze”), not just a static scene. See the wan-t2v-video skill.
• Longer videos. A single WAN clip is ~5 seconds (81 frames; frame count must be 4n + 1). The pack’s namesake video-extend chain stitches successive clips into longer sequences, then runs ClearReality upscaling and RIFE frame interpolation to smooth the result back up to higher frame rates. That’s the whole point of wan-longer-videos: get past the 5-second wall without ghosting at the seams.

What to make with it

• Image-to-video — bring a single illustration, photo, or render to life with a controllable camera move.
• First-last-frame transitions & morphs — animate cleanly between two stills (add a morph LoRA on both passes for true metamorphosis).
• Text-to-video b-roll — cinematic establishing shots, product motion, atmospheric loops.
• Longer sequences — stitch multiple clips past the 5-second wall, then RIFE + upscale for a smooth finish.
• Stylized scenes — the aesthetic-labeled training makes lighting/color direction in the prompt actually land.

Settings that matter

The pack’s workflow is tuned already, but for reference:

• GGUF loaders. UnetLoaderGGUF reads the hi/lo experts from models/unet/; CLIPLoaderGGUF (type wan) loads the UMT5-XXL encoder. Swap quant tiers here.
• Lightning 4-step. With the paired hi/lo Lightning LoRAs: 4 steps, cfg 1.0, sampler euler (T2V) or uni_pc + beta scheduler (I2V/FLF), shift 5, split at step 2. This is the everyday speed config.
• Standard 20-step. Drop the Lightning LoRAs, shift 8, cfg 3.5–4, euler + simple, split at step 10 — for maximum quality when you have time.
• FusionX LoRA layers in extra motion/detail; stack it on both passes like any other hi/lo LoRA.
• RIFE + ClearReality. RIFE (VFI) interpolates frames to smooth motion; 4x-ClearRealityV1 upscales. Both run after decode in the longer-video chain.
• Frame math. Width/height divisible by 16; frame count 4n + 1 (81 ≈ 5s at 16 fps). Always include the quality negative prompt the skills ship.

Troubleshooting

• “Torch not compiled with CUDA enabled.” A CPU-only torch got installed. Reinstall the CUDA build into ComfyUI’s python — for the portable build:

  python_embeded\python.exe -m pip install --force-reinstall torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124
  

• Broken / mushy output. You’re almost certainly running one expert instead of two, or you mismatched the hi/lo LoRAs. Confirm the two-pass KSamplerAdvanced split and that Hi LoRA → Hi model, Lo LoRA → Lo model.

• OOM during generation or RIFE. Drop to a Q5_K_S or Q4_K_S GGUF tier, lower resolution/frame count, and keep --reserve-vram 2.

• rife49.pth missing. It’s not in the installer — ComfyUI-Frame-Interpolation fetches it automatically on first RIFE run into custom_nodes/ComfyUI-Frame-Interpolation/ckpts/rife/.

• Static / “motionless image” result. Strengthen motion language in the prompt and verify the negative prompt includes the motionless/static quality terms.

FAQ

Is WAN 2.2 open source or open weight? Genuinely open source — Apache 2.0, commercial use allowed, no gated download. (model card)

What is the high-noise / low-noise split? WAN 2.2 A14B is a Mixture-of-Experts: a high-noise expert handles early denoising (layout, motion, composition) and a low-noise expert handles late denoising (texture, detail). You run them as a two-pass sampler chain and must use both.

Do I really need both models? Yes. It was trained split-noise; a single model for all steps gives broken output. This is the most common WAN 2.1 → 2.2 mistake.

How much VRAM do I need? 24 GB+ to run the pack as shipped — it pins the Q8_0 GGUFs. Swapping the four UNet files down to Q5_K_S gets you into 12–24 GB, and Q4_K_S under 12 GB. (The -96gb variants are fp16 safetensors, not a GGUF tier — they need more VRAM, not less.)

Can I run it locally / offline? Yes — fully local in ComfyUI, no API key and no network call at generation time (after the one-time model download).

How long can clips be? A single A14B clip is ~5 seconds (81 frames at 16 fps). The wan-longer-videos extend chain stitches clips into longer sequences and smooths them with RIFE.

Do Lightning and other LoRAs apply to both experts? Yes — WAN 2.2 LoRAs come as paired hi/lo files; load the high variant on the Hi path and the low variant on the Lo path.

WAN 2.2 or LTX-2.3? WAN 2.2 for cinematic motion and image-to-video; LTX-2.3 for speed, volume, and built-in audio. (Speed figures quoted online are vendor/blog benchmarks, not independently audited.)

---

Get it running in one command

1. Install comfyui-mcp and the Panel — then start the agent with npx -y comfyui-mcp@latest connect and click Connect in the panel (no API keys; sign in with claude once).
2. Apply the wan-longer-videos pack — nodes + the four hi/lo GGUFs, encoder, VAE, LoRAs, and upscaler land in the right folders, validated. Ships the Q8_0 tier — plan for 24 GB, or swap the four UNet files down.
3. Open the Panel and let the panel’s agent set the hi/lo split, swap LoRAs, and stitch longer clips for you.

That’s the whole point of the project: expert ComfyUI setups that install in one step and drive themselves from your own agent session. Next in the series: Qwen-Image & Qwen-Image-Edit — the local edit-anything model, and the T2I base that powers WAN’s refine combo.