Animation Is Moving From Clips to Motion Priors

Character animation has traditionally been built from authored motion. An animator creates keyframes, a studio captures motion, or a controller blends between clips according to gameplay state.

That model is starting to change.

At SIGGRAPH 2026, NVIDIA introduced MotionBricks, a real-time generative motion system trained on roughly 700 hours of motion capture across about 350,000 clips and 9,300 skills. The model can connect movements, adapt locomotion styles, follow trajectories and handle object interactions at interactive rates. ARDY, another NVIDIA research project shown this year, generates motion continuously from text and sparse kinematic constraints while remaining responsive to changing input.

I think character animation is moving from selecting stored motion toward sampling from a learned motion prior.

The rig is not disappearing. Keyframes are not disappearing either. What changes is where plausible motion comes from between the constraints we choose to author.

Clips encode examples. A motion model encodes a distribution.

Traditional animation systems are explicit.

A walk cycle contains one walk. A motion-matching database contains many recorded fragments and searches for the fragment that best fits the current state. Blend trees combine predefined motions according to parameters such as speed and direction.

These systems work because the data is concrete. Animators can inspect every clip, edit it and know exactly what will play.

Their limitation is coverage.

Every transition, speed, turn angle, interaction height or unusual body configuration expands the space the authored dataset has to represent. Production teams solve this with more capture, more blending logic and increasingly large motion libraries.

A learned motion model changes the representation. Instead of asking which stored clip should play next, it learns patterns across many examples and can synthesise a motion that satisfies the current constraints.

MotionBricks is built around that idea. Its training dataset spans locomotion, combat, sports and object interaction. Rather than requiring task-specific labels for every downstream control mode, the system can apply constraints at runtime and use the learned motion distribution to fill in a valid movement.

That turns the dataset from a library into a prior.

Control is the difference between animation research and production animation

Generating plausible movement is not enough for games or production.

A character has to reach a specific point, face the right direction, place a hand on an object, hit a gameplay timing window or preserve an authored pose.

This is why the interesting part of MotionBricks is not free-form generation. It is constraint handling.

The system separates root trajectory from pose generation and lets downstream controls steer the motion at runtime. Its smart-locomotion layer can adapt movement to heading and velocity commands while preserving style. Its object-interaction system can connect the character to scene targets without retraining the model for each task.

ARDY attacks a related problem from a diffusion-model direction. It supports streaming text input, root paths, waypoints, full-body keyframes and sparse joint constraints while generating motion online.

The pattern is clear: production motion models are being designed around constraints, not prompts alone.

For me, that is the point where generative animation becomes useful.

An animator should not have to ask a model for "a realistic jump" and accept whatever it invents. The useful system is one where the animator defines what must happen, then lets the model solve the motion space between those decisions.

Keyframes become constraints instead of complete descriptions

This changes how I think about keyframing.

In a normal animation workflow, keyframes describe the motion itself. More keys usually mean more direct control over the final movement.

In a generative motion workflow, a keyframe can become a boundary condition.

The artist may define the starting pose, the contact pose and the landing position. The model generates a physically and stylistically plausible path between them. Another constraint can pin a hand to an object, preserve a root trajectory or force the character through a timing beat.

The rig remains the production contract

I do not expect skeletons and rigs to disappear.

In fact, learned animation makes a stable rig more valuable.

The model needs a structured representation of the body: joints, root motion, rotations, contacts and constraints. Downstream systems still need collision, gameplay events, retargeting and animation layers to operate on known transforms.

Kimodo, NVIDIA's larger offline motion-generation model, works directly with skeleton motion and supports full-body keyframes, end-effector constraints and root paths. Motion can be exported for downstream animation or robotics systems. MotionBricks and ARDY continue using structured skeletal representations for real-time control.

This is a useful contrast with generated video.

A video model can make a person appear to perform an action, but the result is pixels. A motion model produces state that a game engine or DCC tool can manipulate.

For production, that difference is enormous.

Motion generation and robotics are converging

One reason this research is moving quickly is that character animation and humanoid robotics now share much of the same data problem.

Both need plausible human motion. Both need control under constraints. Both need retargeting between bodies. Both benefit from large motion datasets.

MotionBricks is evaluated across animation and robotics settings. ARDY can drive humanoid motion generation. Kimodo can generate demonstration data for robot policies. NVIDIA's wider motion research stack connects motion generation, retargeting and physically simulated control.

What this changes in Blender and game production

For Blender, I would treat a motion model as another animation layer rather than a replacement for the animation system.

A useful workflow could begin with rigged characters, authored scene constraints and a small number of key poses. The model generates a motion candidate. The animator edits timing, corrects contacts and keeps the parts that support the shot.

For games, the opportunity is larger because the required motion space is open-ended.

Instead of capturing every turn angle and every transition, a learned model could generate motion that responds continuously to gameplay state. Designers still define gameplay constraints. The engine still owns collision and authoritative state. The motion model provides a richer layer between high-level intent and skeletal pose.

I would keep deterministic fallbacks for cases where animation must reproduce exactly. Competitive actions, networked events and authored cinematics may still need tighter control than a generative system should own.

The right boundary will depend on the game.

The production problem moves from authoring every motion to authoring the space of allowed motion

This may be the larger shift.

Traditional animation production asks: which motions do we need to create?

A learned-motion pipeline asks a different question: what constraints define acceptable motion for this character?

That includes style, contact rules, locomotion limits, timing, interaction targets and poses that must remain authored.

The motion model then fills a much larger region between those constraints.

This is a different technical-art problem. Dataset quality matters. Rig consistency matters. Constraint interfaces matter. Evaluation becomes less about whether one generated clip looks good and more about whether the system stays controllable across thousands of runtime situations.

My prediction

I think animation systems will gradually move from clip libraries toward hybrid motion priors.

Clips will remain useful for exact authored actions. Keyframes will remain the right tool when an artist needs a specific pose at a specific frame. Motion matching will remain efficient for many game workloads.

But learned motion models can cover the space between those assets.

As datasets scale and real-time generation becomes more controllable, I expect engines and DCC tools to treat motion models as another runtime primitive: give the system a rig, constraints and intent, then request a plausible motion that satisfies them.

The model should not decide what the character is meant to do.

It should solve more of how the body gets there.

That is the part of animation I expect to become increasingly learned.

Sources

1. NVIDIA Research, MotionBricks: Scalable Real-Time Motions with Modular Latent Generative Model and Smart Primitives, SIGGRAPH 2026.
2. NVIDIA, At SIGGRAPH, NVIDIA Advances Graphics and Simulation With Agentic and Physical AI, July 2026.
3. NVIDIA Research, ARDY: Autoregressive Diffusion with Hybrid Representation for Interactive Human Motion Generation, SIGGRAPH 2026.
4. NVIDIA Research, Kimodo: Scaling Controllable Human Motion Generation, 2026.