User reports the Robot Wizard “Add Colliders” button does not show in the window. This likely blocks or slows collider generation during robot import/setup.

Robot Wizard Add Colliders Buutton ont show in the window

### Description

Re-directed from #290 , CC @vick-yu 

As the **Content Browser** is planned to replace the Asset Browser in the upcoming Isaac Sim 6 version, there are several UX issues related to the Content Browser (compared to the features of the Asset Browser in Isaac Sim 5.1.0):
- It's not possible to preview assets via thumbnails.
- Search does not include non-SimReady Isaac assets (it only lists SimReady assets). For example, I was looking for a table in the "Props" section. Filtering for "table", the Isaac Sim Assets extension lists 9 tables, whereas the Content Browser only provides 1 table (PackingTable).
- A global search in the "Isaac Sim" category for an asset cannot be performed. For example, filtering for "table" in the global "Isaac Sim" category, searching among all asset categories, does not work.
- There is no indication showing how many assets are available, neither globally for "Isaac Sim" nor for each category.
- There is no option to drag'n'drop assets just right into the viewport or stage. For me, it remains unclear how to add assets from the Content Browser into the environment.

It would be great to address these issues before the full transition to the Content Browser.

### Isaac Sim version

5.1.0 / 6.0.0 dev2

### Operating System (OS)

Windows 11

### GPU Name

RTX 3080 Ti

### GPU Driver and CUDA versions

GameReady 591.86, CUDA 13.2.1

### Logs

_No response_

### Additional information

_No response_

Isaac Sim Content Browser (planned to replace Asset Browser in Isaac Sim 6) lacks key UX features compared to Asset Browser in 5.1.0: no thumbnail preview, incomplete search (excludes non-SimReady assets), and inability to do some global searches within categories. Users can’t reliably find common assets like tables.

Content Browser UX Issues

### Question

Hi, I'm working with tactile sensing and recently I noticed TacSL sensor in IsaacLab. 
Focused on force filed data not visual image, I tried to apply a normal force that increases in steps, but the force data from sensor  didn't increased as expected. It's more like irregular.
Confused about that.

### Result output:
<img width="1047" height="1804" alt="Image" src="https://github.com/user-attachments/assets/c146c001-af3a-46cf-944b-5f252a2b7067" />

### Build Info
- Isaac Lab Version: [main branch]
- Isaac Sim Version: [5.1]

###Code for reproduce

    # Usage
    ./isaaclab.sh -p scripts/demos/sensors/tacsl_sensor.py \
        --use_tactile_ff \
        --tactile_compliance_stiffness 100.0 \
        --num_envs 1 \
        --contact_object_type nut

```python

# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
# All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause

"""
Example script demonstrating the TacSL tactile sensor implementation in IsaacLab.

This script shows how to use the TactileSensor for both camera-based and force field
tactile sensing with the GelSight finger setup.

.. code-block:: bash

    # Usage
    ./isaaclab.sh -p scripts/demos/sensors/tacsl_sensor.py \
        --use_tactile_ff \
        --tactile_compliance_stiffness 100.0 \
        --num_envs 1 \
        --contact_object_type nut

"""

import argparse
import math
import os

import cv2
import numpy as np
import torch

from isaaclab.app import AppLauncher

# Add argparse arguments
parser = argparse.ArgumentParser(description="TacSL tactile sensor example.")
parser.add_argument("--num_envs", type=int, default=2, help="Number of environments to spawn.")
parser.add_argument("--normal_contact_stiffness", type=float, default=1.0, help="Tactile normal stiffness.")
parser.add_argument("--tangential_stiffness", type=float, default=0.1, help="Tactile tangential stiffness.")
parser.add_argument("--friction_coefficient", type=float, default=2.0, help="Tactile friction coefficient.")
parser.add_argument(
    "--tactile_compliance_stiffness",
    type=float,
    default=None,
    help="Optional: Override compliant contact stiffness (default: use USD asset values)",
)
parser.add_argument(
    "--tactile_compliant_damping",
    type=float,
    default=None,
    help="Optional: Override compliant contact damping (default: use USD asset values)",
)
parser.add_argument("--save_viz", action="store_true", help="Visualize tactile data.")
parser.add_argument("--save_viz_dir", type=str, default="tactile_record", help="Directory to save tactile data.")
parser.add_argument("--use_tactile_rgb", action="store_true", help="Use tactile RGB sensor data collection.")
parser.add_argument("--use_tactile_ff", action="store_true", help="Use tactile force field sensor data collection.")
parser.add_argument("--debug_sdf_closest_pts", action="store_true", help="Visualize closest SDF points.")
parser.add_argument("--debug_tactile_sensor_pts", action="store_true", help="Visualize tactile sensor points.")
parser.add_argument("--trimesh_vis_tactile_points", action="store_true", help="Visualize tactile points using trimesh.")
parser.add_argument(
    "--contact_object_type",
    type=str,
    default="nut",
    choices=["none", "cube", "nut"],
    help="Type of contact object to use.",
)

# Append AppLauncher cli args
AppLauncher.add_app_launcher_args(parser)
# Parse the arguments
args_cli = parser.parse_args()

# Launch omniverse app
app_launcher = AppLauncher(args_cli)
simulation_app = app_launcher.app

"""Rest everything follows."""

import isaaclab.sim as sim_utils
from isaaclab.assets import ArticulationCfg, AssetBaseCfg, RigidObjectCfg
from isaaclab.scene import InteractiveScene, InteractiveSceneCfg
from isaaclab.sensors import TiledCameraCfg
from isaaclab.utils import configclass
from isaaclab.utils.assets import ISAACLAB_NUCLEUS_DIR
from isaaclab.utils.timer import Timer

from isaaclab_contrib.sensors.tacsl_sensor import VisuoTactileSensorCfg
from isaaclab_contrib.sensors.tacsl_sensor.visuotactile_render import compute_tactile_shear_image
from isaaclab_contrib.sensors.tacsl_sensor.visuotactile_sensor_data import VisuoTactileSensorData

from isaaclab_assets.sensors import GELSIGHT_R15_CFG


@configclass
class TactileSensorsSceneCfg(InteractiveSceneCfg):
    """Design the scene with tactile sensors on the robot."""

    # Ground plane
    ground = AssetBaseCfg(prim_path="/World/defaultGroundPlane", spawn=sim_utils.GroundPlaneCfg())

    # Lights
    dome_light = AssetBaseCfg(
        prim_path="/World/Light", spawn=sim_utils.DomeLightCfg(intensity=3000.0, color=(0.75, 0.75, 0.75))
    )

    # Robot with tactile sensor
    robot = ArticulationCfg(
        prim_path="{ENV_REGEX_NS}/Robot",
        spawn=sim_utils.UsdFileWithCompliantContactCfg(
            usd_path=f"{ISAACLAB_NUCLEUS_DIR}/TacSL/gelsight_r15_finger/gelsight_r15_finger.usd",
            rigid_props=sim_utils.RigidBodyPropertiesCfg(
                disable_gravity=True,
                max_depenetration_velocity=5.0,
            ),
            compliant_contact_stiffness=args_cli.tactile_compliance_stiffness,
            compliant_contact_damping=args_cli.tactile_compliant_damping,
            physics_material_prim_path="elastomer",
            articulation_props=sim_utils.ArticulationRootPropertiesCfg(
                enabled_self_collisions=False,
                solver_position_iteration_count=12,
                solver_velocity_iteration_count=1,
            ),
            collision_props=sim_utils.CollisionPropertiesCfg(contact_offset=0.001, rest_offset=-0.0005),
        ),
        init_state=ArticulationCfg.InitialStateCfg(
            pos=(0.0, 0.0, 0.5),
            rot=(math.sqrt(2) / 2, -math.sqrt(2) / 2, 0.0, 0.0),  # 90° rotation
            joint_pos={},
            joint_vel={},
        ),
        actuators={},
    )

    # Camera configuration for tactile sensing

    # TacSL Tactile Sensor
    tactile_sensor = VisuoTactileSensorCfg(
        prim_path="{ENV_REGEX_NS}/Robot/elastomer/tactile_sensor",
        history_length=0,
        debug_vis=args_cli.debug_tactile_sensor_pts or args_cli.debug_sdf_closest_pts,
        # Sensor configuration
        render_cfg=GELSIGHT_R15_CFG,
        enable_camera_tactile=args_cli.use_tactile_rgb,
        enable_force_field=args_cli.use_tactile_ff,
        # Elastomer configuration
        tactile_array_size=(20, 25),
        tactile_margin=0.003,
        # Contact object configuration
        contact_object_prim_path_expr="{ENV_REGEX_NS}/contact_object",
        # Force field physics parameters
        normal_contact_stiffness=args_cli.normal_contact_stiffness,
        friction_coefficient=args_cli.friction_coefficient,
        tangential_stiffness=args_cli.tangential_stiffness,
        # Camera configuration
        # Note: the camera is already spawned in the scene, properties are set in the
        # 'gelsight_r15_finger.usd' USD file
        camera_cfg=TiledCameraCfg(
            prim_path="{ENV_REGEX_NS}/Robot/elastomer_tip/cam",
            height=GELSIGHT_R15_CFG.image_height,
            width=GELSIGHT_R15_CFG.image_width,
            data_types=["distance_to_image_plane"],
            spawn=None,
        ),
        # Debug Visualization
        trimesh_vis_tactile_points=args_cli.trimesh_vis_tactile_points,
        visualize_sdf_closest_pts=args_cli.debug_sdf_closest_pts,
    )


@configclass
class CubeTactileSceneCfg(TactileSensorsSceneCfg):
    """Scene with cube contact object."""

    # Cube contact object
    contact_object = RigidObjectCfg(
        prim_path="{ENV_REGEX_NS}/contact_object",
        spawn=sim_utils.CuboidCfg(
            size=(0.01, 0.01, 0.01),
            rigid_props=sim_utils.RigidBodyPropertiesCfg(disable_gravity=True),
            mass_props=sim_utils.MassPropertiesCfg(mass=0.00327211),
            collision_props=sim_utils.CollisionPropertiesCfg(),
            physics_material=sim_utils.RigidBodyMaterialCfg(),
            visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(0.0, 0.1, 0.1)),
        ),
        init_state=RigidObjectCfg.InitialStateCfg(pos=(0.0, 0.0 + 0.06776, 0.51), rot=(1.0, 0.0, 0.0, 0.0)),
    )


@configclass
class NutTactileSceneCfg(TactileSensorsSceneCfg):
    """Scene with nut contact object."""

    # Nut contact object
    contact_object = RigidObjectCfg(
        prim_path="{ENV_REGEX_NS}/contact_object",
        spawn=sim_utils.UsdFileCfg(
            usd_path=f"{ISAACLAB_NUCLEUS_DIR}/Factory/factory_nut_m16.usd",
            rigid_props=sim_utils.RigidBodyPropertiesCfg(
                disable_gravity=True,
                solver_position_iteration_count=12,
                solver_velocity_iteration_count=1,
                max_angular_velocity=180.0,
            ),
            mass_props=sim_utils.MassPropertiesCfg(mass=0.1),
            collision_props=sim_utils.CollisionPropertiesCfg(contact_offset=0.005, rest_offset=0),
            articulation_props=sim_utils.ArticulationRootPropertiesCfg(articulation_enabled=False),
        ),
        init_state=RigidObjectCfg.InitialStateCfg(
            pos=(0.0, 0.0 + 0.06776, 0.498),
            rot=(1.0, 0.0, 0.0, 0.0),
        ),
    )


def mkdir_helper(dir_path: str) -> tuple[str, str]:
    """Create directories for saving tactile sensor visualizations.

    Args:
        dir_path: The base directory path where visualizations will be saved.

    Returns:
        A tuple containing paths to the force field directory and RGB image directory.
    """
    tactile_img_folder = dir_path
    os.makedirs(tactile_img_folder, exist_ok=True)
    # create a subdirectory for the force field data
    tactile_force_field_dir = os.path.join(tactile_img_folder, "tactile_force_field")
    os.makedirs(tactile_force_field_dir, exist_ok=True)
    # create a subdirectory for the RGB image data
    tactile_rgb_image_dir = os.path.join(tactile_img_folder, "tactile_rgb_image")
    os.makedirs(tactile_rgb_image_dir, exist_ok=True)

    return tactile_force_field_dir, tactile_rgb_image_dir


def save_viz_helper(
    dir_path_list: tuple[str, str],
    count: int,
    tactile_data: VisuoTactileSensorData,
    num_envs: int,
    nrows: int,
    ncols: int,
):
    """Save visualization of tactile sensor data.

    Args:
        dir_path_list: A tuple containing paths to the force field directory and RGB image directory.
        count: The current simulation step count, used for naming saved files.
        tactile_data: The data object containing tactile sensor readings (forces, images).
        num_envs: Number of environments in the simulation.
        nrows: Number of rows in the tactile array.
        ncols: Number of columns in the tactile array.
    """
    # Only save the first 2 environments

    tactile_force_field_dir, tactile_rgb_image_dir = dir_path_list

    if tactile_data.tactile_shear_force is not None and tactile_data.tactile_normal_force is not None:
        # visualize tactile forces
        tactile_normal_force = tactile_data.tactile_normal_force.view((num_envs, nrows, ncols))
        tactile_shear_force = tactile_data.tactile_shear_force.view((num_envs, nrows, ncols, 2))

        tactile_image = compute_tactile_shear_image(
            tactile_normal_force[0, :, :].detach().cpu().numpy(), tactile_shear_force[0, :, :].detach().cpu().numpy()
        )

        if tactile_normal_force.shape[0] > 1:
            tactile_image_1 = compute_tactile_shear_image(
                tactile_normal_force[1, :, :].detach().cpu().numpy(),
                tactile_shear_force[1, :, :].detach().cpu().numpy(),
            )
            combined_image = np.vstack([tactile_image, tactile_image_1])
            cv2.imwrite(
                os.path.join(tactile_force_field_dir, f"{count:04d}.png"), (combined_image * 255).astype(np.uint8)
            )
        else:
            cv2.imwrite(
                os.path.join(tactile_force_field_dir, f"{count:04d}.png"), (tactile_image * 255).astype(np.uint8)
            )

    if tactile_data.tactile_rgb_image is not None:
        tactile_rgb_data = tactile_data.tactile_rgb_image.cpu().numpy()
        tactile_rgb_data = np.transpose(tactile_rgb_data, axes=(0, 2, 1, 3))
        tactile_rgb_data_first_2 = tactile_rgb_data[:2] if len(tactile_rgb_data) >= 2 else tactile_rgb_data
        tactile_rgb_tiled = np.concatenate(tactile_rgb_data_first_2, axis=0)
        # Convert to uint8 if not already
        if tactile_rgb_tiled.dtype != np.uint8:
            tactile_rgb_tiled = (
                (tactile_rgb_tiled * 255).astype(np.uint8)
                if tactile_rgb_tiled.max() <= 1.0
                else tactile_rgb_tiled.astype(np.uint8)
            )
        cv2.imwrite(os.path.join(tactile_rgb_image_dir, f"{count:04d}.png"), tactile_rgb_tiled)


def run_simulator(sim: sim_utils.SimulationContext, scene: InteractiveScene):
    """Run the simulator."""
    # Define simulation stepping
    sim_dt = sim.get_physics_dt()
    sim_time = 0.0
    count = 0

    # Assign different masses to contact objects in different environments
    num_envs = scene.num_envs

    if args_cli.save_viz:
        # Create output directories for tactile data
        print(f"[INFO]: Saving tactile data to: {args_cli.save_viz_dir}...")
        dir_path_list = mkdir_helper(args_cli.save_viz_dir)

    # Create constant downward force
    force_tensor = torch.zeros(scene.num_envs, 1, 3, device=sim.device)
    torque_tensor = torch.zeros(scene.num_envs, 1, 3, device=sim.device)
    force_tensor[:, 0, 2] = -1.0

    nrows = scene["tactile_sensor"].cfg.tactile_array_size[0]
    ncols = scene["tactile_sensor"].cfg.tactile_array_size[1]

    physics_timer = Timer()
    physics_total_time = 0.0
    physics_total_count = 0

    entity_list = ["robot"]
    if "contact_object" in scene.keys():
        entity_list.append("contact_object")

    while simulation_app.is_running():
        if count == 122:
            # Reset robot and contact object positions
            count = 0
            force_tensor[:, 0, 2] -= 0.5
            for entity in entity_list:
                root_state = scene[entity].data.default_root_state.clone()
                root_state[:, :3] += scene.env_origins
                scene[entity].write_root_state_to_sim(root_state)

            scene.reset()
            print("[INFO]: Resetting robot and contact object state...")

        if "contact_object" in scene.keys():
            # rotation
            if count > 20:
                env_indices = torch.arange(scene.num_envs, device=sim.device)
                odd_mask = env_indices % 2 == 1
                even_mask = env_indices % 2 == 0
                torque_tensor[odd_mask, 0, 2] = 0  # rotation for odd environments
                torque_tensor[even_mask, 0, 2] = 0  # rotation for even environments
                scene["contact_object"].permanent_wrench_composer.set_forces_and_torques(force_tensor, torque_tensor)

        # Step simulation
        scene.write_data_to_sim()
        physics_timer.start()
        sim.step()
        physics_timer.stop()
        physics_total_time += physics_timer.total_run_time
        physics_total_count += 1
        sim_time += sim_dt
        count += 1
        scene.update(sim_dt)

        if count % 50 == 0:
            print(f"Force: {force_tensor[0, 0, 2]}, Count: {count}".center(50, "="))
            # print(f" - tactile_points_pos_w.shape: {tactile_data.tactile_points_pos_w.shape}")
            # print(f" - tactile_points_quat_w.shape: {tactile_data.tactile_points_quat_w.shape}")
            # print(f" - penetration_depth.shape: {tactile_data.penetration_depth.shape}")
            # print(f" - tactile_normal_force.shape: {tactile_data.tactile_normal_force.shape}")
            # print(f" - tactile_shear_force.shape: {tactile_data.tactile_shear_force.shape}")
            print(f" - Sum tactile_normal_force: {tactile_data.tactile_normal_force.sum()*1000:.4f}")
            print(f" - Max tactile_normal_force: {tactile_data.tactile_normal_force.max()*1000:.4f}")
            print(f" - Max penetration_depth: {tactile_data.penetration_depth.max():.4f}")



        # Access tactile sensor data
        tactile_data = scene["tactile_sensor"].data

        if args_cli.save_viz:
            save_viz_helper(dir_path_list, count, tactile_data, num_envs, nrows, ncols)

    # Get timing summary from sensor and add physics timing
    timing_summary = scene["tactile_sensor"].get_timing_summary()

    # Add physics timing to the summary
    physics_avg = physics_total_time / (physics_total_count * scene.num_envs) if physics_total_count > 0 else 0.0
    timing_summary["physics_total"] = physics_total_time
    timing_summary["physics_average"] = physics_avg
    timing_summary["physics_fps"] = 1 / physics_avg if physics_avg > 0 else 0.0

    print(timing_summary)


def main():
    """Main function."""
    # Initialize simulation
    # Note: We set the gpu_collision_stack_size to prevent buffer overflow in contact-rich environments.
    sim_cfg = sim_utils.SimulationCfg(
        dt=0.005,
        device=args_cli.device,
        physx=sim_utils.PhysxCfg(gpu_collision_stack_size=2**30),
    )
    sim = sim_utils.SimulationContext(sim_cfg)

    # Set main camera
    sim.set_camera_view(eye=[0.5, 0.6, 1.0], target=[-0.1, 0.1, 0.5])

    # Create scene based on contact object type
    if args_cli.contact_object_type == "cube":
        scene_cfg = CubeTactileSceneCfg(num_envs=args_cli.num_envs, env_spacing=0.2)
        # disabled force field for cube contact object because a SDF collision mesh cannot
        # be created for the Shape Prims
        scene_cfg.tactile_sensor.enable_force_field = False
    elif args_cli.contact_object_type == "nut":
        scene_cfg = NutTactileSceneCfg(num_envs=args_cli.num_envs, env_spacing=0.2)
    elif args_cli.contact_object_type == "none":
        scene_cfg = TactileSensorsSceneCfg(num_envs=args_cli.num_envs, env_spacing=0.2)
        scene_cfg.tactile_sensor.contact_object_prim_path_expr = None
        # this flag is to visualize the tactile sensor points
        scene_cfg.tactile_sensor.debug_vis = True
    else:
        raise ValueError(
            f"Invalid contact object type: '{args_cli.contact_object_type}'. Must be 'none', 'cube', or 'nut'."
        )

    scene = InteractiveScene(scene_cfg)

    # Initialize simulation
    sim.reset()
    print("[INFO]: Setup complete...")

    # Get initial render
    scene["tactile_sensor"].get_initial_render()
    # Run simulation
    run_simulator(sim, scene)


if __name__ == "__main__":
    # Run the main function
    main()
    # Close sim app
    simulation_app.close()



TacSL force-field readings in an Isaac Lab demo do not increase smoothly with stepped applied normal force and instead appear irregular. The user reports Isaac Lab main branch with Isaac Sim 5.1.

[Question] Uncorrect  force data from tacsl demo

### Bug Description

My task is to import an inspirt dexterous hand (.urdf) and a bottle (.obj) to newton physics, then control the hand to grasp the bottle from the side and lift the bottle. However, the bottle is always unliftable, when the hand move upwards, the bottle seems slide from the hand, failing to be lifted from the ground.  

I can confirm that the collision and the contact between the hand and the bottle is already set, however, maybe because the force closure or friction or other reseason, the bottle is unliftable.  I tried to use the franka example (example_robot_panda_hydro.py) to lift the same bottle, and this works well, the bottle can be correctly lifted. I think this might owing to the stable grasp of two-finger grasping. Despite this, I tried to use build the dexterous grasping scene in isaaclab, which uses PhysX, and also have good result, the bottle can be lifted too. I think it's possible that the bottom layer of Physx has already set up this type of dexterous grasping contact setting, while Newton hasn't yet.  

Hoping someone could give me some advises, thanks very much~

The __init__ function of the Example is shown following:

### Reproduction Script

```python
class Example:
    def __init__(self, viewer, args):
        self.fps = 60  # FIXED: Increased from 50 to 60 (match Panda)
        self.frame_dt = 1.0 / self.fps

        self.sim_time = 0.0
        self.sim_substeps = 10  # FIXED: Increased from 2 to 10 (match Panda) - CRITICAL for stability!
        self.collide_substeps = 2  # FIXED: Run collision every 2 substeps (match Panda)
        self.sim_dt = self.frame_dt / self.sim_substeps  # Now ~1.67ms instead of 10ms

        self.world_count = args.world_count

        self.viewer = viewer

        self.device = wp.get_device()

        self.mimic_mapping = [
            (0, 1.0),      # DOF 0: thumb_1 -> traj[0]
            (1, 1.0),      # DOF 1: thumb_2 -> traj[1]
            (1, 1.1425),   # DOF 2: thumb_3 -> traj[1] * 1.1425 (mimic thumb_2)
            (1, 0.8571),   # DOF 3: thumb_4 -> traj[1] * 0.8571 (mimic thumb_2)
            (2, 1.0),      # DOF 4: index_1 -> traj[2]
            (2, 1.1169),   # DOF 5: index_2 -> traj[2] * 1.1169 (mimic index_1)
            (3, 1.0),      # DOF 6: middle_1 -> traj[3]
            (3, 1.1169),   # DOF 7: middle_2 -> traj[3] * 1.1169 (mimic middle_1)
            (4, 1.0),      # DOF 8: ring_1 -> traj[4]
            (4, 1.1169),   # DOF 9: ring_2 -> traj[4] * 1.1169 (mimic ring_1)
            (5, 1.0),      # DOF 10: little_1 -> traj[5]
            (5, 1.1169),   # DOF 11: little_2 -> traj[5] * 1.1169 (mimic little_1)
        ]

        # Load trajectory data
        self.load_trajectory("trajectory/trajectory_1")

        max_contacts_per_world = 300

        sdf_max_resolution = 64
        sdf_narrow_band_range = (-0.05, 0.05)  # FIXED: Increased from 0.01 to 0.02 (±2cm instead of ±1cm)

        shape_cfg = newton.ModelBuilder.ShapeConfig(
            kh=1e12,
            gap=0.0,  # FIXED: Reduced from 0.01 to 0.005 (5mm collision gap)
            mu=10,  # 添加合理的摩擦
            # mu_torsional=0.005,
            # mu_rolling=0.0001,
        )


        # meshes need explicit call to build_sdf with sdf parameters, while primitive sdf are configured directly via shape config flags
        shape_cfg_meshes = replace(shape_cfg, is_hydroelastic=True,density=1,kh=1e12)
        shape_cfg_primitives = replace(
            shape_cfg,
            is_hydroelastic=True,
            sdf_max_resolution=sdf_max_resolution,
            sdf_narrow_band_range=sdf_narrow_band_range,
        )

        env = newton.ModelBuilder()
        newton.solvers.SolverMuJoCo.register_custom_attributes(env)
        
        env.default_shape_cfg.ke = 1.0e3
        env.default_shape_cfg.kd = 1.0e3
        env.default_shape_cfg.kh = 1e12
        env.default_shape_cfg.margin = 0.0  # FIXED: Reduced from 0.005 to 0.002 (2mm margin)
        env.default_shape_cfg.gap = 0.0     # FIXED: Reduced from 0.015 to 0.005 (5mm gap)
        env.default_shape_cfg.mu = 2  # Friction coefficient
        env.default_shape_cfg.restitution = 0.0
        # env.default_shape_cfg.is_hydroelastic=True
        

        # Load hand URDF
        hand_asset_file = "assets/urdf/RH56F1_L/urdf/RH56F1_L.urdf"
        initial_wrist_pos = self.initial_wrist_pos
        initial_wrist_quat = self.initial_wrist_quat
        
        print(f"\n=== Loading Hand URDF ===")
        print(f"Hand asset: {hand_asset_file}")
        print(f"Initial wrist position: {initial_wrist_pos}")
        print(f"Initial wrist rotation: {initial_wrist_quat}")
        
        env.add_urdf(
            hand_asset_file,
            xform=wp.transform(initial_wrist_pos, initial_wrist_quat),  # Use trajectory initial position
            enable_self_collisions=False,
            parse_visuals_as_colliders=False,
        )
        
        # Helper function to find joint index by name
        def find_joint(name):
            """Find joint index by name (similar to find_body in panda example)"""
            return next(i for i, lbl in enumerate(env.joint_label) if lbl.endswith(f"/{name}"))
        
        # Helper function to find joint DOF index by name
        def find_joint_dof(name):
            """Find joint DOF index by joint name"""
            joint_idx = find_joint(name)
            return env.joint_qd_start[joint_idx]

        for shape_idx, body_idx in enumerate(env.shape_body):
            if env.shape_type[shape_idx] == newton.GeoType.MESH:
                mesh = env.shape_source[shape_idx]
                if mesh is not None and mesh.sdf is None:
                    shape_scale = np.asarray(env.shape_scale[shape_idx], dtype=np.float32)
                    if not np.allclose(shape_scale, 1.0):
                        # Hydroelastic mesh SDFs must be scale-baked for non-unit shape scale.
                        mesh = mesh.copy(vertices=mesh.vertices * shape_scale, recompute_inertia=True)
                        env.shape_source[shape_idx] = mesh
                        env.shape_scale[shape_idx] = (1.0, 1.0, 1.0)
                    mesh.build_sdf(
                        max_resolution=sdf_max_resolution,
                        narrow_band_range=sdf_narrow_band_range,
                        margin=0.0,
                        # gap=0.001
                    )
                env.shape_flags[shape_idx] |= newton.ShapeFlags.HYDROELASTIC


        
        hand_body_count = env.body_count
        hand_joint_count = env.joint_count
        print(f"Hand bodies: {hand_body_count}, joints: {hand_joint_count}")
        
        # Print all joint names and their DOF indices for debugging
        print(f"\n=== Joint Structure ===")
        print(f"Total joints: {env.joint_count}")
        print(f"Total DOFs: {env.joint_dof_count}")
        print(f"\nActive joints (with DOFs):")
        active_joint_names = []
        for i in range(env.joint_count):
            dof_start = env.joint_qd_start[i]
            dof_count = env.joint_qd_start[i+1] - dof_start if i+1 < len(env.joint_qd_start) else 0
            if dof_count > 0:
                joint_name = env.joint_label[i].split('/')[-1]  # Get last part of label
                active_joint_names.append(joint_name)
                print(f"  Joint {i}: {joint_name}, DOF index: {dof_start}")
        
        # Build mimic mapping automatically based on URDF joint order
        # Trajectory order: thumb_1(0), thumb_2(1), index_1(2), middle_1(3), ring_1(4), little_1(5)
        print(f"\n=== Building Mimic Mapping ===")
        
        
        # Verify the mapping matches URDF DOF order
        for dof_idx, (traj_idx, mult) in enumerate(self.mimic_mapping):
            traj_names = ["thumb_1", "thumb_2", "index_1", "middle_1", "ring_1", "little_1"]
            print(f"  DOF {dof_idx} -> traj[{traj_idx}] ({traj_names[traj_idx]}) * {mult}")
        
        # Update self.mimic_mapping with the new mapping
        self.mimic_mapping = self.mimic_mapping

        # Load bottle mesh
        bottle_mesh = newton.Mesh.create_from_file("assets/usd/water_bottle/textured_mesh.obj",)
        bottle_scale = np.array([1,1,1], dtype=np.float32)
        if not np.allclose(bottle_scale, 1.0):
            # Hydroelastic mesh SDFs must be scale-baked for non-unit shape scale.
            bottle_mesh = bottle_mesh.copy(vertices=bottle_mesh.vertices * bottle_scale, recompute_inertia=True)
        # Find the mesh prim in the bottle USD
        # obj_idx=27
        # env.approximate_meshes(method="coacd", shape_indices=[obj_idx], raise_on_failure=True)
        bottle_mesh.build_sdf(
            max_resolution=sdf_max_resolution,
            narrow_band_range=sdf_narrow_band_range,
            # margin=0.003,
            )

        bottle_xform = wp.transform(self.object_position, self.object_rotation)
        bottle_body = env.add_body(xform=bottle_xform, label="bottle")
        env.add_shape_mesh(body=bottle_body, mesh=bottle_mesh, cfg=shape_cfg_meshes)
        

        # Verify hand collision shapes
        print(f"\n=== Shape Distribution ===")
        hand_shape_count = 0
        bottle_shape_count = 0
        for i in range(env.shape_count):
            body_idx = env.shape_body[i]
            if body_idx < hand_body_count:
                hand_shape_count += 1
            else:
                bottle_shape_count += 1

        def find_body(name):
            return next(i for i, lbl in enumerate(env.body_label) if lbl.endswith(f"/{name}"))

        

        for i in range(env.joint_dof_count -6):
            env.joint_target_ke[i] = 150
            env.joint_target_kd[i] = 5
            env.joint_target_mode[i] = int(JointTargetMode.POSITION)
            if env.joint_type[i] == newton.JointType.REVOLUTE:
                env.joint_armature[i] = 0.01
        
        # Set initial joint positions with mimic using the mapping
        for i in range(12):
            traj_idx = self.mimic_mapping[i][0]
            mult = self.mimic_mapping[i][1]
            angle = self.initial_joint_angles[traj_idx] * mult
            env.joint_q[i] = angle
            env.joint_target_pos[i] = angle

        builder = newton.ModelBuilder()
        builder.replicate(env, self.world_count)

        builder.default_shape_cfg.ke = 1.0e3
        builder.default_shape_cfg.kd = 1.0e2
        shape_cfg_ground = newton.ModelBuilder.ShapeConfig(
            kh=1e12,             # 地面可以更硬
            mu=0.01,              # 地面高摩擦！
            gap=0.004,
            mu_torsional=0.001,
            mu_rolling=0.0001,    # 地面滚动摩擦更大
            restitution=0.0,
        )
        self.model = builder.finalize()
        shape_mu = self.model.shape_material_mu.numpy()
        builder.add_ground_plane(cfg=shape_cfg_ground)

        self.model = builder.finalize()
        
        # Set material properties for all shapes (friction and collision)
        # Convert to numpy, modify, then convert back
        shape_mu = self.model.shape_material_mu.numpy()
        shape_ka = self.model.shape_material_ka.numpy()
        shape_solid = self.model.shape_is_solid.numpy()
        
        for i in range(len(shape_mu)-1):
            shape_mu[i] = 2  # Friction coefficient
            shape_ka[i] = 0.0  # Adhesion
            shape_solid[i] = True  # Enable solid collision
        
        self.model.shape_material_mu = wp.array(shape_mu, dtype=wp.float32, device=self.device)
        self.model.shape_material_ka = wp.array(shape_ka, dtype=wp.float32, device=self.device)
        self.model.shape_is_solid = wp.array(shape_solid, dtype=wp.bool, device=self.device)

        newton.eval_fk(self.model, self.model.joint_q, self.model.joint_qd, self.model)
        self.initial_world_positions = self.model.body_q.numpy()[:: env.body_count, :3].copy()

        # CRITICAL: Store joint/body counts for correct indexing in kernels
        # Calculate from finalized model, not from env
        self.joints_per_world = self.model.joint_count // self.world_count
        self.bodies_per_world = self.model.body_count // self.world_count
        self.hand_dof_count = env.joint_dof_count    # Only hand DOFs (12)
        
        print(f"\n=== World Structure ===")
        print(f"Joints per world: {self.joints_per_world} (calculated from finalized model)")
        print(f"Bodies per world: {self.bodies_per_world} (calculated from finalized model)")
        print(f"Hand DOFs: {self.hand_dof_count}")
        print(f"Total model joints: {self.model.joint_count}")
        print(f"Total model bodies: {self.model.body_count}")
        print(f"Total model DOFs: {self.model.joint_dof_count}")
        print(f"Verification: {self.joints_per_world} * {self.world_count} = {self.joints_per_world * self.world_count} (should equal {self.model.joint_count})")
        print(f"========================\n")

        self.world_time = wp.zeros(self.world_count, dtype=wp.float32)

        self.solver = newton.solvers.SolverMuJoCo(
            self.model,
            solver="newton",
            integrator="implicitfast",
            njmax=15000,  # FIXED: Increased from 200 to 5000 (max constraint Jacobian rows)
            nconmax=15000,  # FIXED: Increased from 300 to 1000 (max contacts per world)
            impratio=1000.0,  # FIXED: Increased from 20.0 to 1000.0 (match Panda) - CRITICAL for stability!
            cone="elliptic",
            iterations=15,  # FIXED: Reduced from 100 to 15 (match Panda)
            ls_iterations=100,  # FIXED: Increased from 50 to 100 (match Panda)
            use_mujoco_contacts=False,
        )

        self.state_0 = self.model.state()
        self.state_1 = self.model.state()
        self.control = self.model.control()
        
        # FIXED: Use CollisionPipeline instead of model.contacts()
        # This is critical for hydroelastic contact stability
        from newton.geometry import HydroelasticSDF
        sdf_hydroelastic_config = HydroelasticSDF.Config(
            output_contact_surface=hasattr(self.viewer, "renderer"),
            buffer_fraction=1.0,           # 内部缓冲区
            buffer_mult_contact=2,         # 面接触缓冲区
            contact_buffer_fraction=1.0,
        )
        self.collision_pipeline = newton.CollisionPipeline(
            self.model,
            reduce_contacts=True,
            broad_phase="explicit",
            sdf_hydroelastic_config=sdf_hydroelastic_config,
            rigid_contact_max=35000,
        )
        self.contacts = self.collision_pipeline.contacts()
        
        # CRITICAL FIX: Initialize state with forward kinematics
        # This ensures body transforms match joint positions
        newton.eval_fk(self.model, self.state_0.joint_q, self.state_0.joint_qd, self.state_0)
        newton.eval_fk(self.model, self.state_1.joint_q, self.state_1.joint_qd, self.state_1)

        self.viewer.set_model(self.model)
        
        # CRITICAL FIX: Set world offsets for visual separation (like Newton examples)
        # This separates worlds visually without affecting physics
        world_offset_spacing = (2.0, 2.0, 0.0)  # 2m spacing in X and Y
        self.viewer.set_world_offsets(world_offset_spacing)

        self.capture()
```

### System Information

_No response_

A dexterous hand imported via URDF fails to grasp and lift a bottle; the object slides and remains unliftable. The same bottle can be lifted using a Franka example, suggesting contact/friction or grasp modeling differences for the hand.

[BUG] dexterous robot hand failed to grasp and lift object in newton

A dexterous hand imported via URDF cannot grasp a bottle reliably; the bottle slides and cannot be lifted. The reporter notes the Franka example can lift the same object, implying a hand-specific contact/friction issue.

[BUG] dexterous robot hand failed to grasp object in newton

A user reports a Tegraparser_v2 problem. No further details are included in the issue body.

Tegraparser_v2 problem


### Describe the bug

In a CloudXR setup with Isaac Sim 5.1 + Isaac Lab 2.3 + `cloudxr-runtime-early-access:6.0.1-webrtc` + `cloudxr-js-early-access v6.0.0-beta`, the **render path works** (frames stream from Isaac Sim to the Meta Quest correctly), but **both inbound channels from the client to the OpenXR server are silently dropped**:

1. `cxrSession.sendServerMessage({ type: 'teleop_command', message: { command: 'start teleop' } })` returns successfully on the client (browser console logs `Start teleop command sent`), but the server-side `omni.kit.xr.system.openxr` plugin never dispatches a `teleop_command` carb event. `OpenXRDevice._on_teleop_command` is never invoked.

2. WebXR hand-tracking poses are never delivered to the OpenXR session. `XRCore.get_singleton().get_input_device("/user/hand/left")` and `…/hand/right` both return `None` continuously, even when the Quest has hand-tracking enabled, both hands are unobstructed, and `handTracking: 'required'` is set on the `@react-three/xr` store (so the WebXR session would fail outright if hand-tracking were denied).

Same hardware/software stack was confirmed working in the last week of April 2026 by the reporter. It stopped working without any user-side change to Isaac Lab, the CloudXR JS source, the runtime image, or the host (md5sums of `libopenxr_cloudxr.so` and `openxr_cloudxr.json` identical to working-period). The render direction has continued to work throughout.

Critically, the OpenXR plugin's own incoming-message validation error strings — which are present in the `libomni.ext-system.openxr.plugin.so` binary —

- `Message received from CloudXR cannot be parsed, skipping message`
- `Message received from CloudXR does not have a field called 'type'`
- `Message received from CloudXR has a 'message' field that cannot be parsed`
- `Message received from CloudXR has no 'message' or 'payload' field`
- `Message received from CloudXR with a 'payload' field that is not a dictionary`
- `Message received from CloudXR with a 'type' field that is not a string`

**never fire** in the kit log on Play clicks. That indicates the plugin's incoming-message handler is never reached at all — the messages aren't being delivered by `cloudxr-service` to the OpenXR client, not even in a malformed form.

### Steps to reproduce

```bash
# terminal 1 — start CloudXR runtime
conda activate nova_env
cd ~/IsaacLab
docker run -dit --rm --name cloudxr-runtime \
    --user $(id -u):$(id -g) \
    --gpus=all \
    -e "ACCEPT_EULA=Y" \
    --mount type=bind,src=$(pwd)/openxr,dst=/openxr \
    --network host \
    nvcr.io/nvidia/cloudxr-runtime-early-access:6.0.1-webrtc

export XDG_RUNTIME_DIR=$(pwd)/openxr/run
export XR_RUNTIME_JSON=$(pwd)/openxr/share/openxr/1/openxr_cloudxr.json
```

```bash
# terminal 2 — start CloudXR JS dev-server
conda activate nova_env
cd ~/cloudxr-js-early-access_v6.0.0-beta/isaac
npm install ../nvidia-cloudxr-6.0.0-beta.tgz
npm install
npm run dev-server
```

```bash
# terminal 1 — start Isaac Lab record_demos with hand tracking
PYTHONUNBUFFERED=1 ./isaaclab.sh -p scripts/tools/record_demos.py \
    --device cpu \
    --task Isaac-Surgical-Locomanipulation-G1-Abs-v0 \
    --teleop_device handtracking \
    --dataset_file /tmp/test.hdf5 \
    --num_demos 1 \
    --enable_pinocchio
```

Then in the Meta Quest browser:

1. Open the CloudXR client page served by the dev-server.
2. Tap **CONNECT**, enter immersive mode.
3. The Isaac Sim scene renders correctly in the headset (render direction confirmed working).
4. Tap the **Play** button on the floating 3D control panel.
5. Wave bare hands in view of the Quest cameras.

**Observed**:

- Quest browser console:
  ```
  Start Teleop pressed                      App.tsx:265
  Start teleop command sent                 App.tsx:302
  ```
  No errors. `sendServerMessage` returns without throwing.

- CloudXR runtime container logs (`docker logs cloudxr-runtime`):
  ```
  INFO [onStreamEventRaised] Video stream connected: packed
  INFO [onStreamEventRaised] Input stream connected
  INFO [onStreamEventRaised] Audio stream connected!
  INFO [processSystemInfo] Got system info from CloudXR client.
      protocol: 6.0.0
      client: 6.0.0
  INFO [processSystemInfo] Processed SystemInfo successfully.
  INFO [onClientEventRaised] Client message channel is ready (code: 226)
  ```
  Stable connection. No subsequent activity logged for inbound messages.

- Isaac Sim Kit log (`/home/labuser/miniconda3/envs/nova_env/lib/python3.11/site-packages/isaacsim/kit/logs/Kit/Isaac-Sim/5.1/kit_<timestamp>.log`):
  - Plugin starts cleanly: `[omni.kit.xr.system.openxr.plugin] [XR] Starting system: omni.kit.xr.system.openxr-107.3.109`.
  - None of the plugin's `"Message received from CloudXR …"` strings ever appear.

- Temporary debug print added to `OpenXRDevice._calculate_joint_poses` in `source/isaaclab/isaaclab/devices/openxr/openxr_device.py`:
  ```
  [xr] left:  device=None  -> hand-tracking not delivered by CloudXR
  [xr] right: device=None  -> hand-tracking not delivered by CloudXR
  ```
  Repeats every second, no exceptions, both hands return `None` for the entire session.

- Temporary debug print added to `_on_teleop_command`:
  ```python
  print(f"[openxr_device] _on_teleop_command fired; payload={event.payload!r} msg={msg!r} type={type(msg).__name__}")
  ```
  **Never fires**, neither on Play clicks nor on Stop/Reset.

Bug reproduces with both the stock `Isaac-Surgical-Locomanipulation-G1-Abs-v0` task and a custom downstream SERL task (`Isaac-SERL-G1-Abs-v0`) using `record_serl_demos.py`. Identical failure mode → not a downstream-task issue.

### Environment

```
CloudXR runtime:   nvcr.io/nvidia/cloudxr-runtime-early-access:6.0.1-webrtc
                   image id b63cd79ba804
                   digest sha256:b63cd79ba80417b957f7b6bae4de7e10c9399bbf3f1e6c8dfc7bad7c7cab5b79
CloudXR JS:        cloudxr-js-early-access v6.0.0-beta, nvidia-cloudxr-6.0.0-beta.tgz
Negotiated:        protocol 6.0.0, client 6.0.0, server 6.0.1
Isaac Sim:         5.1.0
Isaac Lab:         2.3.1
omni.kit.xr.core:  107.3.109
omni.kit.xr.system.openxr: 107.3.109
                   plugin: libomni.ext-system.openxr.plugin.so
OpenXR runtime:    libopenxr_cloudxr.so (md5 e920965738894284c644289325508c95)
Host OS:           Ubuntu 24.04.3 LTS (Noble)
Host kernel:       6.17.0-22-generic
NVIDIA driver:     580.126.09
GPU:               NVIDIA GeForce RTX 5090
Headset:           Meta Quest, hand-tracking enabled
Browser:           Quest Browser (Chrome)
```

### Already ruled out

A thorough investigation eliminated every plausible local cause:

- **Source code unchanged**: no commits to `source/isaaclab/isaaclab/devices/openxr/`, `apps/isaaclab.python.xr.openxr.kit`, or task env configs in 30+ days.
- **CloudXR JS source unchanged**: `isaac/src/*` is bit-identical to `react/src/*` reference (single trailing-blank-line whitespace diff in `CloudXRComponent.tsx`).
- **node_modules unchanged**, also confirmed irrelevant by a fresh `rm -rf node_modules package-lock.json && npm install ../nvidia-cloudxr-6.0.0-beta.tgz && npm install` (no behavior change).
- **Container image unchanged**: only one cloudxr-runtime-early-access tag pulled; the running container matches the on-disk image; no recent re-pull.
- **Host CloudXR binaries match container**: md5 of `libopenxr_cloudxr.so` and contents of `openxr_cloudxr.json` identical between host bind-mount, the container's `/opt/nvidia/cloudxr/`, and the working-period state.
- **OpenXR runtime selection correct**: `XR_RUNTIME_JSON` and `XDG_RUNTIME_DIR` in the running Python process point to the IsaacLab bind-mounted runtime. No competing OpenXR runtime registered in `/etc/openxr/1/`, `~/.config/openxr/1/`, or `/etc/xdg/openxr/1/`.
- **Hard reset of CloudXR state**: `docker rm -f cloudxr-runtime`, removal of `cloudxr.pid`/`runtime_started`/`ipc_cloudxr` lockfiles from both `~/openxr/run/` and `~/IsaacLab/openxr/run/`, kill of npm dev-server, restart from the documented sequence — no change.
- **Kernel/driver match working period**: still on `6.17.0-22-generic` with `nvidia-580-open-6.17.0-22-generic` (same kernel + module pair as during the working April session).
- **Quest firmware unchanged** (per reporter).
- **WebXR hand-tracking confirmed working in other apps** on the same Quest. Setting `handTracking: 'required'` on `@react-three/xr`'s `createXRStore` does not cause the session to fail to start — the Quest is granting hand-tracking; the data just isn't reaching CloudXR's OpenXR-side path.
- **No conflicting third-party OpenXR runtime / API layer**: a separately-installed `xr_teleoperate / televuer` package has no `.so` files, no pip install in `nova_env`, no API-layer manifests. Its only footprint is two unrelated `XR_TELEOP_*` env vars in `~/.bashrc`.
- **No port / process conflict**: only `cloudxr-service` listens on port 49100; no other VR teleop process active.
- **Not SERL-specific**: reproduces equally with the stock `record_demos.py` + `Isaac-Surgical-Locomanipulation-G1-Abs-v0`.

### Diagnostic interpretation

Combining the above:

- **Render direction works** → CloudXR frame-relay healthy.
- **`Client message channel is ready (code: 226)` logs**, then silence → message channel is plumbed but no message dispatch is reaching the OpenXR-client side of `cloudxr-service`.
- **None of the OpenXR plugin's `"Message received from CloudXR …"` validation strings ever fire**, even on garbled JSON — the plugin's inbound handler is never invoked at all.
- **`get_input_device("/user/hand/*")` returns `None` even with hand-tracking granted by the Quest** — CloudXR is not bridging WebXR hand-tracking input to OpenXR `XR_EXT_hand_tracking` on the server side (the runtime binary contains the extension symbols `xrCreateHandTrackerEXT`, `xrLocateHandJointsEXT`, etc., so support is present in the runtime — but it isn't being exercised in this session).

Conclusion: the inbound message-relay path and the inbound hand-pose path from `cloudxr-service` to the `omni.kit.xr.system.openxr` OpenXR client are both silently dropping data in this version pairing. Outbound (Isaac Sim → CloudXR JS) frame relay is unaffected. Failure is in the CloudXR runtime + JS bundle layer, below the Isaac Sim application.

### Asks

1. Is `cloudxr-runtime-early-access:6.0.1-webrtc` + `cloudxr-js-early-access v6.0.0-beta` a supported pairing? Protocol negotiation succeeds at `6.0.0` but the inbound channel is silent.
2. Is there a configuration flag (`NV_CXR_*` env var, runtime config JSON, kit setting under `xr.openxr.…`) required to enable bidirectional message and hand-pose relay in this image that the README in `cloudxr-js-early-access/isaac/` does not document?
3. If there is a newer cloudxr-runtime-early-access image, or a matching cloudxr-js build, that pairs cleanly with Isaac Sim 5.1 + `omni.kit.xr.core 107.3.109`, please point us at it.


In a CloudXR + OpenXR setup, frames stream correctly but inbound messages and hand-tracking poses are silently dropped between client and Isaac Sim’s OpenXR plugin. This blocks teleop commands and hand tracking for interactive workflows.

[Bug Report]  CloudXR JS / Runtime — inbound message channel and hand-tracking poses silently dropped between client and Isaac Sim's OpenXR plugin

### Bug Description

The CUDA tile backend is missing a same-shape assignment path from a shared-memory-backed tile into an existing register-backed tile. This complements #1439, which tracks the reverse register-to-shared tile reassignment path.

Kernels can require this storage migration when a register tile variable is reassigned from a shared tile value. One example is a dynamic loop where codegen materializes the variable redefinition with `wp::assign(dest, src)`:

```python
@wp.kernel
def register_from_shared_kernel(src: wp.array1d(dtype=float), dst: wp.array1d(dtype=float), iters: int):
    t = wp.tile_load(src, shape=8, offset=0, storage="register")
    s = wp.tile_load(src, shape=8, offset=0, storage="shared")

    for _ in range(iters):
        t = s

    wp.tile_store(dst, t, offset=0)
```

Expected behavior:

- Forward assignment copies the shared tile values into the register tile destination.
- Backward assignment accumulates the register destination adjoint into the shared source adjoint.
- The overwritten register destination adjoint is cleared after propagation.

Actual behavior:

The native tile assignment overloads do not cover `tile_register_t <- tile_shared_t`, so generated code using `wp::assign(register_tile, shared_tile)` and `wp::adj_assign(register_tile, shared_tile, ...)` does not have a matching overload.

### System Information

- Warp version: `main` / development branch
- Backend: CUDA tile backend


Shared-to-register tile reassignment fails in CUDA tile kernels

### Bug Description

The CUDA tile backend is missing a same-shape assignment path from a register-backed tile into an existing shared-memory-backed tile. Kernels that keep tile operands live across `wp.tile_matmul()` and then assign the next register-loaded operands back to those variables require this storage migration.

One example is a pipelined tile matmul kernel:

```python
@wp.kernel
def matmul_pipelined(A: wp.array2d(dtype=float), B: wp.array2d(dtype=float), C: wp.array2d(dtype=float)):
    i, j = wp.tid()

    acc = wp.tile_zeros(shape=(8, 4), dtype=wp.float32)

    a = wp.tile_load(A, shape=(8, 8), offset=(i * 8, 0), storage="register")
    b = wp.tile_load(B, shape=(8, 4), offset=(0, j * 4), storage="register")

    count = int(A.shape[1] / 8)
    for k in range(1, count):
        a_next = wp.tile_load(A, shape=(8, 8), offset=(i * 8, k * 8), storage="register")
        b_next = wp.tile_load(B, shape=(8, 4), offset=(k * 8, j * 4), storage="register")

        wp.tile_matmul(a, b, acc)

        a = a_next
        b = b_next

    wp.tile_matmul(a, b, acc)
    wp.tile_store(C, acc, offset=(i * 8, j * 4))
```

Expected behavior:

- Forward assignment copies the register tile values into the shared tile destination.
- Backward assignment accumulates the shared destination adjoint into the register source adjoint.
- The overwritten shared destination adjoint is cleared after propagation.

Actual behavior:

The native tile assignment overloads do not cover `tile_shared_t <- tile_register_t`, so this reassignment pattern is not handled correctly in forward execution or adjoint propagation.

### System Information

- Warp version: `main` / development branch
- Backend: CUDA tile backend


Register-to-shared tile reassignment fails in CUDA tile kernels

## Bug Description

When constructing a mesh with `bvh_constructor="cubql"` on a CUDA device that reports `wp.is_mempool_supported(device) == False`, the call fails inside the native cuBQL builder before returning to Python. On Windows, the failure surfaces as `OSError [WinError -529697949]` (`0xe06d7363`) with no actionable message, and the CUDA context is left in an error state, causing subsequent unrelated kernel launches on the same device to fail with `Warp CUDA error 101: invalid device ordinal` or `error 901` until the process is restarted.

The same hardware on Linux reports `is_mempool_supported = True`, so this only reproduces on Windows + TCC-mode GPUs, or on any future device that reports `is_mempool_supported = False`.

## Reproduction

On a CUDA device where `wp.is_mempool_supported(device) == False`:

```python
import numpy as np
import warp as wp

device = "cuda:0"
assert not wp.is_mempool_supported(device), "reproducer requires a no-mempool device"

points = wp.array(
    np.array([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]),
    dtype=wp.vec3, device=device,
)
indices = wp.array([0, 1, 2], dtype=int, device=device)

mesh = wp.Mesh(points=points, indices=indices, bvh_constructor="cubql")
# OSError: [WinError -529697949] Windows Error 0xe06d7363
```

## Where this surfaces in CI

The following tests fail on the GitHub Actions runner `windows-amd64-gpu-rtxpro6000-latest-1`:

- `warp.tests.geometry.test_mesh`: `test_mesh_query_ray`, `test_mesh_refit`
- `warp.tests.geometry.test_mesh_query_ray`: `test_mesh_query_ray`, `test_mesh_query_ray_count_intersections`, `test_mesh_query_ray_edge`

PR #1425 currently filters `"cubql"` out of `bvh_constructor` lists for these tests on `device.is_mempool_supported = False` so CI stays green. That keeps the CI signal but does not address the user-visible API gap: callers on the same hardware still hit the failure when they pass `bvh_constructor="cubql"` directly.

## System Information

- Runner: GitHub Actions `windows-amd64-gpu-rtxpro6000-latest-1`
- GPU: NVIDIA RTX PRO 6000 Blackwell Server Edition (sm_120, TCC mode, 95 GiB, mempool not supported)
- Driver: 582.16, CUDA 13.0
- Warp branch: `ershi/expand-github-gpu-tests` (PR #1425), built against cu13 / libmathdx 0.3.2

wp.Mesh(bvh_constructor="cubql") fails on CUDA devices without memory pool support

# Title

`tile_matmul()` fails to compile with bfloat16 accumulator on CUDA 13 (cuBLASDx `static_assert` in libmathdx 0.3.2)

# Bug Description

Calling `wp.tile_matmul(a, b, sum)` with a bfloat16 accumulator (the `sum` / `out` tile) fails
to compile with libmathdx 0.3.2 / cuBLASDx 0.6.0 (bundled with cu13). NVRTC reports a
`static_assert` from `cublasdx/detail/blas_description.hpp(456)`:

```
error: static assertion failed with "Accumulator precision must be one of the following:
    int32_t, uint32_t, int64_t, uint64_t, __half, float, double, please consult docs
    for more information"
```

When backward is enabled, the same failure occurs even if `out` is `float32`, because the
backward LTOs `adjA += adjC * Bᵀ` and `adjB += Aᵀ * adjC` use `a.dtype` and `b.dtype` as
their accumulators. So bf16 `a` or `b` inputs are also incompatible with autodiff.

The same code compiles on cu12 (libmathdx 0.3.1) where the older cuBLASDx version does not
fire this `static_assert`. That path silently produces degraded results (bf16 accumulation
diverges quickly for non-trivial K, since bf16 has only 8 mantissa bits).

# Reproduction

1. Build Warp against the cu13 toolchain (libmathdx 0.3.2, cuBLASDx 0.6.0).
2. Run `LIBMATHDX_LOG_LEVEL=5 uv run warp/tests/tile/test_tile_matmul.py`.
3. `test_tile_gemm_bf16_cuda_0` fails at module load with the static_assert above.

The failing config in the log is the LTO `dot_8_4_8_86_64_1_1_1_2_2_2_0` —
`Precision<__nv_bfloat16, __nv_bfloat16, __nv_bfloat16>`.

# Why this wasn't caught in CI

The Warp cu13 GitLab build job is build-only at the moment — see the comment in
`.gitlab/ci/cuda-13-build.yml`:

```
# CUDA 13 Toolkit (release mode). No testing until GitLab runners have CUDA 13
```

`test_tile_gemm_bf16` was added with `wp.bfloat16` scalar support in GH-1332 and went green
on cu12 (libmathdx 0.3.1), where cuBLASDx silently accepted the bf16 accumulator and
returned numerically poor results. Once the cu13 toolchain enforces the constraint as a
`static_assert`, the test fails to compile.

# Root cause

cuBLASDx requires the accumulator precision (the C type in `cublasdx::Precision<A, B, C>`)
to be one of `__half`, `float`, `double`, or an integer type. `bf16` is permitted as an A/B
input element type but never as an accumulator. Every bf16 GEMM test in libmathdx
(`test/integration/cublasdx_codegen_test.cpp` and friends) uses the combination
`{BF16, BF16, F32}` exclusively — there is no `{BF16, BF16, BF16}` combination anywhere.

The `tile_matmul` builtin in Warp passes `out.dtype` straight through to cuBLASDx as the
accumulator (and `a.dtype` / `b.dtype` for the backward adjoint LTOs), without enforcing
this restriction at the Python validation layer.

# Follow-up

Supporting bf16 inputs together with autodiff would require Warp to internally promote the
backward accumulators to fp32 and cast back to bf16 when storing the input adjoints. That
needs changes to `tile_matmul_acc` (to allow a separate accumulator dtype distinct from
the output tile dtype) and the LTO dispatch, and is out of scope for this issue.

# System Information

- Warp 1.14.0.dev0
- CUDA Toolkit 13.0, Driver 13.1
- libmathdx 0.3.2 (cuBLASDx 0.6.0, MathDx 26.00.3)
- NVIDIA GeForce RTX 3090 (sm_86), Linux x86_64


Search — dx