2026-10-16

Wan 2.2 in ComfyUI: Local AI Video on an 8GB GPU (Tested)

Creator at a desk watching a Wan 2.2 video clip render on a monitor beside a small PC with a glowing graphics card

Yes, Wan 2.2 runs in ComfyUI on an 8GB graphics card. I generated a 5-second 720p clip on an RTX 3070 Ti in 11 minutes. A shorter 832×480 clip took just over a minute.

Wan 2.2 is Alibaba's open-weight video model. It was released on July 28, 2025 under the Apache 2.0 licence, so you can use its output commercially, according to the Wan 2.2 GitHub repository. It comes in three variants: text-to-video, image-to-video, and a smaller hybrid model that does both.

One thing to clear up before anything else. Wan 2.5, 2.6 and later are not local models. They are API-only, and in ComfyUI they run through API nodes on Alibaba's cloud, as howaiworks.ai and localaimaster.com both confirm. If you want to generate video on your own GPU, Wan 2.2 is still the newest Wan you can download.

This guide covers which files to grab, where they go, which template to open, and what actually happened on my 8GB card.

Most Valuable Takeaways

  • The Wan 2.2 5B model fits on 8GB of VRAM with no launch flags. ComfyUI's built-in dynamic offloading handles it.
  • A 2-second 832×480 clip (49 frames, 20 steps) sampled in about 60 seconds on an RTX 3070 Ti.
  • A 5-second 720p clip (1280×704, 121 frames) took 11 minutes wall-clock on the same card. Wan's own README quotes "under 9 minutes" for a 4090.
  • The 10 GB fp16 model ran at the same per-step speed as the 3.4 GB Q4_K_M GGUF quant. ComfyUI streamed the fp16 weights instead of loading them all at once.
  • A different quant gives a different video, even with the same seed. Q8_0 and fp16 matched closely. Q4_K_M produced a different composition.
  • The 14B models need the Wan 2.1 VAE, not the Wan 2.2 VAE. Mixing those up is the most common setup error.
  • Wan 2.5 and newer are cloud-only. Wan 2.2 is the latest local option.

Which Wan 2.2 Model to Download

There are three open-weight Wan 2.2 models, per the GitHub repository:

  • TI2V-5B: a hybrid text-and-image-to-video model. It outputs 720p at 24fps and is the one to use on 8–12 GB cards.
  • T2V-A14B: text-to-video, 14B active parameters.
  • I2V-A14B: image-to-video, 14B active parameters.

The A14B models use a Mixture-of-Experts design. A "high-noise" expert handles the early sampling steps, where the layout forms. A "low-noise" expert handles the late steps, where detail appears. That is 27B parameters in total, with 14B active per step. It is also why the 14B ComfyUI workflows load two diffusion model files instead of one.

ComfyUI template browser filtered to Wan 2.2, showing the 5B, 14B T2V, 14B I2V and first-last-frame templates

The 5B model is dense (no experts) and uses a 4×16×16 compression VAE. The GitHub README says it can produce a 5-second 720p clip "in under 9 minutes on a single consumer-grade GPU" such as a 4090. Compared with Wan 2.1, the training set grew by 65.6% more images and 83.2% more videos, plus curated labels for lighting, composition and colour tone, according to the same README.

Here are the 5B files, their folders, and their sizes. The sizes come from the Comfy-Org repackaged Hugging Face repo, verified by HTTP HEAD on 2026-10-15.

FileFolderSize
wan2.2_ti2v_5B_fp16.safetensorsmodels/diffusion_models/10.0 GB
wan2.2_vae.safetensorsmodels/vae/1.4 GB
umt5_xxl_fp8_e4m3fn_scaled.safetensorsmodels/text_encoders/6.7 GB

The text encoder is shared by every Wan 2.2 workflow, so you only download it once.

For the 14B models, you need a high-noise file and a low-noise file for T2V or I2V, plus wan_2.1_vae.safetensors in models/vae/, plus the same umt5 text encoder. The ComfyUI Wan 2.2 tutorial links to every file directly.

My rule of thumb for which model to pick:

  • 8–12 GB VRAM: 5B. Use fp16, or a GGUF quant if you want faster loading.
  • 16 GB and up: 14B in fp8.
  • 24 GB: 14B in fp16.

I did not test the 14B models on this rig, so I will not quote times for them.

Install and Load the Wan 2.2 Template

First, update ComfyUI. The built-in Wan 2.2 templates only appear in recent versions, and the ComfyUI docs recommend running the latest release. If you are starting from scratch, the ComfyUI installation guide walks through a fresh install. If you already have it, how to update ComfyUI covers the update.

Next, drop the three 5B files into the folders from the table above. Restart ComfyUI so it rescans the model folders.

Then open the template browser (the Templates button in the left sidebar) and search for "Wan". You should see four Wan 2.2 entries: "Wan2.2 5B", "Wan2.2 14B T2V", "Wan2.2 14B I2V" and "Wan2.2 14B FLF2V". The last one is first-frame-last-frame, where you supply both the start and end image. Open "Wan2.2 5B".

The Wan 2.2 5B template loaded in ComfyUI: three loader nodes, prompt nodes, size node, KSampler and video output

The workflow is simple. Here is what each part does:

  • Load Diffusion Model picks the 5B safetensors file.
  • Load CLIP picks the umt5 text encoder. Despite the node name, it is a text encoder, not an image model.
  • Load VAE picks wan2.2_vae.safetensors.
  • Positive and negative prompt nodes feed the text encoder.
  • Wan22ImageToVideoLatent sets width, height and frame count. This is the node you will change most.
  • ModelSamplingSD3 sets the shift value. The template uses 8.
  • KSampler runs the steps. The template uses 20 steps, uni_pc sampler, simple scheduler and CFG 5.
  • Video output saves the frames as a video file at 24fps.

Close-up of the Load Diffusion Model, Load CLIP and Load VAE nodes with the Wan 2.2 5B files selected, and the video size node set to 832 by 480, 49 frames

If a loader shows a red outline, the file is missing or in the wrong folder. Check the folder names exactly. text_encoders and diffusion_models are both underscored.

First Generation: Settings That Fit 8GB

My test rig: an RTX 3070 Ti with 8,192 MiB of VRAM, 30 GB of system RAM, Arch Linux, ComfyUI v0.41.0 from git master, Python 3.13, and PyTorch 2.14.1 with CUDA 13.0. The desktop idles at about 740 MiB, so roughly 7.4 GB is free for ComfyUI. I used no launch flags. No --lowvram, nothing.

I left the template unchanged except for size, length and seed. The prompt was the template's own (a 1970s subway street musician), seed 42, 20 steps, uni_pc, simple scheduler, CFG 5, shift 8.

Run A: 832×480, 49 frames. That is 2 seconds of video at 24fps.

ModelFile sizeSampling (20 steps)Per stepWall-clockPeak VRAM
fp16 official10.0 GB60 s3.0 s73 s7,686 MiB

The fp16 file is 10 GB. The card has 8 GB. It ran anyway. ComfyUI logged "Model WAN22 prepared for dynamic VRAM loading, 9535MB staged" and streamed the weights as needed. Peak VRAM sat just under the limit.

nvidia-smi during a Wan 2.2 generation on an RTX 3070 Ti showing about 7 GB of 8 GB in use at 87 percent utilisation

Run B: 1280×704, 121 frames. That is the template default. It is real 720p and 5 seconds at 24fps.

ModelSamplingPer stepWall-clockPeak VRAM
fp16 official9 min 8 s27.4 s10 min 52 snot captured

It fit. The VAE decode ran out of memory once, and ComfyUI retried on its own. The log line was "Ran out of memory when regular VAE decoding, retrying with tiled VAE decoding". I did nothing. The clip saved normally.

Last frame of the 720p, 5-second Wan 2.2 clip generated on the 8GB card

For scale, the Wan README quotes "a 5-second 720P video in under 9 minutes" on a 4090. An 8GB 3070 Ti did it in about 11 minutes. That is a usable result for a card from 2021.

Two more notes from the server log. The umt5 text encoder stages 6,419 MB on its own. A cold first generation adds roughly 15–20 seconds over a warm one, because the encoder has to load. Keep the prompt the same between runs and ComfyUI reuses the cached conditioning.

A practical starting point for 8GB: 832×480 at 49 frames. Iterate on the prompt there, then switch to 1280×704 at 121 frames for the final render.

Image-to-Video With the Same 5B Model

The 5B model is a hybrid. It takes an optional start image. In the template, the Wan22ImageToVideoLatent node has an image input. Leave it empty for text-to-video. Connect a Load Image node to it and the model animates that image instead.

The VRAM behaviour is the same as text-to-video. The start image sets the first frame. Resolution still matters more than anything else, so match the image size to the output size you can afford.

For a broader look at image-to-video in ComfyUI, including other models and motion control, see the ComfyUI image-to-video guide. This post is the dedicated Wan 2.2 guide, so I will not repeat that material here.

Going Faster: GGUF Quants and the Lightx2v LoRA

GGUF quants shrink the model file. The QuantStack Wan2.2-TI2V-5B-GGUF repo offers files from Q2_K (1.85 GB) up to Q8_0 (5.4 GB). Q4_K_M is 3.43 GB. You need the ComfyUI-GGUF custom node, and you swap the Load Diffusion Model node for Unet Loader (GGUF). I used ComfyUI-GGUF at commit 6ea2651.

The same Wan 2.2 workflow with the Unet Loader (GGUF) node swapped in and the Q4_K_M file selected

Here are the full Run A numbers with the quants included:

ModelFileSampling (20 steps)Per stepWall-clockPeak VRAM
Q4_K_M GGUF3.4 GB67 s3.3 s92 s*7,330 MiB
Q8_0 GGUF5.4 GB59 s3.0 s76 s7,124 MiB
fp16 official10.0 GB60 s3.0 s73 s7,686 MiB

*Q4 ran first, so its wall-clock includes the one-time text encoder load. Compare the sampling column, not wall-clock.

The surprise is how little the quants help at this size. Q8_0 was marginally the fastest at 59 seconds. It does less dequantisation work than Q4 and needs less streaming than fp16. But the spread across all three is a few seconds.

At 720p the story was the same. Q4_K_M sampled 121 frames in 9 min 14 s (27.7 s per step) with a peak of 7,798 MiB. The fp16 run was 9 min 8 s (27.4 s per step). Per-step speed is essentially identical. Both hit the same tiled-VAE fallback.

The log shows why. Q4 "loaded completely" at 3,357 MB and Q8 at 5,233 MB. The fp16 model staged 9,535 MB for dynamic loading. ComfyUI is good enough at streaming that the quants mostly save disk space and load time, not generation time.

Side by side frame 24 from the Q4_K_M, Q8_0 and fp16 runs with identical prompt and seed

Quality is the honest caveat. All three 832×480 clips were coherent and usable. Q8_0 and fp16 produced near-identical framing and motion. Q4_K_M gave a visibly different composition, with a different camera placement and a different second figure. There were no obvious artifacts. But a different quant is a different model. The same seed does not mean the same video.

My recommendation on 8GB: use fp16 if you have the disk space, or Q8_0 if you want a smaller download with matching output. Save Q4_K_M for cards with less than 8GB. For the mechanics of GGUF in ComfyUI, including the node install and other models, see the ComfyUI GGUF guide.

If you are on a 14B card, there is a Lightx2v 4-step LoRA for the 14B T2V model, as noted in the ComfyUI docs. It cuts steps from 20 to 4 at some quality cost. Loading it is a standard LoRA step, covered in the ComfyUI LoRA guide. I did not test it on this rig.

Errors You Will Actually Hit

Out of memory during sampling. Reduce the frame count first, then the resolution. Going from 121 frames to 49 at the same size is the biggest single saving. Only reach for a quant after that, since the quants barely changed peak VRAM in my runs.

Out of memory during VAE decode. ComfyUI retries with tiled decoding on its own. Wait for it. If it still fails, lower the resolution.

Wrong VAE on the 14B models. The 14B T2V and I2V workflows use wan_2.1_vae.safetensors, not wan2.2_vae.safetensors. The 2.2 VAE only belongs to the 5B model, as the ComfyUI docs make clear. If your 14B output is garbage or errors on decode, check the VAE first.

Text encoder not found. Put the umt5 file in models/text_encoders/ (ComfyUI also scans models/clip/), then restart or press Refresh so the dropdown rescans. A half-downloaded file shows up in the list but fails to load, so check the size matches 6.7 GB.

Template not showing. Your ComfyUI is too old. Update it and reload. If the template browser itself is missing or the Manager will not open, see the ComfyUI Manager guide for the enable-manager fix.

Two diffusion files in a 5B workflow. You opened a 14B template by mistake. The 5B template has one Load Diffusion Model node. Check the title bar.

When to Rent a GPU Instead

The 5B model is a good fit for 8GB. The 14B models are not. Each one swaps between two 14B expert files partway through the run, and at 720p you will spend more time streaming weights than sampling. I would not try it.

If you want 14B quality for client work, rent a 24 GB card by the hour. RunPod vs AWS for ComfyUI compares the two main options on price and setup. The ComfyUI cloud and remote access guide covers how to reach a remote ComfyUI from your own browser.

For a 5B workflow you have already dialled in locally, renting is also a quick way to batch final renders. Upload the workflow JSON, point it at the same files, and queue a dozen clips while your own card stays free.

If you want an older but lighter animation route, the ComfyUI AnimateDiff guide still works on small cards. For a wider view of which models are worth the download, see best ComfyUI models.

Frequently Asked Questions

Does Wan 2.2 run on 8GB of VRAM?

Yes. The 5B model ran on my RTX 3070 Ti with no launch flags. A 2-second 832×480 clip sampled in about 60 seconds. A 5-second 720p clip took 11 minutes. The ComfyUI docs say the 5B model "should fit well on 8GB vram with the ComfyUI native offloading", and that matched what I saw. The 14B models are not practical on 8GB.

Is Wan 2.2 free for commercial use?

Yes. Wan 2.2 is released under the Apache 2.0 licence, per the GitHub repository. You can use the generated video in paid work without a separate licence. Check the terms of any LoRA or custom node you add on top, since those have their own licences.

What is the difference between Wan 2.2 and Wan 2.5 or 2.6?

Wan 2.2 has open weights you can download and run on your own GPU. Wan 2.5, released in September 2025, and Wan 2.6, released in December 2025, are API-only, according to howaiworks.ai and localaimaster.com. In ComfyUI they run through API nodes that send your request to Alibaba's cloud. Wan 2.2 is the newest local option.

Which VAE does the Wan 2.2 14B model use?

The 14B T2V and I2V models use wan_2.1_vae.safetensors. Only the 5B model uses wan2.2_vae.safetensors. The ComfyUI docs list both. Using the wrong one is the most common Wan 2.2 setup mistake.

How long does a 5-second Wan 2.2 clip take?

On an 8GB RTX 3070 Ti with the 5B model at 1280×704 and 121 frames, it took 10 min 52 s wall-clock with the fp16 file and 11 min 0 s with the Q4_K_M quant. Wan's README quotes under 9 minutes for the same clip on a 4090. Faster cards and shorter clips scale roughly with the per-step time, which was about 27 seconds at 720p on my card.

Conclusion

Wan 2.2 is the best local video model you can run in ComfyUI right now, and the 5B variant genuinely works on an 8GB card. Download the three files, open the built-in template, start at 832×480 with 49 frames, and move up to 720p once the prompt is right. Skip the quants unless you need the disk space, and keep the 14B models for a 24 GB card.

If you want help turning a workflow like this into something that runs on its own, book a free automation audit at /audit/. And if you want the next test like this one in your inbox, the newsletter goes out whenever a post is published.

Enjoyed this one?

Get The Streamlined CEO — one email a week on what’s actually worth automating.

No spam. Unsubscribe anytime.

Free · The Automation Playbook

The 5 systems readers build first

Each with the exact tools, the exact workflow, and the exact steps. Plus The Streamlined CEO — one email a week on what’s actually worth automating.

No spam. Unsubscribe anytime.