MotionBricks by NVIDIA: Real-Time AI Animation Without State Machines (2026 Setup Guide)

Traditional 3D character animation is a nightmare of state machines. A single character in a modern game can have over 5,000 nested animation states for walking, running, crouching, jumping, transitioning, and interacting with objects. Wiring these together manually takes weeks of technical animator time, and the result is brittle: one wrong transition and your character's limbs clip through the floor.

MotionBricks, developed by NVIDIA Research, eliminates the entire animation graph. Instead of manually wiring fragmented animations, it replaces the system with a single latent generative neural model trained on over 350,000 motion clips. You feed it directional inputs or style requests, and it generates natural, continuous motion in real time at 15,000 frames per second with 2ms latency.

In this guide, you'll learn what MotionBricks is, who it's for, and how to install and run it from NVIDIA's GR00T-WholeBodyControl repository.

What is MotionBricks?

MotionBricks is a real-time AI motion generation framework developed by NVIDIA Research. It aims to completely eliminate one of the most painful aspects of 3D game development and robotics: the traditional animation state machine (or animation graph). Instead of developers manually wiring together thousands of fragmented animations for walking, running, transitioning, and jumping, MotionBricks replaces the entire system with a single latent generative neural model.

Shipping as a subproject within NVIDIA's GR00T-WholeBodyControl repository, MotionBricks has been trained on a massive dataset of over 350,000 motion clips. By utilizing an interface called "Smart Primitives," it allows you to control a character (or a physical robot) simply by feeding it directional inputs or style requests. The neural backbone instantly calculates the precise timing, root trajectory, and pose tokens required to make the movement look perfectly natural and continuous.

Whether a character needs to smoothly transition from a jog to a "zombie walk," strafe while crouching, or dynamically vault over a bench, MotionBricks generates the frames in real time, handling both locomotion and complex object interactions autonomously.

Who is it for?

Game developers and technical animators looking to eliminate the nightmare of managing massive, brittle animation blueprints (which often contain over 5,000 nested states) in engines like Unreal Engine 5.
Robotics engineers building control systems for advanced humanoid robots (like the Unitree G1) who need robust, whole-body controllers that adapt to complex physical environments dynamically.
AI researchers experimenting with real-time latent diffusion and VQ-VAE models applied to skeletal kinematics and in-betweening.
Virtual production studios needing rapid, highly adaptable motion generation for digital avatars without spending weeks scheduling and cleaning up motion-capture sessions.

What makes MotionBricks different from traditional animation systems?

The death of the animation graph: New behaviors and transitions compose seamlessly in zero-shot. You do not need to fine-tune the model or add task-specific tags to combine a "limping" style with a "running" command. The neural model handles it automatically.
Blistering speed: AI generation is usually slow, but MotionBricks is highly optimized. The neural network achieves a real-time throughput of 15,000 frames per second with a latency of just 2ms, making it perfectly suited for high-fidelity 60fps+ video games.
Sim2Real robotics: It bridges the gap between virtual character animation and physical robot control. NVIDIA actively deploys the exact same MotionBricks framework on physical humanoid robots to handle real-world physical AI interactions.
Smart objects: It doesn't just handle walking. The Smart Object primitives allow the AI to dynamically align hands, limbs, and body weight to interact with scene props naturally, like picking up a sword or opening a door, without clipping.
Free and open source: The entire framework is available as open source research code from NVIDIA. No commercial licensing fees, no per-seat pricing, no proprietary lock-in.

What you need before you start

Because MotionBricks is an advanced research framework embedded in a robotics monorepo, you need a capable AI development environment:

Linux (or Windows with WSL2): Strongly recommended, as this is the standard for NVIDIA robotics and MuJoCo simulation stacks.
Python 3.10+ and Conda: Essential for managing the isolated environment dependencies.
A modern NVIDIA GPU: You need a CUDA-capable GPU (RTX 30-series or higher) to run the neural inference at real-time speeds.
Git LFS (Large File Storage): Mandatory. The pretrained checkpoints and mesh assets weigh over 2.2 GB. Standard Git will not download them correctly.

Step-by-step installation

Step 1: Install Git LFS

Before doing anything, ensure Git LFS is installed on your system. If you skip this, you will download tiny 1KB text files instead of the actual AI models, and the code will crash silently.

sudo apt install git-lfs
git lfs install

Step 2: Clone the repository and fetch checkpoints

MotionBricks lives inside the GR00T-WholeBodyControl repository. Clone it to your machine:

git clone https://github.com/NVlabs/GR00T-WholeBodyControl.git
cd GR00T-WholeBodyControl

By default, the massive MotionBricks checkpoints are excluded to save space for general GR00T users. You must fetch them explicitly from the repo root:

git lfs pull --include="motionbricks/out/**" --exclude=""
git lfs pull --include="motionbricks/assets/skeletons/g1/meshes/**" --exclude=""

Step 3: Create the Conda environment

Navigate into the MotionBricks subfolder and create a dedicated Python environment:

cd motionbricks
conda create -n motionbricks python=3.10 -y
conda activate motionbricks

Step 4: Install dependencies

Install the required Python packages in editable mode:

pip install -e .

Note for Linux users: If you plan to run the interactive MuJoCo demo and use your keyboard to control the character, you must also install the input hooks:

pip install pynput python-xlib

You can now run the included interactive demo scripts to watch the neural model generate movements live based on your inputs.

Common errors and how to fix them

Error	What it means	How to fix it
Serialization errors or `.ckpt` files failing to load	You did not successfully pull the large files using Git LFS. You currently have 1KB pointer files in your `out/` directory instead of the 2.2GB model weights.	Navigate to the root of the `GR00T-WholeBodyControl` folder (not the `motionbricks` subfolder) and re-run the specific `git lfs pull` commands provided in Step 2.
Keyboard inputs ignored in MuJoCo viewer	On Linux, MuJoCo sometimes struggles to capture keystrokes from the X11 display server natively.	Ensure you have installed the required workaround libraries by running `pip install pynput python-xlib` while your conda environment is active.
CUDA Out of Memory (OOM) or massive FPS drops	Your GPU lacks the VRAM or Tensor Core throughput to handle the neural inference pipeline alongside the physics simulation.	Ensure no other heavy AI workloads are running in the background. If you are trying to spawn multiple characters in the demo, reduce the actor count to 1 to stay within your hardware limits.

MotionBricks vs traditional animation systems

Feature	MotionBricks (NVIDIA Research)	Traditional mo-cap / state machines
Cost	$0 (open source research code)	Thousands in hardware and animator salaries
Animation state machines	None (managed dynamically by AI)	Extremely heavy (often 5,000+ nested states)
Robotics integration	Yes (direct Sim2Real deployment)	No (strictly visual/kinematic)
Production readiness	Experimental preview	Industry standard
Best for	Prototyping, research, robotics	Shipping games with proven pipelines

Bottom line: MotionBricks provides a glimpse into the inevitable future of video game development and robotics. Hand-authoring thousands of animation transition states is inefficient and expensive. By utilizing a real-time generative backbone, NVIDIA allows developers to prototype fluid, complex, responsive characters instantly. While it is currently in an early research preview stage and not ready for production game shipping, it is an essential technology for technical artists and robotics engineers to start experimenting with today.

3 alternatives worth checking out

Motorica (MoGen) (motorica.ai): A commercial AI animation platform that generates incredibly high-quality character locomotion and movement. It provides excellent, polished plugins for Unreal Engine and Maya. If you are a game developer who wants AI-generated movement without the heavy technical setup of running your own Python neural backbones, Motorica is a fantastic choice.
Cascadeur (cascadeur.com): A highly popular AI-assisted 3D keyframe animation software. While MotionBricks generates continuous motion from a latent space autonomously, Cascadeur uses AI to help you manually keyframe poses by automatically predicting physically accurate follow-throughs, secondary motions, and centers of mass.
NVIDIA Kimodo (github.com/nv-tlabs/kimodo): Another powerful generative motion tool from NVIDIA, operating within the same ecosystem. While MotionBricks focuses on real-time interactive control (responding to joystick or directional inputs dynamically), Kimodo is a text-to-motion diffusion model. It generates complete, standalone 3D animations based purely on natural language prompts.

Found this guide useful? Check out more open source projects and free tools for developers on Sudo Scout.