Wan 2.2 Image-to-Video on 8GB VRAM: Best ComfyUI Settings (10 Min)

スポンサーリンク
Wan 2.2 Image-to-Video on 8GB VRAM: Best ComfyUI Settings (10 Min) Generative AI
スポンサーリンク

On an 8GB VRAM card (RTX 2080 SUPER), I looked for ComfyUI + Wan 2.2 settings that turn one image into a 5-second video with a good balance between “watchable quality” and “a wait I can live with”.

After testing a lot of combinations, my recommendation is the Wan 2.2 Q8_0 model, 14 steps, plus the --fast launch option. One 5-second video takes about 10 minutes 20 seconds, without broken hands or faces. The settings files are available for download, so you can copy them as is.

A video made with the recommended settings

Here is the result first. It was made from the single image below and a prompt along the lines of “in a cherry blossom park, a woman smiles and waves; the camera is fixed”.

Source image: a woman standing in a cherry blossom park
Source image (made with Stable Diffusion on the same PC)

The camera stays still while she smiles and waves. The row of cherry trees behind her is unchanged from the source image. The waving hand gets a little blurry and translucent, but the face, background stay intact.

Time per video About 10 min 20 s (619 s). The first video after starting ComfyUI took about 11 min (659 s)
Video size 1280 x 704, 121 frames (about 5 s)
PC RTX 2080 SUPER (8GB VRAM), Core i9-9900K, 32GB RAM, Windows 11

Times are the “Prompt executed in” value ComfyUI prints when a video is finished.

How to use the recommended settings

This assumes ComfyUI (portable) with Wan 2.2 installed as in my earlier post. If not, read that first:

Download the settings files (a launch .bat plus the workflow) here:

1. Add the Q8_0 model

Download Wan2.2-TI2V-5B-Q8_0.gguf (about 5.4GB) from QuantStack/Wan2.2-TI2V-5B-GGUF on Hugging Face and place it in this folder:

ComfyUI_windows_portable\ComfyUI\models\unet

Keep using the text encoder (umt5-xxl-encoder-Q5_K_M.gguf) and VAE (Wan2.2_VAE.safetensors) from the earlier post.

2. Create the launch .bat

Put run_nvidia_gpu_fast.bat from the ZIP in the same folder as run_nvidia_gpu.bat (ComfyUI_windows_portable). To make it yourself, write these two lines in Notepad and save as run_nvidia_gpu_fast.bat:

.\python_embeded\python.exe -s ComfyUI\main.py --windows-standalone-build --fast --disable-dynamic-vram
pause

From now on, start ComfyUI by double-clicking this .bat. Keep the original run_nvidia_gpu.bat so you can always go back.

3. Load the workflow

Drag and drop Wan22_5B_Q8_i2v_recommend.json onto the ComfyUI page. Then just put your image in “Load Image”, edit the prompt, run it.

If your model file names differ you’ll get red errors; reselect your files in each node. To modify the workflow from my earlier post yourself, use these values:

Node Field Value
Unet Loader (GGUF) unet_name Wan2.2-TI2V-5B-Q8_0.gguf
KSampler steps 14
cfg 5
sampler_name uni_pc
scheduler simple
ModelSamplingSD3 shift 8
VAE Decode (Tiled) tile_size 512
overlap 32
temporal_size 64
temporal_overlap 8
Wan22ImageToVideoLatent width / height / length 1280 / 704 / 121

The LoRA node for the Turbo model is removed. The prompt I used is still in the workflow as an example.

Why these settings

This section shows the comparisons behind the recommendation. Each time is the second of two runs with identical settings, using one input image and one seed.

14 steps still holds up

Steps (KSampler steps) is how many times the model refines the picture. The official workflow uses 20, but time scales almost linearly with steps, so I tested how low I could go.

Steps Time per video Quality
20 14 min 6 s No artifacts
14 (recommended) 10 min 19 s No artifacts. Can’t tell it from 20
10 7 min 47 s Pink streaks from the hand to the face

Here are all four side by side. Top left: the full-size baseline model (fp16, 20 steps, no --fast, about 16 min). Top right: Q8_0 at 20 steps. Bottom left: 14 steps. Bottom right: 10 steps.

Cropping around the hand: only 10 steps (far right) shows a pink ribbon-like artifact next to the hand.

Hand area compared across step counts
Top: frame 60; bottom: frame 120. From left: fp16 20 steps, Q8_0 at 20, 14, 10 steps

fp16 (far left) has the clearest hand shape; with Q8_0 the hand is slightly translucent. In motion it wasn’t noticeable.

A smaller model file isn’t faster

Besides the full-size model (fp16, about 10GB), Wan 2.2 comes in quantized GGUF versions (Q4_K_M, Q5_K_M, Q8_0). I assumed smaller would be faster with little VRAM, but at 20 steps they all took about 16 minutes (without --fast here).

Model File size Time per video Similarity to fp16
Q4_K_M 3.4GB 15 min 51 s Hand height, mouth shape slightly different
Q5_K_M 3.8GB 16 min 31 s Hand height, mouth shape slightly different
Q8_0 5.4GB 16 min 16 s Almost identical
fp16 10.0GB 16 min 3 s (baseline)

Since speed doesn’t change, pick Q8_0 or fp16, which stay closest to the original. fp16 also ran on 8GB VRAM (ComfyUI offloads what doesn’t fit to system RAM). I recommend Q8_0 because the file is half the size. If you have disk space and want slightly crisper hands, fp16 is fine too.

Launch options plus VAE settings save about 2 minutes

With the same Q8_0 at 20 steps, two changes cut a video from 16 min 16 s to 14 min 6 s:

  • Add --fast plus --disable-dynamic-vram to the launch options. ComfyUI describes --fast as enabling experimental optimizations that may reduce quality, but I saw no artifacts
  • Lower overlap in the final decode node (VAE Decode (Tiled)) from 128 to 32. Decoding went from about 2 min 20 s to about 1 min 40 s

At overlap 0, tile seams (vertical lines) appeared around the hand. Raising tile_size to 768 overflowed VRAM and took over 27 minutes, so keep it at 512.

If speed matters most: the Turbo model

The “Turbo” model, built to generate in few steps (4 steps), takes about 2 min 45 s (163 s) per video with the launch options above plus overlap 32. However, even when told the camera is fixed, the camera drifts toward the subject, and the raised hand blurs into translucency. Below is a Turbo video (no launch options, about 3 min 50 s).

Swapping the decoder for a lightweight one (lighttaew2_2.safetensors from lightx2v/Autoencoders on Hugging Face) brought it down to about 1.5 minutes (86 s), at the cost of blocky noise on the moving hand. It’s an option when you need many quick drafts to find a prompt that works.

Summary

Even an 8GB VRAM card can make 5-second videos from an image. The Q8_0 model at 14 steps with --fast produced clean videos in about 10 min 20 s each. Grab the settings files and try them as is.

Related posts

References

コメント

Copied title and URL