Frontier Radar | BlinkMimic: splitting a humanoid motion tracker’s training time into cost per iteration, fit and tail, with one policy for 40 clips in 3.38 minutes on one RTX 4090, as reported by the author

BlinkMimic splits training time into iteration cost, fit and tail. Author-reported, in simulation: 3.38 min on one RTX 4090 vs 7.4 min for InstantTrack v1.2.

Table diagram on a light background. The title reads "Author-reported: BlinkMimic reaches the target in 3.38 min, the re-run InstantTrack v1.2 in 7.4 min". The subtitle says the values are training time on one RTX 4090 (min), mean of 3 seeds, in simulation, author-reported. The table has two rows and two columns, "First mean return ≥ 0.82" and "3 clean checkpoints in a row". Row one, "InstantTrack v1.2, re-run by the author", shows 5.9 min and 7.4 min. Row two, "BlinkMimic, release recipe", shows 2.94 min and 3.38 min in a darker colour. The source line at the bottom names arXiv 2611.16422 Table 1 and says the SuperMimic estimate is not drawn.
Drawn from arXiv 2611.16422 Table 1 (reported by the author): training time of two configurations on the same RTX 4090 with the same evaluator, mean of 3 seeds, for a simulated Unitree G1 tracking 40 LAFAN1 clips. The darker BlinkMimic row is the result discussed in the article; it is shorter than InstantTrack v1.2 in both columns, and the per-seed ranges do not overlap. The SuperMimic time in Figure 1 of the paper is an estimate and is not drawn. Not measured by this site.

The preprint BlinkMimic (arXiv 2611.16422, 2026-11-12, by Fuyi Chen) builds on SuperMimic and InstantTrack to cut the training time of a whole-body motion-tracking policy for a humanoid robot further. The author reports that on a simulated Unitree G1, one policy for all 40 LAFAN1 clips reaches the paper’s strict target in 3.38 minutes on average (3 seeds) on a single RTX 4090, while InstantTrack v1.2, re-run on the same GPU with the same evaluator, takes 7.4 minutes. For readers who work on training pipelines, the paper’s accounting method is more useful than the headline number: it splits training time into the cost per iteration, the iterations needed to fit and the iterations needed to remove the last failures, and then uses a leave-one-out ablation to check which of these terms each component acts on. All numbers below are reported by the author [R] and were measured in simulation only; this site has not run the code or reproduced any result independently.

The task and what “reaching the target” means

The robot is a Unitree G1 with 29 actuated joints, controlled at 50 Hz in MuJoCo-Warp. The motion library is the 40 LAFAN1 clips retargeted to the G1: 441,140 frames, 2.45 hours, with an average clip length of 3.7 minutes. The policy outputs a normalized action that is scaled and passed as a joint position target to PD controllers. The reward is a sum of Gaussian tracking kernels plus an action-rate penalty, and an episode fails when the height or tilt error of the anchor body exceeds a threshold. These settings follow SuperMimic.

At evaluation, the deployed policy runs deterministically, without domain randomization or noise, from the first frame to the end of every clip. The normalized return lies in [0, 1] and accumulates until the first failure. Because the simulator is not bitwise reproducible and a clip near its margin can flip between evaluations, each clip is run as 4 replicas, 160 rollouts in total. A checkpoint is “clean” when the mean return is at least 0.82 and all 160 rollouts survive. The target is 3 consecutive clean checkpoints, with the time recorded at the first of them, the same rule as InstantTrack. A checkpoint is taken every 100 iterations (about 13 seconds). Training time includes compilation, graph capture, checkpoints and probes, and excludes the offline evaluation.

Physical AI Lab 1.7 applied one rule when reading Learning to Walk in Minutes: a training time holds only for its own hardware, task and settings. BlinkMimic states the target, the evaluation conditions and what the clock covers next to its times, which makes it a ready example of reading a number by that rule.

The training loop: backpropagating through a learned world model

Each iteration has two parts. In collection, 4096 simulated robots run the noisy training policy under domain randomization and store transitions in a replay buffer; finished episodes restart at a frame drawn from a reset distribution over 1-second bins of the library. In imagination, B start states from the buffer are rolled out for H = 32 steps through the learned world model, and the policy follows the gradient obtained by backpropagation through time (BPTT). A critic is fit to λ-returns of the imagined rollouts, and the deployed policy is an exponential moving average (EMA, β = 0.995) of the training policy.

Using BPTT through a learned world model, with a pathwise gradient in place of the high-variance policy-gradient estimate, comes from SuperMimic. The EMA deployed policy, Muon updates and a residual policy that outputs a correction to the reference motion come from InstantTrack’s open implementation. BlinkMimic adds three things: a step size that falls once training has progressed, resets allocated by failures under deployment conditions, and capture of the whole iteration as a CUDA graph. It also halves the imagination batch to 2048.

The time budget: cost per iteration times fit and tail iterations

The paper writes training time as T = c̄ (N_fit + N_tail): the mean cost per iteration c̄ times the number of iterations, which splits into a fit phase N_fit (until the mean evaluation return first reaches 0.82) and a tail phase N_tail (until the last failing clips stop failing). The three terms are limited by different things, and the author designs for each separately. The main result on a single RTX 4090 (Table 1 of the paper; seeds 0 / 1 / 2, mean in parentheses, times in minutes):

Configurationms/iterationIterations to 0.82First ≥ 0.823 consecutive clean checkpointsTail failuresFinal return
InstantTrack v1.2 (re-run)1472408 / 2741 / 24925.6 / 6.3 / 5.8 (5.9)7.3 / 8.5 / 6.3 (7.4)80 / 126 / 1130.856
BlinkMimic (release)1351292 / 1456 / 11692.89 / 3.28 / 2.64 (2.94)3.32 / 3.28 / 3.53 (3.38)2 / 6 / 00.861

Tail failures are failed rollouts summed over the checkpoints from iteration 2000 to 3500. The per-seed times of the two configurations do not overlap. Averaged over 3 seeds, the 3.38 minutes consist of about 9 seconds of startup and compilation, 167 seconds to the first checkpoint at return 0.82, and 26 seconds of tail; the fit phase takes more than 80%. At the target, the RMS position error of the 14 tracked bodies is 4.1 cm and the mean joint-angle error is 4.0°; with no global position feedback, the root drifts by 93 cm. The SuperMimic bar in Figure 1 of the paper is an estimate (the iterations of InstantTrack’s SuperMimic runs times SuperMimic’s time per iteration on the author’s GPU), not a measurement. Checking how a baseline was obtained before comparing speed-ups is the step practised in Physical AI Lab 1.4; here InstantTrack is a measured re-run and SuperMimic is a projection.

Which term each component acts on

The author removes one component at a time from the final recipe, with 3 seeds per row (Table 2 of the paper). The ablation runs on a different GPU type and compares iterations. There the full recipe needs 1422 iterations to reach 0.82, against 1306 on the RTX 4090, so numbers are compared only within one table.

Component removedTermChange reported by the author
Muon on the policy (Adam instead)N_fitTarget not reached by iteration 6000, return stays at 0.81; the row keeps the ×4 step and batch 2048, so it does not show the best Adam can do with tuned settings
Muon on the world modelN_fitIterations to 0.82 +24%
Progress-triggered step size (constant ×1 instead)N_fit+14%
Reference residualN_fit+23%
Semi-implicit world model and mirror augmentationReturn levelFit iterations unchanged (1428 against 1422); mean return over iterations 2000–3500 falls to 0.854 (full recipe 0.860)
Deployment-condition reset allocationN_tailTail failures over 3 seeds 9 → 18, but the seeds overlap and the three-checkpoint rule is not slower
Imagination batch restored to 4096c̄Iterations −20%, but in an earlier configuration measured on the RTX 4090 each iteration cost 41% more (172 against 122 ms), so total time grows

The step size starts at 4 times the base learning rate and falls linearly to 1 times over 300 iterations once the training return first exceeds 0.75 (at iteration 1400 at the latest). InstantTrack already captures the two update phases as CUDA graphs; BlinkMimic captures them from the first iteration and puts the collection step (policy inference, physics step, reward, and episode resets done with fixed-shape operations) into the same CUDA graph. The author reports that in two alternating paired runs on the same GPU, without checkpoints or probes, the steady-state iteration falls from 127.5 ms to 118.5 ms (−7%) and the first 700 iterations take 18 seconds less. The author checked that after a masked reset every simulator field matches the original reset bit for bit, except joint velocities, which differ by at most 2.4 × 10⁻⁷.

The fit phase is limited by the update rule, the tail by where practice goes

To see how much room the gradient signal has left, the author trains the same network with the same optimizer by regression onto the actions of a converged policy, with DAgger-style data collection, as a “perfect teacher” reference. Muon cuts the teacher’s updates from 3494 to 1478 (2.3 times); the release recipe needs only 1306 iterations at batch 2048, fewer than the teacher’s 1478–1499. The author concludes that a better signal has little left to give, while a better update rule still can. The author also states that this ratio is a reference, not a lower bound. The world model’s action gradient correlates with the simulator at 0.95–0.98 over 1 step and 0.80–0.89 over 8 steps, and the correlation is low over 32 steps; removing the critic costs 50% more iterations.

The tail analysis uses jumps1_subject2 as its example: before allocation, most late failures came from a floor roll followed by a stand-up in this clip. Trained alone, the clip fails in all 16 rollouts up to iteration 1000 and in none of 128 from iteration 1250 on. In the 40-clip mix, the 10 seconds before the hard spot receive only 0.6%–1.5% of resets. Forcing 10% of resets onto that window gives no failures in 256 rollouts at the 6 checkpoints from iteration 1750 to 3000 (one seed for each test). The author concludes that these states are learnable but get too little practice, and that failure statistics collected during training (from a policy that is noisy, randomized and not averaged) point at the wrong places. The replay buffer also lags: a new failure window that receives 18.2% of resets accounts for only 2.5% of imagination starts until the buffer turns over, about 400 iterations later.

BlinkMimic therefore sweeps the whole library with the EMA policy under deployment conditions every 125 iterations from iteration 1000, counts first failures in 1-second bins, decays the counts by 0.7 per sweep, spreads each count over the failing bin and the 10 bins before it, and gives this map 15% of all resets. In the earlier recipe B, the author registered a criterion before the run; tail failures fell from 23 / 22 / 10 to 2 / 10 / 2, and the three-checkpoint time improved from 6.1 to 4.9 minutes. In the release recipe so few failures remain that 3 seeds no longer separate the two arms.

SONIC-K1, covered earlier on this site, is also a humanoid motion tracker, but it deals with porting to the Booster K1 and with success under latency. The robot, training hardware and metrics differ, so the numbers of the two papers cannot be compared directly.

Limitations

  • This is a single-author arXiv preprint; every number is reported by the author [R] and none has been reproduced independently. The paper gives a repository address for the code and per-seed results; this site has not opened it or run anything.
  • The scope stated by the author: one robot, one motion library, training time on one GPU type, and no real-robot deployment. “Training in minutes” refers to training in simulation only and is not a hardware safety validation.
  • Three seeds cannot resolve differences below about 15% under the strict rule. The ablation keeps the settings tuned for the full recipe, so a removed component might do better with settings of its own. Structure and mirror are removed together, and several diagnostics rest on one seed and were measured on earlier configurations.
  • Reaching the target does not guarantee that later checkpoints stay clean: in seed 1, fallAndGetUp2_subject2 fails in all 4 replicas at iteration 3100. The author names such late flips as the most valuable target for future work.
  • The asynchronous probe assumes an otherwise idle GPU; when another process shares the GPU, training with it can crash. The synchronous probe avoids this at a cost in speed.
  • The SuperMimic time in Figure 1 is an estimate, not a measurement under the same conditions; InstantTrack is v1.2 as re-run by the author.

Links