Introduction

NVIDIA has split MotionBricks into its own open repo and shipped a pretrained model for human characters, so game developers can now run its real-time motion generator on a standard humanoid skeleton instead of only a Unitree G1 robot. The

and the NVIDIA developer blog post went out on October 27. The update adds new SOMA human-motion models, downloadable checkpoints, ONNX exports and export tools, and an interactive reference app built on Newton. The code lives at NVlabs/motionbricks (software v0.2.0), and the weights are on Hugging Face.

We first covered MotionBricks as a research result in August. At that point the only public release was a G1 robot preview tucked inside GR00T Whole-Body Control. Now there's a human model and a runtime you can clone and play with.

What shipped

  • Model: MotionBricks-SOMA-RP-v1 (human) and MotionBricks-G1-RP-v1 (robot)
  • Vendor: NVIDIA (NVlabs, SIGGRAPH 2026 paper)
  • Modality: real-time skeletal motion generation. You give it recent poses plus target poses, and it outputs the movement between them.
  • Open vs API: open weights under the NVIDIA Open Model Agreement, which allows commercial use and redistribution of modified models under its terms. The code is Apache 2.0.
  • Where to run it today: locally on an NVIDIA GPU. The TensorRT runtime was tested on Windows and Linux x86-64 with an RTX 4090.
  • Skeleton: 30-joint SOMA body, trained on Bones RigPlay 1 motion data, at 30 FPS
  • Concrete fact: each generation fills in about 0.6 to 1.9 seconds of motion from the 4 most recent poses and 1 to 4 target poses. The model decides how long the transition takes.

How it works

Three small networks do the work. A root module predicts the path and duration. A masked token transformer predicts motion tokens along that path. A VQ-VAE decoder turns those tokens into continuous motion that hits your targets. For longer motion, the runtime chains generations: it plays what it generated, records it, and feeds the last four poses back in as the next context.

The part that matters for games is Smart Primitives. A primitive is just a set of target poses placed around an object, like a vault over a crate or sitting on a bench. Drop it in a scene and the same model handles the action, with no retraining and no hand-built animation graph. The Scene Preview demo walks and runs, strafes, crouches, vaults, ducks and sits, and offers six walk styles, Skipping and Zombie among them. NVIDIA says it's a distilled Python version of the Unreal Engine demo behind the paper's videos.

Try it

The apps use the ONNX models bundled in the repo, so you don't need to download checkpoints to see it move. The first launch builds a TensorRT plan and takes a few minutes. After that it's cached.

git clone https://github.com/NVlabs/motionbricks
cd motionbricks
git lfs pull
uv sync

# Place poses and generate motion between them
uv run python -m app.inbetweener_demo

# Drive a human character through the gym scene
uv run python -m app.scene_preview --scene assets/scenes/soma_gym.scene.json

# Author your own interactions
uv run python -m app.smart_primitive_editor
uv run python -m app.scene_editor

If you want to build your own runtime, or bring it into an engine through ONNX, grab the weights and export them:

hf download nvidia/MotionBricks --include "soma/*" --local-dir checkpoints/MotionBricks
uv run --locked --project tools/onnx motionbricks-onnx --model soma --checkpoints checkpoints/MotionBricks/soma --precision fp16

Things to watch

  • License split. The weights are commercial-friendly, but the bundled Bones-derived sample motion clips use an evaluation-only license. Don't ship those clips in a game.
  • NVIDIA GPU required. The demo runtime uses TensorRT. ONNX exports are your route to other runtimes, but you'll need to build and test that path yourself.
  • No training pipeline. You get inference weights and configs, not the training code or full dataset.
  • SOMA skeleton. You'll need to retarget to your own rig. NVIDIA's SOMA tooling and retargeter are the intended path.

Why it matters for game devs

Locomotion and interaction blending still eat a big share of animation budgets. MotionBricks swaps "author every transition" for "place target poses and let the model connect them" at interactive rates, and it does it with permissive weights you can actually ship. It also fits the rest of NVIDIA's character stack from the same post: on-device NPC brains through ACE and Nemotron 3.5 Bolt E4B, now with an open body that can move on its own.

—Titus