Wan Animate 2: Features, Models, ComfyUI, and Complete Guide

Wan Animate 2 is an open character-animation framework from the Wan team. It takes a reference image and a driving video, then generates a video in which the referenced character follows the motion while retaining its visual identity. Unlike the earlier Wan2.2 Animate pipeline, the new system feeds the driving video directly into a redesigned Diffusion Transformer instead of depending on an intermediate pose or motion extractor.

The other headline feature is text-driven viewpoint control. The output camera no longer has to copy the driving video's perspective exactly, so a creator can transfer an action while asking for a different view of the character. The team released inference code plus Base and Distillation weights on August 7, 2026. It also announced Wan-Animate-2-Lite as a streaming-oriented variant, although Lite was not included in that public weight release.

This guide separates those confirmed facts from community assumptions, explains the model choices, and covers the official repository, Diffusers, and the newer ComfyUI workflow.

Status checked August 17, 2026. Wan Animate 2 is moving quickly. Node names, model packaging, and hardware optimizations may change. Check the official Wan-Animate-2 repository before building a production workflow.

Wan Animate 2 at a glance

What is Wan Animate 2?

Wan Animate 2 is not a general text-to-video model. Its core workflow has three inputs:

1. A reference image that defines the target character and scene appearance.
2. A driving video that supplies movement over time.
3. A structured text description that states the character's appearance, background, and optionally the desired viewpoint.

The output is a newly rendered character video. This makes the model relevant to digital characters, virtual presenters, stylized avatars, advertising mascots, short-form animation, and motion previsualization.

The name can be confusing. The downloadable checkpoint is published as Wan2.2-Animate-2-14B, but Wan Animate 2 is a new framework, not simply a minor rename of the original Wan2.2 Animate workflow. Search results for “wan 2.2 animate,” “wan animate,” and “wan animate 2” currently overlap, so always check the checkpoint name and node version before downloading files.

Key Wan Animate 2 features

1. Direct driving-video conditioning

Earlier character-animation systems commonly convert a performance into pose, facial, skeleton, or other motion representations before generation. Each conversion can discard details or introduce alignment errors.

Wan Animate 2 instead consumes the driving video within its redesigned Diffusion Transformer. The stated goal is higher-fidelity motion and stronger identity preservation without an intermediate motion extractor. This does not mean preprocessing disappears completely from every implementation, but the principal motion signal is no longer reduced to a pose sequence before reaching the model.

2. Stronger identity preservation

The reference image supplies the character's face, body, clothing, and style. Direct conditioning is intended to keep those traits more stable while the driving video changes pose and expression.

Identity consistency should still be tested under difficult conditions: rapid turns, self-occlusion, hands covering the face, motion blur, full-body movement, unusual proportions, and large changes in scale. A clean launch example is not a substitute for repeated tests with your own character.

3. Text-driven viewpoint control

Traditional motion transfer often inherits the camera view of the source performance. Wan Animate 2 adds text-driven control that can decouple output viewpoint from the driving video.

For example, a front-facing driving clip can guide motion while the prompt requests a three-quarter view or a slightly lower camera. This is useful when the motion is correct but the source video's framing does not match the target shot.

Viewpoint changes are still generative reconstructions. They may reveal parts of a character that are not visible in the reference image, so front, back, costume, and prop details should be checked for invention or drift.

4. Base and Distilled models

The public release includes a Base model for the full inference path and a Distillation model for fewer denoising steps. The official Diffusers example uses 40 steps for Base and 10 steps for Distilled.

The Distilled example also sets guidance_scale=1.0 and uses the Euler flow solver. Those settings are model-specific: copying Base settings into the Distilled checkpoint is not a reliable way to compare them.

5. A Lite model aimed at streaming

The project introduction says Wan-Animate-2-Lite reduces inference latency to real-time thresholds for streaming character animation. That is an important direction for live avatars and interactive agents.

However, the August 7 release notes list Base and Distillation weights, not a Lite checkpoint. Treat Lite as an announced variant until the team publishes a weight, endpoint, demo contract, or reproducible latency specification. “Real time” also depends on resolution, clip length, batch size, hardware, and whether latency is measured per frame or end to end.

6. Multiple ways to run the model

The official project documents its own inference scripts and a Gradio interface. Wan Animate 2 also has Diffusers support, and ComfyUI has introduced a native workflow for node-based use. These routes share the same basic inputs but differ in model packaging, memory behavior, and operational control.

Wan Animate 2 models compared

The Diffusers repositories are packaging choices, not additional model tiers. Use the Base Diffusers checkpoint or the Distilled Diffusers checkpoint according to the pipeline you want to run.

How Wan Animate 2 works

At a practical level, the workflow looks like this:

1. Prepare the reference image. Use one clearly visible character, stable lighting, and enough resolution to show facial and costume details.
2. Prepare the driving video. Keep the performer visible, avoid unnecessary cuts, and start with a short clip that exposes the motion you actually need.
3. Describe appearance rather than action. The official workflow asks an LLM to create an objective caption covering the character's appearance and the background while omitting action and emotional speculation.
4. Encode the three inputs. The reference image defines identity, the video supplies temporal motion, and the prompt supplies appearance and viewpoint instructions.
5. Denoise with Base or Distilled inference. The model produces a temporally coherent video latent conditioned on all three sources.
6. Decode and export. The official Diffusers example exports at 24 fps.

This division of responsibilities is important. Do not use the appearance prompt to fight the driving video with a contradictory action description. Let the video control motion and use text to make the target character and camera unambiguous.

Hardware requirements and realistic expectations

Wan Animate 2 is a 14B video model, so the official reference setup is much heavier than a typical consumer image-generation workflow.

The repository says its default parallel configuration is tuned for 8× A800 GPUs at 720p. The team also tested 480p on 2× A800 GPUs. Other setups require changes to the parallel YAML configuration.

These are official tested configurations, not universal minimum requirements. They do not prove that a particular consumer GPU will fail, because offloading, quantization, reduced resolution, shorter clips, and ComfyUI optimizations can change memory use. They also do not guarantee practical speed on a smaller card.

For an honest local test plan:

• begin at 480p with a short driving clip;
• use the Distilled checkpoint before Base;
• avoid long batches until one clip completes reliably;
• monitor both VRAM and system RAM;
• record cold-start time separately from generation time;
• compare cost per usable output, not seconds per preview alone.

Community FP8 or GGUF conversions may lower the hardware barrier, but they are not the same artifacts as the official BF16 checkpoints. Verify the source, checksum, node compatibility, and output quality before using a conversion in production.

How to install Wan Animate 2 from the official repository

The official setup uses Python 3.11, PyTorch 2.7 with CUDA 12.6 wheels, FlashAttention, and an editable installation of the repository.

git clone --recursive https://github.com/Wan-Video/Wan-Animate-2.git
cd Wan-Animate-2

conda create -n wan_animate_2 python=3.11 -y
conda activate wan_animate_2

pip install torch==2.7.0 torchvision==0.22.0 torchaudio==2.7.0 \
  --index-url https://download.pytorch.org/whl/cu126
pip install -r requirements.txt
pip install flash-attn --no-build-isolation
pip install -e .

Download the main checkpoint with the Hugging Face CLI:

pip install "huggingface_hub[cli]"
huggingface-cli download Wan-AI/Wan2.2-Animate-2-14B \
  --local-dir ./ckpts/

The repository contains separate YAML files for Base and Distillation inference. Review their parallel settings before launching a job; the defaults assume the multi-A800 setup described above.

Wan Animate 2 with Diffusers

Until support reaches the next packaged release identified by the project, the official instructions install Diffusers from source:

pip install git+https://github.com/huggingface/diffusers.git
pip install flash-attn --no-build-isolation

A minimal Base pipeline follows this pattern:

import torch
from diffusers import WanAnimate2Pipeline
from diffusers.utils import export_to_video, load_image

pipe = WanAnimate2Pipeline.from_pretrained(
    "Wan-AI/Wan2.2-Animate-2-14B-Diffusers",
    torch_dtype=torch.bfloat16,
).to("cuda")

result = pipe(
    image=load_image("reference.png"),
    driving_video="driving.mp4",
    prompt=(
        "Subject appearance: a small wooden courier with a teal vest, "
        "cream shirt, coral shoes, and a paper cap. "
        "Background: a simple navy theater stage. "
        "Viewpoint: front three-quarter view, slightly low camera."
    ),
    height=800,
    width=640,
    num_inference_steps=40,
)

export_to_video(result.frames[0], "wan-animate-2-output.mp4", fps=24)

For the Distilled package, start with the published configuration:

pipe = WanAnimate2Pipeline.from_pretrained(
    "Wan-AI/Wan2.2-Animate-2-14B-Distilled-Diffusers",
    torch_dtype=torch.bfloat16,
).to("cuda")

result = pipe(
    image=load_image("reference.png"),
    driving_video="driving.mp4",
    prompt=prompt,
    num_inference_steps=10,
    guidance_scale=1.0,
    flow_solver="euler",
)

The examples are starting points, not deployment code. A service also needs input validation, video decoding limits, timeouts, queue control, model warm-up, output storage, and failure handling.

Wan Animate 2 ComfyUI workflow

ComfyUI is the more approachable option for creators who want to inspect and change the pipeline visually. The new integration is built around WanAnimate2ToVideo, while WanAnimate2Cache can exchange additional system-memory use for faster repeated computation. ComfyUI describes the cache as capable of roughly halving generation time in its launch material, but the actual gain depends on the graph, hardware, resolution, and clip length.

Step-by-step setup

1. Update ComfyUI. Use a version that includes the Wan Animate 2 nodes. If the template opens with missing core nodes, your stable or Desktop build may be behind the required release.
2. Load the Wan Animate 2 workflow. Start with the official template or the published ComfyUI workflow instead of rebuilding the graph from memory.
3. Resolve model downloads. Confirm that every loader points to Wan Animate 2 assets. An older Wan2.2 Animate checkpoint is not interchangeable with the new Animate 2 model.
4. Upload the reference image. Prefer a single, unobstructed subject with details that remain readable after resizing.
5. Load the driving video. Trim it before generation. A five-second motion test is easier to diagnose than a long mixed-action clip.
6. Write the appearance caption. Describe visible subject and background traits. Add a concise camera-view instruction if you want a viewpoint different from the driver.
7. Choose Base or Distilled. Use Distilled for the first compatibility and motion tests; switch to Base when the workflow is stable and you need to compare final quality.
8. Set conservative dimensions. Start around 480p and keep width and height compatible with the workflow's latent requirements.
9. Enable cache only after a clean baseline. This makes it easier to tell whether a memory or output issue comes from the core workflow or the optimization.
10. Queue one short generation. Inspect identity, hands, occlusion, motion timing, viewpoint, and first-to-last-frame stability before increasing resolution or duration.

Do not mix the old and new ComfyUI workflows

The older Wan2.2 Animate workflow uses nodes such as WanAnimateToVideo and may preprocess DWPose, face, mask, and background inputs for Move or Mix modes. The Wan Animate 2 workflow uses the new WanAnimate2ToVideo path and direct driving-video conditioning.

If a tutorial asks you to download the original wan2.2_animate_14B_bf16.safetensors, clip_vision_h, a pose estimator, and Mix-mode masks, it is probably describing the earlier model. That tutorial may still be useful, but it is not a Wan Animate 2 installation guide.

Recommended starting settings

These settings mirror the official examples where possible. They are not a claim that every local ComfyUI package exposes the same controls or that 480p fits every GPU.

Prompting guide

The official repository recommends generating an objective image caption with an LLM. Its example uses a strict Chinese structure: subject appearance first, then background, with no action description, subjective judgment, or inferred emotion.

A language-neutral template is:

Subject appearance: [species or person, face, hair, body proportions,
clothing, colors, materials, accessories].
Background: [location, major objects, lighting, dominant colors].
Viewpoint: [front, profile, rear, three-quarter, high, low, close, wide].

Better prompt

Subject appearance: a stylized wooden courier with a round carved face,
short dark hair, a cream paper cap, teal vest, ivory shirt, and coral shoes.
Background: a simple miniature theater with a muted navy curtain and warm
gold stage light. Viewpoint: front three-quarter full-body view, slightly low.

Weaker prompt

A happy courier runs dramatically, waves at the camera, jumps over a box,
and looks excited in a beautiful cinematic scene.

The weaker version duplicates motion instructions already present in the driving video and adds subjective language. If an English caption underperforms, test the repository's recommended Chinese caption structure before concluding that the model cannot preserve the character.

Strengths and limitations

Where Wan Animate 2 looks strongest

• Motion transfer without reducing the driving performance to an intermediate pose sequence.
• Reference-based identity and style preservation.
• A camera viewpoint that can differ from the driving video.
• Base and lower-step Distilled options for quality/speed testing.
• Official repository, Diffusers, Gradio, and ComfyUI paths.
• Apache 2.0 repository license and published weights.

What still needs careful testing

• Heavy official multi-GPU requirements for 480p and 720p configurations.
• Fast action, severe motion blur, occlusion, hands, and body rotation.
• Long clips and shot-to-shot identity continuity.
• Large camera changes that require inventing unseen character details.
• Multi-character scenes and interactions with objects.
• Quality differences between Base, Distilled, FP8, and community quantized versions.
• The release timing and real-world latency of Wan-Animate-2-Lite.

Early social comparisons are mixed. Some creators report impressive motion and viewpoint control; others prefer earlier systems for particular fast-motion or video-to-video examples. A community discussion and an early comparison video are useful for identifying tests, but they do not publish every attempt, exact settings, source-media rights, or cost per accepted clip. Treat them as hypotheses rather than a leaderboard.

Wan Animate 2 vs Wan2.2 Animate

Choose the older workflow when you specifically need its documented Move/Mix replacement process or already have a stable production graph. Evaluate Wan Animate 2 when direct motion fidelity, identity, or independent viewpoint control is more important.

Best use cases

Wan Animate 2 is a promising fit for:

• stylized characters animated from an actor's performance;
• virtual presenters and avatar prototypes;
• advertising mascots and branded characters;
• previz for camera alternatives using one driving take;
• short social clips and narrative inserts;
• game, animation, and film concept development;
• research into streaming animation when Lite becomes reproducibly available.

It is a weaker first choice for long uninterrupted scenes, exact product demonstrations, crowded multi-character action, or live streaming today unless your own tests prove the necessary consistency and latency.

License and commercial use

The Wan-Animate-2 repository is licensed under Apache 2.0. That generally permits use, modification, and distribution, including commercial use, subject to the license conditions.

The repository license is only one part of a commercial review. Teams must also have rights to the reference image, driving performance, likeness, clothing, music, and any background assets. Do not animate a real person's identity or performance without appropriate consent. Keep the relevant license and attribution notices when redistributing code or modified packages.

Where to access Wan Animate 2

Use these primary resources:

• Wan-Animate-2 official GitHub repository
• Official 14B model package
• Base Diffusers package
• Distilled Diffusers package
• Official ComfyUI workflow

Poyo.ai currently has an existing Wan Animate API with separate move and replace routes. That listing refers to the earlier production model, not the new Wan Animate 2 checkpoint described in this guide. This article does not claim that Wan Animate 2 is currently available through the Poyo.ai API.

Final verdict

Wan Animate 2 makes two meaningful architectural bets: use the driving video directly, and let text control a camera viewpoint that can differ from the source. Together, those changes target two persistent problems in character animation—lost motion detail and a camera locked to the performer recording.

The Base and Distilled releases make the system testable today through the official code, Diffusers, and ComfyUI. The practical constraints are equally clear: the official hardware setup is large, the model is new, Lite availability is not yet settled, and difficult motion still needs controlled evaluation.

Start with a short 480p Distilled run, keep the appearance caption objective, change one variable at a time, and compare outputs by usable frames rather than launch-demo impact. That process will tell you more than any universal “best character animation model” claim.

FAQ

Is Wan Animate 2 the same as Wan2.2 Animate?

No. Wan Animate 2 uses a redesigned end-to-end architecture that consumes the driving video directly and adds text-driven viewpoint control. The checkpoint name still contains Wan2.2, which causes search and tutorial confusion.

Is Wan Animate 2 open source?

The official repository and released weights are public, and the repository is licensed under Apache 2.0. Review the license and model files for your exact distribution or commercial use case.

Which Wan Animate 2 models can I download?

The August 7 release includes Base and Distillation weights. Diffusers packages exist for both. Wan-Animate-2-Lite was announced but was not listed among the initial public weight releases.

What is the difference between Base and Distilled?

The official Diffusers examples use 40 steps for Base and 10 steps for Distilled. Distilled also uses guidance scale 1.0 and the Euler flow solver. Start with Distilled for iteration and compare Base on the same inputs for final quality.

Can Wan Animate 2 run in ComfyUI?

Yes. Use an updated ComfyUI build and the Wan Animate 2 workflow based on WanAnimate2ToVideo. Do not confuse it with the older Wan2.2 Animate graph based on WanAnimateToVideo.

What GPU do I need for Wan Animate 2?

The official repository is tuned for 720p on 8× A800 GPUs and reports testing 480p on 2× A800 GPUs. Other hardware may work with offloading or optimized weights, but no single consumer-GPU minimum is established by those official numbers.

Does Wan Animate 2 support real-time animation?

The team says Wan-Animate-2-Lite reaches real-time thresholds for streaming, but the initial release notes do not list Lite weights. Wait for a reproducible public package and test the complete latency path before planning a live product.

Can the output camera differ from the driving video?

Yes. Text-driven viewpoint control is one of the model's central features. Large changes may require the model to generate unseen details, so check character and costume consistency carefully.

Should the prompt describe the action?

Usually no. Let the driving video specify action. The official workflow recommends an objective description of character appearance and background, without action or inferred emotion. Add a concise viewpoint instruction when needed.

Does Poyo.ai offer the new Wan Animate 2 API?

Not at the time of this status check. Poyo.ai's current Wan Animate listing is the earlier move/replace API. Use the official repository, Diffusers packages, or ComfyUI workflow for the new Wan Animate 2 release.