Wan 2.2 local: gere vídeos com IA no seu PC

👁 115 leituras

Wan 2.2 é um modelo de vídeo gratuito da Alibaba que pode ser executado no seu computador e usado comercialmente. Em 26 de setembro de 2026, gerei quatro vídeos de 5 segundos em 720p com uma RTX 4090, usando o ComfyUI e a versão menor, TI2V 5B. Cada vídeo levou cerca de 4 minutos depois que o modelo foi carregado. A seguir, veja os quatro vídeos sem edição, os tempos, o uso de memória e os erros que dá para notar.

O que é o Wan 2.2 e qual versão roda no seu PC

Wan 2.2 é uma família de modelos abertos de vídeo da equipe Wan-AI, da Alibaba, distribuída sob a licença Apache 2.0. As versões maiores, com 14 bilhões de parâmetros, precisam de muito mais memória do que uma placa de vídeo para jogos costuma ter. A versão TI2V 5B tem 5 bilhões de parâmetros e gera vídeo a partir de texto ou de uma imagem inicial. Ela pode rodar em uma única placa de vídeo. Usei os arquivos prontos preparados pela equipe do ComfyUI:

• modelo wan2.2_ti2v_5B_fp16.safetensors - 10,0 GB,
• codificador de texto umt5_xxl_fp8_e4m3fn_scaled.safetensors - 6,7 GB,
• VAE wan2.2_vae.safetensors - 1,4 GB.

Os arquivos vão para as pastas models/diffusion_models, models/text_encoders e models/vae do ComfyUI. Veja no guia ComfyUI do zero como instalar o programa.

Compare geradores de vídeo: ranking de geradores de vídeo com IA, preços e teste em polonês · em polonês, sem assinatura: ZWID (meu serviço)

Configurações e medições

Cada vídeo foi gerado em 1280×704, com 121 quadros a 24 quadros por segundo (5,04 s), 20 etapas, CFG 5, sampler uni_pc e deslocamento 8. São as configurações do modelo oficial do ComfyUI para o Wan 2.2 5B. Equipamento: RTX 4090 de 24 GB, Windows 11 e ComfyUI 0.37.

O primeiro vídeo de cada sequência demora mais que o dobro porque o modelo é carregado do disco para a memória. Os seguintes levam cerca de 4 minutos. O pico de memória inclui aproximadamente 3,4 GB que já estavam ocupados pelo sistema e pelo navegador, então o Wan usou cerca de 20 GB. Em placas com 12 a 16 GB, o ComfyUI transfere parte do modelo para a RAM. Isso funciona, mas a geração demora mais. Não medi esse tempo.

Vídeos gerados: o que deu certo e o que não deu

1. Café sendo servido em uma xícara

2. Bondinho em uma rua chuvosa

3. Lhama em um campo na montanha

4. Animação 2D: trabalho noturno e um gato

O padrão é claro: quanto menos movimento e interação física, melhor. Cenas com câmera parada e movimento ao fundo, como chuva, bondinho e folhas, ficam convincentes. Ações precisas, como servir um líquido ou pedir um gesto específico de um animal, são simplificadas ou interpretadas de outro jeito pelo modelo.

Wan 2.2 local ou gerador de vídeo na nuvem?

Os preços dos geradores na nuvem mudam com frequência. Consulte a comparação atualizada no guia de geradores de vídeo com IA. Esta é minha opinião: o Wan 2.2 5B local vale a pena se você precisa de dezenas de cenas de trabalho, fundos ou materiais para edição, e não de um único vídeo de impacto.

Uma opção simples: Hangar

O Wan 2.2 TI2V 5B está no catálogo do Hangar, minha ferramenta: um gerenciador gratuito de modelos locais de imagem, vídeo e música para Windows, sem conta e com o ComfyUI funcionando nos bastidores. O pacote usa os mesmos três arquivos descritos acima, que somam 18,1 GB (modelo fp16 de 10,0 GB, codificador umT5 fp8 de 6,74 GB e VAE de 1,41 GB). Por enquanto, não há uma versão mais leve no catálogo. Em placas com 12 a 16 GB, o ComfyUI transfere parte dos pesos para a RAM, o que torna o processo mais lento. A licença Apache 2.0 permite usar os vídeos comercialmente, inclusive na União Europeia.

1. Baixe o instalador (14 MB) na página do Hangar. Ele ainda não tem assinatura digital, então o Windows SmartScreen mostrará um aviso: clique em “Mais informações” e depois em “Executar assim mesmo”.
2. O Hangar detecta a placa de vídeo (Nvidia com CUDA, a partir de 8 GB de VRAM; o recomendado é 12 GB ou mais) e informa se o modelo cabe nela.
3. Escolha Wan 2.2 TI2V 5B. O Hangar baixa os arquivos do Hugging Face e verifica seus hashes sha256.
4. Digite uma descrição da cena em inglês, escolha a duração em segundos e clique em gerar.

No teste do Hangar com uma RTX 4090, em 17 de outubro de 2026, um vídeo de 2 s em 1280×704 ficou pronto em 105 s, incluindo o carregamento do modelo. Instalador e informações: Hangar.

Script pronto: gere um vídeo com um comando

O script de instalação do guia do ComfyUI baixa os arquivos do modelo com a opção -Modele wan. Para gerar vídeos, preparei um script que envia o comando ao ComfyUI, espera os quadros e os reúne em um MP4 usando o ffmpeg. Você informa a duração em segundos, e o script calcula o número de quadros no formato exigido pelo Wan (4n+1). Testei o script em 26/09/2026 com um vídeo curto: 2 segundos, 640×352, 49 quadros e arquivo MP4 pronto.

• Baixe: generuj-wideo.py (6 KB) ou os cinco scripts em um arquivo ZIP (15 KB).
• Vídeo de 5 s em 720p: python generuj-wideo.py "a yellow tram passing a rainy street at dusk, static camera" (exemplo traduzido do comando de teste original em inglês)
• Prévia mais rápida: --sekundy 3 --szer 960 --wys 544 --kroki 12. Para criar o MP4, instale o ffmpeg (winget install Gyan.FFmpeg); sem ele, você terá arquivos PNG.

Leia qualquer script baixado da internet antes de executá-lo: ele usa as permissões da sua conta. Abaixo está o código completo, sem cortes, com comentários traduzidos do original em polonês. Os scripts usam a licença MIT: você pode modificá-los e usá-los também em uma empresa.

"""
generuj-wideo.py - vídeo com Wan 2.2 TI2V 5B pelo ComfyUI local
Autor: Piotr Olszewski. Licença do script: MIT. Testado em 26/09/2026: ComfyUI 0.37, RTX 4090.

Requisitos: ComfyUI em funcionamento (http://127.0.0.1:8188) com os arquivos do Wan 2.2 5B
(instaluj-comfyui.ps1 -Modele wan) e ffmpeg no PATH para criar o MP4 (winget install Gyan.FFmpeg).
Sem ffmpeg, você terá apenas os quadros PNG. Apenas a biblioteca padrão do Python 3.9 ou posterior.

Exemplos:
  python generuj-wideo.py "a yellow tram passing a rainy street at dusk, static camera, realistic"
  python generuj-wideo.py "flat 2D animation of a cat walking across a desk" --sekundy 3 --szer 960 --wys 544

Na RTX 4090: cerca de 4 minutos para 5 s em 1280x704 (o primeiro vídeo demora mais, pois carrega 18 GB do disco).
O modelo funciona melhor com câmera estática e movimento ao fundo; tem dificuldade com física precisa (líquidos e gestos).
"""
import argparse, json, os, random, shutil, subprocess, sys, tempfile, time, urllib.parse, urllib.request, uuid

FPS = 24
NEG = "blurry, distorted, low quality, jitter, watermark, text, subtitles, static image, deformed hands, extra limbs"


def graf(polecenie, szer, wys, klatki, kroki, seed, prefiks):
    # Equivalente ao modelo oficial do ComfyUI "Wan 2.2 5B text to video"
    return {
        "1": {"class_type": "UNETLoader", "inputs": {"unet_name": "wan2.2_ti2v_5B_fp16.safetensors", "weight_dtype": "default"}},
        "2": {"class_type": "CLIPLoader", "inputs": {"clip_name": "umt5_xxl_fp8_e4m3fn_scaled.safetensors", "type": "wan", "device": "default"}},
        "3": {"class_type": "VAELoader", "inputs": {"vae_name": "wan2.2_vae.safetensors"}},
        "4": {"class_type": "CLIPTextEncode", "inputs": {"clip": ["2", 0], "text": polecenie}},
        "5": {"class_type": "CLIPTextEncode", "inputs": {"clip": ["2", 0], "text": NEG}},
        "6": {"class_type": "ModelSamplingSD3", "inputs": {"model": ["1", 0], "shift": 8.0}},
        "7": {"class_type": "Wan22ImageToVideoLatent", "inputs": {"vae": ["3", 0], "width": szer, "height": wys, "length": klatki, "batch_size": 1}},
        "8": {"class_type": "KSampler", "inputs": {"model": ["6", 0], "seed": seed, "steps": kroki, "cfg": 5.0, "sampler_name": "uni_pc", "scheduler": "simple",
                                                    "positive": ["4", 0], "negative": ["5", 0], "latent_image": ["7", 0], "denoise": 1.0}},
        "9": {"class_type": "VAEDecode", "inputs": {"samples": ["8", 0], "vae": ["3", 0]}},
        "10": {"class_type": "SaveImage", "inputs": {"images": ["9", 0], "filename_prefix": prefiks}},
    }


def api(serwer, sciezka, dane=None):
    req = urllib.request.Request(serwer + sciezka, data=json.dumps(dane).encode() if dane is not None else None,
                                 headers={"Content-Type": "application/json"})
    return json.load(urllib.request.urlopen(req, timeout=60))


def main():
    a = argparse.ArgumentParser(description="Vídeo com Wan 2.2 5B pelo ComfyUI local")
    a.add_argument("polecenie", help="descrição da cena (de preferência em inglês, incluindo a câmera)")
    a.add_argument("--sekundy", type=float, default=5.0, help="duração do vídeo (padrão: 5 s)")
    a.add_argument("--szer", type=int, default=1280); a.add_argument("--wys", type=int, default=704)
    a.add_argument("--kroki", type=int, default=20)
    a.add_argument("--seed", type=int, default=None)
    a.add_argument("--serwer", default="http://127.0.0.1:8188")
    a.add_argument("--wyjscie", default="wideo")
    x = a.parse_args()
    if x.szer % 32 or x.wys % 32:
        a.error("largura e altura devem ser múltiplos de 32 (por exemplo, 1280x704 ou 960x544)")
    klatki = int(round(x.sekundy * FPS / 4)) * 4 + 1          # O Wan exige uma duração de 4n+1 quadros
    try:
        api(x.serwer, "/system_stats")
    except Exception as e:
        sys.exit(f"Não foi possível conectar ao ComfyUI em {x.serwer} ({e}). Inicie start-comfyui.bat.")
    seed = x.seed if x.seed is not None else random.randint(1, 2**31)
    prefiks = f"wan_{uuid.uuid4().hex[:8]}"
    print(f"Gerando {klatki} quadros ({klatki / FPS:.1f} s) em {x.szer}x{x.wys}, seed {seed}...")
    t0 = time.time()
    pid = api(x.serwer, "/prompt", {"prompt": graf(x.polecenie, x.szer, x.wys, klatki, x.kroki, seed, prefiks), "client_id": str(uuid.uuid4())})["prompt_id"]
    while True:
        h = api(x.serwer, f"/history/{pid}")
        if pid in h:
            break
        print(f"\r  processando... {time.time() - t0:.0f} s", end="", flush=True)
        time.sleep(2)
    print()
    wynik = h[pid]
    if wynik.get("status", {}).get("status_str") != "success":
        sys.exit("Erro do ComfyUI: " + json.dumps(wynik.get("status", {}), ensure_ascii=False)[:600])
    imgs = sorted([o for v in wynik["outputs"].values() for o in v.get("images", [])], key=lambda o: o["filename"])
    os.makedirs(x.wyjscie, exist_ok=True)
    tmp = tempfile.mkdtemp(prefix="wan_")
    for i, img in enumerate(imgs):
        q = urllib.parse.urlencode({"filename": img["filename"], "subfolder": img.get("subfolder", ""), "type": img.get("type", "output")})
        with urllib.request.urlopen(f"{x.serwer}/view?{q}", timeout=60) as r, open(os.path.join(tmp, f"{i:04d}.png"), "wb") as f:
            shutil.copyfileobj(r, f)
    czas = time.time() - t0
    nazwa = os.path.join(x.wyjscie, f"wan_{time.strftime('%Y%m%d_%H%M%S')}_{seed}")
    if shutil.which("ffmpeg"):
        subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-framerate", str(FPS), "-i", os.path.join(tmp, "%04d.png"),
                        "-c:v", "libx264", "-crf", "20", "-pix_fmt", "yuv420p", "-movflags", "+faststart", nazwa + ".mp4"], check=True)
        shutil.rmtree(tmp, ignore_errors=True)
        print(f"Pronto: {nazwa}.mp4 ({len(imgs)} quadros, {czas:.0f} s)")
    else:
        shutil.move(tmp, nazwa + "_klatki")
        print(f"Pronto: quadros PNG em {nazwa}_klatki ({czas:.0f} s). Instale ffmpeg para criar o MP4.")


if __name__ == "__main__":
    main()

Veja também: Wan AI: versões, preços e meus testes com vídeos · Wan 3.0 e Wan 2.2 com os mesmos comandos

perguntas frequentes

Qual placa de vídeo é necessária para usar o Wan 2.2?

No meu teste, o Wan 2.2 TI2V 5B usou cerca de 20 GB de memória da RTX 4090 ao gerar vídeos em 1280×704. Em placas com 12 a 16 GB, funciona mais devagar, usando também a RAM para parte do modelo. As versões maiores, 14B, exigem muito mais memória.

Quanto tempo leva para gerar um vídeo com o Wan 2.2?

Cerca de 4 minutos para um vídeo de 5 segundos em 720p (121 quadros e 20 etapas), usando uma RTX 4090 com o modelo já carregado. O primeiro vídeo demorou 574 s porque os arquivos, que ocupam 18 GB, precisaram ser carregados do disco.

O Wan 2.2 é gratuito? Posso usar comercialmente?

Sim. Os pesos estão no Hugging Face sob a licença Apache 2.0, que permite uso comercial. Há apenas o custo de eletricidade, que é baixo.

O Wan 2.2 gera vídeo com áudio?

Não. A versão 5B gera apenas imagem. Você precisa adicionar o áudio na edição.

// continue lendoVídeo estilo trailer de GTA 6 com IA: Wan 3.0, Seedance e MiniMaxBenchmarksGPT-6.1 Terra: qual nível de raciocínio escolher?BenchmarksGPT-6.1 Terra: teste de preenchimento de formuláriosBenchmarks