ComfyUI on Windows 11 with ROCm: Wan 2.2 AI Video on AMD GPUs

If you can run Flux.1-dev, you can also generate videos — Wan 2.2 is a diffusion model that turns text (and images) into video, and it runs in ComfyUI on Windows 11 with the same official ROCm nightly PyTorch setup as before. This works on the RX 7000, RX 8000, and RX 9000 series as well as Strix Halo.

This post picks up where the Flux.1-dev article left off: choosing a Wan 2.2 workflow, downloading the models, fixing a common VAE decode problem, and running a First-Last-Frame (FLF) generation.

1. Install ComfyUI

If you haven’t set up ComfyUI yet, follow the previous article first: AMD drivers, Git, Python, cloning ComfyUI, the virtual environment, and the ROCm nightly PyTorch wheels. Once python main.py serves the UI at localhost:8188, you’re ready for Wan 2.2.

2. Choose a Wan 2.2 workflow

In the ComfyUI browser UI, go to Workflow → Browse templates → Video. There you’ll find all kinds of ready-made workflows that use the Wan 2.2 model. For this walkthrough, pick Wan 2.2 First Last Frame to Video (FLF): you provide a starting image and an ending image, and Wan 2.2 animates the transition between them.

3. Download the models

Download the fp8-scaled models from the Wan 2.2 ComfyUI repack on Hugging Face and place them in the right directories:

Model	File	Directory
Diffusion (high noise)	`wan2.2_t2v_high_noise_14B_fp8_scaled.safetensors`	`models/diffusion_models`
Diffusion (low noise)	`wan2.2_t2v_low_noise_14B_fp8_scaled.safetensors`	`models/diffusion_models`
LoRA (high noise)	`wan2.2_t2v_lightx2v_4steps_lora_v1.1_high_noise.safetensors`	`models/loras`
LoRA (low noise)	`wan2.2_t2v_lightx2v_4steps_lora_v1.1_low_noise.safetensors`	`models/loras`
Text encoder	`umt5_xxl_fp8_e4m3fn_scaled.safetensors`	`models/text_encoders`
VAE	`wan_2.1_vae.safetensors`	`models/vae`

The two diffusion models (high/low noise) and the matching LoRAs are used together — the high-noise model handles the early denoising steps, the low-noise model the later ones. The LightX2V LoRAs reduce the step count to just 4 per stage.

ComfyUI/
├───📂 models/
│   ├───📂 diffusion_models/
│   │   ├─── wan2.2_t2v_low_noise_14B_fp8_scaled.safetensors
│   │   └─── wan2.2_t2v_high_noise_14B_fp8_scaled.safetensors
│   ├───📂 loras/
│   │   ├─── wan2.2_t2v_lightx2v_4steps_lora_v1.1_low_noise.safetensors
│   │   └─── wan2.2_t2v_lightx2v_4steps_lora_v1.1_high_noise.safetensors
│   ├───📂 text_encoders/
│   │   └─── umt5_xxl_fp8_e4m3fn_scaled.safetensors
│   └───📂 vae/
│       └─── wan_2.1_vae.safetensors

Once the files are in place, ComfyUI picks them up in the browser.

4. Fix the VAE Decode node

When trying the Wan 2.2 workflows, the VAE Decode node often doesn’t work out of the box — it’s the node that gives open errors. The fix:

Remove the problematic VAE decode node from the workflow.
Right-click on the canvas → Add node → search for VAE Decode and add that node instead.
Wire it up: the denoised latent goes into the VAE Decode node, and its image output goes into the Create Video node.

5. Configure the workflow

Set up the FLF workflow with your own images and prompt. In the video, the example is:

Starting image: a house in the water.
Ending image: a futuristic house.
Prompt: describes an explosion in between.

The result is a video that starts with the first image, ends with the second, and animates whatever the prompt describes in between.

A couple of settings matter:

Width/height: match your images. Since the example images are 512×512, set both to 512.
Frame count: the default can mean a long wait — the video uses 41 frames to keep generation time down.

6. Run it

Queue the workflow and wait — video generation takes a while. While it runs you can check that your GPU is actually working:

In the Adrenalin software, the GPU utilization goes up.
In the command prompt where ComfyUI runs, you can see all the models being loaded.

After a while, there’s your video, generated entirely on your local AMD GPU — no cloud, no API keys.