---
title: Viggle-Animate
emoji: 🕺
colorFrom: indigo
colorTo: purple
sdk: gradio
sdk_version: 5.50.0
python_version: "3.10"
app_file: app.py
hf_oauth: true
pinned: false
models:
  - Viggle/Viggle-Animate
short_description: Put the person from a still into a driving video, in 4 steps
---

Upload a driving video and a character still. The clip's first frame is repainted with
gpt-image-2 so it shows your character in that exact pose and framing, and that repainted
frame is the only conditioning the model gets besides the clip itself — no pose estimation,
no segmentation, no masks.

Takes 4–10 s of driving video and renders it at 4 sampling steps; anything longer is cut to
10.1 s. The model itself only renders frame counts of the form 17k+5 and never fewer than 124
(5.17 s), so shorter clips are held out to 124 frames with a frozen last frame and the render
is trimmed back — what comes out is exactly as long as what went in.

Weights: [`Viggle/Viggle-Animate`](https://huggingface.co/Viggle/Viggle-Animate).

**No sign-in.** The GPU comes out of your own ZeroGPU quota, and the render asks for more of
it than a free account's day holds — in practice rendering needs PRO. The repaint calls an
image model this Space pays for, on the CPU, before any GPU is involved, and is limited to
five a day per visitor. The finished examples at the bottom of the page need neither, and
are there so the model can be judged for free.

**Hardware.** The transformer is 62 GiB in bf16; with the VAEs that is 73.5 GiB on the card.
ZeroGPU `xlarge` (96 GB) is required — `large` is 48 GB and cannot hold it. `xlarge` bills at
2× the normal quota rate, so a free account's day does not go far here; PRO gets 40 min.

The weights stay on the CPU at startup. Pre-staging them through ZeroGPU's tensor pack was
tried and cannot fit: the pack plus the source weights need ~159 GB on disk at once, and the
container enforces a write quota that `df` does not show — the pack's `fallocate` dies with
ENOSPC while the boot log prints over a terabyte free. The cost is one host-to-device copy on
the first render a cold worker handles (measured 14 s, from warm page cache); queued renders
after it skip the copy. What did land instead: the decode step quantizes to uint8 on the card
rather than walking the clip to fp32 numpy on the CPU (bit-identical frames, several seconds
of GPU time saved), the frame count rides along from `prepare` instead of being re-counted in
the billed window, and trimming plus watermarking run in the parent process after the GPU
window closes.

When AOT-compiled copies of the transformer's two repeated block classes exist in the weights
repo (`<ClassName>/package.pt2`, built once on this hardware from an owner-only maintenance
button), they are downloaded at boot and swapped in after the weights reach the card; without
them the Space renders the same model eagerly.