Deploy ARDY ZeroGPU Blender motion API

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* 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
+*.STL filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,13 +1,52 @@
 ---
-title: Ardy Motion Api
-emoji: 🔥
-colorFrom: pink
-colorTo: pink
+title: ARDY Motion Playground
+emoji: 🕺
+colorFrom: gray
+colorTo: purple
 sdk: gradio
 sdk_version: 6.20.0
-python_version: '3.13'
 app_file: app.py
+short_description: Text-to-motion with an interactive 3D skeleton playground
+python_version: "3.12"
+startup_duration_timeout: 1h
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# ARDY Motion Playground
+
+Interactive **text-to-motion** demo for [ARDY](https://research.nvidia.com/labs/sil/projects/ardy/)
+(*Autoregressive Diffusion with Hybrid Representation for Interactive Human Motion Generation*, NVIDIA, SIGGRAPH 2026).
+
+Pick a **rig** (human or robot), type a natural-language prompt, generate a 3D motion clip,
+then **orbit, scrub, and play** it in the built-in Three.js playground (play/pause, timeline
+scrubber, speed control, loop, and a root-trajectory trail).
+
+- **Human rig:** `nvidia/ARDY-Core-RP-20FPS-Horizon40` — 27-joint "Core" skeleton at 20 fps.
+- **Robot rig:** `nvidia/ARDY-G1-RP-25FPS-Horizon52` — 34-joint Unitree G1 humanoid robot at 25 fps
+  (same rig as the sibling Space `hugging-apps/ardy-g1-motion-generation`).
+- **Text encoder:** LLM2Vec-Llama-3-8B using the public
+  `unsloth/llama-3-8b-Instruct` base plus the original McGill MNTP and supervised
+  adapters. No Meta-gated base-model access is required.
+- **Hardware:** ZeroGPU.
+
+Post-processing (foot-skate cleanup, which needs a compiled C++ extension) is disabled in this
+demo; generation uses the model's autoregressive path directly.
+
+Based on the [nv-tlabs/ardy](https://github.com/nv-tlabs/ardy) reference implementation
+(`scripts/generate.py`).
+
+## Blender export
+
+Open **Blender export** to generate three downloadable files:
+
+- `ardy_motion.bvh` — directly importable with Blender's BVH importer.
+- `ardy_motion.npz` — complete ARDY output including joint positions, local and
+  global rotations, root trajectory, and foot contacts.
+- `metadata.json` — prompt, seed, FPS, skeleton hierarchy, and coordinate-system
+  information.
+
+The programmatic endpoint is `/generate_blender`. The existing `/generate`
+endpoint and Three.js playground remain available.
+
+The base and adapter repositories can be overridden with the Space variables
+`LLM2VEC_BASE_MODEL`, `LLM2VEC_MNTP_MODEL`, and `LLM2VEC_SUPERVISED_MODEL`.

app.py

@@ -0,0 +1,1113 @@
+import os
+
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+# Load models locally (no external text-encoder service) and prefer the HF cache.
+os.environ.setdefault("TEXT_ENCODER_MODE", "local")
+
+import base64
+import gzip
+import json
+import random
+import sys
+import tempfile
+import time
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+import spaces  # must precede torch / CUDA-touching imports
+import torch
+import numpy as np
+import trimesh
+import gradio as gr
+
+# The vendored ARDY package lives next to this file.
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from ardy.model import load_model  # noqa: E402
+from ardy.exports import write_bvh  # noqa: E402
+from ardy.model.load_model import load_text_encoder  # noqa: E402
+from ardy.motion_rep.tools import length_to_mask  # noqa: E402
+from ardy.tools import seed_everything, to_numpy  # noqa: E402
+
+# Two rigs are offered in the playground:
+#   "human" -> ARDY-Core-RP-20FPS-Horizon40, 27-joint skeleton @ 20 fps
+#   "robot" -> ARDY-G1-RP-25FPS-Horizon52, 34-joint Unitree G1 robot @ 25 fps
+# The robot rig matches the sibling Space hugging-apps/ardy-g1-motion-generation.
+DEFAULT_RIG = "human"
+MAX_SEED = 2**31 - 1
+
+# -----------------------------------------------------------------------------
+# Model loading (module scope).
+#
+# ZeroGPU has no live GPU at startup: it intercepts .to("cuda") *placement* but
+# NOT arbitrary CUDA compute. LLM2Vec's PEFT load runs a LoRA `merge_and_unload`
+# (real matmuls), so we build everything on CPU first, then .to("cuda") — the
+# placement call is what the ZeroGPU hijack packs to disk and streams into VRAM
+# on the first @spaces.GPU request.
+# -----------------------------------------------------------------------------
+# transformers / PEFT / safetensors infer their load device from
+# torch.cuda.is_available(), which ZeroGPU reports True at startup even though no
+# real GPU is attached — so a plain load tries to place weights on cuda and dies
+# with "No CUDA GPUs are available". Force every loader onto CPU by masking
+# is_available() during construction, then restore it and .to("cuda") (which the
+# ZeroGPU hijack packs to disk + streams into VRAM on the first request).
+#
+# A single text encoder is built once and shared across both motion models
+# (load_text_encoder is explicitly designed for this — see its docstring).
+_real_cuda_available = torch.cuda.is_available
+torch.cuda.is_available = lambda: False
+try:
+    print("Loading ARDY text encoder (LLM2Vec-Llama-3-8B) on CPU…", flush=True)
+    _text_encoder = load_text_encoder(mode="local", device="cpu")
+
+    print("Loading ARDY human (core) motion model on CPU…", flush=True)
+    MODEL_HUMAN = load_model("core", device="cpu", text_encoder=_text_encoder)
+
+    print("Loading ARDY robot (G1) motion model on CPU…", flush=True)
+    MODEL_ROBOT = load_model("g1", device="cpu", text_encoder=_text_encoder)
+finally:
+    torch.cuda.is_available = _real_cuda_available
+
+print("Moving models to CUDA (ZeroGPU-intercepted placement)…", flush=True)
+_text_encoder = _text_encoder.to("cuda")
+for _m in (MODEL_HUMAN, MODEL_ROBOT):
+    _m.to("cuda")
+    # self.device was captured at construction (device="cpu"); generation creates
+    # many tensors on it, so retarget it to cuda to match the moved weights.
+    _m.device = "cuda"
+    _m.eval()
+
+
+def _rig_params(model):
+    fps = float(model.motion_rep.fps)
+    skeleton = model.skeleton
+    parents = skeleton.joint_parents.cpu().numpy().astype(int).tolist()
+    patch = model.num_frames_per_token
+    gen_horizon = model.gen_horizon_len
+    num_base_steps = int(model.diffusion.num_base_steps)
+    # History carried between autoregressive windows. The reference streaming demo
+    # keeps this SHORT so a new prompt takes effect within a window.
+    hist_crop = max(patch, (4 // patch) * patch)
+    root_idx = parents.index(-1) if -1 in parents else 0
+    return {
+        "model": model,
+        "fps": fps,
+        "skeleton": skeleton,
+        "parents": parents,
+        "patch": patch,
+        "gen_horizon": gen_horizon,
+        "num_base_steps": num_base_steps,
+        "hist_crop": hist_crop,
+        "root_idx": root_idx,
+    }
+
+
+RIGS = {
+    "human": _rig_params(MODEL_HUMAN),
+    "robot": _rig_params(MODEL_ROBOT),
+}
+# The largest base-step count across rigs bounds the diffusion-steps slider.
+NUM_BASE_STEPS = max(r["num_base_steps"] for r in RIGS.values())
+for _name, _r in RIGS.items():
+    print(
+        f"[{_name}] rig ready: {_r['skeleton'].nbjoints} joints, {_r['fps']} fps, "
+        f"horizon {_r['gen_horizon']}, patch {_r['patch']}, "
+        f"hist_crop {_r['hist_crop']}, base_steps {_r['num_base_steps']}",
+        flush=True,
+    )
+
+
+def _normalize_rig(rig) -> str:
+    """Map any UI/API rig value onto a valid RIGS key ('human' | 'robot')."""
+    if rig is None:
+        return DEFAULT_RIG
+    key = str(rig).strip().lower()
+    if key in RIGS:
+        return key
+    if key.startswith("hum") or "core" in key or "person" in key:
+        return "human"
+    if key.startswith("rob") or "g1" in key or "unitree" in key:
+        return "robot"
+    return DEFAULT_RIG
+
+
+# -----------------------------------------------------------------------------
+# HUMAN rig: skinned body mesh (ARDY "CoreSkin" linear-blend skinning).
+#
+# The reference viz (ardy/viz/viser_utils.py) renders a smooth humanoid body by
+# skinning a bind mesh with the per-frame *global* joint transforms:
+#     verts = CoreSkin.skin(global_rot_mats, posed_joints, rot_is_global=True)
+# The browser holds the static skin data (bind vertices / faces / LBS
+# indices+weights) and does the per-vertex blend, while the server sends only the
+# tiny per-frame joint affine matrices
+#     A[f,j] = fk[f,j] @ bind_rig_transform_inv[j]      (fk = [R_global | pos])
+# so the payload stays small (~0.1 MB/clip).
+# -----------------------------------------------------------------------------
+_HUMAN_SKEL = RIGS["human"]["skeleton"]
+_SKIN_PATH = Path(_HUMAN_SKEL.folder) / "skin_standard.npz"
+_skin = np.load(_SKIN_PATH)
+BIND_RIG_INV = np.linalg.inv(
+    np.asarray(_skin["bind_rig_transform"], dtype=np.float64)
+).astype(np.float32)  # [J, 4, 4]
+
+
+def _build_skin_blob():
+    """Pack the static skin data into one gzip+base64 blob (loaded once by the
+    browser). Layout: bind_vertices f32[V,3] | faces u32[F,3] | lbs_idx u8[V,W]
+    | lbs_wt f32[V,W]."""
+    bind_v = np.asarray(_skin["bind_vertices"], dtype=np.float32)
+    faces = np.asarray(_skin["faces"], dtype=np.uint32)
+    idx = np.asarray(_skin["lbs_indices"], dtype=np.uint8)
+    wt = np.asarray(_skin["lbs_weights"], dtype=np.float32)
+    raw = (
+        np.ascontiguousarray(bind_v).tobytes()
+        + np.ascontiguousarray(faces).tobytes()
+        + np.ascontiguousarray(idx).tobytes()
+        + np.ascontiguousarray(wt).tobytes()
+    )
+    meta = {"V": int(bind_v.shape[0]), "F": int(faces.shape[0]), "W": int(idx.shape[1])}
+    return base64.b64encode(gzip.compress(raw, 6)).decode("ascii"), meta
+
+
+SKIN_B64, SKIN_META = _build_skin_blob()
+print(f"CoreSkin ready: {SKIN_META['V']} verts / {SKIN_META['F']} faces, "
+      f"blob {len(SKIN_B64) // 1024} KB", flush=True)
+
+
+def _joint_affines_human(global_rot_mats: np.ndarray, posed_joints: np.ndarray) -> str:
+    """Per-frame joint affine matrices A = fk @ bind_rig_inv, base64 f32 [T,J,12].
+
+    global_rot_mats: [T, J, 3, 3]; posed_joints: [T, J, 3]."""
+    T, J = posed_joints.shape[:2]
+    fk = np.tile(np.eye(4, dtype=np.float32), (T, J, 1, 1))
+    fk[..., :3, :3] = global_rot_mats.astype(np.float32)
+    fk[..., :3, 3] = posed_joints.astype(np.float32)
+    A = (fk @ BIND_RIG_INV)[..., :3, :]  # [T, J, 3, 4]
+    A = np.ascontiguousarray(A.reshape(T, J, 12).astype(np.float32))
+    return base64.b64encode(A.tobytes()).decode("ascii")
+
+
+# -----------------------------------------------------------------------------
+# ROBOT rig: G1 robot mesh rig (rigid per-joint STL meshes).
+#
+# Unlike the human skeleton (rendered with one skinned body mesh via LBS), the
+# Unitree G1 robot is rendered by attaching a rigid STL mesh to each articulated
+# joint. This mirrors ardy/viz/g1_rig.py (G1MeshRig): each mesh has a local
+# transform (geom_pos, geom_rot) relative to its joint, read from the MuJoCo
+# g1.xml, plus a coordinate change from MuJoCo to ARDY axes. We precompute — for
+# each mesh — its geometry PRE-TRANSFORMED into the joint-local frame
+# (v' = geom_rot @ v + geom_pos), so at render time the browser just applies the
+# per-frame joint transform: world_v = joint_pos + joint_rot @ v'.
+# -----------------------------------------------------------------------------
+# G1 joint -> STL mesh mapping (mirrors ardy/viz/g1_rig.py G1_MESH_JOINT_MAP).
+G1_MESH_JOINT_MAP = {
+    "pelvis_skel": ["pelvis.STL", "pelvis_contour_link.STL"],
+    "left_hip_pitch_skel": ["left_hip_pitch_link.STL"],
+    "left_hip_roll_skel": ["left_hip_roll_link.STL"],
+    "left_hip_yaw_skel": ["left_hip_yaw_link.STL"],
+    "left_knee_skel": ["left_knee_link.STL"],
+    "left_ankle_pitch_skel": ["left_ankle_pitch_link.STL"],
+    "left_ankle_roll_skel": ["left_ankle_roll_link.STL"],
+    "right_hip_pitch_skel": ["right_hip_pitch_link.STL"],
+    "right_hip_roll_skel": ["right_hip_roll_link.STL"],
+    "right_hip_yaw_skel": ["right_hip_yaw_link.STL"],
+    "right_knee_skel": ["right_knee_link.STL"],
+    "right_ankle_pitch_skel": ["right_ankle_pitch_link.STL"],
+    "right_ankle_roll_skel": ["right_ankle_roll_link.STL"],
+    "waist_yaw_skel": ["waist_yaw_link_rev_1_0.STL", "waist_yaw_link.STL"],
+    "waist_roll_skel": ["waist_roll_link_rev_1_0.STL", "waist_roll_link.STL"],
+    "waist_pitch_skel": [
+        "torso_link_rev_1_0.STL",
+        "torso_link.STL",
+        "logo_link.STL",
+        "head_link.STL",
+    ],
+    "left_shoulder_pitch_skel": ["left_shoulder_pitch_link.STL"],
+    "left_shoulder_roll_skel": ["left_shoulder_roll_link.STL"],
+    "left_shoulder_yaw_skel": ["left_shoulder_yaw_link.STL"],
+    "left_elbow_skel": ["left_elbow_link.STL"],
+    "left_wrist_roll_skel": ["left_wrist_roll_link.STL"],
+    "left_wrist_pitch_skel": ["left_wrist_pitch_link.STL"],
+    "left_wrist_yaw_skel": ["left_wrist_yaw_link.STL", "left_rubber_hand.STL"],
+    "right_shoulder_pitch_skel": ["right_shoulder_pitch_link.STL"],
+    "right_shoulder_roll_skel": ["right_shoulder_roll_link.STL"],
+    "right_shoulder_yaw_skel": ["right_shoulder_yaw_link.STL"],
+    "right_elbow_skel": ["right_elbow_link.STL"],
+    "right_wrist_roll_skel": ["right_wrist_roll_link.STL"],
+    "right_wrist_pitch_skel": ["right_wrist_pitch_link.STL"],
+    "right_wrist_yaw_skel": ["right_wrist_yaw_link.STL", "right_rubber_hand.STL"],
+}
+
+_ROBOT_SKEL = RIGS["robot"]["skeleton"]
+_MUJOCO_TO_ARDY = np.array(
+    [[0.0, 1.0, 0.0], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]], dtype=np.float64
+)
+_G1_SKEL_DIR = Path(_ROBOT_SKEL.folder)
+_G1_MESH_DIR = _G1_SKEL_DIR / "meshes" / "g1"
+_G1_XML = _G1_SKEL_DIR / "xml" / "g1.xml"
+
+
+def _quat_wxyz_to_matrix(wxyz: np.ndarray) -> np.ndarray:
+    w, x, y, z = wxyz
+    n = np.sqrt(w * w + x * x + y * y + z * z)
+    if n < 1e-12:
+        return np.eye(3)
+    w, x, y, z = w / n, x / n, y / n, z / n
+    return np.array(
+        [
+            [1 - 2 * (y * y + z * z), 2 * (x * y - z * w), 2 * (x * z + y * w)],
+            [2 * (x * y + z * w), 1 - 2 * (x * x + z * z), 2 * (y * z - x * w)],
+            [2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x * x + y * y)],
+        ],
+        dtype=np.float64,
+    )
+
+
+def _mesh_local_transforms() -> dict:
+    """mesh_file -> (geom_pos[3], geom_rot[3x3]) in ARDY axes, parsed from g1.xml."""
+    if not _G1_XML.exists():
+        return {}
+    root = ET.parse(_G1_XML).getroot()
+    file_to_name = {}
+    for mesh in root.findall(".//asset/mesh"):
+        name, file = mesh.get("name"), mesh.get("file")
+        if name and file:
+            file_to_name[file] = name
+    name_to_tf = {}
+    for geom in root.findall(".//geom"):
+        name = geom.get("mesh")
+        if name is None:
+            continue
+        pos = geom.get("pos")
+        quat = geom.get("quat")
+        gp = np.zeros(3) if pos is None else np.array([float(v) for v in pos.split()])
+        gr_ = np.eye(3) if quat is None else _quat_wxyz_to_matrix(
+            np.array([float(v) for v in quat.split()])
+        )
+        name_to_tf[name] = (gp, gr_)
+    out = {}
+    for file, name in file_to_name.items():
+        gp, gr_ = name_to_tf.get(name, (np.zeros(3), np.eye(3)))
+        gp = _MUJOCO_TO_ARDY @ gp
+        gr_ = _MUJOCO_TO_ARDY @ gr_ @ _MUJOCO_TO_ARDY.T
+        out[file] = (gp, gr_)
+    return out
+
+
+def _build_g1_mesh_blob():
+    """Pack all rigid G1 meshes, pre-transformed into joint-local frame, into one
+    gzip+base64 blob. Returns (b64, meta). meta.parts lists per-mesh
+    {joint, v_off, v_cnt}. Layout: all verts f32[Vtot,3] then all faces
+    u32[Ftot,3] (face indices are GLOBAL into the concatenated vertex array)."""
+    skeleton = _ROBOT_SKEL
+    local_tf = _mesh_local_transforms()
+    all_v = []
+    all_f = []
+    parts = []
+    v_cursor = 0
+    for joint_name, mesh_files in G1_MESH_JOINT_MAP.items():
+        if joint_name not in skeleton.bone_index:
+            continue
+        joint_idx = int(skeleton.bone_index[joint_name])
+        for mesh_file in mesh_files:
+            mp = _G1_MESH_DIR / mesh_file
+            if not mp.exists():
+                continue
+            mesh = trimesh.load_mesh(str(mp), process=True)
+            if isinstance(mesh, trimesh.Scene):
+                mesh = trimesh.util.concatenate(mesh.dump())
+            verts = np.asarray(mesh.vertices, dtype=np.float64) @ _MUJOCO_TO_ARDY.T
+            faces = np.asarray(mesh.faces, dtype=np.int64)
+            gp, gr_ = local_tf.get(mesh_file, (np.zeros(3), np.eye(3)))
+            # Pre-apply the mesh's joint-local transform: v' = geom_rot @ v + geom_pos.
+            verts = (verts @ gr_.T) + gp
+            vcnt = verts.shape[0]
+            parts.append({"joint": joint_idx, "v_off": v_cursor, "v_cnt": vcnt})
+            all_v.append(verts.astype(np.float32))
+            all_f.append((faces + v_cursor).astype(np.uint32))  # global vertex indices
+            v_cursor += vcnt
+    V = np.concatenate(all_v, axis=0) if all_v else np.zeros((0, 3), np.float32)
+    F = np.concatenate(all_f, axis=0) if all_f else np.zeros((0, 3), np.uint32)
+    raw = np.ascontiguousarray(V).tobytes() + np.ascontiguousarray(F).tobytes()
+    meta = {"Vtot": int(V.shape[0]), "Ftot": int(F.shape[0]), "parts": parts}
+    b64 = base64.b64encode(gzip.compress(raw, 6)).decode("ascii")
+    return b64, meta
+
+
+G1_MESH_B64, G1_MESH_META = _build_g1_mesh_blob()
+print(
+    f"G1 rig ready: {len(G1_MESH_META['parts'])} meshes, "
+    f"{G1_MESH_META['Vtot']} verts / {G1_MESH_META['Ftot']} faces, "
+    f"blob {len(G1_MESH_B64) // 1024} KB",
+    flush=True,
+)
+
+
+def _joint_transforms_robot(global_rot_mats: np.ndarray, posed_joints: np.ndarray) -> str:
+    """Per-frame joint affine matrices [R_global | pos], base64 f32 [T,J,12].
+
+    The browser applies world_v = pos + R_global @ v' per mesh (v' already in
+    joint-local frame)."""
+    T, J = posed_joints.shape[:2]
+    A = np.zeros((T, J, 3, 4), dtype=np.float32)
+    A[..., :3, :3] = global_rot_mats.astype(np.float32)
+    A[..., :3, 3] = posed_joints.astype(np.float32)
+    A = np.ascontiguousarray(A.reshape(T, J, 12).astype(np.float32))
+    return base64.b64encode(A.tobytes()).decode("ascii")
+
+
+# --- Autoregressive generation with a persistable latent state ---------------
+# ARDY is autoregressive: it generates one `gen_horizon_len`-frame window at a
+# time, conditioned on a history of previous frames. `autoregressive_step` is
+# the streaming primitive — it returns the *normalized motion-feature tensor*
+# for (history + new window), which can be fed straight back in as the next
+# window's history. We thread that tensor to (a) fill a requested clip length
+# and (b) CONTINUE a clip with a new prompt, exactly like the reference
+# interactive demo. Persisting the tensor in a gr.State lets a second "Continue"
+# click resume from where the first clip ended, on the same character.
+def _generate_sequence(rig_key, prompt, num_new_frames, steps, cfg_weight, init_tensor):
+    """Run the AR loop for one prompt on the selected rig. `init_tensor`:
+    normalized feature tensor [1, Th, D] on cuda (prior motion to continue), or
+    None to start fresh. Returns the full normalized feature tensor."""
+    r = RIGS[rig_key]
+    model = r["model"]
+    gen_horizon = r["gen_horizon"]
+    patch = r["patch"]
+    hist_crop = r["hist_crop"]
+    text_feat, text_pad_mask = model._encode_text([prompt])
+    motion_tensor = init_tensor
+    target_new = max(1, int(np.ceil(num_new_frames / gen_horizon))) * gen_horizon
+    produced = 0
+    while produced < target_new:
+        if motion_tensor is None:
+            history, hist_len = None, 0
+        else:
+            hist_len = (min(motion_tensor.shape[1], hist_crop) // patch) * patch
+            history = motion_tensor[:, motion_tensor.shape[1] - hist_len:] if hist_len else None
+            hist_len = history.shape[1] if history is not None else 0
+        samples = model.autoregressive_step(
+            num_frames=hist_len + gen_horizon,   # exactly history + one window (no future)
+            num_denoising_steps=steps,
+            motion_mask=None,
+            observed_motion=None,
+            cfg_weight=float(cfg_weight),
+            texts=None,
+            text_feat=text_feat,
+            text_pad_mask=text_pad_mask,
+            init_history_sequence=history,
+            init_global_translation=None,   # first window -> defaults (origin / +Z heading)
+            init_first_heading_angle=None,
+        )
+        new_tail = samples[:, hist_len:]     # the freshly generated window
+        motion_tensor = new_tail if motion_tensor is None else torch.cat([motion_tensor, new_tail], dim=1)
+        produced += new_tail.shape[1]
+    return motion_tensor
+
+
+def _decode_motion(rig_key, motion_tensor):
+    r = RIGS[rig_key]
+    model = r["model"]
+    with torch.no_grad():
+        out = to_numpy(model.motion_rep.inverse(motion_tensor, is_normalized=True))
+    return {
+        key: np.asarray(value)[0]
+        for key, value in out.items()
+    }
+
+
+def _pack_payload(rig_key, motion_tensor, prompt, seed):
+    """Decode a normalized feature tensor to the browser payload (per-frame joint
+    affines + root ground-track), tagged with the rig so the viewer loads the
+    correct skeleton/model."""
+    r = RIGS[rig_key]
+    out = _decode_motion(rig_key, motion_tensor)
+    posed = out["posed_joints"]      # [T, J, 3] global joint positions
+    grm = out["global_rot_mats"]     # [T, J, 3, 3] global rotations
+    if rig_key == "robot":
+        affines = _joint_transforms_robot(grm, posed)
+    else:
+        affines = _joint_affines_human(grm, posed)
+    return {
+        "rig": rig_key,
+        "fps": r["fps"],
+        "num_frames": int(posed.shape[0]),
+        "num_joints": int(posed.shape[1]),
+        "affines": affines,                          # drives the browser rig
+        "root": np.round(posed[:, r["root_idx"], :].astype(np.float32), 4).tolist(),
+        "prompt": prompt,
+        "seed": seed,
+    }
+
+
+def _core_generate(rig, prompt, duration, diffusion_steps, cfg_weight, seed, randomize_seed, init_np):
+    rig_key = _normalize_rig(rig)
+    r = RIGS[rig_key]
+    prompt = (prompt or "").strip()
+    if not prompt:
+        raise gr.Error("Please enter a text prompt describing the motion.")
+    if randomize_seed:
+        seed = random.randint(0, MAX_SEED)
+    seed = int(seed)
+    seed_everything(seed)
+    steps = max(1, min(int(diffusion_steps), r["num_base_steps"]))
+    num_new = max(r["patch"], int(round(float(duration) * r["fps"])))
+    init_tensor = None if init_np is None else torch.from_numpy(init_np).to("cuda")
+
+    t0 = time.perf_counter()
+    with torch.no_grad():
+        full = _generate_sequence(rig_key, prompt, num_new, steps, cfg_weight, init_tensor)
+    payload = _pack_payload(rig_key, full, prompt, seed)
+    tag = "continue" if init_np is not None else "generate"
+    print(f"[{tag}:{rig_key}] '{prompt[:50]}' +{num_new}f -> {full.shape[1]}f total "
+          f"steps={steps} seed={seed} {time.perf_counter() - t0:.1f}s", flush=True)
+    return json.dumps(payload), seed, full.detach().cpu().numpy()
+
+
+@spaces.GPU
+def ui_generate(prompt, rig=DEFAULT_RIG, duration=5.0, diffusion_steps=NUM_BASE_STEPS,
+                cfg_weight=2.0, seed=0, randomize_seed=True):
+    """Start a fresh clip (resets the running sequence)."""
+    return _core_generate(rig, prompt, duration, diffusion_steps, cfg_weight, seed, randomize_seed, None)
+
+
+@spaces.GPU
+def ui_continue(prompt, rig=DEFAULT_RIG, duration=5.0, diffusion_steps=NUM_BASE_STEPS,
+                cfg_weight=2.0, seed=0, randomize_seed=True, state=None):
+    """Append a new action, continuing from the previous clip's final pose."""
+    return _core_generate(rig, prompt, duration, diffusion_steps, cfg_weight, seed, randomize_seed, state)
+
+
+@spaces.GPU
+def generate_motion(prompt: str, rig: str = DEFAULT_RIG, duration: float = 5.0,
+                    diffusion_steps: int = NUM_BASE_STEPS, cfg_weight: float = 2.0,
+                    seed: int = 0, randomize_seed: bool = True) -> tuple[str, int]:
+    """Generate a 3D motion clip from a text prompt with ARDY.
+
+    Args:
+        prompt: Natural-language description of the motion (e.g. "a person walks in a circle").
+        rig: Which character to animate — "human" (27-joint skeleton) or "robot" (Unitree G1).
+        duration: Length of the generated motion in seconds.
+        diffusion_steps: Number of denoising steps (1..num_base_steps).
+        cfg_weight: Classifier-free-guidance weight for the text prompt.
+        seed: Random seed for reproducibility.
+        randomize_seed: If True, ignore `seed` and draw a fresh random one.
+
+    Returns:
+        A JSON string with the animated skeleton payload plus the seed used.
+    """
+    payload_json, seed, _ = _core_generate(
+        rig, prompt, duration, diffusion_steps, cfg_weight, seed, randomize_seed, None
+    )
+    return payload_json, seed
+
+
+@spaces.GPU
+def generate_blender_motion(
+    prompt: str,
+    duration: float = 5.0,
+    diffusion_steps: int = NUM_BASE_STEPS,
+    cfg_weight: float = 2.0,
+    seed: int = 0,
+    randomize_seed: bool = True,
+) -> tuple[str, str, str, int]:
+    """Generate a human motion and return BVH, NPZ, and JSON metadata files."""
+    _, seed, motion_np = _core_generate(
+        "human",
+        prompt,
+        duration,
+        diffusion_steps,
+        cfg_weight,
+        seed,
+        randomize_seed,
+        None,
+    )
+    motion_tensor = torch.from_numpy(motion_np).to("cuda")
+    out = _decode_motion("human", motion_tensor)
+    r = RIGS["human"]
+    skeleton = r["skeleton"]
+    joint_names = list(skeleton.bone_order_names)
+    parents = list(r["parents"])
+    rest_positions = to_numpy(skeleton.neutral_joints)
+
+    output_dir = Path(tempfile.mkdtemp(prefix="ardy_blender_"))
+    npz_path = output_dir / "ardy_motion.npz"
+    bvh_path = output_dir / "ardy_motion.bvh"
+    metadata_path = output_dir / "metadata.json"
+
+    np.savez_compressed(
+        npz_path,
+        **out,
+        fps=np.asarray(r["fps"], dtype=np.float32),
+        text=np.asarray(prompt),
+        seed=np.asarray(seed, dtype=np.int64),
+        rig=np.asarray("human"),
+        joint_names=np.asarray(joint_names),
+        parents=np.asarray(parents, dtype=np.int32),
+        rest_positions=np.asarray(rest_positions, dtype=np.float32),
+    )
+    write_bvh(
+        bvh_path,
+        joint_names=joint_names,
+        parents=parents,
+        rest_positions=rest_positions,
+        local_rot_mats=out["local_rot_mats"],
+        root_positions=out["root_positions"],
+        fps=r["fps"],
+    )
+    metadata_path.write_text(
+        json.dumps(
+            {
+                "model": "nvidia/ARDY-Core-RP-20FPS-Horizon40",
+                "rig": "human",
+                "prompt": prompt,
+                "seed": seed,
+                "fps": r["fps"],
+                "frames": int(out["posed_joints"].shape[0]),
+                "joints": joint_names,
+                "parents": parents,
+                "coordinate_system": "Y-up, metric",
+                "post_processing": False,
+            },
+            ensure_ascii=False,
+            indent=2,
+        ),
+        encoding="utf-8",
+    )
+    return str(bvh_path), str(npz_path), str(metadata_path), seed
+
+
+# -----------------------------------------------------------------------------
+# Front-end: a self-contained Three.js playground, delivered as a Gradio-native
+# custom HTML component (Gradio 6 `gr.HTML` templates + js_on_load).
+#
+# The motion JSON is carried as the component's own `value` prop. `js_on_load`
+# imports three.js, builds the scene once, wires the controls, then registers a
+# `watch('value', ...)` callback that Gradio fires whenever the component is
+# updated as the output of a Python event (Generate button / Examples).
+#
+# Each payload is tagged with its `rig`. The viewer ships the static data for
+# BOTH rigs (human skin blob + G1 rigid-mesh blob) and switches at load time:
+#  - "human": one skinned body mesh (linear-blend skinning in the browser).
+#  - "robot": rigid per-joint G1 STL meshes posed by the joint transforms.
+# -----------------------------------------------------------------------------
+
+PLAYER_TEMPLATE = """
+<div class="ardy-playground">
+  <div class="ardy-canvas-wrap">
+    <div class="ardy-hint">Generate a motion to load it into the playground.</div>
+  </div>
+  <div class="ardy-controls">
+    <button class="ardy-play ardy-btn" type="button">▶ Play</button>
+    <input class="ardy-scrub" type="range" min="0" max="0" value="0" step="1" />
+    <span class="ardy-frame">0 / 0</span>
+    <label class="ardy-lbl">Speed
+      <select class="ardy-speed">
+        <option value="0.25">0.25×</option>
+        <option value="0.5">0.5×</option>
+        <option value="1" selected>1×</option>
+        <option value="2">2×</option>
+      </select>
+    </label>
+    <label class="ardy-lbl"><input type="checkbox" class="ardy-loop" checked/> Loop</label>
+    <label class="ardy-lbl"><input type="checkbox" class="ardy-trail"/> Root trail</label>
+  </div>
+  <div class="ardy-caption"></div>
+</div>
+"""
+
+# css_template rules are auto-scoped to this component by Gradio.
+PLAYER_CSS_TEMPLATE = """
+.ardy-playground { width: 100%; }
+.ardy-canvas-wrap {
+  position: relative; width: 100%; height: 480px;
+  border-radius: 12px; overflow: hidden;
+  background: #ffffff;
+  border: 1px solid #e5e7eb;
+}
+.ardy-canvas-wrap canvas { display:block; width:100% !important; height:100% !important; }
+.ardy-hint {
+  position:absolute; top:50%; left:50%; transform:translate(-50%,-50%);
+  color:#98a2b3; font-size:14px; text-align:center; pointer-events:none;
+}
+.ardy-controls {
+  display:flex; align-items:center; gap:12px; flex-wrap:wrap;
+  margin-top:10px; padding:8px 4px;
+}
+.ardy-controls .ardy-btn {
+  background:#76B900; color:#fff;
+  border:none; border-radius:8px; padding:6px 16px; cursor:pointer; font-weight:600;
+}
+.ardy-scrub { flex:1; min-width:160px; accent-color:#76B900; }
+.ardy-frame { font-variant-numeric: tabular-nums; color: var(--body-text-color); min-width:70px; }
+.ardy-lbl { font-size:13px; color: var(--body-text-color); display:flex; align-items:center; gap:4px; }
+.ardy-caption { margin-top:6px; font-size:13px; color:#667085; }
+"""
+
+APP_CSS = """
+#col-container { max-width: 1200px; margin: 0 auto; }
+.dark .gradio-container { color: var(--body-text-color); }
+"""
+
+# Runs once, when the component first renders. `element`, `props`, and `watch`
+# are injected by Gradio. We import three.js, decode the static skin data (human
+# rig) and the static rigid-mesh data (robot rig), build the scene, and subscribe
+# to value changes with `watch('value', ...)`. Each generated payload carries the
+# per-frame joint affine matrices plus a `rig` tag; the viewer renders whichever
+# rig the payload requests, swapping the on-screen mesh as needed.
+PLAYER_JS_ON_LOAD = r"""
+const root = element;
+const q = (sel) => root.querySelector(sel);
+
+const state = {
+  ready:false,
+  THREE:null, OrbitControls:null,
+  renderer:null, scene:null, camera:null, controls:null,
+  trailLine:null,
+  data:null, verts:null, frame:0, playing:false, lastT:0,
+  speed:1, loop:true, trail:false, pending:null,
+  rig:null,                 // which rig mesh is currently mounted in the scene
+  // human rig
+  skin:null, humanMesh:null, humanGeom:null,
+  // robot rig
+  robotMesh:null, robotGeom:null,
+  robotBaseVerts:null, robotFaces:null, robotVtot:0, robotParts:null,
+};
+
+// --- binary helpers ---------------------------------------------------------
+function b64ToBytes(b64){
+  const bin = atob(b64); const out = new Uint8Array(bin.length);
+  for(let i=0;i<bin.length;i++) out[i]=bin.charCodeAt(i);
+  return out;
+}
+async function gunzip(bytes){
+  const ds = new DecompressionStream("gzip");
+  const buf = await new Response(new Blob([bytes]).stream().pipeThrough(ds)).arrayBuffer();
+  return buf;
+}
+
+// Decode the one-time static human skin blob into typed arrays.
+async function decodeSkin(){
+  const buf = await gunzip(b64ToBytes(ARDY_SKIN_B64));
+  const V = ARDY_SKIN_META.V, F = ARDY_SKIN_META.F, W = ARDY_SKIN_META.W;
+  let o = 0;
+  const bindV = new Float32Array(buf.slice(o, o+V*3*4)); o += V*3*4;
+  const faces = new Uint32Array(buf.slice(o, o+F*3*4));  o += F*3*4;
+  const idx   = new Uint8Array(buf.slice(o, o+V*W));      o += V*W;
+  const wt    = new Float32Array(buf.slice(o, o+V*W*4));  o += V*W*4;
+  return {V, F, W, bindV, faces, idx, wt};
+}
+
+// Decode the one-time static robot rig blob: pre-transformed mesh vertices
+// (joint-local frame) + global-indexed faces + per-mesh part table.
+async function decodeRig(){
+  const buf = await gunzip(b64ToBytes(G1_MESH_B64));
+  const V = G1_MESH_META.Vtot, F = G1_MESH_META.Ftot;
+  let o = 0;
+  const baseVerts = new Float32Array(buf.slice(o, o+V*3*4)); o += V*3*4;
+  const faces     = new Uint32Array(buf.slice(o, o+F*3*4));  o += F*3*4;
+  return {V, F, baseVerts, faces, parts: G1_MESH_META.parts};
+}
+
+// HUMAN: per-vertex linear-blend skinning for every frame (once per clip).
+// A[f,j] is a 3x4 affine (row-major, 12 floats); posed vertex =
+// sum_k w_k * A[idx_k] @ [bind_x, bind_y, bind_z, 1].
+function skinAllFrames(A, T, J){
+  const s = state.skin, V = s.V, W = s.W, bindV = s.bindV, idx = s.idx, wt = s.wt;
+  const frames = new Array(T);
+  for(let f=0; f<T; f++){
+    const out = new Float32Array(V*3);
+    const Ab = f*J*12;
+    for(let v=0; v<V; v++){
+      const bx = bindV[v*3], by = bindV[v*3+1], bz = bindV[v*3+2];
+      let x=0, y=0, z=0;
+      for(let k=0; k<W; k++){
+        const w = wt[v*W+k]; if(w===0) continue;
+        const a = Ab + idx[v*W+k]*12;
+        x += w*(A[a]*bx   + A[a+1]*by  + A[a+2]*bz  + A[a+3]);
+        y += w*(A[a+4]*bx + A[a+5]*by  + A[a+6]*bz  + A[a+7]);
+        z += w*(A[a+8]*bx + A[a+9]*by  + A[a+10]*bz + A[a+11]);
+      }
+      out[v*3]=x; out[v*3+1]=y; out[v*3+2]=z;
+    }
+    frames[f] = out;
+  }
+  return frames;
+}
+
+// ROBOT: per-frame rigid transform: for every mesh part, world_v = pos + R @ v'
+// where (R,pos) is the driving joint's global transform this frame and v' is
+// the vertex already baked into that joint's local frame.
+function poseAllFrames(A, T, J){
+  const V = state.robotVtot, base = state.robotBaseVerts, parts = state.robotParts;
+  const frames = new Array(T);
+  for(let f=0; f<T; f++){
+    const out = new Float32Array(V*3);
+    const Ab = f*J*12;
+    for(let p=0; p<parts.length; p++){
+      const jp = parts[p];
+      const a = Ab + jp.joint*12;
+      const r0=A[a],   r1=A[a+1], r2=A[a+2],  px=A[a+3];
+      const r3=A[a+4], r4=A[a+5], r5=A[a+6],  py=A[a+7];
+      const r6=A[a+8], r7=A[a+9], r8=A[a+10], pz=A[a+11];
+      const vs = jp.v_off, ve = jp.v_off + jp.v_cnt;
+      for(let v=vs; v<ve; v++){
+        const bx=base[v*3], by=base[v*3+1], bz=base[v*3+2];
+        out[v*3]   = px + r0*bx + r1*by + r2*bz;
+        out[v*3+1] = py + r3*bx + r4*by + r5*bz;
+        out[v*3+2] = pz + r6*bx + r7*by + r8*bz;
+      }
+    }
+    frames[f] = out;
+  }
+  return frames;
+}
+
+// --- three.js scene ---------------------------------------------------------
+function initScene(){
+  const THREE = state.THREE, OrbitControls = state.OrbitControls;
+  const wrap = q(".ardy-canvas-wrap");
+  if(!wrap || state.renderer) return;
+  const w = wrap.clientWidth || 800, h = wrap.clientHeight || 480;
+  const scene = new THREE.Scene(); scene.background = new THREE.Color(0xffffff);
+  const camera = new THREE.PerspectiveCamera(42, w/h, 0.05, 200);
+  camera.position.set(3.8, 2.2, 4.7);
+  const renderer = new THREE.WebGLRenderer({antialias:true});
+  renderer.setSize(w, h); renderer.setPixelRatio(Math.min(window.devicePixelRatio,2));
+  renderer.shadowMap.enabled = true; renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+  wrap.appendChild(renderer.domElement);
+  const controls = new OrbitControls(camera, renderer.domElement);
+  controls.target.set(0, 0.9, 0); controls.enableDamping = true;
+
+  scene.add(new THREE.HemisphereLight(0xffffff, 0xdfe4ee, 1.4));
+  const key = new THREE.DirectionalLight(0xffffff, 1.5);
+  key.position.set(3, 6, 4); key.castShadow = true;
+  key.shadow.mapSize.set(2048, 2048);
+  const c = key.shadow.camera; c.near=0.5; c.far=25; c.left=-3; c.right=3; c.top=3; c.bottom=-3;
+  key.shadow.bias = -0.0004;
+  scene.add(key);
+  scene.add(new THREE.DirectionalLight(0xeef2ff, 0.35).translateX(-4).translateZ(-2));
+
+  const ground = new THREE.Mesh(
+    new THREE.PlaneGeometry(40, 40),
+    new THREE.ShadowMaterial({opacity:0.16})
+  );
+  ground.rotation.x = -Math.PI/2; ground.position.y = 0; ground.receiveShadow = true;
+  scene.add(ground);
+
+  const grid = new THREE.GridHelper(10, 20, 0xc4c9d4, 0xe4e7ee);
+  grid.position.y = 0.0015; scene.add(grid);
+
+  state.renderer=renderer; state.scene=scene; state.camera=camera; state.controls=controls;
+
+  new ResizeObserver(()=>{
+    const w2 = wrap.clientWidth, h2 = wrap.clientHeight;
+    if(w2>0 && h2>0){ camera.aspect=w2/h2; camera.updateProjectionMatrix(); renderer.setSize(w2,h2); }
+  }).observe(wrap);
+
+  animate();
+}
+
+// Mount the mesh for the requested rig (lazily built, then shown/hidden). Only
+// one rig mesh is visible at a time; both share the scene once created.
+function mountRig(rig){
+  const THREE = state.THREE;
+  if(rig === "robot"){
+    if(!state.robotMesh){
+      const geom = new THREE.BufferGeometry();
+      geom.setIndex(new THREE.BufferAttribute(state.robotFaces, 1));
+      geom.setAttribute("position", new THREE.BufferAttribute(new Float32Array(state.robotVtot*3), 3));
+      const mat = new THREE.MeshStandardMaterial({color:0xd7dde6, roughness:0.5, metalness:0.55});
+      const mesh = new THREE.Mesh(geom, mat);
+      mesh.castShadow = true; mesh.frustumCulled = false;
+      state.scene.add(mesh); state.robotMesh = mesh; state.robotGeom = geom;
+    }
+    if(state.humanMesh) state.humanMesh.visible = false;
+    state.robotMesh.visible = true;
+    return state.robotGeom;
+  } else {
+    if(!state.humanMesh){
+      const s = state.skin;
+      const geom = new THREE.BufferGeometry();
+      geom.setIndex(new THREE.BufferAttribute(s.faces, 1));
+      geom.setAttribute("position", new THREE.BufferAttribute(new Float32Array(s.V*3), 3));
+      const mat = new THREE.MeshStandardMaterial({color:0x98bdff, roughness:0.85, metalness:0.0});
+      const mesh = new THREE.Mesh(geom, mat);
+      mesh.castShadow = true; mesh.frustumCulled = false;
+      state.scene.add(mesh); state.humanMesh = mesh; state.humanGeom = geom;
+    }
+    if(state.robotMesh) state.robotMesh.visible = false;
+    state.humanMesh.visible = true;
+    return state.humanGeom;
+  }
+}
+
+function activeGeom(){
+  return (state.rig === "robot") ? state.robotGeom : state.humanGeom;
+}
+
+function setFrame(f){
+  if(!state.verts) return;
+  const T = state.data.num_frames;
+  f = Math.max(0, Math.min(T-1, f|0));
+  state.frame = f;
+  const geom = activeGeom();
+  if(!geom) return;
+  const pos = geom.getAttribute("position");
+  pos.array.set(state.verts[f]);
+  pos.needsUpdate = true;
+  geom.computeVertexNormals();
+  geom.computeBoundingSphere();
+  updateTrail();
+  const scrub = q(".ardy-scrub"); if(scrub) scrub.value = f;
+  const lbl = q(".ardy-frame"); if(lbl) lbl.textContent = (f+1)+" / "+T;
+}
+
+function updateTrail(){
+  const THREE = state.THREE;
+  if(!state.data || !state.data.root){ if(state.trailLine) state.trailLine.visible=false; return; }
+  if(!state.trail){ if(state.trailLine) state.trailLine.visible=false; return; }
+  const T = state.data.num_frames, root = state.data.root;
+  if(!state.trailLine){
+    const g = new THREE.BufferGeometry();
+    g.setAttribute("position", new THREE.BufferAttribute(new Float32Array(T*3),3));
+    state.trailLine = new THREE.Line(g, new THREE.LineBasicMaterial({color:0xf59e0b}));
+    state.scene.add(state.trailLine);
+  }
+  state.trailLine.visible = true;
+  const attr = state.trailLine.geometry.getAttribute("position");
+  for(let t=0;t<T;t++){ attr.setXYZ(t, root[t][0], 0.006, root[t][2]); }
+  attr.needsUpdate = true;
+  state.trailLine.geometry.setDrawRange(0, Math.max(1, state.frame+1));
+}
+
+function animate(){
+  requestAnimationFrame(animate);
+  if(!state.renderer) return;
+  const now = performance.now();
+  if(state.playing && state.verts){
+    const dt = (now - state.lastT)/1000;
+    const fps = state.data.fps * state.speed;
+    if(dt >= 1/Math.max(1e-3,fps)){
+      state.lastT = now;
+      let nf = state.frame + 1;
+      if(nf >= state.data.num_frames){
+        if(state.loop){ nf = 0; } else { nf = state.data.num_frames-1; setPlaying(false); }
+      }
+      setFrame(nf);
+    }
+  }
+  state.controls.update();
+  state.renderer.render(state.scene, state.camera);
+}
+
+function setPlaying(p){
+  state.playing = p;
+  const b = q(".ardy-play");
+  if(b) b.textContent = p ? "⏸ Pause" : "▶ Play";
+  state.lastT = performance.now();
+}
+
+function loadData(data){
+  initScene();
+  const rig = (data.rig === "robot") ? "robot" : "human";
+  state.rig = rig;
+  mountRig(rig);
+  state.data = data;
+  // Decode per-frame affines and pre-pose every frame (one-time cost per clip).
+  const T = data.num_frames, J = data.num_joints;
+  const Abytes = b64ToBytes(data.affines);
+  const A = new Float32Array(Abytes.buffer, Abytes.byteOffset, Abytes.byteLength/4);
+  state.verts = (rig === "robot") ? poseAllFrames(A, T, J) : skinAllFrames(A, T, J);
+  if(state.trailLine){ state.scene.remove(state.trailLine); state.trailLine.geometry.dispose(); state.trailLine=null; }
+  const scrub = q(".ardy-scrub"); if(scrub){ scrub.max = T-1; scrub.value = 0; }
+  const hint = q(".ardy-hint"); if(hint) hint.style.display = "none";
+  const cap = q(".ardy-caption");
+  if(cap) cap.textContent = '"' + data.prompt + '"  ·  ' + (rig==="robot"?"robot":"human") +
+    '  ·  ' + T + ' frames @ ' + data.fps + ' fps  ·  seed ' + data.seed;
+  root.dataset.ardyLoaded = "1";
+  root.dataset.ardyRig = rig;
+  root.dataset.ardyFrames = String(T);
+  setFrame(0);
+  setPlaying(true);
+}
+
+function applyPayload(payload){
+  if(!payload) return;
+  if(!state.ready){ state.pending = payload; return; }   // three.js / rigs still loading
+  try { loadData(JSON.parse(payload)); }
+  catch(e){ console.error("ARDY playground load error", e); }
+}
+
+function wireControls(){
+  const bind = (sel, ev, fn) => {
+    const el = q(sel); if(el && !el.dataset.wired){ el.dataset.wired="1"; el.addEventListener(ev, fn); }
+  };
+  bind(".ardy-play", "click", ()=> setPlaying(!state.playing));
+  bind(".ardy-scrub", "input", (e)=>{ setPlaying(false); setFrame(parseInt(e.target.value)); });
+  bind(".ardy-speed", "change", (e)=>{ state.speed = parseFloat(e.target.value); });
+  bind(".ardy-loop", "change", (e)=>{ state.loop = e.target.checked; });
+  bind(".ardy-trail", "change", (e)=>{ state.trail = e.target.checked; updateTrail(); });
+}
+
+// Gradio-native hand-off: render whenever the component's value prop updates as
+// the output of a Python event (Generate / Continue / Examples).
+if (typeof watch === "function") {
+  watch("value", () => applyPayload(props.value));
+}
+
+// Import three.js (esm.sh, not jsDelivr: the OrbitControls addon has an internal
+// bare `import ... from "three"` that a browser dynamic import() can't resolve
+// without an import map; esm.sh rewrites it and dedupes three) and decode both
+// rigs, then flush any value that already arrived.
+Promise.all([
+  import("https://esm.sh/three@0.160.0"),
+  import("https://esm.sh/three@0.160.0/examples/jsm/controls/OrbitControls.js"),
+  decodeSkin(),
+  decodeRig(),
+]).then(([THREE, oc, skin, rig]) => {
+  state.THREE = THREE;
+  state.OrbitControls = oc.OrbitControls;
+  state.skin = skin;
+  state.robotBaseVerts = rig.baseVerts;
+  state.robotFaces = rig.faces;
+  state.robotVtot = rig.V;
+  state.robotParts = rig.parts;
+  state.ready = true;
+  wireControls();
+  initScene();
+  const start = state.pending || props.value;
+  if (start) applyPayload(start);
+}).catch((e)=> console.error("ARDY viewer init failed", e));
+"""
+
+EXAMPLES = [
+    ["A person walks forward confidently.", "human", 5.0],
+    ["A person walks in a circle.", "human", 6.0],
+    ["A person jumps up and down.", "human", 4.0],
+    ["The robot walks forward confidently.", "robot", 5.0],
+    ["The robot waves with the right hand.", "robot", 4.0],
+    ["The robot crouches down and then stands back up.", "robot", 5.0],
+]
+
+with gr.Blocks() as demo:
+    with gr.Column(elem_id="col-container"):
+        gr.Markdown(
+            """
+            # 🕺 ARDY Motion Playground
+            Interactive text-to-motion with **[ARDY](https://research.nvidia.com/labs/sil/projects/ardy/)**
+            (Autoregressive Diffusion with Hybrid Representation) by NVIDIA.
+            Pick a **rig** (human or robot), type a prompt and **Generate** a 3D motion clip,
+            then **orbit, scrub, and play** it below.
+            Chain actions with **Continue ▸** — the same character keeps going from where it stopped.
+            """
+        )
+
+        # Running latent state (normalized feature tensor, CPU) — lets "Continue"
+        # resume the same character from the end of the previous clip.
+        seq_state = gr.State(None)
+
+        prompt = gr.Textbox(
+            label="Motion prompt",
+            placeholder="e.g. a person walks in a circle then waves",
+            lines=2,
+        )
+        rig = gr.Radio(
+            choices=[("🕺 Human", "human"), ("🤖 Robot (Unitree G1)", "robot")],
+            value=DEFAULT_RIG,
+            label="Rig",
+        )
+        with gr.Row():
+            run = gr.Button("Generate", variant="primary", scale=2)
+            cont = gr.Button("Continue ▸", variant="secondary", scale=1)
+
+        # The interactive 3D playground — a Gradio-native custom HTML component.
+        # Its `value` (the motion JSON) is set directly by the Generate handler;
+        # `watch('value', ...)` in js_on_load renders it. Ship the static data for
+        # both rigs (human skin blob + G1 rigid-mesh blob) once, as a header
+        # prepended to js_on_load; the per-frame affines ride in each payload.
+        _rig_header = (
+            f'const ARDY_SKIN_B64="{SKIN_B64}";\n'
+            f"const ARDY_SKIN_META={json.dumps(SKIN_META)};\n"
+            f'const G1_MESH_B64="{G1_MESH_B64}";\n'
+            f"const G1_MESH_META={json.dumps(G1_MESH_META)};\n"
+        )
+        player = gr.HTML(
+            value="",
+            html_template=PLAYER_TEMPLATE,
+            css_template=PLAYER_CSS_TEMPLATE,
+            js_on_load=_rig_header + PLAYER_JS_ON_LOAD,
+            elem_id="ardy-player",
+        )
+
+        with gr.Accordion("Advanced settings", open=False):
+            duration = gr.Slider(1.0, 10.0, value=5.0, step=0.5, label="Duration (seconds)")
+            diffusion_steps = gr.Slider(
+                1, NUM_BASE_STEPS, value=NUM_BASE_STEPS, step=1, label="Diffusion steps"
+            )
+            cfg_weight = gr.Slider(1.0, 6.0, value=2.0, step=0.5, label="Text guidance (CFG)")
+            with gr.Row():
+                randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
+                seed = gr.Number(label="Seed", value=0, precision=0)
+
+        with gr.Accordion("Blender export", open=False):
+            gr.Markdown(
+                "Generate the human rig as **BVH**, full-fidelity **NPZ**, and "
+                "JSON metadata. Import the BVH directly in Blender."
+            )
+            export_blender = gr.Button("Generate Blender files", variant="secondary")
+            with gr.Row():
+                bvh_file = gr.File(label="Blender BVH")
+                npz_file = gr.File(label="ARDY NPZ")
+                metadata_file = gr.File(label="Metadata")
+
+        gr.Examples(
+            examples=EXAMPLES,
+            inputs=[prompt, rig, duration],
+            outputs=[player, seed, seq_state],
+            fn=ui_generate,
+            cache_examples=False,
+            run_on_click=True,
+        )
+
+        gr.Markdown(
+            """
+            <small>Rigs: **ARDY-Core-RP-20FPS-Horizon40** (human, 27-joint skeleton @ 20 fps)
+            and **ARDY-G1-RP-25FPS-Horizon52** (Unitree G1 robot, 34-joint skeleton @ 25 fps).
+            Text encoder: LLM2Vec-Llama-3-8B. Post-processing (foot-skate cleanup) is disabled in this demo.
+            Motion is generated autoregressively; longer clips take longer.
+            **Generate** starts a new clip; **Continue ▸** keeps the same character going,
+            transitioning it into the new prompt (like the reference demo's prompt timeline).</small>
+            """
+        )
+
+    _gen_inputs = [prompt, rig, duration, diffusion_steps, cfg_weight, seed, randomize_seed]
+    # Generate starts fresh; Continue resumes from the running latent state.
+    # The payload is written straight into the player's `value`; its js_on_load
+    # `watch('value', ...)` renders it (loading the correct rig from the payload).
+    run.click(fn=ui_generate, inputs=_gen_inputs,
+              outputs=[player, seed, seq_state], api_name=False)
+    cont.click(fn=ui_continue, inputs=_gen_inputs + [seq_state],
+               outputs=[player, seed, seq_state], api_name=False)
+    export_blender.click(
+        fn=generate_blender_motion,
+        inputs=[prompt, duration, diffusion_steps, cfg_weight, seed, randomize_seed],
+        outputs=[bvh_file, npz_file, metadata_file, seed],
+        api_name=False,
+    )
+
+    # Clean single-shot endpoint for the HTTP API / MCP tool (no session state).
+    gr.api(generate_motion, api_name="generate")
+    gr.api(generate_blender_motion, api_name="generate_blender")
+
+demo.queue()
+
+if __name__ == "__main__":
+    # Gradio 6 moved theme/css from the Blocks constructor to launch(). The
+    # player's JS/CSS now live on the gr.HTML component itself (js_on_load /
+    # css_template), so no global `head=` script is needed.
+    demo.launch(
+        theme=gr.themes.Citrus(),
+        css=APP_CSS,
+        mcp_server=True,
+        ssr_mode=False,
+    )

ardy/__init__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""ARDY: text-to-motion generation."""

ardy/assets.py

@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from pathlib import Path
+
+PACKAGE_ROOT = Path(__file__).resolve().parent
+ASSETS_ROOT = PACKAGE_ROOT / "assets"
+DEMO_ASSETS_ROOT = ASSETS_ROOT / "demo"
+DEMO_EXAMPLES_ROOT = DEMO_ASSETS_ROOT / "examples"
+SKELETONS_ROOT = ASSETS_ROOT / "skeletons"
+SOMA_ASSETS_ROOT = ASSETS_ROOT / "SOMA"
+
+
+def skeleton_asset_path(*parts: str) -> Path:
+    return SKELETONS_ROOT.joinpath(*parts)
+
+
+def demo_asset_path(*parts: str) -> Path:
+    return DEMO_ASSETS_ROOT.joinpath(*parts)

ardy/assets/skeletons/cskel27/skin_standard.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4ed2b1ea33a997d7777a59d74ec2312b52af2276331048c954441f5f44f6e58b
+size 237170

ardy/assets/skeletons/g1skel34/meshes/g1/head_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:005fb67fbd3eff94aa8bf4a6e83238174e9f91b6721f7111594322f223724411
+size 932784

ardy/assets/skeletons/g1skel34/meshes/g1/left_ankle_roll_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4092af943141d4d9f74232f3cfa345afc6565f46a077793b8ae0e68b39dc33f
+size 653384

ardy/assets/skeletons/g1skel34/meshes/g1/left_hip_pitch_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4725168105ee768ee31638ef22b53f6be2d7641bfd7cfefe803488d884776fa4
+size 181684

ardy/assets/skeletons/g1skel34/meshes/g1/left_hip_roll_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91f25922ee8a7c3152790051bebad17b4d9cd243569c38fe340285ff93a97acf
+size 192184

ardy/assets/skeletons/g1skel34/meshes/g1/left_hip_yaw_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a16d88aa6ddac8083aa7ad55ed317bea44b1fa003d314fba88965b7ed0f3b55b
+size 296284

ardy/assets/skeletons/g1skel34/meshes/g1/left_knee_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d92b9e3d3a636761150bb8025e32514c4602b91c7028d523ee42b3e632de477
+size 854884

ardy/assets/skeletons/g1skel34/meshes/g1/left_rubber_hand.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cff2221a690fa69303f61fce68f2d155c1517b52efb6ca9262dd56e0bc6e70fe
+size 2287484

ardy/assets/skeletons/g1skel34/meshes/g1/left_shoulder_pitch_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f0d1cfd02fcf0d42f95e678eeca33da3afbcc366ffba5c052847773ec4f31d52
+size 176784

ardy/assets/skeletons/g1skel34/meshes/g1/left_shoulder_roll_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb9df21687773522598dc384f1a2945c7519f11cbc8bd372a49170316d6eee88
+size 400284

ardy/assets/skeletons/g1skel34/meshes/g1/left_shoulder_yaw_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1aa97e9748e924336567992181f78c7cd0652fd52a4afcca3df6b2ef6f9e712e
+size 249184

ardy/assets/skeletons/g1skel34/meshes/g1/left_wrist_roll_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:edc387c9a0ba8c2237e9b296d32531426fabeb6f53e58df45c76106bca74148c
+size 356184

ardy/assets/skeletons/g1skel34/meshes/g1/left_wrist_yaw_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83f8fb3a726bf9613d65dd14f0f447cb918c3c95b3938042a0c9c09749267d3b
+size 318684

ardy/assets/skeletons/g1skel34/meshes/g1/logo_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8571a0a19bc4916fa55f91449f51d5fdefd751000054865a842449429d5f155b
+size 243384

ardy/assets/skeletons/g1skel34/meshes/g1/pelvis.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ba6bbc888e630550140d3c26763f10206da8c8bd30ed886b8ede41c61f57a31
+size 1060884

ardy/assets/skeletons/g1skel34/meshes/g1/pelvis_contour_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5cc5c2c7a312329e3feeb2b03d3fc09fc29705bd01864f6767e51be959662420
+size 1805184

ardy/assets/skeletons/g1skel34/meshes/g1/right_ankle_roll_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b66222ea56653e627711b56d0a8949b4920da5df091da0ceb343f54e884e3a5
+size 653784

ardy/assets/skeletons/g1skel34/meshes/g1/right_hip_pitch_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4f3c99d7f4a7d34eadbef9461fc66e3486cb5442db1ec50c86317d459f1a9c6
+size 181284

ardy/assets/skeletons/g1skel34/meshes/g1/right_hip_roll_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c254ef66a356f492947f360dd931965477b631e3fcc841f91ccc46d945d54f6
+size 192684

ardy/assets/skeletons/g1skel34/meshes/g1/right_hip_yaw_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e479c2936ca2057e9eb2f7dff6c189b7419d7b8484dea0b298cbb36a2a6aa668
+size 296284

ardy/assets/skeletons/g1skel34/meshes/g1/right_knee_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63c4008449c9bbe701a6e2b557b7a252e90cf3a5abcf54cee46862b9a69f8ec8
+size 852284

ardy/assets/skeletons/g1skel34/meshes/g1/right_rubber_hand.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99533b778bca6246144fa511bb9d4e555e075c641f2a0251e04372869cd99d67
+size 2192684

ardy/assets/skeletons/g1skel34/meshes/g1/right_shoulder_pitch_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:24cdb387e0128dfe602770a81c56cdce3a0181d34d039a11d1aaf8819b7b8c02
+size 176784

ardy/assets/skeletons/g1skel34/meshes/g1/right_shoulder_roll_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:962b97c48f9ce9e8399f45dd9522e0865d19aa9fd299406b2d475a8fc4a53e81
+size 401884

ardy/assets/skeletons/g1skel34/meshes/g1/right_shoulder_yaw_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a0b76489271da0c72461a344c9ffb0f0c6e64f019ea5014c1624886c442a2fe5
+size 249984

ardy/assets/skeletons/g1skel34/meshes/g1/right_wrist_roll_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a7ee9212ff5b94d6cb7f52bb1bbf3f352194d5b598acff74f4c77d340c5b344f
+size 356084

ardy/assets/skeletons/g1skel34/meshes/g1/right_wrist_yaw_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc9dece2d12509707e0057ba2e48df8f3d56db0c79410212963a25e8a50f61a6
+size 341484

ardy/assets/skeletons/g1skel34/meshes/g1/torso_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e96d023f0368a4e3450b86ca5d4f10227d8141156a373e7da8cb3c93266523e0
+size 2232984

ardy/assets/skeletons/g1skel34/meshes/g1/torso_link_rev_1_0.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:11ddb46f2098efbbd8816b1d65893632d8e78be936376c7cdcd6771899ccc723
+size 2570584

ardy/assets/skeletons/g1skel34/meshes/g1/waist_yaw_link.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2883f20e03f09b669b5b4ce10677ee6b5191c0934b584d7cbaef2d0662856ffb
+size 336284

ardy/assets/skeletons/g1skel34/meshes/g1/waist_yaw_link_rev_1_0.STL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec6db442b11f25eed898b5add07940c85d804f300de24dcbd264ccd8be7d554c
+size 619984

ardy/assets/skeletons/g1skel34/xml/g1.xml

@@ -0,0 +1,413 @@
+<mujoco model="g1">
+    <compiler angle="radian" meshdir="../meshes/g1"/>
+
+    <default>
+        <default class="g1">
+            <geom contype="0" conaffinity="0"/>
+
+            <joint frictionloss="0.1" solimplimit="0.97 0.995 0.001"/>
+
+            <default class="hip">
+                <default class="hip_pitch">
+                    <joint axis="0 1 0" range="-2.5307 2.8798" actuatorfrcrange="-88 88" armature="0.01017752004"/>
+                </default>
+                <default class="hip_roll">
+                    <joint axis="1 0 0" actuatorfrcrange="-139 139" armature="0.025101925"/>
+                </default>
+                <default class="hip_yaw">
+                    <joint axis="0 0 1" range="-2.7576 2.7576" actuatorfrcrange="-88 88" armature="0.01017752004"/>
+                </default>
+            </default>
+            <default class="knee">
+                <joint axis="0 1 0" range="-0.087267 2.8798" actuatorfrcrange="-139 139" armature="0.025101925"/>
+            </default>
+            <default class="ankle">
+                <default class="ankle_pitch">
+                    <joint axis="0 1 0" range="-0.87267 0.5236" actuatorfrcrange="-50 50" armature="0.00721945"/>
+                </default>
+                <default class="ankle_roll">
+                    <joint axis="1 0 0" range="-0.2618 0.2618" actuatorfrcrange="-50 50" armature="0.00721945"/>
+                </default>
+            </default>
+            <default class="waist_yaw">
+                <joint axis="0 0 1" range="-2.618 2.618" actuatorfrcrange="-88 88" armature="0.01017752004"/>
+            </default>
+            <default class="waist_pitch">
+                <joint axis="0 1 0" range="-0.52 0.52" actuatorfrcrange="-50 50" armature="0.00721945"/>
+            </default>
+            <default class="waist_roll">
+                <joint axis="1 0 0" range="-0.52 0.52" actuatorfrcrange="-50 50" armature="0.00721945"/>
+            </default>
+            <default class="shoulder">
+                <default class="shoulder_pitch">
+                    <joint axis="0 1 0" range="-3.0892 2.6704" actuatorfrcrange="-25 25" armature="0.003609725"/>
+                </default>
+                <default class="shoulder_roll">
+                    <joint axis="1 0 0" actuatorfrcrange="-25 25" armature="0.003609725"/>
+                </default>
+                <default class="shoulder_yaw">
+                    <joint axis="0 0 1" range="-2.618 2.618" actuatorfrcrange="-25 25" armature="0.003609725"/>
+                </default>
+            </default>
+            <default class="elbow">
+                <joint axis="0 1 0" range="-1.0472 2.0944" actuatorfrcrange="-25 25" armature="0.003609725"/>
+            </default>
+            <default class="wrist">
+                <default class="wrist_roll">
+                    <joint axis="1 0 0" range="-1.97222 1.97222" actuatorfrcrange="-25 25" armature="0.003609725"/>
+                </default>
+                <default class="wrist_pitch">
+                    <joint axis="0 1 0" range="-1.61443 1.61443" actuatorfrcrange="-5 5" armature="0.00425"/>
+                </default>
+                <default class="wrist_yaw">
+                    <joint axis="0 0 1" range="-1.61443 1.61443" actuatorfrcrange="-5 5" armature="0.00425"/>
+                </default>
+            </default>
+
+            <default class="visual">
+                <geom group="2" type="mesh" density="0" material="silver"/>
+            </default>
+            <default class="collision">
+                <geom group="3" rgba=".2 .6 .2 .3" contype="1" conaffinity="1"/>
+                <default class="foot">
+                    <geom size="0.085 0.03 0.005"/>
+                </default>
+            </default>
+            <site group="5" rgba="1 0 0 1"/>
+        </default>
+    </default>
+
+    <asset>
+        <material name="silver" rgba="0.7 0.7 0.7 1"/>
+        <material name="black" rgba="0.2 0.2 0.2 1"/>
+
+        <mesh name="pelvis" file="pelvis.STL"/>
+        <mesh name="pelvis_contour_link" file="pelvis_contour_link.STL"/>
+        <mesh name="left_hip_pitch_link" file="left_hip_pitch_link.STL"/>
+        <mesh name="left_hip_roll_link" file="left_hip_roll_link.STL"/>
+        <mesh name="left_hip_yaw_link" file="left_hip_yaw_link.STL"/>
+        <mesh name="left_knee_link" file="left_knee_link.STL"/>
+        <mesh name="left_ankle_pitch_link"
+              file="left_ankle_pitch_link.STL"/>
+        <mesh name="left_ankle_roll_link" file="left_ankle_roll_link.STL"/>
+        <mesh name="right_hip_pitch_link" file="right_hip_pitch_link.STL"/>
+        <mesh name="right_hip_roll_link" file="right_hip_roll_link.STL"/>
+        <mesh name="right_hip_yaw_link" file="right_hip_yaw_link.STL"/>
+        <mesh name="right_knee_link" file="right_knee_link.STL"/>
+        <mesh name="right_ankle_pitch_link"
+              file="right_ankle_pitch_link.STL"/>
+        <mesh name="right_ankle_roll_link"
+              file="right_ankle_roll_link.STL"/>
+        <mesh name="waist_yaw_link" file="waist_yaw_link_rev_1_0.STL"/>
+        <mesh name="waist_roll_link" file="waist_roll_link_rev_1_0.STL"/>
+        <mesh name="torso_link" file="torso_link_rev_1_0.STL"/>
+        <mesh name="logo_link" file="logo_link.STL"/>
+        <mesh name="head_link" file="head_link.STL"/>
+        <mesh name="left_shoulder_pitch_link"
+              file="left_shoulder_pitch_link.STL"/>
+        <mesh name="left_shoulder_roll_link"
+              file="left_shoulder_roll_link.STL"/>
+        <mesh name="left_shoulder_yaw_link"
+              file="left_shoulder_yaw_link.STL"/>
+        <mesh name="left_elbow_link" file="left_elbow_link.STL"/>
+        <mesh name="left_wrist_roll_link" file="left_wrist_roll_link.STL"/>
+        <mesh name="left_wrist_pitch_link"
+              file="left_wrist_pitch_link.STL"/>
+        <mesh name="left_wrist_yaw_link" file="left_wrist_yaw_link.STL"/>
+        <mesh name="left_rubber_hand" file="left_rubber_hand.STL"/>
+        <mesh name="right_shoulder_pitch_link"
+              file="right_shoulder_pitch_link.STL"/>
+        <mesh name="right_shoulder_roll_link"
+              file="right_shoulder_roll_link.STL"/>
+        <mesh name="right_shoulder_yaw_link"
+              file="right_shoulder_yaw_link.STL"/>
+        <mesh name="right_elbow_link" file="right_elbow_link.STL"/>
+        <mesh name="right_wrist_roll_link"
+              file="right_wrist_roll_link.STL"/>
+        <mesh name="right_wrist_pitch_link"
+              file="right_wrist_pitch_link.STL"/>
+        <mesh name="right_wrist_yaw_link" file="right_wrist_yaw_link.STL"/>
+        <mesh name="right_rubber_hand" file="right_rubber_hand.STL"/>
+    </asset>
+
+    <worldbody>
+        <body name="pelvis" pos="0 0 0.793" childclass="g1">
+            <inertial pos="0 0 -0.07605" quat="1 0 -0.000399148 0" mass="3.813" diaginertia="0.010549 0.0093089 0.0079184"/>
+            <freejoint name="floating_base_joint"/>
+            <geom class="visual" material="black" mesh="pelvis"/>
+            <geom class="visual" mesh="pelvis_contour_link"/>
+            <geom mesh="pelvis_contour_link" class="visual"/>
+            <geom name="pelvis_collision" class="collision" type="sphere" size="0.07" pos="0 0 -0.08"/>
+            <site name="imu_in_pelvis" size="0.01" pos="0.04525 0 -0.08339"/>
+            <site name="pelvis" size="0.01" pos="0 0 0"/>
+            <body name="left_hip_pitch_link" pos="0 0.064452 -0.1027">
+                <inertial pos="0.002741 0.047791 -0.02606" quat="0.954862 0.293964 0.0302556 0.030122" mass="1.35"
+                          diaginertia="0.00181517 0.00153422 0.00116212"/>
+                <joint name="left_hip_pitch_joint" class="hip_pitch"/>
+                <geom class="visual" material="black" mesh="left_hip_pitch_link"/>
+                <geom material="black" mesh="left_hip_pitch_link" class="visual"/>
+                <body name="left_hip_roll_link" pos="0 0.052 -0.030465" quat="0.996179 0 -0.0873386 0">
+                    <inertial pos="0.029812 -0.001045 -0.087934" quat="0.977808 -1.97119e-05 0.205576 -0.0403793" mass="1.52"
+                              diaginertia="0.00254986 0.00241169 0.00148755"/>
+                    <joint name="left_hip_roll_joint" class="hip_roll" range="-0.5236 2.9671"/>
+                    <geom class="visual" mesh="left_hip_roll_link"/>
+                    <geom mesh="left_hip_roll_link" class="visual"/>
+                    <geom name="left_thigh" class="collision" type="capsule" size="0.05" fromto="0.02 0 0 0.02 0 -0.2"/>
+                    <body name="left_hip_yaw_link" pos="0.025001 0 -0.12412">
+                        <inertial pos="-0.057709 -0.010981 -0.15078" quat="0.600598 0.15832 0.223482 0.751181" mass="1.702"
+                                  diaginertia="0.00776166 0.00717575 0.00160139"/>
+                        <joint name="left_hip_yaw_joint" class="hip_yaw"/>
+                        <geom class="visual" mesh="left_hip_yaw_link"/>
+                        <body name="left_knee_link" pos="-0.078273 0.0021489 -0.17734" quat="0.996179 0 0.0873386 0">
+                            <inertial pos="0.005457 0.003964 -0.12074" quat="0.923418 -0.0327699 0.0158246 0.382067" mass="1.932"
+                                      diaginertia="0.0113804 0.0112778 0.00146458"/>
+                            <joint name="left_knee_joint" class="knee"/>
+                            <geom class="visual" mesh="left_knee_link"/>
+                            <geom name="left_shin" class="collision" type="capsule" size="0.04" fromto="0.02 0 0 0.02 0 -0.25"/>
+                            <body name="left_ankle_pitch_link" pos="0 -9.4445e-05 -0.30001">
+                                <inertial pos="-0.007269 0 0.011137" quat="0.603053 0.369225 0.369225 0.603053" mass="0.074"
+                                          diaginertia="1.89e-05 1.40805e-05 6.9195e-06"/>
+                                <joint name="left_ankle_pitch_joint" class="ankle_pitch"/>
+                                <geom class="visual" mesh="left_ankle_pitch_link"/>
+                                <body name="left_ankle_roll_link" pos="0 0 -0.017558">
+                                    <site name="left_foot" rgba="1 0 0 1"/>
+                                    <inertial pos="0.026505 0 -0.016425" quat="-0.000481092 0.728482 -0.000618967 0.685065" mass="0.608"
+                                              diaginertia="0.00167218 0.0016161 0.000217621"/>
+                                    <joint name="left_ankle_roll_joint" class="ankle_roll"/>
+                                    <geom class="visual" material="black" mesh="left_ankle_roll_link"/>
+                                    <geom name="left_foot1_collision" type="capsule" size="0.01" class="collision" fromto="0.1 -0.026 -0.025 0.05 -0.027 -0.025"/>
+                                    <geom name="left_foot2_collision" type="capsule" size="0.01" class="collision" fromto="-0.044 -0.018 -0.025 0.123 -0.018 -0.025"/>
+                                    <geom name="left_foot3_collision" type="capsule" size="0.01" class="collision" fromto="-0.052 -0.01 -0.025 0.13 -0.01 -0.025"/>
+                                    <geom name="left_foot4_collision" type="capsule" size="0.01" class="collision" fromto="-0.054 0 -0.025 0.132 0 -0.025"/>
+                                    <geom name="left_foot5_collision" type="capsule" size="0.01" class="collision" fromto="-0.052 0.01 -0.025 0.13 0.01 -0.025"/>
+                                    <geom name="left_foot6_collision" type="capsule" size="0.01" class="collision" fromto="-0.044 0.018 -0.025 0.123 0.018 -0.025"/>
+                                    <geom name="left_foot7_collision" type="capsule" size="0.01" class="collision" fromto="0.1 0.026 -0.025 0.05 0.026 -0.025"/>
+                                </body>
+                            </body>
+                        </body>
+                    </body>
+                </body>
+            </body>
+            <body name="right_hip_pitch_link" pos="0 -0.064452 -0.1027">
+                <inertial pos="0.002741 -0.047791 -0.02606" quat="0.954862 -0.293964 0.0302556 -0.030122" mass="1.35"
+                          diaginertia="0.00181517 0.00153422 0.00116212"/>
+                <joint name="right_hip_pitch_joint" class="hip_pitch"/>
+                <geom class="visual" material="black" mesh="right_hip_pitch_link"/>
+                <body name="right_hip_roll_link" pos="0 -0.052 -0.030465" quat="0.996179 0 -0.0873386 0">
+                    <inertial pos="0.029812 0.001045 -0.087934" quat="0.977808 1.97119e-05 0.205576 0.0403793" mass="1.52"
+                              diaginertia="0.00254986 0.00241169 0.00148755"/>
+                    <joint name="right_hip_roll_joint" class="hip_roll" range="-2.9671 0.5236"/>
+                    <geom class="visual" mesh="right_hip_roll_link"/>
+                    <geom name="right_thigh" class="collision" type="capsule" size="0.05" fromto="0.02 0 0 0.02 0 -0.2"/>
+                    <body name="right_hip_yaw_link" pos="0.025001 0 -0.12412">
+                        <inertial pos="-0.057709 0.010981 -0.15078" quat="0.751181 0.223482 0.15832 0.600598" mass="1.702"
+                                  diaginertia="0.00776166 0.00717575 0.00160139"/>
+                        <joint name="right_hip_yaw_joint" class="hip_yaw"/>
+                        <geom class="visual" mesh="right_hip_yaw_link"/>
+                        <body name="right_knee_link" pos="-0.078273 -0.0021489 -0.17734" quat="0.996179 0 0.0873386 0">
+                            <inertial pos="0.005457 -0.003964 -0.12074" quat="0.923439 0.0345276 0.0116333 -0.382012" mass="1.932"
+                                      diaginertia="0.011374 0.0112843 0.00146452"/>
+                            <joint name="right_knee_joint" class="knee"/>
+                            <geom class="visual" mesh="right_knee_link"/>
+                            <geom name="right_shin" class="collision" type="capsule" size="0.04" fromto="0.02 0 0 0.02 0 -0.25"/>
+                            <body name="right_ankle_pitch_link" pos="0 9.4445e-05 -0.30001">
+                                <inertial pos="-0.007269 0 0.011137" quat="0.603053 0.369225 0.369225 0.603053" mass="0.074"
+                                          diaginertia="1.89e-05 1.40805e-05 6.9195e-06"/>
+                                <joint name="right_ankle_pitch_joint" class="ankle_pitch"/>
+                                <geom class="visual" mesh="right_ankle_pitch_link"/>
+                                <body name="right_ankle_roll_link" pos="0 0 -0.017558">
+                                    <site name="right_foot" pos="0 0 0"/>
+                                    <inertial pos="0.026505 0 -0.016425" quat="0.000481092 0.728482 0.000618967 0.685065" mass="0.608"
+                                              diaginertia="0.00167218 0.0016161 0.000217621"/>
+                                    <joint name="right_ankle_roll_joint" class="ankle_roll"/>
+                                    <geom class="visual" material="black" mesh="right_ankle_roll_link"/>
+                                    <geom name="right_foot1_collision" type="capsule" size="0.01" class="collision" fromto="0.1 -0.026 -0.025 0.05 -0.026 -0.025"/>
+                                    <geom name="right_foot2_collision" type="capsule" size="0.008" class="collision" fromto="-0.044 -0.018 -0.025 0.123 -0.018 -0.025"/>
+                                    <geom name="right_foot3_collision" type="capsule" size="0.01" class="collision" fromto="-0.052 -0.01 -0.025 0.13 -0.01 -0.025"/>
+                                    <geom name="right_foot4_collision" type="capsule" size="0.01" class="collision" fromto="-0.054 0 -0.025 0.132 0 -0.025"/>
+                                    <geom name="right_foot5_collision" type="capsule" size="0.01" class="collision" fromto="-0.052 0.01 -0.025 0.13 0.01 -0.025"/>
+                                    <geom name="right_foot6_collision" type="capsule" size="0.008" class="collision" fromto="-0.044 0.018 -0.025 0.123 0.018 -0.025"/>
+                                    <geom name="right_foot7_collision" type="capsule" size="0.01" class="collision" fromto="0.1 0.026 -0.025 0.05 0.026 -0.025"/>
+                                </body>
+                            </body>
+                        </body>
+                    </body>
+                </body>
+            </body>
+            <body name="waist_yaw_link">
+                <inertial pos="0.003494 0.000233 0.018034" quat="0.289697 0.591001 -0.337795 0.672821" mass="0.214"
+                          diaginertia="0.000163531 0.000107714 0.000102205"/>
+                <joint name="waist_yaw_joint" class="waist_yaw"/>
+                <geom class="visual" mesh="waist_yaw_link"/>
+                <body name="waist_roll_link" pos="-0.0039635 0 0.044">
+                    <inertial pos="0 2.3e-05 0" quat="0.5 0.5 -0.5 0.5" mass="0.086" diaginertia="8.245e-06 7.079e-06 6.339e-06"/>
+                    <joint name="waist_roll_joint" class="waist_roll"/>
+                    <geom class="visual" mesh="waist_roll_link"/>
+                    <body name="torso_link">
+                        <inertial pos="0.00203158 0.000339683 0.184568" quat="0.999803 -6.03319e-05 0.0198256 0.00131986"
+                                  mass="7.818" diaginertia="0.121847 0.109825 0.0273735"/>
+                        <joint name="waist_pitch_joint" class="waist_pitch"/>
+                        <geom class="visual" mesh="torso_link"/>
+                        <geom pos="0.0039635 0 -0.044" quat="1 0 0 0" class="visual" material="black" mesh="logo_link"/>
+                        <geom pos="0.0039635 0 -0.044" class="visual" material="black" mesh="head_link"/>
+
+                        <geom name="torso_collision1" class="collision" type="capsule" size="0.073" fromto="0.005 -0.032 .22 0.005 0.032 .22"/>
+                        <geom name="torso_collision2" class="collision" type="capsule" size="0.07" fromto="0.005 -0.028 .13 0.005 0.028 .13"/>
+                        <geom name="torso_collision3" class="collision" type="capsule" size="0.065" fromto="0.005 -0.02 .06 0.005 0.02 .06"/>
+                        <geom name="head_collision" class="collision" type="capsule" size="0.068" fromto="0.01 0 .41 0.01 0 .42"/>
+
+                        <site name="imu_in_torso" size="0.01" pos="-0.03959 -0.00224 0.14792"/>
+                        <site name="mid360" size="0.01" pos="0.0002835 0.00003 0.41618" quat="0.00000094 -0.99979404 0.00004632 0.02029493"/>
+                        <body name="left_shoulder_pitch_link" pos="0.0039563 0.10022 0.24778"
+                              quat="0.990264 0.139201 1.38722e-05 -9.86868e-05">
+                            <inertial pos="0 0.035892 -0.011628" quat="0.654152 0.0130458 -0.326267 0.68225" mass="0.718"
+                                      diaginertia="0.000465864 0.000432842 0.000406394"/>
+                            <joint name="left_shoulder_pitch_joint" class="shoulder_pitch"/>
+                            <geom class="visual" mesh="left_shoulder_pitch_link"/>
+                            <geom size="0.03 0.025" pos="0 0.04 -0.01" quat="0.707107 0 0.707107 0" type="cylinder" class="visual"/>
+                            <body name="left_shoulder_roll_link" pos="0 0.038 -0.013831" quat="0.990268 -0.139172 0 0">
+                                <inertial pos="-0.000227 0.00727 -0.063243" quat="0.701256 -0.0196223 -0.00710317 0.712604" mass="0.643"
+                                          diaginertia="0.000691311 0.000618011 0.000388977"/>
+                                <joint name="left_shoulder_roll_joint" range="-1.5882 2.2515" class="shoulder_roll"/>
+                                <geom class="visual" mesh="left_shoulder_roll_link"/>
+                                <geom size="0.03 0.015" pos="-0.004 0.006 -0.053" type="cylinder" class="visual"/>
+                                <body name="left_shoulder_yaw_link" pos="0 0.00624 -0.1032">
+                                    <inertial pos="0.010773 -0.002949 -0.072009" quat="0.716879 -0.0964829 -0.0679942 0.687134"
+                                              mass="0.734" diaginertia="0.00106187 0.00103217 0.000400661"/>
+                                    <joint name="left_shoulder_yaw_joint" class="shoulder_yaw"/>
+                                    <geom class="visual" mesh="left_shoulder_yaw_link"/>
+                                    <geom name="left_shoulder_yaw_collision" class="collision" type="capsule" size="0.035" fromto="0 0 -0.08 0 0 0.05"/>
+                                    <body name="left_elbow_link" pos="0.015783 0 -0.080518">
+                                        <inertial pos="0.064956 0.004454 -0.010062" quat="0.541765 0.636132 0.388821 0.388129" mass="0.6"
+                                                  diaginertia="0.000443035 0.000421612 0.000259353"/>
+                                        <joint name="left_elbow_joint" class="elbow"/>
+                                        <geom class="visual" mesh="left_elbow_link"/>
+                                        <geom name="left_elbow_yaw_collision" class="collision" type="capsule" size="0.035" fromto="-0.01 0 -0.01 0.12 0 -0.01"/>
+                                        <body name="left_wrist_roll_link" pos="0.1 0.00188791 -0.01">
+                                            <inertial pos="0.0171394 0.000537591 4.8864e-07" quat="0.575338 0.411667 -0.574906 0.411094"
+                                                      mass="0.085445" diaginertia="5.48211e-05 4.96646e-05 3.57798e-05"/>
+                                            <joint name="left_wrist_roll_joint" class="wrist_roll"/>
+                                            <geom class="visual" mesh="left_wrist_roll_link"/>
+                                            <body name="left_wrist_pitch_link" pos="0.038 0 0">
+                                                <inertial pos="0.0229999 -0.00111685 -0.00111658" quat="0.249998 0.661363 0.293036 0.643608"
+                                                          mass="0.48405" diaginertia="0.000430353 0.000429873 0.000164648"/>
+                                                <joint name="left_wrist_pitch_joint" class="wrist_pitch"/>
+                                                <geom class="visual" mesh="left_wrist_pitch_link"/>
+                                                <body name="left_wrist_yaw_link" pos="0.046 0 0">
+                                                    <inertial pos="0.0708244 0.000191745 0.00161742" quat="0.510571 0.526295 0.468078 0.493188"
+                                                              mass="0.254576" diaginertia="0.000646113 0.000559993 0.000147566"/>
+                                                    <joint name="left_wrist_yaw_joint" class="wrist_yaw"/>
+                                                    <geom class="visual" mesh="left_wrist_yaw_link"/>
+                                                    <geom pos="0.0415 0.003 0" quat="1 0 0 0" class="visual" mesh="left_rubber_hand"/>
+                                                    <site name="left_palm" pos="0.08 0 0" size="0.01"/>
+                                                    <geom name="left_hand_collision" class="collision" type="capsule" size="0.05" fromto="0.05 0 0 0.1 0 0"/>
+                                                </body>
+                                            </body>
+                                        </body>
+                                    </body>
+                                </body>
+                            </body>
+                        </body>
+                        <body name="right_shoulder_pitch_link" pos="0.0039563 -0.10021 0.24778"
+                              quat="0.990264 -0.139201 1.38722e-05 9.86868e-05">
+                            <inertial pos="0 -0.035892 -0.011628" quat="0.68225 -0.326267 0.0130458 0.654152" mass="0.718"
+                                      diaginertia="0.000465864 0.000432842 0.000406394"/>
+                            <joint name="right_shoulder_pitch_joint" class="shoulder_pitch"/>
+                            <geom class="visual" mesh="right_shoulder_pitch_link"/>
+                            <geom size="0.03 0.025" pos="0 -0.04 -0.01" quat="0.707107 0 0.707107 0" type="cylinder" class="visual"/>
+                            <body name="right_shoulder_roll_link" pos="0 -0.038 -0.013831" quat="0.990268 0.139172 0 0">
+                                <inertial pos="-0.000227 -0.00727 -0.063243" quat="0.712604 -0.00710317 -0.0196223 0.701256"
+                                          mass="0.643" diaginertia="0.000691311 0.000618011 0.000388977"/>
+                                <joint name="right_shoulder_roll_joint" range="-2.2515 1.5882" class="shoulder_roll"/>
+                                <geom class="visual" mesh="right_shoulder_roll_link"/>
+                                <geom size="0.03 0.015" pos="-0.004 -0.006 -0.053" type="cylinder" class="visual"/>
+                                <body name="right_shoulder_yaw_link" pos="0 -0.00624 -0.1032">
+                                    <inertial pos="0.010773 0.002949 -0.072009" quat="0.687134 -0.0679942 -0.0964829 0.716879"
+                                              mass="0.734" diaginertia="0.00106187 0.00103217 0.000400661"/>
+                                    <joint name="right_shoulder_yaw_joint" class="shoulder_yaw"/>
+                                    <geom class="visual" mesh="right_shoulder_yaw_link"/>
+                                    <geom name="right_shoulder_yaw_collision" class="collision" type="capsule" size="0.035" fromto="0 0 -0.08 0 0 0.05"/>
+                                    <body name="right_elbow_link" pos="0.015783 0 -0.080518">
+                                        <inertial pos="0.064956 -0.004454 -0.010062" quat="0.388129 0.388821 0.636132 0.541765" mass="0.6"
+                                                  diaginertia="0.000443035 0.000421612 0.000259353"/>
+                                        <joint name="right_elbow_joint" class="elbow"/>
+                                        <geom class="visual" mesh="right_elbow_link"/>
+                                        <geom name="right_elbow_yaw_collision" class="collision" type="capsule" size="0.035" fromto="-0.01 0 -0.01 0.12 0 -0.01"/>
+                                        <body name="right_wrist_roll_link" pos="0.1 -0.00188791 -0.01">
+                                            <inertial pos="0.0171394 -0.000537591 4.8864e-07" quat="0.411667 0.575338 -0.411094 0.574906"
+                                                      mass="0.085445" diaginertia="5.48211e-05 4.96646e-05 3.57798e-05"/>
+                                            <joint name="right_wrist_roll_joint" class="wrist_roll"/>
+                                            <geom class="visual" mesh="right_wrist_roll_link"/>
+                                            <body name="right_wrist_pitch_link" pos="0.038 0 0">
+                                                <inertial pos="0.0229999 0.00111685 -0.00111658" quat="0.643608 0.293036 0.661363 0.249998"
+                                                          mass="0.48405" diaginertia="0.000430353 0.000429873 0.000164648"/>
+                                                <joint name="right_wrist_pitch_joint" class="wrist_pitch"/>
+                                                <geom class="visual" mesh="right_wrist_pitch_link"/>
+                                                <body name="right_wrist_yaw_link" pos="0.046 0 0">
+                                                    <inertial pos="0.0708244 -0.000191745 0.00161742" quat="0.493188 0.468078 0.526295 0.510571"
+                                                              mass="0.254576" diaginertia="0.000646113 0.000559993 0.000147566"/>
+                                                    <joint name="right_wrist_yaw_joint" class="wrist_yaw"/>
+                                                    <geom class="visual" mesh="right_wrist_yaw_link"/>
+                                                    <geom pos="0.0415 -0.003 0" quat="1 0 0 0" class="visual" mesh="right_rubber_hand"/>
+                                                    <site name="right_palm" pos="0.08 0 0" size="0.01"/>
+                                                    <geom name="right_hand_collision" class="collision" type="capsule" size="0.05" fromto="0.05 0 0 0.1 0 0"/>
+                                                </body>
+                                            </body>
+                                        </body>
+                                    </body>
+                                </body>
+                            </body>
+                        </body>
+                    </body>
+                </body>
+            </body>
+        </body>
+    </worldbody>
+
+    <contact>>
+        <!-- left foot - floor -->
+        <pair name="left_foot1_floor" geom1="left_foot1_collision" geom2="floor" solref="0.01 1" friction="0.8 0.8"/>
+        <pair name="left_foot2_floor" geom1="left_foot2_collision" geom2="floor" solref="0.01 1" friction="0.8 0.8"/>
+        <pair name="left_foot3_floor" geom1="left_foot3_collision" geom2="floor" solref="0.01 1" friction="0.8 0.8"/>
+        <pair name="left_foot4_floor" geom1="left_foot4_collision" geom2="floor" solref="0.01 1" friction="0.8 0.8"/>
+        <pair name="left_foot5_floor" geom1="left_foot5_collision" geom2="floor" solref="0.01 1" friction="0.8 0.8"/>
+        <pair name="left_foot6_floor" geom1="left_foot6_collision" geom2="floor" solref="0.01 1" friction="0.8 0.8"/>
+        <pair name="left_foot7_floor" geom1="left_foot7_collision" geom2="floor" solref="0.01 1" friction="0.8 0.8"/>
+        <!-- right foot - floor -->
+        <pair name="right_foot1_floor" geom1="right_foot1_collision" geom2="floor" solref="0.01 1" friction="0.8 0.8"/>
+        <pair name="right_foot2_floor" geom1="right_foot2_collision" geom2="floor" solref="0.01 1" friction="0.8 0.8"/>
+        <pair name="right_foot3_floor" geom1="right_foot3_collision" geom2="floor" solref="0.01 1" friction="0.8 0.8"/>
+        <pair name="right_foot4_floor" geom1="right_foot4_collision" geom2="floor" solref="0.01 1" friction="0.8 0.8"/>
+        <pair name="right_foot5_floor" geom1="right_foot5_collision" geom2="floor" solref="0.01 1" friction="0.8 0.8"/>
+        <pair name="right_foot6_floor" geom1="right_foot6_collision" geom2="floor" solref="0.01 1" friction="0.8 0.8"/>
+        <pair name="right_foot7_floor" geom1="right_foot7_collision" geom2="floor" solref="0.01 1" friction="0.8 0.8"/>
+    </contact>
+
+    <sensor>
+        <framequat name="base_quat" objtype="site" objname="imu_in_pelvis"/>
+        <gyro name="base_gyro" site="imu_in_pelvis"/>
+        <accelerometer name="base_accel" site="imu_in_pelvis"/>
+
+        <framequat name="mid360_quat" objtype="site" objname="mid360"/>
+        <framepos name="mid360_pos" objtype="site" objname="mid360"/>
+    </sensor>
+
+    <visual>
+        <headlight diffuse="0.6 0.6 0.6" ambient="0.3 0.3 0.3" specular="0 0 0"/>
+        <rgba haze="0.15 0.25 0.35 1"/>
+        <global azimuth="120" elevation="-20"/>
+    </visual>
+
+    <asset>
+        <texture type="skybox" builtin="gradient" rgb1="0.3 0.5 0.7" rgb2="0 0 0" width="512" height="3072"/>
+        <texture type="2d" name="groundplane" builtin="checker" mark="edge" rgb1="0.2 0.3 0.4" rgb2="0.1 0.2 0.3"
+                 markrgb="0.8 0.8 0.8" width="300" height="300"/>
+        <material name="groundplane" texture="groundplane" texuniform="true" texrepeat="5 5" reflectance="0.2"/>
+    </asset>
+
+    <worldbody>
+        <light pos="0 0 1.5" dir="0 0 -1" directional="true"/>
+        <geom name="floor" size="0 0 0.01" type="plane" material="groundplane" conaffinity="1"/>
+    </worldbody>
+
+</mujoco>