REALMIMIC

// open-source reproduction of SuperMimic

realmimic

A whole-body motion tracker for the Unitree G1, trained on one RTX 4090 (24 GB) in 10.5 hours, and run through NVIDIA's SONIC deploy runtime.

Code Weights SuperMimic paper

Kevin Henry · independent and unofficial.
Not affiliated with the SuperMimic authors, UC Berkeley, NVIDIA, Bones Studio or Unitree.
Built on YanYuan98/Supermimic_mod and CuboiLeo/SuperMimic-Reproduced.

Recorded · released policy

Motion Data by Bones Studio · rendered in this scene

Booting simulation0 %

    Everything runs in your browser: no server; the physics and the policy run on your CPU.

    Same policy on every robot.

    Push force
    0 N
    Push test
    m/s
    World model
    -- cm apart now
    -- cm apart after 0.64 s
    Average distance between the blue robot's body parts and the solid robot's. Every 0.64 s (the length of the training rollouts, vertical lines) the blue robot is reset to the solid one.
    Physics simulator (MuJoCo)

    Loading the world model…

    Target pose Policy

    In your browserThe released policy (16-bit weights) running in MuJoCo 3.16, compiled to WebAssembly, with the training physics settings. Nothing runs on a server.

    Try itDrag the robot or use the push test; the white outline is the target pose. It tracks body pose, not position, so it drifts slowly.

    World modelThe translucent blue robot is the learned model the policy was trained in, predicting the motion by itself; every 0.64 s it is reset to the simulated robot. Pushes and drags are outside its training data.

    Load your ownA BONES-SEED G1 CSV, a header-less G1 CSV at 30 fps or a realmimic .npz, with the rights to use it. It never leaves your browser.

    01What this is

    What this is not
    • Not the paper's numbers: everything here is our own evaluation unless it says otherwise.
    • Hardware: early supervised tests on a real G1 are under way. Deploy weights and hardware results will follow in v1.1.

    02Results

    We use the paper's benchmark (its Appendix F): every clip of the BONES-SEED dataset that passes the paper's filter, 129,491 clips, each played once from its first frame. A clip fails if the robot falls: pelvis height off by more than 0.25 m or its tilt by more than 0.8 (difference in the upward component of gravity in the pelvis frame) from the reference. Our policy and SONIC's released policy run in the same evaluator (MuJoCo Warp, mjlab), each with its own motor gains. The paper's figures come from its own evaluation and are quoted as reported.

    – – of – motions completed – failed · tracking score – (average normalised tracking reward; 1 = perfect) released model · one RTX 4090, 10.5 h
    – – of – completed – failed · SONIC release, the same evaluation for both
    – – of – completed – failed · SuperMimic paper, one H100 80 GB, 3 h, as reported (its own evaluation)

    Side by side with SONIC's released policy

    Same clip, same reference: ours on the left, SONIC's release on the right.

    realmimicon trackSONIC releaseon track
    A flip with a hero landing Ours completes it; SONIC's release falls at 1.4 s.
    realmimicon trackSONIC releaseon track
    A 360 flip Ours completes it; SONIC's release falls at 2.4 s.
    realmimicon trackSONIC releaseon track
    A vogue dance drop Ours completes it; SONIC's release falls at 4.7 s.
    realmimicon trackSONIC releaseon track
    A back-kick dance move Ours completes it; SONIC's release falls at 2.7 s.
    realmimicon trackSONIC releaseon track
    A high jump Ours completes it; SONIC's release falls at 2.2 s.
    realmimicon trackSONIC releaseon track
    A broad jump Ours completes it; SONIC's release falls at 4.4 s.

    Hardware: early supervised tests on a real G1 are under way. Deploy weights and hardware results will follow in v1.1.

    Training data includes Motion Data by Bones Studio (https://bones.studio/). Use of the underlying dataset is subject to the BONES Motion Capture Dataset License Agreement.

    All six clips are from BONES-SEED. The faint outline is the reference; the translucent blue robot on our side is the world model the policy was trained in, predicting the motion and reset to the simulated robot every 0.64 s, as in the live demo. The labels mark when a robot goes off track (the benchmark's failure) or falls.

    Full-benchmark results for every run

    None of these failures happens on a clip's last frame. Across the two seeds the final checkpoint fails 4 to 10 clips. Re-running one checkpoint with a different number of parallel simulations moves the failure count by about ±10 (at ~200 failures), so differences under 20 are within measurement noise.

    Training curve

    Full-set failures against training iterations, log scale, for the released model and a run with an alternative reward shape, with SONIC's release at 218 as a dashed line.
    Full-set failures against training hours on one RTX 4090, log scale, with SONIC's release at 218 and the paper's 25 at 3 hours on one H100 as reported.

    All 129,491 clips scored every 8,000 training iterations (on RTX 6000 Ada and RTX 5000 Ada GPUs). The paper's point is as reported, from its own evaluation.

    Failures by motion type

    Show the table

    The paper's Table A.8 groups, recovered from motion-category names; group sizes are ours.

    Motion it never saw (LAFAN1)

    Produced by scripts/eval_benchmark.py; figures by tools/web_figures.py.

    What we found

    Two problems in the open reimplementation we started from decide the result at full data scale; the paper specifies neither.

    1. Training rarely practised the hardest motions

    Flips still failing on the 130 hardest clips at 12k iterations; the two runs in each pair differ in the estimate alone.

    Training starts episodes in 1-second pieces of clips, preferring pieces it tracks badly. The inherited estimate of "badly" started every piece at the best possible score and moved 5 % per visit, so with ~1 million pieces the rare acrobatic ones kept looking easy, while every clip's last second looked hard. Flips and side rolls got half of a fair share of practice.

    Fix: a running mean that counts visits and assumes the worst for unvisited pieces, with a continuation value at clip ends. Effect: on the 130 hardest clips, all 54 flips and 22 side rolls are learned by 6k iterations; with the old estimate, 5 to 12 flips still failed at 12k.

    2. Nothing in the training objective covered the end of a clip

    End-of-clip failures on the full set against training iterations, log scale. Without the fix, one run goes from 1 at 24k to 2,802 at 40k and 4,417 at 48k, another reaches 1,907 at 32k. With the fix, 0 or 1 at every checkpoint.
    Failures on a clip's last frames, full set, against training iterations: two runs without the fix (A, B), one with it.

    The learned-model rollouts stopped 32 frames before the end, so long runs learned to fall on the final frame. That costs almost nothing in the score but counts as a failure: at 40k iterations one such run had 2,882 failures, 2,802 on the last frame, still rising (4,417 at 48k).

    Fix: past the end, the reference holds the last frame still and the rollouts run into it. The released model has no last-frame failures.

    What did not matter measurably

    03Deployment, in simulation

    Before a policy touches a robot, we run it inside NVIDIA SONIC's actual deploy program, the binary that runs on the G1, connected to a MuJoCo simulation of a G1 with BrainCo hands. Each session walks, turns, squats, kneels and stands up through SONIC's planner, with pushes, sensor errors and 10 to 20 ms command delays. Our released tracker is first fine-tuned for this robot. Means over five sessions:

    PolicyFallsJoint tracking error (rad)Body tilt error (rad)Ankle motor load (Nm)Waist motor load (Nm)
    SONIC's released policy00.0830.0524.483.31
    realmimic, fine-tuned for the robot00.0750.0083.322.86

    A second training seed gives no falls, 0.069 rad, 0.008 rad, 4.23 Nm and 3.34 Nm. Without the fine-tune, the released tracker falls once under command delay on this robot model. The fine-tune recipe comes with v1.1.

    Building the runtime and running these sessions: deploy/sonic/README.md.

    04Get started

    You need: Linux, an NVIDIA GPU with 24 GB (training; evaluation works on smaller GPUs), NVIDIA driver 580 or newer, about 170 GB of free disk for the data, uv, and a Hugging Face account.

    git clone https://github.com/kevinhenryzz/realmimic && cd realmimic
uv sync --group dev                 # Python 3.12 and every dependency, pinned by uv.lock
uv run hf auth login                # once; a read token from https://huggingface.co/settings/tokens
tools/download_data.sh              # BONES-SEED (accept its licence on Hugging Face first) and LAFAN1
tools/prepare_data.sh               # convert, filter, build the training library and the benchmark lists
uv run sm-train release             # train the released model's recipe (one RTX 4090, about 10.5 h)

    Use the released weights

    uv run hf download kevinhenryz/realmimic --local-dir weights
uv run python scripts/eval_benchmark.py --ckpt weights/realmimic_g1_86k.pt --npz-dir data/npz/bones_seed \
    --clip-list data/bench/full.txt --num-envs 4096 --chunk-size 8192 --out runs/benchmark/release_full.json

    More in the README: Quick start · Data · Train and evaluate · Deploy

    05Differences from the paper

    Show the table
    ItemPaperHereWhy
    Training GPUone H100 80 GB (SXM5)one RTX 4090 24 GBwhat this reproduction tests
    Policy batch4096 world-model rollouts2048fits the 4090's 24 GB next to the motion library
    Schedulethe paper's Table A.586k iterations, learning-rate decay over the first 69kone 4090 in 10.5 h
    Clips129,514129,491the same filter on the current BONES-SEED release
    Goal termsthe paper'sSONIC's goal termsso the policy runs in SONIC's runtime
    Practice samplingnot specifiedcount-aware estimate, pessimistic for unvisited piecessee What we found
    Clip endsnot specifiedlast frame held, rollouts reach itsee What we found
    World-model framenot specifiedbody frameno singularity; no measured effect
    Input scaling, fall detectionnot specifiedrunning input normalisation and LayerNorm; falls detected from the stateinherited from the reimplementation we started from
    Self-collision—onthe robot's limbs can collide with each other

    Motor gains. Training uses mjlab's default G1 model, with the hip-pitch motors (Unitree 7520-14) at stiffness kp ≈ 40, the low-gain setup the paper builds on; SONIC's runtime uses kp 99 on the same joints. The benchmark scores each policy under its own gains, as in the paper's Appendix F.1.

    Compute

    The released model trains on one RTX 4090 in 10.5 hours. Developing and checking it took more; measured GPU-hours (wall-clock hours × GPUs, from the training and evaluation logs):

    Show the table

    06Credits, licences, citation

    Cite

    @software{henry2026realmimic,
  author = {Henry, Kevin},
  title  = {realmimic: a single-GPU reproduction of SuperMimic with deployment in NVIDIA's SONIC runtime},
  year   = {2026},
  doi    = {10.5281/zenodo.23682224},
  url    = {https://github.com/kevinhenryzz/realmimic}
}

@article{liao2026supermimic,
  author  = {Liao, Qiayuan and Shao, Yiyang and Long, Junfeng and Zakka, Kevin and Horowitz, Roberto and Abbeel, Pieter and Sreenath, Koushil},
  title   = {SuperMimic: Scaling Humanoid Whole-Body Control with One Differentiable World Model},
  journal = {arXiv preprint arXiv:2610.28480},
  year    = {2026}
}