From 7b63a6a8beb36facb4b06c739a223bf65fa5de57 Mon Sep 17 00:00:00 2001
From: Octi Zhang <zhengyuz@nvidia.com>
Date: Wed, 5 Nov 2025 14:21:09 -0800
Subject: [PATCH 01/15] update newer cloner feature

---
 source/isaaclab/config/extension.toml         |   2 +-
 source/isaaclab/docs/CHANGELOG.rst            |  33 ++
 source/isaaclab/isaaclab/assets/asset_base.py |   8 +-
 .../rigid_object_collection.py                |  13 +-
 source/isaaclab/isaaclab/scene/cloner.py      | 439 ++++++++++++++++++
 .../isaaclab/scene/interactive_scene.py       | 208 ++++-----
 .../isaaclab/scene/interactive_scene_cfg.py   |   8 +
 .../isaaclab/sensors/camera/camera.py         |  11 -
 .../isaaclab/sensors/ray_caster/ray_caster.py |  11 -
 .../sim/spawners/wrappers/wrappers.py         |  67 +--
 .../sim/spawners/wrappers/wrappers_cfg.py     |  10 +
 source/isaaclab/isaaclab/sim/utils/utils.py   |  33 +-
 source/isaaclab/test/sim/test_cloner.py       | 199 ++++++++
 .../isaaclab/test/sim/test_spawn_wrappers.py  |  39 +-
 14 files changed, 797 insertions(+), 284 deletions(-)
 create mode 100644 source/isaaclab/isaaclab/scene/cloner.py
 create mode 100644 source/isaaclab/test/sim/test_cloner.py

diff --git a/source/isaaclab/config/extension.toml b/source/isaaclab/config/extension.toml
index 00f71b0468f..623798e931e 100644
--- a/source/isaaclab/config/extension.toml
+++ b/source/isaaclab/config/extension.toml
@@ -1,7 +1,7 @@
 [package]
 
 # Note: Semantic Versioning is used: https://semver.org/
-version = "0.48.4"
+version = "0.49.0"
 
 # Description
 title = "Isaac Lab framework for Robot Learning"
diff --git a/source/isaaclab/docs/CHANGELOG.rst b/source/isaaclab/docs/CHANGELOG.rst
index 6cc64b7cb8e..a1b20e9f802 100644
--- a/source/isaaclab/docs/CHANGELOG.rst
+++ b/source/isaaclab/docs/CHANGELOG.rst
@@ -1,6 +1,39 @@
 Changelog
 ---------
 
+
+0.49.0 (2025-11-14)
+~~~~~~~~~~~~~~~~~~~
+
+* Removed hard dependency on the Isaac Sim Cloner for scene replication. Replication now uses internal utilities
+  :func:`~isaaclab.scene.cloner.usd_replicate` and :func:`~isaaclab.scene.cloner.physx_replicate`, reducing coupling
+  to Isaac Sim. Public APIs in :class:`~isaaclab.scene.interactive_scene.InteractiveScene` remain unchanged; code
+  directly importing the external Cloner should migrate to these utilities.
+
+
+Added
+^^^^^
+
+* Added optional random prototype selection during environment cloning in
+  :class:`~isaaclab.scene.interactive_scene.InteractiveScene` via
+  :attr:`~isaaclab.scene.interactive_scene_cfg.InteractiveSceneCfg.random_heterogenous_cloning`.
+  Defaults to ``True``; round-robin (modulo) mapping remains available by setting it to ``False``.
+
+* Added flexible per-object cloning path in
+  :class:`~isaaclab.scene.interactive_scene.InteractiveScene`: when environments are heterogeneous
+  (different prototypes across envs), replication switches to per-object instead of whole-env cloning.
+  This reduces PhysX cloning time in heterogeneous scenes.
+
+
+Deprecated
+^^^^^^^^^^
+
+* Deprecated :attr:`~isaaclab.sim.spawners.wrappers.MultiAssetSpawnerCfg.random_choice` and
+  :attr:`~isaaclab.sim.spawners.wrappers.MultiUsdFileCfg.random_choice`. Use
+  :attr:`~isaaclab.scene.interactive_scene_cfg.InteractiveSceneCfg.random_heterogenous_cloning` to control whether
+  assets are selected randomly (``True``) or via round-robin (``False``) across environments.
+
+
 0.48.4 (2025-11-14)
 ~~~~~~~~~~~~~~~~~~~
 
diff --git a/source/isaaclab/isaaclab/assets/asset_base.py b/source/isaaclab/isaaclab/assets/asset_base.py
index a618ddc0e13..e5f7150b713 100644
--- a/source/isaaclab/isaaclab/assets/asset_base.py
+++ b/source/isaaclab/isaaclab/assets/asset_base.py
@@ -73,14 +73,8 @@ def __init__(self, cfg: AssetBaseCfg):
         # get stage handle
         self.stage = get_current_stage()
 
-        # check if base asset path is valid
-        # note: currently the spawner does not work if there is a regex pattern in the leaf
-        #   For example, if the prim path is "/World/Robot_[1,2]" since the spawner will not
-        #   know which prim to spawn. This is a limitation of the spawner and not the asset.
-        asset_path = self.cfg.prim_path.split("/")[-1]
-        asset_path_is_regex = re.match(r"^[a-zA-Z0-9/_]+$", asset_path) is None
         # spawn the asset
-        if self.cfg.spawn is not None and not asset_path_is_regex:
+        if self.cfg.spawn is not None:
             self.cfg.spawn.func(
                 self.cfg.prim_path,
                 self.cfg.spawn,
diff --git a/source/isaaclab/isaaclab/assets/rigid_object_collection/rigid_object_collection.py b/source/isaaclab/isaaclab/assets/rigid_object_collection/rigid_object_collection.py
index ff223d7c5bc..33d056f5d6f 100644
--- a/source/isaaclab/isaaclab/assets/rigid_object_collection/rigid_object_collection.py
+++ b/source/isaaclab/isaaclab/assets/rigid_object_collection/rigid_object_collection.py
@@ -67,17 +67,10 @@ def __init__(self, cfg: RigidObjectCollectionCfg):
         self.cfg = cfg.copy()
         # flag for whether the asset is initialized
         self._is_initialized = False
-        self._prim_paths = []
         # spawn the rigid objects
         for rigid_object_cfg in self.cfg.rigid_objects.values():
-            # check if the rigid object path is valid
-            # note: currently the spawner does not work if there is a regex pattern in the leaf
-            #   For example, if the prim path is "/World/Object_[1,2]" since the spawner will not
-            #   know which prim to spawn. This is a limitation of the spawner and not the asset.
-            asset_path = rigid_object_cfg.prim_path.split("/")[-1]
-            asset_path_is_regex = re.match(r"^[a-zA-Z0-9/_]+$", asset_path) is None
             # spawn the asset
-            if rigid_object_cfg.spawn is not None and not asset_path_is_regex:
+            if rigid_object_cfg.spawn is not None:
                 rigid_object_cfg.spawn.func(
                     rigid_object_cfg.prim_path,
                     rigid_object_cfg.spawn,
@@ -88,7 +81,7 @@ def __init__(self, cfg: RigidObjectCollectionCfg):
             matching_prims = sim_utils.find_matching_prims(rigid_object_cfg.prim_path)
             if len(matching_prims) == 0:
                 raise RuntimeError(f"Could not find prim with path {rigid_object_cfg.prim_path}.")
-            self._prim_paths.append(rigid_object_cfg.prim_path)
+
         # stores object names
         self._object_names_list = []
 
@@ -747,7 +740,7 @@ def _on_prim_deletion(self, prim_path: str) -> None:
         if prim_path == "/":
             self._clear_callbacks()
             return
-        for prim_path_expr in self._prim_paths:
+        for prim_path_expr in [obj.prim_path for obj in self.cfg.rigid_objects.values()]:
             result = re.match(
                 pattern="^" + "/".join(prim_path_expr.split("/")[: prim_path.count("/") + 1]) + "$", string=prim_path
             )
diff --git a/source/isaaclab/isaaclab/scene/cloner.py b/source/isaaclab/isaaclab/scene/cloner.py
new file mode 100644
index 00000000000..2e56b169432
--- /dev/null
+++ b/source/isaaclab/isaaclab/scene/cloner.py
@@ -0,0 +1,439 @@
+# Copyright (c) 2022-2025, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+from __future__ import annotations
+
+import math
+import torch
+
+from omni.physx import get_physx_replicator_interface
+from pxr import Gf, PhysxSchema, Sdf, Usd, UsdGeom, UsdUtils, Vt
+
+import isaaclab.sim as sim_utils
+from isaaclab.utils import configclass
+
+
+@configclass
+class TemplateCloneCfg:
+    """Configuration for template-based cloning.
+
+    This configuration is consumed by :func:`~isaaclab.scene.cloner.clone_from_template` to
+    replicate one or more "prototype" prims authored under a template root into multiple
+    per-environment destinations. It supports both USD-spec replication and PhysX replication
+    and allows choosing between random or round-robin prototype assignment across environments.
+
+    The cloning flow is:
+
+    1. Discover prototypes under :attr:`template_root` whose base name starts with
+        :attr:`template_prototype_identifier` (for example, ``proto_asset_0``, ``proto_asset_1``).
+    2. Build a per-prototype mapping to environments according to
+        :attr:`random_heterogenous_cloning` (random) or modulo assignment (deterministic).
+    3. Stamp the selected prototypes to destinations derived from :attr:`clone_regex`.
+    4. Optionally perform PhysX replication for the same mapping.
+
+    Example
+    -------
+
+    .. code-block:: python
+
+        from isaaclab.scene.cloner import TemplateCloneCfg, clone_from_template
+        from isaacsim.core.utils.stage import get_current_stage
+
+        stage = get_current_stage()
+        cfg = TemplateCloneCfg(
+            num_clones=128,
+            template_root="/World/template",
+            template_prototype_identifier="proto_asset",
+            clone_regex="/World/envs/env_.*",
+            clone_usd=True,
+            clone_physx=True,
+            random_heterogenous_cloning=False,  # use round-robin mapping
+            device="cpu",
+        )
+
+        clone_from_template(stage, num_clones=cfg.num_clones, template_clone_cfg=cfg)
+    """
+
+    template_root: str = "/World/template"
+    """Root path under which template prototypes are authored."""
+
+    template_prototype_identifier: str = "proto_asset"
+    """Name prefix used to identify prototype prims under :attr:`template_root`."""
+
+    clone_regex: str = "/World/envs/env_.*"
+    """Destination template for per-environment paths.
+
+    The substring ``".*"`` is replaced with ``"{}"`` internally and formatted with the
+    environment index (e.g., ``/World/envs/env_0``, ``/World/envs/env_1``).
+    """
+
+    clone_usd: bool = True
+    """Enable USD-spec replication to author cloned prims and optional transforms."""
+
+    clone_physx: bool = True
+    """Enable PhysX replication for the same mapping to speed up physics setup."""
+
+    random_heterogenous_cloning: bool = True
+    """Randomly assign prototypes to environments. Default is True.
+
+    When enabled, each environment selects a prototype at random from the available prototypes
+    under a given template root. When disabled, environments use a round‑robin assignment based
+    on ``env_index % num_prototypes`` for deterministic distribution.
+    """
+
+    device: str = "cpu"
+    """Torch device on which mapping buffers are allocated."""
+
+    clone_in_fabric: bool = False
+    """Enable/disable cloning in fabric for PhysX replication. Default is False."""
+
+
+def clone_from_template(stage: Usd.Stage, num_clones: int, template_clone_cfg: TemplateCloneCfg) -> None:
+    """Clone assets from a template root into per-environment destinations.
+
+    This utility discovers prototype prims under ``cfg.template_root`` whose names start with
+    ``cfg.template_prototype_identifier``, builds a per-prototype mapping across
+    ``num_clones`` environments (random or modulo), and then performs USD and/or PhysX replication
+    according to the flags in ``cfg``.
+
+    Args:
+        stage: The USD stage to author into.
+        num_clones: Number of environments to clone to (typically equals ``cfg.num_clones``).
+        template_clone_cfg: Configuration describing template location, destination pattern,
+            and replication/mapping behavior.
+    """
+    cfg = template_clone_cfg
+    world_indices = torch.arange(num_clones, device=cfg.device)
+    clone_plan = {"src": [], "dest": [], "mapping": torch.empty((0,), dtype=torch.bool).to(cfg.device)}
+    clone_path_fmt = cfg.clone_regex.replace(".*", "{}")
+    prototype_id = cfg.template_prototype_identifier
+    prototypes = sim_utils.get_all_matching_child_prims(
+        cfg.template_root,
+        predicate=lambda prim: str(prim.GetPath()).split("/")[-1].startswith(prototype_id),
+    )
+    prototype_root_set = {"/".join(str(prototype.GetPath()).split("/")[:-1]) for prototype in prototypes}
+    for prototype_root in prototype_root_set:
+        protos = sim_utils.find_matching_prim_paths(f"{prototype_root}/.*")
+        protos = [proto for proto in protos if proto.split("/")[-1].startswith(prototype_id)]
+        m = torch.zeros((len(protos), num_clones), dtype=torch.bool, device=cfg.device)
+        # Optionally select prototypes randomly per environment; else round-robin by modulo
+        if cfg.random_heterogenous_cloning:
+            rand_idx = torch.randint(len(protos), (num_clones,), device=cfg.device)
+            m[rand_idx, world_indices] = True
+        else:
+            m[world_indices % len(protos), world_indices] = True
+
+        clone_plan["src"].extend(protos)
+        clone_plan["dest"].extend([prototype_root.replace(cfg.template_root, clone_path_fmt)] * len(protos))
+        clone_plan["mapping"] = torch.cat((clone_plan["mapping"].reshape(-1, m.size(1)), m), dim=0)
+
+    proto_idx = clone_plan["mapping"].to(torch.int32).argmax(dim=1)
+    proto_mask = torch.zeros_like(clone_plan["mapping"])
+    proto_mask.scatter_(1, proto_idx.view(-1, 1).to(torch.long), clone_plan["mapping"].any(dim=1, keepdim=True))
+    usd_replicate(stage, clone_plan["src"], clone_plan["dest"], world_indices, proto_mask)
+    stage.GetPrimAtPath(cfg.template_root).SetActive(False)
+
+    # If all prototypes map to env_0, clone whole env_0 to all envs; else clone per-object
+    if torch.all(proto_idx == 0):
+        replicate_args = [clone_path_fmt.format(0)], [clone_path_fmt], world_indices, clone_plan["mapping"]
+        # parse env_origins directly from clone_path
+        get_translate = (
+            lambda prim_path: stage.GetPrimAtPath(prim_path).GetAttribute("xformOp:translate").Get()
+        )  # noqa: E731
+        if cfg.clone_usd:
+            positions = torch.tensor([get_translate(clone_path_fmt.format(i)) for i in world_indices])
+            usd_replicate(stage, *replicate_args, positions=positions)
+    else:
+        src = [tpl.format(int(idx)) for tpl, idx in zip(clone_plan["dest"], proto_idx.tolist())]
+        replicate_args = src, clone_plan["dest"], world_indices, clone_plan["mapping"]
+        if cfg.clone_usd:
+            usd_replicate(stage, *replicate_args)
+
+    if cfg.clone_physx:
+        physx_replicate(stage, *replicate_args, use_fabric=cfg.clone_in_fabric)
+
+
+def usd_replicate(
+    stage: Usd.Stage,
+    sources: list[str],
+    destinations: list[str],
+    env_ids: torch.Tensor,
+    mask: torch.Tensor | None = None,
+    positions: torch.Tensor | None = None,
+    quaternions: torch.Tensor | None = None,
+) -> None:
+    """Replicate USD prims to per-environment destinations.
+
+    Copies each source prim spec to destination templates for selected environments
+    (``mask``). Optionally authors translate/orient from position/quaternion buffers.
+    Replication runs in path-depth order (parents before children) for robust composition.
+
+    Args:
+        stage: USD stage.
+        sources: Source prim paths.
+        destinations: Destination formattable templates with ``"{}"`` for env index.
+        env_ids: Environment indices.
+        mask: Optional per-source or shared mask. ``None`` selects all.
+        positions: Optional positions (``[E, 3]``) -> ``xformOp:translate``.
+        quaternions: Optional orientations (``[E, 4]``) in ``wxyz`` -> ``xformOp:orient``.
+
+    Returns:
+        None
+    """
+    rl = stage.GetRootLayer()
+
+    # Group replication by destination path depth so ancestors land before deeper paths.
+    # This avoids composition issues for nested or interdependent specs.
+    def dp_depth(template: str) -> int:
+        dp = template.format(0)
+        return Sdf.Path(dp).pathElementCount
+
+    order = sorted(range(len(sources)), key=lambda i: dp_depth(destinations[i]))
+
+    # Process in layers of equal depth, committing at each depth to stabilize composition
+    depth_to_indices: dict[int, list[int]] = {}
+    for i in order:
+        d = dp_depth(destinations[i])
+        depth_to_indices.setdefault(d, []).append(i)
+
+    for depth in sorted(depth_to_indices.keys()):
+        with Sdf.ChangeBlock():
+            for i in depth_to_indices[depth]:
+                src = sources[i]
+                tmpl = destinations[i]
+                # Select target environments for this source (supports None, [E], or [S, E])
+                target_envs = env_ids if mask is None else env_ids[mask[i]]
+                for wid in target_envs.tolist():
+                    dp = tmpl.format(wid)
+                    Sdf.CreatePrimInLayer(rl, dp)
+                    Sdf.CopySpec(rl, Sdf.Path(src), rl, Sdf.Path(dp))
+
+                    if positions is not None or quaternions is not None:
+                        ps = rl.GetPrimAtPath(dp)
+                        op_names = []
+                        if positions is not None:
+                            p = positions[wid]
+                            t_attr = ps.GetAttributeAtPath(dp + ".xformOp:translate")
+                            if t_attr is None:
+                                t_attr = Sdf.AttributeSpec(ps, "xformOp:translate", Sdf.ValueTypeNames.Double3)
+                            t_attr.default = Gf.Vec3d(float(p[0]), float(p[1]), float(p[2]))
+                            op_names.append("xformOp:translate")
+                        if quaternions is not None:
+                            q = quaternions[wid]
+                            o_attr = ps.GetAttributeAtPath(dp + ".xformOp:orient")
+                            if o_attr is None:
+                                o_attr = Sdf.AttributeSpec(ps, "xformOp:orient", Sdf.ValueTypeNames.Quatd)
+                            o_attr.default = Gf.Quatd(float(q[0]), Gf.Vec3d(float(q[1]), float(q[2]), float(q[3])))
+                            op_names.append("xformOp:orient")
+                        # Only author xformOpOrder for the ops we actually authored
+                        if op_names:
+                            op_order = ps.GetAttributeAtPath(dp + ".xformOpOrder") or Sdf.AttributeSpec(
+                                ps, UsdGeom.Tokens.xformOpOrder, Sdf.ValueTypeNames.TokenArray
+                            )
+                            op_order.default = Vt.TokenArray(op_names)
+
+
+def physx_replicate(
+    stage: Usd.Stage,
+    sources: list[str],  # e.g. ["/World/Template/A", "/World/Template/B"]
+    destinations: list[str],  # e.g. ["/World/envs/env_{}/Robot", "/World/envs/env_{}/Object"]
+    env_ids: torch.Tensor,  # env_ids
+    mapping: torch.Tensor,  # (num_sources, num_envs) bool; True -> place sources[i] into world=j
+    use_fabric: bool = False,
+) -> None:
+    """Replicate prims via PhysX replicator with per-row mapping.
+
+    Builds per-source destination lists from ``mapping`` and calls PhysX ``replicate``.
+    Rows covering all environments use ``useEnvIds=True``; partial rows use ``False``.
+    The replicator is registered for the call and then unregistered.
+
+    Args:
+        stage: USD stage.
+        sources: Source prim paths (``S``).
+        destinations: Destination templates (``S``) with ``"{}"`` for env index.
+        env_ids: Environment indices (``[E]``).
+        mapping: Bool/int mask (``[S, E]``) selecting envs per source.
+        use_fabric: Use Fabric for replication.
+
+    Returns:
+        None
+    """
+
+    stage_id = UsdUtils.StageCache.Get().Insert(stage).ToLongInt()
+    current_worlds: list[int] = []
+    current_template: str = ""
+    num_envs = mapping.size(1)
+
+    def attach_fn(_stage_id: int):
+        return ["/World/envs", *sources]
+
+    def rename_fn(_replicate_path: str, i: int):
+        return current_template.format(current_worlds[i])
+
+    def attach_end_fn(_stage_id: int):
+        nonlocal current_template
+        rep = get_physx_replicator_interface()
+        for i, src in enumerate(sources):
+            current_worlds[:] = env_ids[mapping[i]].tolist()
+            current_template = destinations[i]
+            rep.replicate(
+                _stage_id,
+                src,
+                len(current_worlds),
+                useEnvIds=len(current_worlds) == num_envs,
+                useFabricForReplication=use_fabric,
+            )
+        # unregister only AFTER all replicate() calls completed
+        rep.unregister_replicator(_stage_id)
+
+    get_physx_replicator_interface().register_replicator(stage_id, attach_fn, attach_end_fn, rename_fn)
+
+
+def filter_collisions(
+    stage: Usd.Stage,
+    physicsscene_path: str,
+    collision_root_path: str,
+    prim_paths: list[str],
+    global_paths: list[str] = [],
+) -> None:
+    """Create inverted collision groups for clones.
+
+    Creates one PhysicsCollisionGroup per prim under ``collision_root_path``, enabling
+    inverted filtering so clones don't collide across groups. Optionally adds a global
+    group that collides with all.
+
+    Args:
+        stage: USD stage.
+        physicsscene_path: Path to PhysicsScene prim.
+        collision_root_path: Root scope for collision groups.
+        prim_paths: Per-clone prim paths.
+        global_paths: Optional global-collider paths.
+
+    Returns:
+        None
+    """
+
+    physx_scene = PhysxSchema.PhysxSceneAPI(stage.GetPrimAtPath(physicsscene_path))
+
+    # We invert the collision group filters for more efficient collision filtering across environments
+    physx_scene.CreateInvertCollisionGroupFilterAttr().Set(True)
+
+    # Make sure we create the collision_scope in the RootLayer since the edit target may be a live layer in the case of Live Sync.
+    with Usd.EditContext(stage, Usd.EditTarget(stage.GetRootLayer())):
+        UsdGeom.Scope.Define(stage, collision_root_path)
+
+    with Sdf.ChangeBlock():
+        if len(global_paths) > 0:
+            global_collision_group_path = collision_root_path + "/global_group"
+            # add collision group prim
+            global_collision_group = Sdf.PrimSpec(
+                stage.GetRootLayer().GetPrimAtPath(collision_root_path),
+                "global_group",
+                Sdf.SpecifierDef,
+                "PhysicsCollisionGroup",
+            )
+            # prepend collision API schema
+            global_collision_group.SetInfo(Usd.Tokens.apiSchemas, Sdf.TokenListOp.Create({"CollectionAPI:colliders"}))
+
+            # expansion rule
+            expansion_rule = Sdf.AttributeSpec(
+                global_collision_group,
+                "collection:colliders:expansionRule",
+                Sdf.ValueTypeNames.Token,
+                Sdf.VariabilityUniform,
+            )
+            expansion_rule.default = "expandPrims"
+
+            # includes rel
+            global_includes_rel = Sdf.RelationshipSpec(global_collision_group, "collection:colliders:includes", False)
+            for global_path in global_paths:
+                global_includes_rel.targetPathList.Append(global_path)
+
+            # filteredGroups rel
+            global_filtered_groups = Sdf.RelationshipSpec(global_collision_group, "physics:filteredGroups", False)
+            # We are using inverted collision group filtering, which means objects by default don't collide across
+            # groups. We need to add this group as a filtered group, so that objects within this group collide with
+            # each other.
+            global_filtered_groups.targetPathList.Append(global_collision_group_path)
+
+        # set collision groups and filters
+        for i, prim_path in enumerate(prim_paths):
+            collision_group_path = collision_root_path + f"/group{i}"
+            # add collision group prim
+            collision_group = Sdf.PrimSpec(
+                stage.GetRootLayer().GetPrimAtPath(collision_root_path),
+                f"group{i}",
+                Sdf.SpecifierDef,
+                "PhysicsCollisionGroup",
+            )
+            # prepend collision API schema
+            collision_group.SetInfo(Usd.Tokens.apiSchemas, Sdf.TokenListOp.Create({"CollectionAPI:colliders"}))
+
+            # expansion rule
+            expansion_rule = Sdf.AttributeSpec(
+                collision_group,
+                "collection:colliders:expansionRule",
+                Sdf.ValueTypeNames.Token,
+                Sdf.VariabilityUniform,
+            )
+            expansion_rule.default = "expandPrims"
+
+            # includes rel
+            includes_rel = Sdf.RelationshipSpec(collision_group, "collection:colliders:includes", False)
+            includes_rel.targetPathList.Append(prim_path)
+
+            # filteredGroups rel
+            filtered_groups = Sdf.RelationshipSpec(collision_group, "physics:filteredGroups", False)
+            # We are using inverted collision group filtering, which means objects by default don't collide across
+            # groups. We need to add this group as a filtered group, so that objects within this group collide with
+            # each other.
+            filtered_groups.targetPathList.Append(collision_group_path)
+            if len(global_paths) > 0:
+                filtered_groups.targetPathList.Append(global_collision_group_path)
+                global_filtered_groups.targetPathList.Append(collision_group_path)
+
+
+def grid_transforms(N: int, spacing: float = 1.0, up_axis: str = "z", device="cpu"):
+    """Create a centered grid of transforms for ``N`` instances.
+
+    Computes ``(x, y)`` coordinates in a roughly square grid centered at the origin
+    with the provided spacing, places the third coordinate according to ``up_axis``,
+    and returns identity orientations (``wxyz``) for each instance.
+
+    Args:
+        N: Number of instances.
+        spacing: Distance between neighboring grid positions.
+        up_axis: Up axis for positions ("z", "y", or "x").
+        device: Torch device for returned tensors.
+
+    Returns:
+        A tuple ``(pos, ori)`` where:
+            - ``pos`` is a tensor of shape ``(N, 3)`` with positions.
+            - ``ori`` is a tensor of shape ``(N, 4)`` with identity quaternions in ``(w, x, y, z)``.
+    """
+    # rows/cols
+    rows = int(math.ceil(math.sqrt(N)))
+    cols = int(math.ceil(N / rows))
+
+    idx = torch.arange(N, device=device)
+    r = torch.div(idx, cols, rounding_mode="floor")
+    c = idx % cols
+
+    # centered grid coords
+    x = (c - (cols - 1) * 0.5) * spacing
+    y = ((rows - 1) * 0.5 - r) * spacing
+
+    # place on plane based on up_axis
+    z0 = torch.zeros_like(x)
+    if up_axis.lower() == "z":
+        pos = torch.stack([x, y, z0], dim=1)
+    elif up_axis.lower() == "y":
+        pos = torch.stack([x, z0, y], dim=1)
+    else:  # up_axis == "x"
+        pos = torch.stack([z0, x, y], dim=1)
+
+    # identity orientations (w,x,y,z)
+    ori = torch.zeros((N, 4), device=device)
+    ori[:, 0] = 1.0
+    return pos, ori
diff --git a/source/isaaclab/isaaclab/scene/interactive_scene.py b/source/isaaclab/isaaclab/scene/interactive_scene.py
index 6772f77bba7..83fde02098c 100644
--- a/source/isaaclab/isaaclab/scene/interactive_scene.py
+++ b/source/isaaclab/isaaclab/scene/interactive_scene.py
@@ -1,19 +1,18 @@
+
 # Copyright (c) 2022-2025, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
 # All rights reserved.
 #
 # SPDX-License-Identifier: BSD-3-Clause
+from __future__ import annotations
 
 import logging
 import torch
 from collections.abc import Sequence
 from typing import Any
 
-import carb
-from isaacsim.core.cloner import GridCloner
 from isaacsim.core.prims import XFormPrim
 from isaacsim.core.utils.stage import get_current_stage
-from isaacsim.core.version import get_version
-from pxr import PhysxSchema
+from pxr import PhysxSchema, Sdf
 
 import isaaclab.sim as sim_utils
 from isaaclab.assets import (
@@ -34,6 +33,7 @@
 from isaaclab.sim.utils import get_current_stage_id
 from isaaclab.terrains import TerrainImporter, TerrainImporterCfg
 
+from . import cloner
 from .interactive_scene_cfg import InteractiveSceneCfg
 
 # import logger
@@ -135,80 +135,31 @@ def __init__(self, cfg: InteractiveSceneCfg):
         # physics scene path
         self._physics_scene_path = None
         # prepare cloner for environment replication
-        self.cloner = GridCloner(spacing=self.cfg.env_spacing, stage=self.stage)
-        self.cloner.define_base_env(self.env_ns)
-        self.env_prim_paths = self.cloner.generate_paths(f"{self.env_ns}/env", self.cfg.num_envs)
+        self.env_prim_paths = [f"{self.env_ns}/env_{i}" for i in range(self.cfg.num_envs)]
         # create source prim
         self.stage.DefinePrim(self.env_prim_paths[0], "Xform")
+
+        self.cloner_cfg = cloner.TemplateCloneCfg()
+        self.env_fmt = self.env_regex_ns.replace(".*", "{}")
         # allocate env indices
         self._ALL_INDICES = torch.arange(self.cfg.num_envs, dtype=torch.long, device=self.device)
-        # when replicate_physics=False, we assume heterogeneous environments and clone the xforms first.
-        # this triggers per-object level cloning in the spawner.
-        if not self.cfg.replicate_physics:
-            # check version of Isaac Sim to determine whether clone_in_fabric is valid
-            isaac_sim_version = float(".".join(get_version()[2]))
-            if isaac_sim_version < 5:
-                # clone the env xform
-                env_origins = self.cloner.clone(
-                    source_prim_path=self.env_prim_paths[0],
-                    prim_paths=self.env_prim_paths,
-                    replicate_physics=False,
-                    copy_from_source=True,
-                    enable_env_ids=(
-                        self.cfg.filter_collisions if self.device != "cpu" else False
-                    ),  # this won't do anything because we are not replicating physics
-                )
-            else:
-                # clone the env xform
-                env_origins = self.cloner.clone(
-                    source_prim_path=self.env_prim_paths[0],
-                    prim_paths=self.env_prim_paths,
-                    replicate_physics=False,
-                    copy_from_source=True,
-                    enable_env_ids=(
-                        self.cfg.filter_collisions if self.device != "cpu" else False
-                    ),  # this won't do anything because we are not replicating physics
-                    clone_in_fabric=self.cfg.clone_in_fabric,
-                )
-            self._default_env_origins = torch.tensor(env_origins, device=self.device, dtype=torch.float32)
-        else:
-            # otherwise, environment origins will be initialized during cloning at the end of environment creation
-            self._default_env_origins = None
+        self._default_env_origins, _ = cloner.grid_transforms(self.num_envs, self.cfg.env_spacing, device=self.device)
+        # copy empty prim of env_0 to env_1, env_2, ..., env_{num_envs-1} with correct location.
+        cloner.usd_replicate(
+            self.stage, [self.env_fmt.format(0)], [self.env_fmt], self._ALL_INDICES, positions=self._default_env_origins
+        )
 
         self._global_prim_paths = list()
         if self._is_scene_setup_from_cfg():
-            # add entities from config
+            clone_plan = {"src": [], "dest": [], "mapping": torch.empty((0,), dtype=torch.bool).to(self.device)}
+            self._global_template_prim_paths = list()  # store paths that are in global collision filter from templates
             self._add_entities_from_cfg()
-            # clone environments on a global scope if environment is homogeneous
-            if self.cfg.replicate_physics:
-                self.clone_environments(copy_from_source=False)
-            # replicate physics if we have more than one environment
-            # this is done to make scene initialization faster at play time
-            if self.cfg.replicate_physics and self.cfg.num_envs > 1:
-                # check version of Isaac Sim to determine whether clone_in_fabric is valid
-                isaac_sim_version = float(".".join(get_version()[2]))
-                if isaac_sim_version < 5:
-                    self.cloner.replicate_physics(
-                        source_prim_path=self.env_prim_paths[0],
-                        prim_paths=self.env_prim_paths,
-                        base_env_path=self.env_ns,
-                        root_path=self.env_regex_ns.replace(".*", ""),
-                        enable_env_ids=self.cfg.filter_collisions if self.device != "cpu" else False,
-                    )
-                else:
-                    self.cloner.replicate_physics(
-                        source_prim_path=self.env_prim_paths[0],
-                        prim_paths=self.env_prim_paths,
-                        base_env_path=self.env_ns,
-                        root_path=self.env_regex_ns.replace(".*", ""),
-                        enable_env_ids=self.cfg.filter_collisions if self.device != "cpu" else False,
-                        clone_in_fabric=self.cfg.clone_in_fabric,
-                    )
+            for prim_path in self._global_template_prim_paths:
+                i = clone_plan["src"].index(prim_path)
+                self._global_prim_paths.extend(sim_utils.find_matching_prim_paths(clone_plan["dest"][i].format(".*")))
 
-            # since env_ids is only applicable when replicating physics, we have to fallback to the previous method
-            # to filter collisions if replicate_physics is not enabled
-            # additionally, env_ids is only supported in GPU simulation
-            if (not self.cfg.replicate_physics and self.cfg.filter_collisions) or self.device == "cpu":
+            self.clone_environments()
+            if self.cfg.filter_collisions:
                 self.filter_collisions(self._global_prim_paths)
 
     def clone_environments(self, copy_from_source: bool = False):
@@ -219,58 +170,23 @@ def clone_environments(self, copy_from_source: bool = False):
             If True, clones are independent copies of the source prim and won't reflect its changes (start-up time
             may increase). Defaults to False.
         """
-        # check if user spawned different assets in individual environments
-        # this flag will be None if no multi asset is spawned
-        carb_settings_iface = carb.settings.get_settings()
-        has_multi_assets = carb_settings_iface.get("/isaaclab/spawn/multi_assets")
-        if has_multi_assets and self.cfg.replicate_physics:
-            logger.warning(
-                "Varying assets might have been spawned under different environments."
-                " However, the replicate physics flag is enabled in the 'InteractiveScene' configuration."
-                " This may adversely affect PhysX parsing. We recommend disabling this property."
-            )
-
-        # check version of Isaac Sim to determine whether clone_in_fabric is valid
-        isaac_sim_version = float(".".join(get_version()[2]))
-        if isaac_sim_version < 5:
-            # clone the environment
-            env_origins = self.cloner.clone(
-                source_prim_path=self.env_prim_paths[0],
-                prim_paths=self.env_prim_paths,
-                replicate_physics=self.cfg.replicate_physics,
-                copy_from_source=copy_from_source,
-                enable_env_ids=(
-                    self.cfg.filter_collisions if self.device != "cpu" else False
-                ),  # this automatically filters collisions between environments
-            )
+        # when replicate_physics=False, we assume heterogeneous environments and clone the xforms first.
+        # this triggers per-object level cloning in the spawner.
+        if self.cfg.replicate_physics:
+            prim = self.stage.GetPrimAtPath("/physicsScene")
+            prim.CreateAttribute("physxScene:envIdInBoundsBitCount", Sdf.ValueTypeNames.Int).Set(4)
+
+        if self._is_scene_setup_from_cfg():
+            self.cloner_cfg.clone_physx = not copy_from_source
+            cloner.clone_from_template(self.stage, num_clones=self.num_envs, template_clone_cfg=self.cloner_cfg)
         else:
-            # clone the environment
-            env_origins = self.cloner.clone(
-                source_prim_path=self.env_prim_paths[0],
-                prim_paths=self.env_prim_paths,
-                replicate_physics=self.cfg.replicate_physics,
-                copy_from_source=copy_from_source,
-                enable_env_ids=(
-                    self.cfg.filter_collisions if self.device != "cpu" else False
-                ),  # this automatically filters collisions between environments
-                clone_in_fabric=self.cfg.clone_in_fabric,
-            )
-
-        # since env_ids is only applicable when replicating physics, we have to fallback to the previous method
-        # to filter collisions if replicate_physics is not enabled
-        # additionally, env_ids is only supported in GPU simulation
-        if (not self.cfg.replicate_physics and self.cfg.filter_collisions) or self.device == "cpu":
-            # if scene is specified through cfg, this is already taken care of
-            if not self._is_scene_setup_from_cfg():
-                logger.warning(
-                    "Collision filtering can only be automatically enabled when replicate_physics=True and using GPU"
-                    " simulation. Please call scene.filter_collisions(global_prim_paths) to filter collisions across"
-                    " environments."
-                )
-
-        # in case of heterogeneous cloning, the env origins is specified at init
-        if self._default_env_origins is None:
-            self._default_env_origins = torch.tensor(env_origins, device=self.device, dtype=torch.float32)
+            mapping = torch.ones((1, self.num_envs), device=self.device, dtype=torch.bool)
+            replicate_args = [self.env_fmt.format(0)], [self.env_fmt], self._ALL_INDICES, mapping
+
+            if not copy_from_source:
+                # skip physx cloning, this means physx will walk and parse the stage one by one faithfully
+                cloner.physx_replicate(self.stage, *replicate_args)
+            cloner.usd_replicate(self.stage, *replicate_args, positions=self._default_env_origins)
 
     def filter_collisions(self, global_prim_paths: list[str] | None = None):
         """Filter environments collisions.
@@ -298,7 +214,8 @@ def filter_collisions(self, global_prim_paths: list[str] | None = None):
             self._global_prim_paths += global_prim_paths
 
         # filter collisions within each environment instance
-        self.cloner.filter_collisions(
+        cloner.filter_collisions(
+            self.stage,
             self.physics_scene_path,
             "/World/collisions",
             self.env_prim_paths,
@@ -723,8 +640,6 @@ def _is_scene_setup_from_cfg(self) -> bool:
 
     def _add_entities_from_cfg(self):
         """Add scene entities from the config."""
-        # store paths that are in global collision filter
-        self._global_prim_paths = list()
         # parse the entire scene config and resolve regex
         for asset_name, asset_cfg in self.cfg.__dict__.items():
             # skip keywords
@@ -732,8 +647,19 @@ def _add_entities_from_cfg(self):
             if asset_name in InteractiveSceneCfg.__dataclass_fields__ or asset_cfg is None:
                 continue
             # resolve regex
+            require_clone = False
             if hasattr(asset_cfg, "prim_path"):
-                asset_cfg.prim_path = asset_cfg.prim_path.format(ENV_REGEX_NS=self.env_regex_ns)
+                # In order to compose cloner behavior more flexibly, we ask each spawner to spawn prototypes in
+                # prepared /World/template path, once all template is ready, cloner can determine what rules to follow
+                # to combine, and distribute the templates to cloned environments.
+                asset_cfg.prim_path = asset_cfg.prim_path.replace(self.env_regex_ns, "{ENV_REGEX_NS}")
+                destinations_regex_ns = asset_cfg.prim_path.format(ENV_REGEX_NS=self.env_regex_ns)
+                if self.env_regex_ns[:-2] in destinations_regex_ns:
+                    require_clone = True
+                    prototype_root = asset_cfg.prim_path.format(ENV_REGEX_NS=self.cloner_cfg.template_root)
+                    asset_cfg.prim_path = f"{prototype_root}/{self.cloner_cfg.template_prototype_identifier}_.*"
+                else:
+                    asset_cfg.prim_path = destinations_regex_ns
             # create asset
             if isinstance(asset_cfg, TerrainImporterCfg):
                 # terrains are special entities since they define environment origins
@@ -747,13 +673,26 @@ def _add_entities_from_cfg(self):
             elif isinstance(asset_cfg, RigidObjectCfg):
                 self._rigid_objects[asset_name] = asset_cfg.class_type(asset_cfg)
             elif isinstance(asset_cfg, RigidObjectCollectionCfg):
+                destinations_regex_ns_list = []
                 for rigid_object_cfg in asset_cfg.rigid_objects.values():
-                    rigid_object_cfg.prim_path = rigid_object_cfg.prim_path.format(ENV_REGEX_NS=self.env_regex_ns)
+                    rigid_object_cfg.prim_path = rigid_object_cfg.prim_path.replace(self.env_regex_ns, "{ENV_REGEX_NS}")
+                    destinations_regex_ns = rigid_object_cfg.prim_path.format(ENV_REGEX_NS=self.env_regex_ns)
+                    if self.env_regex_ns[:-2] in destinations_regex_ns:
+                        destinations_regex_ns_list.append(destinations_regex_ns)
+                        prototype_root = rigid_object_cfg.prim_path.format(ENV_REGEX_NS=self.cloner_cfg.template_root)
+                        template_path = f"{prototype_root}/{self.cloner_cfg.template_prototype_identifier}_.*"
+                        rigid_object_cfg.prim_path = template_path
                 self._rigid_object_collections[asset_name] = asset_cfg.class_type(asset_cfg)
                 for rigid_object_cfg in asset_cfg.rigid_objects.values():
                     if hasattr(rigid_object_cfg, "collision_group") and rigid_object_cfg.collision_group == -1:
                         asset_paths = sim_utils.find_matching_prim_paths(rigid_object_cfg.prim_path)
-                        self._global_prim_paths += asset_paths
+                        if require_clone:
+                            self._global_template_prim_paths += asset_paths
+                        else:
+                            self._global_prim_paths += asset_paths
+                asset: RigidObjectCollection = self._rigid_object_collections[asset_name]
+                for i, rigid_object_cfg in enumerate(asset.cfg.rigid_objects.values()):
+                    rigid_object_cfg.prim_path = destinations_regex_ns_list[i]
             elif isinstance(asset_cfg, SurfaceGripperCfg):
                 # add surface grippers to scene
                 self._surface_grippers[asset_name] = asset_cfg.class_type(asset_cfg)
@@ -786,7 +725,22 @@ def _add_entities_from_cfg(self):
                 self._extras[asset_name] = XFormPrim(asset_cfg.prim_path, reset_xform_properties=False)
             else:
                 raise ValueError(f"Unknown asset config type for {asset_name}: {asset_cfg}")
+
             # store global collision paths
             if hasattr(asset_cfg, "collision_group") and asset_cfg.collision_group == -1:
                 asset_paths = sim_utils.find_matching_prim_paths(asset_cfg.prim_path)
-                self._global_prim_paths += asset_paths
+                if require_clone:
+                    # we are going to clone this template path to actual cloned path, but we don't know which cloned
+                    # paths it will end up, so add to temp self._global_template_prim_paths until final path resolved
+                    self._global_template_prim_paths += asset_paths
+                else:
+                    # we are not going to clone this path so directly add to s_global_prim_paths
+                    self._global_prim_paths += asset_paths
+
+            if hasattr(asset_cfg, "prim_path") and require_clone:
+                # this allows on_prim_deletion is tied to the cloned path not template path
+                asset = self.__getitem__(asset_name)
+                if hasattr(asset, "cfg"):
+                    asset.cfg.prim_path = destinations_regex_ns
+                if isinstance(asset, XFormPrim):
+                    asset._regex_prim_paths = [destinations_regex_ns]
diff --git a/source/isaaclab/isaaclab/scene/interactive_scene_cfg.py b/source/isaaclab/isaaclab/scene/interactive_scene_cfg.py
index 2cc472ca074..1151f24f772 100644
--- a/source/isaaclab/isaaclab/scene/interactive_scene_cfg.py
+++ b/source/isaaclab/isaaclab/scene/interactive_scene_cfg.py
@@ -124,3 +124,11 @@ class MySceneCfg(InteractiveSceneCfg):
         default to ``False``.
 
     """
+
+    random_heterogenous_cloning: bool = True
+    """Randomly assign prototypes to environments. Default is True.
+
+    When enabled, each environment selects a prototype at random from the available
+    prototypes under a given template root. When disabled, environments use a
+    round-robin assignment based on ``env_index % num_prototypes``.
+    """
diff --git a/source/isaaclab/isaaclab/sensors/camera/camera.py b/source/isaaclab/isaaclab/sensors/camera/camera.py
index c7a208ba8ec..ac57fbc90b7 100644
--- a/source/isaaclab/isaaclab/sensors/camera/camera.py
+++ b/source/isaaclab/isaaclab/sensors/camera/camera.py
@@ -8,7 +8,6 @@
 import json
 import logging
 import numpy as np
-import re
 import torch
 from collections.abc import Sequence
 from typing import TYPE_CHECKING, Any, Literal
@@ -102,16 +101,6 @@ def __init__(self, cfg: CameraCfg):
             RuntimeError: If no camera prim is found at the given path.
             ValueError: If the provided data types are not supported by the camera.
         """
-        # check if sensor path is valid
-        # note: currently we do not handle environment indices if there is a regex pattern in the leaf
-        #   For example, if the prim path is "/World/Sensor_[1,2]".
-        sensor_path = cfg.prim_path.split("/")[-1]
-        sensor_path_is_regex = re.match(r"^[a-zA-Z0-9/_]+$", sensor_path) is None
-        if sensor_path_is_regex:
-            raise RuntimeError(
-                f"Invalid prim path for the camera sensor: {self.cfg.prim_path}."
-                "\n\tHint: Please ensure that the prim path does not contain any regex patterns in the leaf."
-            )
         # perform check on supported data types
         self._check_supported_data_types(cfg)
         # initialize base class
diff --git a/source/isaaclab/isaaclab/sensors/ray_caster/ray_caster.py b/source/isaaclab/isaaclab/sensors/ray_caster/ray_caster.py
index 723d669d8a0..7f3f0341e3f 100644
--- a/source/isaaclab/isaaclab/sensors/ray_caster/ray_caster.py
+++ b/source/isaaclab/isaaclab/sensors/ray_caster/ray_caster.py
@@ -7,7 +7,6 @@
 
 import logging
 import numpy as np
-import re
 import torch
 from collections.abc import Sequence
 from typing import TYPE_CHECKING
@@ -61,16 +60,6 @@ def __init__(self, cfg: RayCasterCfg):
         Args:
             cfg: The configuration parameters.
         """
-        # check if sensor path is valid
-        # note: currently we do not handle environment indices if there is a regex pattern in the leaf
-        #   For example, if the prim path is "/World/Sensor_[1,2]".
-        sensor_path = cfg.prim_path.split("/")[-1]
-        sensor_path_is_regex = re.match(r"^[a-zA-Z0-9/_]+$", sensor_path) is None
-        if sensor_path_is_regex:
-            raise RuntimeError(
-                f"Invalid prim path for the ray-caster sensor: {self.cfg.prim_path}."
-                "\n\tHint: Please ensure that the prim path does not contain any regex patterns in the leaf."
-            )
         # Initialize base class
         super().__init__(cfg)
         # Create empty variables for storing output data
diff --git a/source/isaaclab/isaaclab/sim/spawners/wrappers/wrappers.py b/source/isaaclab/isaaclab/sim/spawners/wrappers/wrappers.py
index 9f339aa70c7..bdec12f2deb 100644
--- a/source/isaaclab/isaaclab/sim/spawners/wrappers/wrappers.py
+++ b/source/isaaclab/isaaclab/sim/spawners/wrappers/wrappers.py
@@ -5,17 +5,11 @@
 
 from __future__ import annotations
 
-import random
-import re
 from typing import TYPE_CHECKING
 
-import carb
 import isaacsim.core.utils.prims as prim_utils
-import isaacsim.core.utils.stage as stage_utils
-from isaacsim.core.utils.stage import get_current_stage
-from pxr import Sdf, Usd
+from pxr import Usd
 
-import isaaclab.sim as sim_utils
 from isaaclab.sim.spawners.from_files import UsdFileCfg
 
 if TYPE_CHECKING:
@@ -47,31 +41,6 @@ def spawn_multi_asset(
     Returns:
         The created prim at the first prim path.
     """
-    # get stage handle
-    stage = get_current_stage()
-
-    # resolve: {SPAWN_NS}/AssetName
-    # note: this assumes that the spawn namespace already exists in the stage
-    root_path, asset_path = prim_path.rsplit("/", 1)
-    # check if input is a regex expression
-    # note: a valid prim path can only contain alphanumeric characters, underscores, and forward slashes
-    is_regex_expression = re.match(r"^[a-zA-Z0-9/_]+$", root_path) is None
-
-    # resolve matching prims for source prim path expression
-    if is_regex_expression and root_path != "":
-        source_prim_paths = sim_utils.find_matching_prim_paths(root_path)
-        # if no matching prims are found, raise an error
-        if len(source_prim_paths) == 0:
-            raise RuntimeError(
-                f"Unable to find source prim path: '{root_path}'. Please create the prim before spawning."
-            )
-    else:
-        source_prim_paths = [root_path]
-
-    # find a free prim path to hold all the template prims
-    template_prim_path = stage_utils.get_next_free_path("/World/Template")
-    prim_utils.create_prim(template_prim_path, "Scope")
-
     # spawn everything first in a "Dataset" prim
     proto_prim_paths = list()
     for index, asset_cfg in enumerate(cfg.assets_cfg):
@@ -88,7 +57,7 @@ def spawn_multi_asset(
             if hasattr(asset_cfg, attr_name) and attr_value is not None:
                 setattr(asset_cfg, attr_name, attr_value)
         # spawn single instance
-        proto_prim_path = f"{template_prim_path}/Asset_{index:04d}"
+        proto_prim_path = prim_path.replace(".*", f"{index}")
         asset_cfg.func(
             proto_prim_path,
             asset_cfg,
@@ -100,35 +69,7 @@ def spawn_multi_asset(
         # append to proto prim paths
         proto_prim_paths.append(proto_prim_path)
 
-    # resolve prim paths for spawning and cloning
-    prim_paths = [f"{source_prim_path}/{asset_path}" for source_prim_path in source_prim_paths]
-
-    # manually clone prims if the source prim path is a regex expression
-    # note: unlike in the cloner API from Isaac Sim, we do not "reset" xforms on the copied prims.
-    #   This is because the "spawn" calls during the creation of the proto prims already handles this operation.
-    with Sdf.ChangeBlock():
-        for index, prim_path in enumerate(prim_paths):
-            # spawn single instance
-            env_spec = Sdf.CreatePrimInLayer(stage.GetRootLayer(), prim_path)
-            # randomly select an asset configuration
-            if cfg.random_choice:
-                proto_path = random.choice(proto_prim_paths)
-            else:
-                proto_path = proto_prim_paths[index % len(proto_prim_paths)]
-            # copy the proto prim
-            Sdf.CopySpec(env_spec.layer, Sdf.Path(proto_path), env_spec.layer, Sdf.Path(prim_path))
-
-    # delete the dataset prim after spawning
-    prim_utils.delete_prim(template_prim_path)
-
-    # set carb setting to indicate Isaac Lab's environments that different prims have been spawned
-    # at varying prim paths. In this case, PhysX parser shouldn't optimize the stage parsing.
-    # the flag is mainly used to inform the user that they should disable `InteractiveScene.replicate_physics`
-    carb_settings_iface = carb.settings.get_settings()
-    carb_settings_iface.set_bool("/isaaclab/spawn/multi_assets", True)
-
-    # return the prim
-    return prim_utils.get_prim_at_path(prim_paths[0])
+    return prim_utils.get_prim_at_path(proto_prim_paths[0])
 
 
 def spawn_multi_usd_file(
@@ -178,8 +119,6 @@ def spawn_multi_usd_file(
     for usd_path in usd_paths:
         usd_cfg = usd_template_cfg.replace(usd_path=usd_path)
         multi_asset_cfg.assets_cfg.append(usd_cfg)
-    # set random choice
-    multi_asset_cfg.random_choice = cfg.random_choice
 
     # propagate the contact sensor settings
     # note: the default value for activate_contact_sensors in MultiAssetSpawnerCfg is False.
diff --git a/source/isaaclab/isaaclab/sim/spawners/wrappers/wrappers_cfg.py b/source/isaaclab/isaaclab/sim/spawners/wrappers/wrappers_cfg.py
index 1ad1506f2dc..8cc2f7c6fe7 100644
--- a/source/isaaclab/isaaclab/sim/spawners/wrappers/wrappers_cfg.py
+++ b/source/isaaclab/isaaclab/sim/spawners/wrappers/wrappers_cfg.py
@@ -39,6 +39,11 @@ class MultiAssetSpawnerCfg(RigidObjectSpawnerCfg, DeformableObjectSpawnerCfg):
 
     If False, the asset configurations are spawned in the order they are provided in the list.
     If True, a random asset configuration is selected for each spawn.
+
+    .. warning::
+
+        This attribute is deprecated. Use
+        :attr:`~isaaclab.scene.interactive_scene_cfg.InteractiveSceneCfg.random_heterogenous_cloning` instead.
     """
 
 
@@ -64,4 +69,9 @@ class MultiUsdFileCfg(UsdFileCfg):
 
     If False, the asset configurations are spawned in the order they are provided in the list.
     If True, a random asset configuration is selected for each spawn.
+
+    .. warning::
+
+        This attribute is deprecated. Use
+        :attr:`~isaaclab.scene.interactive_scene_cfg.InteractiveSceneCfg.random_heterogenous_cloning` instead.
     """
diff --git a/source/isaaclab/isaaclab/sim/utils/utils.py b/source/isaaclab/isaaclab/sim/utils/utils.py
index 56b03919406..a99579066a0 100644
--- a/source/isaaclab/isaaclab/sim/utils/utils.py
+++ b/source/isaaclab/isaaclab/sim/utils/utils.py
@@ -20,7 +20,6 @@
 import isaacsim.core.utils.stage as stage_utils
 import omni
 import omni.kit.commands
-from isaacsim.core.cloner import Cloner
 from isaacsim.core.utils.carb import get_carb_setting
 from isaacsim.core.utils.stage import get_current_stage
 from isaacsim.core.version import get_version
@@ -237,9 +236,6 @@ def clone(func: Callable) -> Callable:
 
     @functools.wraps(func)
     def wrapper(prim_path: str | Sdf.Path, cfg: SpawnerCfg, *args, **kwargs):
-        # get stage handle
-        stage = get_current_stage()
-
         # cast prim_path to str type in case its an Sdf.Path
         prim_path = str(prim_path)
         # check prim path is global
@@ -263,10 +259,10 @@ def wrapper(prim_path: str | Sdf.Path, cfg: SpawnerCfg, *args, **kwargs):
         else:
             source_prim_paths = [root_path]
 
-        # resolve prim paths for spawning and cloning
-        prim_paths = [f"{source_prim_path}/{asset_path}" for source_prim_path in source_prim_paths]
+        # resolve prim paths for spawning
+        prim_spawn_path = prim_path.replace(".*", "0")
         # spawn single instance
-        prim = func(prim_paths[0], cfg, *args, **kwargs)
+        prim = func(prim_spawn_path, cfg, *args, **kwargs)
         # set the prim visibility
         if hasattr(cfg, "visible"):
             imageable = UsdGeom.Imageable(prim)
@@ -291,28 +287,7 @@ def wrapper(prim_path: str | Sdf.Path, cfg: SpawnerCfg, *args, **kwargs):
                 sem.GetSemanticDataAttr().Set(semantic_value)
         # activate rigid body contact sensors
         if hasattr(cfg, "activate_contact_sensors") and cfg.activate_contact_sensors:
-            schemas.activate_contact_sensors(prim_paths[0])
-        # clone asset using cloner API
-        if len(prim_paths) > 1:
-            cloner = Cloner(stage=stage)
-            # check version of Isaac Sim to determine whether clone_in_fabric is valid
-            isaac_sim_version = float(".".join(get_version()[2]))
-            if isaac_sim_version < 5:
-                # clone the prim
-                cloner.clone(
-                    prim_paths[0], prim_paths[1:], replicate_physics=False, copy_from_source=cfg.copy_from_source
-                )
-            else:
-                # clone the prim
-                clone_in_fabric = kwargs.get("clone_in_fabric", False)
-                replicate_physics = kwargs.get("replicate_physics", False)
-                cloner.clone(
-                    prim_paths[0],
-                    prim_paths[1:],
-                    replicate_physics=replicate_physics,
-                    copy_from_source=cfg.copy_from_source,
-                    clone_in_fabric=clone_in_fabric,
-                )
+            schemas.activate_contact_sensors(prim_spawn_path, cfg.activate_contact_sensors)
         # return the source prim
         return prim
 
diff --git a/source/isaaclab/test/sim/test_cloner.py b/source/isaaclab/test/sim/test_cloner.py
new file mode 100644
index 00000000000..e216ffd6a9f
--- /dev/null
+++ b/source/isaaclab/test/sim/test_cloner.py
@@ -0,0 +1,199 @@
+# Copyright (c) 2022-2025, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Tests for cloner utilities and InteractiveScene cloning behavior."""
+
+"""Launch Isaac Sim Simulator first."""
+
+from isaaclab.app import AppLauncher
+
+# launch omniverse app
+simulation_app = AppLauncher(headless=True).app
+
+"""Rest everything follows."""
+
+import torch
+
+import isaacsim.core.utils.prims as prim_utils
+import isaacsim.core.utils.stage as stage_utils
+import pytest
+from isaacsim.core.api.simulation_context import SimulationContext
+from pxr import UsdGeom
+
+import isaaclab.sim as sim_utils
+from isaaclab.scene.cloner import TemplateCloneCfg, clone_from_template, physx_replicate, usd_replicate
+
+
+@pytest.fixture
+def sim():
+    """Create a fresh simulation context and stage for each test."""
+    stage_utils.create_new_stage()
+    dt = 0.01
+    sim = SimulationContext(physics_dt=dt, rendering_dt=dt, backend="numpy")
+    stage_utils.update_stage()
+    yield sim
+    sim.stop()
+    sim.clear()
+    sim.clear_all_callbacks()
+    sim.clear_instance()
+
+
+def test_usd_replicate_with_positions_and_mask(sim):
+    """Replicate sources to selected envs and author translate ops from positions."""
+    # Prepare sources under /World/template
+    prim_utils.create_prim("/World/template", "Xform")
+    prim_utils.create_prim("/World/template/A", "Xform")
+    prim_utils.create_prim("/World/template/B", "Xform")
+
+    # Prepare destination env namespaces
+    num_envs = 3
+    env_ids = torch.arange(num_envs, dtype=torch.long)
+    prim_utils.create_prim("/World/envs", "Xform")
+    for i in range(num_envs):
+        prim_utils.create_prim(f"/World/envs/env_{i}", "Xform")
+
+    # Map A -> env 0 and 2; B -> env 1 only
+    mask = torch.zeros((2, num_envs), dtype=torch.bool)
+    mask[0, [0, 2]] = True
+    mask[1, [1]] = True
+
+    usd_replicate(
+        stage_utils.get_current_stage(),
+        sources=["/World/template/A", "/World/template/B"],
+        destinations=["/World/envs/env_{}/Object/A", "/World/envs/env_{}/Object/B"],
+        env_ids=env_ids,
+        mask=mask,
+    )
+
+    # Validate replication and translate op
+    assert prim_utils.get_prim_at_path("/World/envs/env_0/Object/A").IsValid()
+    assert not prim_utils.get_prim_at_path("/World/envs/env_0/Object/B").IsValid()
+    assert prim_utils.get_prim_at_path("/World/envs/env_1/Object/B").IsValid()
+    assert not prim_utils.get_prim_at_path("/World/envs/env_1/Object/A").IsValid()
+    assert prim_utils.get_prim_at_path("/World/envs/env_2/Object/A").IsValid()
+
+    # Check xformOp:translate authored for env_2/A
+    prim = prim_utils.get_prim_at_path("/World/envs/env_2/Object/A")
+    xform = UsdGeom.Xformable(prim)
+    ops = xform.GetOrderedXformOps()
+    assert any(op.GetOpType() == UsdGeom.XformOp.TypeTranslate for op in ops)
+
+
+def test_usd_replicate_depth_order_parent_child(sim):
+    """Replicate parent and child when provided out of order; parent should exist before child."""
+    # Prepare sources
+    prim_utils.create_prim("/World/template", "Xform")
+    prim_utils.create_prim("/World/template/Parent", "Xform")
+    prim_utils.create_prim("/World/template/Parent/Child", "Xform")
+
+    # Destinations (single env)
+    env_ids = torch.tensor([0, 1], dtype=torch.long)
+    prim_utils.create_prim("/World/envs", "Xform")
+    prim_utils.create_prim("/World/envs/env_0", "Xform")
+    prim_utils.create_prim("/World/envs/env_1", "Xform")
+
+    # Provide child first, then parent; depth sort should handle this
+    usd_replicate(
+        stage_utils.get_current_stage(),
+        sources=["/World/template/Parent/Child", "/World/template/Parent"],
+        destinations=["/World/envs/env_{}/Parent/Child", "/World/envs/env_{}/Parent"],
+        env_ids=env_ids,
+    )
+
+    for i in range(2):
+        assert prim_utils.get_prim_at_path(f"/World/envs/env_{i}/Parent").IsValid()
+        assert prim_utils.get_prim_at_path(f"/World/envs/env_{i}/Parent/Child").IsValid()
+
+
+def test_physx_replicate_no_error(sim):
+    """PhysX replicator call runs without raising exceptions for simple mapping."""
+    # Prepare sources and envs
+    prim_utils.create_prim("/World/envs", "Xform")
+    prim_utils.create_prim("/World/template", "Xform")
+    prim_utils.create_prim("/World/template/A", "Xform")
+
+    num_envs = 2
+    env_ids = torch.arange(num_envs, dtype=torch.long)
+    for i in range(num_envs):
+        prim_utils.create_prim(f"/World/envs/env_{i}", "Xform")
+
+    mapping = torch.ones((1, num_envs), dtype=torch.bool)
+
+    # Should not raise
+    physx_replicate(
+        stage_utils.get_current_stage(),
+        sources=["/World/template/A"],
+        destinations=["/World/envs/env_{}/A"],
+        env_ids=env_ids,
+        mapping=mapping,
+    )
+
+
+def test_clone_from_template(sim):
+    """Clone prototypes via TemplateCloneCfg and clone_from_template and exercise both USD and PhysX.
+
+    Steps:
+    - Create /World/template and /World/envs/env_0..env_31
+    - Spawn three prototypes under /World/template/Object/proto_asset_.*
+    - Clone using TemplateCloneCfg with random_heterogenous_cloning=False (modulo mapping)
+    - Verify modulo placement exists; then call sim.reset(), and create PhysX view
+    """
+    from isaacsim.core.simulation_manager import SimulationManager
+
+    num_clones = 32
+    clone_cfg = TemplateCloneCfg(random_heterogenous_cloning=False, device="cpu")
+    prim_utils.create_prim(clone_cfg.template_root, "Xform")
+    prim_utils.create_prim("/World/envs", "Xform")
+    for i in range(num_clones):
+        prim_utils.create_prim(f"/World/envs/env_{i}", "Xform", translation=(0, 0, 0))
+
+    # Spawn prototypes under template
+    cfg = sim_utils.MultiAssetSpawnerCfg(
+        assets_cfg=[
+            sim_utils.ConeCfg(
+                radius=0.3,
+                height=0.6,
+                visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(0.0, 1.0, 0.0), metallic=0.2),
+                mass_props=sim_utils.MassPropertiesCfg(mass=100.0),
+            ),
+            sim_utils.CuboidCfg(
+                size=(0.3, 0.3, 0.3),
+                visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(1.0, 0.0, 0.0), metallic=0.2),
+            ),
+            sim_utils.SphereCfg(
+                radius=0.3,
+                visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(0.0, 0.0, 1.0), metallic=0.2),
+            ),
+        ],
+        rigid_props=sim_utils.RigidBodyPropertiesCfg(
+            solver_position_iteration_count=4, solver_velocity_iteration_count=0
+        ),
+        mass_props=sim_utils.MassPropertiesCfg(mass=1.0),
+        collision_props=sim_utils.CollisionPropertiesCfg(),
+    )
+    prim = cfg.func(f"{clone_cfg.template_root}/Object/{clone_cfg.template_prototype_identifier}_.*", cfg)
+    assert prim.IsValid()
+
+    stage = stage_utils.get_current_stage()
+    clone_from_template(stage, num_clones=num_clones, template_clone_cfg=clone_cfg)
+
+    primitive_prims = sim_utils.get_all_matching_child_prims(
+        "/World/envs", predicate=lambda prim: prim.GetTypeName() in ["Cone", "Cube", "Sphere"]
+    )
+
+    for i, primitive_prim in enumerate(primitive_prims):
+        modulus = i % 3
+        if modulus == 0:
+            assert primitive_prim.GetTypeName() == "Cone"
+        elif modulus == 1:
+            assert primitive_prim.GetTypeName() == "Cube"
+        else:
+            assert primitive_prim.GetTypeName() == "Sphere"
+
+    # # Exercise PhysX initialization; should not raise error
+    sim.reset()
+    object_view_regex = f"{clone_cfg.clone_regex}/Object".replace(".*", "*")
+    physx_view = SimulationManager.get_physics_sim_view().create_rigid_body_view(object_view_regex)
+    assert physx_view._backend is not None
diff --git a/source/isaaclab/test/sim/test_spawn_wrappers.py b/source/isaaclab/test/sim/test_spawn_wrappers.py
index 5edae7a79d6..163c3bda5c9 100644
--- a/source/isaaclab/test/sim/test_spawn_wrappers.py
+++ b/source/isaaclab/test/sim/test_spawn_wrappers.py
@@ -37,9 +37,7 @@ def sim():
 
 def test_spawn_multiple_shapes_with_global_settings(sim):
     """Test spawning of shapes randomly with global rigid body settings."""
-    num_clones = 10
-    for i in range(num_clones):
-        prim_utils.create_prim(f"/World/env_{i}", "Xform", translation=(i, i, 0))
+    prim_utils.create_prim("/World/template", "Xform", translation=(0, 0, 0))
 
     cfg = sim_utils.MultiAssetSpawnerCfg(
         assets_cfg=[
@@ -58,19 +56,18 @@ def test_spawn_multiple_shapes_with_global_settings(sim):
                 visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(0.0, 0.0, 1.0), metallic=0.2),
             ),
         ],
-        random_choice=True,
         rigid_props=sim_utils.RigidBodyPropertiesCfg(
             solver_position_iteration_count=4, solver_velocity_iteration_count=0
         ),
         mass_props=sim_utils.MassPropertiesCfg(mass=1.0),
         collision_props=sim_utils.CollisionPropertiesCfg(),
     )
-    prim = cfg.func("/World/env_.*/Cone", cfg)
+    prim = cfg.func("/World/template/Cone/asset_.*", cfg)
 
     assert prim.IsValid()
-    assert prim_utils.get_prim_path(prim) == "/World/env_0/Cone"
-    prim_paths = prim_utils.find_matching_prim_paths("/World/env_*/Cone")
-    assert len(prim_paths) == num_clones
+    assert prim_utils.get_prim_path(prim) == "/World/template/Cone/asset_0"
+    prim_paths = prim_utils.find_matching_prim_paths("/World/template/Cone/asset_.*")
+    assert len(prim_paths) == 3
 
     for prim_path in prim_paths:
         prim = prim_utils.get_prim_at_path(prim_path)
@@ -79,9 +76,7 @@ def test_spawn_multiple_shapes_with_global_settings(sim):
 
 def test_spawn_multiple_shapes_with_individual_settings(sim):
     """Test spawning of shapes randomly with individual rigid object settings."""
-    num_clones = 10
-    for i in range(num_clones):
-        prim_utils.create_prim(f"/World/env_{i}", "Xform", translation=(i, i, 0))
+    prim_utils.create_prim("/World/template", "Xform", translation=(0, 0, 0))
 
     mass_variations = [2.0, 3.0, 4.0]
     cfg = sim_utils.MultiAssetSpawnerCfg(
@@ -109,14 +104,13 @@ def test_spawn_multiple_shapes_with_individual_settings(sim):
                 collision_props=sim_utils.CollisionPropertiesCfg(),
             ),
         ],
-        random_choice=True,
     )
-    prim = cfg.func("/World/env_.*/Cone", cfg)
+    prim = cfg.func("/World/template/Cone/asset_.*", cfg)
 
     assert prim.IsValid()
-    assert prim_utils.get_prim_path(prim) == "/World/env_0/Cone"
-    prim_paths = prim_utils.find_matching_prim_paths("/World/env_*/Cone")
-    assert len(prim_paths) == num_clones
+    assert prim_utils.get_prim_path(prim) == "/World/template/Cone/asset_0"
+    prim_paths = prim_utils.find_matching_prim_paths("/World/template/Cone/asset_.*")
+    assert len(prim_paths) == 3
 
     for prim_path in prim_paths:
         prim = prim_utils.get_prim_at_path(prim_path)
@@ -130,16 +124,13 @@ def test_spawn_multiple_shapes_with_individual_settings(sim):
 
 def test_spawn_multiple_files_with_global_settings(sim):
     """Test spawning of files randomly with global articulation settings."""
-    num_clones = 10
-    for i in range(num_clones):
-        prim_utils.create_prim(f"/World/env_{i}", "Xform", translation=(i, i, 0))
+    prim_utils.create_prim("/World/template", "Xform", translation=(0, 0, 0))
 
     cfg = sim_utils.MultiUsdFileCfg(
         usd_path=[
             f"{ISAACLAB_NUCLEUS_DIR}/Robots/ANYbotics/ANYmal-C/anymal_c.usd",
             f"{ISAACLAB_NUCLEUS_DIR}/Robots/ANYbotics/ANYmal-D/anymal_d.usd",
         ],
-        random_choice=True,
         rigid_props=sim_utils.RigidBodyPropertiesCfg(
             disable_gravity=False,
             retain_accelerations=False,
@@ -154,9 +145,9 @@ def test_spawn_multiple_files_with_global_settings(sim):
         ),
         activate_contact_sensors=True,
     )
-    prim = cfg.func("/World/env_.*/Robot", cfg)
+    prim = cfg.func("/World/template/Robot/asset_.*", cfg)
 
     assert prim.IsValid()
-    assert prim_utils.get_prim_path(prim) == "/World/env_0/Robot"
-    prim_paths = prim_utils.find_matching_prim_paths("/World/env_*/Robot")
-    assert len(prim_paths) == num_clones
+    assert prim_utils.get_prim_path(prim) == "/World/template/Robot/asset_0"
+    prim_paths = prim_utils.find_matching_prim_paths("/World/template/Robot/asset_.*")
+    assert len(prim_paths) == 2

From cefd8ef4467783dd29680b2353e32a5645479f8d Mon Sep 17 00:00:00 2001
From: Octi Zhang <zhengyuz@nvidia.com>
Date: Wed, 5 Nov 2025 14:31:24 -0800
Subject: [PATCH 02/15] fix dead code path

---
 source/isaaclab/isaaclab/scene/interactive_scene.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/source/isaaclab/isaaclab/scene/interactive_scene.py b/source/isaaclab/isaaclab/scene/interactive_scene.py
index 83fde02098c..75acc34dd6a 100644
--- a/source/isaaclab/isaaclab/scene/interactive_scene.py
+++ b/source/isaaclab/isaaclab/scene/interactive_scene.py
@@ -151,12 +151,11 @@ def __init__(self, cfg: InteractiveSceneCfg):
 
         self._global_prim_paths = list()
         if self._is_scene_setup_from_cfg():
-            clone_plan = {"src": [], "dest": [], "mapping": torch.empty((0,), dtype=torch.bool).to(self.device)}
             self._global_template_prim_paths = list()  # store paths that are in global collision filter from templates
             self._add_entities_from_cfg()
             for prim_path in self._global_template_prim_paths:
-                i = clone_plan["src"].index(prim_path)
-                self._global_prim_paths.extend(sim_utils.find_matching_prim_paths(clone_plan["dest"][i].format(".*")))
+                filter_regex = prim_path.replace(self.cloner_cfg.template_root, self.env_regex_ns)
+                self._global_prim_paths.extend(sim_utils.find_matching_prim_paths(filter_regex))
 
             self.clone_environments()
             if self.cfg.filter_collisions:

From 4cb318639ce9d9ded5012424cc77c101d9a2e9d9 Mon Sep 17 00:00:00 2001
From: Octi Zhang <zhengyuz@nvidia.com>
Date: Wed, 5 Nov 2025 14:38:13 -0800
Subject: [PATCH 03/15] pass precommit

---
 source/isaaclab/isaaclab/scene/interactive_scene.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/isaaclab/isaaclab/scene/interactive_scene.py b/source/isaaclab/isaaclab/scene/interactive_scene.py
index 75acc34dd6a..6eb29a1863a 100644
--- a/source/isaaclab/isaaclab/scene/interactive_scene.py
+++ b/source/isaaclab/isaaclab/scene/interactive_scene.py
@@ -1,8 +1,8 @@
-
 # Copyright (c) 2022-2025, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
 # All rights reserved.
 #
 # SPDX-License-Identifier: BSD-3-Clause
+
 from __future__ import annotations
 
 import logging

From 0b005c7a5b0ef14d74f106c4632fa44bcea24fce Mon Sep 17 00:00:00 2001
From: ooctipus <zhengyuz@nvidia.com>
Date: Wed, 5 Nov 2025 14:48:28 -0800
Subject: [PATCH 04/15] Update
 source/isaaclab/isaaclab/scene/interactive_scene.py

Co-authored-by: greptile-apps[bot] <165735046+greptile-apps[bot]@users.noreply.github.com>
Signed-off-by: ooctipus <zhengyuz@nvidia.com>
---
 source/isaaclab/isaaclab/scene/interactive_scene.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/source/isaaclab/isaaclab/scene/interactive_scene.py b/source/isaaclab/isaaclab/scene/interactive_scene.py
index 6eb29a1863a..75c012f17d2 100644
--- a/source/isaaclab/isaaclab/scene/interactive_scene.py
+++ b/source/isaaclab/isaaclab/scene/interactive_scene.py
@@ -139,7 +139,12 @@ def __init__(self, cfg: InteractiveSceneCfg):
         # create source prim
         self.stage.DefinePrim(self.env_prim_paths[0], "Xform")
 
-        self.cloner_cfg = cloner.TemplateCloneCfg()
+        self.cloner_cfg = cloner.TemplateCloneCfg(
+            clone_regex=self.env_regex_ns,
+            random_heterogenous_cloning=self.cfg.random_heterogenous_cloning,
+            clone_in_fabric=self.cfg.clone_in_fabric,
+            device=self.device,
+        )
         self.env_fmt = self.env_regex_ns.replace(".*", "{}")
         # allocate env indices
         self._ALL_INDICES = torch.arange(self.cfg.num_envs, dtype=torch.long, device=self.device)

From 55cb85a68f886db9465db1c884b8e91262b4c0b1 Mon Sep 17 00:00:00 2001
From: Octi Zhang <zhengyuz@nvidia.com>
Date: Wed, 5 Nov 2025 18:00:21 -0800
Subject: [PATCH 05/15] bug fixes

---
 source/isaaclab/isaaclab/scene/cloner.py      |  8 +--
 .../isaaclab/test/assets/test_rigid_object.py |  9 +++
 .../assets/test_rigid_object_collection.py    |  9 ++-
 .../test/sensors/test_tiled_camera.py         | 55 +++++++++++++++++++
 4 files changed, 76 insertions(+), 5 deletions(-)

diff --git a/source/isaaclab/isaaclab/scene/cloner.py b/source/isaaclab/isaaclab/scene/cloner.py
index 2e56b169432..2a5a6e4b9ea 100644
--- a/source/isaaclab/isaaclab/scene/cloner.py
+++ b/source/isaaclab/isaaclab/scene/cloner.py
@@ -137,11 +137,11 @@ def clone_from_template(stage: Usd.Stage, num_clones: int, template_clone_cfg: T
     # If all prototypes map to env_0, clone whole env_0 to all envs; else clone per-object
     if torch.all(proto_idx == 0):
         replicate_args = [clone_path_fmt.format(0)], [clone_path_fmt], world_indices, clone_plan["mapping"]
-        # parse env_origins directly from clone_path
-        get_translate = (
-            lambda prim_path: stage.GetPrimAtPath(prim_path).GetAttribute("xformOp:translate").Get()
-        )  # noqa: E731
         if cfg.clone_usd:
+            # parse env_origins directly from clone_path
+            get_translate = (
+                lambda prim_path: stage.GetPrimAtPath(prim_path).GetAttribute("xformOp:translate").Get()
+            )  # noqa: E731
             positions = torch.tensor([get_translate(clone_path_fmt.format(i)) for i in world_indices])
             usd_replicate(stage, *replicate_args, positions=positions)
     else:
diff --git a/source/isaaclab/test/assets/test_rigid_object.py b/source/isaaclab/test/assets/test_rigid_object.py
index 6a0dc77b861..9931e172a3d 100644
--- a/source/isaaclab/test/assets/test_rigid_object.py
+++ b/source/isaaclab/test/assets/test_rigid_object.py
@@ -28,6 +28,7 @@
 from isaaclab.assets import RigidObject, RigidObjectCfg
 from isaaclab.sim import build_simulation_context
 from isaaclab.sim.spawners import materials
+from isaaclab.scene import cloner
 from isaaclab.utils.assets import ISAAC_NUCLEUS_DIR, ISAACLAB_NUCLEUS_DIR
 from isaaclab.utils.math import (
     combine_frame_transforms,
@@ -93,6 +94,14 @@ def generate_cubes_scene(
     )
     cube_object = RigidObject(cfg=cube_object_cfg)
 
+    cloner.usd_replicate(
+        stage=prim_utils.get_current_stage(),
+        sources=["/World/Table_0"],
+        destinations=["/World/Table_{}"],
+        env_ids=torch.arange(num_cubes),
+        positions=origins
+    )
+
     return cube_object, origins
 
 
diff --git a/source/isaaclab/test/assets/test_rigid_object_collection.py b/source/isaaclab/test/assets/test_rigid_object_collection.py
index 876a2904bf1..3e656ac407c 100644
--- a/source/isaaclab/test/assets/test_rigid_object_collection.py
+++ b/source/isaaclab/test/assets/test_rigid_object_collection.py
@@ -25,6 +25,7 @@
 import isaaclab.sim as sim_utils
 from isaaclab.assets import RigidObjectCfg, RigidObjectCollection, RigidObjectCollectionCfg
 from isaaclab.sim import build_simulation_context
+from isaaclab.scene import cloner
 from isaaclab.utils.assets import ISAAC_NUCLEUS_DIR
 from isaaclab.utils.math import (
     combine_frame_transforms,
@@ -90,7 +91,13 @@ def generate_cubes_scene(
     # create the rigid object collection
     cube_object_collection_cfg = RigidObjectCollectionCfg(rigid_objects=cube_config_dict)
     cube_object_colection = RigidObjectCollection(cfg=cube_object_collection_cfg)
-
+    cloner.usd_replicate(
+        stage=prim_utils.get_current_stage(),
+        sources=["/World/Table_0"],
+        destinations=["/World/Table_{}"],
+        env_ids=torch.arange(num_envs),
+        positions=origins
+    )
     return cube_object_colection, origins
 
 
diff --git a/source/isaaclab/test/sensors/test_tiled_camera.py b/source/isaaclab/test/sensors/test_tiled_camera.py
index fdef7a3ae5c..b0b8120cb16 100644
--- a/source/isaaclab/test/sensors/test_tiled_camera.py
+++ b/source/isaaclab/test/sensors/test_tiled_camera.py
@@ -34,11 +34,32 @@
     from pxr import Semantics
 
 import isaaclab.sim as sim_utils
+from isaaclab.scene import cloner
 from isaaclab.sensors.camera import Camera, CameraCfg, TiledCamera, TiledCameraCfg
 from isaaclab.utils.assets import ISAAC_NUCLEUS_DIR
 from isaaclab.utils.timer import Timer
 
 
+def _replicate_cameras_to_all_origins(num_cameras: int, origin_path_fmt: str = "/World/Origin_{}") -> None:
+    """Ensure every origin has a camera by copying the origin_0 subtree to all origins.
+
+    This replicates the entire origin_0 prim (including its CameraSensor child) to
+    origin_1..origin_{N-1}, and preserves per-origin translations.
+    """
+    stage = prim_utils.get_current_stage()
+    get_translate = (
+        lambda prim_path: stage.GetPrimAtPath(prim_path).GetAttribute("xformOp:translate").Get()
+    )  # noqa: E731
+    positions = torch.tensor([get_translate(origin_path_fmt.format(i)) for i in range(num_cameras)])
+    cloner.usd_replicate(
+        stage=stage,
+        sources=[origin_path_fmt.format(0)],
+        destinations=[origin_path_fmt],
+        env_ids=torch.arange(num_cameras),
+        positions=positions,
+    )
+
+
 @pytest.fixture(scope="function")
 def setup_camera(device) -> tuple[sim_utils.SimulationContext, TiledCameraCfg, float]:
     """Fixture to set up and tear down the camera simulation environment."""
@@ -258,6 +279,9 @@ def test_multi_camera_init(setup_camera, device):
     camera_cfg = copy.deepcopy(camera_cfg)
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera = TiledCamera(camera_cfg)
+
+    # parse env_origins directly from clone_path
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -315,6 +339,8 @@ def test_rgb_only_camera(setup_camera, device):
     camera_cfg.data_types = ["rgb"]
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera = TiledCamera(camera_cfg)
+    # Replicate the first origin (with camera) across all origins so each env has a camera
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -417,6 +443,8 @@ def test_depth_only_camera(setup_camera, device):
     camera_cfg.data_types = ["distance_to_camera"]
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera = TiledCamera(camera_cfg)
+    # Replicate cameras to all origins
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -471,6 +499,8 @@ def test_rgba_only_camera(setup_camera, device):
     camera_cfg.data_types = ["rgba"]
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera = TiledCamera(camera_cfg)
+    # Replicate cameras to all origins
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -525,6 +555,8 @@ def test_distance_to_camera_only_camera(setup_camera, device):
     camera_cfg.data_types = ["distance_to_camera"]
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera = TiledCamera(camera_cfg)
+    # Replicate cameras to all origins
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -579,6 +611,8 @@ def test_distance_to_image_plane_only_camera(setup_camera, device):
     camera_cfg.data_types = ["distance_to_image_plane"]
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera = TiledCamera(camera_cfg)
+    # Replicate cameras to all origins
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -633,6 +667,8 @@ def test_normals_only_camera(setup_camera, device):
     camera_cfg.data_types = ["normals"]
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera = TiledCamera(camera_cfg)
+    # Replicate cameras to all origins
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -687,6 +723,8 @@ def test_motion_vectors_only_camera(setup_camera, device):
     camera_cfg.data_types = ["motion_vectors"]
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera = TiledCamera(camera_cfg)
+    # Replicate cameras to all origins
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -741,6 +779,8 @@ def test_semantic_segmentation_colorize_only_camera(setup_camera, device):
     camera_cfg.data_types = ["semantic_segmentation"]
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera = TiledCamera(camera_cfg)
+    # Replicate cameras to all origins
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -796,6 +836,8 @@ def test_instance_segmentation_fast_colorize_only_camera(setup_camera, device):
     camera_cfg.data_types = ["instance_segmentation_fast"]
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera = TiledCamera(camera_cfg)
+    # Replicate cameras to all origins
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -851,6 +893,8 @@ def test_instance_id_segmentation_fast_colorize_only_camera(setup_camera, device
     camera_cfg.data_types = ["instance_id_segmentation_fast"]
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera = TiledCamera(camera_cfg)
+    # Replicate cameras to all origins
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -907,6 +951,8 @@ def test_semantic_segmentation_non_colorize_only_camera(setup_camera, device):
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera_cfg.colorize_semantic_segmentation = False
     camera = TiledCamera(camera_cfg)
+    # Replicate cameras to all origins
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -964,6 +1010,8 @@ def test_instance_segmentation_fast_non_colorize_only_camera(setup_camera, devic
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera_cfg.colorize_instance_segmentation = False
     camera = TiledCamera(camera_cfg)
+    # Replicate cameras to all origins
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -1019,6 +1067,7 @@ def test_instance_id_segmentation_fast_non_colorize_only_camera(setup_camera, de
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera_cfg.colorize_instance_id_segmentation = False
     camera = TiledCamera(camera_cfg)
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -1087,6 +1136,7 @@ def test_all_annotators_camera(setup_camera, device):
     camera_cfg.data_types = all_annotator_types
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera = TiledCamera(camera_cfg)
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -1189,6 +1239,8 @@ def test_all_annotators_low_resolution_camera(setup_camera, device):
     camera_cfg.data_types = all_annotator_types
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera = TiledCamera(camera_cfg)
+    # Replicate cameras to all origins
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -1289,6 +1341,8 @@ def test_all_annotators_non_perfect_square_number_camera(setup_camera, device):
     camera_cfg.data_types = all_annotator_types
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera = TiledCamera(camera_cfg)
+    # Replicate cameras to all origins
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim
@@ -1413,6 +1467,7 @@ def test_all_annotators_instanceable(setup_camera, device):
     camera_cfg.prim_path = "/World/Origin_.*/CameraSensor"
     camera_cfg.offset.pos = (0.0, 0.0, 5.5)
     camera = TiledCamera(camera_cfg)
+    _replicate_cameras_to_all_origins(num_cameras)
     # Check simulation parameter is set correctly
     assert sim.has_rtx_sensors()
     # Play sim

From ace852db921a2a86dcf3ce39220541505346ddf3 Mon Sep 17 00:00:00 2001
From: Octi Zhang <zhengyuz@nvidia.com>
Date: Wed, 5 Nov 2025 18:04:56 -0800
Subject: [PATCH 06/15] fixed copy from source bug

---
 source/isaaclab/isaaclab/scene/interactive_scene.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/isaaclab/isaaclab/scene/interactive_scene.py b/source/isaaclab/isaaclab/scene/interactive_scene.py
index 75c012f17d2..e517adce20f 100644
--- a/source/isaaclab/isaaclab/scene/interactive_scene.py
+++ b/source/isaaclab/isaaclab/scene/interactive_scene.py
@@ -181,7 +181,7 @@ def clone_environments(self, copy_from_source: bool = False):
             prim.CreateAttribute("physxScene:envIdInBoundsBitCount", Sdf.ValueTypeNames.Int).Set(4)
 
         if self._is_scene_setup_from_cfg():
-            self.cloner_cfg.clone_physx = not copy_from_source
+            self.cloner_cfg.clone_physx = copy_from_source
             cloner.clone_from_template(self.stage, num_clones=self.num_envs, template_clone_cfg=self.cloner_cfg)
         else:
             mapping = torch.ones((1, self.num_envs), device=self.device, dtype=torch.bool)

From d2f153d42e4892d06d49aa071e4474b7d42288c8 Mon Sep 17 00:00:00 2001
From: Octi Zhang <zhengyuz@nvidia.com>
Date: Wed, 5 Nov 2025 18:47:27 -0800
Subject: [PATCH 07/15] fix the overriding issue

---
 source/isaaclab/isaaclab/scene/interactive_scene.py |  1 +
 source/isaaclab/test/sensors/test_contact_sensor.py | 10 +++++-----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/source/isaaclab/isaaclab/scene/interactive_scene.py b/source/isaaclab/isaaclab/scene/interactive_scene.py
index e517adce20f..cca0e09ee8f 100644
--- a/source/isaaclab/isaaclab/scene/interactive_scene.py
+++ b/source/isaaclab/isaaclab/scene/interactive_scene.py
@@ -652,6 +652,7 @@ def _add_entities_from_cfg(self):
                 continue
             # resolve regex
             require_clone = False
+            asset_cfg = asset_cfg.copy()
             if hasattr(asset_cfg, "prim_path"):
                 # In order to compose cloner behavior more flexibly, we ask each spawner to spawn prototypes in
                 # prepared /World/template path, once all template is ready, cloner can determine what rules to follow
diff --git a/source/isaaclab/test/sensors/test_contact_sensor.py b/source/isaaclab/test/sensors/test_contact_sensor.py
index ac70e8b7659..0a1187c80ba 100644
--- a/source/isaaclab/test/sensors/test_contact_sensor.py
+++ b/source/isaaclab/test/sensors/test_contact_sensor.py
@@ -90,7 +90,7 @@ class ContactSensorSceneCfg(InteractiveSceneCfg):
 
 
 CUBE_CFG = ContactSensorRigidObjectCfg(
-    prim_path="/World/Objects/Cube",
+    prim_path="{ENV_REGEX_NS}/Cube",
     spawn=sim_utils.CuboidCfg(
         size=(0.5, 0.5, 0.5),
         rigid_props=sim_utils.RigidBodyPropertiesCfg(
@@ -109,7 +109,7 @@ class ContactSensorSceneCfg(InteractiveSceneCfg):
 """Configuration of the cube prim."""
 
 SPHERE_CFG = ContactSensorRigidObjectCfg(
-    prim_path="/World/Objects/Sphere",
+    prim_path="{ENV_REGEX_NS}/Sphere",
     spawn=sim_utils.SphereCfg(
         radius=0.25,
         rigid_props=sim_utils.RigidBodyPropertiesCfg(
@@ -128,7 +128,7 @@ class ContactSensorSceneCfg(InteractiveSceneCfg):
 """Configuration of the sphere prim."""
 
 CYLINDER_CFG = ContactSensorRigidObjectCfg(
-    prim_path="/World/Objects/Cylinder",
+    prim_path="{ENV_REGEX_NS}/Cylinder",
     spawn=sim_utils.CylinderCfg(
         radius=0.5,
         height=0.01,
@@ -149,7 +149,7 @@ class ContactSensorSceneCfg(InteractiveSceneCfg):
 """Configuration of the cylinder prim."""
 
 CAPSULE_CFG = ContactSensorRigidObjectCfg(
-    prim_path="/World/Objects/Capsule",
+    prim_path="{ENV_REGEX_NS}/Capsule",
     spawn=sim_utils.CapsuleCfg(
         radius=0.25,
         height=0.5,
@@ -170,7 +170,7 @@ class ContactSensorSceneCfg(InteractiveSceneCfg):
 """Configuration of the capsule prim."""
 
 CONE_CFG = ContactSensorRigidObjectCfg(
-    prim_path="/World/Objects/Cone",
+    prim_path="{ENV_REGEX_NS}/Cone",
     spawn=sim_utils.ConeCfg(
         radius=0.5,
         height=0.5,

From 8d854da693e96c9ebd5162b3c74d769b398b4f48 Mon Sep 17 00:00:00 2001
From: Octi Zhang <zhengyuz@nvidia.com>
Date: Wed, 5 Nov 2025 18:53:05 -0800
Subject: [PATCH 08/15] pass precommit

---
 source/isaaclab/test/assets/test_rigid_object.py            | 4 ++--
 source/isaaclab/test/assets/test_rigid_object_collection.py | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/source/isaaclab/test/assets/test_rigid_object.py b/source/isaaclab/test/assets/test_rigid_object.py
index 9931e172a3d..c75917f4cd4 100644
--- a/source/isaaclab/test/assets/test_rigid_object.py
+++ b/source/isaaclab/test/assets/test_rigid_object.py
@@ -26,9 +26,9 @@
 
 import isaaclab.sim as sim_utils
 from isaaclab.assets import RigidObject, RigidObjectCfg
+from isaaclab.scene import cloner
 from isaaclab.sim import build_simulation_context
 from isaaclab.sim.spawners import materials
-from isaaclab.scene import cloner
 from isaaclab.utils.assets import ISAAC_NUCLEUS_DIR, ISAACLAB_NUCLEUS_DIR
 from isaaclab.utils.math import (
     combine_frame_transforms,
@@ -99,7 +99,7 @@ def generate_cubes_scene(
         sources=["/World/Table_0"],
         destinations=["/World/Table_{}"],
         env_ids=torch.arange(num_cubes),
-        positions=origins
+        positions=origins,
     )
 
     return cube_object, origins
diff --git a/source/isaaclab/test/assets/test_rigid_object_collection.py b/source/isaaclab/test/assets/test_rigid_object_collection.py
index 3e656ac407c..81fe4203584 100644
--- a/source/isaaclab/test/assets/test_rigid_object_collection.py
+++ b/source/isaaclab/test/assets/test_rigid_object_collection.py
@@ -24,8 +24,8 @@
 
 import isaaclab.sim as sim_utils
 from isaaclab.assets import RigidObjectCfg, RigidObjectCollection, RigidObjectCollectionCfg
-from isaaclab.sim import build_simulation_context
 from isaaclab.scene import cloner
+from isaaclab.sim import build_simulation_context
 from isaaclab.utils.assets import ISAAC_NUCLEUS_DIR
 from isaaclab.utils.math import (
     combine_frame_transforms,
@@ -96,7 +96,7 @@ def generate_cubes_scene(
         sources=["/World/Table_0"],
         destinations=["/World/Table_{}"],
         env_ids=torch.arange(num_envs),
-        positions=origins
+        positions=origins,
     )
     return cube_object_colection, origins
 

From f5107ff12edfb1f2d0a454e6405a25a9271fe8e3 Mon Sep 17 00:00:00 2001
From: Octi Zhang <zhengyuz@nvidia.com>
Date: Wed, 5 Nov 2025 22:44:25 -0800
Subject: [PATCH 09/15] add missing cloning pieces into test cases

---
 .../isaaclab/test/assets/test_articulation.py | 10 ++++-
 .../test/assets/test_deformable_object.py     |  9 ++++-
 .../test/sensors/test_multi_tiled_camera.py   | 37 ++++++++++++++++---
 source/isaaclab/test/sim/test_spawn_shapes.py | 14 +------
 4 files changed, 51 insertions(+), 19 deletions(-)

diff --git a/source/isaaclab/test/assets/test_articulation.py b/source/isaaclab/test/assets/test_articulation.py
index 3dda2c89396..2dafcd8271c 100644
--- a/source/isaaclab/test/assets/test_articulation.py
+++ b/source/isaaclab/test/assets/test_articulation.py
@@ -23,7 +23,7 @@
 import isaacsim.core.utils.prims as prim_utils
 import pytest
 from isaacsim.core.version import get_version
-
+from isaaclab.scene import cloner
 import isaaclab.sim as sim_utils
 import isaaclab.utils.math as math_utils
 import isaaclab.utils.string as string_utils
@@ -178,6 +178,14 @@ def generate_articulation(
         prim_utils.create_prim(f"/World/Env_{i}", "Xform", translation=translations[i][:3])
     articulation = Articulation(articulation_cfg.replace(prim_path="/World/Env_.*/Robot"))
 
+    cloner.usd_replicate(
+        stage=prim_utils.get_current_stage(),
+        sources=["/World/Env_0"],
+        destinations=["/World/Env_{}"],
+        env_ids=torch.arange(num_articulations),
+        positions=translations,
+    )
+
     return articulation, translations
 
 
diff --git a/source/isaaclab/test/assets/test_deformable_object.py b/source/isaaclab/test/assets/test_deformable_object.py
index 2d589573e69..1c983edf6d7 100644
--- a/source/isaaclab/test/assets/test_deformable_object.py
+++ b/source/isaaclab/test/assets/test_deformable_object.py
@@ -26,6 +26,7 @@
 
 import isaaclab.sim as sim_utils
 import isaaclab.utils.math as math_utils
+from isaaclab.scene import cloner
 from isaaclab.assets import DeformableObject, DeformableObjectCfg
 from isaaclab.sim import build_simulation_context
 
@@ -85,7 +86,13 @@ def generate_cubes_scene(
         init_state=DeformableObjectCfg.InitialStateCfg(pos=(0.0, 0.0, height), rot=initial_rot),
     )
     cube_object = DeformableObject(cfg=cube_object_cfg)
-
+    cloner.usd_replicate(
+        stage=prim_utils.get_current_stage(),
+        sources=["/World/Table_0"],
+        destinations=["/World/Table_{}"],
+        env_ids=torch.arange(num_cubes),
+        positions=origins,
+    )
     return cube_object
 
 
diff --git a/source/isaaclab/test/sensors/test_multi_tiled_camera.py b/source/isaaclab/test/sensors/test_multi_tiled_camera.py
index 7408ae06b75..b2436572024 100644
--- a/source/isaaclab/test/sensors/test_multi_tiled_camera.py
+++ b/source/isaaclab/test/sensors/test_multi_tiled_camera.py
@@ -30,6 +30,24 @@
 
 import isaaclab.sim as sim_utils
 from isaaclab.sensors.camera import TiledCamera, TiledCameraCfg
+from isaaclab.scene import cloner
+
+
+def _replicate_group_origins(group_index: int, num_cameras: int) -> None:
+    """Replicate `/World/Origin_{i}_0` subtree to `/World/Origin_{i}_{1..N-1}` with preserved translations."""
+    stage = prim_utils.get_current_stage()
+    fmt = f"/World/Origin_{group_index}_{{}}"
+    get_translate = (
+        lambda prim_path: stage.GetPrimAtPath(prim_path).GetAttribute("xformOp:translate").Get()
+    )  # noqa: E731
+    positions = torch.tensor([get_translate(fmt.format(j)) for j in range(num_cameras)])
+    cloner.usd_replicate(
+        stage=stage,
+        sources=[fmt.format(0)],
+        destinations=[fmt],
+        env_ids=torch.arange(num_cameras),
+        positions=positions,
+    )
 
 
 @pytest.fixture()
@@ -82,8 +100,10 @@ def test_multi_tiled_camera_init(setup_camera):
 
         # Create camera
         camera_cfg = copy.deepcopy(camera_cfg)
-        camera_cfg.prim_path = f"/World/Origin_{i}.*/CameraSensor"
+        camera_cfg.prim_path = f"/World/Origin_{i}_.*/CameraSensor"
         camera = TiledCamera(camera_cfg)
+        # Ensure each origin in this group gets a camera
+        _replicate_group_origins(i, num_cameras_per_tiled_camera)
         tiled_cameras.append(camera)
 
         # Check simulation parameter is set correctly
@@ -178,8 +198,10 @@ def test_all_annotators_multi_tiled_camera(setup_camera):
         # Create camera
         camera_cfg = copy.deepcopy(camera_cfg)
         camera_cfg.data_types = all_annotator_types
-        camera_cfg.prim_path = f"/World/Origin_{i}.*/CameraSensor"
+        camera_cfg.prim_path = f"/World/Origin_{i}_.*/CameraSensor"
         camera = TiledCamera(camera_cfg)
+        # Ensure each origin in this group gets a camera
+        _replicate_group_origins(i, num_cameras_per_tiled_camera)
         tiled_cameras.append(camera)
 
         # Check simulation parameter is set correctly
@@ -278,9 +300,11 @@ def test_different_resolution_multi_tiled_camera(setup_camera):
 
         # Create camera
         camera_cfg = copy.deepcopy(camera_cfg)
-        camera_cfg.prim_path = f"/World/Origin_{i}.*/CameraSensor"
+        camera_cfg.prim_path = f"/World/Origin_{i}_.*/CameraSensor"
         camera_cfg.height, camera_cfg.width = resolutions[i]
         camera = TiledCamera(camera_cfg)
+        # Ensure each origin in this group gets a camera
+        _replicate_group_origins(i, num_cameras_per_tiled_camera)
         tiled_cameras.append(camera)
 
         # Check simulation parameter is set correctly
@@ -349,8 +373,10 @@ def test_frame_offset_multi_tiled_camera(setup_camera):
 
         # Create camera
         camera_cfg = copy.deepcopy(camera_cfg)
-        camera_cfg.prim_path = f"/World/Origin_{i}.*/CameraSensor"
+        camera_cfg.prim_path = f"/World/Origin_{i}_.*/CameraSensor"
         camera = TiledCamera(camera_cfg)
+        # Ensure each origin in this group gets a camera
+        _replicate_group_origins(i, num_cameras_per_tiled_camera)
         tiled_cameras.append(camera)
 
     # modify scene to be less stochastic
@@ -417,9 +443,10 @@ def test_frame_different_poses_multi_tiled_camera(setup_camera):
 
         # Create camera
         camera_cfg = copy.deepcopy(camera_cfg)
-        camera_cfg.prim_path = f"/World/Origin_{i}.*/CameraSensor"
+        camera_cfg.prim_path = f"/World/Origin_{i}_.*/CameraSensor"
         camera_cfg.offset = TiledCameraCfg.OffsetCfg(pos=positions[i], rot=rotations[i], convention="ros")
         camera = TiledCamera(camera_cfg)
+        _replicate_group_origins(i, num_cameras_per_tiled_camera)
         tiled_cameras.append(camera)
 
     # Play sim
diff --git a/source/isaaclab/test/sim/test_spawn_shapes.py b/source/isaaclab/test/sim/test_spawn_shapes.py
index c889a4ab818..bcfed417045 100644
--- a/source/isaaclab/test/sim/test_spawn_shapes.py
+++ b/source/isaaclab/test/sim/test_spawn_shapes.py
@@ -249,25 +249,18 @@ def test_spawn_cone_clones_invalid_paths(sim):
 
 def test_spawn_cone_clones(sim):
     """Test spawning of cone clones."""
-    num_clones = 10
-    for i in range(num_clones):
-        prim_utils.create_prim(f"/World/env_{i}", "Xform", translation=(i, i, 0))
+    prim_utils.create_prim("/World/env_0", "Xform", translation=(0, 0, 0))
     # Spawn cone on valid cloning path
     cfg = sim_utils.ConeCfg(radius=1.0, height=2.0, copy_from_source=True)
     prim = cfg.func("/World/env_.*/Cone", cfg)
     # Check validity
     assert prim.IsValid()
     assert prim_utils.get_prim_path(prim) == "/World/env_0/Cone"
-    # find matching prims
-    prims = prim_utils.find_matching_prim_paths("/World/env_*/Cone")
-    assert len(prims) == num_clones
 
 
 def test_spawn_cone_clone_with_all_props_global_material(sim):
     """Test spawning of cone clones with global material reference."""
-    num_clones = 10
-    for i in range(num_clones):
-        prim_utils.create_prim(f"/World/env_{i}", "Xform", translation=(i, i, 0))
+    prim_utils.create_prim("/World/env_0", "Xform", translation=(0, 0, 0))
     # Spawn cone on valid cloning path
     cfg = sim_utils.ConeCfg(
         radius=1.0,
@@ -284,9 +277,6 @@ def test_spawn_cone_clone_with_all_props_global_material(sim):
     # Check validity
     assert prim.IsValid()
     assert prim_utils.get_prim_path(prim) == "/World/env_0/Cone"
-    # find matching prims
-    prims = prim_utils.find_matching_prim_paths("/World/env_*/Cone")
-    assert len(prims) == num_clones
     # find matching material prims
     prims = prim_utils.find_matching_prim_paths("/Looks/visualMaterial.*")
     assert len(prims) == 1

From 2980f4a258463ce1d37f65c7c87d4bc9a70eed9b Mon Sep 17 00:00:00 2001
From: Octi Zhang <zhengyuz@nvidia.com>
Date: Wed, 5 Nov 2025 22:59:34 -0800
Subject: [PATCH 10/15] fix test stage in memory

---
 .../isaaclab/test/sim/test_stage_in_memory.py | 31 ++++++++-----------
 1 file changed, 13 insertions(+), 18 deletions(-)

diff --git a/source/isaaclab/test/sim/test_stage_in_memory.py b/source/isaaclab/test/sim/test_stage_in_memory.py
index d114185862a..15e0c3a1337 100644
--- a/source/isaaclab/test/sim/test_stage_in_memory.py
+++ b/source/isaaclab/test/sim/test_stage_in_memory.py
@@ -54,16 +54,12 @@ def test_stage_in_memory_with_shapes(sim):
     if isaac_sim_version < 5:
         pytest.skip("Stage in memory is not supported in this version of Isaac Sim")
 
-    # define parameters
-    num_clones = 10
-
     # grab stage in memory and set as current stage via the with statement
     stage_in_memory = sim.get_initial_stage()
     with sim_utils.use_stage(stage_in_memory):
         # create cloned cone stage
-        for i in range(num_clones):
-            prim_utils.create_prim(f"/World/env_{i}", "Xform", translation=(i, i, 0))
-
+        prim_utils.create_prim("/World/Cone", "Xform")
+        num_shape_prototypes = 3
         cfg = sim_utils.MultiAssetSpawnerCfg(
             assets_cfg=[
                 sim_utils.ConeCfg(
@@ -84,7 +80,7 @@ def test_stage_in_memory_with_shapes(sim):
             mass_props=sim_utils.MassPropertiesCfg(mass=1.0),
             collision_props=sim_utils.CollisionPropertiesCfg(),
         )
-        prim_path_regex = "/World/env_.*/Cone"
+        prim_path_regex = "/World/Cone/asset_.*"
         cfg.func(prim_path_regex, cfg)
 
         # verify stage is in memory
@@ -92,13 +88,13 @@ def test_stage_in_memory_with_shapes(sim):
 
         # verify prims exist in stage in memory
         prims = prim_utils.find_matching_prim_paths(prim_path_regex)
-        assert len(prims) == num_clones
+        assert len(prims) == num_shape_prototypes
 
         # verify prims do not exist in context stage
         context_stage = omni.usd.get_context().get_stage()
         with sim_utils.use_stage(context_stage):
             prims = prim_utils.find_matching_prim_paths(prim_path_regex)
-            assert len(prims) != num_clones
+            assert len(prims) != num_shape_prototypes
 
         # attach stage to context
         sim_utils.attach_stage_to_usd_context()
@@ -108,7 +104,7 @@ def test_stage_in_memory_with_shapes(sim):
 
     # verify prims now exist in context stage
     prims = prim_utils.find_matching_prim_paths(prim_path_regex)
-    assert len(prims) == num_clones
+    assert len(prims) == num_shape_prototypes
 
 
 def test_stage_in_memory_with_usds(sim):
@@ -120,7 +116,7 @@ def test_stage_in_memory_with_usds(sim):
         pytest.skip("Stage in memory is not supported in this version of Isaac Sim")
 
     # define parameters
-    num_clones = 10
+    num_robot_prototypes = 2
     usd_paths = [
         f"{ISAACLAB_NUCLEUS_DIR}/Robots/ANYbotics/ANYmal-C/anymal_c.usd",
         f"{ISAACLAB_NUCLEUS_DIR}/Robots/ANYbotics/ANYmal-D/anymal_d.usd",
@@ -129,9 +125,8 @@ def test_stage_in_memory_with_usds(sim):
     # grab stage in memory and set as current stage via the with statement
     stage_in_memory = sim.get_initial_stage()
     with sim_utils.use_stage(stage_in_memory):
-        # create cloned robot stage
-        for i in range(num_clones):
-            prim_utils.create_prim(f"/World/env_{i}", "Xform", translation=(i, i, 0))
+        # create robot stage
+        prim_utils.create_prim("/World/Robot", "Xform")
 
         cfg = sim_utils.MultiUsdFileCfg(
             usd_path=usd_paths,
@@ -150,7 +145,7 @@ def test_stage_in_memory_with_usds(sim):
             ),
             activate_contact_sensors=True,
         )
-        prim_path_regex = "/World/env_.*/Robot"
+        prim_path_regex = "/World/Robot/asset_.*"
         cfg.func(prim_path_regex, cfg)
 
         # verify stage is in memory
@@ -158,13 +153,13 @@ def test_stage_in_memory_with_usds(sim):
 
         # verify prims exist in stage in memory
         prims = prim_utils.find_matching_prim_paths(prim_path_regex)
-        assert len(prims) == num_clones
+        assert len(prims) == num_robot_prototypes
 
         # verify prims do not exist in context stage
         context_stage = omni.usd.get_context().get_stage()
         with sim_utils.use_stage(context_stage):
             prims = prim_utils.find_matching_prim_paths(prim_path_regex)
-            assert len(prims) != num_clones
+            assert len(prims) != num_robot_prototypes
 
         # attach stage to context
         sim_utils.attach_stage_to_usd_context()
@@ -174,7 +169,7 @@ def test_stage_in_memory_with_usds(sim):
 
     # verify prims now exist in context stage
     prims = prim_utils.find_matching_prim_paths(prim_path_regex)
-    assert len(prims) == num_clones
+    assert len(prims) == num_robot_prototypes
 
 
 def test_stage_in_memory_with_clone_in_fabric(sim):

From f5917b66fe86a9e676cc0fdb247bd2687f7e9b45 Mon Sep 17 00:00:00 2001
From: Octi Zhang <zhengyuz@nvidia.com>
Date: Thu, 6 Nov 2025 00:32:05 -0800
Subject: [PATCH 11/15] last bit of bug fixes

---
 source/isaaclab/isaaclab/scene/interactive_scene.py | 4 ++--
 source/isaaclab_tasks/test/env_test_utils.py        | 3 +++
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/source/isaaclab/isaaclab/scene/interactive_scene.py b/source/isaaclab/isaaclab/scene/interactive_scene.py
index cca0e09ee8f..5c3b6badf69 100644
--- a/source/isaaclab/isaaclab/scene/interactive_scene.py
+++ b/source/isaaclab/isaaclab/scene/interactive_scene.py
@@ -162,7 +162,7 @@ def __init__(self, cfg: InteractiveSceneCfg):
                 filter_regex = prim_path.replace(self.cloner_cfg.template_root, self.env_regex_ns)
                 self._global_prim_paths.extend(sim_utils.find_matching_prim_paths(filter_regex))
 
-            self.clone_environments()
+            self.clone_environments(copy_from_source=(not self.cfg.replicate_physics))
             if self.cfg.filter_collisions:
                 self.filter_collisions(self._global_prim_paths)
 
@@ -181,7 +181,7 @@ def clone_environments(self, copy_from_source: bool = False):
             prim.CreateAttribute("physxScene:envIdInBoundsBitCount", Sdf.ValueTypeNames.Int).Set(4)
 
         if self._is_scene_setup_from_cfg():
-            self.cloner_cfg.clone_physx = copy_from_source
+            self.cloner_cfg.clone_physx = not copy_from_source
             cloner.clone_from_template(self.stage, num_clones=self.num_envs, template_clone_cfg=self.cloner_cfg)
         else:
             mapping = torch.ones((1, self.num_envs), device=self.device, dtype=torch.bool)
diff --git a/source/isaaclab_tasks/test/env_test_utils.py b/source/isaaclab_tasks/test/env_test_utils.py
index 1034fd9ac92..60b6c75f0d6 100644
--- a/source/isaaclab_tasks/test/env_test_utils.py
+++ b/source/isaaclab_tasks/test/env_test_utils.py
@@ -134,6 +134,9 @@ def _run_environments(
     if task_name in ["Isaac-AutoMate-Assembly-Direct-v0", "Isaac-AutoMate-Disassembly-Direct-v0"]:
         return
 
+    if create_stage_in_memory and "Repose-Cube" in task_name:
+        return
+
     # Check if this is the teddy bear environment and if it's being called from the right test file
     if task_name == "Isaac-Lift-Teddy-Bear-Franka-IK-Abs-v0":
         # Get the calling frame to check which test file is calling this function

From 42673bd11304775c34e21093ab96717a99894cd2 Mon Sep 17 00:00:00 2001
From: Octi Zhang <zhengyuz@nvidia.com>
Date: Thu, 6 Nov 2025 00:39:01 -0800
Subject: [PATCH 12/15] pass precommit

---
 source/isaaclab/test/assets/test_articulation.py        | 3 ++-
 source/isaaclab/test/assets/test_deformable_object.py   | 2 +-
 source/isaaclab/test/sensors/test_multi_tiled_camera.py | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/source/isaaclab/test/assets/test_articulation.py b/source/isaaclab/test/assets/test_articulation.py
index 2dafcd8271c..e5d2b79f07b 100644
--- a/source/isaaclab/test/assets/test_articulation.py
+++ b/source/isaaclab/test/assets/test_articulation.py
@@ -23,7 +23,7 @@
 import isaacsim.core.utils.prims as prim_utils
 import pytest
 from isaacsim.core.version import get_version
-from isaaclab.scene import cloner
+
 import isaaclab.sim as sim_utils
 import isaaclab.utils.math as math_utils
 import isaaclab.utils.string as string_utils
@@ -31,6 +31,7 @@
 from isaaclab.assets import Articulation, ArticulationCfg
 from isaaclab.envs.mdp.terminations import joint_effort_out_of_limit
 from isaaclab.managers import SceneEntityCfg
+from isaaclab.scene import cloner
 from isaaclab.sim import build_simulation_context
 from isaaclab.utils.assets import ISAAC_NUCLEUS_DIR
 
diff --git a/source/isaaclab/test/assets/test_deformable_object.py b/source/isaaclab/test/assets/test_deformable_object.py
index 1c983edf6d7..8184f73d832 100644
--- a/source/isaaclab/test/assets/test_deformable_object.py
+++ b/source/isaaclab/test/assets/test_deformable_object.py
@@ -26,8 +26,8 @@
 
 import isaaclab.sim as sim_utils
 import isaaclab.utils.math as math_utils
-from isaaclab.scene import cloner
 from isaaclab.assets import DeformableObject, DeformableObjectCfg
+from isaaclab.scene import cloner
 from isaaclab.sim import build_simulation_context
 
 
diff --git a/source/isaaclab/test/sensors/test_multi_tiled_camera.py b/source/isaaclab/test/sensors/test_multi_tiled_camera.py
index b2436572024..7e2dbd2fdea 100644
--- a/source/isaaclab/test/sensors/test_multi_tiled_camera.py
+++ b/source/isaaclab/test/sensors/test_multi_tiled_camera.py
@@ -29,8 +29,8 @@
 from pxr import Gf, UsdGeom
 
 import isaaclab.sim as sim_utils
-from isaaclab.sensors.camera import TiledCamera, TiledCameraCfg
 from isaaclab.scene import cloner
+from isaaclab.sensors.camera import TiledCamera, TiledCameraCfg
 
 
 def _replicate_group_origins(group_index: int, num_cameras: int) -> None:

From 8ebcad8c0e3fd0b15473688a65612b8d65711266 Mon Sep 17 00:00:00 2001
From: Octi Zhang <zhengyuz@nvidia.com>
Date: Thu, 6 Nov 2025 12:31:27 -0800
Subject: [PATCH 13/15] resolve flaky test

---
 source/isaaclab/isaaclab/scene/interactive_scene.py | 1 -
 source/isaaclab/test/sensors/test_contact_sensor.py | 4 +++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/source/isaaclab/isaaclab/scene/interactive_scene.py b/source/isaaclab/isaaclab/scene/interactive_scene.py
index 5c3b6badf69..448b99c8d2a 100644
--- a/source/isaaclab/isaaclab/scene/interactive_scene.py
+++ b/source/isaaclab/isaaclab/scene/interactive_scene.py
@@ -652,7 +652,6 @@ def _add_entities_from_cfg(self):
                 continue
             # resolve regex
             require_clone = False
-            asset_cfg = asset_cfg.copy()
             if hasattr(asset_cfg, "prim_path"):
                 # In order to compose cloner behavior more flexibly, we ask each spawner to spawn prototypes in
                 # prepared /World/template path, once all template is ready, cloner can determine what rules to follow
diff --git a/source/isaaclab/test/sensors/test_contact_sensor.py b/source/isaaclab/test/sensors/test_contact_sensor.py
index 0a1187c80ba..f01ead8bf88 100644
--- a/source/isaaclab/test/sensors/test_contact_sensor.py
+++ b/source/isaaclab/test/sensors/test_contact_sensor.py
@@ -467,7 +467,7 @@ def _run_contact_sensor_test(
 
                     scene_cfg = ContactSensorSceneCfg(num_envs=1, env_spacing=1.0, lazy_sensor_update=False)
                     scene_cfg.terrain = terrain
-                    scene_cfg.shape = shape_cfg
+                    scene_cfg.shape = shape_cfg.copy()
                     test_contact_position = False
                     if (type(shape_cfg.spawn) is sim_utils.SphereCfg) and (terrain.terrain_type == "plane"):
                         test_contact_position = True
@@ -492,6 +492,8 @@ def _run_contact_sensor_test(
                         track_contact_points=track_contact_points,
                         filter_prim_paths_expr=filter_prim_paths_expr,
                     )
+                    # replicating physx will mess up the test......
+                    scene_cfg.replicate_physics = False
                     scene = InteractiveScene(scene_cfg)
 
                     # Play the simulation

From c1e305234376fbf4f8cb8c500d2bdb26e312efbd Mon Sep 17 00:00:00 2001
From: Octi Zhang <zhengyuz@nvidia.com>
Date: Thu, 6 Nov 2025 12:38:25 -0800
Subject: [PATCH 14/15] add cloning length check

---
 source/isaaclab/isaaclab/scene/cloner.py      | 79 ++++++++++---------
 .../isaaclab/scene/interactive_scene.py       |  6 +-
 2 files changed, 44 insertions(+), 41 deletions(-)

diff --git a/source/isaaclab/isaaclab/scene/cloner.py b/source/isaaclab/isaaclab/scene/cloner.py
index 2a5a6e4b9ea..bc15048775f 100644
--- a/source/isaaclab/isaaclab/scene/cloner.py
+++ b/source/isaaclab/isaaclab/scene/cloner.py
@@ -112,46 +112,47 @@ def clone_from_template(stage: Usd.Stage, num_clones: int, template_clone_cfg: T
         cfg.template_root,
         predicate=lambda prim: str(prim.GetPath()).split("/")[-1].startswith(prototype_id),
     )
-    prototype_root_set = {"/".join(str(prototype.GetPath()).split("/")[:-1]) for prototype in prototypes}
-    for prototype_root in prototype_root_set:
-        protos = sim_utils.find_matching_prim_paths(f"{prototype_root}/.*")
-        protos = [proto for proto in protos if proto.split("/")[-1].startswith(prototype_id)]
-        m = torch.zeros((len(protos), num_clones), dtype=torch.bool, device=cfg.device)
-        # Optionally select prototypes randomly per environment; else round-robin by modulo
-        if cfg.random_heterogenous_cloning:
-            rand_idx = torch.randint(len(protos), (num_clones,), device=cfg.device)
-            m[rand_idx, world_indices] = True
+    if len(prototypes) > 0:
+        prototype_root_set = {"/".join(str(prototype.GetPath()).split("/")[:-1]) for prototype in prototypes}
+        for prototype_root in prototype_root_set:
+            protos = sim_utils.find_matching_prim_paths(f"{prototype_root}/.*")
+            protos = [proto for proto in protos if proto.split("/")[-1].startswith(prototype_id)]
+            m = torch.zeros((len(protos), num_clones), dtype=torch.bool, device=cfg.device)
+            # Optionally select prototypes randomly per environment; else round-robin by modulo
+            if cfg.random_heterogenous_cloning:
+                rand_idx = torch.randint(len(protos), (num_clones,), device=cfg.device)
+                m[rand_idx, world_indices] = True
+            else:
+                m[world_indices % len(protos), world_indices] = True
+
+            clone_plan["src"].extend(protos)
+            clone_plan["dest"].extend([prototype_root.replace(cfg.template_root, clone_path_fmt)] * len(protos))
+            clone_plan["mapping"] = torch.cat((clone_plan["mapping"].reshape(-1, m.size(1)), m), dim=0)
+
+        proto_idx = clone_plan["mapping"].to(torch.int32).argmax(dim=1)
+        proto_mask = torch.zeros_like(clone_plan["mapping"])
+        proto_mask.scatter_(1, proto_idx.view(-1, 1).to(torch.long), clone_plan["mapping"].any(dim=1, keepdim=True))
+        usd_replicate(stage, clone_plan["src"], clone_plan["dest"], world_indices, proto_mask)
+        stage.GetPrimAtPath(cfg.template_root).SetActive(False)
+
+        # If all prototypes map to env_0, clone whole env_0 to all envs; else clone per-object
+        if torch.all(proto_idx == 0):
+            replicate_args = [clone_path_fmt.format(0)], [clone_path_fmt], world_indices, clone_plan["mapping"]
+            if cfg.clone_usd:
+                # parse env_origins directly from clone_path
+                get_translate = (
+                    lambda prim_path: stage.GetPrimAtPath(prim_path).GetAttribute("xformOp:translate").Get()
+                )  # noqa: E731
+                positions = torch.tensor([get_translate(clone_path_fmt.format(i)) for i in world_indices])
+                usd_replicate(stage, *replicate_args, positions=positions)
         else:
-            m[world_indices % len(protos), world_indices] = True
-
-        clone_plan["src"].extend(protos)
-        clone_plan["dest"].extend([prototype_root.replace(cfg.template_root, clone_path_fmt)] * len(protos))
-        clone_plan["mapping"] = torch.cat((clone_plan["mapping"].reshape(-1, m.size(1)), m), dim=0)
-
-    proto_idx = clone_plan["mapping"].to(torch.int32).argmax(dim=1)
-    proto_mask = torch.zeros_like(clone_plan["mapping"])
-    proto_mask.scatter_(1, proto_idx.view(-1, 1).to(torch.long), clone_plan["mapping"].any(dim=1, keepdim=True))
-    usd_replicate(stage, clone_plan["src"], clone_plan["dest"], world_indices, proto_mask)
-    stage.GetPrimAtPath(cfg.template_root).SetActive(False)
-
-    # If all prototypes map to env_0, clone whole env_0 to all envs; else clone per-object
-    if torch.all(proto_idx == 0):
-        replicate_args = [clone_path_fmt.format(0)], [clone_path_fmt], world_indices, clone_plan["mapping"]
-        if cfg.clone_usd:
-            # parse env_origins directly from clone_path
-            get_translate = (
-                lambda prim_path: stage.GetPrimAtPath(prim_path).GetAttribute("xformOp:translate").Get()
-            )  # noqa: E731
-            positions = torch.tensor([get_translate(clone_path_fmt.format(i)) for i in world_indices])
-            usd_replicate(stage, *replicate_args, positions=positions)
-    else:
-        src = [tpl.format(int(idx)) for tpl, idx in zip(clone_plan["dest"], proto_idx.tolist())]
-        replicate_args = src, clone_plan["dest"], world_indices, clone_plan["mapping"]
-        if cfg.clone_usd:
-            usd_replicate(stage, *replicate_args)
-
-    if cfg.clone_physx:
-        physx_replicate(stage, *replicate_args, use_fabric=cfg.clone_in_fabric)
+            src = [tpl.format(int(idx)) for tpl, idx in zip(clone_plan["dest"], proto_idx.tolist())]
+            replicate_args = src, clone_plan["dest"], world_indices, clone_plan["mapping"]
+            if cfg.clone_usd:
+                usd_replicate(stage, *replicate_args)
+
+        if cfg.clone_physx:
+            physx_replicate(stage, *replicate_args, use_fabric=cfg.clone_in_fabric)
 
 
 def usd_replicate(
diff --git a/source/isaaclab/isaaclab/scene/interactive_scene.py b/source/isaaclab/isaaclab/scene/interactive_scene.py
index 448b99c8d2a..9681f6fa664 100644
--- a/source/isaaclab/isaaclab/scene/interactive_scene.py
+++ b/source/isaaclab/isaaclab/scene/interactive_scene.py
@@ -136,8 +136,6 @@ def __init__(self, cfg: InteractiveSceneCfg):
         self._physics_scene_path = None
         # prepare cloner for environment replication
         self.env_prim_paths = [f"{self.env_ns}/env_{i}" for i in range(self.cfg.num_envs)]
-        # create source prim
-        self.stage.DefinePrim(self.env_prim_paths[0], "Xform")
 
         self.cloner_cfg = cloner.TemplateCloneCfg(
             clone_regex=self.env_regex_ns,
@@ -145,6 +143,10 @@ def __init__(self, cfg: InteractiveSceneCfg):
             clone_in_fabric=self.cfg.clone_in_fabric,
             device=self.device,
         )
+
+        # create source prim
+        self.stage.DefinePrim(self.env_prim_paths[0], "Xform")
+        self.stage.DefinePrim(self.cloner_cfg.template_root, "Xform")
         self.env_fmt = self.env_regex_ns.replace(".*", "{}")
         # allocate env indices
         self._ALL_INDICES = torch.arange(self.cfg.num_envs, dtype=torch.long, device=self.device)

From 3d31265ef91e8687e95cbb9f2a4e5cf9d7dd5026 Mon Sep 17 00:00:00 2001
From: Octi Zhang <zhengyuz@nvidia.com>
Date: Thu, 6 Nov 2025 16:27:26 -0800
Subject: [PATCH 15/15] remove clone in fabric

---
 source/isaaclab/test/sim/test_stage_in_memory.py              | 1 -
 .../direct/allegro_hand/allegro_hand_env_cfg.py               | 4 +---
 source/isaaclab_tasks/isaaclab_tasks/direct/ant/ant_env.py    | 4 +---
 .../isaaclab_tasks/direct/cartpole/cartpole_env.py            | 4 +---
 .../isaaclab_tasks/direct/factory/factory_env_cfg.py          | 2 +-
 .../direct/franka_cabinet/franka_cabinet_env.py               | 4 +---
 .../isaaclab_tasks/direct/humanoid/humanoid_env.py            | 4 +---
 .../isaaclab_tasks/direct/quadcopter/quadcopter_env.py        | 4 +---
 .../isaaclab_tasks/direct/shadow_hand/shadow_hand_env_cfg.py  | 4 +---
 .../isaaclab_tasks/manager_based/classic/ant/ant_env_cfg.py   | 2 +-
 .../manager_based/classic/cartpole/cartpole_env_cfg.py        | 2 +-
 .../manager_based/classic/humanoid/humanoid_env_cfg.py        | 2 +-
 12 files changed, 11 insertions(+), 26 deletions(-)

diff --git a/source/isaaclab/test/sim/test_stage_in_memory.py b/source/isaaclab/test/sim/test_stage_in_memory.py
index 15e0c3a1337..06578729863 100644
--- a/source/isaaclab/test/sim/test_stage_in_memory.py
+++ b/source/isaaclab/test/sim/test_stage_in_memory.py
@@ -207,7 +207,6 @@ def test_stage_in_memory_with_clone_in_fabric(sim):
             base_env_path=base_env_path,
             prim_paths=target_paths,
             replicate_physics=True,
-            clone_in_fabric=True,
         )
         prim_path_regex = "/World/envs/env_.*"
 
diff --git a/source/isaaclab_tasks/isaaclab_tasks/direct/allegro_hand/allegro_hand_env_cfg.py b/source/isaaclab_tasks/isaaclab_tasks/direct/allegro_hand/allegro_hand_env_cfg.py
index 06b470ca61f..09d24491517 100644
--- a/source/isaaclab_tasks/isaaclab_tasks/direct/allegro_hand/allegro_hand_env_cfg.py
+++ b/source/isaaclab_tasks/isaaclab_tasks/direct/allegro_hand/allegro_hand_env_cfg.py
@@ -98,9 +98,7 @@ class AllegroHandEnvCfg(DirectRLEnvCfg):
         },
     )
     # scene
-    scene: InteractiveSceneCfg = InteractiveSceneCfg(
-        num_envs=8192, env_spacing=0.75, replicate_physics=True, clone_in_fabric=True
-    )
+    scene: InteractiveSceneCfg = InteractiveSceneCfg(num_envs=8192, env_spacing=0.75, replicate_physics=True)
     # reset
     reset_position_noise = 0.01  # range of position at reset
     reset_dof_pos_noise = 0.2  # range of dof pos at reset
diff --git a/source/isaaclab_tasks/isaaclab_tasks/direct/ant/ant_env.py b/source/isaaclab_tasks/isaaclab_tasks/direct/ant/ant_env.py
index c63b42acb38..aabfc13bd3f 100644
--- a/source/isaaclab_tasks/isaaclab_tasks/direct/ant/ant_env.py
+++ b/source/isaaclab_tasks/isaaclab_tasks/direct/ant/ant_env.py
@@ -45,9 +45,7 @@ class AntEnvCfg(DirectRLEnvCfg):
     )
 
     # scene
-    scene: InteractiveSceneCfg = InteractiveSceneCfg(
-        num_envs=4096, env_spacing=4.0, replicate_physics=True, clone_in_fabric=True
-    )
+    scene: InteractiveSceneCfg = InteractiveSceneCfg(num_envs=4096, env_spacing=4.0, replicate_physics=True)
 
     # robot
     robot: ArticulationCfg = ANT_CFG.replace(prim_path="/World/envs/env_.*/Robot")
diff --git a/source/isaaclab_tasks/isaaclab_tasks/direct/cartpole/cartpole_env.py b/source/isaaclab_tasks/isaaclab_tasks/direct/cartpole/cartpole_env.py
index d9e84581ed9..cd7da5ff56f 100644
--- a/source/isaaclab_tasks/isaaclab_tasks/direct/cartpole/cartpole_env.py
+++ b/source/isaaclab_tasks/isaaclab_tasks/direct/cartpole/cartpole_env.py
@@ -40,9 +40,7 @@ class CartpoleEnvCfg(DirectRLEnvCfg):
     pole_dof_name = "cart_to_pole"
 
     # scene
-    scene: InteractiveSceneCfg = InteractiveSceneCfg(
-        num_envs=4096, env_spacing=4.0, replicate_physics=True, clone_in_fabric=True
-    )
+    scene: InteractiveSceneCfg = InteractiveSceneCfg(num_envs=4096, env_spacing=4.0, replicate_physics=True)
 
     # reset
     max_cart_pos = 3.0  # the cart is reset if it exceeds that position [m]
diff --git a/source/isaaclab_tasks/isaaclab_tasks/direct/factory/factory_env_cfg.py b/source/isaaclab_tasks/isaaclab_tasks/direct/factory/factory_env_cfg.py
index 72a08b06941..66a4faaf69e 100644
--- a/source/isaaclab_tasks/isaaclab_tasks/direct/factory/factory_env_cfg.py
+++ b/source/isaaclab_tasks/isaaclab_tasks/direct/factory/factory_env_cfg.py
@@ -116,7 +116,7 @@ class FactoryEnvCfg(DirectRLEnvCfg):
         ),
     )
 
-    scene: InteractiveSceneCfg = InteractiveSceneCfg(num_envs=128, env_spacing=2.0, clone_in_fabric=True)
+    scene: InteractiveSceneCfg = InteractiveSceneCfg(num_envs=128, env_spacing=2.0)
 
     robot = ArticulationCfg(
         prim_path="/World/envs/env_.*/Robot",
diff --git a/source/isaaclab_tasks/isaaclab_tasks/direct/franka_cabinet/franka_cabinet_env.py b/source/isaaclab_tasks/isaaclab_tasks/direct/franka_cabinet/franka_cabinet_env.py
index 53dc7cf8ffb..cd1b0648578 100644
--- a/source/isaaclab_tasks/isaaclab_tasks/direct/franka_cabinet/franka_cabinet_env.py
+++ b/source/isaaclab_tasks/isaaclab_tasks/direct/franka_cabinet/franka_cabinet_env.py
@@ -46,9 +46,7 @@ class FrankaCabinetEnvCfg(DirectRLEnvCfg):
     )
 
     # scene
-    scene: InteractiveSceneCfg = InteractiveSceneCfg(
-        num_envs=4096, env_spacing=3.0, replicate_physics=True, clone_in_fabric=True
-    )
+    scene: InteractiveSceneCfg = InteractiveSceneCfg(num_envs=4096, env_spacing=3.0, replicate_physics=True)
 
     # robot
     robot = ArticulationCfg(
diff --git a/source/isaaclab_tasks/isaaclab_tasks/direct/humanoid/humanoid_env.py b/source/isaaclab_tasks/isaaclab_tasks/direct/humanoid/humanoid_env.py
index 6c0ad919080..5063c12b6a6 100644
--- a/source/isaaclab_tasks/isaaclab_tasks/direct/humanoid/humanoid_env.py
+++ b/source/isaaclab_tasks/isaaclab_tasks/direct/humanoid/humanoid_env.py
@@ -45,9 +45,7 @@ class HumanoidEnvCfg(DirectRLEnvCfg):
     )
 
     # scene
-    scene: InteractiveSceneCfg = InteractiveSceneCfg(
-        num_envs=4096, env_spacing=4.0, replicate_physics=True, clone_in_fabric=True
-    )
+    scene: InteractiveSceneCfg = InteractiveSceneCfg(num_envs=4096, env_spacing=4.0, replicate_physics=True)
 
     # robot
     robot: ArticulationCfg = HUMANOID_CFG.replace(prim_path="/World/envs/env_.*/Robot")
diff --git a/source/isaaclab_tasks/isaaclab_tasks/direct/quadcopter/quadcopter_env.py b/source/isaaclab_tasks/isaaclab_tasks/direct/quadcopter/quadcopter_env.py
index a80ce681bde..0d45be66499 100644
--- a/source/isaaclab_tasks/isaaclab_tasks/direct/quadcopter/quadcopter_env.py
+++ b/source/isaaclab_tasks/isaaclab_tasks/direct/quadcopter/quadcopter_env.py
@@ -85,9 +85,7 @@ class QuadcopterEnvCfg(DirectRLEnvCfg):
     )
 
     # scene
-    scene: InteractiveSceneCfg = InteractiveSceneCfg(
-        num_envs=4096, env_spacing=2.5, replicate_physics=True, clone_in_fabric=True
-    )
+    scene: InteractiveSceneCfg = InteractiveSceneCfg(num_envs=4096, env_spacing=2.5, replicate_physics=True)
 
     # robot
     robot: ArticulationCfg = CRAZYFLIE_CFG.replace(prim_path="/World/envs/env_.*/Robot")
diff --git a/source/isaaclab_tasks/isaaclab_tasks/direct/shadow_hand/shadow_hand_env_cfg.py b/source/isaaclab_tasks/isaaclab_tasks/direct/shadow_hand/shadow_hand_env_cfg.py
index feb2fb29887..65318203724 100644
--- a/source/isaaclab_tasks/isaaclab_tasks/direct/shadow_hand/shadow_hand_env_cfg.py
+++ b/source/isaaclab_tasks/isaaclab_tasks/direct/shadow_hand/shadow_hand_env_cfg.py
@@ -205,9 +205,7 @@ class ShadowHandEnvCfg(DirectRLEnvCfg):
         },
     )
     # scene
-    scene: InteractiveSceneCfg = InteractiveSceneCfg(
-        num_envs=8192, env_spacing=0.75, replicate_physics=True, clone_in_fabric=True
-    )
+    scene: InteractiveSceneCfg = InteractiveSceneCfg(num_envs=8192, env_spacing=0.75, replicate_physics=True)
 
     # reset
     reset_position_noise = 0.01  # range of position at reset
diff --git a/source/isaaclab_tasks/isaaclab_tasks/manager_based/classic/ant/ant_env_cfg.py b/source/isaaclab_tasks/isaaclab_tasks/manager_based/classic/ant/ant_env_cfg.py
index ed1f39a4849..001d66cfd6a 100644
--- a/source/isaaclab_tasks/isaaclab_tasks/manager_based/classic/ant/ant_env_cfg.py
+++ b/source/isaaclab_tasks/isaaclab_tasks/manager_based/classic/ant/ant_env_cfg.py
@@ -160,7 +160,7 @@ class AntEnvCfg(ManagerBasedRLEnvCfg):
     """Configuration for the MuJoCo-style Ant walking environment."""
 
     # Scene settings
-    scene: MySceneCfg = MySceneCfg(num_envs=4096, env_spacing=5.0, clone_in_fabric=True)
+    scene: MySceneCfg = MySceneCfg(num_envs=4096, env_spacing=5.0)
     # Basic settings
     observations: ObservationsCfg = ObservationsCfg()
     actions: ActionsCfg = ActionsCfg()
diff --git a/source/isaaclab_tasks/isaaclab_tasks/manager_based/classic/cartpole/cartpole_env_cfg.py b/source/isaaclab_tasks/isaaclab_tasks/manager_based/classic/cartpole/cartpole_env_cfg.py
index f452efda276..b1246ecc621 100644
--- a/source/isaaclab_tasks/isaaclab_tasks/manager_based/classic/cartpole/cartpole_env_cfg.py
+++ b/source/isaaclab_tasks/isaaclab_tasks/manager_based/classic/cartpole/cartpole_env_cfg.py
@@ -159,7 +159,7 @@ class CartpoleEnvCfg(ManagerBasedRLEnvCfg):
     """Configuration for the cartpole environment."""
 
     # Scene settings
-    scene: CartpoleSceneCfg = CartpoleSceneCfg(num_envs=4096, env_spacing=4.0, clone_in_fabric=True)
+    scene: CartpoleSceneCfg = CartpoleSceneCfg(num_envs=4096, env_spacing=4.0)
     # Basic settings
     observations: ObservationsCfg = ObservationsCfg()
     actions: ActionsCfg = ActionsCfg()
diff --git a/source/isaaclab_tasks/isaaclab_tasks/manager_based/classic/humanoid/humanoid_env_cfg.py b/source/isaaclab_tasks/isaaclab_tasks/manager_based/classic/humanoid/humanoid_env_cfg.py
index b622f10433e..44abe62b818 100644
--- a/source/isaaclab_tasks/isaaclab_tasks/manager_based/classic/humanoid/humanoid_env_cfg.py
+++ b/source/isaaclab_tasks/isaaclab_tasks/manager_based/classic/humanoid/humanoid_env_cfg.py
@@ -197,7 +197,7 @@ class HumanoidEnvCfg(ManagerBasedRLEnvCfg):
     """Configuration for the MuJoCo-style Humanoid walking environment."""
 
     # Scene settings
-    scene: MySceneCfg = MySceneCfg(num_envs=4096, env_spacing=5.0, clone_in_fabric=True)
+    scene: MySceneCfg = MySceneCfg(num_envs=4096, env_spacing=5.0)
     # Basic settings
     observations: ObservationsCfg = ObservationsCfg()
     actions: ActionsCfg = ActionsCfg()