Running WAN Video on 8-12 GB: GGUF Quantization, Block Swapping, and SageAttention for 50-Series GPUs

WAN 2.2's official inference scripts require at least 80 GB VRAM at full precision. Three community techniques bring that down to single-digit gigabytes: GGUF weight quantisation, MoE block swapping, and SageAttention2++ kernel acceleration. This guide covers what each technique does, how to install it, and which parameter values to use.

TL;DR

• GGUF-quantised WAN 2.2 models (HighNoise + LowNoise) run via the ComfyUI-GGUF custom node; use Q5_K_M or larger for the umt5-xxl text encoder
• LightX2V LoRA distills the A14B model to 4 denoising steps (20× speed-up, no CFG trick needed) — download
• SageAttention 2.2.0 with Triton ≥ 3.0.0 gives INT8 QK² + FP8 PV attention; requires CUDA ≥ 12.8 on 50-series cards
• MoE block swap boundary: 0.900 for I2V, 0.875 for T2V (source)

Installation Requirements

Model downloads — place in the ComfyUI models directory as indicated:

GGUF Quantisation for Low VRAM

GGUF replaces full-precision model weights with compact quantised representations. If you are still deciding what your card can hold at all, start with VRAM requirements by model. The ComfyUI-GGUF custom node loads these at inference time using a "Unet Loader (GGUF)" node instead of the stock diffusion-model loader.

For the umt5-xxl text encoder, the quantiser recommends Q5_K_M or larger for acceptable quality. Smaller quants may still work in resource-constrained scenarios, but the encoder is more sensitive to precision loss than the DiT backbone. (source)

WAN's DiT architecture — like Flux and SD3.5 before it — tolerates quantisation better than convolutional UNet models. This is why GGUF works for WAN where it would degrade most image models more noticeably.

The two GGUF model sets (HighNoise and LowNoise) are direct conversions of the full Wan-AI/Wan2.2-I2V-A14B weights. Original licensing terms remain in effect. (source)

LightX2V LoRA: 4-Step Distillation

The default WAN 2.2 A14B pipeline uses 40 denoising steps (confirmed by the official config: sample_steps = 40). LightX2V distills this to 4 steps without CFG, claiming a 20× speed-up while keeping output quality close to the base model. (source)

The LoRA adapter is rank 64, compatible with both native ComfyUI workflows and Kijai's WanVideoWrapper. The LightX2V team notes a known limitation: videos with extremely large motion may contain artifacts, and vehicle direction can occasionally reverse. (source)

Supported LoRA variants

(source)

SageAttention2++ on 50-Series GPUs

SageAttention replaces the standard scaled_dot_product_attention with quantised kernels. Version 2.2.0 bundles SageAttention2++, which uses INT8 quantisation for QK^T and FP8 for PV, with two-level accumulation to preserve accuracy in FP8 matrix multiply-accumulate operations. (source)

The authors claim 2–5× speed-up over FlashAttention without losing end-to-end metrics across language, image, and video models. (source)

For WAN specifically, the repo ships a plug-in file — example/modify_model/modify_wan.py — containing a SageWanAttnProcessor class and a set_sage_attn_wan() helper that patches every attention block in the transformer. It handles both self-attention (with RoPE) and the I2V cross-attention path for image encoder context.

50-series cards require CUDA ≥ 12.8 and Triton ≥ 3.0.0. The ChronoKnight ComfyUI guide (source) walks through the full installation: clean Python 3.13.2, CUDA 12.8 toolkit, Visual Studio Build Tools 2022 with C++ desktop workload, then pip-installing triton-windows and sageattention inside ComfyUI's embedded Python. The author marked the guide outdated since the latest ComfyUI update, so check for newer instructions.

Quick SageAttention install (Linux / standard ComfyUI)

pip install sageattention==2.2.0 --no-build-isolation

On Windows portable ComfyUI, use the embedded Python and add --use-sage-attention to your launch .bat.

MoE Block Swapping

WAN 2.2 A14B uses a Mixture-of-Experts architecture with two transformer sets — covered in depth in our guide to the high-noise and low-noise experts: a high-noise expert for early denoising and a low-noise expert for later stages. (source)

The WanMOE KSampler automates the switch between experts at the diffusion timestep where the signal-to-noise ratio crosses 1:1. The key parameter is boundary:

• I2V: 0.900 (source config)
• T2V: 0.875 (source)

The relationship between boundary timestep and denoising step is non-linear — it depends on total step count, sampler, noise schedule, and sigma shift. (source)

Kijai's ComfyUI-WanVideoWrapper takes a different approach: it swaps individual transformer blocks between GPU and system RAM during inference, allowing the model to fit in VRAM well below its native footprint. Unmerged LoRA weights are now treated as block buffers and swap along with the blocks. (source)

I2V A14B config at a glance

boundary: 0.900
sample_steps: 40
vae_stride: [4, 8, 8]
patch_size: [1, 2, 2]
dim: 5120
ffn_dim: 13824
num_heads: 40
num_layers: 40
sample_shift: 5.0
sample_guide_scale: [3.5, 3.5]

(source)

What the Sources Report on VRAM and Speed

The dossier explicitly flagged VRAM budgets and generation times as gaps — no primary source gives verified numbers across different cards. What the community articles do report:

The 1440×960 @ 60 fps output comes from 2× upscaling and 4× framerate multiplication applied after base generation — not from native high-resolution inference. (source)

Both the arkinson workflow and the ChronoKnight 50-series guide have been flagged as outdated by their authors. (sources, 13010)

For the wider set of speed techniques beyond low-VRAM work, see making local video generation faster.

Common Errors

Frequently Asked Questions

What GGUF quant level should I use for the text encoder?

Q5_K_M or larger. The city96 repo notes this is a non-imatrix quant, so smaller quants degrade faster. For resource-constrained setups, smaller levels "may still provide decent results," but Q5_K_M is the stated minimum recommendation. (source)

Do I need SageAttention, or can I skip it?

SageAttention is optional but significant. It gives 2–5× attention kernel speed-up. One community workflow (arkinson's RTX 3060 guide) explicitly runs without Triton or SageAttention, relying on block swapping and LightX2V LoRA alone. (source) The ChronoKnight guide, by contrast, considers both essential for 50-series cards. (source)

What's the difference between the WanMOE KSampler and Kijai's block swap?

The WanMOE KSampler switches between the high-noise and low-noise expert models at the correct diffusion timestep. Kijai's WanVideoWrapper swaps individual transformer blocks to and from system RAM to reduce VRAM usage. They solve different problems and can be combined. (sources, kijai/ComfyUI-WanVideoWrapper)

What supported samplers work with these workflows?

The community workflows tend to use euler and uni_pc samplers. (source)

Does LightX2V LoRA work with GGUF-quantised models?

The TwoMoreLurker workflow ships a Lightning variant alongside the standard GGUF variant, implying compatibility. Both load through the same GGUF Unet loader. (source)

Sources

1. QuantStack/Wan2.2-I2V-A14B-GGUF — GGUF model cards, download links
2. city96/umt5-xxl-encoder-gguf — Text encoder quantisation guidance
3. thu-ml/SageAttention — SageAttention2++ installation and benchmarks
4. stduhpf/ComfyUI-WanMoeKSampler — MoE boundary parameter values
5. Wan-Video/Wan2.2 — Official model configs and architecture
6. city96/ComfyUI-GGUF — GGUF loader for ComfyUI
7. kijai/ComfyUI-WanVideoWrapper — Block swap implementation and LoRA memory notes
8. lightx2v/Wan2.2-Lightning — LightX2V LoRA details and known limitations
9. wan_i2v_A14B.py config — Official I2V A14B parameters
10. SageAttention modify_wan.py — Wan attention processor integration
11. TwoMoreLurker — Civitai 18162 — Low-VRAM I2V workflow
12. arkinson — Civitai 17955 — RTX 3060 12 GB workflow with timing data
13. aipinups69 — Civitai 12380 — Wan 2.1 12 GB GGUF workflows
14. ChronoKnight — Civitai 13010 — 50-series Triton + SageAttention install guide