SuperMimic Reproduced in 1.5 GPU-Hours with AI-Assisted Code

Start with the boundary: this is not the authors' repository

SuperMimic Vibed is an unofficial reproduction. Its author, Chong Zhang, states that the project is not affiliated with or endorsed by the authors of SuperMimic: Scaling Humanoid Whole-Body Control with One Differentiable World Model. The target is the paper's controlled LAFAN1 comparison, and the repository independently reconstructs a full training path around that experiment.

The author also applies a warning to the repository itself: it was assembled in roughly one hour with an AI coding assistant, is described as fast and unreviewed, and should be used at the reader's risk. That does not make the implementation useless, but it changes how the evidence should be read. This page therefore separates what the source code verifies, what the author reports from a run, and what an outside reader still cannot check.

What the project does

The test uses a 29-DoF Unitree G1 and 40 LAFAN1 clips retargeted to that robot. The motion library contains 264,705 frames recorded at 30 fps, or about 2.45 hours of movement. The goal is not one controller per clip. A single policy is trained to track a sequence of future reference frames across dance, jumps, falls and get-ups, fighting, running, sprinting, and walking.

On one RTX PRO 6000 Blackwell, the author reports a normalized return of 0.824 with one failed clip after 1.24 training hours. At 1.47 hours, the run reached 0.829 with 0 of 40 clips failing. The README also cites the paper's result of 0.82 at 1.2 hours on an H100. Those figures share a rough time scale, not a controlled hardware comparison: the GPU models, software stack, implementation, and evaluation details differ. The repository does not establish a speed advantage over the paper.

A kit-less Isaac Lab and MuJoCo-Warp stack

The code targets a pinned Isaac Lab 3 main commit and runs in the kit-less container image. Physics comes from Newton with MuJoCo-Warp rather than Isaac Sim, Kit, or PhysX. Control runs at 50 Hz with four 5 ms substeps, an implicitfast integrator, and MuJoCo's contact pipeline. The solver permits 500 Jacobian rows and 128 contacts to reduce constraint overflow during falls.

G1 actuation follows BeyondMimic's model: a 10 Hz natural frequency, damping ratio 2, reflected motor armature, and an action scale of 0.25 * effort_limit / Kp. Self-collision is disabled. The feet and other collision shapes still interact with the ground through convex meshes generated from the URDF. The robot description is converted from URDF to MJCF and then USD in separate steps because the kit-less importer cannot register the PhysX schema inside a live Isaac Lab process.

This stack is central to the claimed runtime, but it also defines the experimental boundary. Every reported rollout happens in simulation. There is no hardware transfer, contact-safety study, or claim of deployment on a physical G1.

Turning 30 Hz reference clips into control targets

supermimic/motion.py reads root position, root quaternion, and 29 joint angles from each CSV. Positions and joints are linearly interpolated, quaternions use spherical interpolation, and the complete motion is resampled from 30 Hz to 50 Hz. Linear and angular velocities are computed from central differences, with one-sided differences at clip boundaries.

Each future reference frame is represented by 73 numbers: local translation relative to the current frame, a six-dimensional relative rotation, local linear and angular velocity, 29 joint positions, and scaled joint velocities. The policy sees ten future frames, producing a 730-dimensional goal. The reference library is split into one-second bins so training episodes can begin from many parts of the motion rather than always starting at frame zero.

The tracking reward compares 14 bodies: pelvis, both hip rolls, knees, ankle rolls, torso, shoulder rolls, elbows, and wrist yaws. It combines body position, orientation, linear velocity, angular velocity, root position, and root orientation, then penalizes action changes and soft joint-limit violations. A rollout terminates when root-height error exceeds 0.25 m or the tilt metric exceeds 0.8.

The world model predicts local state increments

The learned dynamics model predicts a 71-dimensional increment rather than an absolute next state. Its input combines heading- and position-invariant robot features, the current 29-dimensional action, and a 33-dimensional environment context containing friction, 29 joint offsets, and a three-axis torso center-of-mass offset. Three 2048-wide SiLU layers with LayerNorm form the MLP. The output layer starts at zero so that, at initialization, the predicted transition leaves the state nearly unchanged.

Because global position and full heading are removed from the input, the model is asked to learn local dynamics rather than memorize where a clip occurs in world coordinates. Its predicted translation and velocities are mapped back through the current heading, while a rotation vector updates orientation. Training does not use isolated one-step pairs. The replay buffer supplies eight-step windows, and the loss differentiates through all eight autoregressive predictions. Per-component running scales, with error floors, normalize position, rotation, linear velocity, angular velocity, joints, and joint velocities.

This is the implementation's version of the paper's differentiable-world-model idea. The policy does not backpropagate through the MuJoCo simulator. Instead, it optimizes within a learned local transition model. Reward, observation construction, and termination remain analytic, so differentiability comes primarily from the state-transition chain rather than from replacing the entire simulator with a network.

Training loop: short simulator collection, long imagined optimization

By default, 4096 environments feed a replay buffer that stores 1,000 steps per environment. Each iteration collects 2.5 vectorized simulator steps, corresponding to an update-to-data ratio of 0.4. It then performs ten world-model updates, each on 2048 windows of length eight. Once the 500 world-model-only warm-up iterations end, 4096 valid states are rolled through the learned model for 32 steps and used for one policy update.

The policy is an asymmetric actor. A goal encoder maps the 730-dimensional future reference to a 32-dimensional tanh-bounded latent through 2048, 1024, 512, and 256 wide layers. A shared decoder concatenates that latent with ten recent proprioceptive observations and emits 29 actions. Observations include joint-position error, joint velocity, body-frame angular velocity, projected gravity, the previous action, and six numbers for root orientation relative to the reference. Global position is deliberately absent.

The critic uses 256- and 128-wide hidden layers. Its input combines invariant state information, the future goal, simulator context, and errors between the robot and reference bodies. The imagined batch receives GAE targets with a discount of 0.99 and lambda of 0.95. The critic trains for five epochs over four minibatches. Policy value includes a bootstrap estimate after the 32-step horizon, so imagined returns do not simply stop at the horizon.

All three networks use Adam at a base learning rate of 2e-4. The policy uses beta values of 0.9 and 0.95. Learning rate follows a cosine decay to 3 percent of the initial value over 250,000 iterations. Policy gradients are clipped to norm 1.0 and element 0.1. World-model windows mask transitions after episode boundaries, and observation histories reset with each episode.

Reset curriculum and randomization

Training starts are not sampled uniformly from the reference library. Motions are divided into one-second bins, and starts come from a mixture of three distributions: 50 percent uniform sampling, 40 percent a softmax biased toward low-return bins, and 10 percent a historical softmax that adapts as episodes finish. The result is intended to revisit difficult regions such as jumps, falls, and get-ups instead of spending most samples on easy motion.

Friction is sampled from 0.3 to 1.2 once per environment. A small torso center-of-mass offset is also sampled once per environment. Joint offsets are redrawn within plus or minus 0.01 radians at every episode reset. Exploration adds Gaussian action noise with standard deviation 0.1. Observation noise, reset-state noise, and joint-limit clipping are implemented separately. Because friction and center of mass do not change on every episode, this is lighter than a fully episode-level domain randomization protocol.

Evaluation: clean rollouts with a narrow success definition

Evaluation assigns one environment to each clip, starts every motion at its first frame, and plays it once. Friction is fixed at 1.0. Domain randomization, reset noise, action noise, and observation noise are disabled, and the policy is deterministic. The setup tests first-frame recovery from all 40 clips, but it does not test the policy's ability to resume successfully from every training start distribution.

A clip fails when the training termination condition triggers. That condition checks root-height error and tilt, not task completion, visual quality, energy use, contact force, or hardware safety. Normalized return is the undiscounted reward sum divided by the theoretical maximum. It is useful for comparing checkpoints under the same reward implementation, but it is not a physical-robot stability score. No per-clip JSON, raw evaluation data, or checkpoint is committed, so an outside reader cannot recalculate the aggregate.

The milestone log reports a progression from 0.541 with 12 failures at 0.15 hours to 0.781 with one failure at 0.62 hours, a temporary dip to 0.779 at 0.82 hours, 0.811 at 1.04 hours, 0.824 at 1.24 hours, and 0.829 with no failures at 1.47 hours. This shows that the author observed a nontrivial training trajectory, but it remains a narrative from one run rather than a reproducible data artifact.

Where the implementation departs from the paper

The README is explicit that the reproduction makes engineering choices. Self-collisions are disabled for speed. MLP matrix multiplies use bf16 instead of the paper's reported TF32. Reward, observation, and termination heads remain analytic. Termination during imagined rollouts is softened with sigmoid probabilities. Policy training starts after 500 world-model-only iterations. Asset conversion happens outside the simulator process. State integration, forward kinematics, reward, and termination stay in fp32.

Each choice changes comparability. Disabling self-collision can make falls, contacts, and get-ups easier. bf16 can alter numerical behavior. A deterministic analytic termination is easier to inspect than a learned head but is not the same learned component. The reported 0.829 should therefore be understood as a result for this independent implementation and configuration, not as an exact replication of a paper table row.

The evidence that is still missing

The repository contains the training and evaluation code, motion pipeline, robot setup, a held-goal regression test, a success curve, and a highlight GIF. It does not contain train_log.csv, eval.csv, checkpoints, recorded trajectories, or the full MP4 described in the milestone log. The code explains how the numbers would be produced, but an external reader cannot recompute 0.824 or 0.829 from the committed evidence.

Test coverage is also narrow. The Isaac Lab dependency and motion data are not included, so the project cannot run in a standard Python environment without a substantial setup. The main independently executable logic test is tools/test_motion_goal.py. It checks that a goal beyond a clip end holds the last pose while only the synthetic padding receives zero velocity. Several other files named as tests are simulator probes, benchmarks, or setup checks rather than a broad regression suite.

The complete run is reported on one RTX PRO 6000 Blackwell configuration with driver 580 and CUDA 13. The project says official code was not available, so its module boundaries and data formats were inferred from the paper and the surrounding BeyondMimic ecosystem. A second hardware run, an independent rerun, or a comparison against official code would materially strengthen the result.

Why the repository matters

The useful contribution is not the one-hour creation story. It is the attempt to decompose an expensive humanoid training experiment into inspectable parts: short simulator collection, local dynamics learning, high-ratio model updates, imagined policy optimization, critic bootstrapping, and a clean deterministic evaluation pass. If an independent rerun confirms the result, 1.5 GPU-hours for 40 tracking clips would lower the cost of iteration for this class of research.

The repository also provides a practical checklist for reproduction: motion resampling, tracked-body definition, actuator calibration, invariant state features, environment context, reward and termination, a start-state curriculum, warm-up, and evaluation isolation. Omitting any of these can make a headline return misleading. The author's explicit warning about review status and missing official code is part of the project's credibility, not a footnote to hide.

Turning the author report into repeatable evidence requires a frozen code and container snapshot, published evaluation CSVs, checkpoints and trajectories, a clean rerun on the same motion set, and targeted ablations. At minimum, removing the low-return reset curriculum, removing environment context, and shortening the imagination horizon would show which parts drive the reported efficiency. Until then, the project is best treated as a concrete and unusually candid reproduction hypothesis.

Who should use it, and how

The project is relevant to researchers who already understand Isaac Lab, reinforcement learning loops, and humanoid motion tracking. It can serve as a source-level study of one possible SuperMimic implementation or as a starting point for smaller GPU experiments. It is not a production controller and should not be moved to a physical robot without a separate safety and contact review. A sensible first pass is to audit the code, verify every data license, and reproduce one clip with a fixed seed before scaling to 4096 environments.

Licensing is layered. The repository code is MIT. The LAFAN1 motion data is attributed to Ubisoft La Forge under CC BY-NC-ND 4.0, while the G1 description is BSD-3-Clause. The GIF shows reference motion and is described as illustrative rather than covered by the repository's MIT license. Reuse, redistribution, and commercial deployment require checking the code, robot description, motion data, and rendered media separately.

Bottom line

SuperMimic Vibed is a clearly bounded, end-to-end, but not yet independently validated reproduction. It turns the paper's differentiable-world-model training story into concrete code and reports a strong one-GPU result: 0.829 return and no failed clips after 1.47 hours. Without checkpoints, raw logs, trajectories, and an outside rerun, the defensible conclusion is narrower: this is a high-upside implementation worth auditing and reproducing, not evidence that the paper's claims have already been independently confirmed.