WAN 2.2 Looping Animations in ComfyUI

In this tutorial, you’ll learn how to create looping animations using WAN 2.2 in ComfyUI. Instead of providing separate start and end frames, our workflow feeds the same image into WAN’s First–Last Frame node, generating smooth, continuous motion that loops perfectly. We’ll cover the FP8 workflow for high-VRAM GPUs and the GGUF variant for lower-VRAM systems, so you can create seamless animations on a wide range of hardware. By the end, you’ll be able to produce high-quality, endless loops for backgrounds, ads, or creative effects, with full control over motion and style.

Before diving into looping animation generation, ensure your system meets the hardware and software requirements to run the WAN 2.2 Looping FP8 workflow smoothly. This setup still needs a solid GPU — we recommend at least an RTX 4090 (24GB VRAM) or using a cloud GPU service like RunPod.

Requirement 1: ComfyUI Installed & Updated

To get started, you need ComfyUI installed locally or via cloud. For local Windows setup, follow this guide:

👉 How to Install ComfyUI Locally on Windows

Once installed, make sure to update ComfyUI to the latest version by opening the Manager tab in the interface and clicking Update ComfyUI. Keeping it up to date ensures compatibility with the latest workflows and features.

If you don’t have a high-end GPU locally, consider running ComfyUI on RunPod with a network volume for persistent storage:

👉 How to Run ComfyUI on RunPod with Network Volume

Requirement 2: Download WAN 2.2 FP8 Model Files

The looping workflow uses the same models as the First–Last Frame workflow, so download and place the following files in the correct ComfyUI folders:

Requirement 3: Verify Folder Structure

Confirm that your folders and files look like this:

ts
1📁 ComfyUI/
2└── 📁 models/
3    ├── 📁 text_encoders/
4    │   └── umt5_xxl_fp8_e4m3fn_scaled.safetensors
5    ├── 📁 diffusion_models/
6    │   ├── wan2.2_i2v_high_noise_14B_fp8_scaled.safetensors
7    │   └── wan2.2_i2v_low_noise_14B_fp8_scaled.safetensors
8    ├── 📁 vae/
9    │   └── wan_2.1_vae.safetensors
10    └── 📁 loras/
11        ├── Wan2.2-Lightning_I2V-A14B-4steps-lora_HIGH_fp16.safetensors
12        └── Wan2.2-Lightning_I2V-A14B-4steps-lora_LOW_fp16.safetensors

Once everything is installed and organized, you’re ready to download and load the WAN 2.2 Looping FP8 workflow and start generating smooth, endless animations. Thanks to the Lightning LoRA’s, the render can be completed in just 4 total steps—2 steps per KSampler while maintaining high visual quality.

Now that your environment and model files are set, it’s time to load and configure the WAN 2.2 Looping FP8 workflow in ComfyUI. This setup ensures all components work together seamlessly for high-quality looping animation generation from a single image. Once configured, you’ll be ready to create smooth, endless loops with precise control over motion and style.

Load the WAN 2.2 Looping FP8 workflow JSON file:

👉 Download the WAN 2.2 Looping FP8 workflow JSON file and drag it into your ComfyUI canvas.

This workflow comes fully pre-arranged with all nodes and model references needed for smooth looping animation generation.

Install Missing Nodes

If you see any red nodes in the workflow, it means some nodes are missing. To fix this, open the Manager tab in ComfyUI, click Install Missing Custom Nodes, then restart ComfyUI. This should resolve the issues.

Once all nodes are installed and the workflow loads without errors, you’re ready to start creating your first seamless loop animation by uploading your image into the workflow — the same image will serve as both the start and end frame, allowing WAN 2.2 to generate smooth, continuous motion automatically.

With the workflow loaded and all components in place, it’s time to run the FP8 Looping animation generation.

Uploading Your Image

Start by loading your chosen image into the image loader. For this looping workflow, the same image will serve as both the start and end frame, allowing WAN 2.2 to generate smooth, continuous motion that loops perfectly. Choose a highly detailed image to set the style, lighting, and color tone for your animation.

We’re starting with the image above as our base ☝️But feel free to use any image of your own!

Set Animation Prompt

Next, describe the motion and dynamic elements you want in your loop. Focus on continuous, cyclical movements like hair sway, clothing ripple, floating objects, camera orbit, or environmental motion. Think of it like directing a short, repeating scene: mention the subject, motion, lighting, atmosphere, and any subtle environmental changes.

Example prompt for a looping animation:

Animate a massive glowing battle axe forged from obsidian and gold, hovering in mid-air. The axe gently bounces up and down while slowly rotating around its vertical axis. Magical runes pulse and orbit around it in a continuous loop. Faint molten-red cracks shimmer, with subtle flames drifting upward. Camera smoothly orbits the axe in a slow circular motion, slightly zooming in and out to enhance depth. Background is a dark gothic cathedral hall with broken stained glass windows, dust particles floating in golden light. Ultra-sharp 3D textures, cinematic lighting, seamless loop-ready animation.

When writing your own prompts, break motion into small, repeatable actions for each element of your scene — this helps the model generate smoother, more cohesive loops.

Set Video Dimensions and Length

Before running the generation, we need to define the output dimensions and duration of your looping animation. This is done in the WanFirstLastFrameToVideo Node.

• Aspect Ratio: This image is 16:9, so we’ll keep that ratio.

• Resolution: Set Width to 832 and Height to 480.

• Length: Adjust the number of frames depending on your desired loop duration:

  • 4 seconds → 65 frames

  • 5 seconds → 81 frames

  • 8 seconds → 129 frames

Choosing the right length ensures the motion remains smooth and the loop seamless. Once these settings are configured, you’re ready to move on to generating your animation.

Keep the Rest of the Workflow

After setting the dimensions and length, the rest of the workflow can remain as it is.

• The High & Low Noise KSampler nodes handles the main sampling steps — keep these settings unchanged.

• The RIFE node takes care of frame interpolation, creating smooth motion between frames.

• The Color Match node ensures consistent lighting and color across all frames.

• Since we are using the same image for both the first and last frames, the ImageSelector node removes the final frame to prevent duplication, ensuring a perfectly seamless loop.

With these nodes configured, your workflow is fully prepared for the FP8 looping animation generation.

Run the Generation

Once your image and prompt are set, run the FP8 workflow. WAN 2.2 will process the frames and generate your endless loop animation automatically. The result will be a smooth, cinematic loop ready to use for backgrounds, ads, or creative visuals.

Above example was rendered at 480p (832×480). If you’d like to upscale your videos, check out this guide:

👉 Read the full tutorial here: How to Upscale Videos in ComfyUI

The example above was generated using FP8 models, which still require a fair amount of VRAM — I ran this on an RTX 4090. For users with less VRAM, we have a handy bonus workflow below.

For users operating in low-VRAM environments, the GGUF variant of the WAN 2.2 model offers a viable alternative for creating seamless looping animations.

Looping GGUF Workflow

For running locally without a high-end GPU, the main difference is that instead of the FP8 high and low diffusion models, you’ll need High Noise and Low Noise GGUF models that fit your VRAM.

You can download them here:
👉 WAN 2.2 High & Low Noise GGUF Models on Hugging Face

That’s the only extra requirement for this workflow — everything else stays the same.

Verify Folder Structure

Confirm your folders and files look like this:

ts
1📁 ComfyUI/
2└── 📁 models/
3    ├── 📁 clip/
4    │   └── umt5_xxl_fp8_e4m3fn_scaled.safetensors
5    ├── 📁 diffusion_models/
6    │   ├── Wan2.2-I2V-A14B-HighNoise-Q4_K_S.gguf  # Or any other GGUF version
7    │   └── Wan2.2-I2V-A14B-LowNoise-Q4_K_S.gguf   # Or any other GGUF version
8    ├── 📁 vae/
9    │   └── wan_2.1_vae.safetensors
10    └── 📁 loras/
11        ├── Wan2.2-Lightning_I2V-A14B-4steps-lora_HIGH_fp16.safetensors
12        └── Wan2.2-Lightning_I2V-A14B-4steps-lora_LOW_fp16.safetensors

Once these GGUF models are in place, you’re ready to run the WAN 2.2 Looping workflow entirely on your local machine, no cloud service needed.

Load the WAN 2.2 Looping GGUF Workflow

Start by loading the WAN 2.2 Looping GGUF Workflow:

👉 Download the provided WAN 2.2 Looping GGUF workflow JSON file and drag it into your ComfyUI canvas.

This workflow comes fully configured with all nodes and references required for smooth looping animation generation. With the GGUF workflow set up, you’re ready to start generating seamless loops locally, even on lower-VRAM hardware!

✨ In the next section, you’ll find a collection of additional stunning examples, each rendered in 480p resolution.

Below, you can see some more stunning examples of what’s possible with the Looping workflows.

To make your looping animation smoother and more faithful to your prompt, adjust the High Noise KSampler:

• Disable the High Noise LoRA — this helps reduce jittery motion.

• Increase the total steps (for example, from 4 → 10 or 20).

• Set the end_at_step to half of the total steps (so if total steps = 10, end = 5; if total steps = 20, end = 10).

• Increase the CFG value from 1 → 3 to make the animation adhere more closely to your prompt.

Keep in mind that increasing total steps will also increase rendering time, but the result is smoother, more natural motion while keeping the loop seamless.

Congratulations! You’ve now explored the full capabilities of WAN 2.2 Looping Animations in ComfyUI — from the high-VRAM FP8 workflow to the VRAM-friendly GGUF variant. You’ve learned how to set up your system, load the workflow, feed in your images, craft detailed prompts, and generate smooth, endless loops with precise control over motion and style.

With WAN 2.2, creating high-quality, eye-catching looping animations is no longer limited to complex software or top-tier GPUs. Whether you’re producing background animations, social media visuals, ads, or creative experimental loops, the FP8 and GGUF workflows provide the flexibility to generate stunning, continuous motion efficiently.

Now it’s your turn: experiment with your own images, refine your prompts, and explore the creative possibilities. With the workflows and tools covered here, you’re fully equipped to bring your visions to life — endlessly looping, frame by frame.