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”.

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:
- wan22-vram8gb-recommend.zip (contains
run_nvidia_gpu_fast.batandWan22_5B_Q8_i2v_recommend.json)
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.

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
--fastplus--disable-dynamic-vramto the launch options. ComfyUI describes--fastas 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
- Local AI video generation on an 8GB GPU, set up by Claude Code (installing ComfyUI with Wan 2.2)
- SDXL on 8GB VRAM: --medvram took generation from 18 minutes to under 1 (the Stable Diffusion settings used for the source image)
- Free the VRAM used by Ollama and AivisSpeech


コメント