Part of AI Tools & Automation — automating real work with local AI models.
11_wan_motion_analysis.py and 11_wan_narrative.py. Model: Wan 2.1 T2V 1.3B in ComfyUI on an AMD PRO W7900 (ROCm, Windows 11). Motion measured objectively with optical flow. Every clip below is real, unedited output.
Cloud video generators like Google Veo are impressive, but they bill per clip and send your prompts to someone else’s servers. There is a free alternative that runs entirely on your own machine: Wan 2.1 in ComfyUI on an AMD GPU. This article sets it up, then asks the question people actually care about — does a small local model produce real, physical motion? — and answers it objectively across ten experiments, plus a 30-second narrative clip.
- Wan 2.1 (1.3B) generates video locally on AMD via ComfyUI + ROCm — free and offline.
- Motion is real and physical for dynamic subjects (a car scored 7.1 px/frame of measured motion), but subtle motion barely animates (a camera pan managed just 0.11 px).
- Fast action trades off temporal smoothness — the more motion, the more jitter.
- A 480×480 clip takes about 50 seconds to generate; a 30-second story is a handful of stitched scenes.
Why generate video locally?
The economics are stark. A cloud model charges for every second of video, so experimentation gets expensive fast. A local model turns that into a one-time hardware cost — once the GPU is paid for, you can generate all night for the price of electricity. Privacy matters too: prompts and results never leave your machine, which is the whole point for anything unreleased.
The trade-off is capability. A small local model like Wan 2.1 1.3B will not match a frontier cloud system on length or fidelity. But as the experiments below show, it produces genuinely usable motion — and it is completely free to run.
Setting up Wan 2.1 in ComfyUI on AMD
Recent ComfyUI has native Wan support, so no custom nodes are needed. You need three model files, placed in the usual folders:
diffusion_models/wan2.1_t2v_1.3B_fp16.safetensors— the video model (~2.8 GB)text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors— the text encoder (~6.7 GB)vae/wan_2.1_vae.safetensors— the video VAE (~250 MB)
A practical warning from building this: if you resume an interrupted download, verify the file size. A safetensors file with extra trailing bytes fails to load with “file not fully covered”. Re-download or truncate to the exact expected size, and the model loads cleanly.
The text-to-video workflow
The graph mirrors the image workflow, with a video twist. A UNET loader brings in the Wan model, a CLIP loader the umt5 encoder, and a VAE loader the video VAE. A ModelSamplingSD3 node sets the shift, an EmptyHunyuanLatentVideo node defines the clip’s width, height, and frame count, and a KSampler denoises the whole video latent at once. A VAE decode turns it into frames, and a save node writes the clip.
Driving it from Python is the same pattern as any ComfyUI job: build the workflow JSON, set the prompt, frame count, and seed, POST it to /prompt, and poll /history for the finished video.
wf["40"]["inputs"]["length"] = 33 # frames (~2 s at 16 fps)
wf["6"]["inputs"]["text"] = "a red ball bouncing on a wooden floor"
wf["3"]["inputs"]["seed"] = random.randint(1, 2**31)
pid = post("/prompt", {"prompt": wf})["prompt_id"]
# poll /history/{pid}, then download the .webm from /viewA 30-second story, stitched locally
Wan 1.3B makes short clips, so a longer video is a storyboard: generate several coherent scenes, then concatenate them with ffmpeg. Here is a 30-second narrative — “a day with local AI” — built from six 5-second scenes: sunrise over a home office, sitting down at a laptop, a glowing GPU, the model “thinking”, a smile at the screen, and the city at dusk.
Free ebook
Free AI Video, Generated Locally
Working scripts and measured benchmarks. Free.
No spam. Unsubscribe at any time.
The cuts are hard rather than blended, but the story reads clearly, and each scene carries its own motion. That is the practical recipe for length on a small model: keep scenes short, keep them coherent, and let ffmpeg handle the assembly.
Does it produce real motion? An objective test
“AI video” often means “a still image that barely moves.” So instead of trusting our eyes, we measured motion objectively. For each clip we computed dense optical flow (Farneback) between consecutive frames and took the mean magnitude — literally how many pixels the content moves per frame. Higher means more motion. We also measured temporal smoothness: how steady that motion is over the clip.
Ten prompts, each naming a specific kind of motion or physics, gave ten independent experiments.
| Prompt | Motion (px/frame) | Smoothness | Verdict |
|---|---|---|---|
| Campfire flickering | 7.20 | 0.41 | Strong, lively flames |
| Sports car on a highway | 7.11 | 0.26 | Strong, with motion blur |
| Bird taking off | 5.44 | 0.27 | Strong wing flap |
| Person walking | 3.18 | 0.51 | Clear, natural gait |
| Ocean waves | 2.38 | 0.54 | Moderate, believable |
| Ball bouncing | 2.14 | 0.37 | Plausible physics |
| Leaves blowing | 1.56 | 0.37 | Gentle drift |
| Flag waving | 1.44 | 0.65 | Subtle but steady |
| Smoke rising | 0.19 | 0.93 | Nearly static |
| Slow camera pan | 0.11 | 0.96 | Failed — a beautiful still |
The pattern is clear and honest. The model animates obvious, high-energy subjects well — fire, a speeding car, a flapping bird all scored above 5 px of motion. It handles everyday motion — walking, waves, a bouncing ball — believably. But it struggles with subtle motion and camera moves: “smoke rising” barely curled, and “slow camera pan” produced a gorgeous still image that hardly moved at all.
Watch the clips — motion gallery
Numbers are one thing; watching is another. Here are the experiments, from the most dynamic to the nearly static. Press play and judge the motion for yourself.
The motion–smoothness trade-off
There is a clear inverse relationship in the data. The high-motion clips — the car (smoothness 0.26) and the bird (0.27) — are the jitteriest, because fast action strains a small model’s temporal consistency. The near-static clips score high on smoothness almost by default, since nothing moving cannot jitter. So a high smoothness number alone is not “good”; read it together with the motion magnitude. The sweet spot is moderate motion with decent smoothness, which is where the walking and waves clips land.
Physics: what the model gets right
On the physics prompts, the model did better than a 1.3B size would suggest. The bouncing ball was caught mid-air just above the floor, with the floor motion-blurred beneath it — a plausible frame from a real bounce. The flag waved in a coherent direction, and the campfire’s flames flickered upward rather than randomly. It does not simulate physics, of course; it has simply learned what these motions look like well enough to reproduce them convincingly at short durations.
Generation speed
Each 480×480, 33-frame clip took about 50 seconds on the W7900. The longer 81-frame scenes for the narrative took roughly three minutes each. That is slow compared to image generation, but it is unattended: queue a batch of prompts and come back to a folder of clips. For a small local model producing real motion at no cost, that is a fair trade.
Prompting for more motion
The experiments point to a practical prompting recipe. The clips that moved most named an active subject and a clear action: “a sports car driving fast”, “a bird taking off and flapping its wings”, “flames dancing”. The clips that barely moved described an ambient state or a camera instruction: “smoke rising”, “a slow camera pan”. A small model animates subjects far better than it moves the camera.
Three habits help. First, put the motion in the subject, not the camera — say “a running dog”, not “the camera follows a dog”. Second, add motion cues the model understands, like “fast”, “flapping”, “crashing”, or “blowing in the wind”. Third, use the negative prompt to push against stillness — listing “static, still image, no motion” nudges the sampler toward movement. Together these turned flat prompts into clips with real, measurable motion.
Limitations to plan around
Three limits shape how you use this. First, length: clips are a few seconds, so longer videos mean stitching scenes. Second, subtle motion: smoke, mist, and slow camera moves barely animate — prompt for clear, energetic action instead. Third, fidelity: 1.3B at 480p is good, not flawless, so treat it as a source of B-roll and concept clips rather than finished cinema. Work with these limits and the model earns its place in a local pipeline.
Frequently asked questions
Does Wan really run on an AMD GPU?
Yes. With a ROCm build of ComfyUI, Wan 2.1 runs natively on the Radeon PRO W7900. No CUDA and no custom nodes are required — recent ComfyUI ships native Wan support.
How long can a single clip be?
A few seconds. In this test, 33 frames (~2 s) and 81 frames (~5 s) both worked well. For longer videos, generate several scenes and concatenate them with ffmpeg, as the 30-second story shows.
Why did the camera pan barely move?
Small video models render subtle and camera-driven motion weakly. The pan produced a beautiful still with almost no movement. Prompt for motion in the subject — a running animal, flowing water, a moving vehicle — for reliable animation.
Is a 1.3B model good enough for real use?
For concept clips, B-roll, social snippets, and backgrounds, yes. It produces real motion at zero cost. For polished, long-form video you would still reach for a larger model, but nothing about the workflow changes — only the weights.
How do I make a longer narrative?
Write a short storyboard, generate each scene as its own clip with a coherent prompt, and stitch them with ffmpeg’s concat. Keep scene lengths equal for an even rhythm.
Summary
Free, local AI video is real. Wan 2.1 1.3B in ComfyUI on an AMD W7900 generated genuine, physical motion — measured objectively at up to 7 px/frame for dynamic scenes — and stitched into a coherent 30-second story, all offline and at no per-clip cost. It shines on energetic subjects and struggles with subtle motion and camera moves, which is exactly the map you need to use it well. Reproduce every clip and metric with the scripts: 11_wan_motion_analysis.py and 11_wan_narrative.py.
Companion code — every script and benchmark from this series lives in one repository: github.com/bestin-it/qwen-local-ai-scripts.
Free ebook
Free AI Video, Generated Locally
Run Wan 2.1 in ComfyUI on your own GPU — the scripts I use, measured times, sample clips. No cloud, no API keys.
No spam. Unsubscribe at any time.
Leave a Reply