Add rig-selection (human / Unitree G1 robot) to the playground

.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

@@ -17,11 +17,13 @@ pinned: false
 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).
 
-Type a natural-language prompt, generate a 3D human-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).
+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).
 
-- **Model:** `nvidia/ARDY-Core-RP-20FPS-Horizon40` — 27-joint "Core" skeleton at 20 fps.
+- **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 (gated base weights pulled via the Space `HF_TOKEN` secret).
 - **Hardware:** ZeroGPU.
 

app.py

@@ -10,11 +10,13 @@ import json
 import random
 import sys
 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.
@@ -25,7 +27,11 @@ 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
 
-MODEL_NICKNAME = "core"  # ARDY-Core-RP-20FPS-Horizon40, 27-joint skeleton @ 20 fps
+# 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
 
 # -----------------------------------------------------------------------------
@@ -43,64 +49,100 @@ MAX_SEED = 2**31 - 1
 # 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 motion model on CPU…", flush=True)
-    MODEL = load_model(MODEL_NICKNAME, device="cpu", text_encoder=_text_encoder)
+    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")
-MODEL = MODEL.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.
-MODEL.device = "cuda"
-MODEL = MODEL.eval()
-
-FPS = float(MODEL.motion_rep.fps)
-SKELETON = MODEL.skeleton
-PARENTS = SKELETON.joint_parents.cpu().numpy().astype(int).tolist()  # [J]
-JOINT_NAMES = list(SKELETON.bone_order_names)
-PATCH = MODEL.num_frames_per_token
-GEN_HORIZON = MODEL.gen_horizon_len
-NUM_BASE_STEPS = int(MODEL.diffusion.num_base_steps)
-print(f"Model ready: {SKELETON.nbjoints} joints, {FPS} fps, horizon {GEN_HORIZON}", flush=True)
-
-
-def _default_history_frames(fps: float, gen_horizon_len: int, patch: int) -> int:
-    max_window_len = (int(10 * fps) // patch) * patch
-    return ((max_window_len - gen_horizon_len) // patch) * patch
-
-
-HISTORY_FRAMES = _default_history_frames(FPS, GEN_HORIZON, PATCH)
-# History carried between autoregressive windows. The reference streaming demo
-# (scripts/interactive_demo, DEFAULT_HISTORY_CROP_LENGTH=4) keeps this SHORT: a
-# new prompt then takes effect within a window. A long history makes the model
-# refuse to switch actions (it just keeps doing the previous motion), which is
-# why "Continue" and compound prompts weren't changing behavior.
-HIST_CROP = max(PATCH, (4 // PATCH) * PATCH)
-ROOT_IDX = PARENTS.index(-1) if -1 in PARENTS else 0
-print(f"AR params: nfpt(PATCH)={PATCH}, gen_horizon={GEN_HORIZON}, hist_crop={HIST_CROP}", flush=True)
+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
 
 
 # -----------------------------------------------------------------------------
-# Skinned body mesh (ARDY "CoreSkin" linear-blend skinning).
+# 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)
-# We do the same, but split the work: 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
+# 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) instead of streaming ~9k verts/frame.
+# so the payload stays small (~0.1 MB/clip).
 # -----------------------------------------------------------------------------
-_SKIN_PATH = Path(SKELETON.folder) / "skin_standard.npz"
+_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)
@@ -130,7 +172,7 @@ print(f"CoreSkin ready: {SKIN_META['V']} verts / {SKIN_META['F']} faces, "
       f"blob {len(SKIN_B64) // 1024} KB", flush=True)
 
 
-def _joint_affines(global_rot_mats: np.ndarray, posed_joints: np.ndarray) -> str:
+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]."""
@@ -143,10 +185,179 @@ def _joint_affines(global_rot_mats: np.ndarray, posed_joints: np.ndarray) -> str
     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")
+
+
 # -----------------------------------------------------------------------------
 # Inference
 # -----------------------------------------------------------------------------
-def _estimate_duration(prompt, duration=5.0, *args, **kwargs):
+def _estimate_duration(prompt, rig=DEFAULT_RIG, duration=5.0, *args, **kwargs):
     # Autoregressive: rough per-second-of-motion cost + text encoding overhead.
     try:
         d = float(duration)
@@ -162,26 +373,30 @@ def _estimate_duration(prompt, duration=5.0, *args, **kwargs):
 # 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 (scripts/interactive_demo/generation.py). 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(prompt, num_new_frames, steps, cfg_weight, init_tensor):
-    """Run the AR loop for one prompt. `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 [1, Th + rounded(new), D]."""
-    text_feat, text_pad_mask = MODEL._encode_text([prompt])
+# 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
+    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
+            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)
+        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,
@@ -199,25 +414,35 @@ def _generate_sequence(prompt, num_new_frames, steps, cfg_weight, init_tensor):
     return motion_tensor
 
 
-def _pack_payload(motion_tensor, prompt, seed):
+def _pack_payload(rig_key, motion_tensor, prompt, seed):
     """Decode a normalized feature tensor to the browser payload (per-frame joint
-    affines for LBS + root ground-track)."""
+    affines + root ground-track), tagged with the rig so the viewer loads the
+    correct skeleton/model."""
+    r = RIGS[rig_key]
+    model = r["model"]
     with torch.no_grad():
-        out = to_numpy(MODEL.motion_rep.inverse(motion_tensor, is_normalized=True))
+        out = to_numpy(model.motion_rep.inverse(motion_tensor, is_normalized=True))
     posed = np.asarray(out["posed_joints"])[0]      # [T, J, 3] global joint positions
     grm = np.asarray(out["global_rot_mats"])[0]      # [T, J, 3, 3] global rotations
+    if rig_key == "robot":
+        affines = _joint_transforms_robot(grm, posed)
+    else:
+        affines = _joint_affines_human(grm, posed)
     return {
-        "fps": FPS,
+        "rig": rig_key,
+        "fps": r["fps"],
         "num_frames": int(posed.shape[0]),
         "num_joints": int(posed.shape[1]),
-        "affines": _joint_affines(grm, posed),       # drives browser-side LBS
-        "root": np.round(posed[:, ROOT_IDX, :].astype(np.float32), 4).tolist(),
+        "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(prompt, duration, diffusion_steps, cfg_weight, seed, randomize_seed, init_np):
+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.")
@@ -225,41 +450,43 @@ def _core_generate(prompt, duration, diffusion_steps, cfg_weight, seed, randomiz
         seed = random.randint(0, MAX_SEED)
     seed = int(seed)
     seed_everything(seed)
-    steps = max(1, min(int(diffusion_steps), NUM_BASE_STEPS))
-    num_new = max(PATCH, int(round(float(duration) * FPS)))
+    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(prompt, num_new, steps, cfg_weight, init_tensor)
-    payload = _pack_payload(full, prompt, seed)
+        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}] '{prompt[:50]}' +{num_new}f -> {full.shape[1]}f total "
+    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(duration=_estimate_duration)
-def ui_generate(prompt, duration=5.0, diffusion_steps=NUM_BASE_STEPS,
+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(prompt, duration, diffusion_steps, cfg_weight, seed, randomize_seed, None)
+    return _core_generate(rig, prompt, duration, diffusion_steps, cfg_weight, seed, randomize_seed, None)
 
 
 @spaces.GPU(duration=_estimate_duration)
-def ui_continue(prompt, duration=5.0, diffusion_steps=NUM_BASE_STEPS,
+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(prompt, duration, diffusion_steps, cfg_weight, seed, randomize_seed, state)
+    return _core_generate(rig, prompt, duration, diffusion_steps, cfg_weight, seed, randomize_seed, state)
 
 
 @spaces.GPU(duration=_estimate_duration)
-def generate_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, int]:
-    """Generate a 3D human motion clip from a text prompt with ARDY.
+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.
@@ -270,29 +497,26 @@ def generate_motion(prompt: str, duration: float = 5.0, diffusion_steps: int = N
         A JSON string with the animated skeleton payload plus the seed used.
     """
     payload_json, seed, _ = _core_generate(
-        prompt, duration, diffusion_steps, cfg_weight, seed, randomize_seed, None
+        rig, prompt, duration, diffusion_steps, cfg_weight, seed, randomize_seed, None
     )
     return payload_json, seed
 
 
 # -----------------------------------------------------------------------------
-# Front-end: a self-contained Three.js skeleton playground, delivered as a
-# Gradio-native custom HTML component (Gradio 6 `gr.HTML` templates + js_on_load).
+# 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). This is
-# the robust hand-off described in the official guide
-# (https://www.gradio.app/guides/custom-HTML-components) and replaces the old
-# hidden-textbox + window.ardyLoad global bridge, which was fragile across
-# Gradio 6 rerender/hydration (the js= callback could fire before the module
-# script initialised, and the DOM node could re-mount and drop listeners).
+# 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.
 # -----------------------------------------------------------------------------
 
-# Static markup for the player. Lives *inside* the component so js_on_load can
-# scope every query to `element` (its own DOM root) — no global element IDs, so
-# nothing races or collides across rerenders.
 PLAYER_TEMPLATE = """
 <div class="ardy-playground">
   <div class="ardy-canvas-wrap">
@@ -318,8 +542,6 @@ PLAYER_TEMPLATE = """
 """
 
 # css_template rules are auto-scoped to this component by Gradio.
-# Light "studio" look matching the ARDY project page: white stage, faint grid,
-# soft contact shadow, light-blue body.
 PLAYER_CSS_TEMPLATE = """
 .ardy-playground { width: 100%; }
 .ardy-canvas-wrap {
@@ -347,30 +569,34 @@ PLAYER_CSS_TEMPLATE = """
 .ardy-caption { margin-top:6px; font-size:13px; color:#667085; }
 """
 
-# Page-level CSS (container width + dark-mode text fix). The player's own
-# styles live in PLAYER_CSS_TEMPLATE, auto-scoped to the component by Gradio.
 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
-# (bind mesh + LBS weights, shipped once as ARDY_SKIN_B64), build the scene, and
-# subscribe to value changes with `watch('value', ...)`. Each generated payload
-# carries only the per-frame joint affine matrices; we run linear-blend skinning
-# in the browser to produce the body mesh — matching ardy/viz/core_skin.py.
+# 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, skin:null,
+  ready:false,
   THREE:null, OrbitControls:null,
   renderer:null, scene:null, camera:null, controls:null,
-  mesh:null, geom:null, trailLine: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 ---------------------------------------------------------
@@ -385,7 +611,7 @@ async function gunzip(bytes){
   return buf;
 }
 
-// Decode the one-time static skin blob into typed arrays.
+// 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;
@@ -397,7 +623,18 @@ async function decodeSkin(){
   return {V, F, W, bindV, faces, idx, wt};
 }
 
-// Per-vertex linear-blend skinning for every frame (done once per clip on load).
+// 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){
@@ -423,7 +660,35 @@ function skinAllFrames(A, T, J){
   return frames;
 }
 
-// --- three.js scene (light "studio" look, matching the ARDY project page) ---
+// 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");
@@ -448,7 +713,6 @@ function initScene(){
   scene.add(key);
   scene.add(new THREE.DirectionalLight(0xeef2ff, 0.35).translateX(-4).translateZ(-2));
 
-  // Soft contact shadow on an invisible ground plane.
   const ground = new THREE.Mesh(
     new THREE.PlaneGeometry(40, 40),
     new THREE.ShadowMaterial({opacity:0.16})
@@ -469,16 +733,42 @@ function initScene(){
   animate();
 }
 
-function buildMesh(){
-  const THREE = state.THREE, s = state.skin;
-  if(state.mesh) return;   // static topology — build once, reuse across clips
-  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.mesh = mesh; state.geom = geom;
+// 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){
@@ -486,11 +776,13 @@ function setFrame(f){
   const T = state.data.num_frames;
   f = Math.max(0, Math.min(T-1, f|0));
   state.frame = f;
-  const pos = state.geom.getAttribute("position");
+  const geom = activeGeom();
+  if(!geom) return;
+  const pos = geom.getAttribute("position");
   pos.array.set(state.verts[f]);
   pos.needsUpdate = true;
-  state.geom.computeVertexNormals();
-  state.geom.computeBoundingSphere();
+  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;
@@ -543,19 +835,23 @@ function setPlaying(p){
 
 function loadData(data){
   initScene();
-  buildMesh();
+  const rig = (data.rig === "robot") ? "robot" : "human";
+  state.rig = rig;
+  mountRig(rig);
   state.data = data;
-  // Decode per-frame affines and pre-skin every frame (one-time cost per clip).
+  // 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 = skinAllFrames(A, T, J);
+  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 + '"  ·  ' + T + ' frames @ ' + data.fps + ' fps  ·  seed ' + data.seed;
+  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);
@@ -563,7 +859,7 @@ function loadData(data){
 
 function applyPayload(payload){
   if(!payload) return;
-  if(!state.ready){ state.pending = payload; return; }   // three.js / skin still loading
+  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); }
 }
@@ -580,23 +876,28 @@ function wireControls(){
 }
 
 // Gradio-native hand-off: render whenever the component's value prop updates as
-// the output of a Python event (Generate / Examples).
+// 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 the
-// skin, then flush any value that already arrived.
+// 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(),
-]).then(([THREE, oc, skin]) => {
+  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();
@@ -606,12 +907,12 @@ Promise.all([
 """
 
 EXAMPLES = [
-    ["A person walks forward confidently.", 5.0],
-    ["A person walks in a circle.", 6.0],
-    ["A person jumps up and down.", 4.0],
-    ["A person waves with the right hand.", 4.0],
-    ["A person crouches down and then stands back up.", 5.0],
-    ["A person kicks with the right leg.", 4.0],
+    ["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:
@@ -621,7 +922,8 @@ with gr.Blocks() as demo:
             # 🕺 ARDY Motion Playground
             Interactive text-to-motion with **[ARDY](https://research.nvidia.com/labs/sil/projects/ardy/)**
             (Autoregressive Diffusion with Hybrid Representation) by NVIDIA.
-            Type a prompt and **Generate** a 3D human-motion clip, then **orbit, scrub, and play** it below.
+            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.
             """
         )
@@ -630,6 +932,14 @@ with gr.Blocks() as demo:
         # resume the same character from the end of the previous clip.
         seq_state = gr.State(None)
 
+        rig = gr.Radio(
+            choices=[("🕺 Human", "human"), ("🤖 Robot (Unitree G1)", "robot")],
+            value=DEFAULT_RIG,
+            label="Rig",
+            info="Choose which character to animate. Human uses the 27-joint skeleton; "
+                 "Robot uses the Unitree G1 humanoid.",
+        )
+
         prompt = gr.Textbox(
             label="Motion prompt",
             placeholder="e.g. a person walks in a circle then waves",
@@ -641,18 +951,20 @@ with gr.Blocks() as demo:
 
         # 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. No hidden bridge.
-        # Ship the static skin data (bind mesh + LBS weights) once, as a header
+        # `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.
-        _skin_header = (
+        _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=_skin_header + PLAYER_JS_ON_LOAD,
+            js_on_load=_rig_header + PLAYER_JS_ON_LOAD,
             elem_id="ardy-player",
         )
 
@@ -668,7 +980,7 @@ with gr.Blocks() as demo:
 
         gr.Examples(
             examples=EXAMPLES,
-            inputs=[prompt, duration],
+            inputs=[prompt, rig, duration],
             outputs=[player, seed, seq_state],
             fn=ui_generate,
             cache_examples=False,
@@ -677,7 +989,8 @@ with gr.Blocks() as demo:
 
         gr.Markdown(
             """
-            <small>Model: **ARDY-Core-RP-20FPS-Horizon40** · 27-joint skeleton · 20 fps.
+            <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,
@@ -685,10 +998,10 @@ with gr.Blocks() as demo:
             """
         )
 
-    _gen_inputs = [prompt, duration, diffusion_steps, cfg_weight, seed, randomize_seed]
+    _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. No hidden bridge.
+    # `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],

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

requirements.txt

@@ -8,5 +8,6 @@ peft>=0.19
 einops>=0.7
 vector-quantize-pytorch>=1.25,<1.26
 safetensors>=0.4
+trimesh>=4.0
 tqdm>=4.0
 packaging>=21.0