Add files using upload-large-folder tool

.gitattributes

@@ -1,60 +1,11 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
+*.fbx filter=lfs diff=lfs merge=lfs -text
+*.bvh filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
 *.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*_training.gif !filter !diff !merge text=auto
+*_training.mp4 !filter !diff !merge text=auto
+*_policy.gif !filter !diff !merge text=auto
+*_policy.mp4 !filter !diff !merge text=auto
+*_policy.pt !filter !diff !merge text=auto

.gitignore

@@ -0,0 +1,3 @@
+.venv/
+__pycache__/
+*.pyc

.gitmodules

@@ -0,0 +1,12 @@
+[submodule "Motion-Player-ROS"]
+	path = Motion-Player-ROS
+	url = https://github.com/MOVIN3D/Motion-Player-ROS.git
+[submodule "mjlab"]
+	path = mjlab
+	url = https://github.com/mujocolab/mjlab
+[submodule "RoboJuDo"]
+	path = RoboJuDo
+	url = https://github.com/experientialtech/RoboJuDo.git
+[submodule "external/video2robot"]
+	path = external/video2robot
+	url = https://github.com/AIM-Intelligence/video2robot

.playwright-mcp/console-2026-02-25T23-30-28-765Z.log

@@ -0,0 +1,7 @@
+[    3414ms] [WARNING] Failed to create WebGPU Context Provider @ https://abs.twimg.com/responsive-web/client-web/vendor.e0c4a7ca.js:0
+[    4259ms] [ERROR] Not signed in with the identity provider. @ https://x.com/taker_of_whizz/status/2026749425851253095:0
+[    4260ms] [ERROR] [GSI_LOGGER]: FedCM get() rejects with AbortError: signal is aborted without reason @ https://accounts.google.com/gsi/client:81
+[    4260ms] [ERROR] Not signed in with the identity provider. @ https://x.com/taker_of_whizz/status/2026749425851253095:0
+[    7228ms] [ERROR] Framing 'https://accounts.google.com/' violates the following report-only Content Security Policy directive: "frame-ancestors 'self'". The violation has been logged, but no further action has been taken.
+ @ :0
+[    7372ms] [ERROR] [GSI_LOGGER]: FedCM get() rejects with NetworkError: Error retrieving a token. @ https://accounts.google.com/gsi/client:81

.playwright-mcp/console-2026-02-25T23-36-54-631Z.log

@@ -0,0 +1 @@
+[    1851ms] [ERROR] Failed to load resource: the server responded with a status of 401 () @ https://www.virustotal.com/ui/me?relationships=active_group%2Cparent_group:0

.playwright-mcp/console-2026-02-25T23-57-00-677Z.log

@@ -0,0 +1,3 @@
+[    4324ms] [WARNING] Unrecognized feature: 'web-share'. @ https://www.google.com/xjs/_/js/k=xjs.s.en.QjWJURgsC5I.2019.O/am=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAiAAACSAAAAQAAAAAAAAAAAAAACAAAgACAAAAAAAAAAAAAAAAAAAAAAAAACAgAAACAAACQAAAAAAAAAAAAIAAABAAAAAAAAAAAAABgACAAACCFAgAAAAKAAAAAAAAAAAAAAAAAAAAGAQCAAAAAkkAAD-bX9AAwAAAAAAAAIAAAAAAAAAAAAAAAAACQAAAAAAAAAAAAsAAAAQCgMAEAAhAAEAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAgAAAAAIACAAAgAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAgAAAEAAAAAOAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAIYAAAAAACAAgAB_AAABAAAAAAAADgAQACAQAAAAAAAuIAQAQCAAAAAAADIAeDxAA4RFAAAAAAAAAAAAAAAAAAAAAAAABAABWAcSH5AAAIAAAAAAAAAAAAAAAAAAAAAAAAAAKAibApWDQAI/d=0/dg=0/br=1/rs=ACT90oFbf07X_2j7uDMQrGJWGbw7Wk2O-Q/cb=loaded_h_0/m=sy416,P10Owf,sy2xe,gSZvdb,sy7n9,sy1uf,sy1ol,sy1oj,sy1ok,sy2yi,sy2yh,VD4Qme,VEbNoe,sy7n8,TmFfhf,sy312,Dq2Yjb,sy315,sy313,sy1q0,NVlnE,sy317,sy30x,qmdEUe,sy319,sy318,UqGwg,sy689,qcH9Lc,sy67s,pjDTFb,gCngrf,sy67u,sy2qf,sA1ssc,sy67q,khkNpe?xjs=s4:173
+[    4677ms] [ERROR] Failed to load resource: net::ERR_CACHE_MISS @ https://www.google.com/search?vsrid=CNqBibvJhY-gtQEQAhgBIiQyMGVhNTNhOC1kOWU3LTQ2MTgtYWEwYS04NTA1MjhjYTNjMjkyBiICZHooCTiN0uyU7PWSAw&vsint=CAIqDAoCCAcSAggKGAEgATojChYNAAAAPxUAAAA_HQAAgD8lAACAPzABEIAIGLgDJQAAgD8&udm=26&lns_mode=un&source=lns.web.ukn&vsdim=1024,440&gsessionid=fS2O8swB_Q92WjLEqfedfw4rLF8DawyupRGtSTi5iGvUSlnMUUkuPw&lsessionid=w24RHwvVVCgYFH-xU2XDNHaB7GZdVUtlS9M7biZck6vd0EN8jbvWNw&lns_surface=26&lns_vfs=e&cs=0:0
+[    5190ms] [WARNING] Failed to execute 'postMessage' on 'DOMWindow': The target origin provided ('https://www.youtube.com') does not match the recipient window's origin ('https://www.google.com'). @ https://www.youtube.com/s/player/4e67f8a0/www-widgetapi.vflset/www-widgetapi.js:209

.playwright-mcp/console-2026-02-26T00-03-30-969Z.log

@@ -0,0 +1 @@
+[    9967ms] [ERROR] Failed to load resource: net::ERR_CERT_AUTHORITY_INVALID @ https://hdrc.yandex.net/:0

.playwright-mcp/console-2026-02-26T00-07-08-716Z.log

@@ -0,0 +1 @@
+[     513ms] [ERROR] Failed to load resource: the server responded with a status of 503 () @ https://nitter.poast.org/taker_of_whizz/status/2026749425851253095:0

.playwright-mcp/console-2026-02-26T00-07-14-577Z.log

@@ -0,0 +1,5 @@
+[     493ms] [ERROR] Failed to load resource: the server responded with a status of 503 () @ https://xcancel.com/taker_of_whizz/status/2026749425851253095:0
+[    1175ms] ReferenceError: a0_0x44517f is not defined
+    at getHighEntropyValues (blob:https://xcancel.com/c01e03ed-a9a1-45e3-9554-c3726bc611cc:1:105)
+    at self.onmessage (blob:https://xcancel.com/c01e03ed-a9a1-45e3-9554-c3726bc611cc:1:466)
+[   18694ms] [WARNING] The resource https://xcancel.com/fonts/fontello.woff2?61663884 was preloaded using link preload but not used within a few seconds from the window's load event. Please make sure it has an appropriate `as` value and it is preloaded intentionally. @ https://xcancel.com/taker_of_whizz/status/2026749425851253095:0

.playwright-mcp/console-2026-02-26T00-11-16-782Z.log

@@ -0,0 +1,2 @@
+[      35ms] [ERROR] Failed to load resource: net::ERR_CONNECTION_CLOSED @ https://www.youtube.com/youtubei/v1/log_event?alt=json:0
+[     883ms] [ERROR] Failed to load resource: the server responded with a status of 403 () @ https://patched.to/search.php?action=do_search&keywords=seedance&postthread=1&submit=Search:0

.playwright-mcp/console-2026-02-26T00-12-06-806Z.log

@@ -0,0 +1 @@
+[    4186ms] [ERROR] Failed to load resource: net::ERR_CERT_AUTHORITY_INVALID @ https://hdrc.yandex.net/:0

CLAUDE.md

@@ -0,0 +1,742 @@
+# G1 Moves — Motion-to-Policy Pipeline
+
+## Project Overview
+
+This repository contains 59 motion capture clips for the Unitree G1 humanoid robot (mode 15, 29 DOF). The pipeline takes raw BVH motion capture from MOVIN3D and processes it through retargeting, training data generation, RL policy training, and archival.
+
+**Robot**: Unitree G1, mode 15, 29 DOF
+**Capture systems**: MOVIN TRACIN (markerless, LiDAR + vision), video2robot (monocular video)
+**Training framework**: mjlab (MuJoCo-Warp + RSL-RL PPO)
+**Workstation**: Dell Pro Max Tower T2, RTX PRO 6000 (96GB), Ubuntu 24.04
+
+## Repository Layout
+
+```
+g1-moves/
+  dance/                        28 clips
+  karate/                       27 clips
+  bonus/                         4 clips
+  <category>/<clip>/
+    capture/                    Original mocap
+      <clip>.bvh                BVH motion (51-joint humanoid, 60 FPS)
+      <clip>.gif                Preview GIF
+      <clip>.mp4                Preview video
+      <clip>_{bl,mb,ue,un}.fbx  FBX exports
+    retarget/                   G1 retargeting
+      <clip>.pkl                Retargeted joints (29 DOF)
+      <clip>.csv                Same as PKL in CSV format
+      <clip>_retarget.gif       Retarget preview
+      <clip>_retarget.mp4       Retarget video
+    training/                   RL training data
+      <clip>.npz                Training-ready data
+      <clip>_training.gif       Training visualization
+      <clip>_training.mp4       Training video
+    policy/                     Trained RL policy (when available)
+      <clip>_policy.pt          PyTorch checkpoint
+      <clip>_policy.gif         Policy rollout GIF
+      <clip>_policy.mp4         Policy rollout video
+      agent.yaml                PPO hyperparameters
+      env.yaml                  Full environment config
+      training_log.csv          Training metrics
+  external/
+    video2robot/                video2robot pipeline (monocular video → robot motion)
+  manifest.json                 Per-clip metadata index
+  quality_report.json           Automated validation
+  generate_metadata.py          Regenerate metadata
+  retarget_all.py               Batch retarget pipeline
+  DATASET_CARD.md               Dataset documentation
+```
+
+## Key Paths
+
+| What | Path |
+|------|------|
+| This repo | `~/Repositories/g1-moves` |
+| mjlab-gui | `~/Repositories/mjlab-gui` |
+| G1 URDF | `~/Repositories/g1-urdf` |
+| MuJoCo XML | `~/Repositories/g1-urdf/g1_mode15_square.xml` |
+| Training logs | `~/Repositories/mjlab-gui/logs/rsl_rl/g1_tracking/` |
+| video2robot | `~/Repositories/g1-moves/external/video2robot` |
+| GMR | `~/Repositories/g1-moves/external/video2robot/third_party/GMR` |
+| PromptHMR | `~/Repositories/g1-moves/external/video2robot/third_party/PromptHMR` |
+
+## Pipeline Stages
+
+There are two input paths that converge at the PKL stage:
+- **Path A (BVH)**: MOVIN TRACIN → BVH → retarget_all.py → PKL (Stage 1)
+- **Path B (Video)**: Any video → PromptHMR → SMPL-X → GMR → PKL (Stage 0)
+
+Both produce the same PKL format and feed into Stage 2+ identically.
+
+### Stage 0: Video to PKL via video2robot
+
+Extracts human pose from monocular video (YouTube, phone, etc.) and retargets to G1 robot joints. Alternative to the BVH pipeline for clips without mocap hardware.
+
+**Input**: Any MP4 video with a visible full-body human
+**Output**: `<category>/<clip>/retarget/<clip>.pkl`, `<clip>.csv`
+
+**Environments**: Two separate conda envs required (conflicting deps):
+- `phmr` (Python 3.11) — PromptHMR pose extraction (PyTorch 2.9+, xformers, SAM2, detectron2)
+- `gmr` (Python 3.10) — GMR motion retargeting (MuJoCo, mink IK solver)
+
+#### Step 1: Set up project directory
+
+```bash
+CLIP=V_MyClip
+CATEGORY=bonus
+V2R=~/Repositories/g1-moves/external/video2robot
+
+# Create project folder with video
+mkdir -p $V2R/data/$CLIP
+cp /path/to/video.mp4 $V2R/data/$CLIP/original.mp4
+```
+
+Or download from YouTube:
+```bash
+yt-dlp -f "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best" \
+  -o "$V2R/data/$CLIP/original.mp4" "https://youtube.com/..."
+```
+
+#### Step 2: Extract pose (PromptHMR)
+
+```bash
+cd $V2R
+conda run -n phmr python scripts/extract_pose.py \
+  --project data/$CLIP --static-camera
+```
+
+**What it does**:
+1. Converts video to H.264 if needed (AV1, VP9, etc.)
+2. Runs person detection + SAM2 tracking
+3. Estimates 3D human mesh (SMPL-X) per frame via PromptHMR
+4. Exports `smplx.npz` with root_orient, pose_body, betas, trans
+
+**Output**: `data/$CLIP/smplx.npz`, `smplx_tracks.json`, `results.pkl`, `world4d.glb`
+
+**Flags**:
+- `--static-camera`: Skip SLAM camera estimation (use for tripod/fixed-camera videos)
+
+**Time**: ~2-5 min on RTX PRO 6000
+
+#### Step 3: Retarget to G1 (GMR)
+
+```bash
+cd $V2R
+conda run -n gmr python scripts/convert_to_robot.py \
+  --project data/$CLIP --robot unitree_g1 --no-twist
+```
+
+**What it does**:
+1. Loads SMPL-X body model, computes human height from betas
+2. Per-frame IK: maps SMPL-X joints → G1 29-DOF joint angles
+3. Forward kinematics for body positions + ground calibration
+4. Saves PKL: `{fps, root_pos (N,3), root_rot (N,4) xyzw, dof_pos (N,29)}`
+
+**Output**: `data/$CLIP/robot_motion.pkl`
+
+**Flags**:
+- `--no-twist`: Skip 23-DOF TWIST conversion (we use 29-DOF)
+- `--all-tracks`: Retarget every detected person (default: best track only)
+- `--fps 60`: Upsample to 60 FPS (default: keep original video FPS)
+
+**Time**: ~30s for 285 frames
+
+#### Step 4: Copy to g1-moves and generate CSV
+
+```bash
+mkdir -p ~/Repositories/g1-moves/$CATEGORY/$CLIP/{capture,retarget,training,policy}
+
+# Copy video + retarget output
+cp $V2R/data/$CLIP/original.mp4 ~/Repositories/g1-moves/$CATEGORY/$CLIP/capture/$CLIP.mp4
+cp $V2R/data/$CLIP/robot_motion.pkl ~/Repositories/g1-moves/$CATEGORY/$CLIP/retarget/$CLIP.pkl
+
+# Generate CSV (36 columns: 3 pos + 4 quat_xyzw + 29 joints)
+python3 -c "
+import pickle, numpy as np
+with open('$HOME/Repositories/g1-moves/$CATEGORY/$CLIP/retarget/$CLIP.pkl','rb') as f:
+    d = pickle.load(f)
+combined = np.hstack([d['root_pos'], d['root_rot'], d['dof_pos']])
+np.savetxt('$HOME/Repositories/g1-moves/$CATEGORY/$CLIP/retarget/$CLIP.csv', combined, delimiter=',', fmt='%.10f')
+print(f'CSV: {combined.shape[0]} frames x {combined.shape[1]} cols')
+"
+```
+
+#### Step 5: Visualize in MuJoCo
+
+```bash
+cd ~/Repositories/g1-moves/external/video2robot/third_party/GMR
+conda run -n gmr python scripts/vis_robot_motion.py \
+  --robot unitree_g1 \
+  --robot_motion_path ~/Repositories/g1-moves/$CATEGORY/$CLIP/retarget/$CLIP.pkl \
+  --record_video \
+  --video_path ~/Repositories/g1-moves/$CATEGORY/$CLIP/retarget/${CLIP}_retarget.mp4
+```
+
+#### Step 6: Self-collision correction
+
+video2robot/GMR does not enforce self-collision avoidance during retargeting. Post-process to fix arm-into-arm, arm-into-torso, etc:
+
+```bash
+python3 -c "
+import pickle, mujoco, numpy as np
+
+CLIP='$CLIP'; CAT='$CATEGORY'
+PKL=f'$HOME/Repositories/g1-moves/{CAT}/{CLIP}/retarget/{CLIP}.pkl'
+CSV=f'$HOME/Repositories/g1-moves/{CAT}/{CLIP}/retarget/{CLIP}.csv'
+
+with open(PKL,'rb') as f: d=pickle.load(f)
+model=mujoco.MjModel.from_xml_path('$HOME/Repositories/g1-urdf/g1_mode15_square.xml')
+data=mujoco.MjData(model)
+rp,rr,dp=d['root_pos'].copy(),d['root_rot'].copy(),d['dof_pos'].copy()
+n=len(rp)
+
+def has_col(i):
+    data.qpos[:3]=rp[i]; data.qpos[3:7]=[rr[i,3],rr[i,0],rr[i,1],rr[i,2]]; data.qpos[7:]=dp[i]
+    mujoco.mj_forward(model,data)
+    return any(model.body(model.geom_bodyid[data.contact[c].geom1]).name!='world'
+               and model.body(model.geom_bodyid[data.contact[c].geom2]).name!='world'
+               for c in range(data.ncon))
+
+# Find collision ranges
+ic=[i for i in range(n) if has_col(i)]
+print(f'{len(ic)} collision frames')
+
+# Interpolate arm joints (15-28) from boundary clean frames
+ARM=list(range(15,29))
+ranges=[]; i=0
+while i<n:
+    if has_col(i):
+        s=i
+        while i<n and has_col(i): i+=1
+        ranges.append((s,i-1))
+    else: i+=1
+
+for s,e in ranges:
+    cb=s-1; ca=e+1
+    while cb>0 and has_col(cb): cb-=1
+    while ca<n-1 and has_col(ca): ca+=1
+    span=ca-cb
+    for f in range(s,e+1):
+        t=(f-cb)/span if span>0 else 0.5
+        for j in ARM: dp[f,j]=(1-t)*dp[cb,j]+t*dp[ca,j]
+
+# If any remain, widen to all joints
+for _ in range(3):
+    ic2=[i for i in range(n) if has_col(i)]
+    if not ic2: break
+    for s,e in ranges:
+        cb=max(0,s-3); ca=min(n-1,e+3)
+        while cb>0 and has_col(cb): cb-=1
+        while ca<n-1 and has_col(ca): ca+=1
+        span=ca-cb
+        for f in range(s,e+1):
+            if not has_col(f): continue
+            t=(f-cb)/span if span>0 else 0.5
+            dp[f]=(1-t)*dp[cb]+t*dp[ca]
+
+final=sum(has_col(i) for i in range(n))
+print(f'Remaining: {final}')
+
+d['dof_pos']=dp.astype(np.float32)
+with open(PKL,'wb') as f: pickle.dump(d,f)
+np.savetxt(CSV,np.hstack([rp,rr,dp]),delimiter=',',fmt='%.10f')
+print('Saved corrected PKL+CSV')
+"
+```
+
+**Strategy**: For collision frames, interpolate arm joints (shoulder/elbow/wrist) between nearest clean boundary frames. Falls back to full-joint interpolation if arm-only doesn't resolve. Typically corrects <5 deg mean deviation, preserving motion character.
+
+#### Verify
+
+```bash
+python3 -c "
+import pickle, numpy as np, mujoco
+with open('$HOME/Repositories/g1-moves/$CATEGORY/$CLIP/retarget/$CLIP.pkl','rb') as f:
+    d = pickle.load(f)
+assert d['dof_pos'].shape[1] == 29
+assert d['root_rot'].shape[1] == 4
+assert not np.any(np.isnan(d['dof_pos']))
+
+# Self-collision check
+model=mujoco.MjModel.from_xml_path('$HOME/Repositories/g1-urdf/g1_mode15_square.xml')
+data=mujoco.MjData(model)
+cols=0
+for i in range(len(d['root_pos'])):
+    data.qpos[:3]=d['root_pos'][i]
+    data.qpos[3:7]=[d['root_rot'][i,3],d['root_rot'][i,0],d['root_rot'][i,1],d['root_rot'][i,2]]
+    data.qpos[7:]=d['dof_pos'][i]
+    mujoco.mj_forward(model,data)
+    for c in range(data.ncon):
+        b1=model.body(model.geom_bodyid[data.contact[c].geom1]).name
+        b2=model.body(model.geom_bodyid[data.contact[c].geom2]).name
+        if b1!='world' and b2!='world': cols+=1; break
+print(f'frames={d[\"dof_pos\"].shape[0]}, fps={d[\"fps\"]}, dof={d[\"dof_pos\"].shape[1]}, self_collisions={cols}')
+assert cols == 0, f'{cols} self-collision frames remain!'
+"
+```
+
+**Then continue with Stage 2 (CSV → NPZ) and beyond.**
+
+### Stage 1: Retarget BVH to PKL
+
+Converts human motion capture to G1 robot joint trajectories using inverse kinematics.
+
+**Input**: `<category>/<clip>/capture/<clip>.bvh`
+**Output**: `<category>/<clip>/retarget/<clip>.pkl`
+
+```bash
+cd ~/Repositories/g1-moves
+python retarget_all.py --workers 4
+```
+
+For a single clip:
+```bash
+python retarget_all.py --clips "B_Fence1"
+```
+
+**What it does**:
+1. Loads BVH via `movin_sdk_python.load_bvh_file()` with `human_height=1.75`
+2. Per-frame IK retargeting to G1 29-DOF joint limits
+3. Ground calibration: MuJoCo FK finds min ankle Z, shifts root down
+4. Renders 1080x1080 MP4 (libx264 CRF 18) + 360px 15fps GIF (capped at 20s)
+5. Saves PKL: `{fps: 60, root_pos: (N,3), root_rot: (N,4) xyzw, dof_pos: (N,29)}`
+
+**Verify**:
+```bash
+python -c "
+import pickle
+with open('<category>/<clip>/retarget/<clip>.pkl','rb') as f: d=pickle.load(f)
+print(f'frames={d[\"dof_pos\"].shape[0]}, dof={d[\"dof_pos\"].shape[1]}')
+assert d['dof_pos'].shape[1] == 29
+"
+```
+
+**Time**: ~5s per clip, ~5 min for all 59 with 4 workers
+
+### Stage 2: Convert PKL to NPZ Training Data
+
+Runs MuJoCo forward kinematics to compute body positions, orientations, and velocities needed for RL training.
+
+**Input**: `<category>/<clip>/retarget/<clip>.csv`
+**Output**: `<category>/<clip>/training/<clip>.npz`
+
+```bash
+cd ~/Repositories/mjlab-gui
+MUJOCO_GL=egl uv run python src/mjlab/scripts/csv_to_npz.py \
+  --input-file ~/Repositories/g1-moves/<category>/<clip>/retarget/<clip>.csv \
+  --output-name <clip> \
+  --input-fps 60 \
+  --output-fps 60 \
+  --render
+```
+
+Or use the local wrapper (bypasses WandB):
+```bash
+cd ~/Repositories/mjlab-gui
+MUJOCO_GL=egl python app/scripts/process_motion_local.py \
+  --input-file ~/Repositories/g1-moves/<category>/<clip>/retarget/<clip>.csv \
+  --output-name <clip> \
+  --run-folder <clip>_$(date +%Y%m%d_%H%M%S) \
+  --input-fps 60 \
+  --output-fps 60 \
+  --render
+```
+
+**What it does**:
+1. Loads CSV (36 columns: 3 root pos + 4 root quat + 29 joint angles)
+2. Optional interpolation to target FPS
+3. MuJoCo FK: computes body positions, quaternions, linear/angular velocities
+4. Saves NPZ with joint_pos, joint_vel, body_pos_w, body_quat_w, body_lin_vel_w, body_ang_vel_w
+
+**Output location**: `app/datasets/processed/<clip>_<timestamp>/motion.npz`
+
+Copy to g1-moves:
+```bash
+cp app/datasets/processed/<clip>_*/motion.npz \
+   ~/Repositories/g1-moves/<category>/<clip>/training/<clip>.npz
+```
+
+**Verify**:
+```bash
+python -c "
+import numpy as np
+d = np.load('<clip>.npz')
+print({k: d[k].shape for k in d.files})
+assert 'joint_pos' in d.files and 'body_pos_w' in d.files
+"
+```
+
+**Time**: ~10s per clip
+
+### Stage 3: Render Training Visualization
+
+Render the NPZ training data as a MuJoCo video to visually verify the processed motion.
+
+**Input**: `<category>/<clip>/training/<clip>.npz`
+**Output**: `<category>/<clip>/training/<clip>_training.mp4`, `<clip>_training.gif`
+
+The render is produced by the `--render` flag in Stage 2, or can be generated separately using the MuJoCo offscreen renderer with the same camera settings as retarget_all.py.
+
+### Stage 4: Train RL Policy
+
+Train a PPO policy to imitate the reference motion in MuJoCo-Warp simulation.
+
+**Input**: `<category>/<clip>/training/<clip>.npz`
+**Output**: `~/Repositories/mjlab-gui/logs/rsl_rl/g1_tracking/<timestamp>_<clip>/`
+
+```bash
+cd ~/Repositories/mjlab-gui
+MUJOCO_GL=egl MUJOCO_EGL_DEVICE_ID=0 uv run train \
+  Mjlab-Tracking-Flat-Unitree-G1 \
+  --env.commands.motion.motion-file ~/Repositories/g1-moves/<category>/<clip>/training/<clip>.npz \
+  --env.scene.num-envs 4096 \
+  --agent.max-iterations 30000 \
+  --agent.save-interval 500 \
+  --agent.run-name <clip> \
+  --video --video-interval 5000
+```
+
+**Key parameters**:
+- `num-envs 4096`: parallel simulation environments (reduce to 2048/1024 if OOM)
+- `max-iterations 30000`: training steps (~6 hours on RTX PRO 6000)
+- `save-interval 500`: checkpoint every 500 iterations
+- `video-interval 5000`: record evaluation video every 5000 steps
+
+**Output structure**:
+```
+logs/rsl_rl/g1_tracking/<timestamp>_<clip>/
+  model_0.pt ... model_29999.pt    Checkpoints
+  params/agent.yaml                PPO hyperparameters
+  params/env.yaml                  Environment config (includes motion_file path)
+  events.out.tfevents.*            TensorBoard log
+  videos/                          Evaluation videos
+```
+
+**Monitor training**:
+```bash
+# TensorBoard
+uv run tensorboard --logdir logs/rsl_rl/g1_tracking/ --port 6006
+
+# Key metrics to watch:
+# - Train/mean_reward: should increase steadily, plateau ~3-5
+# - Train/mean_episode_length: should increase toward max (10s)
+# - Episode_Termination/time_out: should approach 1.0 (fewer early terminations)
+# - Metrics/motion/error_body_pos: should decrease
+```
+
+**Verify**:
+```bash
+# Check final checkpoint exists and has expected keys
+python -c "
+import torch
+ckpt = torch.load('logs/rsl_rl/g1_tracking/<run>/model_29999.pt', map_location='cpu', weights_only=False)
+print(f'iter={ckpt[\"iter\"]}, keys={list(ckpt.keys())}')
+assert ckpt['iter'] == 29999
+"
+```
+
+**Time**: ~6 hours for 30k iterations with 4096 envs on RTX PRO 6000
+
+### Stage 5: Render Policy Rollout
+
+Play back the trained policy and record video.
+
+**Input**: trained checkpoint + NPZ motion file
+**Output**: policy rollout MP4 + GIF
+
+```bash
+cd ~/Repositories/mjlab-gui
+MUJOCO_GL=egl uv run play \
+  Mjlab-Tracking-Flat-Unitree-G1 \
+  --checkpoint-file logs/rsl_rl/g1_tracking/<run>/model_29999.pt \
+  --motion-file ~/Repositories/g1-moves/<category>/<clip>/training/<clip>.npz \
+  --num-envs 1 \
+  --video --video-length 600
+```
+
+**Output**: `logs/rsl_rl/g1_tracking/<run>/videos/play/rl-video-step-0.mp4`
+
+Generate GIF:
+```bash
+ffmpeg -y -i input.mp4 \
+  -vf "fps=15,scale=360:-1:flags=lanczos,palettegen" -t 20 /tmp/palette.png
+ffmpeg -y -i input.mp4 -i /tmp/palette.png \
+  -t 20 -lavfi "fps=15,scale=360:-1:flags=lanczos [x]; [x][1:v] paletteuse" output.gif
+```
+
+### Stage 6: Archive to g1-moves
+
+Copy all policy artifacts back to the clip's directory structure.
+
+```bash
+CLIP=<clip>
+CATEGORY=<category>
+RUN=<timestamp>_${CLIP}
+LOGS=~/Repositories/mjlab-gui/logs/rsl_rl/g1_tracking/${RUN}
+DEST=~/Repositories/g1-moves/${CATEGORY}/${CLIP}/policy
+
+mkdir -p ${DEST}
+
+# Copy final checkpoint (rename to standard name)
+cp ${LOGS}/model_29999.pt ${DEST}/${CLIP}_policy.pt
+
+# Copy training config
+cp ${LOGS}/params/agent.yaml ${DEST}/agent.yaml
+cp ${LOGS}/params/env.yaml ${DEST}/env.yaml
+
+# Copy policy rollout video + generate GIF
+cp ${LOGS}/videos/play/rl-video-step-0.mp4 ${DEST}/${CLIP}_policy.mp4
+ffmpeg -y -i ${DEST}/${CLIP}_policy.mp4 \
+  -vf "fps=15,scale=360:-1:flags=lanczos,palettegen" -t 20 /tmp/palette.png
+ffmpeg -y -i ${DEST}/${CLIP}_policy.mp4 -i /tmp/palette.png \
+  -t 20 -lavfi "fps=15,scale=360:-1:flags=lanczos [x]; [x][1:v] paletteuse" \
+  ${DEST}/${CLIP}_policy.gif
+
+# Extract training log from TensorBoard
+python -c "
+from tensorboard.backend.event_processing.event_accumulator import EventAccumulator
+import csv
+ea = EventAccumulator('${LOGS}')
+ea.Reload()
+tags = ['Train/mean_reward','Train/mean_episode_length','Loss/value_function',
+        'Loss/surrogate','Loss/learning_rate','Policy/mean_noise_std',
+        'Episode_Reward/motion_body_pos','Episode_Reward/motion_body_ori',
+        'Episode_Reward/motion_body_lin_vel','Episode_Reward/motion_body_ang_vel',
+        'Episode_Reward/motion_global_root_pos','Episode_Reward/motion_global_root_ori',
+        'Episode_Reward/action_rate_l2','Episode_Reward/joint_limit',
+        'Episode_Reward/self_collisions','Metrics/motion/error_anchor_pos',
+        'Metrics/motion/error_anchor_rot','Metrics/motion/error_body_pos',
+        'Metrics/motion/error_body_rot','Metrics/motion/error_joint_pos',
+        'Episode_Termination/time_out','Episode_Termination/anchor_pos',
+        'Episode_Termination/anchor_ori','Perf/total_fps']
+all_data = {}
+for tag in tags:
+    for e in ea.Scalars(tag):
+        all_data.setdefault(e.step, {})[tag.replace('/','_')] = e.value
+steps = sorted(all_data)
+cols = sorted(set(c for r in all_data.values() for c in r))
+with open('${DEST}/training_log.csv','w',newline='') as f:
+    w = csv.writer(f)
+    w.writerow(['step']+cols)
+    for s in steps:
+        w.writerow([s]+[all_data[s].get(c,'') for c in cols])
+print(f'Wrote {len(steps)} rows')
+"
+
+# Regenerate metadata
+cd ~/Repositories/g1-moves
+python generate_metadata.py
+```
+
+**Verify**:
+```bash
+ls -lh ${DEST}/
+# Expected: <clip>_policy.pt, .mp4, .gif, agent.yaml, env.yaml, training_log.csv
+```
+
+### Stage 7: Commit and Push
+
+```bash
+cd ~/Repositories/g1-moves
+git add ${CATEGORY}/${CLIP}/policy/ manifest.json quality_report.json ${CATEGORY}/${CLIP}/README.md
+git commit -m "Add ${CLIP} trained policy with metadata"
+git push
+```
+
+## Batch Processing
+
+To process multiple clips end-to-end:
+
+### Retarget all (Stage 1)
+```bash
+cd ~/Repositories/g1-moves
+python retarget_all.py --workers 4
+```
+
+### Train multiple clips sequentially (Stage 4)
+```bash
+cd ~/Repositories/mjlab-gui
+for CLIP in B_DadDance J_Dance3_Woah M_Move1; do
+  CATEGORY=$(python -c "
+import json
+with open('$HOME/Repositories/g1-moves/manifest.json') as f:
+    print(json.load(f)['clips']['${CLIP}']['category'])
+  ")
+  echo "=== Training ${CLIP} (${CATEGORY}) ==="
+  MUJOCO_GL=egl MUJOCO_EGL_DEVICE_ID=0 uv run train \
+    Mjlab-Tracking-Flat-Unitree-G1 \
+    --env.commands.motion.motion-file ~/Repositories/g1-moves/${CATEGORY}/${CLIP}/training/${CLIP}.npz \
+    --env.scene.num-envs 4096 \
+    --agent.max-iterations 30000 \
+    --agent.save-interval 500 \
+    --agent.run-name ${CLIP} \
+    --video --video-interval 5000
+done
+```
+
+### Batch archive all new policies (Stage 6)
+After training completes, archive each run:
+```bash
+cd ~/Repositories/mjlab-gui/logs/rsl_rl/g1_tracking/
+for RUN_DIR in */; do
+  CLIP=$(echo ${RUN_DIR} | sed 's/.*_//' | sed 's/\///')
+  # ... run Stage 6 commands for each
+done
+```
+
+## Sim-to-Real Deployment
+
+After training a policy, deploy it to the physical G1 robot.
+
+### Sim2Sim Validation (MuJoCo to MuJoCo)
+
+Test the policy in a clean MuJoCo environment before deploying to hardware:
+
+```bash
+cd ~/Repositories/mjlab-gui
+MUJOCO_GL=egl uv run play \
+  Mjlab-Tracking-Flat-Unitree-G1 \
+  --checkpoint-file logs/rsl_rl/g1_tracking/<run>/model_29999.pt \
+  --motion-file ~/Repositories/g1-moves/<category>/<clip>/training/<clip>.npz \
+  --num-envs 1 \
+  --no-terminations \
+  --viewer viser
+```
+
+Open http://localhost:8080 to view 3D visualization.
+
+### Deploy to Physical Robot
+
+Uses RoboJuDo framework in `~/Repositories/mjlab-gui/external/RoboJuDo/`.
+
+**Entry point**: `python scripts/run_pipeline.py --config=<config_name>`
+
+#### Step 1: Export policy to TorchScript JIT
+
+mjlab saves standard PyTorch checkpoints. RoboJuDo requires TorchScript JIT (`.pt`) or ONNX (`.onnx`). Export the actor network:
+
+```bash
+cd ~/Repositories/mjlab-gui
+python -c "
+import torch
+ckpt = torch.load('logs/rsl_rl/g1_tracking/<run>/model_29999.pt', map_location='cpu', weights_only=False)
+# Extract actor network from RSL-RL checkpoint
+actor = ckpt['model_state_dict']  # Adapt based on actual model architecture
+# Script and save
+# scripted = torch.jit.script(actor_module)
+# scripted.save('exported_policy.pt')
+print('Keys:', list(ckpt.keys()))
+"
+```
+
+> **Note**: The exact export procedure depends on the mjlab actor architecture. You may need to instantiate the actor class from `src/mjlab/rl/` and load state dict before scripting. This step needs refinement once the first full training run completes.
+
+#### Step 2: Create a RoboJuDo config class
+
+Add a config to `robojudo/config/g1/g1_cfg.py` for the mjlab-trained policy. Use an existing config as template:
+
+- **Sim validation**: Extend `g1` (uses `G1MujocoEnvCfg`)
+- **Real robot**: Extend `g1_real` (uses `G1RealEnvCfg`)
+
+Key config components:
+- **Policy**: Point to exported `.pt` file, define obs/action DOF mappings
+- **Environment**: `G1MujocoEnvCfg` (sim) or `G1RealEnvCfg` (real)
+- **Controller**: `JoystickCtrlCfg` (sim), `UnitreeCtrlCfg` (real), or `MotionCtrlCfg` (motion playback)
+
+#### Step 3: Network setup (real robot only)
+
+Configure the network interface in `robojudo/config/g1/env/g1_real_env_cfg.py`:
+
+```python
+class G1RealEnvCfg(G1EnvCfg, UnitreeEnvCfg):
+    unitree: UnitreeEnvCfg.UnitreeCfg = UnitreeEnvCfg.UnitreeCfg(
+        net_if="eth0",           # Run `ifconfig` to find your interface
+        robot="g1",
+        msg_type="hg",           # G1 uses "hg" message type
+        hand_type="NONE",        # No dexterous hands
+        enable_odometry=True,
+    )
+```
+
+Connect to G1 via Ethernet (robot at `192.168.123.10`, workstation at `192.168.123.100`).
+
+#### Step 4: Run
+
+```bash
+cd ~/Repositories/mjlab-gui/external/RoboJuDo
+
+# Sim2sim validation first
+python scripts/run_pipeline.py --config=g1
+
+# Real robot deployment
+python scripts/run_pipeline.py --config=g1_real
+```
+
+The pipeline runs an infinite control loop at 50 Hz (`dt=0.02`). Emergency stop: press `A` button on controller or `Esc` on keyboard.
+
+#### Available configs
+
+| Config | Environment | Description |
+|--------|------------|-------------|
+| `g1` | MuJoCo sim | Default sim2sim with joystick |
+| `g1_real` | Real robot | Unitree controller |
+| `g1_beyondmimic` | MuJoCo sim | Motion imitation (ONNX) |
+| `g1_switch` | MuJoCo sim | Multi-policy switching |
+| `g1_h2h` | MuJoCo sim | Human2Humanoid motion imitation |
+
+#### Policy format reference
+
+| Format | Used by | Loading |
+|--------|---------|---------|
+| TorchScript JIT (`.pt`) | UnitreePolicy, AMOPolicy, H2HPolicy | `torch.jit.load()` |
+| ONNX (`.onnx`) | BeyondMimicPolicy, ASAPPolicy | `onnxruntime.InferenceSession()` |
+
+**Safety**: Always have the robot on a tether/harness for first deployment of new motions. During real robot initialization (~1000 steps), place the robot on the ground for sensor calibration. Start with slow, low-energy clips (B_Fence1, B_DadDance) before attempting high-energy dance or karate motions.
+
+## Environment Setup
+
+```bash
+# Required for headless MuJoCo rendering
+export MUJOCO_GL=egl
+export MUJOCO_EGL_DEVICE_ID=0
+
+# GPU selection (if multiple GPUs)
+export CUDA_VISIBLE_DEVICES=0
+
+# Python execution in mjlab-gui
+cd ~/Repositories/mjlab-gui
+uv run <command>       # Uses pyproject.toml dependencies
+
+# Python execution in g1-moves
+cd ~/Repositories/g1-moves
+python <script>        # Uses system Python with movin_sdk_python
+
+# video2robot (two conda envs)
+conda run -n phmr python <script>   # Pose extraction (PromptHMR)
+conda run -n gmr python <script>    # Motion retargeting (GMR)
+```
+
+## Common Issues
+
+| Problem | Fix |
+|---------|-----|
+| `CUDA out of memory` | Reduce `--env.scene.num-envs` (4096 -> 2048 -> 1024) |
+| `MUJOCO_GL error` | Set `export MUJOCO_GL=egl` before running |
+| `movin_sdk_python not found` | `pip install movin_sdk_python` |
+| `WandB login prompt` | Use `process_motion_local.py` wrapper instead of `csv_to_npz.py` |
+| Training reward not improving | Check motion NPZ is valid, try lower learning rate (1e-4) |
+| Policy falls immediately | Train longer, or check ground calibration in retarget step |
+| TensorBoard empty | Run `uv run tensorboard --logdir logs/rsl_rl` from mjlab-gui dir |
+| SMPL-X betas size mismatch | Pass `num_betas=10` to `smplx.create()` in GMR's `smpl.py` |
+| PromptHMR sam2 warning | Non-critical `_C.so undefined symbol` — results are unaffected |
+| video2robot AV1 codec | PromptHMR auto-converts to H.264; no manual step needed |
+
+## Data Formats
+
+| Format | Columns/Keys | Shape |
+|--------|-------------|-------|
+| **BVH** | 51-joint humanoid skeleton | N frames at 60 FPS |
+| **PKL** | fps, root_pos, root_rot (xyzw), dof_pos | (N, 3), (N, 4), (N, 29) |
+| **CSV** | root_xyz + root_quat_xyzw + 29 joints | N rows x 36 cols, no header |
+| **NPZ** | fps, joint_pos, joint_vel, body_pos_w, body_quat_w, body_lin_vel_w, body_ang_vel_w | (N, 29), (N, 30, 3/4) |
+| **PT** | model_state_dict, optimizer_state_dict, iter, infos | PyTorch checkpoint |

DATASET_CARD.md

@@ -0,0 +1,257 @@
+---
+license: cc-by-4.0
+task_categories:
+  - robotics
+  - reinforcement-learning
+tags:
+  - motion-capture
+  - humanoid-robot
+  - unitree-g1
+  - bvh
+  - sim-to-real
+size_categories:
+  - n<1K
+---
+
+# G1 Moves
+
+59 motion capture clips for the Unitree G1 humanoid robot (29 DOF, mode 15), captured with [MOVIN TRACIN](https://movin3d.com/) markerless motion capture. Each clip is provided at multiple pipeline stages: raw mocap (BVH/FBX), retargeted robot joint trajectories (PKL), and processed RL training data (NPZ).
+
+## Dataset Summary
+
+| | |
+|---|---|
+| **Total clips** | 59 |
+| **Total duration** | 29.5 minutes (106,149 frames at 60 FPS) |
+| **Categories** | Dance (28), Karate (27), Bonus (4) |
+| **Clip duration** | 6.5s - 119.5s |
+| **Robot** | Unitree G1, mode 15, 29 DOF |
+| **Capture system** | MOVIN TRACIN (markerless, LiDAR + vision) |
+| **Retarget SDK** | [movin_sdk_python](https://github.com/MOVIN3D/movin_sdk_python) |
+
+## Supported Tasks
+
+- **Motion imitation RL**: Train policies to track reference motions on the G1 robot using the NPZ training data
+- **Sim-to-real transfer**: Deploy trained policies from MuJoCo simulation to physical G1 hardware
+- **Motion retargeting research**: Study human-to-robot motion transfer using the BVH-to-PKL pipeline
+- **Animation / visualization**: Import FBX files into Blender, Maya, Unreal Engine, or Unity
+
+## Dataset Structure
+
+Each clip lives in its own subfolder organized by pipeline stage:
+
+```
+<category>/<clip>/
+  capture/                Original motion capture data
+    <clip>.bvh            BVH motion capture (51-joint humanoid skeleton)
+    <clip>.gif            Preview animation
+    <clip>.mp4            Preview video
+    <clip>_bl.fbx         FBX for Blender
+    <clip>_mb.fbx         FBX for Maya
+    <clip>_ue.fbx         FBX for Unreal Engine
+    <clip>_un.fbx         FBX for Unity
+  retarget/               Retargeted G1 joint trajectories
+    <clip>.pkl            Retargeted joint angles (29 DOF)
+    <clip>.csv            Joint angles as CSV (no header)
+    <clip>_retarget.gif   Retarget preview animation
+    <clip>_retarget.mp4   Retarget preview video
+  training/               Processed RL training data
+    <clip>.npz            Training data with forward kinematics
+    <clip>_training.gif   Training visualization
+    <clip>_training.mp4   Training visualization video
+  policy/                 Trained RL policy (if available)
+    <clip>_policy.pt      PyTorch checkpoint
+    <clip>_policy.gif     Policy rollout animation
+    <clip>_policy.mp4     Policy rollout video
+    agent.yaml            PPO hyperparameters
+    env.yaml              Full environment configuration
+    training_log.csv      Training metrics (rewards, losses, errors)
+```
+
+## File Format Reference
+
+### BVH (capture)
+
+Standard BVH motion capture format with a 51-joint humanoid skeleton.
+
+- **Root**: Hips (6 DOF: XYZ position + YXZ Euler rotation)
+- **Joints**: 3 DOF each (YXZ Euler rotation order)
+- **Frame rate**: 60 FPS
+- **Coordinate system**: Y-up
+
+### PKL (retarget)
+
+Python pickle containing a dict with retargeted G1 joint trajectories:
+
+| Key | Shape | Type | Description |
+|-----|-------|------|-------------|
+| `fps` | scalar | int | Frame rate (60) |
+| `root_pos` | (N, 3) | float64 | Root position in world frame (meters) |
+| `root_rot` | (N, 4) | float64 | Root orientation as quaternion (xyzw) |
+| `dof_pos` | (N, 29) | float64 | Joint angles in radians |
+
+Joint order (29 DOF):
+
+| Index | Joint | Index | Joint |
+|-------|-------|-------|-------|
+| 0 | left_hip_pitch | 15 | left_shoulder_pitch |
+| 1 | left_hip_roll | 16 | left_shoulder_roll |
+| 2 | left_hip_yaw | 17 | left_shoulder_yaw |
+| 3 | left_knee | 18 | left_elbow |
+| 4 | left_ankle_pitch | 19 | left_wrist_roll |
+| 5 | left_ankle_roll | 20 | left_wrist_pitch |
+| 6 | right_hip_pitch | 21 | left_wrist_yaw |
+| 7 | right_hip_roll | 22 | right_shoulder_pitch |
+| 8 | right_hip_yaw | 23 | right_shoulder_roll |
+| 9 | right_knee | 24 | right_shoulder_yaw |
+| 10 | right_ankle_pitch | 25 | right_elbow |
+| 11 | right_ankle_roll | 26 | right_wrist_roll |
+| 12 | waist_yaw | 27 | right_wrist_pitch |
+| 13 | waist_roll | 28 | right_wrist_yaw |
+| 14 | waist_pitch | | |
+
+### CSV (retarget)
+
+Same data as PKL in plain CSV format (no header row). 36 columns:
+
+| Columns | Content |
+|---------|---------|
+| 0-2 | Root position (x, y, z) |
+| 3-6 | Root quaternion (x, y, z, w) |
+| 7-35 | Joint angles (29 DOF, same order as PKL) |
+
+### NPZ (training)
+
+NumPy compressed archive with forward kinematics computed from the retargeted motion. Used directly as RL training reference.
+
+| Key | Shape | Type | Description |
+|-----|-------|------|-------------|
+| `fps` | (1,) | float64 | Frame rate (60) |
+| `joint_pos` | (N, 29) | float32 | Joint positions (radians) |
+| `joint_vel` | (N, 29) | float32 | Joint velocities (rad/s) |
+| `body_pos_w` | (N, 30, 3) | float32 | Body positions in world frame (meters) |
+| `body_quat_w` | (N, 30, 4) | float32 | Body orientations as quaternions |
+| `body_lin_vel_w` | (N, 30, 3) | float32 | Body linear velocities (m/s) |
+| `body_ang_vel_w` | (N, 30, 3) | float32 | Body angular velocities (rad/s) |
+
+N = BVH frames - 1 (velocity requires finite differences).
+
+### FBX (capture)
+
+Four platform-optimized FBX variants per clip:
+
+| Suffix | Target |
+|--------|--------|
+| `_bl.fbx` | Blender |
+| `_mb.fbx` | Maya |
+| `_ue.fbx` | Unreal Engine |
+| `_un.fbx` | Unity |
+
+## Usage Examples
+
+### Load retargeted motion (PKL)
+
+```python
+import pickle
+import numpy as np
+
+with open("dance/B_DadDance/retarget/B_DadDance.pkl", "rb") as f:
+    motion = pickle.load(f)
+
+print(f"FPS: {motion['fps']}")
+print(f"Duration: {motion['dof_pos'].shape[0] / motion['fps']:.1f}s")
+print(f"Root position at frame 0: {motion['root_pos'][0]}")
+print(f"Joint angles shape: {motion['dof_pos'].shape}")  # (2509, 29)
+```
+
+### Load training data (NPZ)
+
+```python
+import numpy as np
+
+data = np.load("dance/B_DadDance/training/B_DadDance.npz")
+
+joint_pos = data["joint_pos"]    # (2508, 29)
+joint_vel = data["joint_vel"]    # (2508, 29)
+body_pos = data["body_pos_w"]    # (2508, 30, 3)
+body_quat = data["body_quat_w"]  # (2508, 30, 4)
+
+# Get pelvis height over time
+pelvis_z = body_pos[:, 0, 2]
+print(f"Pelvis height: {pelvis_z.min():.3f} - {pelvis_z.max():.3f} m")
+```
+
+### Filter clips by duration or difficulty
+
+```python
+import json
+
+with open("manifest.json") as f:
+    manifest = json.load(f)
+
+# Find clips longer than 30 seconds
+long_clips = {
+    name: clip for name, clip in manifest["clips"].items()
+    if clip["duration_s"] > 30
+}
+print(f"{len(long_clips)} clips > 30s")
+
+# Sort by motion energy (difficulty proxy)
+by_energy = sorted(
+    manifest["clips"].items(),
+    key=lambda x: x[1]["motion_stats"]["mean_joint_velocity"],
+    reverse=True,
+)
+print("Most energetic:", by_energy[0][0])
+print("Least energetic:", by_energy[-1][0])
+```
+
+## Data Collection
+
+All 59 clips were captured using the [MOVIN TRACIN](https://movin3d.com/) markerless motion capture system. MOVIN TRACIN uses on-device AI to fuse LiDAR point clouds and vision into motion data without markers, suits, or multi-camera rigs. Performances were recorded and exported using [MOVIN Studio](https://www.movin3d.com/studio).
+
+### Performers
+
+| Prefix | Performer | Clips |
+|--------|-----------|-------|
+| `B_` | [Mitch Chaiet](https://mitchchaiet.com/) | Bonus clips + some dance |
+| `J_` | [Jasmine Coro](https://jasminecoro.com/) | Dance choreography |
+| `M_` | [Mike Gassaway](https://www.backstage.com/u/mike-gassaway/) | Karate / martial arts |
+
+### Processing Pipeline
+
+1. **Capture**: MOVIN TRACIN records performer motion as BVH + FBX
+2. **Retarget**: [movin_sdk_python](https://github.com/MOVIN3D/movin_sdk_python) maps human skeleton to G1 joint limits (1.75m human height)
+3. **Ground calibration**: MuJoCo forward kinematics finds minimum foot Z, shifts root for ground contact
+4. **Training data**: MuJoCo computes full-body forward kinematics (positions, orientations, velocities)
+5. **RL training**: PPO with motion imitation rewards in MuJoCo-Warp (4096 parallel envs)
+
+## Metadata Files
+
+| File | Description |
+|------|-------------|
+| `manifest.json` | Machine-readable index of all 59 clips with per-clip metadata |
+| `quality_report.json` | Automated validation (joint limits, ground penetration, frame consistency) |
+| `generate_metadata.py` | Script to regenerate all metadata from source data |
+
+## Citation
+
+```bibtex
+@misc{g1moves2026,
+  title={G1 Moves: Motion Capture Dataset for the Unitree G1 Humanoid Robot},
+  author={Chaiet, Mitch},
+  year={2026},
+  publisher={GitHub},
+  url={https://github.com/experientialtech/g1-moves}
+}
+```
+
+## License
+
+CC-BY-4.0
+
+## Acknowledgements
+
+- [MOVIN3D](https://movin3d.com/) for the MOVIN TRACIN capture system and movin_sdk_python retargeting SDK
+- [Dell Technologies](https://www.dell.com/) for the Pro Max Tower T2 workstation used for capture and training
+- [Unitree Robotics](https://www.unitree.com/) for the G1 humanoid robot platform

Motion-Player-ROS/CMakeLists.txt

@@ -0,0 +1,37 @@
+cmake_minimum_required(VERSION 3.8)
+project(motion_player)
+
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  add_compile_options(-Wall -Wextra -Wpedantic)
+endif()
+
+# find dependencies
+find_package(ament_cmake REQUIRED)
+find_package(ament_cmake_python REQUIRED)
+
+install(
+  DIRECTORY urdf meshes launch rviz
+  DESTINATION share/${PROJECT_NAME}
+)
+
+# Install Python scripts
+install(
+  PROGRAMS scripts/motion_player.py
+  DESTINATION lib/${PROJECT_NAME}
+  RENAME motion_player
+)
+
+
+if(BUILD_TESTING)
+  find_package(ament_lint_auto REQUIRED)
+  # the following line skips the linter which checks for copyrights
+  # comment the line when a copyright and license is added to all source files
+  set(ament_cmake_copyright_FOUND TRUE)
+  # the following line skips cpplint (only works in a git repo)
+  # comment the line when this package is in a git repo and when
+  # a copyright and license is added to all source files
+  set(ament_cmake_cpplint_FOUND TRUE)
+  ament_lint_auto_find_test_dependencies()
+endif()
+
+ament_package()

Motion-Player-ROS/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Motion Player Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Motion-Player-ROS/README.md

@@ -0,0 +1,188 @@
+# Motion Player
+
+A ROS 2 package for playing back motion capture data on a humanoid robot (Unitree G1) with simultaneous BVH skeleton visualization in RViz.
+
+## Demo
+
+![Demo](doc/demo.gif)
+
+## Features
+
+- **Motion Playback**: Play pre-recorded motion data (`.pkl` format) on a 29-DOF humanoid robot model
+- **Real-time Motion Retargeting**: Receive live mocap data via OSC from [MOVIN TRACIN](https://www.movin3d.com) and retarget to robot in real-time
+- **Real-time Visualization**: Simultaneously visualize both the original motion capture skeleton and retargeted robot motion in RViz
+- **BVH Visualization**: Display the original BVH motion capture skeleton alongside the robot
+- **RViz Integration**: Full visualization in RViz2 with robot model and skeleton markers
+
+## Prerequisites
+
+- **ROS 2**: Humble (tested)
+- Required ROS 2 packages:
+  - `robot_state_publisher`
+  - `rviz2`
+  - `xacro`
+  - `tf2_ros`
+
+- Required pip packages:
+  - `numpy`
+  - `scipy`
+  - `movin-sdk-python` (required for BVH loading and real-time mode)
+
+
+## Installation
+
+1. Clone this repository into your ROS 2 workspace:
+   ```bash
+   cd ~/ros2_ws/src
+   git clone https://github.com/MOVIN3D/Motion-Player-ROS
+   ```
+
+2. Install MOVIN SDK Python (required for receiving mocap data and real-time retargeting):
+   ```bash
+   pip install git+https://github.com/MOVIN3D/MOVIN-SDK-Python.git
+   ```
+   
+   For more details about MOVIN SDK, visit: https://github.com/MOVIN3D/MOVIN-SDK-Python
+
+3. Build the package:
+   ```bash
+   cd ~/ros2_ws
+   colcon build --packages-select motion_player
+   ```
+
+4. Source the workspace:
+   ```bash
+   source ~/ros2_ws/install/setup.bash
+   ```
+
+## Usage
+
+### Playback Mode (from file)
+
+Launch the motion player with pre-recorded motion files:
+```bash
+ros2 launch motion_player player.launch.py motion_file:=/path/to/your/motion.pkl bvh_file:=/path/to/your/motion.bvh
+```
+
+Or run the node directly:
+```bash
+ros2 run motion_player motion_player --ros-args -p motion_file:=/path/to/your/motion.pkl
+```
+
+### Real-time Mode (live mocap)
+
+Launch the real-time motion player to receive live mocap data via OSC from [MOVIN TRACIN](https://www.movin3d.com):
+```bash
+ros2 launch motion_player realtime.launch.py
+```
+
+This mode enables:
+- **Real-time retargeting**: Motion capture data is retargeted to the robot model on-the-fly using [MOVIN SDK Python](https://github.com/MOVIN3D/MOVIN-SDK-Python)
+- **Live visualization**: Both the original mocap skeleton and the retargeted robot motion are displayed simultaneously in RViz
+
+With custom parameters:
+```bash
+ros2 launch motion_player realtime.launch.py port:=11235 human_height:=1.80 skeleton_offset_x:=1.5
+```
+
+Or run the node directly with `--realtime` flag:
+```bash
+ros2 run motion_player motion_player --realtime --ros-args -p port:=11235 -p human_height:=1.80
+```
+
+### Launch Arguments
+
+#### player.launch.py (Playback Mode)
+
+| Argument | Default | Description |
+|----------|---------|-------------|
+| `motion_file` | (required) | Path to the motion pickle file (`.pkl`) |
+| `bvh_file` | (required) | Path to the BVH file (`.bvh`)|
+| `loop` | `true` | Whether to loop the motion playback |
+| `urdf_file` | (package default) | Path to custom URDF file |
+| `rviz_config` | (package default) | Path to custom RViz config file |
+
+#### realtime.launch.py (Real-time Mode)
+
+| Argument | Default | Description |
+|----------|---------|-------------|
+| `port` | `11235` | UDP port to listen for OSC mocap data |
+| `robot_type` | `unitree_g1` | Target robot type (`unitree_g1` or `unitree_g1_with_hands`) |
+| `human_height` | `1.75` | Human height in meters for scaling |
+| `skeleton_offset_x` | `1.0` | X offset to place skeleton beside robot |
+| `urdf_file` | (package default) | Path to custom URDF file |
+| `rviz_config` | (package default) | Path to custom RViz config file |
+
+## File Formats
+
+### Motion File (`.pkl`)
+
+The motion file contains joint angles that have been **retargeted from motion capture data to the robot URDF**. This file stores the converted motion that can be directly applied to the Unitree G1 robot model.
+
+The pickle file should contain a dictionary with:
+
+```python
+{
+    'fps': float,           # Frames per second
+    'root_pos': np.ndarray, # Root position [n_frames, 3]
+    'root_rot': np.ndarray, # Root rotation quaternion (xyzw) [n_frames, 4]
+    'dof_pos': np.ndarray,  # Joint positions [n_frames, 29]
+}
+```
+
+### BVH File (`.bvh`)
+
+The BVH file contains the **original motion capture data** from [MOVIN TRACIN](https://www.movin3d.com) motion capture system.
+
+Standard BVH (Biovision Hierarchy) motion capture format.
+The BVH skeleton will be displayed as red spheres (joints) and orange cylinders (bones) in RViz, allowing you to compare the original motion capture with the retargeted robot motion.
+
+## ROS Topics
+
+| Topic | Type | Description |
+|-------|------|-------------|
+| `/joint_states` | `sensor_msgs/JointState` | Robot joint states |
+| `/skeleton_markers` | `visualization_msgs/MarkerArray` | Skeleton visualization (both modes) |
+| `/tf` | TF2 | Robot transforms |
+
+## Project Structure
+
+```
+motion_player_ros/
+├── CMakeLists.txt
+├── package.xml
+├── README.md
+├── data/
+│   ├── test1.bvh              # Example BVH file
+│   └── test1.pkl              # Example motion file
+├── doc/
+│   └── demo.gif               
+├── launch/
+│   ├── player.launch.py       # Playback mode launch file
+│   └── realtime.launch.py     # Real-time mode launch file
+├── meshes/                    # Robot mesh files (STL)*
+├── rviz/
+│   └── robot.rviz             # RViz configuration
+├── scripts/
+│   └── motion_player.py       # Unified motion player node (supports --realtime flag)
+└── urdf/
+    └── g1_custom_collision_29dof.urdf  # Robot URDF*
+```
+
+## Acknowledgments
+
+This project uses:
+
+- **[MOVIN SDK Python](https://github.com/MOVIN3D/MOVIN-SDK-Python)** - Motion retargeting SDK for real-time mocap to robot conversion
+- **[MOVIN TRACIN](https://www.movin3d.com)** - Motion capture system for generating mocap data
+
+The URDF and STL mesh files for the Unitree G1 robot are sourced from [Unitree Robotics](https://github.com/unitreerobotics). Please refer to their repositories for the original robot models and licensing information:
+
+- [unitree_ros](https://github.com/unitreerobotics/unitree_ros) - ROS packages with URDF files for Unitree robots
+- [unitree_mujoco](https://github.com/unitreerobotics/unitree_mujoco) - Mujoco simulation for Unitree robots
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+**Note:** The robot URDF and mesh files (`urdf/` and `meshes/` directories) are from Unitree Robotics and may be subject to their own licensing terms.

Motion-Player-ROS/package.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0"?>
+<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
+<package format="3">
+  <name>motion_player</name>
+  <version>1.0.0</version>
+  <description>ROS 2 package for playing back motion capture data on humanoid robots with BVH skeleton visualization</description>
+  <maintainer email="dy.jang@movin3d.com">YUN</maintainer>
+  <license>MIT</license>
+
+  <buildtool_depend>ament_cmake</buildtool_depend>
+  <buildtool_depend>ament_cmake_python</buildtool_depend>
+
+  <exec_depend>robot_state_publisher</exec_depend>
+  <exec_depend>rviz2</exec_depend>
+  <exec_depend>xacro</exec_depend>
+  <exec_depend>rclpy</exec_depend>
+  <exec_depend>sensor_msgs</exec_depend>
+  <exec_depend>geometry_msgs</exec_depend>
+  <exec_depend>tf2_ros</exec_depend>
+
+  <test_depend>ament_lint_auto</test_depend>
+  <test_depend>ament_lint_common</test_depend>
+
+  <export>
+    <build_type>ament_cmake</build_type>
+  </export>
+</package>

README.md

@@ -0,0 +1,276 @@
+<p align="center">
+  <img src="logo.png" alt="Experiential Technologies" width="500">
+</p>
+
+# G1 Moves
+
+Motion capture clips for the Unitree G1 humanoid robot, captured with Movin Studio and exported as BVH and FBX.
+
+## Credits
+
+**Director:** [Mitch Chaiet](https://mitchchaiet.com/)
+**DIT:** [Molly Maguire](https://www.linkedin.com/in/mollymaguire001/)
+**Dance:** [Jasmine Coro](https://jasminecoro.com/)
+**Karate:** [Mike Gassaway](https://www.backstage.com/u/mike-gassaway/)
+
+## Structure
+
+```
+dance/                          28 clips — dance routines
+  B_DadDance/
+  B_LongDance/
+  B_SpiralDance/
+  B_StretchDance/
+  B_WiggleDance/
+  J_Dance0_StepTouch/
+  J_Dance1_Modern/
+  J_Dance2_Salsa/
+  J_Dance3_Woah/
+  J_Dance4_Broadway/
+  J_Dance5_Hype/
+  J_Dance6_Sassy/
+  J_Dance7_Party/
+  J_Dance8_WestCoast/
+  J_Dance9_PeaceMaker/
+  J_Dance11_Gnarly/
+  J_Dance12_LushLife/
+  J_Dance17_Shuffle/
+  J_Dance18_TikTok/
+  J_Dance19_LetsGO/
+  J_Dance20_DWG/
+  J_Dance21_Blunt/
+  J_Dance22_Thrilling/
+  J_Dance23_MidnightSun/
+  J_ShortDance13_SingleLadies/
+  J_ShortDance14_Disco/
+  J_ShortDance15_Nineties/
+  J_ShortDance16_JazzWalk/
+karate/                         27 clips — karate/martial arts moves
+  B_AttackKarate/
+  B_BowKarate/
+  B_ChopsKarate/
+  B_CrazyChopsKarate/
+  B_ForwardKarate/
+  B_LongKarate/
+  B_SpinKarate/
+  M_Move1/                — Guard Combo
+  M_Move2/                — Low Punch
+  M_Move3/                — Horse Stance
+  M_Move4/                — Spin Punch
+  M_Move5/                — Twist Punch
+  M_Move6/                — Spin Strike
+  M_Move7/                — Rapid Punch
+  M_Move8/                — Drop Spin
+  M_Move9/                — Level Change
+  M_Move10/               — Side Kick
+  M_Move11/               — Blitz
+  M_Move17/               — Double Strike
+  M_Move18/               — Front Kick
+  M_Move19/               — Slow Kata
+  M_Move20/               — Open Strike
+  M_ShortMove12/          — Quick Jab
+  M_ShortMove13/          — Snap Kick
+  M_ShortMove14/          — Light Punch
+  M_ShortMove15/          — Drop Strike
+  M_ShortMove16/          — Power Burst
+bonus/                           4 clips — fencing, hands-up, chops
+  B_Fence1/
+  B_Fence2/
+  B_HandsChop/
+  B_HandsUp/
+movin-studio-project/           Raw Movin Studio recordings and project file
+```
+
+Each clip lives in its own subfolder containing:
+
+| File | Format |
+|------|--------|
+| `<clip>.bvh` | BVH motion capture (humanoid skeleton, Hips root) |
+| `<clip>.pkl` | Retargeted G1 joint trajectories (29 DOF) |
+| `<clip>_bl.fbx` | FBX for Blender |
+| `<clip>_mb.fbx` | FBX for Maya |
+| `<clip>_ue.fbx` | FBX for Unreal Engine |
+| `<clip>_un.fbx` | FBX for Unity |
+
+## Retarget
+
+All 59 BVH clips have been retargeted to the Unitree G1 (mode 15, 29 DOF) using [movin_sdk_python](https://github.com/MOVIN3D/movin_sdk_python). The pipeline:
+
+1. **BVH → IK**: Per-frame inverse kinematics maps human skeleton to G1 joint limits (1.75m human height)
+2. **Ground calibration**: MuJoCo forward kinematics finds minimum foot Z across all frames, shifts root down for ground contact
+3. **PKL output**: `{fps, root_pos, root_rot, dof_pos}` — 60 FPS, quaternions in xyzw order, 29 joint angles
+4. **Video render**: MuJoCo offscreen 1080x1080, libx264 CRF 18
+
+Run `python retarget_all.py` to regenerate (skips existing outputs).
+
+## Equipment
+
+### Motion Capture
+
+All 59 clips were captured using the [MOVIN TRACIN](https://movin3d.com/) markerless motion capture system from [MOVIN3D](https://movin3d.com/). MOVIN TRACIN uses on-device AI to fuse LiDAR point clouds and vision into production-ready motion data — no markers, no suit, no multi-camera rig. Captured performances were recorded and exported using [MOVIN Studio](https://www.movin3d.com/studio), which provides real-time skeleton visualization, recording management, and export to BVH and FBX formats. Retargeting from human skeleton to G1 robot joint space was performed using [movin_sdk_python](https://github.com/MOVIN3D/movin_sdk_python).
+
+Thank you to [MOVIN3D](https://movin3d.com/) for building an incredible motion capture platform that makes professional-grade mocap accessible to robotics researchers.
+
+### Workstation
+
+All data was captured and policies were trained on a [Dell Pro Max Tower T2](https://creatorfolio.co/mitchbookpro) workstation from [Dell Technologies](https://www.dell.com/):
+
+| Component | Spec |
+|-----------|------|
+| CPU | Intel Core Ultra 9 285K (24 cores, up to 7.2 GHz) |
+| GPU | NVIDIA RTX PRO 6000 Blackwell Workstation Edition (96 GB GDDR7) |
+| RAM | 128 GB DDR5 |
+| Storage | 2x 4 TB WD SN8000S NVMe SSD (8 TB total) |
+| OS | Ubuntu 24.04 LTS |
+
+The RTX PRO 6000 Blackwell with 96 GB of VRAM enables running thousands of parallel MuJoCo-Warp simulation environments on a single GPU for reinforcement learning training, while the 24-core Ultra 9 285K handles motion retargeting and data processing. Thank you to [Dell Technologies](https://www.dell.com/) for providing the compute power behind this project.
+
+## Pipeline Progress
+
+| Stage | Bonus (4) | Dance (28) | Karate (27) | Total (59) |
+|-------|:---------:|:----------:|:-----------:|:----------:|
+| BVH (capture) | 4 | 28 | 27 | 59 |
+| PKL (retarget) | 4 | 28 | 27 | 59 |
+| NPZ (training) | 4 | 28 | 27 | 59 |
+| Policy (.pt) | 4 | 0 | 0 | 4 |
+| ONNX (.onnx) | 4 | 0 | 0 | 4 |
+
+## Clips
+
+### Dance (28)
+
+| Mocap | Retarget | Training |
+|-------|----------|----------|
+| **B_DadDance** | | |
+| ![](dance/B_DadDance/capture/B_DadDance.gif) | ![](dance/B_DadDance/retarget/B_DadDance_retarget.gif) | ![](dance/B_DadDance/training/B_DadDance_training.gif) |
+| **B_LongDance** | | |
+| ![](dance/B_LongDance/capture/B_LongDance.gif) | ![](dance/B_LongDance/retarget/B_LongDance_retarget.gif) | ![](dance/B_LongDance/training/B_LongDance_training.gif) |
+| **B_SpiralDance** | | |
+| ![](dance/B_SpiralDance/capture/B_SpiralDance.gif) | ![](dance/B_SpiralDance/retarget/B_SpiralDance_retarget.gif) | ![](dance/B_SpiralDance/training/B_SpiralDance_training.gif) |
+| **B_StretchDance** | | |
+| ![](dance/B_StretchDance/capture/B_StretchDance.gif) | ![](dance/B_StretchDance/retarget/B_StretchDance_retarget.gif) | ![](dance/B_StretchDance/training/B_StretchDance_training.gif) |
+| **B_WiggleDance** | | |
+| ![](dance/B_WiggleDance/capture/B_WiggleDance.gif) | ![](dance/B_WiggleDance/retarget/B_WiggleDance_retarget.gif) | ![](dance/B_WiggleDance/training/B_WiggleDance_training.gif) |
+| **J_Dance0_StepTouch** | | |
+| ![](dance/J_Dance0_StepTouch/capture/J_Dance0_StepTouch.gif) | ![](dance/J_Dance0_StepTouch/retarget/J_Dance0_StepTouch_retarget.gif) | ![](dance/J_Dance0_StepTouch/training/J_Dance0_StepTouch_training.gif) |
+| **J_Dance1_Modern** | | |
+| ![](dance/J_Dance1_Modern/capture/J_Dance1_Modern.gif) | ![](dance/J_Dance1_Modern/retarget/J_Dance1_Modern_retarget.gif) | ![](dance/J_Dance1_Modern/training/J_Dance1_Modern_training.gif) |
+| **J_Dance2_Salsa** | | |
+| ![](dance/J_Dance2_Salsa/capture/J_Dance2_Salsa.gif) | ![](dance/J_Dance2_Salsa/retarget/J_Dance2_Salsa_retarget.gif) | ![](dance/J_Dance2_Salsa/training/J_Dance2_Salsa_training.gif) |
+| **J_Dance3_Woah** | | |
+| ![](dance/J_Dance3_Woah/capture/J_Dance3_Woah.gif) | ![](dance/J_Dance3_Woah/retarget/J_Dance3_Woah_retarget.gif) | ![](dance/J_Dance3_Woah/training/J_Dance3_Woah_training.gif) |
+| **J_Dance4_Broadway** | | |
+| ![](dance/J_Dance4_Broadway/capture/J_Dance4_Broadway.gif) | ![](dance/J_Dance4_Broadway/retarget/J_Dance4_Broadway_retarget.gif) | ![](dance/J_Dance4_Broadway/training/J_Dance4_Broadway_training.gif) |
+| **J_Dance5_Hype** | | |
+| ![](dance/J_Dance5_Hype/capture/J_Dance5_Hype.gif) | ![](dance/J_Dance5_Hype/retarget/J_Dance5_Hype_retarget.gif) | ![](dance/J_Dance5_Hype/training/J_Dance5_Hype_training.gif) |
+| **J_Dance6_Sassy** | | |
+| ![](dance/J_Dance6_Sassy/capture/J_Dance6_Sassy.gif) | ![](dance/J_Dance6_Sassy/retarget/J_Dance6_Sassy_retarget.gif) | ![](dance/J_Dance6_Sassy/training/J_Dance6_Sassy_training.gif) |
+| **J_Dance7_Party** | | |
+| ![](dance/J_Dance7_Party/capture/J_Dance7_Party.gif) | ![](dance/J_Dance7_Party/retarget/J_Dance7_Party_retarget.gif) | ![](dance/J_Dance7_Party/training/J_Dance7_Party_training.gif) |
+| **J_Dance8_WestCoast** | | |
+| ![](dance/J_Dance8_WestCoast/capture/J_Dance8_WestCoast.gif) | ![](dance/J_Dance8_WestCoast/retarget/J_Dance8_WestCoast_retarget.gif) | ![](dance/J_Dance8_WestCoast/training/J_Dance8_WestCoast_training.gif) |
+| **J_Dance9_PeaceMaker** | | |
+| ![](dance/J_Dance9_PeaceMaker/capture/J_Dance9_PeaceMaker.gif) | ![](dance/J_Dance9_PeaceMaker/retarget/J_Dance9_PeaceMaker_retarget.gif) | ![](dance/J_Dance9_PeaceMaker/training/J_Dance9_PeaceMaker_training.gif) |
+| **J_Dance11_Gnarly** | | |
+| ![](dance/J_Dance11_Gnarly/capture/J_Dance11_Gnarly.gif) | ![](dance/J_Dance11_Gnarly/retarget/J_Dance11_Gnarly_retarget.gif) | ![](dance/J_Dance11_Gnarly/training/J_Dance11_Gnarly_training.gif) |
+| **J_Dance12_LushLife** | | |
+| ![](dance/J_Dance12_LushLife/capture/J_Dance12_LushLife.gif) | ![](dance/J_Dance12_LushLife/retarget/J_Dance12_LushLife_retarget.gif) | ![](dance/J_Dance12_LushLife/training/J_Dance12_LushLife_training.gif) |
+| **J_Dance17_Shuffle** | | |
+| ![](dance/J_Dance17_Shuffle/capture/J_Dance17_Shuffle.gif) | ![](dance/J_Dance17_Shuffle/retarget/J_Dance17_Shuffle_retarget.gif) | ![](dance/J_Dance17_Shuffle/training/J_Dance17_Shuffle_training.gif) |
+| **J_Dance18_TikTok** | | |
+| ![](dance/J_Dance18_TikTok/capture/J_Dance18_TikTok.gif) | ![](dance/J_Dance18_TikTok/retarget/J_Dance18_TikTok_retarget.gif) | ![](dance/J_Dance18_TikTok/training/J_Dance18_TikTok_training.gif) |
+| **J_Dance19_LetsGO** | | |
+| ![](dance/J_Dance19_LetsGO/capture/J_Dance19_LetsGO.gif) | ![](dance/J_Dance19_LetsGO/retarget/J_Dance19_LetsGO_retarget.gif) | ![](dance/J_Dance19_LetsGO/training/J_Dance19_LetsGO_training.gif) |
+| **J_Dance20_DWG** | | |
+| ![](dance/J_Dance20_DWG/capture/J_Dance20_DWG.gif) | ![](dance/J_Dance20_DWG/retarget/J_Dance20_DWG_retarget.gif) | ![](dance/J_Dance20_DWG/training/J_Dance20_DWG_training.gif) |
+| **J_Dance21_Blunt** | | |
+| ![](dance/J_Dance21_Blunt/capture/J_Dance21_Blunt.gif) | ![](dance/J_Dance21_Blunt/retarget/J_Dance21_Blunt_retarget.gif) | ![](dance/J_Dance21_Blunt/training/J_Dance21_Blunt_training.gif) |
+| **J_Dance22_Thrilling** | | |
+| ![](dance/J_Dance22_Thrilling/capture/J_Dance22_Thrilling.gif) | ![](dance/J_Dance22_Thrilling/retarget/J_Dance22_Thrilling_retarget.gif) | ![](dance/J_Dance22_Thrilling/training/J_Dance22_Thrilling_training.gif) |
+| **J_Dance23_MidnightSun** | | |
+| ![](dance/J_Dance23_MidnightSun/capture/J_Dance23_MidnightSun.gif) | ![](dance/J_Dance23_MidnightSun/retarget/J_Dance23_MidnightSun_retarget.gif) | ![](dance/J_Dance23_MidnightSun/training/J_Dance23_MidnightSun_training.gif) |
+| **J_ShortDance13_SingleLadies** | | |
+| ![](dance/J_ShortDance13_SingleLadies/capture/J_ShortDance13_SingleLadies.gif) | ![](dance/J_ShortDance13_SingleLadies/retarget/J_ShortDance13_SingleLadies_retarget.gif) | ![](dance/J_ShortDance13_SingleLadies/training/J_ShortDance13_SingleLadies_training.gif) |
+| **J_ShortDance14_Disco** | | |
+| ![](dance/J_ShortDance14_Disco/capture/J_ShortDance14_Disco.gif) | ![](dance/J_ShortDance14_Disco/retarget/J_ShortDance14_Disco_retarget.gif) | ![](dance/J_ShortDance14_Disco/training/J_ShortDance14_Disco_training.gif) |
+| **J_ShortDance15_Nineties** | | |
+| ![](dance/J_ShortDance15_Nineties/capture/J_ShortDance15_Nineties.gif) | ![](dance/J_ShortDance15_Nineties/retarget/J_ShortDance15_Nineties_retarget.gif) | ![](dance/J_ShortDance15_Nineties/training/J_ShortDance15_Nineties_training.gif) |
+| **J_ShortDance16_JazzWalk** | | |
+| ![](dance/J_ShortDance16_JazzWalk/capture/J_ShortDance16_JazzWalk.gif) | ![](dance/J_ShortDance16_JazzWalk/retarget/J_ShortDance16_JazzWalk_retarget.gif) | ![](dance/J_ShortDance16_JazzWalk/training/J_ShortDance16_JazzWalk_training.gif) |
+
+### Karate (27)
+
+| Mocap | Retarget | Training |
+|-------|----------|----------|
+| **B_AttackKarate** | | |
+| ![](karate/B_AttackKarate/capture/B_AttackKarate.gif) | ![](karate/B_AttackKarate/retarget/B_AttackKarate_retarget.gif) | ![](karate/B_AttackKarate/training/B_AttackKarate_training.gif) |
+| **B_BowKarate** | | |
+| ![](karate/B_BowKarate/capture/B_BowKarate.gif) | ![](karate/B_BowKarate/retarget/B_BowKarate_retarget.gif) | ![](karate/B_BowKarate/training/B_BowKarate_training.gif) |
+| **B_ChopsKarate** | | |
+| ![](karate/B_ChopsKarate/capture/B_ChopsKarate.gif) | ![](karate/B_ChopsKarate/retarget/B_ChopsKarate_retarget.gif) | ![](karate/B_ChopsKarate/training/B_ChopsKarate_training.gif) |
+| **B_CrazyChopsKarate** | | |
+| ![](karate/B_CrazyChopsKarate/capture/B_CrazyChopsKarate.gif) | ![](karate/B_CrazyChopsKarate/retarget/B_CrazyChopsKarate_retarget.gif) | ![](karate/B_CrazyChopsKarate/training/B_CrazyChopsKarate_training.gif) |
+| **B_ForwardKarate** | | |
+| ![](karate/B_ForwardKarate/capture/B_ForwardKarate.gif) | ![](karate/B_ForwardKarate/retarget/B_ForwardKarate_retarget.gif) | ![](karate/B_ForwardKarate/training/B_ForwardKarate_training.gif) |
+| **B_LongKarate** | | |
+| ![](karate/B_LongKarate/capture/B_LongKarate.gif) | ![](karate/B_LongKarate/retarget/B_LongKarate_retarget.gif) | ![](karate/B_LongKarate/training/B_LongKarate_training.gif) |
+| **B_SpinKarate** | | |
+| ![](karate/B_SpinKarate/capture/B_SpinKarate.gif) | ![](karate/B_SpinKarate/retarget/B_SpinKarate_retarget.gif) | ![](karate/B_SpinKarate/training/B_SpinKarate_training.gif) |
+| **M_Move1 — Guard Combo** | | |
+| ![](karate/M_Move1/capture/M_Move1.gif) | ![](karate/M_Move1/retarget/M_Move1_retarget.gif) | ![](karate/M_Move1/training/M_Move1_training.gif) |
+| **M_Move2 — Low Punch** | | |
+| ![](karate/M_Move2/capture/M_Move2.gif) | ![](karate/M_Move2/retarget/M_Move2_retarget.gif) | ![](karate/M_Move2/training/M_Move2_training.gif) |
+| **M_Move3 — Horse Stance** | | |
+| ![](karate/M_Move3/capture/M_Move3.gif) | ![](karate/M_Move3/retarget/M_Move3_retarget.gif) | ![](karate/M_Move3/training/M_Move3_training.gif) |
+| **M_Move4 — Spin Punch** | | |
+| ![](karate/M_Move4/capture/M_Move4.gif) | ![](karate/M_Move4/retarget/M_Move4_retarget.gif) | ![](karate/M_Move4/training/M_Move4_training.gif) |
+| **M_Move5 — Twist Punch** | | |
+| ![](karate/M_Move5/capture/M_Move5.gif) | ![](karate/M_Move5/retarget/M_Move5_retarget.gif) | ![](karate/M_Move5/training/M_Move5_training.gif) |
+| **M_Move6 — Spin Strike** | | |
+| ![](karate/M_Move6/capture/M_Move6.gif) | ![](karate/M_Move6/retarget/M_Move6_retarget.gif) | ![](karate/M_Move6/training/M_Move6_training.gif) |
+| **M_Move7 — Rapid Punch** | | |
+| ![](karate/M_Move7/capture/M_Move7.gif) | ![](karate/M_Move7/retarget/M_Move7_retarget.gif) | ![](karate/M_Move7/training/M_Move7_training.gif) |
+| **M_Move8 — Drop Spin** | | |
+| ![](karate/M_Move8/capture/M_Move8.gif) | ![](karate/M_Move8/retarget/M_Move8_retarget.gif) | ![](karate/M_Move8/training/M_Move8_training.gif) |
+| **M_Move9 — Level Change** | | |
+| ![](karate/M_Move9/capture/M_Move9.gif) | ![](karate/M_Move9/retarget/M_Move9_retarget.gif) | ![](karate/M_Move9/training/M_Move9_training.gif) |
+| **M_Move10 — Side Kick** | | |
+| ![](karate/M_Move10/capture/M_Move10.gif) | ![](karate/M_Move10/retarget/M_Move10_retarget.gif) | ![](karate/M_Move10/training/M_Move10_training.gif) |
+| **M_Move11 — Blitz** | | |
+| ![](karate/M_Move11/capture/M_Move11.gif) | ![](karate/M_Move11/retarget/M_Move11_retarget.gif) | ![](karate/M_Move11/training/M_Move11_training.gif) |
+| **M_Move17 — Double Strike** | | |
+| ![](karate/M_Move17/capture/M_Move17.gif) | ![](karate/M_Move17/retarget/M_Move17_retarget.gif) | ![](karate/M_Move17/training/M_Move17_training.gif) |
+| **M_Move18 — Front Kick** | | |
+| ![](karate/M_Move18/capture/M_Move18.gif) | ![](karate/M_Move18/retarget/M_Move18_retarget.gif) | ![](karate/M_Move18/training/M_Move18_training.gif) |
+| **M_Move19 — Slow Kata** | | |
+| ![](karate/M_Move19/capture/M_Move19.gif) | ![](karate/M_Move19/retarget/M_Move19_retarget.gif) | ![](karate/M_Move19/training/M_Move19_training.gif) |
+| **M_Move20 — Open Strike** | | |
+| ![](karate/M_Move20/capture/M_Move20.gif) | ![](karate/M_Move20/retarget/M_Move20_retarget.gif) | ![](karate/M_Move20/training/M_Move20_training.gif) |
+| **M_ShortMove12 — Quick Jab** | | |
+| ![](karate/M_ShortMove12/capture/M_ShortMove12.gif) | ![](karate/M_ShortMove12/retarget/M_ShortMove12_retarget.gif) | ![](karate/M_ShortMove12/training/M_ShortMove12_training.gif) |
+| **M_ShortMove13 — Snap Kick** | | |
+| ![](karate/M_ShortMove13/capture/M_ShortMove13.gif) | ![](karate/M_ShortMove13/retarget/M_ShortMove13_retarget.gif) | ![](karate/M_ShortMove13/training/M_ShortMove13_training.gif) |
+| **M_ShortMove14 — Light Punch** | | |
+| ![](karate/M_ShortMove14/capture/M_ShortMove14.gif) | ![](karate/M_ShortMove14/retarget/M_ShortMove14_retarget.gif) | ![](karate/M_ShortMove14/training/M_ShortMove14_training.gif) |
+| **M_ShortMove15 — Drop Strike** | | |
+| ![](karate/M_ShortMove15/capture/M_ShortMove15.gif) | ![](karate/M_ShortMove15/retarget/M_ShortMove15_retarget.gif) | ![](karate/M_ShortMove15/training/M_ShortMove15_training.gif) |
+| **M_ShortMove16 — Power Burst** | | |
+| ![](karate/M_ShortMove16/capture/M_ShortMove16.gif) | ![](karate/M_ShortMove16/retarget/M_ShortMove16_retarget.gif) | ![](karate/M_ShortMove16/training/M_ShortMove16_training.gif) |
+
+### Bonus (4)
+
+| Mocap | Retarget | Training | Policy |
+|-------|----------|----------|--------|
+| **B_Fence1** | | | |
+| ![](bonus/B_Fence1/capture/B_Fence1.gif) | ![](bonus/B_Fence1/retarget/B_Fence1_retarget.gif) | ![](bonus/B_Fence1/training/B_Fence1_training.gif) | ![](bonus/B_Fence1/policy/B_Fence1_policy.gif) |
+| **B_Fence2** | | | |
+| ![](bonus/B_Fence2/capture/B_Fence2.gif) | ![](bonus/B_Fence2/retarget/B_Fence2_retarget.gif) | ![](bonus/B_Fence2/training/B_Fence2_training.gif) | ![](bonus/B_Fence2/policy/B_Fence2_policy.gif) |
+| **B_HandsChop** | | | |
+| ![](bonus/B_HandsChop/capture/B_HandsChop.gif) | ![](bonus/B_HandsChop/retarget/B_HandsChop_retarget.gif) | ![](bonus/B_HandsChop/training/B_HandsChop_training.gif) | ![](bonus/B_HandsChop/policy/B_HandsChop_policy.gif) |
+| **B_HandsUp** | | | |
+| ![](bonus/B_HandsUp/capture/B_HandsUp.gif) | ![](bonus/B_HandsUp/retarget/B_HandsUp_retarget.gif) | ![](bonus/B_HandsUp/training/B_HandsUp_training.gif) | ![](bonus/B_HandsUp/policy/B_HandsUp_policy.gif) |
+
+## Capture Details
+
+- **Skeleton**: Humanoid, Hips root, 6-DOF root channels, 3-DOF joint rotations (YXZ)
+- **Export formats**: BVH + 4 FBX variants (Blender, Maya, Unreal, Unity)

app/scripts/CLAUDE.md

@@ -0,0 +1,7 @@
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+*No recent activity*
+</claude-mem-context>

bonus/CLAUDE.md

@@ -0,0 +1,11 @@
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+### Feb 22, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #1572 | 11:01 PM | ✅ | Removed incomplete B_Fence2 motion clip files | ~278 |
+</claude-mem-context>

bonus/movin_export_result.txt

@@ -0,0 +1,5 @@
+Start exporting clip 'B_DadDance'.
+Start loading MOVINMan motion : B_DadDance
+	Motion Path : recordings\Actor_1_260223_072738.bin
+Clip 'B_DadDance' exported successfully.
+

dance/CLAUDE.md

@@ -0,0 +1,7 @@
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+*No recent activity*
+</claude-mem-context>

dance/movin_export_result.txt

@@ -0,0 +1,5 @@
+Start exporting clip 'J_Dance23_MidnightSun'.
+Start loading MOVINMan motion : J_Dance23_MidnightSun
+	Motion Path : recordings\Actor_1_260223_074610.bin
+Clip 'J_Dance23_MidnightSun' exported successfully.
+

docs/plans/CLAUDE.md

@@ -0,0 +1,7 @@
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+*No recent activity*
+</claude-mem-context>

export_onnx.py

@@ -0,0 +1,215 @@
+"""Export a trained checkpoint to ONNX with bundled motion data.
+
+Usage:
+    uv run python export_onnx.py <category>/<clip>
+    uv run python export_onnx.py bonus/B_Fence1
+    uv run python export_onnx.py --all              # export all clips with policies
+"""
+
+import argparse
+import os
+import sys
+from dataclasses import asdict
+from pathlib import Path
+from typing import cast
+
+import torch
+from torch import nn
+
+import mjlab.tasks  # noqa: F401 (populate registry)
+from mjlab.envs import ManagerBasedRlEnv
+from mjlab.rl import RslRlVecEnvWrapper
+from mjlab.rl.exporter_utils import attach_metadata_to_onnx, get_base_metadata
+from mjlab.tasks.registry import load_env_cfg, load_rl_cfg, load_runner_cls
+from mjlab.tasks.tracking.mdp.commands import MotionCommand, MotionCommandCfg
+from mjlab.tasks.tracking.rl.runner import MotionTrackingOnPolicyRunner
+from mjlab.utils.torch import configure_torch_backends
+
+TASK = "Mjlab-Tracking-Flat-Unitree-G1"
+REPO_DIR = Path(__file__).resolve().parent
+
+
+class _OnnxActorModel(nn.Module):
+    """ONNX-exportable wrapper for the actor MLP + obs normalizer."""
+
+    def __init__(self, actor_critic):
+        super().__init__()
+        self.normalizer = actor_critic.actor_obs_normalizer
+        self.actor = actor_critic.actor
+        # Get input size from first Linear layer
+        for layer in self.actor:
+            if isinstance(layer, nn.Linear):
+                self.input_size = layer.in_features
+                break
+
+    def forward(self, x):
+        return self.actor(self.normalizer(x))
+
+
+class _OnnxMotionModel(nn.Module):
+    """ONNX-exportable model wrapping the policy and motion reference data."""
+
+    def __init__(self, actor_model, motion):
+        super().__init__()
+        self.policy = actor_model
+        self.register_buffer("joint_pos", motion.joint_pos.to("cpu"))
+        self.register_buffer("joint_vel", motion.joint_vel.to("cpu"))
+        self.register_buffer("body_pos_w", motion.body_pos_w.to("cpu"))
+        self.register_buffer("body_quat_w", motion.body_quat_w.to("cpu"))
+        self.register_buffer("body_lin_vel_w", motion.body_lin_vel_w.to("cpu"))
+        self.register_buffer("body_ang_vel_w", motion.body_ang_vel_w.to("cpu"))
+        self.time_step_total: int = self.joint_pos.shape[0]
+
+    def forward(self, x, time_step):
+        time_step_clamped = torch.clamp(
+            time_step.long().squeeze(-1), max=self.time_step_total - 1
+        )
+        return (
+            self.policy(x),
+            self.joint_pos[time_step_clamped],
+            self.joint_vel[time_step_clamped],
+            self.body_pos_w[time_step_clamped],
+            self.body_quat_w[time_step_clamped],
+            self.body_lin_vel_w[time_step_clamped],
+            self.body_ang_vel_w[time_step_clamped],
+        )
+
+
+def export_clip(category: str, clip: str, device: str = "cuda:0"):
+    """Export a single clip's policy to ONNX."""
+    clip_dir = REPO_DIR / category / clip
+    checkpoint = clip_dir / "policy" / f"{clip}_policy.pt"
+    motion = clip_dir / "training" / f"{clip}.npz"
+    output_dir = clip_dir / "policy"
+    output_name = f"{clip}.onnx"
+
+    if not checkpoint.exists():
+        print(f"SKIP {category}/{clip} — no policy checkpoint")
+        return False
+    if not motion.exists():
+        print(f"SKIP {category}/{clip} — no training NPZ")
+        return False
+
+    print(f"Exporting {category}/{clip}...")
+
+    env_cfg = load_env_cfg(TASK, play=True)
+    agent_cfg = load_rl_cfg(TASK)
+
+    motion_cmd = env_cfg.commands["motion"]
+    assert isinstance(motion_cmd, MotionCommandCfg)
+    motion_cmd.motion_file = str(motion)
+
+    env_cfg.scene.num_envs = 1
+    env = ManagerBasedRlEnv(cfg=env_cfg, device=device)
+    env_wrapped = RslRlVecEnvWrapper(env, clip_actions=agent_cfg.clip_actions)
+
+    runner_cls = load_runner_cls(TASK) or MotionTrackingOnPolicyRunner
+    runner = runner_cls(env_wrapped, asdict(agent_cfg), device=device)
+    runner.load(str(checkpoint), load_optimizer=False, map_location=device)
+
+    # Build ONNX model directly (bypasses runner.export_policy_to_onnx which
+    # relies on PPO.get_policy() / ActorCritic.as_onnx() that don't exist in
+    # the installed rsl_rl version).
+    actor_model = _OnnxActorModel(runner.alg.policy)
+    motion_term = cast(MotionCommand, env.command_manager.get_term("motion"))
+    model = _OnnxMotionModel(actor_model, motion_term.motion)
+    model.to("cpu")
+    model.eval()
+
+    os.makedirs(str(output_dir), exist_ok=True)
+    obs = torch.zeros(1, actor_model.input_size)
+    time_step = torch.zeros(1, 1)
+    torch.onnx.export(
+        model,
+        (obs, time_step),
+        str(output_dir / output_name),
+        export_params=True,
+        opset_version=18,
+        verbose=False,
+        input_names=["obs", "time_step"],
+        output_names=[
+            "actions",
+            "joint_pos",
+            "joint_vel",
+            "body_pos_w",
+            "body_quat_w",
+            "body_lin_vel_w",
+            "body_ang_vel_w",
+        ],
+        dynamic_axes={},
+        dynamo=False,
+    )
+
+    metadata = get_base_metadata(env, "local")
+    metadata.update(
+        {
+            "anchor_body_name": motion_term.cfg.anchor_body_name,
+            "body_names": list(motion_term.cfg.body_names),
+        }
+    )
+    attach_metadata_to_onnx(str(output_dir / output_name), metadata)
+
+    print(f"  Exported: {output_dir / output_name}")
+    env.close()
+    return True
+
+
+def find_all_clips_with_policies():
+    """Find all clips that have a trained policy checkpoint."""
+    clips = []
+    for category in ["bonus", "dance", "karate"]:
+        cat_dir = REPO_DIR / category
+        if not cat_dir.is_dir():
+            continue
+        for clip_dir in sorted(cat_dir.iterdir()):
+            if not clip_dir.is_dir():
+                continue
+            clip = clip_dir.name
+            pt = clip_dir / "policy" / f"{clip}_policy.pt"
+            npz = clip_dir / "training" / f"{clip}.npz"
+            if pt.exists() and npz.exists():
+                clips.append((category, clip))
+    return clips
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Export trained policies to ONNX")
+    parser.add_argument("clip", nargs="?", help="category/clip (e.g. bonus/B_Fence1)")
+    parser.add_argument("--all", action="store_true", help="Export all clips with policies")
+    parser.add_argument("--device", default="cuda:0", help="Device (default: cuda:0)")
+    args = parser.parse_args()
+
+    if not args.clip and not args.all:
+        parser.print_help()
+        sys.exit(1)
+
+    configure_torch_backends()
+    device = args.device if torch.cuda.is_available() else "cpu"
+
+    if args.all:
+        clips = find_all_clips_with_policies()
+        print(f"Found {len(clips)} clips with trained policies")
+        ok, skip = 0, 0
+        for category, clip in clips:
+            onnx = REPO_DIR / category / clip / "policy" / f"{clip}.onnx"
+            if onnx.exists():
+                print(f"SKIP {category}/{clip} — ONNX already exists")
+                skip += 1
+                continue
+            if export_clip(category, clip, device):
+                ok += 1
+            else:
+                skip += 1
+        print(f"\nDone: {ok} exported, {skip} skipped")
+    else:
+        parts = args.clip.strip("/").split("/")
+        if len(parts) != 2:
+            print(f"Expected category/clip, got: {args.clip}")
+            sys.exit(1)
+        category, clip = parts
+        if not export_clip(category, clip, device):
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

external/CLAUDE.md

@@ -0,0 +1,7 @@
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+*No recent activity*
+</claude-mem-context>

generate_metadata.py

@@ -0,0 +1,504 @@
+#!/usr/bin/env python3
+"""Generate dataset metadata for g1-moves repository.
+
+Reads all 59 motion capture clips and produces:
+  - manifest.json: per-clip metadata index
+  - quality_report.json: automated validation results
+  - <clip>/README.md: per-clip summary
+
+Usage:
+    python generate_metadata.py
+    python generate_metadata.py --skip-quality
+    python generate_metadata.py --clips "B_Fence*"
+"""
+
+import argparse
+import json
+import os
+import pickle
+import fnmatch
+from datetime import datetime, timezone
+
+import numpy as np
+
+# ── G1 joint configuration ──────────────────────────────────────────────────
+
+JOINT_NAMES = [
+    "left_hip_pitch_joint", "left_hip_roll_joint", "left_hip_yaw_joint",
+    "left_knee_joint", "left_ankle_pitch_joint", "left_ankle_roll_joint",
+    "right_hip_pitch_joint", "right_hip_roll_joint", "right_hip_yaw_joint",
+    "right_knee_joint", "right_ankle_pitch_joint", "right_ankle_roll_joint",
+    "waist_yaw_joint", "waist_roll_joint", "waist_pitch_joint",
+    "left_shoulder_pitch_joint", "left_shoulder_roll_joint",
+    "left_shoulder_yaw_joint", "left_elbow_joint", "left_wrist_roll_joint",
+    "left_wrist_pitch_joint", "left_wrist_yaw_joint",
+    "right_shoulder_pitch_joint", "right_shoulder_roll_joint",
+    "right_shoulder_yaw_joint", "right_elbow_joint", "right_wrist_roll_joint",
+    "right_wrist_pitch_joint", "right_wrist_yaw_joint",
+]
+
+JOINT_LIMITS = {
+    "left_hip_pitch_joint": (-2.5307, 2.8798),
+    "left_hip_roll_joint": (-0.5236, 2.9671),
+    "left_hip_yaw_joint": (-2.7576, 2.7576),
+    "left_knee_joint": (-0.0873, 2.8798),
+    "left_ankle_pitch_joint": (-0.8727, 0.5236),
+    "left_ankle_roll_joint": (-0.2618, 0.2618),
+    "right_hip_pitch_joint": (-2.5307, 2.8798),
+    "right_hip_roll_joint": (-2.9671, 0.5236),
+    "right_hip_yaw_joint": (-2.7576, 2.7576),
+    "right_knee_joint": (-0.0873, 2.8798),
+    "right_ankle_pitch_joint": (-0.8727, 0.5236),
+    "right_ankle_roll_joint": (-0.2618, 0.2618),
+    "waist_yaw_joint": (-2.6180, 2.6180),
+    "waist_roll_joint": (-0.5200, 0.5200),
+    "waist_pitch_joint": (-0.5200, 0.5200),
+    "left_shoulder_pitch_joint": (-3.0892, 2.6704),
+    "left_shoulder_roll_joint": (-1.5882, 2.2515),
+    "left_shoulder_yaw_joint": (-2.6180, 2.6180),
+    "left_elbow_joint": (-1.0472, 2.0944),
+    "left_wrist_roll_joint": (-1.9722, 1.9722),
+    "left_wrist_pitch_joint": (-1.6144, 1.6144),
+    "left_wrist_yaw_joint": (-1.6144, 1.6144),
+    "right_shoulder_pitch_joint": (-3.0892, 2.6704),
+    "right_shoulder_roll_joint": (-2.2515, 1.5882),
+    "right_shoulder_yaw_joint": (-2.6180, 2.6180),
+    "right_elbow_joint": (-1.0472, 2.0944),
+    "right_wrist_roll_joint": (-1.9722, 1.9722),
+    "right_wrist_pitch_joint": (-1.6144, 1.6144),
+    "right_wrist_yaw_joint": (-1.6144, 1.6144),
+}
+
+# Performer mapping from clip name prefix
+PERFORMERS = {
+    "B_": "Mitch Chaiet",
+    "J_": "Jasmine Coro",
+    "M_": "Mike Gassaway",
+}
+
+# Foot body indices in NPZ body_pos_w (30 bodies)
+# These are the ankle roll links which represent the foot
+FOOT_BODY_NAMES = ["left_ankle_roll_link", "right_ankle_roll_link"]
+FOOT_BODY_INDICES = [3, 6]  # indices in the 30-body array
+
+
+def get_performer(clip_name):
+    for prefix, name in PERFORMERS.items():
+        if clip_name.startswith(prefix):
+            return name
+    return "Unknown"
+
+
+def parse_bvh(path):
+    """Extract frame count, frame time, and joint count from BVH file."""
+    joints = 0
+    frames = 0
+    frame_time = 0.0
+    with open(path) as f:
+        for line in f:
+            stripped = line.strip()
+            if "JOINT" in stripped or "ROOT" in stripped:
+                joints += 1
+            if stripped.startswith("Frames:"):
+                frames = int(stripped.split(":")[1].strip())
+            if stripped.startswith("Frame Time:"):
+                frame_time = float(stripped.split(":")[1].strip())
+    return {
+        "joints": joints,
+        "frames": frames,
+        "frame_time": frame_time,
+        "fps": round(1.0 / frame_time) if frame_time > 0 else 0,
+        "duration_s": round(frames * frame_time, 2),
+    }
+
+
+def load_pkl(path):
+    """Load retargeted PKL file."""
+    with open(path, "rb") as f:
+        return pickle.load(f)
+
+
+def load_npz(path):
+    """Load training NPZ file."""
+    return np.load(path)
+
+
+def compute_motion_stats(pkl_data):
+    """Compute motion energy and difficulty metrics from PKL data."""
+    dof_pos = np.array(pkl_data["dof_pos"], dtype=np.float64)
+    root_pos = np.array(pkl_data["root_pos"], dtype=np.float64)
+    fps = int(pkl_data["fps"])
+
+    # Joint velocities (finite differences)
+    joint_vel = np.diff(dof_pos, axis=0) * fps
+    mean_joint_vel = float(np.mean(np.abs(joint_vel)))
+    max_joint_vel = float(np.max(np.abs(joint_vel)))
+
+    # Root displacement
+    root_deltas = np.diff(root_pos, axis=0)
+    root_displacement = float(np.sum(np.linalg.norm(root_deltas, axis=1)))
+
+    # Root velocity
+    root_vel = root_deltas * fps
+    mean_root_vel = float(np.mean(np.linalg.norm(root_vel, axis=1)))
+
+    return {
+        "mean_joint_velocity": round(mean_joint_vel, 4),
+        "max_joint_velocity": round(max_joint_vel, 4),
+        "root_displacement_m": round(root_displacement, 4),
+        "mean_root_velocity": round(mean_root_vel, 4),
+    }
+
+
+def compute_joint_range(pkl_data):
+    """Compute per-joint min/max from PKL data."""
+    dof_pos = np.array(pkl_data["dof_pos"], dtype=np.float64)
+    return {
+        "min": [round(float(v), 4) for v in dof_pos.min(axis=0)],
+        "max": [round(float(v), 4) for v in dof_pos.max(axis=0)],
+    }
+
+
+def check_joint_limits(pkl_data):
+    """Check for joint limit violations."""
+    dof_pos = np.array(pkl_data["dof_pos"], dtype=np.float64)
+    violations = 0
+    max_excess = 0.0
+    worst_joint = None
+
+    for j, name in enumerate(JOINT_NAMES):
+        lo, hi = JOINT_LIMITS[name]
+        below = dof_pos[:, j] < lo
+        above = dof_pos[:, j] > hi
+        joint_violations = int(np.sum(below) + np.sum(above))
+        if joint_violations > 0:
+            violations += joint_violations
+            excess_below = float(np.max(lo - dof_pos[below, j])) if np.any(below) else 0.0
+            excess_above = float(np.max(dof_pos[above, j] - hi)) if np.any(above) else 0.0
+            joint_max = max(excess_below, excess_above)
+            if joint_max > max_excess:
+                max_excess = joint_max
+                worst_joint = name
+
+    return {
+        "violations": violations,
+        "max_excess_rad": round(max_excess, 4),
+        "worst_joint": worst_joint,
+    }
+
+
+def check_ground_penetration(npz_data):
+    """Check for foot ground penetration in training data."""
+    body_pos = npz_data["body_pos_w"]  # (frames, 30, 3)
+    min_foot_z = float("inf")
+    penetration_frames = 0
+
+    for idx in FOOT_BODY_INDICES:
+        foot_z = body_pos[:, idx, 2]
+        below = foot_z < -0.01  # 1cm tolerance
+        penetration_frames += int(np.sum(below))
+        min_foot_z = min(min_foot_z, float(np.min(foot_z)))
+
+    return {
+        "penetration_frames": penetration_frames,
+        "min_foot_z_m": round(min_foot_z, 4),
+    }
+
+
+def check_nan(pkl_data, npz_data):
+    """Check for NaN values in data arrays."""
+    issues = []
+    for key in ["root_pos", "root_rot", "dof_pos"]:
+        arr = np.array(pkl_data[key])
+        if np.any(np.isnan(arr)):
+            issues.append(f"pkl.{key}")
+    for key in npz_data.files:
+        arr = npz_data[key]
+        if np.any(np.isnan(arr)):
+            issues.append(f"npz.{key}")
+    return {"has_nan": len(issues) > 0, "fields": issues}
+
+
+def get_file_sizes(clip_dir, clip_name):
+    """Get sizes of key data files."""
+    files = {
+        "bvh": f"capture/{clip_name}.bvh",
+        "pkl": f"retarget/{clip_name}.pkl",
+        "csv": f"retarget/{clip_name}.csv",
+        "npz": f"training/{clip_name}.npz",
+    }
+    sizes = {}
+    for key, rel_path in files.items():
+        full = os.path.join(clip_dir, rel_path)
+        if os.path.exists(full):
+            sizes[key] = os.path.getsize(full)
+    return sizes
+
+
+def get_pipeline_stages(clip_dir, clip_name):
+    """Determine which pipeline stages are complete."""
+    stages = []
+    if os.path.exists(os.path.join(clip_dir, "capture", f"{clip_name}.bvh")):
+        stages.append("capture")
+    if os.path.exists(os.path.join(clip_dir, "retarget", f"{clip_name}.pkl")):
+        stages.append("retarget")
+    if os.path.exists(os.path.join(clip_dir, "training", f"{clip_name}.npz")):
+        stages.append("training")
+    if os.path.exists(os.path.join(clip_dir, "policy", f"{clip_name}_policy.pt")):
+        stages.append("policy")
+    return stages
+
+
+def generate_clip_readme(clip_dir, clip_name, clip_data):
+    """Generate a README.md for a clip folder."""
+    stages = clip_data["pipeline_stages"]
+    stats = clip_data["motion_stats"]
+    has_policy = "policy" in stages
+
+    lines = [
+        f"# {clip_name}",
+        "",
+        f"**Category:** {clip_data['category'].title()} | "
+        f"**Performer:** {clip_data['performer']} | "
+        f"**Duration:** {clip_data['duration_s']}s | "
+        f"**Frames:** {clip_data['frames']}",
+        "",
+        "## Files",
+        "",
+        "| Stage | Files |",
+        "|-------|-------|",
+        f"| `capture/` | BVH, MP4, GIF, 4x FBX |",
+        f"| `retarget/` | PKL, CSV, MP4, GIF |",
+        f"| `training/` | NPZ, MP4, GIF |",
+    ]
+    if has_policy:
+        lines.append(f"| `policy/` | PT, MP4, GIF, agent.yaml, env.yaml, training_log.csv |")
+
+    lines.extend([
+        "",
+        "## Motion Stats",
+        "",
+        f"| Metric | Value |",
+        f"|--------|-------|",
+        f"| Joint velocity (mean) | {stats['mean_joint_velocity']:.2f} rad/s |",
+        f"| Joint velocity (max) | {stats['max_joint_velocity']:.2f} rad/s |",
+        f"| Root displacement | {stats['root_displacement_m']:.2f} m |",
+        f"| Root velocity (mean) | {stats['mean_root_velocity']:.2f} m/s |",
+        "",
+        "## Formats",
+        "",
+        "- **BVH**: Motion capture with 51-joint humanoid skeleton, 60 FPS",
+        f"- **PKL**: Retargeted G1 trajectories — `root_pos` ({clip_data['frames']}, 3), "
+        f"`root_rot` ({clip_data['frames']}, 4), `dof_pos` ({clip_data['frames']}, 29)",
+        f"- **NPZ**: Training data — `joint_pos/vel` ({clip_data['training_frames']}, 29), "
+        f"`body_pos/quat/vel` ({clip_data['training_frames']}, 30, 3/4)",
+        "- **FBX**: Blender (`_bl`), Maya (`_mb`), Unreal (`_ue`), Unity (`_un`)",
+        "",
+    ])
+
+    readme_path = os.path.join(clip_dir, "README.md")
+    with open(readme_path, "w") as f:
+        f.write("\n".join(lines))
+    return readme_path
+
+
+def discover_clips(base_dir, pattern=None):
+    """Find all clip directories."""
+    clips = []
+    for category in ["dance", "karate", "bonus"]:
+        cat_dir = os.path.join(base_dir, category)
+        if not os.path.isdir(cat_dir):
+            continue
+        for clip_name in sorted(os.listdir(cat_dir)):
+            clip_dir = os.path.join(cat_dir, clip_name)
+            if not os.path.isdir(clip_dir):
+                continue
+            bvh = os.path.join(clip_dir, "capture", f"{clip_name}.bvh")
+            if not os.path.exists(bvh):
+                continue
+            if pattern and not fnmatch.fnmatch(clip_name, pattern):
+                continue
+            clips.append((category, clip_name, clip_dir))
+    return clips
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate g1-moves dataset metadata")
+    parser.add_argument("--skip-quality", action="store_true", help="Skip quality checks")
+    parser.add_argument("--clips", type=str, default=None, help="Only process matching clips")
+    args = parser.parse_args()
+
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    os.chdir(base_dir)
+
+    clips = discover_clips(".", args.clips)
+    print(f"Found {len(clips)} clips")
+
+    now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    manifest = {
+        "version": "1.0",
+        "generated": now,
+        "robot": "unitree_g1",
+        "robot_mode": 15,
+        "dof": 29,
+        "capture_system": "MOVIN TRACIN",
+        "retarget_sdk": "movin_sdk_python",
+        "clips": {},
+    }
+
+    quality = {
+        "generated": now,
+        "checks": {
+            "joint_limit_violations": {"description": "Frames where retargeted angles exceed G1 limits", "clips": {}},
+            "ground_penetration": {"description": "Frames where foot Z < -1cm", "clips": {}},
+            "frame_consistency": {"description": "PKL frames == BVH frames, NPZ frames == BVH - 1", "clips": {}},
+            "nan_check": {"description": "NaN values in PKL or NPZ arrays", "clips": {}},
+            "file_completeness": {"description": "All expected files present", "clips": {}},
+        },
+        "summary": {"passed": [], "warnings": [], "errors": []},
+    }
+
+    total_frames = 0
+    total_duration = 0.0
+
+    for category, clip_name, clip_dir in clips:
+        print(f"  Processing {clip_name}...", end=" ", flush=True)
+
+        # Parse BVH
+        bvh_path = os.path.join(clip_dir, "capture", f"{clip_name}.bvh")
+        bvh = parse_bvh(bvh_path)
+
+        # Load PKL
+        pkl_path = os.path.join(clip_dir, "retarget", f"{clip_name}.pkl")
+        pkl_data = load_pkl(pkl_path)
+
+        # Load NPZ
+        npz_path = os.path.join(clip_dir, "training", f"{clip_name}.npz")
+        npz_data = load_npz(npz_path)
+
+        # Compute stats
+        motion_stats = compute_motion_stats(pkl_data)
+        joint_range = compute_joint_range(pkl_data)
+        stages = get_pipeline_stages(clip_dir, clip_name)
+        file_sizes = get_file_sizes(clip_dir, clip_name)
+
+        clip_entry = {
+            "category": category,
+            "performer": get_performer(clip_name),
+            "frames": bvh["frames"],
+            "fps": bvh["fps"],
+            "duration_s": bvh["duration_s"],
+            "bvh_joints": bvh["joints"],
+            "retarget_dof": 29,
+            "training_frames": int(npz_data["joint_pos"].shape[0]),
+            "file_sizes": file_sizes,
+            "joint_range": joint_range,
+            "motion_stats": motion_stats,
+            "has_policy": "policy" in stages,
+            "pipeline_stages": stages,
+        }
+        manifest["clips"][clip_name] = clip_entry
+
+        total_frames += bvh["frames"]
+        total_duration += bvh["duration_s"]
+
+        # Quality checks
+        if not args.skip_quality:
+            # Joint limits
+            jl = check_joint_limits(pkl_data)
+            quality["checks"]["joint_limit_violations"]["clips"][clip_name] = jl
+
+            # Ground penetration
+            gp = check_ground_penetration(npz_data)
+            quality["checks"]["ground_penetration"]["clips"][clip_name] = gp
+
+            # Frame consistency
+            pkl_frames = np.array(pkl_data["dof_pos"]).shape[0]
+            npz_frames = npz_data["joint_pos"].shape[0]
+            fc = {
+                "bvh_frames": bvh["frames"],
+                "pkl_frames": pkl_frames,
+                "npz_frames": npz_frames,
+                "pkl_match": pkl_frames == bvh["frames"],
+                "npz_match": npz_frames in (bvh["frames"], bvh["frames"] - 1),
+            }
+            quality["checks"]["frame_consistency"]["clips"][clip_name] = fc
+
+            # NaN check
+            nan = check_nan(pkl_data, npz_data)
+            quality["checks"]["nan_check"]["clips"][clip_name] = nan
+
+            # File completeness
+            expected_capture = [f"{clip_name}.bvh", f"{clip_name}.gif", f"{clip_name}.mp4",
+                                f"{clip_name}_bl.fbx", f"{clip_name}_mb.fbx",
+                                f"{clip_name}_ue.fbx", f"{clip_name}_un.fbx"]
+            expected_retarget = [f"{clip_name}.pkl", f"{clip_name}.csv",
+                                 f"{clip_name}_retarget.gif", f"{clip_name}_retarget.mp4"]
+            expected_training = [f"{clip_name}.npz",
+                                 f"{clip_name}_training.gif", f"{clip_name}_training.mp4"]
+            missing = []
+            for f in expected_capture:
+                if not os.path.exists(os.path.join(clip_dir, "capture", f)):
+                    missing.append(f"capture/{f}")
+            for f in expected_retarget:
+                if not os.path.exists(os.path.join(clip_dir, "retarget", f)):
+                    missing.append(f"retarget/{f}")
+            for f in expected_training:
+                if not os.path.exists(os.path.join(clip_dir, "training", f)):
+                    missing.append(f"training/{f}")
+            quality["checks"]["file_completeness"]["clips"][clip_name] = {
+                "complete": len(missing) == 0,
+                "missing": missing,
+            }
+
+            # Classify clip
+            has_issues = (jl["violations"] > 0 or gp["penetration_frames"] > 0 or
+                          not fc["pkl_match"] or not fc["npz_match"] or
+                          nan["has_nan"] or len(missing) > 0)
+            has_errors = nan["has_nan"] or not fc["pkl_match"] or not fc["npz_match"]
+
+            if has_errors:
+                quality["summary"]["errors"].append(clip_name)
+            elif has_issues:
+                quality["summary"]["warnings"].append(clip_name)
+            else:
+                quality["summary"]["passed"].append(clip_name)
+
+        # Generate per-clip README
+        generate_clip_readme(clip_dir, clip_name, clip_entry)
+
+        print("done")
+
+    # Add totals to manifest
+    manifest["total_clips"] = len(clips)
+    manifest["total_duration_s"] = round(total_duration, 1)
+    manifest["total_frames"] = total_frames
+    manifest["categories"] = {}
+    for cat in ["dance", "karate", "bonus"]:
+        cat_clips = [c for c in clips if c[0] == cat]
+        manifest["categories"][cat] = {
+            "clips": len(cat_clips),
+            "duration_s": round(sum(manifest["clips"][c[1]]["duration_s"] for c in cat_clips), 1),
+        }
+
+    # Write manifest
+    with open("manifest.json", "w") as f:
+        json.dump(manifest, f, indent=2)
+    print(f"\nWrote manifest.json ({len(clips)} clips)")
+
+    # Write quality report
+    if not args.skip_quality:
+        with open("quality_report.json", "w") as f:
+            json.dump(quality, f, indent=2)
+        p = len(quality["summary"]["passed"])
+        w = len(quality["summary"]["warnings"])
+        e = len(quality["summary"]["errors"])
+        print(f"Wrote quality_report.json ({p} passed, {w} warnings, {e} errors)")
+
+    print(f"Generated {len(clips)} clip READMEs")
+    print(f"\nDataset: {len(clips)} clips, {total_frames} frames, {total_duration:.0f}s ({total_duration/60:.1f} min)")
+
+
+if __name__ == "__main__":
+    main()

karate/CLAUDE.md

@@ -0,0 +1,7 @@
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+*No recent activity*
+</claude-mem-context>

karate/movin_export_result.txt

@@ -0,0 +1,5 @@
+Start exporting clip 'M_Dance20'.
+Start loading MOVINMan motion : M_Dance20
+	Motion Path : recordings\Actor_1_260223_073816.bin
+Clip 'M_Dance20' exported successfully.
+

mjlab/.dockerignore

@@ -0,0 +1,5 @@
+.venv/
+.git/
+.github/
+.gitignore
+Dockerfile

mjlab/.gitignore

@@ -0,0 +1,20 @@
+wandb/
+logs/
+onnx/
+videos/
+__pycache__/
+MUJOCO_LOG.TXT
+debug.py
+.vscode/
+*.ipynb_checkpoints/
+motions/
+*_rerun*
+artifacts/
+.venv/
+render_robots.py
+benchmark_results/
+
+# Documentation outputs.
+**/_build/*
+**/generated/*
+

mjlab/.pre-commit-config.yaml

@@ -0,0 +1,10 @@
+repos:
+- repo: https://github.com/astral-sh/ruff-pre-commit
+  # Ruff version.
+  rev: v0.14.14
+  hooks:
+    # Run the linter.
+    - id: ruff-check
+      args: [ --fix ]
+    # Run the formatter.
+    - id: ruff-format

mjlab/.python-version

@@ -0,0 +1 @@
+3.13

mjlab/CITATION.cff

@@ -0,0 +1,60 @@
+# This CITATION.cff file was generated with cffinit.
+# Visit https://bit.ly/cffinit to generate yours today!
+
+cff-version: 1.2.0
+title: >-
+  mjlab: A Lightweight Framework for GPU-Accelerated Robot Learning
+message: >-
+  If you use this software, please cite it using the
+  metadata from this file.
+type: software
+authors:
+  - given-names: Kevin
+    family-names: Zakka
+    email: zakka@berkeley.edu
+  - given-names: Brent
+    family-names: Yi
+    email: brentyi@berkeley.edu
+  - given-names: Qiayuan
+    family-names: Liao
+    email: qiayuanl@berkeley.edu
+  - given-names: Louis
+    family-names: Le Lay
+    email: le.lay.louis@gmail.com
+  - given-names: Koushil
+    family-names: Sreenath
+  - given-names: Pieter
+    family-names: Abbeel
+repository-code: 'https://github.com/mujocolab/mjlab'
+keywords:
+  - mujoco
+  - mujoco-warp
+  - simulation
+  - reinforcement-learning
+  - robotics
+license: Apache-2.0
+commit: 20233215611f55fba8cff34a1ce3f9937ab63a25
+version: 1.1.1
+date-released: '2026-02-14'
+preferred-citation:
+  type: article
+  title: >-
+    mjlab: A Lightweight Framework for GPU-Accelerated Robot Learning
+  authors:
+    - given-names: Kevin
+      family-names: Zakka
+    - given-names: Qiayuan
+      family-names: Liao
+    - given-names: Brent
+      family-names: Yi
+    - given-names: Louis
+      family-names: Le Lay
+    - given-names: Koushil
+      family-names: Sreenath
+    - given-names: Pieter
+      family-names: Abbeel
+  year: 2026
+  url: https://arxiv.org/abs/2601.22074
+  identifiers:
+    - type: arxiv
+      value: 2601.22074

mjlab/CLAUDE.md

@@ -0,0 +1,45 @@
+# Development Workflow
+
+**Always use `uv run`, not python**.
+
+```sh
+
+# 1. Make changes.
+
+# 2. Type check.
+uv run ty check  # Fast
+uv run pyright  # More thorough, but slower
+
+# 3. Run tests.
+uv run pytest tests/  # Single suite
+uv run pytest tests/<test_file>.py  # Specific file
+
+# 4. Format and lint before committing.
+uv run ruff format
+uv run ruff check --fix
+```
+
+We've bundled common commands into a Makefile for convenience.
+
+```sh
+make format     # Format and lint
+make type       # Type-check
+make check      # make format && make type
+make test-fast  # Run tests excluding slow ones
+make test       # Run the full test suite
+make docs       # Build documentation
+```
+
+Before creating a PR, ensure all checks pass with `make test`.
+
+When making user-facing changes, add an entry to `docs/source/changelog.rst`
+under the "Upcoming version (not yet released)" section using
+Added/Changed/Fixed categories.
+
+Some style guidelines to follow:
+- Line length limit is 88 columns. This applies to code, comments, and docstrings.
+- Avoid local imports unless they are strictly necessary (e.g. circular imports).
+- Tests should follow these principles:
+  - Use functions and fixtures; do not use test classes.
+  - Favor targeted, efficient tests over exhaustive edge-case coverage.
+  - Prefer running individual tests rather than the full test suite to improve iteration speed.

mjlab/CONTRIBUTING.md

@@ -0,0 +1,25 @@
+# Contributing
+
+Bug fixes and documentation improvements are always welcome. For new features, please open an issue first so we can discuss whether it fits and work out the design, as we're intentional about keeping the scope focused.
+
+## Workflow
+
+1. Fork the repository and create a feature branch.
+2. Make your changes.
+3. Ensure formatting, type checking, and tests pass: `make test-all`.
+4. Submit a pull request.
+
+Type checking (`make type`) is required, PRs that don't pass will be blocked. You can optionally install pre-commit hooks (`pre-commit install`) to catch issues early.
+
+## Changelog
+
+Add entries to the "Upcoming version" section in `docs/source/changelog.rst` under the appropriate category (Added / Changed / Fixed), following [Keep a Changelog](https://keepachangelog.com/) conventions.
+
+## Getting Help
+
+- **Issues**: https://github.com/mujocolab/mjlab/issues
+- **Discussions**: https://github.com/mujocolab/mjlab/discussions
+
+## License
+
+By contributing, you agree your contributions will be licensed under Apache 2.0.

mjlab/Dockerfile

@@ -0,0 +1,36 @@
+# Refer to uv-docker-example:
+# https://github.com/astral-sh/uv-docker-example/blob/main/standalone.Dockerfile
+# Note that we use uv to launch, so we omit the second half of the example (non-UV final image)
+
+FROM nvidia/cuda:12.8.0-devel-ubuntu24.04
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt-get update && apt-get install -y \
+    git \
+    curl \
+    libegl-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV UV_COMPILE_BYTECODE=1
+ENV UV_LINK_MODE=copy
+ENV UV_PYTHON_PREFERENCE=only-managed
+
+RUN uv python install 3.13
+
+WORKDIR /app
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    --mount=type=bind,source=uv.lock,target=uv.lock \
+    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
+    uv sync --locked --no-install-project --no-editable --no-dev
+
+ADD . /app
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --locked --no-editable --no-dev
+
+ENV MUJOCO_GL=egl
+EXPOSE 8080
+
+CMD ["uv", "run", "python", "tests/smoke_test.py"]

mjlab/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025, The mjlab Developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

mjlab/Makefile

@@ -0,0 +1,66 @@
+.PHONY: sync
+sync:
+	uv sync --all-extras --all-packages --group dev
+
+.PHONY: format
+format:
+	uv run ruff format
+	uv run ruff check --fix
+
+.PHONY: type
+type:
+	uv run ty check
+	uv run pyright
+
+.PHONY: check
+check: format type
+
+.PHONY: test
+test:
+	uv run pytest
+
+.PHONY: test-fast
+test-fast:
+	uv run pytest -m "not slow"
+
+.PHONY: test-cpu
+test-cpu:
+	FORCE_CPU=1 uv run pytest
+
+.PHONY: test-cpu-fast
+test-cpu-fast:
+	FORCE_CPU=1 uv run pytest -m "not slow"
+
+.PHONY: test-all
+test-all: check test
+
+.PHONY: build
+build:
+	uv build
+	uv run --isolated --no-project --with dist/*.whl tests/smoke_test.py
+	uv run --isolated --no-project --with dist/*.tar.gz tests/smoke_test.py
+	@echo "Build and import test successful"
+
+.PHONY: docs
+docs:
+	uv run --group docs sphinx-build docs docs/_build
+
+.PHONY: docs-multiversion
+docs-multiversion:
+	uv run --group docs sphinx-multiversion docs docs/_build
+
+.PHONY: docs-watch
+docs-watch:
+	uv run --group docs sphinx-autobuild docs docs/_build
+
+.PHONY: publish-test
+publish-test: build
+	uv publish --publish-url https://test.pypi.org/legacy/
+
+.PHONY: publish
+publish: build
+	uv publish
+
+.PHONY: docker-build
+docker-build:
+	docker build -t mjlab:latest .

mjlab/README.md

@@ -0,0 +1,233 @@
+![Project banner](https://raw.githubusercontent.com/mujocolab/mjlab/main/docs/source/_static/mjlab-banner.jpg)
+
+# mjlab
+
+[![GitHub Actions](https://img.shields.io/github/actions/workflow/status/mujocolab/mjlab/ci.yml?branch=main)](https://github.com/mujocolab/mjlab/actions/workflows/ci.yml?query=branch%3Amain)
+[![Documentation](https://github.com/mujocolab/mjlab/actions/workflows/docs.yml/badge.svg)](https://mujocolab.github.io/mjlab/)
+[![License](https://img.shields.io/github/license/mujocolab/mjlab)](https://github.com/mujocolab/mjlab/blob/main/LICENSE)
+[![Nightly Benchmarks](https://img.shields.io/badge/Nightly-Benchmarks-blue)](https://mujocolab.github.io/mjlab/nightly/)
+[![PyPI](https://img.shields.io/pypi/v/mjlab)](https://pypi.org/project/mjlab/)
+
+mjlab combines [Isaac Lab](https://github.com/isaac-sim/IsaacLab)'s manager-based API with [MuJoCo Warp](https://github.com/google-deepmind/mujoco_warp), a GPU-accelerated version of [MuJoCo](https://github.com/google-deepmind/mujoco).
+The framework provides composable building blocks for environment design,
+with minimal dependencies and direct access to native MuJoCo data structures.
+
+## Getting Started
+
+mjlab requires an NVIDIA GPU for training. macOS is supported for evaluation only.
+
+**Try it now:**
+
+Run the demo (no installation needed):
+
+```bash
+uvx --from mjlab --refresh demo
+```
+
+Or try in [Google Colab](https://colab.research.google.com/github/mujocolab/mjlab/blob/main/notebooks/demo.ipynb) (no local setup required).
+
+**Install from source:**
+
+```bash
+git clone https://github.com/mujocolab/mjlab.git && cd mjlab
+uv run demo
+```
+
+For alternative installation methods (PyPI, Docker), see the [Installation Guide](https://mujocolab.github.io/mjlab/source/installation.html).
+
+## Training Examples
+
+### 1. Velocity Tracking
+
+Train a Unitree G1 humanoid to follow velocity commands on flat terrain:
+
+```bash
+uv run train Mjlab-Velocity-Flat-Unitree-G1 --env.scene.num-envs 4096
+```
+
+**Multi-GPU Training:** Scale to multiple GPUs using `--gpu-ids`:
+
+```bash
+uv run train Mjlab-Velocity-Flat-Unitree-G1 \
+  --gpu-ids 0 1 \
+  --env.scene.num-envs 4096
+```
+
+See the [Distributed Training guide](https://mujocolab.github.io/mjlab/source/distributed_training.html) for details.
+
+Evaluate a policy while training (fetches latest checkpoint from Weights & Biases):
+
+```bash
+uv run play Mjlab-Velocity-Flat-Unitree-G1 --wandb-run-path your-org/mjlab/run-id
+```
+
+### 2. Motion Imitation
+
+Train a humanoid to mimic reference motions. mjlab uses WandB to manage motion datasets.
+See the [motion preprocessing documentation](https://github.com/HybridRobotics/whole_body_tracking/blob/main/README.md#motion-preprocessing--registry-setup) for setup instructions.
+
+```bash
+uv run train Mjlab-Tracking-Flat-Unitree-G1 --registry-name your-org/motions/motion-name --env.scene.num-envs 4096
+uv run play Mjlab-Tracking-Flat-Unitree-G1 --wandb-run-path your-org/mjlab/run-id
+```
+
+### 3. Sanity-check with Dummy Agents
+
+Use built-in agents to sanity check your MDP before training:
+
+```bash
+uv run play Mjlab-Your-Task-Id --agent zero  # Sends zero actions
+uv run play Mjlab-Your-Task-Id --agent random  # Sends uniform random actions
+```
+
+When running motion-tracking tasks, add `--registry-name your-org/motions/motion-name` to the command.
+
+
+## Community Projects
+
+mjlab is used for research and robotics applications around the world. Examples:
+
+<table>
+  <tr>
+    <td>
+      <a href="https://github.com/menloresearch/asimov-mjlab">
+        menloresearch/asimov-mjlab
+        <br /><img
+          alt="GitHub stars"
+          src="https://img.shields.io/github/stars/menloresearch/asimov-mjlab?style=social"
+        />
+      </a>
+    </td>
+    <td>Locomotion fork for the Asimov bipedal robot.</td>
+  </tr>
+  <tr>
+    <td>
+      <a href="http://husky-humanoid.github.io/">
+        HUSKY
+      </a>
+      <br />
+      <a href="https://github.com/mujocolab/mjlab/discussions/572">#572</a>
+      ·
+      <a href="https://arxiv.org/abs/2602.03205">Paper</a>
+    </td>
+    <td>
+      Humanoid skateboarding with dynamic balance control.
+    </td>
+  </tr>
+  <tr>
+    <td>
+      <a href="https://github.com/Nagi-ovo/mjlab-homierl">
+        Nagi-ovo/mjlab-homierl
+        <br /><img
+          alt="GitHub stars"
+          src="https://img.shields.io/github/stars/Nagi-ovo/mjlab-homierl?style=social"
+        />
+      </a>
+    </td>
+    <td>Multi-task H1 locomotion (walk/squat/stand) with upper-body disturbance robustness.</td>
+  </tr>
+  <tr>
+    <td>
+      <a href="https://github.com/MyoHub/mjlab_myosuite">
+        MyoHub/mjlab_myosuite
+        <br /><img
+          alt="GitHub stars"
+          src="https://img.shields.io/github/stars/MyoHub/mjlab_myosuite?style=social"
+        />
+      </a>
+    </td>
+    <td>Musculoskeletal simulation integration with MyoSuite.</td>
+  </tr>
+  <tr>
+    <td>
+      <a href="https://github.com/MarcDcls/mjlab_upkie">
+        MarcDcls/mjlab_upkie
+        <br /><img
+          alt="GitHub stars"
+          src="https://img.shields.io/github/stars/MarcDcls/mjlab_upkie?style=social"
+        />
+      </a>
+    </td>
+    <td>Velocity control for the Upkie wheeled biped.</td>
+  </tr>
+  <tr>
+    <td>
+      <a href="https://github.com/unitreerobotics/unitree_rl_mjlab">
+        unitreerobotics/unitree_rl_mjlab
+        <br /><img
+          alt="GitHub stars"
+          src="https://img.shields.io/github/stars/unitreerobotics/unitree_rl_mjlab?style=social"
+        />
+      </a>
+    </td>
+    <td>Official Unitree RL environments for Go2, G1, and H1_2.</td>
+  </tr>
+  <tr>
+    <td>
+      <a href="https://github.com/Msornerrrr/in-hand-rotation-mjlab">
+        Msornerrrr/in-hand-rotation-mjlab
+        <br /><img
+          alt="GitHub stars"
+          src="https://img.shields.io/github/stars/Msornerrrr/in-hand-rotation-mjlab?style=social"
+        />
+      </a>
+    </td>
+    <td>Sim-to-real RL for in-hand cube rotation with the LEAP Hand.</td>
+  </tr>
+</table>
+
+Want to share your project? Post in [Show and Tell](https://github.com/mujocolab/mjlab/discussions/categories/show-and-tell)!
+
+## Documentation
+
+Full documentation is available at **[mujocolab.github.io/mjlab](https://mujocolab.github.io/mjlab/)**.
+
+## Development
+
+```bash
+make test          # Run all tests
+make test-fast     # Skip slow tests
+make format        # Format and lint
+make docs          # Build docs locally
+```
+
+For development setup: `uvx pre-commit install`
+
+## Citation
+
+If you use mjlab in your research, please cite:
+
+```bibtex
+@misc{zakka2026mjlablightweightframeworkgpuaccelerated,
+  title={mjlab: A Lightweight Framework for GPU-Accelerated Robot Learning},
+  author={Kevin Zakka and Qiayuan Liao and Brent Yi and Louis Le Lay and Koushil Sreenath and Pieter Abbeel},
+  year={2026},
+  eprint={2601.22074},
+  archivePrefix={arXiv},
+  primaryClass={cs.RO},
+  url={https://arxiv.org/abs/2601.22074},
+}
+```
+
+## License
+
+mjlab is licensed under the [Apache License, Version 2.0](LICENSE).
+
+### Third-Party Code
+
+Some portions of mjlab are forked from external projects:
+
+- **`src/mjlab/utils/lab_api/`** — Utilities forked from [NVIDIA Isaac
+  Lab](https://github.com/isaac-sim/IsaacLab) (BSD-3-Clause license, see file
+  headers)
+
+Forked components retain their original licenses. See file headers for details.
+
+## Acknowledgments
+
+mjlab wouldn't exist without the excellent work of the Isaac Lab team, whose API
+design and abstractions mjlab builds upon.
+
+Thanks to the MuJoCo Warp team — especially Erik Frey and Taylor Howell — for
+answering our questions, giving helpful feedback, and implementing features
+based on our requests countless times.

mjlab/RELEASING.md

@@ -0,0 +1,76 @@
+# Releasing
+
+## Pre-release checklist
+
+1. Bump `version` in `pyproject.toml`.
+2. Update `version` and `date-released` in `CITATION.cff`.
+3. Update the "Upcoming version (not yet released)" heading in `docs/source/changelog.rst` to the new version number and date.
+4. Commit the version bump, then create an annotated tag:
+
+```sh
+git tag -a vX.Y.Z -m "Release vX.Y.Z"
+git push origin vX.Y.Z
+```
+
+## Build and verify
+
+Clean previous build artifacts, then build:
+
+```sh
+rm -rf dist/
+make build
+```
+
+This runs `uv build` to produce a wheel and sdist in `dist/`, then smoke-tests
+both artifacts in isolated environments.
+
+## Test on TestPyPI (optional but recommended)
+
+Upload to TestPyPI first to catch packaging issues before the real release:
+
+```sh
+UV_PUBLISH_TOKEN=<your-testpypi-token> make publish-test
+```
+
+Then verify the upload works end-to-end. Use `--index-strategy unsafe-best-match`
+because TestPyPI won't have all dependencies and uv needs to fall back to real
+PyPI for them:
+
+```sh
+uvx --extra-index-url https://test.pypi.org/simple/ \
+    --index-strategy unsafe-best-match \
+    --from mjlab \
+    demo
+```
+
+Note: TestPyPI requires a separate account and token from real PyPI.
+Generate one at https://test.pypi.org/manage/account/token/.
+
+## Publish to PyPI
+
+```sh
+UV_PUBLISH_TOKEN=<your-pypi-token> make publish
+```
+
+Generate a token at https://pypi.org/manage/account/token/.
+
+## Post-release
+
+Verify the release installs and runs correctly. Use `--refresh` to bypass
+the `uvx` cache (which may still hold the TestPyPI version):
+
+```sh
+uvx --refresh --from mjlab demo
+```
+
+## Releasing from a past tag
+
+If the tag has already been created and HEAD has moved ahead, check out the
+tag before building:
+
+```sh
+git checkout vX.Y.Z
+make build
+make publish
+git checkout main
+```

mjlab/pyproject.toml

@@ -0,0 +1,155 @@
+[build-system]
+requires = ["uv_build>=0.8.19,<0.9.0"]
+build-backend = "uv_build"
+
+[project]
+name = "mjlab"
+version = "1.1.1"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+readme = { file = "README.md", content-type = "text/markdown" }
+authors = [
+  {name = "The MjLab Developers"},
+]
+keywords = ["mujoco", "mujoco-warp", "simulation", "reinforcement-learning", "robotics"]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: Apache Software License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3 :: Only",
+  "Typing :: Typed",
+  "Environment :: GPU :: NVIDIA CUDA",
+  "Topic :: Scientific/Engineering",
+  "Natural Language :: English",
+]
+description = "Isaac Lab API, powered by MuJoCo-Warp, for RL and robotics research."
+requires-python = ">=3.10,<3.14"
+dependencies = [
+  "prettytable",
+  "tqdm",
+  "tyro>=1.0.1",
+  "torch>=2.7.0",
+  "torchrunx>=0.3.4",
+  "warp-lang>=1.12.0.dev",
+  "mujoco-warp>=3.5.0",
+  "mujoco>=3.5.0",
+  "trimesh>=4.8.3",
+  "viser>=1.0.21",
+  "mediapy>=1.2.6",
+  "imageio-ffmpeg",
+  "tensordict",
+  "rsl-rl-lib==4.0.1",
+  "tensorboard>=2.20.0",
+  "onnxscript>=0.5.4",
+  "wandb>=0.22.3",
+]
+
+[project.urls]
+  "Bug Reports" = "https://github.com/mujocolab/mjlab/issues"
+  "Source" = "https://github.com/mujocolab/mjlab"
+
+[project.scripts]
+train = "mjlab.scripts.train:main"
+play = "mjlab.scripts.play:main"
+demo = "mjlab.scripts.demo:main"
+list_envs = "mjlab.scripts.list_envs:main"
+viz-nan = "mjlab.scripts.nan_viz:main"
+
+[dependency-groups]
+dev = [
+  "ipdb>=0.13.13",
+  "pre-commit>=4.3.0",
+  "pyright>=1.1.408",
+  "pytest>=v9.0.2",
+  "ruff>=v0.14.14",
+  "ty>=v0.0.14",
+]
+docs = [
+  "myst-parser>=4.0.1",
+  "sphinx>=8.1.3",
+  "sphinx-autodoc-typehints>=3.0.1",
+  "sphinx-autobuild>=2024.10.3",
+  "sphinx-book-theme>=1.1.4",
+  "sphinx-copybutton>=0.5.2",
+  "sphinx-design>=0.6.1",
+  "autodocsumm",
+  "sphinxemoji",
+  "sphinxcontrib.bibtex",
+  "sphinx-icon",
+  "sphinx-tabs",
+  "sphinx_multiversion",
+]
+
+[project.optional-dependencies]
+cu128 = ["torch>=2.7.0"]
+
+[tool.uv]
+required-environments = [
+  "sys_platform == 'darwin' and platform_machine == 'arm64'",
+  "sys_platform == 'linux' and platform_machine == 'x86_64'",
+]
+
+[[tool.uv.index]]
+url = "https://pypi.org/simple"
+
+[[tool.uv.index]]
+name = "nvidia"
+url = "https://pypi.nvidia.com/"
+explicit = true
+
+[[tool.uv.index]]
+name = "pytorch-cu128"
+url = "https://download.pytorch.org/whl/cu128"
+explicit = true
+
+[[tool.uv.index]]
+name = "pytorch-cpu"
+url = "https://download.pytorch.org/whl/cpu"
+explicit = true
+
+[[tool.uv.index]]
+name = "mujoco"
+url = "https://py.mujoco.org"
+explicit = true
+
+[tool.uv.sources]
+warp-lang = { index = "nvidia", marker = "sys_platform != 'darwin'" }
+torch = { index = "pytorch-cu128", extra = "cu128", marker = "sys_platform != 'darwin'" }
+mujoco = { index = "mujoco" }
+mujoco-warp = { git = "https://github.com/google-deepmind/mujoco_warp", rev = "fc9158989525538db53a2a8c3c0f156cbfeca911" }
+
+[tool.ruff]
+src = ["src"]  # Helpful for recognizing first-party imports.
+indent-width = 2
+exclude = [
+  "src/mjlab/utils/lab_api",
+  "typings",
+]
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "I", "B"]
+ignore = ["B011"]
+
+[tool.pyright]
+pythonVersion = "3.10"
+ignore = ["./typings", "./src/mjlab/utils/lab_api", "./docs"]
+stubPath = "typings"
+
+[tool.ty.environment]
+extra-paths = ["typings"]
+
+[tool.ty.src]
+include = ["src", "tests"]
+exclude = ["src/mjlab/utils/lab_api", "typings"]
+
+[tool.pytest.ini_options]
+markers = [
+  "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+]
+addopts = "--strict-markers"

quality_report.json

@@ -0,0 +1,1512 @@
+{
+  "generated": "2026-02-25T06:18:21Z",
+  "checks": {
+    "joint_limit_violations": {
+      "description": "Frames where retargeted angles exceed G1 limits",
+      "clips": {
+        "B_DadDance": {
+          "violations": 1,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "B_LongDance": {
+          "violations": 62,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "B_SpiralDance": {
+          "violations": 0,
+          "max_excess_rad": 0.0,
+          "worst_joint": null
+        },
+        "B_StretchDance": {
+          "violations": 0,
+          "max_excess_rad": 0.0,
+          "worst_joint": null
+        },
+        "B_WiggleDance": {
+          "violations": 0,
+          "max_excess_rad": 0.0,
+          "worst_joint": null
+        },
+        "J_Dance0_StepTouch": {
+          "violations": 281,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "J_Dance11_Gnarly": {
+          "violations": 2,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "J_Dance12_LushLife": {
+          "violations": 0,
+          "max_excess_rad": 0.0,
+          "worst_joint": null
+        },
+        "J_Dance17_Shuffle": {
+          "violations": 16,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "J_Dance18_TikTok": {
+          "violations": 8,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "J_Dance19_LetsGO": {
+          "violations": 0,
+          "max_excess_rad": 0.0,
+          "worst_joint": null
+        },
+        "J_Dance1_Modern": {
+          "violations": 58,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "J_Dance20_DWG": {
+          "violations": 0,
+          "max_excess_rad": 0.0,
+          "worst_joint": null
+        },
+        "J_Dance21_Blunt": {
+          "violations": 81,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "J_Dance22_Thrilling": {
+          "violations": 17,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "J_Dance23_MidnightSun": {
+          "violations": 31,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "J_Dance2_Salsa": {
+          "violations": 9,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "J_Dance3_Woah": {
+          "violations": 109,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "J_Dance4_Broadway": {
+          "violations": 27,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "J_Dance5_Hype": {
+          "violations": 134,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "J_Dance6_Sassy": {
+          "violations": 0,
+          "max_excess_rad": 0.0,
+          "worst_joint": null
+        },
+        "J_Dance7_Party": {
+          "violations": 38,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "J_Dance8_WestCoast": {
+          "violations": 11,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "J_Dance9_PeaceMaker": {
+          "violations": 105,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "J_ShortDance13_SingleLadies": {
+          "violations": 0,
+          "max_excess_rad": 0.0,
+          "worst_joint": null
+        },
+        "J_ShortDance14_Disco": {
+          "violations": 1,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "J_ShortDance15_Nineties": {
+          "violations": 2,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "J_ShortDance16_JazzWalk": {
+          "violations": 1,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "B_AttackKarate": {
+          "violations": 310,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "B_BowKarate": {
+          "violations": 283,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "B_ChopsKarate": {
+          "violations": 149,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "B_CrazyChopsKarate": {
+          "violations": 68,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "B_ForwardKarate": {
+          "violations": 132,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "B_LongKarate": {
+          "violations": 398,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "B_SpinKarate": {
+          "violations": 208,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "M_Move1": {
+          "violations": 376,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "M_Move10": {
+          "violations": 80,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "M_Move11": {
+          "violations": 117,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "M_Move17": {
+          "violations": 53,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "M_Move18": {
+          "violations": 77,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "M_Move19": {
+          "violations": 7,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "M_Move2": {
+          "violations": 477,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "M_Move20": {
+          "violations": 56,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "M_Move3": {
+          "violations": 331,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "M_Move4": {
+          "violations": 330,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "M_Move5": {
+          "violations": 297,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "M_Move6": {
+          "violations": 98,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "M_Move7": {
+          "violations": 167,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "M_Move8": {
+          "violations": 117,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "M_Move9": {
+          "violations": 182,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "M_ShortMove12": {
+          "violations": 10,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "M_ShortMove13": {
+          "violations": 37,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "M_ShortMove14": {
+          "violations": 16,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "M_ShortMove15": {
+          "violations": 46,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "M_ShortMove16": {
+          "violations": 76,
+          "max_excess_rad": 0.0,
+          "worst_joint": "right_ankle_roll_joint"
+        },
+        "B_Fence1": {
+          "violations": 17,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "B_Fence2": {
+          "violations": 35,
+          "max_excess_rad": 0.0,
+          "worst_joint": "left_ankle_roll_joint"
+        },
+        "B_HandsChop": {
+          "violations": 0,
+          "max_excess_rad": 0.0,
+          "worst_joint": null
+        },
+        "B_HandsUp": {
+          "violations": 0,
+          "max_excess_rad": 0.0,
+          "worst_joint": null
+        }
+      }
+    },
+    "ground_penetration": {
+      "description": "Frames where foot Z < -1cm",
+      "clips": {
+        "B_DadDance": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0423
+        },
+        "B_LongDance": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0424
+        },
+        "B_SpiralDance": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0361
+        },
+        "B_StretchDance": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0323
+        },
+        "B_WiggleDance": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0313
+        },
+        "J_Dance0_StepTouch": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0367
+        },
+        "J_Dance11_Gnarly": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.035
+        },
+        "J_Dance12_LushLife": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0371
+        },
+        "J_Dance17_Shuffle": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0387
+        },
+        "J_Dance18_TikTok": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0344
+        },
+        "J_Dance19_LetsGO": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0419
+        },
+        "J_Dance1_Modern": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0369
+        },
+        "J_Dance20_DWG": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0335
+        },
+        "J_Dance21_Blunt": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0494
+        },
+        "J_Dance22_Thrilling": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0382
+        },
+        "J_Dance23_MidnightSun": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0335
+        },
+        "J_Dance2_Salsa": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0386
+        },
+        "J_Dance3_Woah": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0399
+        },
+        "J_Dance4_Broadway": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0394
+        },
+        "J_Dance5_Hype": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0384
+        },
+        "J_Dance6_Sassy": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0348
+        },
+        "J_Dance7_Party": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0435
+        },
+        "J_Dance8_WestCoast": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0607
+        },
+        "J_Dance9_PeaceMaker": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0359
+        },
+        "J_ShortDance13_SingleLadies": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0331
+        },
+        "J_ShortDance14_Disco": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0394
+        },
+        "J_ShortDance15_Nineties": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.038
+        },
+        "J_ShortDance16_JazzWalk": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0353
+        },
+        "B_AttackKarate": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0371
+        },
+        "B_BowKarate": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0355
+        },
+        "B_ChopsKarate": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0406
+        },
+        "B_CrazyChopsKarate": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0381
+        },
+        "B_ForwardKarate": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0415
+        },
+        "B_LongKarate": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0346
+        },
+        "B_SpinKarate": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0406
+        },
+        "M_Move1": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0353
+        },
+        "M_Move10": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.038
+        },
+        "M_Move11": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0381
+        },
+        "M_Move17": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0313
+        },
+        "M_Move18": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0355
+        },
+        "M_Move19": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0355
+        },
+        "M_Move2": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0362
+        },
+        "M_Move20": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0365
+        },
+        "M_Move3": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0365
+        },
+        "M_Move4": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0418
+        },
+        "M_Move5": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.042
+        },
+        "M_Move6": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0335
+        },
+        "M_Move7": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0375
+        },
+        "M_Move8": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0469
+        },
+        "M_Move9": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0361
+        },
+        "M_ShortMove12": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0336
+        },
+        "M_ShortMove13": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0324
+        },
+        "M_ShortMove14": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0346
+        },
+        "M_ShortMove15": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.038
+        },
+        "M_ShortMove16": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0365
+        },
+        "B_Fence1": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0394
+        },
+        "B_Fence2": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0414
+        },
+        "B_HandsChop": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.0361
+        },
+        "B_HandsUp": {
+          "penetration_frames": 0,
+          "min_foot_z_m": 0.05
+        }
+      }
+    },
+    "frame_consistency": {
+      "description": "PKL frames == BVH frames, NPZ frames == BVH - 1",
+      "clips": {
+        "B_DadDance": {
+          "bvh_frames": 2509,
+          "pkl_frames": 2509,
+          "npz_frames": 2508,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "B_LongDance": {
+          "bvh_frames": 7167,
+          "pkl_frames": 7167,
+          "npz_frames": 7166,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "B_SpiralDance": {
+          "bvh_frames": 2868,
+          "pkl_frames": 2868,
+          "npz_frames": 2867,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "B_StretchDance": {
+          "bvh_frames": 2586,
+          "pkl_frames": 2586,
+          "npz_frames": 2585,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "B_WiggleDance": {
+          "bvh_frames": 2237,
+          "pkl_frames": 2237,
+          "npz_frames": 2236,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance0_StepTouch": {
+          "bvh_frames": 1949,
+          "pkl_frames": 1949,
+          "npz_frames": 1949,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance11_Gnarly": {
+          "bvh_frames": 2709,
+          "pkl_frames": 2709,
+          "npz_frames": 2708,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance12_LushLife": {
+          "bvh_frames": 2136,
+          "pkl_frames": 2136,
+          "npz_frames": 2135,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance17_Shuffle": {
+          "bvh_frames": 1922,
+          "pkl_frames": 1922,
+          "npz_frames": 1921,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance18_TikTok": {
+          "bvh_frames": 1077,
+          "pkl_frames": 1077,
+          "npz_frames": 1076,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance19_LetsGO": {
+          "bvh_frames": 1491,
+          "pkl_frames": 1491,
+          "npz_frames": 1490,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance1_Modern": {
+          "bvh_frames": 2265,
+          "pkl_frames": 2265,
+          "npz_frames": 2264,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance20_DWG": {
+          "bvh_frames": 938,
+          "pkl_frames": 938,
+          "npz_frames": 937,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance21_Blunt": {
+          "bvh_frames": 1725,
+          "pkl_frames": 1725,
+          "npz_frames": 1724,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance22_Thrilling": {
+          "bvh_frames": 1619,
+          "pkl_frames": 1619,
+          "npz_frames": 1618,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance23_MidnightSun": {
+          "bvh_frames": 2915,
+          "pkl_frames": 2915,
+          "npz_frames": 2914,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance2_Salsa": {
+          "bvh_frames": 2151,
+          "pkl_frames": 2151,
+          "npz_frames": 2150,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance3_Woah": {
+          "bvh_frames": 1800,
+          "pkl_frames": 1800,
+          "npz_frames": 1799,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance4_Broadway": {
+          "bvh_frames": 1677,
+          "pkl_frames": 1677,
+          "npz_frames": 1676,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance5_Hype": {
+          "bvh_frames": 1896,
+          "pkl_frames": 1896,
+          "npz_frames": 1895,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance6_Sassy": {
+          "bvh_frames": 1914,
+          "pkl_frames": 1914,
+          "npz_frames": 1913,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance7_Party": {
+          "bvh_frames": 2773,
+          "pkl_frames": 2773,
+          "npz_frames": 2772,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance8_WestCoast": {
+          "bvh_frames": 2395,
+          "pkl_frames": 2395,
+          "npz_frames": 2394,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_Dance9_PeaceMaker": {
+          "bvh_frames": 3501,
+          "pkl_frames": 3501,
+          "npz_frames": 3500,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_ShortDance13_SingleLadies": {
+          "bvh_frames": 842,
+          "pkl_frames": 842,
+          "npz_frames": 841,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_ShortDance14_Disco": {
+          "bvh_frames": 858,
+          "pkl_frames": 858,
+          "npz_frames": 857,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_ShortDance15_Nineties": {
+          "bvh_frames": 787,
+          "pkl_frames": 787,
+          "npz_frames": 786,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "J_ShortDance16_JazzWalk": {
+          "bvh_frames": 637,
+          "pkl_frames": 637,
+          "npz_frames": 636,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "B_AttackKarate": {
+          "bvh_frames": 2831,
+          "pkl_frames": 2831,
+          "npz_frames": 2830,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "B_BowKarate": {
+          "bvh_frames": 2254,
+          "pkl_frames": 2254,
+          "npz_frames": 2253,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "B_ChopsKarate": {
+          "bvh_frames": 3160,
+          "pkl_frames": 3160,
+          "npz_frames": 3159,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "B_CrazyChopsKarate": {
+          "bvh_frames": 1452,
+          "pkl_frames": 1452,
+          "npz_frames": 1451,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "B_ForwardKarate": {
+          "bvh_frames": 2180,
+          "pkl_frames": 2180,
+          "npz_frames": 2179,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "B_LongKarate": {
+          "bvh_frames": 2881,
+          "pkl_frames": 2881,
+          "npz_frames": 2880,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "B_SpinKarate": {
+          "bvh_frames": 1540,
+          "pkl_frames": 1540,
+          "npz_frames": 1539,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_Move1": {
+          "bvh_frames": 1870,
+          "pkl_frames": 1870,
+          "npz_frames": 1869,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_Move10": {
+          "bvh_frames": 1832,
+          "pkl_frames": 1832,
+          "npz_frames": 1831,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_Move11": {
+          "bvh_frames": 996,
+          "pkl_frames": 996,
+          "npz_frames": 995,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_Move17": {
+          "bvh_frames": 1598,
+          "pkl_frames": 1598,
+          "npz_frames": 1597,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_Move18": {
+          "bvh_frames": 1003,
+          "pkl_frames": 1003,
+          "npz_frames": 1002,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_Move19": {
+          "bvh_frames": 1012,
+          "pkl_frames": 1012,
+          "npz_frames": 1012,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_Move2": {
+          "bvh_frames": 2187,
+          "pkl_frames": 2187,
+          "npz_frames": 2186,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_Move20": {
+          "bvh_frames": 1414,
+          "pkl_frames": 1414,
+          "npz_frames": 1413,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_Move3": {
+          "bvh_frames": 1918,
+          "pkl_frames": 1918,
+          "npz_frames": 1917,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_Move4": {
+          "bvh_frames": 1755,
+          "pkl_frames": 1755,
+          "npz_frames": 1754,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_Move5": {
+          "bvh_frames": 2159,
+          "pkl_frames": 2159,
+          "npz_frames": 2158,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_Move6": {
+          "bvh_frames": 2137,
+          "pkl_frames": 2137,
+          "npz_frames": 2136,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_Move7": {
+          "bvh_frames": 1429,
+          "pkl_frames": 1429,
+          "npz_frames": 1428,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_Move8": {
+          "bvh_frames": 843,
+          "pkl_frames": 843,
+          "npz_frames": 842,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_Move9": {
+          "bvh_frames": 1638,
+          "pkl_frames": 1638,
+          "npz_frames": 1637,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_ShortMove12": {
+          "bvh_frames": 467,
+          "pkl_frames": 467,
+          "npz_frames": 466,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_ShortMove13": {
+          "bvh_frames": 539,
+          "pkl_frames": 539,
+          "npz_frames": 538,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_ShortMove14": {
+          "bvh_frames": 393,
+          "pkl_frames": 393,
+          "npz_frames": 392,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_ShortMove15": {
+          "bvh_frames": 408,
+          "pkl_frames": 408,
+          "npz_frames": 407,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "M_ShortMove16": {
+          "bvh_frames": 443,
+          "pkl_frames": 443,
+          "npz_frames": 442,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "B_Fence1": {
+          "bvh_frames": 1620,
+          "pkl_frames": 1620,
+          "npz_frames": 1619,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "B_Fence2": {
+          "bvh_frames": 638,
+          "pkl_frames": 638,
+          "npz_frames": 637,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "B_HandsChop": {
+          "bvh_frames": 1766,
+          "pkl_frames": 1766,
+          "npz_frames": 1765,
+          "pkl_match": true,
+          "npz_match": true
+        },
+        "B_HandsUp": {
+          "bvh_frames": 442,
+          "pkl_frames": 442,
+          "npz_frames": 441,
+          "pkl_match": true,
+          "npz_match": true
+        }
+      }
+    },
+    "nan_check": {
+      "description": "NaN values in PKL or NPZ arrays",
+      "clips": {
+        "B_DadDance": {
+          "has_nan": false,
+          "fields": []
+        },
+        "B_LongDance": {
+          "has_nan": false,
+          "fields": []
+        },
+        "B_SpiralDance": {
+          "has_nan": false,
+          "fields": []
+        },
+        "B_StretchDance": {
+          "has_nan": false,
+          "fields": []
+        },
+        "B_WiggleDance": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance0_StepTouch": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance11_Gnarly": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance12_LushLife": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance17_Shuffle": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance18_TikTok": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance19_LetsGO": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance1_Modern": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance20_DWG": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance21_Blunt": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance22_Thrilling": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance23_MidnightSun": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance2_Salsa": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance3_Woah": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance4_Broadway": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance5_Hype": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance6_Sassy": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance7_Party": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance8_WestCoast": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_Dance9_PeaceMaker": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_ShortDance13_SingleLadies": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_ShortDance14_Disco": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_ShortDance15_Nineties": {
+          "has_nan": false,
+          "fields": []
+        },
+        "J_ShortDance16_JazzWalk": {
+          "has_nan": false,
+          "fields": []
+        },
+        "B_AttackKarate": {
+          "has_nan": false,
+          "fields": []
+        },
+        "B_BowKarate": {
+          "has_nan": false,
+          "fields": []
+        },
+        "B_ChopsKarate": {
+          "has_nan": false,
+          "fields": []
+        },
+        "B_CrazyChopsKarate": {
+          "has_nan": false,
+          "fields": []
+        },
+        "B_ForwardKarate": {
+          "has_nan": false,
+          "fields": []
+        },
+        "B_LongKarate": {
+          "has_nan": false,
+          "fields": []
+        },
+        "B_SpinKarate": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_Move1": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_Move10": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_Move11": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_Move17": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_Move18": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_Move19": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_Move2": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_Move20": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_Move3": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_Move4": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_Move5": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_Move6": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_Move7": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_Move8": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_Move9": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_ShortMove12": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_ShortMove13": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_ShortMove14": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_ShortMove15": {
+          "has_nan": false,
+          "fields": []
+        },
+        "M_ShortMove16": {
+          "has_nan": false,
+          "fields": []
+        },
+        "B_Fence1": {
+          "has_nan": false,
+          "fields": []
+        },
+        "B_Fence2": {
+          "has_nan": false,
+          "fields": []
+        },
+        "B_HandsChop": {
+          "has_nan": false,
+          "fields": []
+        },
+        "B_HandsUp": {
+          "has_nan": false,
+          "fields": []
+        }
+      }
+    },
+    "file_completeness": {
+      "description": "All expected files present",
+      "clips": {
+        "B_DadDance": {
+          "complete": true,
+          "missing": []
+        },
+        "B_LongDance": {
+          "complete": true,
+          "missing": []
+        },
+        "B_SpiralDance": {
+          "complete": true,
+          "missing": []
+        },
+        "B_StretchDance": {
+          "complete": true,
+          "missing": []
+        },
+        "B_WiggleDance": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance0_StepTouch": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance11_Gnarly": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance12_LushLife": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance17_Shuffle": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance18_TikTok": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance19_LetsGO": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance1_Modern": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance20_DWG": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance21_Blunt": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance22_Thrilling": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance23_MidnightSun": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance2_Salsa": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance3_Woah": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance4_Broadway": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance5_Hype": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance6_Sassy": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance7_Party": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance8_WestCoast": {
+          "complete": true,
+          "missing": []
+        },
+        "J_Dance9_PeaceMaker": {
+          "complete": true,
+          "missing": []
+        },
+        "J_ShortDance13_SingleLadies": {
+          "complete": true,
+          "missing": []
+        },
+        "J_ShortDance14_Disco": {
+          "complete": true,
+          "missing": []
+        },
+        "J_ShortDance15_Nineties": {
+          "complete": true,
+          "missing": []
+        },
+        "J_ShortDance16_JazzWalk": {
+          "complete": true,
+          "missing": []
+        },
+        "B_AttackKarate": {
+          "complete": true,
+          "missing": []
+        },
+        "B_BowKarate": {
+          "complete": true,
+          "missing": []
+        },
+        "B_ChopsKarate": {
+          "complete": true,
+          "missing": []
+        },
+        "B_CrazyChopsKarate": {
+          "complete": true,
+          "missing": []
+        },
+        "B_ForwardKarate": {
+          "complete": true,
+          "missing": []
+        },
+        "B_LongKarate": {
+          "complete": true,
+          "missing": []
+        },
+        "B_SpinKarate": {
+          "complete": true,
+          "missing": []
+        },
+        "M_Move1": {
+          "complete": true,
+          "missing": []
+        },
+        "M_Move10": {
+          "complete": true,
+          "missing": []
+        },
+        "M_Move11": {
+          "complete": true,
+          "missing": []
+        },
+        "M_Move17": {
+          "complete": true,
+          "missing": []
+        },
+        "M_Move18": {
+          "complete": true,
+          "missing": []
+        },
+        "M_Move19": {
+          "complete": true,
+          "missing": []
+        },
+        "M_Move2": {
+          "complete": true,
+          "missing": []
+        },
+        "M_Move20": {
+          "complete": true,
+          "missing": []
+        },
+        "M_Move3": {
+          "complete": true,
+          "missing": []
+        },
+        "M_Move4": {
+          "complete": true,
+          "missing": []
+        },
+        "M_Move5": {
+          "complete": true,
+          "missing": []
+        },
+        "M_Move6": {
+          "complete": true,
+          "missing": []
+        },
+        "M_Move7": {
+          "complete": true,
+          "missing": []
+        },
+        "M_Move8": {
+          "complete": true,
+          "missing": []
+        },
+        "M_Move9": {
+          "complete": true,
+          "missing": []
+        },
+        "M_ShortMove12": {
+          "complete": true,
+          "missing": []
+        },
+        "M_ShortMove13": {
+          "complete": true,
+          "missing": []
+        },
+        "M_ShortMove14": {
+          "complete": true,
+          "missing": []
+        },
+        "M_ShortMove15": {
+          "complete": true,
+          "missing": []
+        },
+        "M_ShortMove16": {
+          "complete": true,
+          "missing": []
+        },
+        "B_Fence1": {
+          "complete": true,
+          "missing": []
+        },
+        "B_Fence2": {
+          "complete": true,
+          "missing": []
+        },
+        "B_HandsChop": {
+          "complete": true,
+          "missing": []
+        },
+        "B_HandsUp": {
+          "complete": true,
+          "missing": []
+        }
+      }
+    }
+  },
+  "summary": {
+    "passed": [
+      "B_SpiralDance",
+      "B_StretchDance",
+      "B_WiggleDance",
+      "J_Dance12_LushLife",
+      "J_Dance19_LetsGO",
+      "J_Dance20_DWG",
+      "J_Dance6_Sassy",
+      "J_ShortDance13_SingleLadies",
+      "B_HandsChop",
+      "B_HandsUp"
+    ],
+    "warnings": [
+      "B_DadDance",
+      "B_LongDance",
+      "J_Dance0_StepTouch",
+      "J_Dance11_Gnarly",
+      "J_Dance17_Shuffle",
+      "J_Dance18_TikTok",
+      "J_Dance1_Modern",
+      "J_Dance21_Blunt",
+      "J_Dance22_Thrilling",
+      "J_Dance23_MidnightSun",
+      "J_Dance2_Salsa",
+      "J_Dance3_Woah",
+      "J_Dance4_Broadway",
+      "J_Dance5_Hype",
+      "J_Dance7_Party",
+      "J_Dance8_WestCoast",
+      "J_Dance9_PeaceMaker",
+      "J_ShortDance14_Disco",
+      "J_ShortDance15_Nineties",
+      "J_ShortDance16_JazzWalk",
+      "B_AttackKarate",
+      "B_BowKarate",
+      "B_ChopsKarate",
+      "B_CrazyChopsKarate",
+      "B_ForwardKarate",
+      "B_LongKarate",
+      "B_SpinKarate",
+      "M_Move1",
+      "M_Move10",
+      "M_Move11",
+      "M_Move17",
+      "M_Move18",
+      "M_Move19",
+      "M_Move2",
+      "M_Move20",
+      "M_Move3",
+      "M_Move4",
+      "M_Move5",
+      "M_Move6",
+      "M_Move7",
+      "M_Move8",
+      "M_Move9",
+      "M_ShortMove12",
+      "M_ShortMove13",
+      "M_ShortMove14",
+      "M_ShortMove15",
+      "M_ShortMove16",
+      "B_Fence1",
+      "B_Fence2"
+    ],
+    "errors": []
+  }
+}

render_all.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# Render all BVH files to MP4, running N jobs in parallel
+cd "$(dirname "$0")"
+
+JOBS=4
+count=0
+total=$(find . -name "*.bvh" -type f | wc -l)
+current=0
+
+for bvh in $(find . -name "*.bvh" -type f | sort); do
+    mp4="${bvh%.bvh}.mp4"
+    current=$((current + 1))
+
+    # Skip if already rendered
+    if [ -f "$mp4" ]; then
+        echo "[$current/$total] SKIP $bvh (already exists)"
+        continue
+    fi
+
+    echo "[$current/$total] Rendering $bvh..."
+    python3 render_bvh.py "$bvh" "$mp4" &
+
+    count=$((count + 1))
+    if [ $count -ge $JOBS ]; then
+        wait
+        count=0
+    fi
+done
+
+wait
+echo "All done!"

render_bvh.py

@@ -0,0 +1,237 @@
+"""Fast BVH to MP4 renderer using PIL + ffmpeg pipe."""
+import sys
+import subprocess
+import numpy as np
+from PIL import Image, ImageDraw
+
+WIDTH, HEIGHT = 640, 640
+BG_COLOR = (0, 0, 0)
+BONE_COLOR = (0, 255, 170)
+JOINT_COLOR = (0, 255, 170)
+JOINT_RADIUS = 3
+BONE_WIDTH = 3
+
+
+def parse_bvh(filepath):
+    with open(filepath) as f:
+        lines = f.readlines()
+
+    joints = []
+    parent_stack = []
+    joint_offsets = {}
+    joint_channels = {}
+    joint_parents = {}
+    channel_order = []
+    i = 0
+
+    while i < len(lines):
+        line = lines[i].strip()
+        if line.startswith('ROOT') or line.startswith('JOINT'):
+            name = line.split()[-1]
+            joints.append(name)
+            joint_parents[name] = parent_stack[-1] if parent_stack else None
+        elif line.startswith('End Site'):
+            name = parent_stack[-1] + '_End'
+            joints.append(name)
+            joint_parents[name] = parent_stack[-1]
+        elif line.startswith('OFFSET'):
+            vals = list(map(float, line.split()[1:]))
+            joint_offsets[joints[-1]] = np.array(vals)
+        elif line.startswith('CHANNELS'):
+            parts = line.split()
+            n_ch = int(parts[1])
+            ch_names = parts[2:2+n_ch]
+            joint_channels[joints[-1]] = ch_names
+            for ch in ch_names:
+                channel_order.append((joints[-1], ch))
+        elif line == '{':
+            if joints:
+                parent_stack.append(joints[-1])
+        elif line == '}':
+            if parent_stack:
+                parent_stack.pop()
+        elif line.startswith('MOTION'):
+            i += 1
+            break
+        i += 1
+
+    n_frames = int(lines[i].split(':')[1])
+    i += 1
+    frame_time = float(lines[i].split(':')[1])
+    i += 1
+
+    frames = []
+    while i < len(lines):
+        line = lines[i].strip()
+        if line:
+            frames.append(list(map(float, line.split())))
+        i += 1
+
+    return joints, joint_offsets, joint_channels, joint_parents, channel_order, np.array(frames), n_frames, frame_time
+
+
+# Precompute rotation matrices for common angles
+def rot_x(a):
+    c, s = np.cos(a), np.sin(a)
+    return np.array([[1,0,0],[0,c,-s],[0,s,c]])
+
+def rot_y(a):
+    c, s = np.cos(a), np.sin(a)
+    return np.array([[c,0,s],[0,1,0],[-s,0,c]])
+
+def rot_z(a):
+    c, s = np.cos(a), np.sin(a)
+    return np.array([[c,-s,0],[s,c,0],[0,0,1]])
+
+ROT_FN = {'X': rot_x, 'Y': rot_y, 'Z': rot_z}
+
+
+def compute_all_positions(frames, joints, offsets, channels, parents, ch_order):
+    """Vectorized position computation for all frames."""
+    n_frames = len(frames)
+    n_joints = len(joints)
+    joint_idx = {j: i for i, j in enumerate(joints)}
+
+    # Build channel mapping
+    ch_map = {}
+    ci = 0
+    for joint, ch_name in ch_order:
+        if joint not in ch_map:
+            ch_map[joint] = {}
+        ch_map[joint][ch_name] = ci
+        ci += 1
+
+    all_positions = np.zeros((n_frames, n_joints, 3))
+
+    for fi in range(n_frames):
+        fd = frames[fi]
+        positions = {}
+        rotations = {}
+
+        for joint in joints:
+            parent = parents[joint]
+            offset = offsets.get(joint, np.zeros(3))
+
+            if parent is None:
+                cm = ch_map.get(joint, {})
+                tx = fd[cm['Xposition']] if 'Xposition' in cm else 0
+                ty = fd[cm['Yposition']] if 'Yposition' in cm else 0
+                tz = fd[cm['Zposition']] if 'Zposition' in cm else 0
+                p_pos = np.array([tx, ty, tz])
+                p_rot = np.eye(3)
+            else:
+                p_pos = positions[parent]
+                p_rot = rotations[parent]
+
+            pos = p_pos + p_rot @ offset
+
+            local_rot = np.eye(3)
+            if joint in channels and joint in ch_map:
+                for ch in channels[joint]:
+                    if 'rotation' in ch.lower():
+                        axis = ch[0]
+                        val = np.radians(fd[ch_map[joint][ch]])
+                        local_rot = local_rot @ ROT_FN[axis](val)
+
+            rotations[joint] = p_rot @ local_rot
+            positions[joint] = pos
+            all_positions[fi, joint_idx[joint]] = pos
+
+    return all_positions
+
+
+def project(pos_3d, center, scale):
+    """Simple orthographic projection: X right, Y up, looking from front-ish."""
+    # Rotate slightly for a 3/4 view
+    angle = np.radians(30)
+    c, s = np.cos(angle), np.sin(angle)
+    x = pos_3d[:, 0] * c + pos_3d[:, 2] * s
+    y = pos_3d[:, 1]
+    # Map to screen
+    sx = (x - center[0]) * scale + WIDTH / 2
+    sy = HEIGHT / 2 - (y - center[1]) * scale
+    return np.column_stack([sx, sy])
+
+
+def main():
+    bvh_path = sys.argv[1] if len(sys.argv) > 1 else 'dance/J_Dance3_Woah/J_Dance3_Woah.bvh'
+    out_path = sys.argv[2] if len(sys.argv) > 2 else bvh_path.rsplit('.', 1)[0] + '.mp4'
+
+    print(f"Parsing {bvh_path}...")
+    joints, offsets, channels, parents, ch_order, frames, n_frames, frame_time = parse_bvh(bvh_path)
+
+    # Filter joints
+    finger_keywords = ['Index', 'Middle', 'Ring', 'Pinky', 'Thumb']
+    major_mask = [i for i, j in enumerate(joints) if '_End' not in j and not any(k in j for k in finger_keywords)]
+    major_joints = [joints[i] for i in major_mask]
+    major_set = set(major_mask)
+
+    bones = []
+    joint_idx = {j: i for i, j in enumerate(joints)}
+    for j in major_joints:
+        p = parents[j]
+        if p is not None and joint_idx[p] in major_set:
+            bones.append((joint_idx[p], joint_idx[j]))
+
+    # Subsample for speed
+    step = 2
+    sampled = frames[::step]
+    fps = 1.0 / (frame_time * step)
+
+    print(f"Computing positions for {len(sampled)} frames...")
+    all_pos = compute_all_positions(sampled, joints, offsets, channels, parents, ch_order)
+
+    # Compute projection params from all major joint positions
+    major_pos = all_pos[:, major_mask, :]
+    flat = major_pos.reshape(-1, 3)
+
+    angle = np.radians(30)
+    c, s = np.cos(angle), np.sin(angle)
+    proj_x = flat[:, 0] * c + flat[:, 2] * s
+    proj_y = flat[:, 1]
+
+    cx = (proj_x.min() + proj_x.max()) / 2
+    cy = (proj_y.min() + proj_y.max()) / 2
+    rx = (proj_x.max() - proj_x.min()) / 2
+    ry = (proj_y.max() - proj_y.min()) / 2
+    max_r = max(rx, ry) * 1.3
+    scale = (min(WIDTH, HEIGHT) / 2) / max_r if max_r > 0 else 1
+    center = np.array([cx, cy])
+
+    print(f"Rendering to {out_path} at {fps:.0f} fps...")
+    proc = subprocess.Popen([
+        'ffmpeg', '-y',
+        '-f', 'rawvideo', '-pix_fmt', 'rgb24',
+        '-s', f'{WIDTH}x{HEIGHT}',
+        '-r', str(int(round(fps))),
+        '-i', '-',
+        '-c:v', 'libx264', '-preset', 'fast', '-crf', '23',
+        '-pix_fmt', 'yuv420p',
+        out_path
+    ], stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+    for fi in range(len(sampled)):
+        pts = project(all_pos[fi], center, scale)
+
+        img = Image.new('RGB', (WIDTH, HEIGHT), BG_COLOR)
+        draw = ImageDraw.Draw(img)
+
+        for pi, ci in bones:
+            x1, y1 = pts[pi]
+            x2, y2 = pts[ci]
+            draw.line([(x1, y1), (x2, y2)], fill=BONE_COLOR, width=BONE_WIDTH)
+
+        for idx in major_mask:
+            x, y = pts[idx]
+            draw.ellipse([x-JOINT_RADIUS, y-JOINT_RADIUS, x+JOINT_RADIUS, y+JOINT_RADIUS],
+                         fill=JOINT_COLOR)
+
+        proc.stdin.write(np.array(img).tobytes())
+
+    proc.stdin.close()
+    proc.wait()
+    print(f"Done: {out_path}")
+
+
+if __name__ == '__main__':
+    main()

retarget_all.py

@@ -0,0 +1,364 @@
+#!/usr/bin/env python3
+"""Batch retarget all BVH clips to G1 robot PKL + render MP4/GIF previews.
+
+Usage:
+    python retarget_all.py              # process all clips, skip completed
+    python retarget_all.py --force      # reprocess everything
+    python retarget_all.py --workers 8  # custom parallelism
+"""
+import argparse
+import os
+import pickle
+import subprocess
+import sys
+import time
+from multiprocessing import Pool
+from pathlib import Path
+
+import mujoco
+import numpy as np
+from movin_sdk_python import Retargeter, load_bvh_file
+
+REPO_DIR = Path(__file__).resolve().parent
+MUJOCO_XML = Path("/home/mitch/Repositories/g1-urdf/g1_mode15_square.xml")
+CATEGORIES = ["dance", "karate", "bonus"]
+HUMAN_HEIGHT = 1.75
+
+# Rendering config
+RENDER_W, RENDER_H = 1080, 1080
+CAM_AZIMUTH = 90
+CAM_ELEVATION = -10
+CAM_DISTANCE = 2.8
+CAM_LOOKAT = [0, 0, 0.65]
+FFMPEG_CRF = 18
+
+# GIF config
+GIF_WIDTH = 360
+GIF_FPS = 15
+
+
+def discover_bvh_clips():
+    """Find all BVH files under category/clip/capture/ directories."""
+    clips = []
+    for cat in CATEGORIES:
+        cat_dir = REPO_DIR / cat
+        if not cat_dir.is_dir():
+            continue
+        for clip_dir in sorted(cat_dir.iterdir()):
+            if not clip_dir.is_dir():
+                continue
+            capture_dir = clip_dir / "capture"
+            if capture_dir.is_dir():
+                bvh_files = list(capture_dir.glob("*.bvh"))
+            else:
+                bvh_files = list(clip_dir.glob("*.bvh"))
+            if bvh_files:
+                clips.append(bvh_files[0])
+    return clips
+
+
+MIN_MP4_SIZE = 10_000  # bytes — valid MP4s are at least 10KB
+
+
+def is_valid_file(path, min_size=1):
+    """Check file exists and is at least min_size bytes."""
+    return path.exists() and path.stat().st_size >= min_size
+
+
+def clip_root(bvh_path):
+    """Get the clip root directory from a BVH path.
+
+    Handles both capture/ subdirectory and flat layout.
+    """
+    if bvh_path.parent.name == "capture":
+        return bvh_path.parent.parent
+    return bvh_path.parent
+
+
+def is_complete(bvh_path):
+    """Check if all outputs already exist and are valid for a clip."""
+    stem = bvh_path.stem
+    root = clip_root(bvh_path)
+    retarget_dir = root / "retarget"
+    pkl = retarget_dir / f"{stem}.pkl"
+    csv = retarget_dir / f"{stem}.csv"
+    mp4 = retarget_dir / f"{stem}_retarget.mp4"
+    gif = retarget_dir / f"{stem}_retarget.gif"
+    return (is_valid_file(pkl, 1000)
+            and is_valid_file(csv, 100)
+            and is_valid_file(mp4, MIN_MP4_SIZE)
+            and is_valid_file(gif, 1000))
+
+
+def retarget_bvh(bvh_path):
+    """Retarget BVH to PKL with ground offset calibration."""
+    frames, _, parents, bones = load_bvh_file(str(bvh_path), human_height=HUMAN_HEIGHT)
+    retargeter = Retargeter(robot_type="unitree_g1", human_height=HUMAN_HEIGHT)
+
+    n_frames = len(frames)
+    root_pos = np.zeros((n_frames, 3))
+    root_rot = np.zeros((n_frames, 4))  # xyzw storage
+    dof_pos = np.zeros((n_frames, 29))
+
+    for i, frame_data in enumerate(frames):
+        qpos = retargeter.retarget(frame_data)
+        root_pos[i] = qpos[:3]
+        # MuJoCo returns wxyz, store as xyzw
+        root_rot[i] = [qpos[4], qpos[5], qpos[6], qpos[3]]
+        dof_pos[i] = qpos[7:]
+
+    # Ground offset: find min foot Z via MuJoCo FK
+    model = mujoco.MjModel.from_xml_path(str(MUJOCO_XML))
+    data = mujoco.MjData(model)
+
+    # Find foot geom IDs (ankle bodies)
+    foot_geom_ids = []
+    for gi in range(model.ngeom):
+        body_name = model.body(model.geom_bodyid[gi]).name
+        if "ankle" in body_name:
+            foot_geom_ids.append(gi)
+
+    min_foot_z = float("inf")
+    for i in range(n_frames):
+        data.qpos[:3] = root_pos[i]
+        # Convert xyzw back to wxyz for MuJoCo
+        data.qpos[3:7] = [root_rot[i, 3], root_rot[i, 0], root_rot[i, 1], root_rot[i, 2]]
+        data.qpos[7:] = dof_pos[i]
+        mujoco.mj_forward(model, data)
+        for gi in foot_geom_ids:
+            z = data.geom_xpos[gi, 2]
+            if z < min_foot_z:
+                min_foot_z = z
+
+    # Shift root down so feet touch ground
+    if min_foot_z != float("inf"):
+        root_pos[:, 2] -= min_foot_z
+
+    # BVH files in this repo are all 60fps
+    pkl_data = {
+        "fps": 60,
+        "root_pos": root_pos,
+        "root_rot": root_rot,
+        "dof_pos": dof_pos,
+        "local_body_pos": None,
+        "link_body_list": None,
+    }
+    return pkl_data
+
+
+def render_mp4(pkl_data, mp4_path):
+    """Render motion to MP4 using MuJoCo offscreen + ffmpeg pipe."""
+    model = mujoco.MjModel.from_xml_path(str(MUJOCO_XML))
+    data = mujoco.MjData(model)
+    renderer = mujoco.Renderer(model, height=RENDER_H, width=RENDER_W)
+
+    root_pos = pkl_data["root_pos"]
+    root_rot = pkl_data["root_rot"]
+    dof_pos = pkl_data["dof_pos"]
+    fps = pkl_data["fps"]
+    n_frames = len(root_pos)
+
+    proc = subprocess.Popen(
+        [
+            "ffmpeg", "-y",
+            "-f", "rawvideo", "-pix_fmt", "rgb24",
+            "-s", f"{RENDER_W}x{RENDER_H}",
+            "-r", str(fps),
+            "-i", "-",
+            "-c:v", "libx264", "-preset", "fast", "-crf", str(FFMPEG_CRF),
+            "-pix_fmt", "yuv420p",
+            str(mp4_path),
+        ],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+    cam = mujoco.MjvCamera()
+    cam.azimuth = CAM_AZIMUTH
+    cam.elevation = CAM_ELEVATION
+    cam.distance = CAM_DISTANCE
+    cam.lookat[:] = CAM_LOOKAT
+
+    for i in range(n_frames):
+        data.qpos[:3] = root_pos[i]
+        data.qpos[3:7] = [root_rot[i, 3], root_rot[i, 0], root_rot[i, 1], root_rot[i, 2]]
+        data.qpos[7:] = dof_pos[i]
+        mujoco.mj_forward(model, data)
+        renderer.update_scene(data, cam)
+        pixels = renderer.render()
+        proc.stdin.write(pixels.tobytes())
+
+    proc.stdin.close()
+    proc.wait()
+    renderer.close()
+
+
+def create_gif(mp4_path, gif_path):
+    """Create optimized GIF from MP4 using palettegen/paletteuse."""
+    palette_filter = f"fps={GIF_FPS},scale={GIF_WIDTH}:-1:flags=lanczos"
+    # Use per-clip palette file to avoid race conditions with multiprocessing
+    palette_path = str(mp4_path).replace(".mp4", "_palette.png")
+    # Two-pass: generate palette, then apply
+    subprocess.run(
+        [
+            "ffmpeg", "-y", "-i", str(mp4_path),
+            "-vf", f"{palette_filter},palettegen",
+            "-t", "20",  # cap at 20s to keep GIF size reasonable
+            palette_path,
+        ],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        check=True,
+    )
+    subprocess.run(
+        [
+            "ffmpeg", "-y", "-i", str(mp4_path),
+            "-i", palette_path,
+            "-t", "20",
+            "-lavfi", f"{palette_filter} [x]; [x][1:v] paletteuse",
+            str(gif_path),
+        ],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        check=True,
+    )
+    # Clean up palette
+    os.remove(palette_path)
+
+
+def pkl_to_csv(pkl_data, csv_path):
+    """Export PKL motion data to CSV (36 columns: 3 pos + 4 quat + 29 joints)."""
+    root_pos = pkl_data["root_pos"]
+    root_rot = pkl_data["root_rot"]
+    dof_pos = pkl_data["dof_pos"]
+    combined = np.hstack([root_pos, root_rot, dof_pos])
+    np.savetxt(csv_path, combined, delimiter=",", fmt="%.10f")
+
+
+def process_clip(args):
+    """Process a single BVH clip through the full pipeline."""
+    bvh_path, force = args
+    stem = bvh_path.stem
+    root = clip_root(bvh_path)
+    cat = root.parent.name
+    label = f"{cat}/{stem}"
+    retarget_dir = root / "retarget"
+    retarget_dir.mkdir(exist_ok=True)
+    pkl_path = retarget_dir / f"{stem}.pkl"
+    csv_path = retarget_dir / f"{stem}.csv"
+    mp4_path = retarget_dir / f"{stem}_retarget.mp4"
+    gif_path = retarget_dir / f"{stem}_retarget.gif"
+
+    if not force and is_complete(bvh_path):
+        print(f"  [SKIP] {label} — all outputs exist", flush=True)
+        return f"SKIP {label}"
+
+    t0 = time.time()
+    try:
+        # Step 1: Retarget BVH → PKL
+        if force or not is_valid_file(pkl_path, 1000):
+            print(f"  [RETARGET] {label} — loading BVH and running IK...", flush=True)
+            pkl_data = retarget_bvh(bvh_path)
+            with open(pkl_path, "wb") as f:
+                pickle.dump(pkl_data, f)
+            n = len(pkl_data["root_pos"])
+            sz = pkl_path.stat().st_size
+            print(f"  [RETARGET] {label} — done: {n} frames, {sz/1024:.0f}KB pkl ({time.time()-t0:.1f}s)", flush=True)
+        else:
+            with open(pkl_path, "rb") as f:
+                pkl_data = pickle.load(f)
+            n = len(pkl_data["root_pos"])
+            print(f"  [RETARGET] {label} — using existing pkl ({n} frames)", flush=True)
+
+        # Step 2: Export CSV
+        if force or not is_valid_file(csv_path, 100):
+            pkl_to_csv(pkl_data, csv_path)
+            sz = csv_path.stat().st_size
+            print(f"  [CSV]      {label} — done: {sz/1024:.0f}KB csv", flush=True)
+        else:
+            print(f"  [CSV]      {label} — using existing csv", flush=True)
+
+        # Step 3: Render retarget MP4
+        if force or not is_valid_file(mp4_path, MIN_MP4_SIZE):
+            if mp4_path.exists():
+                mp4_path.unlink()  # remove corrupt file
+            t1 = time.time()
+            print(f"  [RENDER]   {label} — rendering {n} frames to MP4...", flush=True)
+            render_mp4(pkl_data, mp4_path)
+            sz = mp4_path.stat().st_size
+            if sz < MIN_MP4_SIZE:
+                raise RuntimeError(f"Rendered MP4 too small ({sz} bytes), likely corrupt")
+            print(f"  [RENDER]   {label} — done: {sz/1024/1024:.1f}MB mp4 ({time.time()-t1:.1f}s)", flush=True)
+        else:
+            print(f"  [RENDER]   {label} — using existing mp4", flush=True)
+
+        # Step 4: Create GIF
+        if force or not is_valid_file(gif_path, 1000):
+            t2 = time.time()
+            print(f"  [GIF]      {label} — generating optimized GIF...", flush=True)
+            create_gif(mp4_path, gif_path)
+            sz = gif_path.stat().st_size
+            print(f"  [GIF]      {label} — done: {sz/1024/1024:.1f}MB gif ({time.time()-t2:.1f}s)", flush=True)
+        else:
+            print(f"  [GIF]      {label} — using existing gif", flush=True)
+
+        elapsed = time.time() - t0
+        print(f"  [OK]       {label} — complete ({n} frames, {elapsed:.1f}s total)", flush=True)
+        return f"OK   {label} ({n} frames, {elapsed:.1f}s)"
+
+    except Exception as e:
+        elapsed = time.time() - t0
+        print(f"  [FAIL]     {label} — {e} ({elapsed:.1f}s)", flush=True)
+        return f"FAIL {label} ({elapsed:.1f}s): {e}"
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Batch retarget BVH clips to G1 robot")
+    parser.add_argument("--force", action="store_true", help="Reprocess all clips")
+    parser.add_argument("--workers", type=int, default=4, help="Number of parallel workers")
+    parser.add_argument("--clips", type=str, help="Comma-separated clip names to process (e.g. B_Fence1,B_DadDance)")
+    args = parser.parse_args()
+
+    clips = discover_bvh_clips()
+    if args.clips:
+        names = set(args.clips.split(","))
+        clips = [c for c in clips if c.stem in names]
+    print(f"Found {len(clips)} BVH clips")
+
+    if not args.force:
+        pending = [c for c in clips if not is_complete(c)]
+        print(f"  {len(clips) - len(pending)} already complete, {len(pending)} to process")
+    else:
+        pending = clips
+
+    if not pending:
+        print("Nothing to do.")
+        return
+
+    work = [(c, args.force) for c in pending]
+
+    print(f"\nStarting processing with {args.workers} workers...\n", flush=True)
+    t_start = time.time()
+    if args.workers == 1:
+        results = [process_clip(w) for w in work]
+    else:
+        with Pool(args.workers) as pool:
+            results = list(pool.imap_unordered(process_clip, work))
+
+    print(f"\n{'='*60}")
+    for r in sorted(results):
+        print(f"  {r}")
+
+    ok = sum(1 for r in results if r.startswith("OK"))
+    fail = sum(1 for r in results if r.startswith("FAIL"))
+    skip = sum(1 for r in results if r.startswith("SKIP"))
+    elapsed = time.time() - t_start
+    print(f"\nDone: {ok} OK, {fail} FAIL, {skip} SKIP in {elapsed:.1f}s")
+
+    if fail > 0:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()