A free AI video generator no longer means a watermarked web demo with five credits. Wan 2.2, the newest Wan release whose weights you can still download, ships under the Apache 2.0 license, so you can run it on your own GPU, keep every clip, and pay nothing per second, according to an October 2026 roundup of open video models from CinemaDrop. That makes it the cleanest starting point for anyone who wants a free AI video generator without a subscription.
This tutorial walks you through 13 steps and about 60 minutes of work, most of it model downloads. You will install ComfyUI, load the Wan 2.2 5B text-to-video and image-to-video template, render your first clip, squeeze the workflow onto a smaller card, and finish with a working Python batch runner that turns a text file of prompts into a folder of finished clips. The date of writing is October 26, 2026, and every version and license note below reflects what was current on that day.
One scoping note before we start. Newer Wan generations exist, but they are hosted services, not downloads. This guide covers the local path only. If you have run ComfyUI before, for example in our walkthrough on running FLUX locally in ComfyUI, steps 1 to 4 will feel like a refresher and you can skim ahead to the template.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
Why Run a Free AI Video Generator Locally in 2026
Hosted video generators bill by the second of output. A third-party Wan guide site lists Wan 3.0 at $0.05, $0.10 and $0.20 per second at 480p, 720p and 1080p respectively, and describes it as API-only. At the 720p rate, a five-second clip costs about 50 cents, and a hundred exploratory drafts cost about $50 before you keep a single one. Treat those figures as one reseller’s reported pricing rather than an official Alibaba rate card. The order of magnitude still matches what most hosted tools charge.
A local setup flips that math. Once the weights sit on your disk, each extra attempt costs electricity and nothing else. Assume a 300 W card running for nine minutes at 17 cents per kWh (both numbers are our illustrative assumptions, so swap in your own). That works out to roughly 0.045 kWh, or under a cent per clip. You trade money for time and for a bit of setup friction.
Privacy is the second reason. Prompts, reference photos and drafts never leave your machine, which matters if you animate client product shots, unreleased designs or footage of people who did not agree to cloud processing. The third reason is control. A local pipeline lets you fix the seed, swap the sampler, chain a second model and script the whole thing. A web form allows none of that.
The downsides are real, so go in with open eyes. A local 5B model will not match the polish of the best hosted systems, clips run about five seconds, and the 5B workflow reportedly produces silent video. If you only need two polished clips for a pitch deck, a hosted tool wins on time. For a ranking of those hosted options, see our best AI video generator comparison. If you want to iterate fifty times on one idea, own the pipeline.
Prerequisites and Versions for This Free AI Video Generator
You need an NVIDIA GPU for the smooth path. Wan 2.2’s 5B hybrid model targets 720p at 24 frames per second and was designed to run on consumer cards such as the RTX 4090. A community test published on October 23, 2026 reportedly ran the 5B model on an RTX 5060 Ti with 16 GB, peaking at about 15,465 MiB of VRAM and finishing one generation in roughly 9 minutes 10 seconds. Those numbers set expectations. A 16 GB card works but sits close to its ceiling, and a 24 GB card gives you breathing room.
| Requirement | Recommended | Notes |
|---|---|---|
| GPU | NVIDIA RTX with 16 GB VRAM or more | 24 GB is comfortable. Smaller cards need the low-VRAM options in Step 9 |
| Python | 3.13 | ComfyUI’s system requirements page recommends 3.13. Use 3.12 if a custom node refuses to install |
| PyTorch | Current stable build with CUDA 13.0 wheels | Installed from the cu130 index in Step 3 |
| ComfyUI | Latest release from the official repository | Always pull the newest tag, since templates change often |
| Model | Wan 2.2 TI2V 5B | Apache 2.0 license, code and weights free to download |
| Disk | 40 GB free | Our planning figure: model files plus outputs plus headroom |
| System RAM | 32 GB | Our planning figure: offloading spills into RAM |
| Extras | Git, ffmpeg, a recent NVIDIA driver | ffmpeg is used in Step 13 |
Pin the numbers loosely. ComfyUI ships frequent releases, and its changelog reportedly lists v0.42.4, dated October 22, 2026, as the newest at the time of writing. The project advises using the newest stable PyTorch with the newest CUDA build that is more than about two weeks old. If a newer ComfyUI tag exists by the time you read this, use it. The tutorial does not depend on a specific tag.
Which Open-Weight Model to Pick: Wan 2.2, LTX-2.5 or HunyuanVideo 1.5
Three open-weight families dominate local video generation right now. We build on Wan 2.2 because it has the friendliest license, the most mature ComfyUI support and a 5B variant that fits consumer hardware. The other two deserve a fair look, and the table below compares them using only details confirmed against current pages.
| Model | License | Audio | Hardware guidance |
|---|---|---|---|
| Wan 2.2 (5B hybrid) | Apache 2.0 | Not advertised as a built-in feature | 720p at 24 fps, built for consumer cards such as the RTX 4090 |
| LTX-2.5 | Free to run under $10M annual revenue, per LTX | Native audio and video in one pass | LTX says to plan for an NVIDIA GPU with at least 32 GB, with FP8 quantization for 32 GB workflows |
| HunyuanVideo 1.5 | Tencent Hunyuan Community License | No native audio | About 14 GB with offloading, 480p and 720p, 1080p through upscaling |
LTX describes LTX-2.5 as the only open model with native audio-video generation in a single pass, and its own comparison page admits the trade-off: more capability, higher hardware floor. The same LTX comparison of open-source video models lists a hosted API for readers who do not own a 32 GB card, billed per second of output from $0.09 at 720p to $0.37 at 4K. Pick LTX-2.5 if synchronized sound is the point of your project and you own the hardware.
HunyuanVideo 1.5 is the low-VRAM challenger. A HunyuanVideo 1.5 review updated October 24, 2026 covers its ComfyUI workflow and the roughly 14 GB offloading figure. Read the license before you ship anything commercial, because the Hunyuan Community License reportedly excludes the European Union, the United Kingdom and South Korea, and requires a separate license for services above 100 million monthly active users. Check Tencent’s current text before relying on that summary.
What about newer Wan numbers? ComfyUI’s official documentation now presents Wan 2.7 through Partner Nodes, which are paid hosted calls. A third-party roundup dated October 14 and updated October 25 reportedly found no official Wan 3.0 weights in public model listings and called Wan 2.2 the latest downloadable Wan model. So Wan 2.2 remains the current open-weight Wan, and the newer versions are services. To compare local output against those services in a disciplined way, our AI video generator benchmark harness tutorial covers blind rating and scoring.
Steps 1 and 2: Check Your GPU and Build a Clean Python Environment
Step 1: Confirm the GPU, driver and disk space
Open a terminal and ask the driver what it sees. You want to confirm the card name, the total VRAM, and that nothing else is eating memory. Close browsers with hardware acceleration and any game launcher before you continue, because Chrome alone can hold a gigabyte or two of VRAM.
nvidia-smi --query-gpu=name,memory.total,memory.used,driver_version --format=csv
df -h .The output should look like the example below. Your card and driver will differ, but memory.used should sit near zero before you start.
name, memory.total [MiB], memory.used [MiB], driver_version
NVIDIA GeForce RTX 4090, 24564 MiB, 612 MiB, (your driver version)
Filesystem Size Used Avail Use% Mounted on
/dev/nvme0n1p2 1.8T 910G 798G 54% /If nvidia-smi is not found, install the current NVIDIA driver for your card first and reboot. CUDA 13.0 PyTorch wheels need a driver new enough to support them, and the quickest way to avoid trouble is to take the latest driver from NVIDIA. Keep at least 40 GB free on the drive where ComfyUI will live.
Step 2: Create an isolated Python 3.13 environment
ComfyUI pulls in dozens of packages and custom nodes pull in more, so give it its own virtual environment. That keeps your system Python clean and lets you delete the whole thing if an install goes sideways. Pick a folder with plenty of room, then create and activate the environment.
# Linux and macOS
mkdir -p ~/video-lab
cd ~/video-lab
python3.13 -m venv comfy-env
source comfy-env/bin/activate
python --version
# Windows PowerShell
mkdir $HOME\video-lab
cd $HOME\video-lab
py -3.13 -m venv comfy-env
.\comfy-env\Scripts\Activate.ps1
python --versionThe last command should print Python 3.13 and a patch number. If it prints something older, the venv picked up the wrong interpreter. Python 3.14 reportedly works in some setups but can break custom-node dependencies, so stay on 3.13 or fall back to 3.12 rather than chasing the newest interpreter.
Steps 3 and 4: Install ComfyUI and Launch the Server
Step 3: Clone ComfyUI and install PyTorch with CUDA
Windows users who want zero command-line work can skip this step. ComfyUI publishes a portable package that bundles its own Python and a CUDA build of PyTorch. Download it, extract it, and double-click the NVIDIA launcher batch file. The manual route below gives you more control and is the same on Linux, which is why this guide uses it.
git clone https://github.com/Comfy-Org/ComfyUI.git
cd ComfyUI
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu130
pip install -r requirements.txtOrder matters here. Install PyTorch first so the requirements file does not pull a CPU-only build behind your back. Once the installs finish, run a one-line sanity check to confirm that PyTorch sees the GPU.
python -c "import torch; print(torch.__version__, torch.cuda.is_available(), torch.cuda.get_device_name(0))"You want to see True in the middle of that output. A False means PyTorch installed without CUDA support, and the troubleshooting section covers the fix.
Step 4: Start ComfyUI and open the interface
Launch the server from the ComfyUI folder. The first start takes a little longer because it builds caches. When you see the address line, open it in a browser.
python main.py --listen 127.0.0.1 --port 8188Total VRAM 24564 MB, total RAM 65536 MB
pytorch version: (your version)
Device: cuda:0 NVIDIA GeForce RTX 4090 : cudaMallocAsync
Starting server
To see the GUI go to: http://127.0.0.1:8188Keep this terminal open, because closing it stops the server. Binding to 127.0.0.1 keeps ComfyUI reachable only from your own machine. Do not expose it to your network or the internet, since the server has no authentication and can execute arbitrary workflow graphs. Our self-hosting guide for Qwen-Image-2.1 uses the same loopback habit for the same reason.
Steps 5 and 6: Load the Wan 2.2 Template and Download the Model Files
Step 5: Open the official Wan 2.2 5B template
ComfyUI ships workflow templates, so you never have to wire a video graph by hand. In the interface, open the Templates browser, go to the Video section and pick the Wan 2.2 5B text-and-image-to-video entry. Its internal name is video_wan2_2_5B_ti2v. The documented workflow reportedly produces 121 frames at 1280 by 704 and 24 fps, which is about five seconds of video, and it handles both text-to-video and image-to-video from the same graph.
When the graph loads, expect red-bordered nodes and a Missing Models dialog. That is normal. The template knows which files it needs but your install has none of them yet. The dialog lists each file with a download link, which brings us to the next step.
Step 6: Download the diffusion model, text encoder and VAE
The 5B workflow needs three files: the diffusion model, a UMT5 text encoder, and the Wan 2.2 VAE. The ComfyUI team announced day-0 native support for Wan 2.2 when the weights shipped, and the repackaged files live on Hugging Face under the Comfy-Org organization. Use the links in the Missing Models dialog if you can, since they track the exact filenames your template version expects. If you prefer the command line, the Hugging Face CLI works too.
pip install -U "huggingface_hub[cli]"
cd ~/video-lab/ComfyUI
hf download Comfy-Org/Wan_2.2_ComfyUI_Repackaged split_files/diffusion_models/wan2.2_ti2v_5B_fp16.safetensors --local-dir ./models/_dl
hf download Comfy-Org/Wan_2.2_ComfyUI_Repackaged split_files/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors --local-dir ./models/_dl
hf download Comfy-Org/Wan_2.2_ComfyUI_Repackaged split_files/vae/wan2.2_vae.safetensors --local-dir ./models/_dl
mv ./models/_dl/split_files/diffusion_models/*.safetensors ./models/diffusion_models/
mv ./models/_dl/split_files/text_encoders/*.safetensors ./models/text_encoders/
mv ./models/_dl/split_files/vae/*.safetensors ./models/vae/The 5B diffusion file in 16-bit precision weighs roughly 10 GB, which is simple arithmetic: five billion parameters at two bytes each. The text encoder adds several more gigabytes. This download is the slowest part of the whole tutorial, so start it, make coffee, and read ahead. If a path returns a 404, the repository layout changed. Fall back to the download links inside the Missing Models dialog, which always match the template.
After the files land in models/diffusion_models, models/text_encoders and models/vae, press R in the ComfyUI window to refresh the node lists, or restart the server. The red borders should disappear and each loader node should show its filename in the dropdown.
Step 7: Render Your First Text-to-Video Clip
Now for the payoff. Find the positive prompt node (a CLIPTextEncode box with a long default prompt) and replace the text with something simple and visual. Keep your first test small so a failure costs minutes rather than a quarter hour. Here is a prompt that works well as a smoke test.
A red fox trots across fresh snow at sunrise, low camera tracking beside it,
breath visible in the cold air, soft golden backlight, shallow depth of fieldBefore you press Queue, check two settings. The template’s image-input node should be bypassed or empty if you want pure text-to-video, and the sampler’s seed should be on fixed rather than randomize so you can compare changes later. Then press Queue, or hit Ctrl+Enter. The first run loads roughly 20 GB of weights into memory, so it takes noticeably longer than later runs. On a 16 GB card, the community test above reported just over nine minutes for a generation, and a 24 GB card should finish in less.
got prompt
Requested to load WanVAE
Requested to load WAN21
loaded completely 14882.3 9536.1 True
100%|##########| 20/20 [05:41<00:00, 17.08s/it]
Prompt executed in 00:07:12Treat the timings above as an illustration of the log format rather than a benchmark of your hardware. When the run finishes, a video node at the end of the graph shows a preview, and the file lands in ComfyUI/output. Play it back at full size. Look for a coherent subject, stable background, and motion that matches your prompt. If the clip looks like a slideshow or melts into noise, jump to the troubleshooting list.
Step 8: Animate a Still With Image-to-Video
The same 5B graph also animates a starting image, which is how most creators get consistent characters and brand-accurate products. Copy a PNG or JPG into ComfyUI/input, or use the Load Image node’s upload button. Enable the image-input node in the template (un-bypass it), pick your file, and write a prompt that describes the motion, not the picture. The still already tells the model what things look like.
Image choice decides the result. Use a sharp image with a clear subject, generous empty space where motion can happen, and an aspect ratio close to the 1280 by 704 output. A portrait photo forced into a landscape frame gets cropped or stretched, and the model will invent whatever fills the gap. You can generate starting stills locally too. Our walkthrough on running FLUX.2 Klein locally with InvokeAI makes a quick source of clean 16:9 frames.
The camera slowly pushes in as the woman turns her head toward the window,
curtains move in a light breeze, natural daylight, steady handheld feelImage-to-video usually holds identity better than text-to-video because the first frame is fixed. It also exposes a known weakness of five-second models: the further a clip drifts from the starting frame, the more faces and hands wobble. Keep motion modest, with one action per clip, and cut together several short shots instead of asking for one long scene. The modellix team published a tested comparison of local Wan against a no-GPU API route in ComfyUI that shows the same trade-off on real clips.
Step 9: Fit the Workflow Onto a Smaller GPU
Not everyone owns a 16 or 24 GB card. VRAM use is a property of the workflow rather than the model alone, and you control several knobs. ComfyUI documentation is reported to say the 5B Wan 2.2 model can fit an 8 GB GPU with native offloading, though the same evidence records much higher needs for some other models and settings. Work through the options below in order, and stop as soon as the run completes without an out-of-memory error.
| Lever | How to apply it | Cost |
|---|---|---|
| Lower the resolution | Change width and height on the latent node, for example from 1280 by 704 to 832 by 480 | Softer detail, big VRAM saving |
| Cut the frame count | Reduce the length value so the clip runs two or three seconds | Shorter clips, fewer wobble artifacts |
| Use offloading | Start ComfyUI with –lowvram, or –novram on very small cards | Slower, uses system RAM |
| Use a quantized model | Load a GGUF or FP8 version through a compatible loader | Small quality loss, large memory saving |
| Tile the VAE decode | Swap in the tiled VAE decode node | Slightly slower decode, avoids the last-step spike |
| Close other GPU apps | Quit browsers, launchers and overlays | None |
Community GGUF workflows deserve a special mention. An October 2026 guide to Wan 2.2 GGUF on 6 to 8 GB of VRAM documents a quantized route, and a separate community package reportedly covers the 14B text-to-video and image-to-video experts plus the 5B model, with LightX2V LoRA support for fewer sampling steps. These are third-party projects, so install custom nodes only from maintained repositories and read their issue trackers first.
# Low-VRAM launch: offload weights to system RAM
python main.py --lowvram --listen 127.0.0.1 --port 8188
# Very small cards (slow, but it can finish)
python main.py --novram --listen 127.0.0.1 --port 8188Steps 10 and 11: Write Prompts That Move and Export the Workflow as API JSON
Step 10: Prompt for motion, camera and light
Video prompts differ from image prompts. A still image prompt names a subject and a style, while a video prompt must also say what happens and how the camera behaves. A reliable structure has four parts: subject, action, camera, and lighting or mood. Keep each part short, put the action in the present tense, and avoid stacking more than one action per clip.
- Subject: one clear noun phrase, such as a ceramic teapot on a wooden table.
- Action: a single verb, such as steam rises or the lid slowly lifts.
- Camera: a named move, such as slow push-in, locked-off shot, orbit left, or handheld.
- Light and mood: morning window light, neon rain, overcast softbox, golden hour.
Negative prompts help less than people expect, but a short list still cuts the worst artifacts. Fix the seed while you tune wording, then change one variable at a time. If you change the prompt, the resolution and the sampler together, you will never know which edit made the clip better.
Step 11: Export the graph in API format
ComfyUI has two JSON formats. The regular save includes layout data for the canvas, while the API format is a flat dictionary of node IDs that the server accepts directly. Enable Dev Mode in the settings, then use Export (API) from the workflow menu and save the file as wan22_ti2v_api.json inside a new project folder. Your batch runner will load this file, so export it after you settle on resolution and frame count in the earlier steps.
Open the exported file in an editor and skim it. You will see entries shaped like a node number mapped to a class_type and an inputs dictionary. Node numbers differ between template versions, so the script in the next step finds nodes by class and by their links instead of hard-coding IDs. That choice lets the project survive template updates, which ComfyUI ships often.
Steps 12 and 13: The Complete Working Project, a Batch Runner and Post-Processing
Step 12: Build the Python batch runner
The project has three files: the exported wan22_ti2v_api.json, a prompts.txt with one prompt per line, and batch_video.py. The script uses only the Python standard library, so it needs no extra installs. It reads each prompt, writes it into the positive text node, sets a seed, queues the job on the local server, waits for completion, and downloads the finished clip into a clips folder.
#!/usr/bin/env python3
"""Queue prompts on a local ComfyUI server and save the finished clips."""
import argparse
import json
import random
import sys
import time
import urllib.error
import urllib.parse
import urllib.request
from pathlib import Path
SERVER = "http://127.0.0.1:8188"
def call(path, payload=None):
data = json.dumps(payload).encode() if payload is not None else None
req = urllib.request.Request(
SERVER + path, data=data, headers={"Content-Type": "application/json"}
)
try:
with urllib.request.urlopen(req, timeout=60) as resp:
return json.loads(resp.read())
except urllib.error.HTTPError as err:
sys.exit(f"Server rejected the request ({err.code}): {err.read().decode()[:800]}")
except urllib.error.URLError as err:
sys.exit(f"Cannot reach ComfyUI at {SERVER}. Is it running? ({err.reason})")
def find_sampler(graph):
for node in graph.values():
if node["class_type"] in ("KSampler", "KSamplerAdvanced"):
return node
sys.exit("No KSampler node found in the workflow file.")
def apply_settings(graph, prompt, seed, args):
sampler = find_sampler(graph)
positive_id = str(sampler["inputs"]["positive"][0])
graph[positive_id]["inputs"]["text"] = prompt
key = "seed" if "seed" in sampler["inputs"] else "noise_seed"
sampler["inputs"][key] = seed
for node in graph.values():
inputs = node["inputs"]
if "Latent" in node["class_type"]:
if args.frames and "length" in inputs:
inputs["length"] = args.frames
if args.width and "width" in inputs:
inputs["width"] = args.width
if args.height and "height" in inputs:
inputs["height"] = args.height
if args.image and node["class_type"] == "LoadImage":
inputs["image"] = args.image
def wait_for(prompt_id, poll=3.0, limit=3600):
started = time.time()
while time.time() - started < limit:
history = call(f"/history/{prompt_id}")
if prompt_id in history:
return history[prompt_id]
time.sleep(poll)
sys.exit(f"Timed out waiting for job {prompt_id}.")
def collect_files(entry):
files = []
for output in entry.get("outputs", {}).values():
for items in output.values():
if isinstance(items, list):
files += [i for i in items if isinstance(i, dict) and "filename" in i]
return files
def download(item, target):
query = urllib.parse.urlencode(
{
"filename": item["filename"],
"subfolder": item.get("subfolder", ""),
"type": item.get("type", "output"),
}
)
with urllib.request.urlopen(f"{SERVER}/view?{query}", timeout=120) as resp:
target.write_bytes(resp.read())
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--workflow", default="wan22_ti2v_api.json")
parser.add_argument("--prompts", default="prompts.txt")
parser.add_argument("--out", default="clips")
parser.add_argument("--frames", type=int, default=0)
parser.add_argument("--width", type=int, default=0)
parser.add_argument("--height", type=int, default=0)
parser.add_argument("--image", default="")
parser.add_argument("--seed", type=int, default=-1)
args = parser.parse_args()
template = json.loads(Path(args.workflow).read_text())
prompts = [p.strip() for p in Path(args.prompts).read_text().splitlines() if p.strip()]
out_dir = Path(args.out)
out_dir.mkdir(exist_ok=True)
for index, prompt in enumerate(prompts, start=1):
graph = json.loads(json.dumps(template))
seed = args.seed if args.seed >= 0 else random.randint(0, 2**32 - 1)
apply_settings(graph, prompt, seed, args)
queued = call("/prompt", {"prompt": graph})
began = time.time()
print(f"[{index}/{len(prompts)}] queued {queued['prompt_id'][:8]} seed={seed}")
entry = wait_for(queued["prompt_id"])
for item in collect_files(entry):
name = f"{index:03d}_{seed}_{item['filename']}"
download(item, out_dir / name)
print(f" saved {out_dir / name} in {time.time() - began:.0f}s")
if __name__ == "__main__":
main()Two details matter. First, the script finds the positive prompt by following the sampler’s positive input link, so it works even if the node numbering changes. Second, ComfyUI caches results for identical inputs and skips the run. That is why the script randomizes the seed unless you pass one. Create the prompts file, then run the script while the ComfyUI server is up in the other terminal.
cat > prompts.txt << 'EOF'
A red fox trots across fresh snow at sunrise, low tracking camera, golden backlight
A ceramic teapot on a wooden table, steam rises, slow push-in, soft window light
Neon rain falls on an empty night market, slow orbit left, reflections on wet stone
EOF
python batch_video.py --workflow wan22_ti2v_api.json --prompts prompts.txt --out clips[1/3] queued 7c1e9a42 seed=2814409731
saved clips/001_2814409731_wan22_00001.mp4 in 438s
[2/3] queued b09d1f6e seed=1160072205
saved clips/002_1160072205_wan22_00002.mp4 in 412s
[3/3] queued 5ae82c13 seed=3921847760
saved clips/003_3921847760_wan22_00003.mp4 in 419sThe example output shows the log shape, with timings that will vary by card. For image-to-video batches, copy your start frame into ComfyUI/input and pass its filename with the image flag, for example --image fox_start.png. To test a cheaper draft, add flags like --frames 49 --width 832 --height 480, which shrinks every clip in the batch without touching the template.
Step 13: Post-process with ffmpeg and log what each clip costs
Raw model output is a starting point. A few ffmpeg passes turn it into something you can post. The commands below re-encode for broad player compatibility, smooth motion by interpolating to 48 fps, and scale to 1920 pixels wide. The scale pass is a classic resize, not AI upscaling, so it will not add real detail.
# Compatibility re-encode (H.264, plays everywhere)
ffmpeg -i clips/001_2814409731_wan22_00001.mp4 -c:v libx264 -crf 18 -pix_fmt yuv420p fox_h264.mp4
# Interpolate 24 fps to 48 fps
ffmpeg -i fox_h264.mp4 -vf "minterpolate=fps=48:mi_mode=mci" -c:v libx264 -crf 18 -pix_fmt yuv420p fox_48fps.mp4
# Resize to 1920 wide with a sharp filter
ffmpeg -i fox_h264.mp4 -vf "scale=1920:-2:flags=lanczos" -c:v libx264 -crf 18 -pix_fmt yuv420p fox_1080w.mp4Then close the loop on cost. Append a line to a CSV after each batch, with the date, prompt, seed, seconds taken and the clip’s filename. After a week you will know your real cost per usable clip, including the drafts you threw away. Our Gemini video generator API cost ledger tutorial shows how to keep that kind of ledger for a hosted service, and the same columns let you compare both routes fairly.
| Steps | Task | Planned time |
|---|---|---|
| 1 and 2 | GPU check, Python environment | 8 min |
| 3 and 4 | Install and launch ComfyUI | 10 min |
| 5 and 6 | Template and model downloads | 20 min |
| 7 | First text-to-video render | 6 min |
| 8 | Image-to-video test | 6 min |
| 9 | Low-VRAM tuning (only if needed) | 0 min |
| 10 and 11 | Prompt practice, API export | 5 min |
| 12 and 13 | Batch script, ffmpeg, cost log | 5 min |
Common Pitfalls With a Free AI Video Generator
Most failed first attempts trace back to the same handful of mistakes. Read this list before you debug anything else.
- Installing a CPU-only PyTorch. Running
pip install -r requirements.txtbefore installing the CUDA build can pull in a generic wheel. Install PyTorch from the CUDA index first and verify with torch.cuda.is_available(). - Skipping the model refresh. You moved the files into the right folders, but the dropdowns still show nothing. Press R in the interface or restart the server. ComfyUI does not rescan folders on its own.
- Judging quality from one seed. A single bad render says little. Run the same prompt with three or four seeds before you rewrite anything, because seed variance in video models is large.
- Asking for too much in one clip. Five seconds fit one action and one camera move. Prompts with a crowd, a chase and a camera orbit produce mush.
- Leaving the server open to the network. Launching with –listen 0.0.0.0 exposes a service with no login. Keep it on 127.0.0.1 or put an authenticated reverse proxy in front.
- Trusting every custom node. Custom nodes run arbitrary Python on your machine. Install only from maintained repositories, check recent commits, and avoid nodes that ask for broad system access.
- Ignoring the license. Apache 2.0 covers Wan 2.2, but the Hunyuan and LTX terms differ. Read the model card before you sell clips made with a different model.
Troubleshooting: Ten Errors and How to Fix Them
CUDA out of memory during sampling or decode
This is the most common error. Lower the resolution and frame count first, then launch with –lowvram, then try a quantized model. If the crash happens at the very end, the VAE decode is the culprit, so switch to the tiled decode node. Also check nvidia-smi for stray processes holding memory.
torch.cuda.is_available() prints False
PyTorch installed without CUDA, or the driver is too old. Uninstall torch, torchvision and torchaudio, then reinstall from the cu130 index shown in Step 3. If it still fails, update the NVIDIA driver and reboot.
Red nodes and a Missing Models dialog that will not go away
The files sit in the wrong folder or have different names than the template expects. Diffusion models go in models/diffusion_models, text encoders in models/text_encoders and the VAE in models/vae. Match the filenames in the dropdowns, then refresh.
Cannot execute because a node does not exist
Your ComfyUI is older than the template. Run git pull in the ComfyUI folder, reinstall requirements, and restart. If you use a community workflow, install the custom nodes it names, using the manager or by cloning into custom_nodes.
The clip is gray, black or full of static
Usually a wrong VAE or a mismatched text encoder. Confirm that the 5B workflow uses the Wan 2.2 VAE, not an older Wan 2.1 file. A sampler set far outside the template’s defaults can also produce noise, so reload the template and change one value at a time.
Corrupt frames on Apple Silicon
A ComfyUI issue open since late September reports corrupt output when running the Wan 2.2 5B model on an M4 Max through the MPS backend, and the available evidence does not show a fix. Mac users should expect trouble, try a newer ComfyUI and PyTorch build, and consider a hosted route or a Linux box with an NVIDIA card for this particular model.
The batch script says it cannot reach ComfyUI
The server is not running, or it uses a different port. Confirm the address in the ComfyUI terminal and edit the SERVER constant if you changed the port. Firewalls rarely matter on loopback, but a VPN client sometimes grabs port 8188.
The script gets HTTP 400 with node errors
You probably exported the regular workflow instead of the API format, or the graph references a model file you do not have. Re-export with Export (API) and read the error text the script prints, which names the failing node and input.
Nothing happens when the same prompt runs twice
ComfyUI reuses cached outputs when every input is identical. Change the seed, or pass a different value to the script. In the UI, set the seed control to randomize.
The MP4 will not play in a browser or editor
Some players dislike the default pixel format. Re-encode with the H.264 command from Step 13, which sets yuv420p and works almost everywhere.
Faces and hands warp halfway through the clip
This is a model limit, not a bug. Shorten the clip, simplify the motion, use image-to-video with a clean first frame, and cut away before the drift starts. Stitching three two-second shots usually beats one six-second shot.
Advanced Tips to Get More From Wan 2.2
Once the basic loop works, a few upgrades pay off quickly. Try the 14B variants if your GPU has plenty of VRAM, or look at community GGUF quantized builds if it does not. The family covers text-to-video, image-to-video, speech-to-video, animation and control workflows. ComfyUI’s documentation also surfaced a Wan 2.2 Fun Control 14B workflow on October 26, which accepts a guiding video so you can steer the generation. The Wan 2.2 Fun Control page in the official docs walks through it, albeit in Spanish.
Speed is the next lever. Distillation LoRAs such as the LightX2V adapters mentioned by the GGUF community packages cut the number of sampling steps, trading a little fidelity for a large cut in time. Test them on a fixed seed against your baseline before you adopt them for everything. For sound, remember that the 5B workflow is silent. Pair it with a separate audio tool, or evaluate LTX-2.5 if native audio matters to you.
Prompt writing scales better with help. A small local language model can expand a one-line idea into a structured subject, action, camera and light prompt before your batch runs. If you do not have one yet, our guide to running Ollama locally gets a model serving in minutes, and a few lines added to batch_video.py can call it before each job. For broader context on the tools around this stack, browse the AI and machine learning section for new model coverage.
Finally, think about the hosted fallback. A hybrid workflow works well: draft locally at low resolution, then send only the winning prompts to a paid service for the final render. Google’s Veo is one such service, and our tutorial on the Veo 3.1 API shows how to call it from code. That split keeps your spend limited to the clips that earn it.
Reproducibility deserves a habit of its own. Save the API JSON next to every batch, log the seed the script prints, and keep the ComfyUI commit you ran. Video models react to tiny changes in sampler settings, and six weeks from now you will want to regenerate the one clip a client liked. A tagged folder per project, holding the workflow file, the prompts and the CSV ledger, costs a few kilobytes and saves an afternoon of guessing.
Storage also creeps up on you. Every experiment leaves an MP4 in the output folder, plus cached latents and preview files, and a week of serious testing can fill a drive that looked roomy on day one. Delete rejected drafts the same day, keep only winners and their workflow files, and move finished projects to a slower disk. Model files are the exception. Keep the 5B weights on your fastest drive, because loading them from a slow disk adds minutes to the first render of every session.
A last word on judging results honestly. Local open models improve fast, but hosted systems still lead on prompt adherence and long-range consistency. Judge your clips against the job rather than against the best demo reel you have seen. A five-second loop for a product page, a moving background for a talk, or an animatic that sells an idea before the real shoot are all jobs where Wan 2.2 on your own card already holds up, and you pay nothing per attempt while you find the version that works.
Frequently Asked Questions
Is there a truly free AI video generator with no watermark?
Yes, if you run it yourself. Wan 2.2 is released under Apache 2.0 and its weights are free to download, so a local ComfyUI setup produces clips with no watermark and no per-second fee. You pay with hardware, electricity and setup time.
What GPU do I need to run Wan 2.2 locally?
The 5B model targets consumer cards such as the RTX 4090. Smaller cards can work with quantized or offloaded setups at a cost in speed and quality. More VRAM means higher resolution and fewer compromises.
Can I use these clips commercially?
Apache 2.0 places no commercial restriction on Wan 2.2. Other models differ, so check each model card. You also stay responsible for what you generate, including likeness, trademarks and music rights.
Does Wan 2.2 generate audio?
The standard text and image workflow is a picture-only pipeline, so plan to add sound in an editor or with a separate audio model. LTX-2.5 generates audio and video together if you need sound from one model.
Is there an open-weight Wan 3.0?
We could not confirm one as of October 26, 2026. Newer Wan versions are offered as hosted services, so Wan 2.2 remains the newest Wan you can download and run yourself.
How long can a local clip be?
Expect clips of around five seconds. Longer scenes come from stitching several clips, or from image-to-video chains where each clip starts on the last frame of the previous one.
Should I use Wan 2.2, LTX-2.5 or HunyuanVideo 1.5?
Choose Wan 2.2 for the permissive license and wide ComfyUI support, LTX-2.5 when native audio justifies a 32 GB-class GPU, and HunyuanVideo 1.5 when you need a lower memory footprint and your region is covered by its license.
Is it safe to run ComfyUI on my main machine?
The core app is fine when bound to localhost. The risk sits in custom nodes, which run arbitrary code. Install few of them, prefer maintained projects, and consider a separate user account or container for experiments.
