Add files using upload-large-folder tool

mjlab/docs/source/_static/css/custom.css

@@ -0,0 +1,172 @@
+/*
+ * PyData Sphinx Theme — Option A (Indigo/Teal)
+ * Aesthetic: modern lab — indigo primary, teal accent, neutral grays
+ */
+
+/* LIGHT THEME */
+html[data-theme="light"] {
+    /* Brand */
+    --pst-color-primary: #4F46E5;
+    /* Indigo-600 */
+    --pst-color-secondary: #14B8A6;
+    /* Teal-500 */
+    --pst-color-secondary-highlight: #2DD4BF;
+    /* Teal-400 */
+
+    /* Links / code links */
+    --pst-color-inline-code-links: #0D9488;
+    /* Teal-600 */
+    --pst-color-link: var(--pst-color-primary);
+    --pst-color-link-hover: #4338CA;
+    /* Indigo-700 */
+
+    /* Semantic */
+    --pst-color-info: var(--pst-color-secondary);
+    --pst-color-info-highlight: var(--pst-color-secondary);
+    --pst-color-info-bg: #D1FAE5;
+    /* Teal-50 */
+    --pst-color-attention: #F59E0B;
+    /* Amber-500 */
+    --pst-color-target: #EEF2FF;
+    /* Indigo-50 */
+
+    /* Text */
+    --pst-color-text-base: #1F2937;
+    /* Slate-800 */
+    --pst-color-text-muted: #6B7280;
+    /* Slate-500 */
+
+    /* Surfaces */
+    --pst-color-background: #FFFFFF;
+    --pst-color-on-background: #FFFFFF;
+    --pst-color-surface: #F3F4F6;
+    /* Gray-100 */
+    --pst-color-on-surface: #E5E7EB;
+    /* Gray-200 */
+    --pst-color-shadow: #D1D5DB;
+    --pst-color-border: #E5E7EB;
+
+    /* Inline code */
+    --pst-color-inline-code: #0D9488;
+    /* Teal-600 */
+
+    /* Tables / hovers */
+    --pst-color-table-row-hover-bg: #EEF2FF;
+    /* Indigo-50 */
+
+    /* Accent (sparingly) */
+    --pst-color-accent: #10B981;
+    /* Emerald-500 */
+}
+
+/* DARK THEME */
+html[data-theme="dark"] {
+    /* Brand */
+    --pst-color-primary: #A5B4FC;
+    /* Indigo-300/200 mix for readability */
+    --pst-color-secondary: #5EEAD4;
+    /* Teal-300 */
+    --pst-color-secondary-highlight: #2DD4BF;
+
+    /* Links / code links */
+    --pst-color-inline-code-links: #93C5FD;
+    /* Indigo-300 */
+    --pst-color-link: var(--pst-color-primary);
+    --pst-color-link-hover: #818CF8;
+    /* Indigo-400 */
+
+    /* Semantic */
+    --pst-color-info: var(--pst-color-secondary);
+    --pst-color-info-highlight: var(--pst-color-secondary);
+    --pst-color-info-bg: #042F2E;
+    /* Deep teal */
+    --pst-color-attention: #F59E0B;
+    --pst-color-target: #1B1C2A;
+    /* Indigo-tinted surface */
+
+    /* Text */
+    --pst-color-text-base: #E5E7EB;
+    /* Gray-200 */
+    --pst-color-text-muted: #9CA3AF;
+    /* Gray-400 */
+
+    /* Surfaces */
+    --pst-color-background: #0B0C10;
+    /* Deep graphite */
+    --pst-color-on-background: #12131A;
+    --pst-color-surface: #111827;
+    /* Slate-900 */
+    --pst-color-on-surface: #1F2937;
+    /* Slate-800 */
+    --pst-color-shadow: #0F172A;
+    --pst-color-border: #2A2D3A;
+
+    /* Inline code */
+    --pst-color-inline-code: #5EEAD4;
+    /* Teal-300 */
+
+    /* Tables / hovers */
+    --pst-color-table-row-hover-bg: #1B1C2A;
+
+    /* Accent */
+    --pst-color-accent: #34D399;
+    /* Emerald-400 */
+}
+
+/* General tweaks */
+a {
+    text-decoration: none !important;
+}
+
+.bd-header-announcement a,
+.bd-header-version-warning a {
+    color: #5EEAD4;
+}
+
+.form-control {
+    border-radius: 0 !important;
+    border: none !important;
+    outline: none !important;
+}
+
+.navbar-brand,
+.navbar-icon-links {
+    padding-top: 0rem !important;
+    padding-bottom: 0rem !important;
+}
+
+/* Version switcher */
+.sidebar-version-switcher {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.4rem 1rem;
+    margin-bottom: 0.5rem;
+}
+
+.sidebar-version-label {
+    font-size: 0.8rem;
+    font-weight: 600;
+    color: var(--pst-color-text-muted);
+    white-space: nowrap;
+}
+
+.sidebar-version-select {
+    flex: 1;
+    font-size: 0.8rem;
+    padding: 0.25rem 0.5rem;
+    border: 1px solid var(--pst-color-border);
+    border-radius: 4px;
+    background: var(--pst-color-background);
+    color: var(--pst-color-text-base);
+    cursor: pointer;
+}
+
+.sidebar-version-select:hover {
+    border-color: var(--pst-color-primary);
+}
+
+/* Sidebar section spacing */
+.bd-sidebar .navbar-icon-links {
+    padding: 0 1rem 0.25rem !important;
+}

mjlab/docs/source/api/actuator.rst

@@ -0,0 +1,10 @@
+mjlab.actuator
+==============
+
+Actuator implementations for motor control.
+
+.. automodule:: mjlab.actuator
+   :members:
+   :undoc-members:
+   :imported-members:
+   :show-inheritance:

mjlab/docs/source/api/entity.rst

@@ -0,0 +1,10 @@
+mjlab.entity
+============
+
+Entity models and data structures.
+
+.. automodule:: mjlab.entity
+   :members:
+   :undoc-members:
+   :imported-members:
+   :show-inheritance:

mjlab/docs/source/api/envs.rst

@@ -0,0 +1,10 @@
+mjlab.envs
+==========
+
+RL environment classes.
+
+.. automodule:: mjlab.envs
+   :members:
+   :undoc-members:
+   :imported-members:
+   :show-inheritance:

mjlab/docs/source/api/index.rst

@@ -0,0 +1,16 @@
+API Reference
+=============
+
+This section provides detailed API documentation for all public modules in mjlab.
+
+.. toctree::
+   :maxdepth: 1
+
+   envs
+   scene
+   sim
+   entity
+   actuator
+   sensor
+   managers
+   terrains

mjlab/docs/source/api/managers.rst

@@ -0,0 +1,10 @@
+mjlab.managers
+==============
+
+Environment managers for actions, observations, rewards, terminations, commands, and curriculum.
+
+.. automodule:: mjlab.managers
+   :members:
+   :undoc-members:
+   :imported-members:
+   :show-inheritance:

mjlab/docs/source/api/scene.rst

@@ -0,0 +1,10 @@
+mjlab.scene
+===========
+
+Scene management.
+
+.. automodule:: mjlab.scene
+   :members:
+   :undoc-members:
+   :imported-members:
+   :show-inheritance:

mjlab/docs/source/api/sensor.rst

@@ -0,0 +1,10 @@
+mjlab.sensor
+============
+
+Sensor implementations.
+
+.. automodule:: mjlab.sensor
+   :members:
+   :undoc-members:
+   :imported-members:
+   :show-inheritance:

mjlab/docs/source/api/sim.rst

@@ -0,0 +1,10 @@
+mjlab.sim
+=========
+
+Simulation core.
+
+.. automodule:: mjlab.sim
+   :members:
+   :undoc-members:
+   :imported-members:
+   :show-inheritance:

mjlab/docs/source/api/terrains.rst

@@ -0,0 +1,10 @@
+mjlab.terrains
+==============
+
+Terrain generation and importing.
+
+.. automodule:: mjlab.terrains
+   :members:
+   :undoc-members:
+   :imported-members:
+   :show-inheritance:

mjlab/src/mjlab/__init__.py

@@ -0,0 +1,59 @@
+import os
+from importlib.metadata import entry_points
+from pathlib import Path
+
+import tyro
+import warp as wp
+
+MJLAB_SRC_PATH: Path = Path(__file__).parent
+
+TYRO_FLAGS = (
+  # Don't let users switch between types in unions. This produces a simpler CLI
+  # with flatter helptext, at the cost of some flexibility. Type changes can
+  # just be done in code.
+  tyro.conf.AvoidSubcommands,
+  # Disable automatic flag conversion (e.g., use `--flag False` instead of
+  # `--no-flag` for booleans).
+  tyro.conf.FlagConversionOff,
+  # Use Python syntax for collections: --tuple (1,2,3) instead of --tuple 1 2 3.
+  # Helps with wandb sweep compatibility: https://brentyi.github.io/tyro/wandb_sweeps/
+  tyro.conf.UsePythonSyntaxForLiteralCollections,
+)
+
+
+def _configure_warp() -> None:
+  """Configure Warp globally for mjlab."""
+  wp.config.enable_backward = False
+
+  # Keep warp verbose by default to show kernel compilation progress.
+  # Override with MJLAB_WARP_QUIET=1 environment variable if needed.
+  quiet = os.environ.get("MJLAB_WARP_QUIET", "0").lower() in ("1", "true", "yes")
+  wp.config.quiet = quiet
+
+
+def _import_registered_packages() -> None:
+  """Auto-discover and import packages registered via entry points.
+
+  Looks for packages registered under the 'mjlab.tasks' entry point group.
+  Each discovered package is imported, which allows it to register custom
+  environments with gymnasium.
+  """
+  mjlab_tasks = entry_points().select(group="mjlab.tasks")
+  for entry_point in mjlab_tasks:
+    try:
+      entry_point.load()
+    except Exception as e:
+      print(f"[WARN] Failed to load task package {entry_point.name}: {e}")
+
+
+def _configure_mediapy() -> None:
+  """Point mediapy at the bundled imageio-ffmpeg binary."""
+  import imageio_ffmpeg
+  import mediapy
+
+  mediapy.set_ffmpeg(imageio_ffmpeg.get_ffmpeg_exe())
+
+
+_configure_warp()
+_configure_mediapy()
+_import_registered_packages()

mjlab/src/mjlab/actuator/__init__.py

@@ -0,0 +1,48 @@
+"""Actuator implementations for mjlab."""
+
+from mjlab.actuator.actuator import Actuator as Actuator
+from mjlab.actuator.actuator import ActuatorCfg as ActuatorCfg
+from mjlab.actuator.actuator import ActuatorCmd as ActuatorCmd
+from mjlab.actuator.builtin_actuator import (
+  BuiltinMotorActuator as BuiltinMotorActuator,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinMotorActuatorCfg as BuiltinMotorActuatorCfg,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinMuscleActuator as BuiltinMuscleActuator,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinMuscleActuatorCfg as BuiltinMuscleActuatorCfg,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinPositionActuator as BuiltinPositionActuator,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinPositionActuatorCfg as BuiltinPositionActuatorCfg,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinVelocityActuator as BuiltinVelocityActuator,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinVelocityActuatorCfg as BuiltinVelocityActuatorCfg,
+)
+from mjlab.actuator.builtin_group import BuiltinActuatorGroup as BuiltinActuatorGroup
+from mjlab.actuator.dc_actuator import DcMotorActuator as DcMotorActuator
+from mjlab.actuator.dc_actuator import DcMotorActuatorCfg as DcMotorActuatorCfg
+from mjlab.actuator.delayed_actuator import DelayedActuator as DelayedActuator
+from mjlab.actuator.delayed_actuator import DelayedActuatorCfg as DelayedActuatorCfg
+from mjlab.actuator.learned_actuator import LearnedMlpActuator as LearnedMlpActuator
+from mjlab.actuator.learned_actuator import (
+  LearnedMlpActuatorCfg as LearnedMlpActuatorCfg,
+)
+from mjlab.actuator.pd_actuator import IdealPdActuator as IdealPdActuator
+from mjlab.actuator.pd_actuator import IdealPdActuatorCfg as IdealPdActuatorCfg
+from mjlab.actuator.xml_actuator import XmlMotorActuator as XmlMotorActuator
+from mjlab.actuator.xml_actuator import XmlMotorActuatorCfg as XmlMotorActuatorCfg
+from mjlab.actuator.xml_actuator import XmlMuscleActuator as XmlMuscleActuator
+from mjlab.actuator.xml_actuator import XmlMuscleActuatorCfg as XmlMuscleActuatorCfg
+from mjlab.actuator.xml_actuator import XmlPositionActuator as XmlPositionActuator
+from mjlab.actuator.xml_actuator import XmlPositionActuatorCfg as XmlPositionActuatorCfg
+from mjlab.actuator.xml_actuator import XmlVelocityActuator as XmlVelocityActuator
+from mjlab.actuator.xml_actuator import XmlVelocityActuatorCfg as XmlVelocityActuatorCfg

mjlab/src/mjlab/actuator/actuator.py

@@ -0,0 +1,269 @@
+"""Base actuator interface."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+import mujoco
+import mujoco_warp as mjwarp
+import torch
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+  from mjlab.entity.data import EntityData
+
+ActuatorCfgT = TypeVar("ActuatorCfgT", bound="ActuatorCfg")
+
+
+class TransmissionType(str, Enum):
+  """Transmission types for actuators."""
+
+  JOINT = "joint"
+  TENDON = "tendon"
+  SITE = "site"
+
+
+@dataclass(kw_only=True)
+class ActuatorCfg(ABC):
+  target_names_expr: tuple[str, ...]
+  """Targets that are part of this actuator group.
+
+  Can be a tuple of names or tuple of regex expressions.
+  Interpreted based on transmission_type (joint/tendon/site).
+  """
+
+  transmission_type: TransmissionType = TransmissionType.JOINT
+  """Transmission type. Defaults to JOINT."""
+
+  armature: float = 0.0
+  """Reflected rotor inertia."""
+
+  frictionloss: float = 0.0
+  """Friction loss force limit.
+
+  Applies a constant friction force opposing motion, independent of load or velocity.
+  Also known as dry friction or load-independent friction.
+  """
+
+  def __post_init__(self) -> None:
+    assert self.armature >= 0.0, "armature must be non-negative."
+    assert self.frictionloss >= 0.0, "frictionloss must be non-negative."
+    if self.transmission_type == TransmissionType.SITE:
+      if self.armature > 0.0 or self.frictionloss > 0.0:
+        raise ValueError(
+          f"{self.__class__.__name__}: armature and frictionloss are not supported for "
+          "SITE transmission type."
+        )
+
+  @abstractmethod
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> Actuator:
+    """Build actuator instance.
+
+    Args:
+      entity: Entity this actuator belongs to.
+      target_ids: Local target indices (for indexing entity arrays).
+      target_names: Target names corresponding to target_ids.
+
+    Returns:
+      Actuator instance.
+    """
+    raise NotImplementedError
+
+
+@dataclass
+class ActuatorCmd:
+  """High-level actuator command with targets and current state.
+
+  Passed to actuator's `compute()` method to generate low-level control signals.
+  All tensors have shape (num_envs, num_targets).
+  """
+
+  position_target: torch.Tensor
+  """Desired positions (joint positions, tendon lengths, or site positions)."""
+  velocity_target: torch.Tensor
+  """Desired velocities (joint velocities, tendon velocities, or site velocities)."""
+  effort_target: torch.Tensor
+  """Feedforward effort (torques or forces)."""
+  pos: torch.Tensor
+  """Current positions (joint positions, tendon lengths, or site positions)."""
+  vel: torch.Tensor
+  """Current velocities (joint velocities, tendon velocities, or site velocities)."""
+
+
+class Actuator(ABC, Generic[ActuatorCfgT]):
+  """Base actuator interface."""
+
+  def __init__(
+    self,
+    cfg: ActuatorCfgT,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    self.cfg = cfg
+    self.entity = entity
+    self._target_ids_list = target_ids
+    self._target_names = target_names
+    self._target_ids: torch.Tensor | None = None
+    self._ctrl_ids: torch.Tensor | None = None
+    self._global_ctrl_ids: torch.Tensor | None = None
+    self._mjs_actuators: list[mujoco.MjsActuator] = []
+    self._site_zeros: torch.Tensor | None = None
+
+  @property
+  def target_ids(self) -> torch.Tensor:
+    """Local indices of targets controlled by this actuator."""
+    assert self._target_ids is not None
+    return self._target_ids
+
+  @property
+  def target_names(self) -> list[str]:
+    """Names of targets controlled by this actuator."""
+    return self._target_names
+
+  @property
+  def transmission_type(self) -> TransmissionType:
+    """Transmission type of this actuator."""
+    return self.cfg.transmission_type
+
+  @property
+  def ctrl_ids(self) -> torch.Tensor:
+    """Local indices of control inputs within the entity."""
+    assert self._ctrl_ids is not None
+    return self._ctrl_ids
+
+  @property
+  def global_ctrl_ids(self) -> torch.Tensor:
+    """Global indices of control inputs in the MuJoCo model."""
+    assert self._global_ctrl_ids is not None
+    return self._global_ctrl_ids
+
+  @abstractmethod
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    """Edit the MjSpec to add actuators.
+
+    This is called during entity construction, before the model is compiled.
+
+    Args:
+      spec: The entity's MjSpec to edit.
+      target_names: Names of targets (joints, tendons, or sites) controlled by
+        this actuator.
+    """
+    raise NotImplementedError
+
+  def initialize(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+    device: str,
+  ) -> None:
+    """Initialize the actuator after model compilation.
+
+    This is called after the MjSpec is compiled into an MjModel.
+
+    Args:
+      mj_model: The compiled MuJoCo model.
+      model: The compiled mjwarp model.
+      data: The mjwarp data arrays.
+      device: Device for tensor operations (e.g., "cuda", "cpu").
+    """
+    del mj_model, model  # Unused.
+    self._target_ids = torch.tensor(
+      self._target_ids_list, dtype=torch.long, device=device
+    )
+    global_ctrl_ids_list = [act.id for act in self._mjs_actuators]
+    self._global_ctrl_ids = torch.tensor(
+      global_ctrl_ids_list, dtype=torch.long, device=device
+    )
+    entity_ctrl_ids = self.entity.indexing.ctrl_ids
+    global_to_local = {gid.item(): i for i, gid in enumerate(entity_ctrl_ids)}
+    self._ctrl_ids = torch.tensor(
+      [global_to_local[gid] for gid in global_ctrl_ids_list],
+      dtype=torch.long,
+      device=device,
+    )
+
+    # Pre-allocate zeros for SITE transmission type to avoid repeated allocations.
+    if self.transmission_type == TransmissionType.SITE:
+      nenvs = data.nworld
+      ntargets = len(self._target_ids_list)
+      self._site_zeros = torch.zeros((nenvs, ntargets), device=device)
+
+  def get_command(self, data: EntityData) -> ActuatorCmd:
+    """Extract command data for this actuator from entity data.
+
+    Args:
+      data: The entity data containing all state and target information.
+
+    Returns:
+      ActuatorCmd with appropriate data based on transmission type.
+    """
+    if self.transmission_type == TransmissionType.JOINT:
+      return ActuatorCmd(
+        position_target=data.joint_pos_target[:, self.target_ids],
+        velocity_target=data.joint_vel_target[:, self.target_ids],
+        effort_target=data.joint_effort_target[:, self.target_ids],
+        pos=data.joint_pos[:, self.target_ids],
+        vel=data.joint_vel[:, self.target_ids],
+      )
+    elif self.transmission_type == TransmissionType.TENDON:
+      return ActuatorCmd(
+        position_target=data.tendon_len_target[:, self.target_ids],
+        velocity_target=data.tendon_vel_target[:, self.target_ids],
+        effort_target=data.tendon_effort_target[:, self.target_ids],
+        pos=data.tendon_len[:, self.target_ids],
+        vel=data.tendon_vel[:, self.target_ids],
+      )
+    elif self.transmission_type == TransmissionType.SITE:
+      assert self._site_zeros is not None
+      return ActuatorCmd(
+        position_target=self._site_zeros,
+        velocity_target=self._site_zeros,
+        effort_target=data.site_effort_target[:, self.target_ids],
+        pos=self._site_zeros,
+        vel=self._site_zeros,
+      )
+    else:
+      raise ValueError(f"Unknown transmission type: {self.transmission_type}")
+
+  @abstractmethod
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    """Compute low-level actuator control signal from high-level commands.
+
+    Args:
+      cmd: High-level actuator command.
+
+    Returns:
+      Control signal tensor of shape (num_envs, num_actuators).
+    """
+    raise NotImplementedError
+
+  # Optional methods.
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    """Reset actuator state for specified environments.
+
+    Base implementation does nothing. Override in subclasses that maintain
+    internal state.
+
+    Args:
+      env_ids: Environment indices to reset. If None, reset all environments.
+    """
+    del env_ids  # Unused.
+
+  def update(self, dt: float) -> None:
+    """Update actuator state after a simulation step.
+
+    Base implementation does nothing. Override in subclasses that need
+    per-step updates.
+
+    Args:
+      dt: Time step in seconds.
+    """
+    del dt  # Unused.

mjlab/src/mjlab/actuator/builtin_actuator.py

@@ -0,0 +1,279 @@
+"""MuJoCo built-in actuators.
+
+This module provides actuators that use MuJoCo's native actuator implementations,
+created programmatically via the MjSpec API.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import mujoco
+import torch
+
+from mjlab.actuator.actuator import (
+  Actuator,
+  ActuatorCfg,
+  ActuatorCmd,
+  TransmissionType,
+)
+from mjlab.utils.spec import (
+  create_motor_actuator,
+  create_muscle_actuator,
+  create_position_actuator,
+  create_velocity_actuator,
+)
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+
+
+@dataclass(kw_only=True)
+class BuiltinPositionActuatorCfg(ActuatorCfg):
+  """Configuration for MuJoCo built-in position actuator.
+
+  Under the hood, this creates a <position> actuator for each target and sets
+  the stiffness, damping and effort limits accordingly. It also modifies the target's
+  properties, namely armature and frictionloss.
+  """
+
+  stiffness: float
+  """PD proportional gain."""
+  damping: float
+  """PD derivative gain."""
+  effort_limit: float | None = None
+  """Maximum actuator force/torque. If None, no limit is applied."""
+
+  def __post_init__(self) -> None:
+    super().__post_init__()
+    if self.transmission_type == TransmissionType.SITE:
+      raise ValueError(
+        "BuiltinPositionActuatorCfg does not support SITE transmission. "
+        "Use BuiltinMotorActuatorCfg for site transmission."
+      )
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> BuiltinPositionActuator:
+    return BuiltinPositionActuator(self, entity, target_ids, target_names)
+
+
+class BuiltinPositionActuator(Actuator[BuiltinPositionActuatorCfg]):
+  """MuJoCo built-in position actuator."""
+
+  def __init__(
+    self,
+    cfg: BuiltinPositionActuatorCfg,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    # Add <position> actuator to spec, one per target.
+    for target_name in target_names:
+      actuator = create_position_actuator(
+        spec,
+        target_name,
+        stiffness=self.cfg.stiffness,
+        damping=self.cfg.damping,
+        effort_limit=self.cfg.effort_limit,
+        armature=self.cfg.armature,
+        frictionloss=self.cfg.frictionloss,
+        transmission_type=self.cfg.transmission_type,
+      )
+      self._mjs_actuators.append(actuator)
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    return cmd.position_target
+
+
+@dataclass(kw_only=True)
+class BuiltinMotorActuatorCfg(ActuatorCfg):
+  """Configuration for MuJoCo built-in motor actuator.
+
+  Under the hood, this creates a <motor> actuator for each target and sets
+  its effort limit and gear ratio accordingly. It also modifies the target's
+  properties, namely armature and frictionloss.
+  """
+
+  effort_limit: float
+  """Maximum actuator effort."""
+  gear: float = 1.0
+  """Actuator gear ratio."""
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> BuiltinMotorActuator:
+    return BuiltinMotorActuator(self, entity, target_ids, target_names)
+
+
+class BuiltinMotorActuator(Actuator[BuiltinMotorActuatorCfg]):
+  """MuJoCo built-in motor actuator."""
+
+  def __init__(
+    self,
+    cfg: BuiltinMotorActuatorCfg,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    # Add <motor> actuator to spec, one per target.
+    for target_name in target_names:
+      actuator = create_motor_actuator(
+        spec,
+        target_name,
+        effort_limit=self.cfg.effort_limit,
+        gear=self.cfg.gear,
+        armature=self.cfg.armature,
+        frictionloss=self.cfg.frictionloss,
+        transmission_type=self.cfg.transmission_type,
+      )
+      self._mjs_actuators.append(actuator)
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    return cmd.effort_target
+
+
+@dataclass(kw_only=True)
+class BuiltinVelocityActuatorCfg(ActuatorCfg):
+  """Configuration for MuJoCo built-in velocity actuator.
+
+  Under the hood, this creates a <velocity> actuator for each target and sets the
+  damping gain. It also modifies the target's properties, namely armature and
+  frictionloss.
+  """
+
+  damping: float
+  """Damping gain."""
+  effort_limit: float | None = None
+  """Maximum actuator force/torque. If None, no limit is applied."""
+
+  def __post_init__(self) -> None:
+    super().__post_init__()
+    if self.transmission_type == TransmissionType.SITE:
+      raise ValueError(
+        "BuiltinVelocityActuatorCfg does not support SITE transmission. "
+        "Use BuiltinMotorActuatorCfg for site transmission."
+      )
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> BuiltinVelocityActuator:
+    return BuiltinVelocityActuator(self, entity, target_ids, target_names)
+
+
+class BuiltinVelocityActuator(Actuator[BuiltinVelocityActuatorCfg]):
+  """MuJoCo built-in velocity actuator."""
+
+  def __init__(
+    self,
+    cfg: BuiltinVelocityActuatorCfg,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    # Add <velocity> actuator to spec, one per target.
+    for target_name in target_names:
+      actuator = create_velocity_actuator(
+        spec,
+        target_name,
+        damping=self.cfg.damping,
+        effort_limit=self.cfg.effort_limit,
+        armature=self.cfg.armature,
+        frictionloss=self.cfg.frictionloss,
+        transmission_type=self.cfg.transmission_type,
+      )
+      self._mjs_actuators.append(actuator)
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    return cmd.velocity_target
+
+
+@dataclass(kw_only=True)
+class BuiltinMuscleActuatorCfg(ActuatorCfg):
+  """Configuration for MuJoCo built-in muscle actuator."""
+
+  length_range: tuple[float, float] = (0.0, 0.0)
+  """Length range for muscle actuator."""
+  gear: float = 1.0
+  """Gear ratio."""
+  timeconst: tuple[float, float] = (0.01, 0.04)
+  """Activation and deactivation time constants."""
+  tausmooth: float = 0.0
+  """Smoothing time constant."""
+  range: tuple[float, float] = (0.75, 1.05)
+  """Operating range of normalized muscle length."""
+  force: float = -1.0
+  """Peak force (if -1, defaults to scale * FLV)."""
+  scale: float = 200.0
+  """Force scaling factor."""
+  lmin: float = 0.5
+  """Minimum normalized muscle length."""
+  lmax: float = 1.6
+  """Maximum normalized muscle length."""
+  vmax: float = 1.5
+  """Maximum normalized muscle velocity."""
+  fpmax: float = 1.3
+  """Passive force at lmax."""
+  fvmax: float = 1.2
+  """Active force at -vmax."""
+
+  def __post_init__(self) -> None:
+    super().__post_init__()
+    if self.transmission_type == TransmissionType.SITE:
+      raise ValueError(
+        "BuiltinMuscleActuatorCfg does not support SITE transmission. "
+        "Use BuiltinMotorActuatorCfg for site transmission."
+      )
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> BuiltinMuscleActuator:
+    return BuiltinMuscleActuator(self, entity, target_ids, target_names)
+
+
+class BuiltinMuscleActuator(Actuator[BuiltinMuscleActuatorCfg]):
+  """MuJoCo built-in muscle actuator."""
+
+  def __init__(
+    self,
+    cfg: BuiltinMuscleActuatorCfg,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    # Add <muscle> actuator to spec, one per target.
+    for target_name in target_names:
+      actuator = create_muscle_actuator(
+        spec,
+        target_name,
+        length_range=self.cfg.length_range,
+        gear=self.cfg.gear,
+        timeconst=self.cfg.timeconst,
+        tausmooth=self.cfg.tausmooth,
+        range=self.cfg.range,
+        force=self.cfg.force,
+        scale=self.cfg.scale,
+        lmin=self.cfg.lmin,
+        lmax=self.cfg.lmax,
+        vmax=self.cfg.vmax,
+        fpmax=self.cfg.fpmax,
+        fvmax=self.cfg.fvmax,
+        transmission_type=self.cfg.transmission_type,
+      )
+      self._mjs_actuators.append(actuator)
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    return cmd.effort_target

mjlab/src/mjlab/actuator/builtin_group.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.actuator.actuator import TransmissionType
+from mjlab.actuator.builtin_actuator import (
+  BuiltinMotorActuator,
+  BuiltinMuscleActuator,
+  BuiltinPositionActuator,
+  BuiltinVelocityActuator,
+)
+
+if TYPE_CHECKING:
+  from mjlab.actuator.actuator import Actuator
+  from mjlab.entity.data import EntityData
+
+BuiltinActuatorType = (
+  BuiltinMotorActuator
+  | BuiltinMuscleActuator
+  | BuiltinPositionActuator
+  | BuiltinVelocityActuator
+)
+
+# Maps (actuator_type, transmission_type) to EntityData target tensor attribute name.
+_TARGET_TENSOR_MAP: dict[tuple[type[BuiltinActuatorType], TransmissionType], str] = {
+  (BuiltinPositionActuator, TransmissionType.JOINT): "joint_pos_target",
+  (BuiltinVelocityActuator, TransmissionType.JOINT): "joint_vel_target",
+  (BuiltinMotorActuator, TransmissionType.JOINT): "joint_effort_target",
+  (BuiltinPositionActuator, TransmissionType.TENDON): "tendon_len_target",
+  (BuiltinVelocityActuator, TransmissionType.TENDON): "tendon_vel_target",
+  (BuiltinMotorActuator, TransmissionType.TENDON): "tendon_effort_target",
+  (BuiltinMotorActuator, TransmissionType.SITE): "site_effort_target",
+  (BuiltinMuscleActuator, TransmissionType.JOINT): "joint_effort_target",
+  (BuiltinMuscleActuator, TransmissionType.TENDON): "tendon_effort_target",
+}
+
+
+@dataclass(frozen=True)
+class BuiltinActuatorGroup:
+  """Groups builtin actuators for batch processing.
+
+  Builtin actuators (position, velocity, motor) just pass through target values
+  from entity data to control signals. This class pre-computes the mappings and
+  enables direct writes without per-actuator overhead.
+  """
+
+  # Map from (BuiltinActuator type, transmission_type) to (target_ids, ctrl_ids).
+  _index_groups: dict[
+    tuple[type[BuiltinActuatorType], TransmissionType],
+    tuple[torch.Tensor, torch.Tensor],
+  ]
+
+  @staticmethod
+  def process(
+    actuators: list[Actuator],
+  ) -> tuple[BuiltinActuatorGroup, tuple[Actuator, ...]]:
+    """Register builtin actuators and pre-compute their mappings.
+
+    Args:
+      actuators: List of initialized actuators to process.
+
+    Returns:
+      A tuple containing:
+        - BuiltinActuatorGroup with pre-computed mappings.
+        - List of custom (non-builtin) actuators.
+    """
+
+    builtin_groups: dict[
+      tuple[type[BuiltinActuatorType], TransmissionType], list[Actuator]
+    ] = {}
+    custom_actuators: list[Actuator] = []
+
+    # Group actuators by (type, transmission_type).
+    for act in actuators:
+      if isinstance(act, BuiltinActuatorType):
+        key: tuple[type[BuiltinActuatorType], TransmissionType] = (
+          type(act),
+          act.cfg.transmission_type,
+        )
+        builtin_groups.setdefault(key, []).append(act)
+      else:
+        custom_actuators.append(act)
+
+    # Return stacked indices for each (actuator_type, transmission_type) group.
+    index_groups: dict[
+      tuple[type[BuiltinActuatorType], TransmissionType],
+      tuple[torch.Tensor, torch.Tensor],
+    ] = {
+      key: (
+        torch.cat([act.target_ids for act in acts], dim=0),
+        torch.cat([act.ctrl_ids for act in acts], dim=0),
+      )
+      for key, acts in builtin_groups.items()
+    }
+    return BuiltinActuatorGroup(index_groups), tuple(custom_actuators)
+
+  def apply_controls(self, data: EntityData) -> None:
+    """Write builtin actuator controls directly to simulation data.
+
+    Args:
+      data: Entity data containing targets and control arrays.
+    """
+    for (actuator_type, transmission_type), (
+      target_ids,
+      ctrl_ids,
+    ) in self._index_groups.items():
+      attr_name = _TARGET_TENSOR_MAP[(actuator_type, transmission_type)]
+      target_tensor = getattr(data, attr_name)
+      data.write_ctrl(target_tensor[:, target_ids], ctrl_ids)

mjlab/src/mjlab/actuator/dc_actuator.py

@@ -0,0 +1,162 @@
+"""DC motor actuator with velocity-based saturation model.
+
+This module provides a DC motor actuator that implements a realistic torque-speed
+curve for more accurate motor behavior simulation.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+import mujoco
+import mujoco_warp as mjwarp
+import torch
+
+from mjlab.actuator.actuator import ActuatorCmd
+from mjlab.actuator.pd_actuator import IdealPdActuator, IdealPdActuatorCfg
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+
+DcMotorCfgT = TypeVar("DcMotorCfgT", bound="DcMotorActuatorCfg")
+
+
+@dataclass(kw_only=True)
+class DcMotorActuatorCfg(IdealPdActuatorCfg):
+  """Configuration for DC motor actuator with velocity-based saturation.
+
+  This actuator implements a DC motor torque-speed curve for more realistic
+  actuator behavior. The motor produces maximum torque (saturation_effort) at
+  zero velocity and reduces linearly to zero torque at maximum velocity.
+
+  Note: effort_limit should be explicitly set to a realistic value for proper
+  motor modeling. Using the default (inf) will trigger a warning. Use
+  IdealPdActuator if unlimited torque is desired.
+  """
+
+  saturation_effort: float
+  """Peak motor torque at zero velocity (stall torque)."""
+
+  velocity_limit: float
+  """Maximum motor velocity (no-load speed)."""
+
+  def __post_init__(self) -> None:
+    """Validate DC motor parameters."""
+    import warnings
+
+    if self.effort_limit == float("inf"):
+      warnings.warn(
+        "effort_limit is set to inf for DcMotorActuator, which creates an "
+        "unrealistic motor with unlimited continuous torque. Consider setting "
+        "effort_limit to your motor's continuous rating (<= saturation_effort). "
+        "Use IdealPdActuator if you truly want unlimited torque.",
+        UserWarning,
+        stacklevel=2,
+      )
+
+    if self.effort_limit > self.saturation_effort:
+      warnings.warn(
+        f"effort_limit ({self.effort_limit}) exceeds saturation_effort "
+        f"({self.saturation_effort}). For realistic motors, continuous torque "
+        "should be <= peak torque.",
+        UserWarning,
+        stacklevel=2,
+      )
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> DcMotorActuator:
+    return DcMotorActuator(self, entity, target_ids, target_names)
+
+
+class DcMotorActuator(IdealPdActuator[DcMotorCfgT], Generic[DcMotorCfgT]):
+  """DC motor actuator with velocity-based saturation model.
+
+  This actuator extends IdealPdActuator with a realistic DC motor model
+  that limits torque based on current joint velocity. The model implements
+  a linear torque-speed curve where:
+  - At zero velocity: can produce full saturation_effort (stall torque)
+  - At max velocity: can produce zero torque
+  - Between: torque limit varies linearly
+
+  The continuous torque limit (effort_limit) further constrains the output.
+  """
+
+  def __init__(
+    self,
+    cfg: DcMotorCfgT,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+    self.saturation_effort: torch.Tensor | None = None
+    self.velocity_limit_motor: torch.Tensor | None = None
+    self._vel_at_effort_lim: torch.Tensor | None = None
+    self._joint_vel_clipped: torch.Tensor | None = None
+
+  def initialize(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+    device: str,
+  ) -> None:
+    super().initialize(mj_model, model, data, device)
+
+    num_envs = data.nworld
+    num_joints = len(self._target_names)
+
+    self.saturation_effort = torch.full(
+      (num_envs, num_joints),
+      self.cfg.saturation_effort,
+      dtype=torch.float,
+      device=device,
+    )
+    self.velocity_limit_motor = torch.full(
+      (num_envs, num_joints),
+      self.cfg.velocity_limit,
+      dtype=torch.float,
+      device=device,
+    )
+
+    # Compute corner velocity where torque-speed curve intersects effort_limit.
+    assert self.force_limit is not None
+    self._vel_at_effort_lim = self.velocity_limit_motor * (
+      1 + self.force_limit / self.saturation_effort
+    )
+    self._joint_vel_clipped = torch.zeros(num_envs, num_joints, device=device)
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    assert self._joint_vel_clipped is not None
+    self._joint_vel_clipped[:] = cmd.vel
+    return super().compute(cmd)
+
+  def _clip_effort(self, effort: torch.Tensor) -> torch.Tensor:
+    assert self.saturation_effort is not None
+    assert self.velocity_limit_motor is not None
+    assert self.force_limit is not None
+    assert self._vel_at_effort_lim is not None
+    assert self._joint_vel_clipped is not None
+
+    # Clip velocity to corner velocity range.
+    vel_clipped = torch.clamp(
+      self._joint_vel_clipped,
+      min=-self._vel_at_effort_lim,
+      max=self._vel_at_effort_lim,
+    )
+
+    # Compute torque-speed curve limits.
+    torque_speed_top = self.saturation_effort * (
+      1.0 - vel_clipped / self.velocity_limit_motor
+    )
+    torque_speed_bottom = self.saturation_effort * (
+      -1.0 - vel_clipped / self.velocity_limit_motor
+    )
+
+    # Apply continuous torque constraint.
+    max_effort = torch.clamp(torque_speed_top, max=self.force_limit)
+    min_effort = torch.clamp(torque_speed_bottom, min=-self.force_limit)
+
+    return torch.clamp(effort, min=min_effort, max=max_effort)

mjlab/src/mjlab/actuator/delayed_actuator.py

@@ -0,0 +1,174 @@
+"""Generic delayed actuator wrapper."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Literal
+
+import mujoco
+import mujoco_warp as mjwarp
+import torch
+
+from mjlab.actuator.actuator import Actuator, ActuatorCfg, ActuatorCmd
+from mjlab.utils.buffers import DelayBuffer
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+
+
+@dataclass(kw_only=True)
+class DelayedActuatorCfg(ActuatorCfg):
+  """Configuration for delayed actuator wrapper.
+
+  Wraps any actuator config to add delay functionality. Delays are quantized
+  to physics timesteps (not control timesteps). For example, with 500Hz physics
+  and 50Hz control (decimation=10), a lag of 2 represents a 4ms delay (2 physics
+  steps).
+  """
+
+  target_names_expr: tuple[str, ...] = field(init=False, default=())
+
+  base_cfg: ActuatorCfg
+  """Configuration for the underlying actuator."""
+
+  def __post_init__(self):
+    object.__setattr__(self, "target_names_expr", self.base_cfg.target_names_expr)
+    object.__setattr__(self, "transmission_type", self.base_cfg.transmission_type)
+
+  delay_target: (
+    Literal["position", "velocity", "effort"]
+    | tuple[Literal["position", "velocity", "effort"], ...]
+  ) = "position"
+  """Which command target(s) to delay.
+
+  Can be a single string like 'position', or a tuple of strings like
+  ('position', 'velocity', 'effort') to delay multiple targets together.
+  """
+
+  delay_min_lag: int = 0
+  """Minimum delay lag in physics timesteps."""
+
+  delay_max_lag: int = 0
+  """Maximum delay lag in physics timesteps."""
+
+  delay_hold_prob: float = 0.0
+  """Probability of keeping previous lag when updating."""
+
+  delay_update_period: int = 0
+  """Period for updating delays in physics timesteps (0 = every step)."""
+
+  delay_per_env_phase: bool = True
+  """Whether each environment has a different phase offset."""
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> DelayedActuator:
+    base_actuator = self.base_cfg.build(entity, target_ids, target_names)
+    return DelayedActuator(self, base_actuator)
+
+
+class DelayedActuator(Actuator[DelayedActuatorCfg]):
+  """Generic wrapper that adds delay to any actuator.
+
+  Delays the specified command target(s) (position, velocity, and/or effort)
+  before passing it to the underlying actuator's compute method.
+  """
+
+  def __init__(self, cfg: DelayedActuatorCfg, base_actuator: Actuator) -> None:
+    super().__init__(
+      cfg,
+      base_actuator.entity,
+      base_actuator._target_ids_list,
+      base_actuator._target_names,
+    )
+    self._base_actuator = base_actuator
+    self._delay_buffers: dict[str, DelayBuffer] = {}
+
+  @property
+  def base_actuator(self) -> Actuator:
+    """The underlying actuator being wrapped."""
+    return self._base_actuator
+
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    self._base_actuator.edit_spec(spec, target_names)
+    self._mjs_actuators = self._base_actuator._mjs_actuators
+
+  def initialize(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+    device: str,
+  ) -> None:
+    self._base_actuator.initialize(mj_model, model, data, device)
+
+    self._target_ids = self._base_actuator._target_ids
+    self._ctrl_ids = self._base_actuator._ctrl_ids
+    self._global_ctrl_ids = self._base_actuator._global_ctrl_ids
+
+    targets = (
+      (self.cfg.delay_target,)
+      if isinstance(self.cfg.delay_target, str)
+      else self.cfg.delay_target
+    )
+
+    # Create independent delay buffer for each target.
+    for target in targets:
+      self._delay_buffers[target] = DelayBuffer(
+        min_lag=self.cfg.delay_min_lag,
+        max_lag=self.cfg.delay_max_lag,
+        batch_size=data.nworld,
+        device=device,
+        hold_prob=self.cfg.delay_hold_prob,
+        update_period=self.cfg.delay_update_period,
+        per_env_phase=self.cfg.delay_per_env_phase,
+      )
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    position_target = cmd.position_target
+    velocity_target = cmd.velocity_target
+    effort_target = cmd.effort_target
+
+    if "position" in self._delay_buffers:
+      self._delay_buffers["position"].append(cmd.position_target)
+      position_target = self._delay_buffers["position"].compute()
+
+    if "velocity" in self._delay_buffers:
+      self._delay_buffers["velocity"].append(cmd.velocity_target)
+      velocity_target = self._delay_buffers["velocity"].compute()
+
+    if "effort" in self._delay_buffers:
+      self._delay_buffers["effort"].append(cmd.effort_target)
+      effort_target = self._delay_buffers["effort"].compute()
+
+    delayed_cmd = ActuatorCmd(
+      position_target=position_target,
+      velocity_target=velocity_target,
+      effort_target=effort_target,
+      pos=cmd.pos,
+      vel=cmd.vel,
+    )
+
+    return self._base_actuator.compute(delayed_cmd)
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    for buffer in self._delay_buffers.values():
+      buffer.reset(env_ids)
+    self._base_actuator.reset(env_ids)
+
+  def set_lags(
+    self,
+    lags: torch.Tensor,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set delay lag values for specified environments.
+
+    Args:
+      lags: Lag values in physics timesteps. Shape: (num_env_ids,) or scalar.
+      env_ids: Environment indices to set. If None, sets all environments.
+    """
+    for buffer in self._delay_buffers.values():
+      buffer.set_lags(lags, env_ids)
+
+  def update(self, dt: float) -> None:
+    self._base_actuator.update(dt)

mjlab/src/mjlab/actuator/learned_actuator.py

@@ -0,0 +1,207 @@
+"""Learned actuator models."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal
+
+import mujoco
+import mujoco_warp as mjwarp
+import torch
+
+from mjlab.actuator.actuator import ActuatorCmd
+from mjlab.actuator.dc_actuator import DcMotorActuator, DcMotorActuatorCfg
+from mjlab.utils.buffers import CircularBuffer
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+
+
+@dataclass(kw_only=True)
+class LearnedMlpActuatorCfg(DcMotorActuatorCfg):
+  """Configuration for MLP-based learned actuator model.
+
+  This actuator learns the mapping from joint commands and state history to
+  actual torque output. It's useful for capturing actuator dynamics that are
+  difficult to model analytically, such as delays, non-linearities, and
+  friction effects.
+
+  The network is trained offline using data from the real system and loaded
+  as a TorchScript file. The model uses a sliding window of historical joint
+  position errors and velocities as inputs.
+  """
+
+  network_file: str
+  """Path to the TorchScript file containing the trained MLP model."""
+
+  pos_scale: float
+  """Scaling factor for joint position error inputs to the network."""
+
+  vel_scale: float
+  """Scaling factor for joint velocity inputs to the network."""
+
+  torque_scale: float
+  """Scaling factor for torque outputs from the network."""
+
+  input_order: Literal["pos_vel", "vel_pos"] = "pos_vel"
+  """Order of inputs to the network.
+
+  - "pos_vel": position errors followed by velocities
+  - "vel_pos": velocities followed by position errors
+  """
+
+  history_length: int = 3
+  """Number of timesteps of history to use as network inputs.
+
+  For example, history_length=3 uses the current timestep plus the previous
+  2 timesteps (total of 3 frames).
+  """
+
+  # Learned actuators don't use stiffness/damping from PD controller.
+  stiffness: float = 0.0
+  damping: float = 0.0
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> LearnedMlpActuator:
+    return LearnedMlpActuator(self, entity, target_ids, target_names)
+
+
+class LearnedMlpActuator(DcMotorActuator[LearnedMlpActuatorCfg]):
+  """MLP-based learned actuator with joint history.
+
+  This actuator uses a trained neural network to map from joint commands and
+  state history to torque outputs. The network captures complex actuator
+  dynamics that are difficult to model analytically.
+
+  The actuator maintains circular buffers of joint position errors and
+  velocities, which are used as inputs to the MLP. The network outputs are
+  then scaled and clipped using the DC motor limits from the parent class.
+  """
+
+  def __init__(
+    self,
+    cfg: LearnedMlpActuatorCfg,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+    self.network: torch.jit.ScriptModule | None = None
+    self._pos_error_history: CircularBuffer | None = None
+    self._vel_history: CircularBuffer | None = None
+
+  def initialize(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+    device: str,
+  ) -> None:
+    super().initialize(mj_model, model, data, device)
+
+    # Load the trained network from TorchScript file.
+    self.network = torch.jit.load(self.cfg.network_file, map_location=device)
+    assert self.network is not None
+    self.network.eval()
+
+    # Create history buffers.
+    num_envs = data.nworld
+
+    self._pos_error_history = CircularBuffer(
+      max_len=self.cfg.history_length,
+      batch_size=num_envs,
+      device=device,
+    )
+    self._vel_history = CircularBuffer(
+      max_len=self.cfg.history_length,
+      batch_size=num_envs,
+      device=device,
+    )
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    """Reset history buffers for specified environments.
+
+    Args:
+      env_ids: Environment indices to reset. If None, reset all environments.
+    """
+    assert self._pos_error_history is not None
+    assert self._vel_history is not None
+
+    if env_ids is None:
+      self._pos_error_history.reset()
+      self._vel_history.reset()
+    elif isinstance(env_ids, slice):
+      # Convert slice to indices for CircularBuffer.
+      batch_size = self._pos_error_history.batch_size
+      indices = list(range(*env_ids.indices(batch_size)))
+      self._pos_error_history.reset(indices)
+      self._vel_history.reset(indices)
+    else:
+      self._pos_error_history.reset(env_ids)
+      self._vel_history.reset(env_ids)
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    """Compute actuator torques using the learned MLP model.
+
+    Args:
+      cmd: High-level actuator command containing targets and current state.
+
+    Returns:
+      Computed torque tensor of shape (num_envs, num_joints).
+    """
+    assert self.network is not None
+    assert self._pos_error_history is not None
+    assert self._vel_history is not None
+    assert self._joint_vel_clipped is not None
+
+    # Update history buffers with current state.
+    pos_error = cmd.position_target - cmd.pos
+    self._pos_error_history.append(pos_error)
+    self._vel_history.append(cmd.vel)
+
+    # Save velocity for DC motor clipping in parent class.
+    self._joint_vel_clipped[:] = cmd.vel
+
+    num_envs = cmd.pos.shape[0]
+    num_joints = cmd.pos.shape[1]
+
+    # Extract history from current to history_length-1 steps back.
+    # Each returns shape: (num_envs, num_joints).
+    pos_inputs = [
+      self._pos_error_history[lag] for lag in range(self.cfg.history_length)
+    ]
+    vel_inputs = [self._vel_history[lag] for lag in range(self.cfg.history_length)]
+
+    # Stack along feature dimension: (num_envs, num_joints, history_length).
+    pos_stacked = torch.stack(pos_inputs, dim=2)
+    vel_stacked = torch.stack(vel_inputs, dim=2)
+
+    # Reshape to (num_envs * num_joints, num_history_steps) for network.
+    pos_flat = pos_stacked.reshape(num_envs * num_joints, -1)
+    vel_flat = vel_stacked.reshape(num_envs * num_joints, -1)
+
+    # Scale and concatenate inputs based on specified order.
+    if self.cfg.input_order == "pos_vel":
+      network_input = torch.cat(
+        [pos_flat * self.cfg.pos_scale, vel_flat * self.cfg.vel_scale], dim=1
+      )
+    elif self.cfg.input_order == "vel_pos":
+      network_input = torch.cat(
+        [vel_flat * self.cfg.vel_scale, pos_flat * self.cfg.pos_scale], dim=1
+      )
+    else:
+      raise ValueError(
+        f"Invalid input order: {self.cfg.input_order}. Must be 'pos_vel' or 'vel_pos'."
+      )
+
+    # Run network inference.
+    with torch.inference_mode():
+      torques_flat = self.network(network_input)
+
+    # Reshape and scale output torques.
+    computed_torques = torques_flat.reshape(num_envs, num_joints)
+    computed_torques = computed_torques * self.cfg.torque_scale
+
+    # Clip using DC motor limits from parent class.
+    return self._clip_effort(computed_torques)

mjlab/src/mjlab/actuator/pd_actuator.py

@@ -0,0 +1,150 @@
+"""An ideal PD control actuator."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+import mujoco
+import mujoco_warp as mjwarp
+import torch
+
+from mjlab.actuator.actuator import Actuator, ActuatorCfg, ActuatorCmd
+from mjlab.utils.spec import create_motor_actuator
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+
+IdealPdCfgT = TypeVar("IdealPdCfgT", bound="IdealPdActuatorCfg")
+
+
+@dataclass(kw_only=True)
+class IdealPdActuatorCfg(ActuatorCfg):
+  """Configuration for ideal PD actuator."""
+
+  stiffness: float
+  """PD stiffness (proportional gain)."""
+  damping: float
+  """PD damping (derivative gain)."""
+  effort_limit: float = float("inf")
+  """Maximum force/torque limit."""
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> IdealPdActuator:
+    return IdealPdActuator(self, entity, target_ids, target_names)
+
+
+class IdealPdActuator(Actuator, Generic[IdealPdCfgT]):
+  """Ideal PD control actuator."""
+
+  def __init__(
+    self,
+    cfg: IdealPdCfgT,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+    self.stiffness: torch.Tensor | None = None
+    self.damping: torch.Tensor | None = None
+    self.force_limit: torch.Tensor | None = None
+    self.default_stiffness: torch.Tensor | None = None
+    self.default_damping: torch.Tensor | None = None
+    self.default_force_limit: torch.Tensor | None = None
+
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    # Add <motor> actuator to spec, one per target.
+    for target_name in target_names:
+      actuator = create_motor_actuator(
+        spec,
+        target_name,
+        effort_limit=self.cfg.effort_limit,
+        armature=self.cfg.armature,
+        frictionloss=self.cfg.frictionloss,
+        transmission_type=self.cfg.transmission_type,
+      )
+      self._mjs_actuators.append(actuator)
+
+  def initialize(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+    device: str,
+  ) -> None:
+    super().initialize(mj_model, model, data, device)
+
+    num_envs = data.nworld
+    num_joints = len(self._target_names)
+    self.stiffness = torch.full(
+      (num_envs, num_joints), self.cfg.stiffness, dtype=torch.float, device=device
+    )
+    self.damping = torch.full(
+      (num_envs, num_joints), self.cfg.damping, dtype=torch.float, device=device
+    )
+    self.force_limit = torch.full(
+      (num_envs, num_joints), self.cfg.effort_limit, dtype=torch.float, device=device
+    )
+
+    self.default_stiffness = self.stiffness.clone()
+    self.default_damping = self.damping.clone()
+    self.default_force_limit = self.force_limit.clone()
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    assert self.stiffness is not None
+    assert self.damping is not None
+
+    pos_error = cmd.position_target - cmd.pos
+    vel_error = cmd.velocity_target - cmd.vel
+
+    computed_torques = self.stiffness * pos_error
+    computed_torques += self.damping * vel_error
+    computed_torques += cmd.effort_target
+
+    return self._clip_effort(computed_torques)
+
+  def _clip_effort(self, effort: torch.Tensor) -> torch.Tensor:
+    assert self.force_limit is not None
+    return torch.clamp(effort, -self.force_limit, self.force_limit)
+
+  def set_gains(
+    self,
+    env_ids: torch.Tensor | slice,
+    kp: torch.Tensor | None = None,
+    kd: torch.Tensor | None = None,
+  ) -> None:
+    """Set PD gains for specified environments.
+
+    Args:
+      env_ids: Environment indices to update.
+      kp: New proportional gains. Shape: (num_envs, num_actuators) or (num_envs,).
+      kd: New derivative gains. Shape: (num_envs, num_actuators) or (num_envs,).
+    """
+    assert self.stiffness is not None
+    assert self.damping is not None
+
+    if kp is not None:
+      if kp.ndim == 1:
+        kp = kp.unsqueeze(-1)
+      self.stiffness[env_ids] = kp
+
+    if kd is not None:
+      if kd.ndim == 1:
+        kd = kd.unsqueeze(-1)
+      self.damping[env_ids] = kd
+
+  def set_effort_limit(
+    self, env_ids: torch.Tensor | slice, effort_limit: torch.Tensor
+  ) -> None:
+    """Set effort limits for specified environments.
+
+    Args:
+      env_ids: Environment indices to update.
+      effort_limit: New effort limits. Shape: (num_envs, num_actuators) or (num_envs,).
+    """
+    assert self.force_limit is not None
+
+    if effort_limit.ndim == 1:
+      effort_limit = effort_limit.unsqueeze(-1)
+    self.force_limit[env_ids] = effort_limit

mjlab/src/mjlab/actuator/xml_actuator.py

@@ -0,0 +1,131 @@
+"""Wrappers for XML-defined actuators.
+
+This module provides wrappers for actuators already defined in robot XML/MJCF files.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+import mujoco
+import torch
+
+from mjlab.actuator.actuator import Actuator, ActuatorCfg, ActuatorCmd
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+
+XmlActuatorCfgT = TypeVar("XmlActuatorCfgT", bound=ActuatorCfg)
+
+
+class XmlActuator(Actuator[XmlActuatorCfgT], Generic[XmlActuatorCfgT]):
+  """Base class for XML-defined actuators."""
+
+  def __init__(
+    self,
+    cfg: XmlActuatorCfgT,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    # Filter to only targets that have corresponding XML actuators.
+    filtered_target_ids = []
+    filtered_target_names = []
+    for i, target_name in enumerate(target_names):
+      actuator = self._find_actuator_for_target(spec, target_name)
+      if actuator is not None:
+        self._mjs_actuators.append(actuator)
+        filtered_target_ids.append(self._target_ids_list[i])
+        filtered_target_names.append(target_name)
+
+    if len(filtered_target_names) == 0:
+      raise ValueError(
+        f"No XML actuators found for any targets matching the patterns. "
+        f"Searched targets: {target_names}. "
+        f"XML actuator config expects actuators to already exist in the XML."
+      )
+
+    # Update target IDs and names to only include those with actuators.
+    self._target_ids_list = filtered_target_ids
+    self._target_names = filtered_target_names
+
+  def _find_actuator_for_target(
+    self, spec: mujoco.MjSpec, target_name: str
+  ) -> mujoco.MjsActuator | None:
+    """Find an actuator that targets the given target (joint, tendon, or site)."""
+    for actuator in spec.actuators:
+      if actuator.target == target_name:
+        return actuator
+    return None
+
+
+@dataclass(kw_only=True)
+class XmlPositionActuatorCfg(ActuatorCfg):
+  """Wrap existing XML-defined <position> actuators."""
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> XmlPositionActuator:
+    return XmlPositionActuator(self, entity, target_ids, target_names)
+
+
+class XmlPositionActuator(XmlActuator[XmlPositionActuatorCfg]):
+  """Wrapper for XML-defined <position> actuators."""
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    return cmd.position_target
+
+
+@dataclass(kw_only=True)
+class XmlMotorActuatorCfg(ActuatorCfg):
+  """Wrap existing XML-defined <motor> actuators."""
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> XmlMotorActuator:
+    return XmlMotorActuator(self, entity, target_ids, target_names)
+
+
+class XmlMotorActuator(XmlActuator[XmlMotorActuatorCfg]):
+  """Wrapper for XML-defined <motor> actuators."""
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    return cmd.effort_target
+
+
+@dataclass(kw_only=True)
+class XmlVelocityActuatorCfg(ActuatorCfg):
+  """Wrap existing XML-defined <velocity> actuators."""
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> XmlVelocityActuator:
+    return XmlVelocityActuator(self, entity, target_ids, target_names)
+
+
+class XmlVelocityActuator(XmlActuator[XmlVelocityActuatorCfg]):
+  """Wrapper for XML-defined <velocity> actuators."""
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    return cmd.velocity_target
+
+
+@dataclass(kw_only=True)
+class XmlMuscleActuatorCfg(ActuatorCfg):
+  """Wrap existing XML-defined <muscle> actuators."""
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> XmlMuscleActuator:
+    return XmlMuscleActuator(self, entity, target_ids, target_names)
+
+
+class XmlMuscleActuator(XmlActuator[XmlMuscleActuatorCfg]):
+  """Wrapper for XML-defined <muscle> actuators."""
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    return cmd.effort_target

mjlab/src/mjlab/asset_zoo/README.md

@@ -0,0 +1,7 @@
+# Asset Zoo
+
+| Robot | Image |
+|-------|-------|
+| **Unitree G1** | <img src="../../../docs/source/_static/content/g1.png" width="200" height="150" alt="Unitree G1 Humanoid"> |
+| **Unitree Go1** | <img src="../../../docs/source/_static/content/go1.png" width="200" height="150" alt="Unitree Go1 Quadruped"> |
+| **i2rt YAM** | <img src="../../../docs/source/_static/content/yam.png" width="200" height="150" alt="i2rt YAM Robot Arm"> |

mjlab/src/mjlab/entity/__init__.py

@@ -0,0 +1,5 @@
+from mjlab.entity.data import EntityData as EntityData
+from mjlab.entity.entity import Entity as Entity
+from mjlab.entity.entity import EntityArticulationInfoCfg as EntityArticulationInfoCfg
+from mjlab.entity.entity import EntityCfg as EntityCfg
+from mjlab.entity.entity import EntityIndexing as EntityIndexing

mjlab/src/mjlab/entity/data.py

@@ -0,0 +1,576 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Sequence
+
+import mujoco_warp as mjwarp
+import torch
+
+from mjlab.utils.lab_api.math import (
+  quat_apply,
+  quat_apply_inverse,
+  quat_from_matrix,
+  quat_mul,
+)
+
+if TYPE_CHECKING:
+  from mjlab.entity.entity import EntityIndexing
+
+
+def compute_velocity_from_cvel(
+  pos: torch.Tensor,
+  subtree_com: torch.Tensor,
+  cvel: torch.Tensor,
+) -> torch.Tensor:
+  """Convert cvel quantities to world-frame velocities."""
+  lin_vel_c = cvel[..., 3:6]
+  ang_vel_c = cvel[..., 0:3]
+  offset = subtree_com - pos
+  lin_vel_w = lin_vel_c - torch.cross(ang_vel_c, offset, dim=-1)
+  ang_vel_w = ang_vel_c
+  return torch.cat([lin_vel_w, ang_vel_w], dim=-1)
+
+
+@dataclass
+class EntityData:
+  """Data container for an entity.
+
+  Note: Write methods (write_*) modify state directly. Read properties (e.g.,
+  root_link_pose_w) require sim.forward() to be current. If you write then read,
+  call sim.forward() in between. Event order matters when mixing reads and writes.
+  All inputs/outputs use world frame.
+  """
+
+  indexing: EntityIndexing
+  data: mjwarp.Data
+  model: mjwarp.Model
+  device: str
+
+  default_root_state: torch.Tensor
+  default_joint_pos: torch.Tensor
+  default_joint_vel: torch.Tensor
+
+  default_joint_pos_limits: torch.Tensor
+  joint_pos_limits: torch.Tensor
+  soft_joint_pos_limits: torch.Tensor
+
+  gravity_vec_w: torch.Tensor
+  forward_vec_b: torch.Tensor
+
+  is_fixed_base: bool
+  is_articulated: bool
+  is_actuated: bool
+
+  joint_pos_target: torch.Tensor
+  joint_vel_target: torch.Tensor
+  joint_effort_target: torch.Tensor
+
+  tendon_len_target: torch.Tensor
+  tendon_vel_target: torch.Tensor
+  tendon_effort_target: torch.Tensor
+
+  site_effort_target: torch.Tensor
+
+  encoder_bias: torch.Tensor
+
+  # State dimensions.
+  POS_DIM = 3
+  QUAT_DIM = 4
+  LIN_VEL_DIM = 3
+  ANG_VEL_DIM = 3
+  ROOT_POSE_DIM = POS_DIM + QUAT_DIM  # 7
+  ROOT_VEL_DIM = LIN_VEL_DIM + ANG_VEL_DIM  # 6
+  ROOT_STATE_DIM = ROOT_POSE_DIM + ROOT_VEL_DIM  # 13
+
+  def write_root_state(
+    self, root_state: torch.Tensor, env_ids: torch.Tensor | slice | None = None
+  ) -> None:
+    if self.is_fixed_base:
+      raise ValueError("Cannot write root state for fixed-base entity.")
+    assert root_state.shape[-1] == self.ROOT_STATE_DIM
+
+    self.write_root_pose(root_state[:, : self.ROOT_POSE_DIM], env_ids)
+    self.write_root_velocity(root_state[:, self.ROOT_POSE_DIM :], env_ids)
+
+  def write_root_pose(
+    self, pose: torch.Tensor, env_ids: torch.Tensor | slice | None = None
+  ) -> None:
+    if self.is_fixed_base:
+      raise ValueError("Cannot write root pose for fixed-base entity.")
+    assert pose.shape[-1] == self.ROOT_POSE_DIM
+
+    env_ids = self._resolve_env_ids(env_ids)
+    self.data.qpos[env_ids, self.indexing.free_joint_q_adr] = pose
+
+  def write_root_velocity(
+    self, velocity: torch.Tensor, env_ids: torch.Tensor | slice | None = None
+  ) -> None:
+    if self.is_fixed_base:
+      raise ValueError("Cannot write root velocity for fixed-base entity.")
+    assert velocity.shape[-1] == self.ROOT_VEL_DIM
+
+    env_ids = self._resolve_env_ids(env_ids)
+    quat_w = self.data.qpos[env_ids, self.indexing.free_joint_q_adr[3:7]]
+    ang_vel_b = quat_apply_inverse(quat_w, velocity[:, 3:])
+    velocity_qvel = torch.cat([velocity[:, :3], ang_vel_b], dim=-1)
+    self.data.qvel[env_ids, self.indexing.free_joint_v_adr] = velocity_qvel
+
+  def write_root_com_velocity(
+    self, velocity: torch.Tensor, env_ids: torch.Tensor | slice | None = None
+  ) -> None:
+    if self.is_fixed_base:
+      raise ValueError("Cannot write root COM velocity for fixed-base entity.")
+    assert velocity.shape[-1] == self.ROOT_VEL_DIM
+
+    env_ids = self._resolve_env_ids(env_ids)
+    com_offset_b = self.model.body_ipos[:, self.indexing.root_body_id]
+    quat_w = self.data.qpos[env_ids, self.indexing.free_joint_q_adr[3:7]]
+    com_offset_w = quat_apply(quat_w, com_offset_b[env_ids])
+    lin_vel_com = velocity[:, :3]
+    ang_vel_w = velocity[:, 3:]
+    lin_vel_link = lin_vel_com - torch.cross(ang_vel_w, com_offset_w, dim=-1)
+    link_velocity = torch.cat([lin_vel_link, ang_vel_w], dim=-1)
+    self.write_root_velocity(link_velocity, env_ids)
+
+  def write_joint_state(
+    self,
+    position: torch.Tensor,
+    velocity: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    if not self.is_articulated:
+      raise ValueError("Cannot write joint state for non-articulated entity.")
+
+    self.write_joint_position(position, joint_ids, env_ids)
+    self.write_joint_velocity(velocity, joint_ids, env_ids)
+
+  def write_joint_position(
+    self,
+    position: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    if not self.is_articulated:
+      raise ValueError("Cannot write joint position for non-articulated entity.")
+
+    env_ids = self._resolve_env_ids(env_ids)
+    joint_ids = joint_ids if joint_ids is not None else slice(None)
+    q_slice = self.indexing.joint_q_adr[joint_ids]
+    self.data.qpos[env_ids, q_slice] = position
+
+  def write_joint_velocity(
+    self,
+    velocity: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    if not self.is_articulated:
+      raise ValueError("Cannot write joint velocity for non-articulated entity.")
+
+    env_ids = self._resolve_env_ids(env_ids)
+    joint_ids = joint_ids if joint_ids is not None else slice(None)
+    v_slice = self.indexing.joint_v_adr[joint_ids]
+    self.data.qvel[env_ids, v_slice] = velocity
+
+  def write_external_wrench(
+    self,
+    force: torch.Tensor | None,
+    torque: torch.Tensor | None,
+    body_ids: Sequence[int] | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    env_ids = self._resolve_env_ids(env_ids)
+    local_body_ids = body_ids if body_ids is not None else slice(None)
+    global_body_ids = self.indexing.body_ids[local_body_ids]
+    if force is not None:
+      self.data.xfrc_applied[env_ids, global_body_ids, 0:3] = force
+    if torque is not None:
+      self.data.xfrc_applied[env_ids, global_body_ids, 3:6] = torque
+
+  def write_ctrl(
+    self,
+    ctrl: torch.Tensor,
+    ctrl_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    if not self.is_actuated:
+      raise ValueError("Cannot write control for non-actuated entity.")
+
+    env_ids = self._resolve_env_ids(env_ids)
+    local_ctrl_ids = ctrl_ids if ctrl_ids is not None else slice(None)
+    global_ctrl_ids = self.indexing.ctrl_ids[local_ctrl_ids]
+    self.data.ctrl[env_ids, global_ctrl_ids] = ctrl
+
+  def write_mocap_pose(
+    self, pose: torch.Tensor, env_ids: torch.Tensor | slice | None = None
+  ) -> None:
+    if self.indexing.mocap_id is None:
+      raise ValueError("Cannot write mocap pose for non-mocap entity.")
+    assert pose.shape[-1] == self.ROOT_POSE_DIM
+
+    env_ids = self._resolve_env_ids(env_ids)
+    self.data.mocap_pos[env_ids, self.indexing.mocap_id] = pose[:, 0:3].unsqueeze(1)
+    self.data.mocap_quat[env_ids, self.indexing.mocap_id] = pose[:, 3:7].unsqueeze(1)
+
+  def clear_state(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    if self.is_actuated:
+      env_ids = self._resolve_env_ids(env_ids)
+      self.joint_pos_target[env_ids] = 0.0
+      self.joint_vel_target[env_ids] = 0.0
+      self.joint_effort_target[env_ids] = 0.0
+      self.tendon_len_target[env_ids] = 0.0
+      self.tendon_vel_target[env_ids] = 0.0
+      self.tendon_effort_target[env_ids] = 0.0
+      self.site_effort_target[env_ids] = 0.0
+
+  def _resolve_env_ids(
+    self, env_ids: torch.Tensor | slice | None
+  ) -> torch.Tensor | slice:
+    """Convert env_ids to consistent indexing format."""
+    if env_ids is None:
+      return slice(None)
+    if isinstance(env_ids, torch.Tensor):
+      return env_ids[:, None]
+    return env_ids
+
+  # Root properties
+
+  @property
+  def root_link_pose_w(self) -> torch.Tensor:
+    """Root link pose in world frame. Shape (num_envs, 7)."""
+    pos_w = self.data.xpos[:, self.indexing.root_body_id]  # (num_envs, 3)
+    quat_w = self.data.xquat[:, self.indexing.root_body_id]  # (num_envs, 4)
+    return torch.cat([pos_w, quat_w], dim=-1)  # (num_envs, 7)
+
+  @property
+  def root_link_vel_w(self) -> torch.Tensor:
+    """Root link velocity in world frame. Shape (num_envs, 6)."""
+    # NOTE: Equivalently, can read this from qvel[:6] but the angular part
+    # will be in body frame and needs to be rotated to world frame.
+    # Note also that an extra forward() call might be required to make
+    # both values equal.
+    pos = self.data.xpos[:, self.indexing.root_body_id]  # (num_envs, 3)
+    subtree_com = self.data.subtree_com[:, self.indexing.root_body_id]
+    cvel = self.data.cvel[:, self.indexing.root_body_id]  # (num_envs, 6)
+    return compute_velocity_from_cvel(pos, subtree_com, cvel)  # (num_envs, 6)
+
+  @property
+  def root_com_pose_w(self) -> torch.Tensor:
+    """Root center-of-mass pose in world frame. Shape (num_envs, 7)."""
+    pos_w = self.data.xipos[:, self.indexing.root_body_id]
+    quat = self.data.xquat[:, self.indexing.root_body_id]
+    body_iquat = self.model.body_iquat[:, self.indexing.root_body_id]
+    assert body_iquat is not None
+    quat_w = quat_mul(quat, body_iquat.squeeze(1))
+    return torch.cat([pos_w, quat_w], dim=-1)
+
+  @property
+  def root_com_vel_w(self) -> torch.Tensor:
+    """Root center-of-mass velocity in world frame. Shape (num_envs, 6)."""
+    # NOTE: Equivalent sensor is framelinvel/frameangvel with objtype="body".
+    pos = self.data.xipos[:, self.indexing.root_body_id]  # (num_envs, 3)
+    subtree_com = self.data.subtree_com[:, self.indexing.root_body_id]
+    cvel = self.data.cvel[:, self.indexing.root_body_id]  # (num_envs, 6)
+    return compute_velocity_from_cvel(pos, subtree_com, cvel)  # (num_envs, 6)
+
+  # Body properties
+
+  @property
+  def body_link_pose_w(self) -> torch.Tensor:
+    """Body link pose in world frame. Shape (num_envs, num_bodies, 7)."""
+    pos_w = self.data.xpos[:, self.indexing.body_ids]
+    quat_w = self.data.xquat[:, self.indexing.body_ids]
+    return torch.cat([pos_w, quat_w], dim=-1)
+
+  @property
+  def body_link_vel_w(self) -> torch.Tensor:
+    """Body link velocity in world frame. Shape (num_envs, num_bodies, 6)."""
+    # NOTE: Equivalent sensor is framelinvel/frameangvel with objtype="xbody".
+    pos = self.data.xpos[:, self.indexing.body_ids]  # (num_envs, num_bodies, 3)
+    subtree_com = self.data.subtree_com[:, self.indexing.root_body_id]
+    cvel = self.data.cvel[:, self.indexing.body_ids]
+    return compute_velocity_from_cvel(pos, subtree_com.unsqueeze(1), cvel)
+
+  @property
+  def body_com_pose_w(self) -> torch.Tensor:
+    """Body center-of-mass pose in world frame. Shape (num_envs, num_bodies, 7)."""
+    pos_w = self.data.xipos[:, self.indexing.body_ids]
+    quat = self.data.xquat[:, self.indexing.body_ids]
+    body_iquat = self.model.body_iquat[:, self.indexing.body_ids]
+    quat_w = quat_mul(quat, body_iquat)
+    return torch.cat([pos_w, quat_w], dim=-1)
+
+  @property
+  def body_com_vel_w(self) -> torch.Tensor:
+    """Body center-of-mass velocity in world frame. Shape (num_envs, num_bodies, 6)."""
+    # NOTE: Equivalent sensor is framelinvel/frameangvel with objtype="body".
+    pos = self.data.xipos[:, self.indexing.body_ids]
+    subtree_com = self.data.subtree_com[:, self.indexing.root_body_id]
+    cvel = self.data.cvel[:, self.indexing.body_ids]
+    return compute_velocity_from_cvel(pos, subtree_com.unsqueeze(1), cvel)
+
+  @property
+  def body_external_wrench(self) -> torch.Tensor:
+    """Body external wrench in world frame. Shape (num_envs, num_bodies, 6)."""
+    return self.data.xfrc_applied[:, self.indexing.body_ids]
+
+  # Geom properties
+
+  @property
+  def geom_pose_w(self) -> torch.Tensor:
+    """Geom pose in world frame. Shape (num_envs, num_geoms, 7)."""
+    pos_w = self.data.geom_xpos[:, self.indexing.geom_ids]
+    xmat = self.data.geom_xmat[:, self.indexing.geom_ids]
+    quat_w = quat_from_matrix(xmat)
+    return torch.cat([pos_w, quat_w], dim=-1)
+
+  @property
+  def geom_vel_w(self) -> torch.Tensor:
+    """Geom velocity in world frame. Shape (num_envs, num_geoms, 6)."""
+    pos = self.data.geom_xpos[:, self.indexing.geom_ids]
+    body_ids = self.model.geom_bodyid[self.indexing.geom_ids]  # (num_geoms,)
+    subtree_com = self.data.subtree_com[:, self.indexing.root_body_id]
+    cvel = self.data.cvel[:, body_ids]
+    return compute_velocity_from_cvel(pos, subtree_com.unsqueeze(1), cvel)
+
+  # Site properties
+
+  @property
+  def site_pose_w(self) -> torch.Tensor:
+    """Site pose in world frame. Shape (num_envs, num_sites, 7)."""
+    pos_w = self.data.site_xpos[:, self.indexing.site_ids]
+    mat_w = self.data.site_xmat[:, self.indexing.site_ids]
+    quat_w = quat_from_matrix(mat_w)
+    return torch.cat([pos_w, quat_w], dim=-1)
+
+  @property
+  def site_vel_w(self) -> torch.Tensor:
+    """Site velocity in world frame. Shape (num_envs, num_sites, 6)."""
+    pos = self.data.site_xpos[:, self.indexing.site_ids]
+    body_ids = self.model.site_bodyid[self.indexing.site_ids]  # (num_sites,)
+    subtree_com = self.data.subtree_com[:, self.indexing.root_body_id]
+    cvel = self.data.cvel[:, body_ids]
+    return compute_velocity_from_cvel(pos, subtree_com.unsqueeze(1), cvel)
+
+  # Joint properties
+
+  @property
+  def joint_pos(self) -> torch.Tensor:
+    """Joint positions. Shape (num_envs, num_joints)."""
+    return self.data.qpos[:, self.indexing.joint_q_adr]
+
+  @property
+  def joint_pos_biased(self) -> torch.Tensor:
+    """Joint positions with encoder bias applied. Shape (num_envs, num_joints)."""
+    return self.joint_pos + self.encoder_bias
+
+  @property
+  def joint_vel(self) -> torch.Tensor:
+    """Joint velocities. Shape (num_envs, nv)."""
+    return self.data.qvel[:, self.indexing.joint_v_adr]
+
+  @property
+  def joint_acc(self) -> torch.Tensor:
+    """Joint accelerations. Shape (num_envs, nv)."""
+    return self.data.qacc[:, self.indexing.joint_v_adr]
+
+  # Tendon properties
+
+  @property
+  def tendon_len(self) -> torch.Tensor:
+    """Tendon lengths. Shape (num_envs, num_tendons)."""
+    return self.data.ten_length[:, self.indexing.tendon_ids]
+
+  @property
+  def tendon_vel(self) -> torch.Tensor:
+    """Tendon velocities. Shape (num_envs, num_tendons)."""
+    return self.data.ten_velocity[:, self.indexing.tendon_ids]
+
+  @property
+  def joint_torques(self) -> torch.Tensor:
+    """Joint torques. Shape (num_envs, nv)."""
+    raise NotImplementedError(
+      "Joint torques are not currently available. "
+      "Consider using 'actuator_force' property for actuation forces, "
+      "or 'generalized_force' property for generalized forces applied to the DoFs."
+    )
+
+  @property
+  def actuator_force(self) -> torch.Tensor:
+    """Scalar actuation force in actuation space. Shape (num_envs, nu)."""
+    return self.data.actuator_force[:, self.indexing.ctrl_ids]
+
+  @property
+  def generalized_force(self) -> torch.Tensor:
+    """Generalized forces applied to the DoFs. Shape (num_envs, nv)."""
+    return self.data.qfrc_applied[:, self.indexing.free_joint_v_adr]
+
+  # Pose and velocity component accessors.
+
+  @property
+  def root_link_pos_w(self) -> torch.Tensor:
+    """Root link position in world frame. Shape (num_envs, 3)."""
+    return self.root_link_pose_w[:, 0:3]
+
+  @property
+  def root_link_quat_w(self) -> torch.Tensor:
+    """Root link quaternion in world frame. Shape (num_envs, 4)."""
+    return self.root_link_pose_w[:, 3:7]
+
+  @property
+  def root_link_lin_vel_w(self) -> torch.Tensor:
+    """Root link linear velocity in world frame. Shape (num_envs, 3)."""
+    return self.root_link_vel_w[:, 0:3]
+
+  @property
+  def root_link_ang_vel_w(self) -> torch.Tensor:
+    """Root link angular velocity in world frame. Shape (num_envs, 3)."""
+    return self.data.cvel[:, self.indexing.root_body_id, 0:3]
+
+  @property
+  def root_com_pos_w(self) -> torch.Tensor:
+    """Root COM position in world frame. Shape (num_envs, 3)."""
+    return self.root_com_pose_w[:, 0:3]
+
+  @property
+  def root_com_quat_w(self) -> torch.Tensor:
+    """Root COM quaternion in world frame. Shape (num_envs, 4)."""
+    return self.root_com_pose_w[:, 3:7]
+
+  @property
+  def root_com_lin_vel_w(self) -> torch.Tensor:
+    """Root COM linear velocity in world frame. Shape (num_envs, 3)."""
+    return self.root_com_vel_w[:, 0:3]
+
+  @property
+  def root_com_ang_vel_w(self) -> torch.Tensor:
+    """Root COM angular velocity in world frame. Shape (num_envs, 3)."""
+    # Angular velocity is the same for link and COM frames.
+    return self.data.cvel[:, self.indexing.root_body_id, 0:3]
+
+  @property
+  def body_link_pos_w(self) -> torch.Tensor:
+    """Body link positions in world frame. Shape (num_envs, num_bodies, 3)."""
+    return self.body_link_pose_w[..., 0:3]
+
+  @property
+  def body_link_quat_w(self) -> torch.Tensor:
+    """Body link quaternions in world frame. Shape (num_envs, num_bodies, 4)."""
+    return self.body_link_pose_w[..., 3:7]
+
+  @property
+  def body_link_lin_vel_w(self) -> torch.Tensor:
+    """Body link linear velocities in world frame. Shape (num_envs, num_bodies, 3)."""
+    return self.body_link_vel_w[..., 0:3]
+
+  @property
+  def body_link_ang_vel_w(self) -> torch.Tensor:
+    """Body link angular velocities in world frame. Shape (num_envs, num_bodies, 3)."""
+    return self.data.cvel[:, self.indexing.body_ids, 0:3]
+
+  @property
+  def body_com_pos_w(self) -> torch.Tensor:
+    """Body COM positions in world frame. Shape (num_envs, num_bodies, 3)."""
+    return self.body_com_pose_w[..., 0:3]
+
+  @property
+  def body_com_quat_w(self) -> torch.Tensor:
+    """Body COM quaternions in world frame. Shape (num_envs, num_bodies, 4)."""
+    return self.body_com_pose_w[..., 3:7]
+
+  @property
+  def body_com_lin_vel_w(self) -> torch.Tensor:
+    """Body COM linear velocities in world frame. Shape (num_envs, num_bodies, 3)."""
+    return self.body_com_vel_w[..., 0:3]
+
+  @property
+  def body_com_ang_vel_w(self) -> torch.Tensor:
+    """Body COM angular velocities in world frame. Shape (num_envs, num_bodies, 3)."""
+    # Angular velocity is the same for link and COM frames.
+    return self.data.cvel[:, self.indexing.body_ids, 0:3]
+
+  @property
+  def body_external_force(self) -> torch.Tensor:
+    """Body external forces in world frame. Shape (num_envs, num_bodies, 3)."""
+    return self.body_external_wrench[..., 0:3]
+
+  @property
+  def body_external_torque(self) -> torch.Tensor:
+    """Body external torques in world frame. Shape (num_envs, num_bodies, 3)."""
+    return self.body_external_wrench[..., 3:6]
+
+  @property
+  def geom_pos_w(self) -> torch.Tensor:
+    """Geom positions in world frame. Shape (num_envs, num_geoms, 3)."""
+    return self.geom_pose_w[..., 0:3]
+
+  @property
+  def geom_quat_w(self) -> torch.Tensor:
+    """Geom quaternions in world frame. Shape (num_envs, num_geoms, 4)."""
+    return self.geom_pose_w[..., 3:7]
+
+  @property
+  def geom_lin_vel_w(self) -> torch.Tensor:
+    """Geom linear velocities in world frame. Shape (num_envs, num_geoms, 3)."""
+    return self.geom_vel_w[..., 0:3]
+
+  @property
+  def geom_ang_vel_w(self) -> torch.Tensor:
+    """Geom angular velocities in world frame. Shape (num_envs, num_geoms, 3)."""
+    body_ids = self.model.geom_bodyid[self.indexing.geom_ids]
+    return self.data.cvel[:, body_ids, 0:3]
+
+  @property
+  def site_pos_w(self) -> torch.Tensor:
+    """Site positions in world frame. Shape (num_envs, num_sites, 3)."""
+    return self.site_pose_w[..., 0:3]
+
+  @property
+  def site_quat_w(self) -> torch.Tensor:
+    """Site quaternions in world frame. Shape (num_envs, num_sites, 4)."""
+    return self.site_pose_w[..., 3:7]
+
+  @property
+  def site_lin_vel_w(self) -> torch.Tensor:
+    """Site linear velocities in world frame. Shape (num_envs, num_sites, 3)."""
+    return self.site_vel_w[..., 0:3]
+
+  @property
+  def site_ang_vel_w(self) -> torch.Tensor:
+    """Site angular velocities in world frame. Shape (num_envs, num_sites, 3)."""
+    body_ids = self.model.site_bodyid[self.indexing.site_ids]
+    return self.data.cvel[:, body_ids, 0:3]
+
+  # Derived properties.
+
+  @property
+  def projected_gravity_b(self) -> torch.Tensor:
+    """Gravity vector projected into body frame. Shape (num_envs, 3)."""
+    return quat_apply_inverse(self.root_link_quat_w, self.gravity_vec_w)
+
+  @property
+  def heading_w(self) -> torch.Tensor:
+    """Heading angle in world frame. Shape (num_envs,)."""
+    forward_w = quat_apply(self.root_link_quat_w, self.forward_vec_b)
+    return torch.atan2(forward_w[:, 1], forward_w[:, 0])
+
+  @property
+  def root_link_lin_vel_b(self) -> torch.Tensor:
+    """Root link linear velocity in body frame. Shape (num_envs, 3)."""
+    return quat_apply_inverse(self.root_link_quat_w, self.root_link_lin_vel_w)
+
+  @property
+  def root_link_ang_vel_b(self) -> torch.Tensor:
+    """Root link angular velocity in body frame. Shape (num_envs, 3)."""
+    return quat_apply_inverse(self.root_link_quat_w, self.root_link_ang_vel_w)
+
+  @property
+  def root_com_lin_vel_b(self) -> torch.Tensor:
+    """Root COM linear velocity in body frame. Shape (num_envs, 3)."""
+    return quat_apply_inverse(self.root_link_quat_w, self.root_com_lin_vel_w)
+
+  @property
+  def root_com_ang_vel_b(self) -> torch.Tensor:
+    """Root COM angular velocity in body frame. Shape (num_envs, 3)."""
+    return quat_apply_inverse(self.root_link_quat_w, self.root_com_ang_vel_w)

mjlab/src/mjlab/entity/entity.py

@@ -0,0 +1,985 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable, Sequence
+
+import mujoco
+import mujoco_warp as mjwarp
+import numpy as np
+import torch
+
+from mjlab import actuator
+from mjlab.actuator import BuiltinActuatorGroup
+from mjlab.actuator.actuator import TransmissionType
+from mjlab.entity.data import EntityData
+from mjlab.utils import spec_config as spec_cfg
+from mjlab.utils.lab_api.string import resolve_matching_names
+from mjlab.utils.mujoco import dof_width, qpos_width
+from mjlab.utils.spec import auto_wrap_fixed_base_mocap
+from mjlab.utils.string import resolve_expr
+
+
+@dataclass(frozen=False)
+class EntityIndexing:
+  """Maps entity elements to global indices and addresses in the simulation."""
+
+  # Elements.
+  bodies: tuple[mujoco.MjsBody, ...]
+  joints: tuple[mujoco.MjsJoint, ...]
+  geoms: tuple[mujoco.MjsGeom, ...]
+  sites: tuple[mujoco.MjsSite, ...]
+  tendons: tuple[mujoco.MjsTendon, ...]
+  actuators: tuple[mujoco.MjsActuator, ...] | None
+
+  # Indices.
+  body_ids: torch.Tensor
+  geom_ids: torch.Tensor
+  site_ids: torch.Tensor
+  tendon_ids: torch.Tensor
+  ctrl_ids: torch.Tensor
+  joint_ids: torch.Tensor
+  mocap_id: int | None
+
+  # Addresses.
+  joint_q_adr: torch.Tensor
+  joint_v_adr: torch.Tensor
+  free_joint_q_adr: torch.Tensor
+  free_joint_v_adr: torch.Tensor
+
+  @property
+  def root_body_id(self) -> int:
+    return self.bodies[0].id
+
+
+@dataclass
+class EntityCfg:
+  @dataclass
+  class InitialStateCfg:
+    # Root position and orientation.
+    pos: tuple[float, float, float] = (0.0, 0.0, 0.0)
+    rot: tuple[float, float, float, float] = (1.0, 0.0, 0.0, 0.0)
+    # Root linear and angular velocity (only for floating base entities).
+    lin_vel: tuple[float, float, float] = (0.0, 0.0, 0.0)
+    ang_vel: tuple[float, float, float] = (0.0, 0.0, 0.0)
+    # Articulation (only for articulated entities).
+    # Set to None to use the model's existing keyframe (errors if none exists).
+    joint_pos: dict[str, float] | None = field(default_factory=lambda: {".*": 0.0})
+    joint_vel: dict[str, float] = field(default_factory=lambda: {".*": 0.0})
+
+  init_state: InitialStateCfg = field(default_factory=InitialStateCfg)
+  spec_fn: Callable[[], mujoco.MjSpec] = field(
+    default_factory=lambda: (lambda: mujoco.MjSpec())
+  )
+  articulation: EntityArticulationInfoCfg | None = None
+
+  # Editors.
+  lights: tuple[spec_cfg.LightCfg, ...] = field(default_factory=tuple)
+  cameras: tuple[spec_cfg.CameraCfg, ...] = field(default_factory=tuple)
+  textures: tuple[spec_cfg.TextureCfg, ...] = field(default_factory=tuple)
+  materials: tuple[spec_cfg.MaterialCfg, ...] = field(default_factory=tuple)
+  collisions: tuple[spec_cfg.CollisionCfg, ...] = field(default_factory=tuple)
+
+  def build(self) -> Entity:
+    """Build entity instance from this config.
+
+    Override in subclasses to return custom Entity types.
+    """
+    return Entity(self)
+
+
+@dataclass
+class EntityArticulationInfoCfg:
+  actuators: tuple[actuator.ActuatorCfg, ...] = field(default_factory=tuple)
+  soft_joint_pos_limit_factor: float = 1.0
+
+
+class Entity:
+  """An entity represents a physical object in the simulation.
+
+  Entity Type Matrix
+  ==================
+  MuJoCo entities can be categorized along two dimensions:
+
+  1. Base Type:
+    - Fixed Base: Entity is welded to the world (no freejoint)
+    - Floating Base: Entity has 6 DOF movement (has freejoint)
+
+  2. Articulation:
+    - Non-articulated: No joints other than freejoint
+    - Articulated: Has joints in kinematic tree (may or may not be actuated)
+
+  Fixed non-articulated entities can optionally be mocap bodies, whereby their
+  position and orientation can be set directly each timestep rather than being
+  determined by physics. This property can be useful for creating props with
+  adjustable position and orientation.
+
+  Supported Combinations:
+  ----------------------
+  | Type                      | Example             | is_fixed_base | is_articulated | is_actuated |
+  |---------------------------|---------------------|---------------|----------------|-------------|
+  | Fixed Non-articulated     | Table, wall         | True          | False          | False       |
+  | Fixed Articulated         | Robot arm, door     | True          | True           | True/False  |
+  | Floating Non-articulated  | Box, ball, mug      | False         | False          | False       |
+  | Floating Articulated      | Humanoid, quadruped | False         | True           | True/False  |
+  """
+
+  def __init__(self, cfg: EntityCfg) -> None:
+    self.cfg = cfg
+    self._spec = auto_wrap_fixed_base_mocap(cfg.spec_fn)()
+
+    # Identify free joint and articulated joints.
+    self._all_joints = self._spec.joints
+    self._free_joint = None
+    self._non_free_joints = tuple(self._all_joints)
+    if self._all_joints and self._all_joints[0].type == mujoco.mjtJoint.mjJNT_FREE:
+      self._free_joint = self._all_joints[0]
+      if not self._free_joint.name:
+        self._free_joint.name = "floating_base_joint"
+      self._non_free_joints = tuple(self._all_joints[1:])
+    self._actuators: list[actuator.Actuator] = []
+
+    self._apply_spec_editors()
+    self._add_actuators()
+    self._add_initial_state_keyframe()
+
+  def _apply_spec_editors(self) -> None:
+    for cfg_list in [
+      self.cfg.lights,
+      self.cfg.cameras,
+      self.cfg.textures,
+      self.cfg.materials,
+      self.cfg.collisions,
+    ]:
+      for cfg in cfg_list:
+        cfg.edit_spec(self._spec)
+
+  def _add_actuators(self) -> None:
+    if self.cfg.articulation is None:
+      return
+
+    for actuator_cfg in self.cfg.articulation.actuators:
+      # Find targets based on transmission type.
+      if actuator_cfg.transmission_type == TransmissionType.JOINT:
+        target_ids, target_names = self.find_joints(actuator_cfg.target_names_expr)
+      elif actuator_cfg.transmission_type == TransmissionType.TENDON:
+        target_ids, target_names = self.find_tendons(actuator_cfg.target_names_expr)
+      elif actuator_cfg.transmission_type == TransmissionType.SITE:
+        target_ids, target_names = self.find_sites(actuator_cfg.target_names_expr)
+      else:
+        raise ValueError(
+          f"Invalid transmission_type: {actuator_cfg.transmission_type}. "
+          f"Must be TransmissionType.JOINT, TransmissionType.TENDON, or TransmissionType.SITE."
+        )
+
+      if len(target_names) == 0:
+        raise ValueError(
+          f"No {actuator_cfg.transmission_type}s found for actuator with "
+          f"expressions: {actuator_cfg.target_names_expr}"
+        )
+      actuator_instance = actuator_cfg.build(self, target_ids, target_names)
+      actuator_instance.edit_spec(self._spec, target_names)
+      self._actuators.append(actuator_instance)
+
+  def _add_initial_state_keyframe(self) -> None:
+    # If joint_pos is None, use existing keyframe from the model.
+    if self.cfg.init_state.joint_pos is None:
+      if not self._spec.keys:
+        raise ValueError(
+          "joint_pos=None requires the model to have a keyframe, but none exists."
+        )
+      # Keep the existing keyframe, just rename it.
+      self._spec.keys[0].name = "init_state"
+      if self.is_fixed_base:
+        self.root_body.pos[:] = self.cfg.init_state.pos
+        self.root_body.quat[:] = self.cfg.init_state.rot
+      return
+
+    qpos_components = []
+
+    if self._free_joint is not None:
+      qpos_components.extend([self.cfg.init_state.pos, self.cfg.init_state.rot])
+
+    joint_pos = None
+    if self._non_free_joints:
+      joint_pos = resolve_expr(self.cfg.init_state.joint_pos, self.joint_names, 0.0)
+      qpos_components.append(joint_pos)
+
+    key_qpos = np.hstack(qpos_components) if qpos_components else np.array([])
+    key = self._spec.add_key(name="init_state", qpos=key_qpos.tolist())
+
+    if self.is_actuated and joint_pos is not None:
+      name_to_pos = {name: joint_pos[i] for i, name in enumerate(self.joint_names)}
+      ctrl = []
+      for act in self._spec.actuators:
+        joint_name = act.target
+        ctrl.append(name_to_pos.get(joint_name, 0.0))
+      key.ctrl = np.array(ctrl)
+
+    if self.is_fixed_base:
+      self.root_body.pos[:] = self.cfg.init_state.pos
+      self.root_body.quat[:] = self.cfg.init_state.rot
+
+  # Attributes.
+
+  @property
+  def is_fixed_base(self) -> bool:
+    """Entity is welded to the world."""
+    return self._free_joint is None
+
+  @property
+  def is_articulated(self) -> bool:
+    """Entity is articulated (has fixed or actuated joints)."""
+    return len(self._non_free_joints) > 0
+
+  @property
+  def is_actuated(self) -> bool:
+    """Entity has actuated joints."""
+    return len(self._actuators) > 0
+
+  @property
+  def has_tendon_actuators(self) -> bool:
+    """Entity has actuators using tendon transmission."""
+    if self.cfg.articulation is None:
+      return False
+    return any(
+      act.transmission_type == TransmissionType.TENDON
+      for act in self.cfg.articulation.actuators
+    )
+
+  @property
+  def has_site_actuators(self) -> bool:
+    """Entity has actuators using site transmission."""
+    if self.cfg.articulation is None:
+      return False
+    return any(
+      act.transmission_type == TransmissionType.SITE
+      for act in self.cfg.articulation.actuators
+    )
+
+  @property
+  def is_mocap(self) -> bool:
+    """Entity root body is a mocap body (only for fixed-base entities)."""
+    return bool(self.root_body.mocap) if self.is_fixed_base else False
+
+  @property
+  def spec(self) -> mujoco.MjSpec:
+    return self._spec
+
+  @property
+  def data(self) -> EntityData:
+    return self._data
+
+  @property
+  def actuators(self) -> list[actuator.Actuator]:
+    return self._actuators
+
+  @property
+  def all_joint_names(self) -> tuple[str, ...]:
+    return tuple(j.name.split("/")[-1] for j in self._all_joints)
+
+  @property
+  def joint_names(self) -> tuple[str, ...]:
+    return tuple(j.name.split("/")[-1] for j in self._non_free_joints)
+
+  @property
+  def body_names(self) -> tuple[str, ...]:
+    return tuple(b.name.split("/")[-1] for b in self.spec.bodies[1:])
+
+  @property
+  def geom_names(self) -> tuple[str, ...]:
+    return tuple(g.name.split("/")[-1] for g in self.spec.geoms)
+
+  @property
+  def tendon_names(self) -> tuple[str, ...]:
+    return tuple(t.name.split("/")[-1] for t in self._spec.tendons)
+
+  @property
+  def site_names(self) -> tuple[str, ...]:
+    return tuple(s.name.split("/")[-1] for s in self.spec.sites)
+
+  @property
+  def actuator_names(self) -> tuple[str, ...]:
+    return tuple(a.name.split("/")[-1] for a in self.spec.actuators)
+
+  @property
+  def num_joints(self) -> int:
+    return len(self.joint_names)
+
+  @property
+  def num_bodies(self) -> int:
+    return len(self.body_names)
+
+  @property
+  def num_geoms(self) -> int:
+    return len(self.geom_names)
+
+  @property
+  def num_sites(self) -> int:
+    return len(self.site_names)
+
+  @property
+  def num_actuators(self) -> int:
+    return len(self.actuator_names)
+
+  @property
+  def root_body(self) -> mujoco.MjsBody:
+    return self.spec.bodies[1]
+
+  # Methods.
+
+  def find_bodies(
+    self, name_keys: str | Sequence[str], preserve_order: bool = False
+  ) -> tuple[list[int], list[str]]:
+    return resolve_matching_names(name_keys, self.body_names, preserve_order)
+
+  def find_joints(
+    self,
+    name_keys: str | Sequence[str],
+    joint_subset: Sequence[str] | None = None,
+    preserve_order: bool = False,
+  ) -> tuple[list[int], list[str]]:
+    if joint_subset is None:
+      joint_subset = self.joint_names
+    return resolve_matching_names(name_keys, joint_subset, preserve_order)
+
+  def find_actuators(
+    self,
+    name_keys: str | Sequence[str],
+    actuator_subset: Sequence[str] | None = None,
+    preserve_order: bool = False,
+  ) -> tuple[list[int], list[str]]:
+    if actuator_subset is None:
+      actuator_subset = self.actuator_names
+    return resolve_matching_names(name_keys, actuator_subset, preserve_order)
+
+  def find_tendons(
+    self,
+    name_keys: str | Sequence[str],
+    tendon_subset: Sequence[str] | None = None,
+    preserve_order: bool = False,
+  ) -> tuple[list[int], list[str]]:
+    if tendon_subset is None:
+      tendon_subset = self.tendon_names
+    return resolve_matching_names(name_keys, tendon_subset, preserve_order)
+
+  def find_joints_by_actuator_names(
+    self,
+    actuator_name_keys: str | Sequence[str],
+  ) -> tuple[list[int], list[str]]:
+    # Collect all actuated joint names.
+    actuated_joint_names_set = set()
+    for act in self._actuators:
+      actuated_joint_names_set.update(act.target_names)
+
+    # Filter self.joint_names to only actuated joints, preserving natural order.
+    actuated_in_natural_order = [
+      name for name in self.joint_names if name in actuated_joint_names_set
+    ]
+
+    # Find joints matching the pattern within actuated joints.
+    _, matched_joint_names = self.find_joints(
+      actuator_name_keys, joint_subset=actuated_in_natural_order, preserve_order=False
+    )
+
+    # Map joint names back to entity-local indices (indices into self.joint_names).
+    name_to_entity_idx = {name: i for i, name in enumerate(self.joint_names)}
+    joint_ids = [name_to_entity_idx[name] for name in matched_joint_names]
+    return joint_ids, matched_joint_names
+
+  def find_geoms(
+    self,
+    name_keys: str | Sequence[str],
+    geom_subset: Sequence[str] | None = None,
+    preserve_order: bool = False,
+  ) -> tuple[list[int], list[str]]:
+    if geom_subset is None:
+      geom_subset = self.geom_names
+    return resolve_matching_names(name_keys, geom_subset, preserve_order)
+
+  def find_sites(
+    self,
+    name_keys: str | Sequence[str],
+    site_subset: Sequence[str] | None = None,
+    preserve_order: bool = False,
+  ) -> tuple[list[int], list[str]]:
+    if site_subset is None:
+      site_subset = self.site_names
+    return resolve_matching_names(name_keys, site_subset, preserve_order)
+
+  def compile(self) -> mujoco.MjModel:
+    """Compile the underlying MjSpec into an MjModel."""
+    return self.spec.compile()
+
+  def write_xml(self, xml_path: Path) -> None:
+    """Write the MjSpec to disk."""
+    with open(xml_path, "w") as f:
+      f.write(self.spec.to_xml())
+
+  def to_zip(self, path: Path) -> None:
+    """Write the MjSpec to a zip file."""
+    with path.open("wb") as f:
+      mujoco.MjSpec.to_zip(self.spec, f)
+
+  def initialize(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+    device: str,
+  ) -> None:
+    indexing = self._compute_indexing(mj_model, device)
+    self.indexing = indexing
+    nworld = data.nworld
+
+    for act in self._actuators:
+      act.initialize(mj_model, model, data, device)
+
+    # Vectorize built-in actuators; we'll loop through custom ones.
+    builtin_group, custom_actuators = BuiltinActuatorGroup.process(self._actuators)
+    self._builtin_group = builtin_group
+    self._custom_actuators = custom_actuators
+
+    # Root state.
+    root_state_components = [self.cfg.init_state.pos, self.cfg.init_state.rot]
+    if not self.is_fixed_base:
+      root_state_components.extend(
+        [self.cfg.init_state.lin_vel, self.cfg.init_state.ang_vel]
+      )
+    default_root_state = torch.tensor(
+      sum((tuple(c) for c in root_state_components), ()),
+      dtype=torch.float,
+      device=device,
+    ).repeat(nworld, 1)
+
+    # Joint state.
+    if self.is_articulated:
+      if self.cfg.init_state.joint_pos is None:
+        # Use keyframe joint positions.
+        key_qpos = mj_model.key("init_state").qpos
+        nq_root = 7 if not self.is_fixed_base else 0
+        default_joint_pos = torch.tensor(key_qpos[nq_root:], device=device)[
+          None
+        ].repeat(nworld, 1)
+      else:
+        default_joint_pos = torch.tensor(
+          resolve_expr(self.cfg.init_state.joint_pos, self.joint_names, 0.0),
+          device=device,
+        )[None].repeat(nworld, 1)
+      default_joint_vel = torch.tensor(
+        resolve_expr(self.cfg.init_state.joint_vel, self.joint_names, 0.0),
+        device=device,
+      )[None].repeat(nworld, 1)
+
+      # Joint limits.
+      joint_ids_global = torch.tensor(
+        [j.id for j in self._non_free_joints], device=device
+      )
+      dof_limits = model.jnt_range[:, joint_ids_global]
+      default_joint_pos_limits = dof_limits.clone()
+      joint_pos_limits = default_joint_pos_limits.clone()
+      joint_pos_mean = (joint_pos_limits[..., 0] + joint_pos_limits[..., 1]) / 2
+      joint_pos_range = joint_pos_limits[..., 1] - joint_pos_limits[..., 0]
+
+      # Soft limits.
+      soft_limit_factor = (
+        self.cfg.articulation.soft_joint_pos_limit_factor
+        if self.cfg.articulation
+        else 1.0
+      )
+      soft_joint_pos_limits = torch.stack(
+        [
+          joint_pos_mean - 0.5 * joint_pos_range * soft_limit_factor,
+          joint_pos_mean + 0.5 * joint_pos_range * soft_limit_factor,
+        ],
+        dim=-1,
+      )
+    else:
+      empty_shape = (nworld, 0)
+      default_joint_pos = torch.empty(*empty_shape, dtype=torch.float, device=device)
+      default_joint_vel = torch.empty(*empty_shape, dtype=torch.float, device=device)
+      default_joint_pos_limits = torch.empty(
+        *empty_shape, 2, dtype=torch.float, device=device
+      )
+      joint_pos_limits = torch.empty(*empty_shape, 2, dtype=torch.float, device=device)
+      soft_joint_pos_limits = torch.empty(
+        *empty_shape, 2, dtype=torch.float, device=device
+      )
+
+    if self.is_actuated:
+      joint_pos_target = torch.zeros(
+        (nworld, self.num_joints), dtype=torch.float, device=device
+      )
+      joint_vel_target = torch.zeros(
+        (nworld, self.num_joints), dtype=torch.float, device=device
+      )
+      joint_effort_target = torch.zeros(
+        (nworld, self.num_joints), dtype=torch.float, device=device
+      )
+    else:
+      joint_pos_target = torch.empty(nworld, 0, dtype=torch.float, device=device)
+      joint_vel_target = torch.empty(nworld, 0, dtype=torch.float, device=device)
+      joint_effort_target = torch.empty(nworld, 0, dtype=torch.float, device=device)
+
+    # Only allocate tendon targets if there are actuators using tendon transmission.
+    if self.has_tendon_actuators:
+      num_tendons = len(self.tendon_names)
+      tendon_len_target = torch.zeros(
+        (nworld, num_tendons), dtype=torch.float, device=device
+      )
+      tendon_vel_target = torch.zeros(
+        (nworld, num_tendons), dtype=torch.float, device=device
+      )
+      tendon_effort_target = torch.zeros(
+        (nworld, num_tendons), dtype=torch.float, device=device
+      )
+    else:
+      tendon_len_target = torch.empty(nworld, 0, dtype=torch.float, device=device)
+      tendon_vel_target = torch.empty(nworld, 0, dtype=torch.float, device=device)
+      tendon_effort_target = torch.empty(nworld, 0, dtype=torch.float, device=device)
+
+    # Only allocate site targets if there are actuators using site transmission.
+    if self.has_site_actuators:
+      num_sites = len(self.site_names)
+      site_effort_target = torch.zeros(
+        (nworld, num_sites), dtype=torch.float, device=device
+      )
+    else:
+      site_effort_target = torch.empty(nworld, 0, dtype=torch.float, device=device)
+
+    # Encoder bias for simulating encoder calibration errors.
+    # Shape: (num_envs, num_joints). Defaults to zero (no bias).
+    if self.is_articulated:
+      encoder_bias = torch.zeros(
+        (nworld, self.num_joints), dtype=torch.float, device=device
+      )
+    else:
+      encoder_bias = torch.empty(nworld, 0, dtype=torch.float, device=device)
+
+    self._data = EntityData(
+      indexing=indexing,
+      data=data,
+      model=model,
+      device=device,
+      default_root_state=default_root_state,
+      default_joint_pos=default_joint_pos,
+      default_joint_vel=default_joint_vel,
+      default_joint_pos_limits=default_joint_pos_limits,
+      joint_pos_limits=joint_pos_limits,
+      soft_joint_pos_limits=soft_joint_pos_limits,
+      gravity_vec_w=torch.tensor([0.0, 0.0, -1.0], device=device).repeat(nworld, 1),
+      forward_vec_b=torch.tensor([1.0, 0.0, 0.0], device=device).repeat(nworld, 1),
+      is_fixed_base=self.is_fixed_base,
+      is_articulated=self.is_articulated,
+      is_actuated=self.is_actuated,
+      joint_pos_target=joint_pos_target,
+      joint_vel_target=joint_vel_target,
+      joint_effort_target=joint_effort_target,
+      tendon_len_target=tendon_len_target,
+      tendon_vel_target=tendon_vel_target,
+      tendon_effort_target=tendon_effort_target,
+      site_effort_target=site_effort_target,
+      encoder_bias=encoder_bias,
+    )
+
+  def update(self, dt: float) -> None:
+    for act in self._actuators:
+      act.update(dt)
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    self.clear_state(env_ids)
+
+    for act in self._actuators:
+      act.reset(env_ids)
+
+  def write_data_to_sim(self) -> None:
+    self._apply_actuator_controls()
+
+  def clear_state(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    self._data.clear_state(env_ids)
+
+  def write_ctrl_to_sim(
+    self,
+    ctrl: torch.Tensor,
+    ctrl_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Write control inputs to the simulation.
+
+    Args:
+      ctrl: A tensor of control inputs.
+      ctrl_ids: A tensor of control indices.
+      env_ids: Optional tensor or slice specifying which environments to set.
+        If None, all environments are set.
+    """
+    self._data.write_ctrl(ctrl, ctrl_ids, env_ids)
+
+  def write_root_state_to_sim(
+    self, root_state: torch.Tensor, env_ids: torch.Tensor | slice | None = None
+  ) -> None:
+    """Set the root state into the simulation.
+
+    The root state consists of position (3), orientation as a (w, x, y, z)
+    quaternion (4), linear velocity (3), and angular velocity (3), for a total
+    of 13 values. All of the quantities are in the world frame.
+
+    Args:
+      root_state: Tensor of shape (N, 13) where N is the number of environments.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_root_state(root_state, env_ids)
+
+  def write_root_link_pose_to_sim(
+    self,
+    root_pose: torch.Tensor,
+    env_ids: torch.Tensor | slice | None = None,
+  ):
+    """Set the root pose into the simulation. Like `write_root_state_to_sim()`
+    but only sets position and orientation.
+
+    Args:
+      root_pose: Tensor of shape (N, 7) where N is the number of environments.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_root_pose(root_pose, env_ids)
+
+  def write_root_link_velocity_to_sim(
+    self,
+    root_velocity: torch.Tensor,
+    env_ids: torch.Tensor | slice | None = None,
+  ):
+    """Set the root link (body origin) velocity into the simulation. Like
+    `write_root_state_to_sim()` but only sets linear and angular velocity.
+
+    Args:
+      root_velocity: Tensor of shape (N, 6) where N is the number of environments.
+        Contains linear velocity (3) at body origin and angular velocity (3),
+        both in world frame.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_root_velocity(root_velocity, env_ids)
+
+  def write_root_com_velocity_to_sim(
+    self,
+    root_velocity: torch.Tensor,
+    env_ids: torch.Tensor | slice | None = None,
+  ):
+    """Set the root COM velocity into the simulation.
+
+    Args:
+      root_velocity: Tensor of shape (N, 6) where N is the number of environments.
+        Contains linear velocity (3) at COM and angular velocity (3),
+        both in world frame.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_root_com_velocity(root_velocity, env_ids)
+
+  def write_joint_state_to_sim(
+    self,
+    position: torch.Tensor,
+    velocity: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ):
+    """Set the joint state into the simulation.
+
+    The joint state consists of joint positions and velocities. It does not include
+    the root state.
+
+    Args:
+      position: Tensor of shape (N, num_joints) where N is the number of environments.
+      velocity: Tensor of shape (N, num_joints) where N is the number of environments.
+      joint_ids: Optional tensor or slice specifying which joints to set. If None,
+        all joints are set.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_joint_state(position, velocity, joint_ids, env_ids)
+
+  def write_joint_position_to_sim(
+    self,
+    position: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ):
+    """Set the joint positions into the simulation. Like `write_joint_state_to_sim()`
+    but only sets joint positions.
+
+    Args:
+      position: Tensor of shape (N, num_joints) where N is the number of environments.
+      joint_ids: Optional tensor or slice specifying which joints to set. If None,
+        all joints are set.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_joint_position(position, joint_ids, env_ids)
+
+  def write_joint_velocity_to_sim(
+    self,
+    velocity: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ):
+    """Set the joint velocities into the simulation. Like `write_joint_state_to_sim()`
+    but only sets joint velocities.
+
+    Args:
+      velocity: Tensor of shape (N, num_joints) where N is the number of environments.
+      joint_ids: Optional tensor or slice specifying which joints to set. If None,
+        all joints are set.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_joint_velocity(velocity, joint_ids, env_ids)
+
+  def set_joint_position_target(
+    self,
+    position: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set joint position targets.
+
+    Args:
+      position: Target joint poisitions with shape (N, num_joints).
+      joint_ids: Optional joint indices to set. If None, set all joints.
+      env_ids: Optional environment indices. If None, set all environments.
+    """
+    if env_ids is None:
+      env_ids = slice(None)
+    if joint_ids is None:
+      joint_ids = slice(None)
+    self._data.joint_pos_target[env_ids, joint_ids] = position
+
+  def set_joint_velocity_target(
+    self,
+    velocity: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set joint velocity targets.
+
+    Args:
+      velocity: Target joint velocities with shape (N, num_joints).
+      joint_ids: Optional joint indices to set. If None, set all joints.
+      env_ids: Optional environment indices. If None, set all environments.
+    """
+    if env_ids is None:
+      env_ids = slice(None)
+    if joint_ids is None:
+      joint_ids = slice(None)
+    self._data.joint_vel_target[env_ids, joint_ids] = velocity
+
+  def set_joint_effort_target(
+    self,
+    effort: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set joint effort targets.
+
+    Args:
+      effort: Target joint efforts with shape (N, num_joints).
+      joint_ids: Optional joint indices to set. If None, set all joints.
+      env_ids: Optional environment indices. If None, set all environments.
+    """
+    if env_ids is None:
+      env_ids = slice(None)
+    if joint_ids is None:
+      joint_ids = slice(None)
+    self._data.joint_effort_target[env_ids, joint_ids] = effort
+
+  def set_tendon_len_target(
+    self,
+    length: torch.Tensor,
+    tendon_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set tendon length targets.
+
+    Args:
+      length: Target tendon lengths with shape (N, num_tendons).
+      tendon_ids: Optional tendon indices to set. If None, set all tendons.
+      env_ids: Optional environment indices. If None, set all environments.
+    """
+    if env_ids is None:
+      env_ids = slice(None)
+    if tendon_ids is None:
+      tendon_ids = slice(None)
+    self._data.tendon_len_target[env_ids, tendon_ids] = length
+
+  def set_tendon_vel_target(
+    self,
+    velocity: torch.Tensor,
+    tendon_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set tendon velocity targets.
+
+    Args:
+      velocity: Target tendon velocities with shape (N, num_tendons).
+      tendon_ids: Optional tendon indices to set. If None, set all tendons.
+      env_ids: Optional environment indices. If None, set all environments.
+    """
+    if env_ids is None:
+      env_ids = slice(None)
+    if tendon_ids is None:
+      tendon_ids = slice(None)
+    self._data.tendon_vel_target[env_ids, tendon_ids] = velocity
+
+  def set_tendon_effort_target(
+    self,
+    effort: torch.Tensor,
+    tendon_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set tendon effort targets.
+
+    Args:
+      effort: Target tendon efforts with shape (N, num_tendons).
+      tendon_ids: Optional tendon indices to set. If None, set all tendons.
+      env_ids: Optional environment indices. If None, set all environments.
+    """
+    if env_ids is None:
+      env_ids = slice(None)
+    if tendon_ids is None:
+      tendon_ids = slice(None)
+    self._data.tendon_effort_target[env_ids, tendon_ids] = effort
+
+  def set_site_effort_target(
+    self,
+    effort: torch.Tensor,
+    site_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set site effort targets.
+
+    Args:
+      effort: Target site efforts with shape (N, num_sites).
+      site_ids: Optional site indices to set. If None, set all sites.
+      env_ids: Optional environment indices. If None, set all environments.
+    """
+    if env_ids is None:
+      env_ids = slice(None)
+    if site_ids is None:
+      site_ids = slice(None)
+    self._data.site_effort_target[env_ids, site_ids] = effort
+
+  def write_external_wrench_to_sim(
+    self,
+    forces: torch.Tensor,
+    torques: torch.Tensor,
+    env_ids: torch.Tensor | slice | None = None,
+    body_ids: Sequence[int] | slice | None = None,
+  ) -> None:
+    """Apply external wrenches to bodies in the simulation.
+
+    Underneath the hood, this sets the `xfrc_applied` field in the MuJoCo data
+    structure. The wrenches are specified in the world frame and persist until
+    the next call to this function or until the simulation is reset.
+
+    Args:
+      forces: Tensor of shape (N, num_bodies, 3) where N is the number of
+        environments.
+      torques: Tensor of shape (N, num_bodies, 3) where N is the number of
+        environments.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+      body_ids: Optional list of body indices or slice specifying which bodies to
+        apply the wrenches to. If None, wrenches are applied to all bodies.
+    """
+    self._data.write_external_wrench(forces, torques, body_ids, env_ids)
+
+  def write_mocap_pose_to_sim(
+    self,
+    mocap_pose: torch.Tensor,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set the pose of a mocap body into the simulation.
+
+    Args:
+      mocap_pose: Tensor of shape (N, 7) where N is the number of environments.
+        Format: [pos_x, pos_y, pos_z, quat_w, quat_x, quat_y, quat_z]
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_mocap_pose(mocap_pose, env_ids)
+
+  ##
+  # Private methods.
+  ##
+
+  def _compute_indexing(self, model: mujoco.MjModel, device: str) -> EntityIndexing:
+    bodies = tuple([b for b in self.spec.bodies[1:]])
+    joints = self._non_free_joints
+    geoms = tuple(self.spec.geoms)
+    sites = tuple(self.spec.sites)
+    tendons = tuple(self.spec.tendons)
+
+    body_ids = torch.tensor([b.id for b in bodies], dtype=torch.int, device=device)
+    geom_ids = torch.tensor([g.id for g in geoms], dtype=torch.int, device=device)
+    site_ids = torch.tensor([s.id for s in sites], dtype=torch.int, device=device)
+    tendon_ids = torch.tensor([t.id for t in tendons], dtype=torch.int, device=device)
+    joint_ids = torch.tensor([j.id for j in joints], dtype=torch.int, device=device)
+
+    if self.is_actuated:
+      actuators = tuple(self.spec.actuators)
+      ctrl_ids = torch.tensor([a.id for a in actuators], dtype=torch.int, device=device)
+    else:
+      actuators = None
+      ctrl_ids = torch.empty(0, dtype=torch.int, device=device)
+
+    joint_q_adr = []
+    joint_v_adr = []
+    free_joint_q_adr = []
+    free_joint_v_adr = []
+    for joint in self.spec.joints:
+      jnt = model.joint(joint.name)
+      jnt_type = jnt.type[0]
+      vadr = jnt.dofadr[0]
+      qadr = jnt.qposadr[0]
+      if jnt_type == mujoco.mjtJoint.mjJNT_FREE:
+        free_joint_v_adr.extend(range(vadr, vadr + 6))
+        free_joint_q_adr.extend(range(qadr, qadr + 7))
+      else:
+        joint_v_adr.extend(range(vadr, vadr + dof_width(jnt_type)))
+        joint_q_adr.extend(range(qadr, qadr + qpos_width(jnt_type)))
+    joint_q_adr = torch.tensor(joint_q_adr, dtype=torch.int, device=device)
+    joint_v_adr = torch.tensor(joint_v_adr, dtype=torch.int, device=device)
+    free_joint_v_adr = torch.tensor(free_joint_v_adr, dtype=torch.int, device=device)
+    free_joint_q_adr = torch.tensor(free_joint_q_adr, dtype=torch.int, device=device)
+
+    if self.is_fixed_base and self.is_mocap:
+      mocap_id = int(model.body_mocapid[self.root_body.id])
+    else:
+      mocap_id = None
+
+    return EntityIndexing(
+      bodies=bodies,
+      joints=joints,
+      geoms=geoms,
+      sites=sites,
+      tendons=tendons,
+      actuators=actuators,
+      body_ids=body_ids,
+      geom_ids=geom_ids,
+      site_ids=site_ids,
+      tendon_ids=tendon_ids,
+      ctrl_ids=ctrl_ids,
+      joint_ids=joint_ids,
+      mocap_id=mocap_id,
+      joint_q_adr=joint_q_adr,
+      joint_v_adr=joint_v_adr,
+      free_joint_q_adr=free_joint_q_adr,
+      free_joint_v_adr=free_joint_v_adr,
+    )
+
+  def _apply_actuator_controls(self) -> None:
+    self._builtin_group.apply_controls(self._data)
+    for act in self._custom_actuators:
+      command = act.get_command(self._data)
+      self._data.write_ctrl(act.compute(command), act.ctrl_ids)

mjlab/src/mjlab/envs/__init__.py

@@ -0,0 +1,4 @@
+from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv as ManagerBasedRlEnv
+from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnvCfg as ManagerBasedRlEnvCfg
+from mjlab.envs.types import VecEnvObs as VecEnvObs
+from mjlab.envs.types import VecEnvStepReturn as VecEnvStepReturn

mjlab/src/mjlab/envs/manager_based_rl_env.py

@@ -0,0 +1,524 @@
+import math
+from dataclasses import dataclass, field
+from typing import Any
+
+import mujoco
+import numpy as np
+import torch
+import warp as wp
+from prettytable import PrettyTable
+
+from mjlab.envs import types
+from mjlab.envs.mdp.events import reset_scene_to_default
+from mjlab.managers.action_manager import ActionManager, ActionTermCfg
+from mjlab.managers.command_manager import (
+  CommandManager,
+  CommandTermCfg,
+  NullCommandManager,
+)
+from mjlab.managers.curriculum_manager import (
+  CurriculumManager,
+  CurriculumTermCfg,
+  NullCurriculumManager,
+)
+from mjlab.managers.event_manager import EventManager, EventTermCfg
+from mjlab.managers.metrics_manager import (
+  MetricsManager,
+  MetricsTermCfg,
+  NullMetricsManager,
+)
+from mjlab.managers.observation_manager import ObservationGroupCfg, ObservationManager
+from mjlab.managers.reward_manager import RewardManager, RewardTermCfg
+from mjlab.managers.termination_manager import TerminationManager, TerminationTermCfg
+from mjlab.scene import Scene
+from mjlab.scene.scene import SceneCfg
+from mjlab.sim import SimulationCfg
+from mjlab.sim.sim import Simulation
+from mjlab.utils import random as random_utils
+from mjlab.utils.logging import print_info
+from mjlab.utils.spaces import Box
+from mjlab.utils.spaces import Dict as DictSpace
+from mjlab.viewer.debug_visualizer import DebugVisualizer
+from mjlab.viewer.offscreen_renderer import OffscreenRenderer
+from mjlab.viewer.viewer_config import ViewerConfig
+
+
+@dataclass(kw_only=True)
+class ManagerBasedRlEnvCfg:
+  """Configuration for a manager-based RL environment.
+
+  This config defines all aspects of an RL environment: the physical scene,
+  observations, actions, rewards, terminations, and optional features like
+  commands and curriculum learning.
+
+  The environment step size is ``sim.mujoco.timestep * decimation``. For example,
+  with a 2ms physics timestep and decimation=10, the environment runs at 50Hz.
+  """
+
+  # Base environment configuration.
+
+  decimation: int
+  """Number of physics simulation steps per environment step. Higher values mean
+  coarser control frequency. Environment step duration = physics_dt * decimation."""
+
+  scene: SceneCfg
+  """Scene configuration defining terrain, entities, and sensors. The scene
+  specifies ``num_envs``, the number of parallel environments."""
+
+  observations: dict[str, ObservationGroupCfg] = field(default_factory=dict)
+  """Observation groups configuration. Each group (e.g., "actor", "critic") contains
+  observation terms that are concatenated. Groups can have different settings for
+  noise, history, and delay."""
+
+  actions: dict[str, ActionTermCfg] = field(default_factory=dict)
+  """Action terms configuration. Each term controls a specific entity/aspect
+  (e.g., joint positions). Action dimensions are concatenated across terms."""
+
+  events: dict[str, EventTermCfg] = field(
+    default_factory=lambda: {
+      "reset_scene_to_default": EventTermCfg(
+        func=reset_scene_to_default,
+        mode="reset",
+      )
+    }
+  )
+  """Event terms for domain randomization and state resets. Default includes
+  ``reset_scene_to_default`` which resets entities to their initial state.
+  Can be set to empty to disable all events including default reset."""
+
+  seed: int | None = None
+  """Random seed for reproducibility. If None, a random seed is used. The actual
+  seed used is stored back into this field after initialization."""
+
+  sim: SimulationCfg = field(default_factory=SimulationCfg)
+  """Simulation configuration including physics timestep, solver iterations,
+  contact parameters, and NaN guarding."""
+
+  viewer: ViewerConfig = field(default_factory=ViewerConfig)
+  """Viewer configuration for rendering (camera position, resolution, etc.)."""
+
+  # RL-specific configuration.
+
+  episode_length_s: float = 0.0
+  """Duration of an episode (in seconds).
+
+  Episode length in steps is computed as:
+    ceil(episode_length_s / (sim.mujoco.timestep * decimation))
+  """
+
+  rewards: dict[str, RewardTermCfg] = field(default_factory=dict)
+  """Reward terms configuration."""
+
+  terminations: dict[str, TerminationTermCfg] = field(default_factory=dict)
+  """Termination terms configuration. If empty, episodes never reset. Use
+  ``mdp.time_out`` with ``time_out=True`` for episode time limits."""
+
+  commands: dict[str, CommandTermCfg] = field(default_factory=dict)
+  """Command generator terms (e.g., velocity targets)."""
+
+  curriculum: dict[str, CurriculumTermCfg] = field(default_factory=dict)
+  """Curriculum terms for adaptive difficulty."""
+
+  metrics: dict[str, MetricsTermCfg] = field(default_factory=dict)
+  """Custom metric terms for logging per-step values as episode averages."""
+
+  is_finite_horizon: bool = False
+  """Whether the task has a finite or infinite horizon. Defaults to False (infinite).
+
+  - **Finite horizon (True)**: The time limit defines the task boundary. When reached,
+    no future value exists beyond it, so the agent receives a terminal done signal.
+  - **Infinite horizon (False)**: The time limit is an artificial cutoff. The agent
+    receives a truncated done signal to bootstrap the value of continuing beyond the
+    limit.
+  """
+
+  scale_rewards_by_dt: bool = True
+  """Whether to multiply rewards by the environment step duration (dt).
+
+  When True (default), reward values are scaled by step_dt to normalize cumulative
+  episodic rewards across different simulation frequencies. Set to False for
+  algorithms that expect unscaled reward signals (e.g., HER, static reward scaling).
+  """
+
+
+class ManagerBasedRlEnv:
+  """Manager-based RL environment."""
+
+  is_vector_env = True
+  metadata = {
+    "render_modes": [None, "rgb_array"],
+    "mujoco_version": mujoco.__version__,
+    "warp_version": wp.config.version,
+  }
+  cfg: ManagerBasedRlEnvCfg
+
+  def __init__(
+    self,
+    cfg: ManagerBasedRlEnvCfg,
+    device: str,
+    render_mode: str | None = None,
+    **kwargs,
+  ) -> None:
+    # Initialize base environment state.
+    self.cfg = cfg
+    if self.cfg.seed is not None:
+      self.cfg.seed = self.seed(self.cfg.seed)
+    self._sim_step_counter = 0
+    self.extras = {}
+    self.obs_buf = {}
+
+    # Initialize scene and simulation.
+    self.scene = Scene(self.cfg.scene, device=device)
+    self.sim = Simulation(
+      num_envs=self.scene.num_envs,
+      cfg=self.cfg.sim,
+      model=self.scene.compile(),
+      device=device,
+    )
+
+    self.scene.initialize(
+      mj_model=self.sim.mj_model,
+      model=self.sim.model,
+      data=self.sim.data,
+    )
+
+    # Wire sensor context to simulation for sense_graph.
+    if self.scene.sensor_context is not None:
+      self.sim.set_sensor_context(self.scene.sensor_context)
+
+    # Print environment info.
+    print_info("")
+    table = PrettyTable()
+    table.title = "Base Environment"
+    table.field_names = ["Property", "Value"]
+    table.align["Property"] = "l"
+    table.align["Value"] = "l"
+    table.add_row(["Number of environments", self.num_envs])
+    table.add_row(["Environment device", self.device])
+    table.add_row(["Environment seed", self.cfg.seed])
+    table.add_row(["Physics step-size", self.physics_dt])
+    table.add_row(["Environment step-size", self.step_dt])
+    print_info(table.get_string())
+    print_info("")
+
+    # Initialize RL-specific state.
+    self.common_step_counter = 0
+    self.episode_length_buf = torch.zeros(
+      cfg.scene.num_envs, device=device, dtype=torch.long
+    )
+    self.render_mode = render_mode
+    self._offline_renderer: OffscreenRenderer | None = None
+    if self.render_mode == "rgb_array":
+      renderer = OffscreenRenderer(
+        model=self.sim.mj_model, cfg=self.cfg.viewer, scene=self.scene
+      )
+      renderer.initialize()
+      self._offline_renderer = renderer
+    self.metadata["render_fps"] = 1.0 / self.step_dt
+
+    # Load all managers.
+    self.load_managers()
+    self.setup_manager_visualizers()
+
+  # Properties.
+
+  @property
+  def num_envs(self) -> int:
+    """Number of parallel environments."""
+    return self.scene.num_envs
+
+  @property
+  def physics_dt(self) -> float:
+    """Physics simulation step size."""
+    return self.cfg.sim.mujoco.timestep
+
+  @property
+  def step_dt(self) -> float:
+    """Environment step size (physics_dt * decimation)."""
+    return self.cfg.sim.mujoco.timestep * self.cfg.decimation
+
+  @property
+  def device(self) -> str:
+    """Device for computation."""
+    return self.sim.device
+
+  @property
+  def max_episode_length_s(self) -> float:
+    """Maximum episode length in seconds."""
+    return self.cfg.episode_length_s
+
+  @property
+  def max_episode_length(self) -> int:
+    """Maximum episode length in steps."""
+    return math.ceil(self.max_episode_length_s / self.step_dt)
+
+  @property
+  def unwrapped(self) -> "ManagerBasedRlEnv":
+    """Get the unwrapped environment (base case for wrapper chains)."""
+    return self
+
+  # Methods.
+
+  def setup_manager_visualizers(self) -> None:
+    self.manager_visualizers = {}
+    if getattr(self.command_manager, "active_terms", None):
+      self.manager_visualizers["command_manager"] = self.command_manager
+
+  def load_managers(self) -> None:
+    """Load and initialize all managers.
+
+    Order is important! Event and command managers must be loaded first,
+    then action and observation managers, then other RL managers.
+    """
+    # Event manager (required before everything else for domain randomization).
+    self.event_manager = EventManager(self.cfg.events, self)
+    print_info(f"[INFO] {self.event_manager}")
+
+    self.sim.expand_model_fields(self.event_manager.domain_randomization_fields)
+
+    # Command manager (must be before observation manager since observations
+    # may reference commands).
+    if len(self.cfg.commands) > 0:
+      self.command_manager = CommandManager(self.cfg.commands, self)
+    else:
+      self.command_manager = NullCommandManager()
+    print_info(f"[INFO] {self.command_manager}")
+
+    # Action and observation managers.
+    self.action_manager = ActionManager(self.cfg.actions, self)
+    print_info(f"[INFO] {self.action_manager}")
+    self.observation_manager = ObservationManager(self.cfg.observations, self)
+    print_info(f"[INFO] {self.observation_manager}")
+
+    # Other RL-specific managers.
+
+    self.termination_manager = TerminationManager(self.cfg.terminations, self)
+    print_info(f"[INFO] {self.termination_manager}")
+    self.reward_manager = RewardManager(
+      self.cfg.rewards, self, scale_by_dt=self.cfg.scale_rewards_by_dt
+    )
+    print_info(f"[INFO] {self.reward_manager}")
+    if len(self.cfg.curriculum) > 0:
+      self.curriculum_manager = CurriculumManager(self.cfg.curriculum, self)
+    else:
+      self.curriculum_manager = NullCurriculumManager()
+    print_info(f"[INFO] {self.curriculum_manager}")
+    if len(self.cfg.metrics) > 0:
+      self.metrics_manager = MetricsManager(self.cfg.metrics, self)
+    else:
+      self.metrics_manager = NullMetricsManager()
+    print_info(f"[INFO] {self.metrics_manager}")
+
+    # Configure spaces for the environment.
+    self._configure_gym_env_spaces()
+
+    # Initialize startup events if defined.
+    if "startup" in self.event_manager.available_modes:
+      self.event_manager.apply(mode="startup")
+
+  def reset(
+    self,
+    *,
+    seed: int | None = None,
+    env_ids: torch.Tensor | None = None,
+    options: dict[str, Any] | None = None,
+  ) -> tuple[types.VecEnvObs, dict]:
+    del options  # Unused.
+    if env_ids is None:
+      env_ids = torch.arange(self.num_envs, dtype=torch.int64, device=self.device)
+    if seed is not None:
+      self.seed(seed)
+    self._reset_idx(env_ids)
+    self.scene.write_data_to_sim()
+    self.sim.forward()
+    self.sim.sense()
+    self.obs_buf = self.observation_manager.compute(update_history=True)
+    return self.obs_buf, self.extras
+
+  def step(self, action: torch.Tensor) -> types.VecEnvStepReturn:
+    """Run one environment step: apply actions, simulate, compute RL signals.
+
+    **Forward-call placement.** MuJoCo's ``mj_step`` runs forward kinematics
+    *before* integration, so after stepping, derived quantities (``xpos``,
+    ``xquat``, ``site_xpos``, ``cvel``, ``sensordata``) lag ``qpos``/``qvel``
+    by one physics substep. Rather than calling ``sim.forward()`` twice (once
+    after the decimation loop and once after the reset block), this method
+    calls it **once**, right before observation computation. This single call
+    refreshes derived quantities for *all* envs: non-reset envs pick up
+    post-decimation kinematics, reset envs pick up post-reset kinematics.
+
+    The tradeoff is that termination and reward managers see derived
+    quantities that are stale by one physics substep (the last ``mj_step``
+    ran ``mj_forward`` from *pre*-integration ``qpos``). In practice, the
+    staleness is negligible for reward shaping and termination
+    checks. Critically, the staleness is *consistent*: every env,
+    every step, always sees the same lag, so the MDP is well-defined
+    and the value function can learn the correct mapping.
+
+    .. note::
+
+      Event and command authors do not need to call ``sim.forward()``
+      themselves. This method handles it. The only constraint is: do not
+      read derived quantities (``root_link_pose_w``, ``body_link_vel_w``,
+      etc.) in the same function that writes state
+      (``write_root_state_to_sim``, ``write_joint_state_to_sim``, etc.).
+      See :ref:`faq` for details.
+    """
+    self.action_manager.process_action(action.to(self.device))
+
+    for _ in range(self.cfg.decimation):
+      self._sim_step_counter += 1
+      self.action_manager.apply_action()
+      self.scene.write_data_to_sim()
+      self.sim.step()
+      self.scene.update(dt=self.physics_dt)
+
+    # Update env counters.
+    self.episode_length_buf += 1
+    self.common_step_counter += 1
+
+    # Check terminations and compute rewards.
+    # NOTE: Derived quantities (xpos, xquat, ...) are stale by one physics
+    # substep here. See the docstring above for why this is acceptable.
+    self.reset_buf = self.termination_manager.compute()
+    self.reset_terminated = self.termination_manager.terminated
+    self.reset_time_outs = self.termination_manager.time_outs
+
+    self.reward_buf = self.reward_manager.compute(dt=self.step_dt)
+    self.metrics_manager.compute()
+
+    # Reset envs that terminated/timed-out and log the episode info.
+    reset_env_ids = self.reset_buf.nonzero(as_tuple=False).squeeze(-1)
+    if len(reset_env_ids) > 0:
+      self._reset_idx(reset_env_ids)
+      self.scene.write_data_to_sim()
+
+    # Single forward() call: recompute derived quantities from current
+    # qpos/qvel for every env. For non-reset envs this resolves the
+    # one-substep staleness left by mj_step; for reset envs it picks up
+    # the freshly written reset state.
+    self.sim.forward()
+
+    self.command_manager.compute(dt=self.step_dt)
+
+    if "interval" in self.event_manager.available_modes:
+      self.event_manager.apply(mode="interval", dt=self.step_dt)
+
+    self.sim.sense()
+    self.obs_buf = self.observation_manager.compute(update_history=True)
+
+    return (
+      self.obs_buf,
+      self.reward_buf,
+      self.reset_terminated,
+      self.reset_time_outs,
+      self.extras,
+    )
+
+  def render(self) -> np.ndarray | None:
+    if self.render_mode == "human" or self.render_mode is None:
+      return None
+    elif self.render_mode == "rgb_array":
+      if self._offline_renderer is None:
+        raise ValueError("Offline renderer not initialized")
+      debug_callback = (
+        self.update_visualizers if hasattr(self, "update_visualizers") else None
+      )
+      self._offline_renderer.update(self.sim.data, debug_vis_callback=debug_callback)
+      return self._offline_renderer.render()
+    else:
+      raise NotImplementedError(
+        f"Render mode {self.render_mode} is not supported. "
+        f"Please use: {self.metadata['render_modes']}."
+      )
+
+  def close(self) -> None:
+    if self._offline_renderer is not None:
+      self._offline_renderer.close()
+
+  @staticmethod
+  def seed(seed: int = -1) -> int:
+    if seed == -1:
+      seed = np.random.randint(0, 10_000)
+    print_info(f"Setting seed: {seed}")
+    random_utils.seed_rng(seed)
+    return seed
+
+  def update_visualizers(self, visualizer: DebugVisualizer) -> None:
+    for mod in self.manager_visualizers.values():
+      mod.debug_vis(visualizer)
+    for sensor in self.scene.sensors.values():
+      sensor.debug_vis(visualizer)
+
+  # Private methods.
+
+  def _configure_gym_env_spaces(self) -> None:
+    from mjlab.utils.spaces import batch_space
+
+    self.single_observation_space = DictSpace()
+    for group_name, group_term_names in self.observation_manager.active_terms.items():
+      has_concatenated_obs = self.observation_manager.group_obs_concatenate[group_name]
+      group_dim = self.observation_manager.group_obs_dim[group_name]
+      if has_concatenated_obs:
+        assert isinstance(group_dim, tuple)
+        self.single_observation_space.spaces[group_name] = Box(
+          shape=group_dim, low=-math.inf, high=math.inf
+        )
+      else:
+        assert not isinstance(group_dim, tuple)
+        group_term_cfgs = self.observation_manager._group_obs_term_cfgs[group_name]
+        # Create a nested dict for this group.
+        group_space = DictSpace()
+        for term_name, term_dim, _term_cfg in zip(
+          group_term_names, group_dim, group_term_cfgs, strict=False
+        ):
+          group_space.spaces[term_name] = Box(
+            shape=term_dim, low=-math.inf, high=math.inf
+          )
+        self.single_observation_space.spaces[group_name] = group_space
+
+    action_dim = sum(self.action_manager.action_term_dim)
+    self.single_action_space = Box(shape=(action_dim,), low=-math.inf, high=math.inf)
+
+    self.observation_space = batch_space(self.single_observation_space, self.num_envs)
+    self.action_space = batch_space(self.single_action_space, self.num_envs)
+
+  def _reset_idx(self, env_ids: torch.Tensor | None = None) -> None:
+    self.curriculum_manager.compute(env_ids=env_ids)
+    self.sim.reset(env_ids)
+    self.scene.reset(env_ids)
+
+    if "reset" in self.event_manager.available_modes:
+      env_step_count = self._sim_step_counter // self.cfg.decimation
+      self.event_manager.apply(
+        mode="reset", env_ids=env_ids, global_env_step_count=env_step_count
+      )
+
+    # NOTE: This is order sensitive.
+    self.extras["log"] = dict()
+    # observation manager.
+    info = self.observation_manager.reset(env_ids)
+    self.extras["log"].update(info)
+    # action manager.
+    info = self.action_manager.reset(env_ids)
+    self.extras["log"].update(info)
+    # rewards manager.
+    info = self.reward_manager.reset(env_ids)
+    self.extras["log"].update(info)
+    # metrics manager.
+    info = self.metrics_manager.reset(env_ids)
+    self.extras["log"].update(info)
+    # curriculum manager.
+    info = self.curriculum_manager.reset(env_ids)
+    self.extras["log"].update(info)
+    # command manager.
+    info = self.command_manager.reset(env_ids)
+    self.extras["log"].update(info)
+    # event manager.
+    info = self.event_manager.reset(env_ids)
+    self.extras["log"].update(info)
+    # termination manager.
+    info = self.termination_manager.reset(env_ids)
+    self.extras["log"].update(info)
+    # reset the episode length buffer.
+    self.episode_length_buf[env_ids] = 0

mjlab/src/mjlab/envs/types.py

@@ -0,0 +1,6 @@
+from typing import Dict
+
+import torch
+
+VecEnvObs = Dict[str, torch.Tensor | Dict[str, torch.Tensor]]
+VecEnvStepReturn = tuple[VecEnvObs, torch.Tensor, torch.Tensor, torch.Tensor, dict]

mjlab/src/mjlab/managers/__init__.py

@@ -0,0 +1,33 @@
+"""Environment managers."""
+
+from mjlab.managers.action_manager import ActionManager as ActionManager
+from mjlab.managers.action_manager import ActionTerm as ActionTerm
+from mjlab.managers.action_manager import ActionTermCfg as ActionTermCfg
+from mjlab.managers.command_manager import CommandManager as CommandManager
+from mjlab.managers.command_manager import CommandTerm as CommandTerm
+from mjlab.managers.command_manager import CommandTermCfg as CommandTermCfg
+from mjlab.managers.command_manager import NullCommandManager as NullCommandManager
+from mjlab.managers.curriculum_manager import CurriculumManager as CurriculumManager
+from mjlab.managers.curriculum_manager import CurriculumTermCfg as CurriculumTermCfg
+from mjlab.managers.curriculum_manager import (
+  NullCurriculumManager as NullCurriculumManager,
+)
+from mjlab.managers.event_manager import EventManager as EventManager
+from mjlab.managers.event_manager import EventMode as EventMode
+from mjlab.managers.event_manager import EventTermCfg as EventTermCfg
+from mjlab.managers.manager_base import ManagerBase as ManagerBase
+from mjlab.managers.manager_base import ManagerTermBase as ManagerTermBase
+from mjlab.managers.manager_base import ManagerTermBaseCfg as ManagerTermBaseCfg
+from mjlab.managers.metrics_manager import MetricsManager as MetricsManager
+from mjlab.managers.metrics_manager import MetricsTermCfg as MetricsTermCfg
+from mjlab.managers.metrics_manager import NullMetricsManager as NullMetricsManager
+from mjlab.managers.observation_manager import (
+  ObservationGroupCfg as ObservationGroupCfg,
+)
+from mjlab.managers.observation_manager import ObservationManager as ObservationManager
+from mjlab.managers.observation_manager import ObservationTermCfg as ObservationTermCfg
+from mjlab.managers.reward_manager import RewardManager as RewardManager
+from mjlab.managers.reward_manager import RewardTermCfg as RewardTermCfg
+from mjlab.managers.scene_entity_config import SceneEntityCfg as SceneEntityCfg
+from mjlab.managers.termination_manager import TerminationManager as TerminationManager
+from mjlab.managers.termination_manager import TerminationTermCfg as TerminationTermCfg

mjlab/src/mjlab/managers/action_manager.py

@@ -0,0 +1,186 @@
+"""Action manager for processing actions sent to the environment."""
+
+from __future__ import annotations
+
+import abc
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Sequence
+
+import torch
+from prettytable import PrettyTable
+
+from mjlab.managers.manager_base import ManagerBase, ManagerTermBase
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+@dataclass(kw_only=True)
+class ActionTermCfg(abc.ABC):
+  """Configuration for an action term.
+
+  Action terms process raw actions from the policy and apply them to entities
+  in the scene (e.g., setting joint positions, velocities, or efforts).
+  """
+
+  entity_name: str
+  """Name of the entity in the scene that this action term controls."""
+
+  clip: dict[str, tuple] | None = None
+  """Optional clipping bounds per transmission type. Maps transmission name
+  (e.g., 'position', 'velocity') to (min, max) tuple."""
+
+  @abc.abstractmethod
+  def build(self, env: ManagerBasedRlEnv) -> ActionTerm:
+    """Build the action term from this config."""
+    raise NotImplementedError
+
+
+class ActionTerm(ManagerTermBase):
+  """Base class for action terms.
+
+  The action term is responsible for processing the raw actions sent to the environment
+  and applying them to the entity managed by the term.
+  """
+
+  def __init__(self, cfg: ActionTermCfg, env: ManagerBasedRlEnv):
+    self.cfg = cfg
+    super().__init__(env)
+    self._entity = self._env.scene[self.cfg.entity_name]
+
+  @property
+  @abc.abstractmethod
+  def action_dim(self) -> int:
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def process_actions(self, actions: torch.Tensor) -> None:
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def apply_actions(self) -> None:
+    raise NotImplementedError
+
+  @property
+  @abc.abstractmethod
+  def raw_action(self) -> torch.Tensor:
+    raise NotImplementedError
+
+
+class ActionManager(ManagerBase):
+  """Manages action processing for the environment.
+
+  The action manager aggregates multiple action terms, each controlling a different
+  entity or aspect of the simulation. It splits the policy's action tensor and
+  routes each slice to the appropriate action term.
+  """
+
+  def __init__(self, cfg: dict[str, ActionTermCfg], env: ManagerBasedRlEnv):
+    self.cfg = cfg
+    super().__init__(env=env)
+
+    # Create buffers to store actions.
+    self._action = torch.zeros(
+      (self.num_envs, self.total_action_dim), device=self.device
+    )
+    self._prev_action = torch.zeros_like(self._action)
+    self._prev_prev_action = torch.zeros_like(self._action)
+
+  def __str__(self) -> str:
+    msg = f"<ActionManager> contains {len(self._term_names)} active terms.\n"
+    table = PrettyTable()
+    table.title = f"Active Action Terms (shape: {self.total_action_dim})"
+    table.field_names = ["Index", "Name", "Dimension"]
+    table.align["Name"] = "l"
+    table.align["Dimension"] = "r"
+    for index, (name, term) in enumerate(self._terms.items()):
+      table.add_row([index, name, term.action_dim])
+    msg += table.get_string()
+    msg += "\n"
+    return msg
+
+  # Properties.
+
+  @property
+  def total_action_dim(self) -> int:
+    return sum(self.action_term_dim)
+
+  @property
+  def action_term_dim(self) -> list[int]:
+    return [term.action_dim for term in self._terms.values()]
+
+  @property
+  def action(self) -> torch.Tensor:
+    return self._action
+
+  @property
+  def prev_action(self) -> torch.Tensor:
+    return self._prev_action
+
+  @property
+  def prev_prev_action(self) -> torch.Tensor:
+    return self._prev_prev_action
+
+  @property
+  def active_terms(self) -> list[str]:
+    return self._term_names
+
+  # Methods.
+
+  def get_term(self, name: str) -> ActionTerm:
+    return self._terms[name]
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> dict[str, float]:
+    if env_ids is None:
+      env_ids = slice(None)
+    # Reset action history.
+    self._prev_action[env_ids] = 0.0
+    self._prev_prev_action[env_ids] = 0.0
+    self._action[env_ids] = 0.0
+    # Reset action terms.
+    for term in self._terms.values():
+      term.reset(env_ids=env_ids)
+    return {}
+
+  def process_action(self, action: torch.Tensor) -> None:
+    if self.total_action_dim != action.shape[1]:
+      raise ValueError(
+        f"Invalid action shape, expected: {self.total_action_dim}, received: {action.shape[1]}."
+      )
+    self._prev_prev_action[:] = self._prev_action
+    self._prev_action[:] = self._action
+    self._action[:] = action.to(self.device)
+    # Split and apply.
+    idx = 0
+    for term in self._terms.values():
+      term_actions = action[:, idx : idx + term.action_dim]
+      term.process_actions(term_actions)
+      idx += term.action_dim
+
+  def apply_action(self) -> None:
+    for term in self._terms.values():
+      term.apply_actions()
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    terms = []
+    idx = 0
+    for name, term in self._terms.items():
+      term_actions = self._action[env_idx, idx : idx + term.action_dim].cpu()
+      terms.append((name, term_actions.tolist()))
+      idx += term.action_dim
+    return terms
+
+  def _prepare_terms(self):
+    self._term_names: list[str] = list()
+    self._terms: dict[str, ActionTerm] = dict()
+
+    for term_name, term_cfg in self.cfg.items():
+      term_cfg: ActionTermCfg | None
+      if term_cfg is None:
+        print(f"term: {term_name} set to None, skipping...")
+        continue
+      term = term_cfg.build(self._env)
+      self._term_names.append(term_name)
+      self._terms[term_name] = term

mjlab/src/mjlab/managers/command_manager.py

@@ -0,0 +1,229 @@
+"""Command manager for generating and updating commands."""
+
+from __future__ import annotations
+
+import abc
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Sequence
+
+import torch
+from prettytable import PrettyTable
+
+from mjlab.managers.manager_base import ManagerBase, ManagerTermBase
+
+if TYPE_CHECKING:
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+  from mjlab.viewer.debug_visualizer import DebugVisualizer
+
+
+@dataclass(kw_only=True)
+class CommandTermCfg(abc.ABC):
+  """Configuration for a command generator term.
+
+  Command terms generate goal commands for the agent (e.g., target velocity,
+  target position). Commands are automatically resampled at configurable
+  intervals and can track metrics for logging.
+  """
+
+  resampling_time_range: tuple[float, float]
+  """Time range in seconds for command resampling. When the timer expires, a new
+  command is sampled and the timer is reset to a value uniformly drawn from
+  ``[min, max]``. Set both values equal for fixed-interval resampling."""
+
+  debug_vis: bool = False
+  """Whether to enable debug visualization for this command term. When True,
+  the command term's ``_debug_vis_impl`` method is called each frame to render
+  visual aids (e.g., velocity arrows, target markers)."""
+
+  @abc.abstractmethod
+  def build(self, env: ManagerBasedRlEnv) -> CommandTerm:
+    """Build the command term from this config."""
+    raise NotImplementedError
+
+
+class CommandTerm(ManagerTermBase):
+  """Base class for command terms."""
+
+  def __init__(self, cfg: CommandTermCfg, env: ManagerBasedRlEnv):
+    self.cfg = cfg
+    super().__init__(env)
+    self.metrics = dict()
+    self.time_left = torch.zeros(self.num_envs, device=self.device)
+    self.command_counter = torch.zeros(
+      self.num_envs, device=self.device, dtype=torch.long
+    )
+
+  def debug_vis(self, visualizer: "DebugVisualizer") -> None:
+    if self.cfg.debug_vis:
+      self._debug_vis_impl(visualizer)
+
+  def _debug_vis_impl(self, visualizer: "DebugVisualizer") -> None:
+    pass
+
+  @property
+  @abc.abstractmethod
+  def command(self):
+    raise NotImplementedError
+
+  def reset(self, env_ids: torch.Tensor | slice | None) -> dict[str, float]:
+    assert isinstance(env_ids, torch.Tensor)
+    extras = {}
+    for metric_name, metric_value in self.metrics.items():
+      extras[metric_name] = torch.mean(metric_value[env_ids]).item()
+      metric_value[env_ids] = 0.0
+    self.command_counter[env_ids] = 0
+    self._resample(env_ids)
+    return extras
+
+  def compute(self, dt: float) -> None:
+    self._update_metrics()
+    self.time_left -= dt
+    resample_env_ids = (self.time_left <= 0.0).nonzero().flatten()
+    if len(resample_env_ids) > 0:
+      self._resample(resample_env_ids)
+    self._update_command()
+
+  def _resample(self, env_ids: torch.Tensor) -> None:
+    if len(env_ids) != 0:
+      self.time_left[env_ids] = self.time_left[env_ids].uniform_(
+        *self.cfg.resampling_time_range
+      )
+      self._resample_command(env_ids)
+      self.command_counter[env_ids] += 1
+
+  @abc.abstractmethod
+  def _update_metrics(self) -> None:
+    """Update the metrics based on the current state."""
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def _resample_command(self, env_ids: torch.Tensor) -> None:
+    """Resample the command for the specified environments."""
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def _update_command(self) -> None:
+    """Update the command based on the current state."""
+    raise NotImplementedError
+
+
+class CommandManager(ManagerBase):
+  """Manages command generation for the environment.
+
+  The command manager generates and updates goal commands for the agent (e.g.,
+  target velocity, target position). Commands are resampled at configurable
+  intervals and can track metrics for logging.
+  """
+
+  _env: ManagerBasedRlEnv
+
+  def __init__(self, cfg: dict[str, CommandTermCfg], env: ManagerBasedRlEnv):
+    self._terms: dict[str, CommandTerm] = dict()
+
+    self.cfg = cfg
+    super().__init__(env)
+    self._commands = dict()
+
+  def __str__(self) -> str:
+    msg = f"<CommandManager> contains {len(self._terms.values())} active terms.\n"
+    table = PrettyTable()
+    table.title = "Active Command Terms"
+    table.field_names = ["Index", "Name", "Type"]
+    table.align["Name"] = "l"
+    for index, (name, term) in enumerate(self._terms.items()):
+      table.add_row([index, name, term.__class__.__name__])
+    msg += table.get_string()
+    msg += "\n"
+    return msg
+
+  def debug_vis(self, visualizer: "DebugVisualizer") -> None:
+    for term in self._terms.values():
+      term.debug_vis(visualizer)
+
+  # Properties.
+
+  @property
+  def active_terms(self) -> list[str]:
+    return list(self._terms.keys())
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    terms = []
+    idx = 0
+    for name, term in self._terms.items():
+      terms.append((name, term.command[env_idx].cpu().tolist()))
+      idx += term.command.shape[1]
+    return terms
+
+  def reset(self, env_ids: torch.Tensor | None) -> dict[str, torch.Tensor]:
+    extras = {}
+    for name, term in self._terms.items():
+      metrics = term.reset(env_ids=env_ids)
+      for metric_name, metric_value in metrics.items():
+        extras[f"Metrics/{name}/{metric_name}"] = metric_value
+    return extras
+
+  def compute(self, dt: float):
+    for term in self._terms.values():
+      term.compute(dt)
+
+  def get_command(self, name: str) -> torch.Tensor:
+    return self._terms[name].command
+
+  def get_term(self, name: str) -> CommandTerm:
+    return self._terms[name]
+
+  def get_term_cfg(self, name: str) -> CommandTermCfg:
+    return self.cfg[name]
+
+  def _prepare_terms(self):
+    for term_name, term_cfg in self.cfg.items():
+      term_cfg: CommandTermCfg | None
+      if term_cfg is None:
+        print(f"term: {term_name} set to None, skipping...")
+        continue
+      term = term_cfg.build(self._env)
+      if not isinstance(term, CommandTerm):
+        raise TypeError(
+          f"Returned object for the term {term_name} is not of type CommandType."
+        )
+      self._terms[term_name] = term
+
+
+class NullCommandManager:
+  """Placeholder for absent command manager that safely no-ops all operations."""
+
+  def __init__(self):
+    self.active_terms: list[str] = []
+    self._terms: dict[str, Any] = {}
+    self.cfg = None
+
+  def __str__(self) -> str:
+    return "<NullCommandManager> (inactive)"
+
+  def __repr__(self) -> str:
+    return "NullCommandManager()"
+
+  def debug_vis(self, visualizer: "DebugVisualizer") -> None:
+    pass
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    return []
+
+  def reset(self, env_ids: torch.Tensor | None = None) -> dict[str, torch.Tensor]:
+    return {}
+
+  def compute(self, dt: float) -> None:
+    pass
+
+  def get_command(self, name: str) -> None:
+    return None
+
+  def get_term(self, name: str) -> None:
+    return None
+
+  def get_term_cfg(self, name: str) -> None:
+    return None

mjlab/src/mjlab/managers/curriculum_manager.py

@@ -0,0 +1,155 @@
+"""Curriculum manager for updating environment quantities subject to a training curriculum."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Sequence
+
+import torch
+from prettytable import PrettyTable
+
+from mjlab.managers.manager_base import ManagerBase, ManagerTermBaseCfg
+
+if TYPE_CHECKING:
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+
+
+@dataclass(kw_only=True)
+class CurriculumTermCfg(ManagerTermBaseCfg):
+  """Configuration for a curriculum term.
+
+  Curriculum terms modify environment parameters during training to implement
+  curriculum learning strategies (e.g., gradually increasing task difficulty).
+  """
+
+  pass
+
+
+class CurriculumManager(ManagerBase):
+  """Manages curriculum learning for the environment.
+
+  The curriculum manager updates environment parameters during training based
+  on agent performance. Each term can modify different aspects of the task
+  difficulty (e.g., terrain complexity, command ranges).
+  """
+
+  _env: ManagerBasedRlEnv
+
+  def __init__(self, cfg: dict[str, CurriculumTermCfg], env: ManagerBasedRlEnv):
+    self._term_names: list[str] = list()
+    self._term_cfgs: list[CurriculumTermCfg] = list()
+    self._class_term_cfgs: list[CurriculumTermCfg] = list()
+
+    self.cfg = deepcopy(cfg)
+    super().__init__(env)
+
+    self._curriculum_state = dict()
+    for term_name in self._term_names:
+      self._curriculum_state[term_name] = None
+
+  def __str__(self) -> str:
+    msg = f"<CurriculumManager> contains {len(self._term_names)} active terms.\n"
+    table = PrettyTable()
+    table.title = "Active Curriculum Terms"
+    table.field_names = ["Index", "Name"]
+    table.align["Name"] = "l"
+    for index, name in enumerate(self._term_names):
+      table.add_row([index, name])
+    msg += table.get_string()
+    msg += "\n"
+    return msg
+
+  # Properties.
+
+  @property
+  def active_terms(self) -> list[str]:
+    return self._term_names
+
+  # Methods.
+
+  def get_term_cfg(self, term_name: str) -> CurriculumTermCfg:
+    if term_name not in self._term_names:
+      raise ValueError(f"Term '{term_name}' not found in active terms.")
+    return self._term_cfgs[self._term_names.index(term_name)]
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    terms = []
+    for term_name, term_state in self._curriculum_state.items():
+      if term_state is not None:
+        data = []
+        if isinstance(term_state, dict):
+          for _key, value in term_state.items():
+            if isinstance(value, torch.Tensor):
+              value = value.item()
+            terms[term_name].append(value)
+        else:
+          if isinstance(term_state, torch.Tensor):
+            term_state = term_state.item()
+          data.append(term_state)
+        terms.append((term_name, data))
+    return terms
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> dict[str, float]:
+    extras = {}
+    for term_name, term_state in self._curriculum_state.items():
+      if term_state is not None:
+        if isinstance(term_state, dict):
+          for key, value in term_state.items():
+            if isinstance(value, torch.Tensor):
+              value = value.item()
+            extras[f"Curriculum/{term_name}/{key}"] = value
+        else:
+          if isinstance(term_state, torch.Tensor):
+            term_state = term_state.item()
+          extras[f"Curriculum/{term_name}"] = term_state
+    for term_cfg in self._class_term_cfgs:
+      term_cfg.func.reset(env_ids=env_ids)
+    return extras
+
+  def compute(self, env_ids: torch.Tensor | slice | None = None):
+    if env_ids is None:
+      env_ids = slice(None)
+    for name, term_cfg in zip(self._term_names, self._term_cfgs, strict=False):
+      state = term_cfg.func(self._env, env_ids, **term_cfg.params)
+      self._curriculum_state[name] = state
+
+  def _prepare_terms(self):
+    for term_name, term_cfg in self.cfg.items():
+      term_cfg: CurriculumTermCfg | None
+      if term_cfg is None:
+        print(f"term: {term_name} set to None, skipping...")
+        continue
+      self._resolve_common_term_cfg(term_name, term_cfg)
+      self._term_names.append(term_name)
+      self._term_cfgs.append(term_cfg)
+      if hasattr(term_cfg.func, "reset") and callable(term_cfg.func.reset):
+        self._class_term_cfgs.append(term_cfg)
+
+
+class NullCurriculumManager:
+  """Placeholder for absent curriculum manager that safely no-ops all operations."""
+
+  def __init__(self):
+    self.active_terms: list[str] = []
+    self._curriculum_state: dict[str, Any] = {}
+    self.cfg = None
+
+  def __str__(self) -> str:
+    return "<NullCurriculumManager> (inactive)"
+
+  def __repr__(self) -> str:
+    return "NullCurriculumManager()"
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    return []
+
+  def reset(self, env_ids: torch.Tensor | None = None) -> dict[str, float]:
+    return {}
+
+  def compute(self, env_ids: torch.Tensor | None = None) -> None:
+    pass

mjlab/src/mjlab/managers/manager_base.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import abc
+import inspect
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+import torch
+
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+@dataclass
+class ManagerTermBaseCfg:
+  """Base configuration for manager terms.
+
+  This is the base config for terms in observation, reward, termination, curriculum,
+  and event managers. It provides a common interface for specifying a callable
+  and its parameters.
+
+  The ``func`` field accepts either a function or a class:
+
+  **Function-based terms** are simpler and suitable for stateless computations:
+
+  .. code-block:: python
+
+      RewardTermCfg(func=mdp.joint_torques_l2, weight=-0.01)
+
+  **Class-based terms** are instantiated with ``(cfg, env)`` and useful when you need
+  to:
+
+  - Cache computed values at initialization (e.g., resolve regex patterns to indices)
+  - Maintain state across calls
+  - Perform expensive setup once rather than every call
+
+  .. code-block:: python
+
+      class posture:
+        def __init__(self, cfg: RewardTermCfg, env: ManagerBasedRlEnv):
+          # Resolve std dict to tensor once at init
+          self.std = resolve_std_to_tensor(cfg.params["std"], env)
+
+        def __call__(self, env, **kwargs) -> torch.Tensor:
+          # Use cached self.std
+          return compute_posture_reward(env, self.std)
+
+      RewardTermCfg(func=posture, params={"std": {".*knee.*": 0.3}}, weight=1.0)
+
+  Class-based terms can optionally implement ``reset(env_ids)`` for per-episode state.
+  """
+
+  func: Any
+  """The callable that computes this term's value. Can be a function or a class.
+  Classes are auto-instantiated with ``(cfg=term_cfg, env=env)``."""
+
+  params: dict[str, Any] = field(default_factory=lambda: {})
+  """Additional keyword arguments passed to func when called."""
+
+
+class ManagerTermBase:
+  def __init__(self, env: ManagerBasedRlEnv):
+    self._env = env
+
+  # Properties.
+
+  @property
+  def num_envs(self) -> int:
+    return self._env.num_envs
+
+  @property
+  def device(self) -> str:
+    return self._env.device
+
+  @property
+  def name(self) -> str:
+    return self.__class__.__name__
+
+  # Methods.
+
+  def reset(self, env_ids: torch.Tensor | slice | None) -> Any:
+    """Resets the manager term."""
+    del env_ids  # Unused.
+    pass
+
+  def __call__(self, *args, **kwargs) -> Any:
+    """Returns the value of the term required by the manager."""
+    raise NotImplementedError
+
+
+class ManagerBase(abc.ABC):
+  """Base class for all managers."""
+
+  def __init__(self, env: ManagerBasedRlEnv):
+    self._env = env
+
+    self._prepare_terms()
+
+  # Properties.
+
+  @property
+  def num_envs(self) -> int:
+    return self._env.num_envs
+
+  @property
+  def device(self) -> str:
+    return self._env.device
+
+  @property
+  @abc.abstractmethod
+  def active_terms(self) -> list[str] | dict[Any, list[str]]:
+    raise NotImplementedError
+
+  # Methods.
+
+  def reset(self, env_ids: torch.Tensor) -> dict[str, Any]:
+    """Resets the manager and returns logging info for the current step."""
+    del env_ids  # Unused.
+    return {}
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def _prepare_terms(self):
+    raise NotImplementedError
+
+  def _resolve_common_term_cfg(self, term_name: str, term_cfg: ManagerTermBaseCfg):
+    del term_name  # Unused.
+    for value in term_cfg.params.values():
+      if isinstance(value, SceneEntityCfg):
+        value.resolve(self._env.scene)
+    if inspect.isclass(term_cfg.func):
+      term_cfg.func = term_cfg.func(cfg=term_cfg, env=self._env)

mjlab/src/mjlab/managers/metrics_manager.py

@@ -0,0 +1,144 @@
+"""Metrics manager for logging custom per-step metrics during training."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Sequence
+
+import torch
+from prettytable import PrettyTable
+
+from mjlab.managers.manager_base import ManagerBase, ManagerTermBaseCfg
+
+if TYPE_CHECKING:
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+
+
+@dataclass(kw_only=True)
+class MetricsTermCfg(ManagerTermBaseCfg):
+  """Configuration for a metrics term."""
+
+  pass
+
+
+class MetricsManager(ManagerBase):
+  """Accumulates per-step metric values, reports episode averages.
+
+  Unlike rewards, metrics have no weight, no dt scaling, and no
+  normalization by episode length. Episode values are true per-step
+  averages (sum / step_count), so a metric in [0,1] stays in [0,1]
+  in the logger.
+  """
+
+  _env: ManagerBasedRlEnv
+
+  def __init__(self, cfg: dict[str, MetricsTermCfg], env: ManagerBasedRlEnv):
+    self._term_names: list[str] = list()
+    self._term_cfgs: list[MetricsTermCfg] = list()
+    self._class_term_cfgs: list[MetricsTermCfg] = list()
+
+    self.cfg = deepcopy(cfg)
+    super().__init__(env=env)
+
+    self._episode_sums: dict[str, torch.Tensor] = {}
+    for term_name in self._term_names:
+      self._episode_sums[term_name] = torch.zeros(
+        self.num_envs, dtype=torch.float, device=self.device
+      )
+    self._step_count = torch.zeros(self.num_envs, dtype=torch.long, device=self.device)
+    self._step_values = torch.zeros(
+      (self.num_envs, len(self._term_names)), dtype=torch.float, device=self.device
+    )
+
+  def __str__(self) -> str:
+    msg = f"<MetricsManager> contains {len(self._term_names)} active terms.\n"
+    table = PrettyTable()
+    table.title = "Active Metrics Terms"
+    table.field_names = ["Index", "Name"]
+    table.align["Name"] = "l"
+    for index, name in enumerate(self._term_names):
+      table.add_row([index, name])
+    msg += table.get_string()
+    msg += "\n"
+    return msg
+
+  # Properties.
+
+  @property
+  def active_terms(self) -> list[str]:
+    return self._term_names
+
+  # Methods.
+
+  def reset(
+    self, env_ids: torch.Tensor | slice | None = None
+  ) -> dict[str, torch.Tensor]:
+    if env_ids is None:
+      env_ids = slice(None)
+    extras = {}
+    counts = self._step_count[env_ids].float()
+    # Avoid division by zero for envs that haven't stepped.
+    safe_counts = torch.clamp(counts, min=1.0)
+    for key in self._episode_sums:
+      episode_avg = torch.mean(self._episode_sums[key][env_ids] / safe_counts)
+      extras["Episode_Metrics/" + key] = episode_avg
+      self._episode_sums[key][env_ids] = 0.0
+    self._step_count[env_ids] = 0
+    for term_cfg in self._class_term_cfgs:
+      term_cfg.func.reset(env_ids=env_ids)
+    return extras
+
+  def compute(self) -> None:
+    self._step_count += 1
+    for term_idx, (name, term_cfg) in enumerate(
+      zip(self._term_names, self._term_cfgs, strict=False)
+    ):
+      value = term_cfg.func(self._env, **term_cfg.params)
+      self._episode_sums[name] += value
+      self._step_values[:, term_idx] = value
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    terms = []
+    for idx, name in enumerate(self._term_names):
+      terms.append((name, [self._step_values[env_idx, idx].cpu().item()]))
+    return terms
+
+  def _prepare_terms(self):
+    for term_name, term_cfg in self.cfg.items():
+      term_cfg: MetricsTermCfg | None
+      if term_cfg is None:
+        print(f"term: {term_name} set to None, skipping...")
+        continue
+      self._resolve_common_term_cfg(term_name, term_cfg)
+      self._term_names.append(term_name)
+      self._term_cfgs.append(term_cfg)
+      if hasattr(term_cfg.func, "reset") and callable(term_cfg.func.reset):
+        self._class_term_cfgs.append(term_cfg)
+
+
+class NullMetricsManager:
+  """Placeholder for absent metrics manager that safely no-ops all operations."""
+
+  def __init__(self):
+    self.active_terms: list[str] = []
+    self.cfg = None
+
+  def __str__(self) -> str:
+    return "<NullMetricsManager> (inactive)"
+
+  def __repr__(self) -> str:
+    return "NullMetricsManager()"
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    return []
+
+  def reset(self, env_ids: torch.Tensor | None = None) -> dict[str, float]:
+    return {}
+
+  def compute(self) -> None:
+    pass

mjlab/src/mjlab/managers/observation_manager.py

@@ -0,0 +1,485 @@
+"""Observation manager for computing observations."""
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Literal, Sequence
+
+import numpy as np
+import torch
+from prettytable import PrettyTable
+
+from mjlab.managers.manager_base import ManagerBase, ManagerTermBaseCfg
+from mjlab.utils.buffers import CircularBuffer, DelayBuffer
+from mjlab.utils.noise import noise_cfg, noise_model
+from mjlab.utils.noise.noise_cfg import NoiseCfg, NoiseModelCfg
+
+
+@dataclass
+class ObservationTermCfg(ManagerTermBaseCfg):
+  """Configuration for an observation term.
+
+  Processing pipeline: compute → noise → clip → scale → delay → history.
+  Delay models sensor latency. History provides temporal context. Both are optional
+  and can be combined.
+  """
+
+  noise: NoiseCfg | NoiseModelCfg | None = None
+  """Noise model to apply to the observation."""
+
+  clip: tuple[float, float] | None = None
+  """Range (min, max) to clip the observation values."""
+
+  scale: tuple[float, ...] | float | torch.Tensor | None = None
+  """Scaling factor(s) to multiply the observation by."""
+
+  delay_min_lag: int = 0
+  """Minimum lag (in steps) for delayed observations. Lag sampled uniformly from
+  [min_lag, max_lag]. Convert to ms: lag * (1000 / control_hz)."""
+
+  delay_max_lag: int = 0
+  """Maximum lag (in steps) for delayed observations. Use min=max for constant delay."""
+
+  delay_per_env: bool = True
+  """If True, each environment samples its own lag. If False, all environments share
+  the same lag at each step."""
+
+  delay_hold_prob: float = 0.0
+  """Probability of reusing the previous lag instead of resampling. Useful for
+  temporally correlated latency patterns."""
+
+  delay_update_period: int = 0
+  """Resample lag every N steps (models multi-rate sensors). If 0, update every step."""
+
+  delay_per_env_phase: bool = True
+  """If True and update_period > 0, stagger update timing across envs to avoid
+  synchronized resampling."""
+
+  history_length: int = 0
+  """Number of past observations to keep in history. 0 = no history."""
+
+  flatten_history_dim: bool = True
+  """Whether to flatten the history dimension into observation.
+
+  When True and concatenate_terms=True, uses term-major ordering:
+  [A_t0, A_t1, ..., A_tH-1, B_t0, B_t1, ..., B_tH-1, ...]
+  See docs/source/observation.rst for details on ordering."""
+
+
+@dataclass
+class ObservationGroupCfg:
+  """Configuration for an observation group.
+
+  An observation group bundles multiple observation terms together. Groups are
+  typically used to separate observations for different purposes (e.g., "actor"
+  for the actor, "critic" for the value function).
+  """
+
+  terms: dict[str, ObservationTermCfg]
+  """Dictionary mapping term names to their configurations."""
+
+  concatenate_terms: bool = True
+  """Whether to concatenate all terms into a single tensor. If False, returns
+  a dict mapping term names to their individual tensors."""
+
+  concatenate_dim: int = -1
+  """Dimension along which to concatenate terms. Default -1 (last dimension)."""
+
+  enable_corruption: bool = False
+  """Whether to apply noise corruption to observations. Set to True during
+  training for domain randomization, False during evaluation."""
+
+  history_length: int | None = None
+  """Group-level history length override. If set, applies to all terms in
+  this group. If None, each term uses its own ``history_length`` setting."""
+
+  flatten_history_dim: bool = True
+  """Whether to flatten history into the observation dimension. If True,
+  observations have shape ``(num_envs, obs_dim * history_length)``. If False,
+  shape is ``(num_envs, history_length, obs_dim)``."""
+
+  nan_policy: Literal["disabled", "warn", "sanitize", "error"] = "disabled"
+  """NaN/Inf handling policy for observations in this group.
+
+  - 'disabled': No checks (default, fastest)
+  - 'warn': Log warning with term name and env IDs, then sanitize (debugging)
+  - 'sanitize': Silent sanitization to 0.0 like reward manager (safe for production)
+  - 'error': Raise ValueError on NaN/Inf (strict development mode)
+  """
+
+  nan_check_per_term: bool = True
+  """If True, check each observation term individually to identify NaN source.
+  If False, check only the final concatenated output (faster but less informative).
+  Only applies when nan_policy != 'disabled'."""
+
+
+class ObservationManager(ManagerBase):
+  """Manages observation computation for the environment.
+
+  The observation manager computes observations from multiple terms organized
+  into groups. Each term can have noise, clipping, scaling, delay, and history
+  applied. Groups can optionally concatenate their terms into a single tensor.
+  """
+
+  def __init__(self, cfg: dict[str, ObservationGroupCfg], env):
+    self.cfg = deepcopy(cfg)
+    super().__init__(env=env)
+
+    self._group_obs_dim: dict[str, tuple[int, ...] | list[tuple[int, ...]]] = dict()
+
+    for group_name, group_term_dims in self._group_obs_term_dim.items():
+      if self._group_obs_concatenate[group_name]:
+        term_dims = torch.stack(
+          [torch.tensor(dims, device="cpu") for dims in group_term_dims], dim=0
+        )
+        if len(term_dims.shape) > 1:
+          if self._group_obs_concatenate_dim[group_name] >= 0:
+            dim = self._group_obs_concatenate_dim[group_name] - 1
+          else:
+            dim = self._group_obs_concatenate_dim[group_name]
+          dim_sum = torch.sum(term_dims[:, dim], dim=0)
+          term_dims[0, dim] = dim_sum
+          term_dims = term_dims[0]
+        else:
+          term_dims = torch.sum(term_dims, dim=0)
+        self._group_obs_dim[group_name] = tuple(term_dims.tolist())
+      else:
+        self._group_obs_dim[group_name] = group_term_dims
+
+    self._obs_buffer: dict[str, torch.Tensor | dict[str, torch.Tensor]] | None = None
+
+  def __str__(self) -> str:
+    msg = f"<ObservationManager> contains {len(self._group_obs_term_names)} groups.\n"
+    for group_name, group_dim in self._group_obs_dim.items():
+      table = PrettyTable()
+      table.title = f"Active Observation Terms in Group: '{group_name}'"
+      if self._group_obs_concatenate[group_name]:
+        table.title += f" (shape: {group_dim})"  # type: ignore
+      table.field_names = ["Index", "Name", "Shape"]
+      table.align["Name"] = "l"
+      obs_terms = zip(
+        self._group_obs_term_names[group_name],
+        self._group_obs_term_dim[group_name],
+        self._group_obs_term_cfgs[group_name],
+        strict=False,
+      )
+      for index, (name, dims, term_cfg) in enumerate(obs_terms):
+        if term_cfg.history_length > 0 and term_cfg.flatten_history_dim:
+          # Flattened history: show (9,) ← 3×(3,)
+          original_size = int(np.prod(dims)) // term_cfg.history_length
+          original_shape = (original_size,) if len(dims) == 1 else dims[1:]
+          shape_str = f"{dims}  ← {term_cfg.history_length}×{original_shape}"
+        else:
+          shape_str = str(tuple(dims))
+        table.add_row([index, name, shape_str])
+      msg += table.get_string()
+      msg += "\n"
+    return msg
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    terms = []
+
+    if self._obs_buffer is None:
+      self.compute()
+    assert self._obs_buffer is not None
+    obs_buffer: dict[str, torch.Tensor | dict[str, torch.Tensor]] = self._obs_buffer
+
+    for group_name, _ in self.group_obs_dim.items():
+      if not self.group_obs_concatenate[group_name]:
+        buffers = obs_buffer[group_name]
+        assert isinstance(buffers, dict)
+        for name, term in buffers.items():
+          terms.append((group_name + "-" + name, term[env_idx].cpu().tolist()))  # type: ignore[unsupported-operator]
+        continue
+
+      idx = 0
+      data = obs_buffer[group_name]
+      assert isinstance(data, torch.Tensor)
+      for name, shape in zip(
+        self._group_obs_term_names[group_name],
+        self._group_obs_term_dim[group_name],
+        strict=False,
+      ):
+        data_length = np.prod(shape)
+        term = data[env_idx, idx : idx + data_length]
+        terms.append((group_name + "-" + name, term.cpu().tolist()))
+        idx += data_length
+
+    return terms
+
+  # Properties.
+
+  @property
+  def active_terms(self) -> dict[str, list[str]]:
+    return self._group_obs_term_names
+
+  @property
+  def group_obs_dim(self) -> dict[str, tuple[int, ...] | list[tuple[int, ...]]]:
+    return self._group_obs_dim
+
+  @property
+  def group_obs_term_dim(self) -> dict[str, list[tuple[int, ...]]]:
+    return self._group_obs_term_dim
+
+  @property
+  def group_obs_concatenate(self) -> dict[str, bool]:
+    return self._group_obs_concatenate
+
+  # Methods.
+
+  def get_term_cfg(self, group_name: str, term_name: str) -> ObservationTermCfg:
+    if group_name not in self._group_obs_term_names:
+      raise ValueError(f"Group '{group_name}' not found in active groups.")
+    if term_name not in self._group_obs_term_names[group_name]:
+      raise ValueError(f"Term '{term_name}' not found in group '{group_name}'.")
+    index = self._group_obs_term_names[group_name].index(term_name)
+    return self._group_obs_term_cfgs[group_name][index]
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> dict[str, float]:
+    # Invalidate cache since reset envs will have different observations.
+    self._obs_buffer = None
+
+    for group_name, group_cfg in self._group_obs_class_term_cfgs.items():
+      for term_cfg in group_cfg:
+        term_cfg.func.reset(env_ids=env_ids)
+      for term_name in self._group_obs_term_names[group_name]:
+        batch_ids = None if isinstance(env_ids, slice) else env_ids
+        if term_name in self._group_obs_term_delay_buffer[group_name]:
+          self._group_obs_term_delay_buffer[group_name][term_name].reset(
+            batch_ids=batch_ids
+          )
+        if term_name in self._group_obs_term_history_buffer[group_name]:
+          self._group_obs_term_history_buffer[group_name][term_name].reset(
+            batch_ids=batch_ids
+          )
+    for mod in self._group_obs_class_instances.values():
+      mod.reset(env_ids=env_ids)
+    return {}
+
+  def _check_and_handle_nans(
+    self, tensor: torch.Tensor, context: str, policy: str
+  ) -> torch.Tensor:
+    """Check for NaN/Inf and handle according to policy.
+
+    Args:
+      tensor: Observation tensor to check.
+      context: Context string for error/warning messages (e.g., "actor/base_lin_vel").
+      policy: NaN handling policy ("disabled", "warn", "sanitize", "error").
+
+    Returns:
+      The tensor, potentially sanitized depending on policy.
+
+    Raises:
+      ValueError: If policy is "error" and NaN/Inf detected.
+    """
+    if policy == "disabled":
+      return tensor
+
+    has_nan = torch.isnan(tensor).any()
+    has_inf = torch.isinf(tensor).any()
+
+    if not (has_nan or has_inf):
+      return tensor
+
+    if policy == "error":
+      nan_mask = torch.isnan(tensor).any(dim=-1) | torch.isinf(tensor).any(dim=-1)
+      nan_env_ids = torch.where(nan_mask)[0].cpu().tolist()
+      raise ValueError(
+        f"NaN/Inf detected in observation '{context}' "
+        f"for environments: {nan_env_ids[:10]}"
+      )
+
+    if policy == "warn":
+      nan_mask = torch.isnan(tensor).any(dim=-1) | torch.isinf(tensor).any(dim=-1)
+      nan_env_ids = torch.where(nan_mask)[0].cpu().tolist()
+      print(
+        f"[ObservationManager] NaN/Inf in '{context}' "
+        f"(envs: {nan_env_ids[:5]}). Sanitizing to 0."
+      )
+
+    # Sanitize (applies to both "warn" and "sanitize" policies).
+    return torch.nan_to_num(tensor, nan=0.0, posinf=0.0, neginf=0.0)
+
+  def compute(
+    self, update_history: bool = False
+  ) -> dict[str, torch.Tensor | dict[str, torch.Tensor]]:
+    # Return cached observations if not updating and cache exists.
+    # This prevents double-pushing to delay buffers when compute() is called
+    # multiple times per control step (e.g., in get_observations() after step()).
+    if not update_history and self._obs_buffer is not None:
+      return self._obs_buffer
+
+    obs_buffer: dict[str, torch.Tensor | dict[str, torch.Tensor]] = dict()
+    for group_name in self._group_obs_term_names:
+      obs_buffer[group_name] = self.compute_group(group_name, update_history)
+    self._obs_buffer = obs_buffer
+    return obs_buffer
+
+  def compute_group(
+    self, group_name: str, update_history: bool = False
+  ) -> torch.Tensor | dict[str, torch.Tensor]:
+    group_cfg = self.cfg[group_name]
+    group_term_names = self._group_obs_term_names[group_name]
+    group_obs: dict[str, torch.Tensor] = {}
+    obs_terms = zip(
+      group_term_names, self._group_obs_term_cfgs[group_name], strict=False
+    )
+    for term_name, term_cfg in obs_terms:
+      obs: torch.Tensor = term_cfg.func(self._env, **term_cfg.params).clone()
+      if isinstance(term_cfg.noise, noise_cfg.NoiseCfg):
+        obs = term_cfg.noise.apply(obs)
+      elif isinstance(term_cfg.noise, noise_cfg.NoiseModelCfg):
+        obs = self._group_obs_class_instances[term_name](obs)
+      if term_cfg.clip:
+        obs = obs.clip_(min=term_cfg.clip[0], max=term_cfg.clip[1])
+      if term_cfg.scale is not None:
+        scale = term_cfg.scale
+        assert isinstance(scale, torch.Tensor)
+        obs = obs.mul_(scale)
+
+      # Check for NaN/Inf before delay/history buffers (per-term checking).
+      if group_cfg.nan_check_per_term and group_cfg.nan_policy != "disabled":
+        obs = self._check_and_handle_nans(
+          obs, context=f"{group_name}/{term_name}", policy=group_cfg.nan_policy
+        )
+
+      if term_cfg.delay_max_lag > 0:
+        delay_buffer = self._group_obs_term_delay_buffer[group_name][term_name]
+        delay_buffer.append(obs)
+        obs = delay_buffer.compute()
+      if term_cfg.history_length > 0:
+        circular_buffer = self._group_obs_term_history_buffer[group_name][term_name]
+        if update_history or not circular_buffer.is_initialized:
+          circular_buffer.append(obs)
+
+        if term_cfg.flatten_history_dim:
+          group_obs[term_name] = circular_buffer.buffer.reshape(self._env.num_envs, -1)
+        else:
+          group_obs[term_name] = circular_buffer.buffer
+      else:
+        group_obs[term_name] = obs
+
+    # Final NaN check for non-per-term checking.
+    if not group_cfg.nan_check_per_term and group_cfg.nan_policy != "disabled":
+      if self._group_obs_concatenate[group_name]:
+        # Will check after concatenation below.
+        pass
+      else:
+        for term_name in group_obs:
+          group_obs[term_name] = self._check_and_handle_nans(
+            group_obs[term_name],
+            context=f"{group_name}/{term_name}",
+            policy=group_cfg.nan_policy,
+          )
+
+    if self._group_obs_concatenate[group_name]:
+      result = torch.cat(
+        list(group_obs.values()), dim=self._group_obs_concatenate_dim[group_name]
+      )
+      # Final check for concatenated result (non-per-term checking).
+      if not group_cfg.nan_check_per_term and group_cfg.nan_policy != "disabled":
+        result = self._check_and_handle_nans(
+          result, context=group_name, policy=group_cfg.nan_policy
+        )
+      return result
+    return group_obs
+
+  def _prepare_terms(self) -> None:
+    self._group_obs_term_names: dict[str, list[str]] = dict()
+    self._group_obs_term_dim: dict[str, list[tuple[int, ...]]] = dict()
+    self._group_obs_term_cfgs: dict[str, list[ObservationTermCfg]] = dict()
+    self._group_obs_class_term_cfgs: dict[str, list[ObservationTermCfg]] = dict()
+    self._group_obs_concatenate: dict[str, bool] = dict()
+    self._group_obs_concatenate_dim: dict[str, int] = dict()
+    self._group_obs_class_instances: dict[str, noise_model.NoiseModel] = {}
+    self._group_obs_term_delay_buffer: dict[str, dict[str, DelayBuffer]] = dict()
+    self._group_obs_term_history_buffer: dict[str, dict[str, CircularBuffer]] = dict()
+
+    for group_name, group_cfg in self.cfg.items():
+      group_cfg: ObservationGroupCfg | None
+      if group_cfg is None:
+        print(f"group: {group_name} set to None, skipping...")
+        continue
+
+      self._group_obs_term_names[group_name] = list()
+      self._group_obs_term_dim[group_name] = list()
+      self._group_obs_term_cfgs[group_name] = list()
+      self._group_obs_class_term_cfgs[group_name] = list()
+      group_entry_delay_buffer: dict[str, DelayBuffer] = dict()
+      group_entry_history_buffer: dict[str, CircularBuffer] = dict()
+
+      self._group_obs_concatenate[group_name] = group_cfg.concatenate_terms
+      self._group_obs_concatenate_dim[group_name] = (
+        group_cfg.concatenate_dim + 1
+        if group_cfg.concatenate_dim >= 0
+        else group_cfg.concatenate_dim
+      )
+
+      for term_name, term_cfg in group_cfg.terms.items():
+        term_cfg: ObservationTermCfg | None
+        if term_cfg is None:
+          print(f"term: {term_name} set to None, skipping...")
+          continue
+
+        # NOTE: This deepcopy is important to avoid cross-group contamination of term
+        # configs.
+        term_cfg = deepcopy(term_cfg)
+        self._resolve_common_term_cfg(term_name, term_cfg)
+
+        if not group_cfg.enable_corruption:
+          term_cfg.noise = None
+        if group_cfg.history_length is not None:
+          term_cfg.history_length = group_cfg.history_length
+          term_cfg.flatten_history_dim = group_cfg.flatten_history_dim
+        self._group_obs_term_names[group_name].append(term_name)
+        self._group_obs_term_cfgs[group_name].append(term_cfg)
+        if hasattr(term_cfg.func, "reset") and callable(term_cfg.func.reset):
+          self._group_obs_class_term_cfgs[group_name].append(term_cfg)
+
+        obs_dims = tuple(term_cfg.func(self._env, **term_cfg.params).shape)
+
+        if term_cfg.scale is not None:
+          term_cfg.scale = torch.tensor(
+            term_cfg.scale, dtype=torch.float, device=self._env.device
+          )
+
+        if term_cfg.noise is not None and isinstance(
+          term_cfg.noise, noise_cfg.NoiseModelCfg
+        ):
+          noise_model_cls = term_cfg.noise.class_type
+          assert issubclass(noise_model_cls, noise_model.NoiseModel), (
+            f"Class type for observation term '{term_name}' NoiseModelCfg"
+            f" is not a subclass of 'NoiseModel'. Received: '{type(noise_model_cls)}'."
+          )
+          self._group_obs_class_instances[term_name] = noise_model_cls(
+            term_cfg.noise, num_envs=self._env.num_envs, device=self._env.device
+          )
+
+        if term_cfg.delay_max_lag > 0:
+          group_entry_delay_buffer[term_name] = DelayBuffer(
+            min_lag=term_cfg.delay_min_lag,
+            max_lag=term_cfg.delay_max_lag,
+            batch_size=self._env.num_envs,
+            device=self._env.device,
+            per_env=term_cfg.delay_per_env,
+            hold_prob=term_cfg.delay_hold_prob,
+            update_period=term_cfg.delay_update_period,
+            per_env_phase=term_cfg.delay_per_env_phase,
+          )
+
+        if term_cfg.history_length > 0:
+          group_entry_history_buffer[term_name] = CircularBuffer(
+            max_len=term_cfg.history_length,
+            batch_size=self._env.num_envs,
+            device=self._env.device,
+          )
+          old_dims = list(obs_dims)
+          old_dims.insert(1, term_cfg.history_length)
+          obs_dims = tuple(old_dims)
+          if term_cfg.flatten_history_dim:
+            obs_dims = (obs_dims[0], int(np.prod(obs_dims[1:])))
+
+        self._group_obs_term_dim[group_name].append(obs_dims[1:])
+      self._group_obs_term_delay_buffer[group_name] = group_entry_delay_buffer
+      self._group_obs_term_history_buffer[group_name] = group_entry_history_buffer

mjlab/src/mjlab/managers/reward_manager.py

@@ -0,0 +1,153 @@
+"""Reward manager for computing reward signals."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+import torch
+from prettytable import PrettyTable
+
+from mjlab.managers.manager_base import ManagerBase, ManagerTermBaseCfg
+
+if TYPE_CHECKING:
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+
+
+@dataclass(kw_only=True)
+class RewardTermCfg(ManagerTermBaseCfg):
+  """Configuration for a reward term."""
+
+  func: Any
+  """The callable that computes this reward term's value."""
+
+  weight: float
+  """Weight multiplier for this reward term."""
+
+
+class RewardManager(ManagerBase):
+  """Manages reward computation by aggregating weighted reward terms.
+
+  Reward Scaling Behavior:
+    By default, rewards are scaled by the environment step duration (dt). This
+    normalizes cumulative episodic rewards across different simulation frequencies.
+    The scaling can be disabled via the ``scale_by_dt`` parameter.
+
+    When ``scale_by_dt=True`` (default):
+      - ``reward_buf`` (returned by ``compute()``) = raw_value * weight * dt
+      - ``_episode_sums`` (cumulative rewards) are scaled by dt
+      - ``Episode_Reward/*`` logged metrics are scaled by dt
+
+    When ``scale_by_dt=False``:
+      - ``reward_buf`` = raw_value * weight (no dt scaling)
+
+    Regardless of the scaling setting:
+      - ``_step_reward`` (via ``get_active_iterable_terms()``) always contains
+        the unscaled reward rate (raw_value * weight)
+  """
+
+  _env: ManagerBasedRlEnv
+
+  def __init__(
+    self,
+    cfg: dict[str, RewardTermCfg],
+    env: ManagerBasedRlEnv,
+    *,
+    scale_by_dt: bool = True,
+  ):
+    self._term_names: list[str] = list()
+    self._term_cfgs: list[RewardTermCfg] = list()
+    self._class_term_cfgs: list[RewardTermCfg] = list()
+    self._scale_by_dt = scale_by_dt
+
+    self.cfg = deepcopy(cfg)
+    super().__init__(env=env)
+    self._episode_sums = dict()
+    for term_name in self._term_names:
+      self._episode_sums[term_name] = torch.zeros(
+        self.num_envs, dtype=torch.float, device=self.device
+      )
+    self._reward_buf = torch.zeros(self.num_envs, dtype=torch.float, device=self.device)
+    self._step_reward = torch.zeros(
+      (self.num_envs, len(self._term_names)), dtype=torch.float, device=self.device
+    )
+
+  def __str__(self) -> str:
+    msg = f"<RewardManager> contains {len(self._term_names)} active terms.\n"
+    table = PrettyTable()
+    table.title = "Active Reward Terms"
+    table.field_names = ["Index", "Name", "Weight"]
+    table.align["Name"] = "l"
+    table.align["Weight"] = "r"
+    for index, (name, term_cfg) in enumerate(
+      zip(self._term_names, self._term_cfgs, strict=False)
+    ):
+      table.add_row([index, name, term_cfg.weight])
+    msg += table.get_string()
+    msg += "\n"
+    return msg
+
+  # Properties.
+
+  @property
+  def active_terms(self) -> list[str]:
+    return self._term_names
+
+  # Methods.
+
+  def reset(
+    self, env_ids: torch.Tensor | slice | None = None
+  ) -> dict[str, torch.Tensor]:
+    if env_ids is None:
+      env_ids = slice(None)
+    extras = {}
+    for key in self._episode_sums.keys():
+      episodic_sum_avg = torch.mean(self._episode_sums[key][env_ids])
+      extras["Episode_Reward/" + key] = (
+        episodic_sum_avg / self._env.max_episode_length_s
+      )
+      self._episode_sums[key][env_ids] = 0.0
+    for term_cfg in self._class_term_cfgs:
+      term_cfg.func.reset(env_ids=env_ids)
+    return extras
+
+  def compute(self, dt: float) -> torch.Tensor:
+    self._reward_buf[:] = 0.0
+    scale = dt if self._scale_by_dt else 1.0
+    for term_idx, (name, term_cfg) in enumerate(
+      zip(self._term_names, self._term_cfgs, strict=False)
+    ):
+      if term_cfg.weight == 0.0:
+        self._step_reward[:, term_idx] = 0.0
+        continue
+      value = term_cfg.func(self._env, **term_cfg.params) * term_cfg.weight * scale
+      # NaN/Inf can occur from corrupted physics state; zero them to avoid policy crash.
+      value = torch.nan_to_num(value, nan=0.0, posinf=0.0, neginf=0.0)
+      self._reward_buf += value
+      self._episode_sums[name] += value
+      self._step_reward[:, term_idx] = value / scale
+    return self._reward_buf
+
+  def get_active_iterable_terms(self, env_idx):
+    terms = []
+    for idx, name in enumerate(self._term_names):
+      terms.append((name, [self._step_reward[env_idx, idx].cpu().item()]))
+    return terms
+
+  def get_term_cfg(self, term_name: str) -> RewardTermCfg:
+    if term_name not in self._term_names:
+      raise ValueError(f"Term '{term_name}' not found in active terms.")
+    return self._term_cfgs[self._term_names.index(term_name)]
+
+  def _prepare_terms(self):
+    for term_name, term_cfg in self.cfg.items():
+      term_cfg: RewardTermCfg | None
+      if term_cfg is None:
+        print(f"term: {term_name} set to None, skipping...")
+        continue
+      self._resolve_common_term_cfg(term_name, term_cfg)
+      self._term_names.append(term_name)
+      self._term_cfgs.append(term_cfg)
+      if hasattr(term_cfg.func, "reset") and callable(term_cfg.func.reset):
+        self._class_term_cfgs.append(term_cfg)

mjlab/src/mjlab/managers/scene_entity_config.py

@@ -0,0 +1,190 @@
+"""Configuration for scene entities used by manager terms."""
+
+from dataclasses import dataclass, field
+from typing import NamedTuple
+
+from mjlab.entity import Entity
+from mjlab.scene import Scene
+
+
+class _FieldConfig(NamedTuple):
+  """Configuration for a resolvable entity field."""
+
+  names_attr: str
+  ids_attr: str
+  find_method: str
+  num_attr: str
+  kind_label: str
+
+
+_FIELD_CONFIGS = [
+  _FieldConfig("joint_names", "joint_ids", "find_joints", "num_joints", "joint"),
+  _FieldConfig("body_names", "body_ids", "find_bodies", "num_bodies", "body"),
+  _FieldConfig("geom_names", "geom_ids", "find_geoms", "num_geoms", "geom"),
+  _FieldConfig("site_names", "site_ids", "find_sites", "num_sites", "site"),
+  _FieldConfig(
+    "actuator_names", "actuator_ids", "find_actuators", "num_actuators", "actuator"
+  ),
+]
+
+
+@dataclass
+class SceneEntityCfg:
+  """Configuration for a scene entity that is used by the manager's term.
+
+  This configuration allows flexible specification of entity components either by name
+  or by ID. During resolution, it ensures consistency between names and IDs, and can
+  optimize to slice(None) when all components are selected.
+  """
+
+  name: str
+  """The name of the entity in the scene."""
+
+  joint_names: str | tuple[str, ...] | None = None
+  """Names of joints to include. Can be a single string or tuple."""
+
+  joint_ids: list[int] | slice = field(default_factory=lambda: slice(None))
+  """IDs of joints to include. Can be a list or slice."""
+
+  body_names: str | tuple[str, ...] | None = None
+  """Names of bodies to include. Can be a single string or tuple."""
+
+  body_ids: list[int] | slice = field(default_factory=lambda: slice(None))
+  """IDs of bodies to include. Can be a list or slice."""
+
+  geom_names: str | tuple[str, ...] | None = None
+  """Names of geometries to include. Can be a single string or tuple."""
+
+  geom_ids: list[int] | slice = field(default_factory=lambda: slice(None))
+  """IDs of geometries to include. Can be a list or slice."""
+
+  site_names: str | tuple[str, ...] | None = None
+  """Names of sites to include. Can be a single string or tuple."""
+
+  site_ids: list[int] | slice = field(default_factory=lambda: slice(None))
+  """IDs of sites to include. Can be a list or slice."""
+
+  actuator_names: str | list[str] | None = None
+  """Names of actuators to include. Can be a single string or list."""
+
+  actuator_ids: list[int] | slice = field(default_factory=lambda: slice(None))
+  """IDs of actuators to include. Can be a list or slice."""
+
+  preserve_order: bool = False
+  """If True, maintains the order of components as specified."""
+
+  def resolve(self, scene: Scene) -> None:
+    """Resolve names and IDs for all configured fields.
+
+    This method ensures consistency between names and IDs for each field type.
+    It handles three cases:
+    1. Both names and IDs provided: Validates they match
+    2. Only names provided: Computes IDs (optimizes to slice(None) if all selected)
+    3. Only IDs provided: Computes names
+
+    Args:
+      scene: The scene containing the entity to resolve against.
+
+    Raises:
+      ValueError: If provided names and IDs are inconsistent.
+      KeyError: If the entity name is not found in the scene.
+    """
+    entity = scene[self.name]
+
+    for config in _FIELD_CONFIGS:
+      self._resolve_field(entity, config)
+
+  def _resolve_field(self, entity: Entity, config: _FieldConfig) -> None:
+    """Resolve a single field's names and IDs.
+
+    Args:
+      entity: The entity to resolve against.
+      config: Field configuration specifying attribute names and methods.
+    """
+    names = getattr(self, config.names_attr)
+    ids = getattr(self, config.ids_attr)
+
+    # Early return if nothing to resolve.
+    if names is None and not isinstance(ids, list):
+      return
+
+    # Get entity metadata.
+    entity_all_names = getattr(entity, config.names_attr)
+    entity_count = getattr(entity, config.num_attr)
+    find_method = getattr(entity, config.find_method)
+
+    # Normalize single values to lists for uniform processing.
+    names = self._normalize_to_list(names)
+    if names is not None:
+      setattr(self, config.names_attr, names)
+
+    if isinstance(ids, (int, list)):
+      ids = self._normalize_to_list(ids)
+      setattr(self, config.ids_attr, ids)
+
+    # Handle three resolution cases.
+    if names is not None and isinstance(ids, list):
+      self._validate_consistency(
+        names, ids, entity_all_names, find_method, config.kind_label
+      )
+    elif names is not None:
+      self._resolve_names_to_ids(
+        names, entity_all_names, entity_count, find_method, config.ids_attr
+      )
+    elif isinstance(ids, list):
+      self._resolve_ids_to_names(ids, entity_all_names, config.names_attr)
+
+  def _normalize_to_list(self, value: str | int | list | None) -> list | None:
+    """Convert single values to lists for uniform processing."""
+    if value is None:
+      return None
+    if isinstance(value, (str, int)):
+      return [value]
+    return value
+
+  def _validate_consistency(
+    self,
+    names: list[str],
+    ids: list[int],
+    entity_all_names: list[str],
+    find_method,
+    kind_label: str,
+  ) -> None:
+    """Validate that provided names and IDs are consistent.
+
+    Raises:
+      ValueError: If names and IDs don't match.
+    """
+    found_ids, _ = find_method(names, preserve_order=self.preserve_order)
+    computed_names = [entity_all_names[i] for i in ids]
+
+    if found_ids != ids or computed_names != names:
+      raise ValueError(
+        f"Inconsistent {kind_label} names and indices. "
+        f"Names {names} resolved to indices {found_ids}, "
+        f"but indices {ids} (mapping to names {computed_names}) were provided."
+      )
+
+  def _resolve_names_to_ids(
+    self,
+    names: list[str],
+    entity_all_names: list[str],
+    entity_count: int,
+    find_method,
+    ids_attr: str,
+  ) -> None:
+    """Resolve names to IDs, optimizing to slice(None) when all are selected."""
+    found_ids, _ = find_method(names, preserve_order=self.preserve_order)
+
+    # Optimize to slice(None) if all components are selected in order.
+    if len(found_ids) == entity_count and names == entity_all_names:
+      setattr(self, ids_attr, slice(None))
+    else:
+      setattr(self, ids_attr, found_ids)
+
+  def _resolve_ids_to_names(
+    self, ids: list[int], entity_all_names: list[str], names_attr: str
+  ) -> None:
+    """Resolve IDs to their corresponding names."""
+    resolved_names = [entity_all_names[i] for i in ids]
+    setattr(self, names_attr, resolved_names)

mjlab/src/mjlab/managers/termination_manager.py

@@ -0,0 +1,140 @@
+"""Termination manager for computing done signals."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Sequence
+
+import torch
+from prettytable import PrettyTable
+
+from mjlab.managers.manager_base import ManagerBase, ManagerTermBaseCfg
+
+if TYPE_CHECKING:
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+
+
+@dataclass
+class TerminationTermCfg(ManagerTermBaseCfg):
+  """Configuration for a termination term."""
+
+  time_out: bool = False
+  """Whether the term contributes towards episodic timeouts."""
+
+
+class TerminationManager(ManagerBase):
+  """Manages termination conditions for the environment.
+
+  The termination manager aggregates multiple termination terms to compute
+  episode done signals. Terms can be either truncations (time-based) or
+  terminations (failure conditions).
+  """
+
+  _env: ManagerBasedRlEnv
+
+  def __init__(self, cfg: dict[str, TerminationTermCfg], env: ManagerBasedRlEnv):
+    self._term_names: list[str] = list()
+    self._term_cfgs: list[TerminationTermCfg] = list()
+    self._class_term_cfgs: list[TerminationTermCfg] = list()
+
+    self.cfg = deepcopy(cfg)
+    super().__init__(env)
+
+    self._term_dones = dict()
+    for term_name in self._term_names:
+      self._term_dones[term_name] = torch.zeros(
+        self.num_envs, device=self.device, dtype=torch.bool
+      )
+    self._truncated_buf = torch.zeros(
+      self.num_envs, device=self.device, dtype=torch.bool
+    )
+    self._terminated_buf = torch.zeros_like(self._truncated_buf)
+
+  def __str__(self) -> str:
+    msg = f"<TerminationManager> contains {len(self._term_names)} active terms.\n"
+    table = PrettyTable()
+    table.title = "Active Termination Terms"
+    table.field_names = ["Index", "Name", "Time Out"]
+    table.align["Name"] = "l"
+    for index, (name, term_cfg) in enumerate(
+      zip(self._term_names, self._term_cfgs, strict=False)
+    ):
+      table.add_row([index, name, term_cfg.time_out])
+    msg += table.get_string()
+    msg += "\n"
+    return msg
+
+  # Properties.
+
+  @property
+  def active_terms(self) -> list[str]:
+    return self._term_names
+
+  @property
+  def dones(self) -> torch.Tensor:
+    return self._truncated_buf | self._terminated_buf
+
+  @property
+  def time_outs(self) -> torch.Tensor:
+    return self._truncated_buf
+
+  @property
+  def terminated(self) -> torch.Tensor:
+    return self._terminated_buf
+
+  # Methods.
+
+  def reset(
+    self, env_ids: torch.Tensor | slice | None = None
+  ) -> dict[str, torch.Tensor]:
+    if env_ids is None:
+      env_ids = slice(None)
+    extras = {}
+    for key in self._term_dones.keys():
+      extras["Episode_Termination/" + key] = torch.count_nonzero(
+        self._term_dones[key][env_ids]
+      ).item()
+    for term_cfg in self._class_term_cfgs:
+      term_cfg.func.reset(env_ids=env_ids)
+    return extras
+
+  def compute(self) -> torch.Tensor:
+    self._truncated_buf[:] = False
+    self._terminated_buf[:] = False
+    for name, term_cfg in zip(self._term_names, self._term_cfgs, strict=False):
+      value = term_cfg.func(self._env, **term_cfg.params)
+      if term_cfg.time_out:
+        self._truncated_buf |= value
+      else:
+        self._terminated_buf |= value
+      self._term_dones[name][:] = value
+    return self._truncated_buf | self._terminated_buf
+
+  def get_term(self, name: str) -> torch.Tensor:
+    return self._term_dones[name]
+
+  def get_term_cfg(self, term_name: str) -> TerminationTermCfg:
+    if term_name not in self._term_names:
+      raise ValueError(f"Term '{term_name}' not found in active terms.")
+    return self._term_cfgs[self._term_names.index(term_name)]
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    terms = []
+    for key in self._term_dones.keys():
+      terms.append((key, [self._term_dones[key][env_idx].float().cpu().item()]))
+    return terms
+
+  def _prepare_terms(self):
+    for term_name, term_cfg in self.cfg.items():
+      term_cfg: TerminationTermCfg | None
+      if term_cfg is None:
+        print(f"term: {term_name} set to None, skipping...")
+        continue
+      self._resolve_common_term_cfg(term_name, term_cfg)
+      self._term_names.append(term_name)
+      self._term_cfgs.append(term_cfg)
+      if hasattr(term_cfg.func, "reset") and callable(term_cfg.func.reset):
+        self._class_term_cfgs.append(term_cfg)

mjlab/src/mjlab/rl/__init__.py

@@ -0,0 +1,6 @@
+from mjlab.rl.config import RslRlBaseRunnerCfg as RslRlBaseRunnerCfg
+from mjlab.rl.config import RslRlModelCfg as RslRlModelCfg
+from mjlab.rl.config import RslRlOnPolicyRunnerCfg as RslRlOnPolicyRunnerCfg
+from mjlab.rl.config import RslRlPpoAlgorithmCfg as RslRlPpoAlgorithmCfg
+from mjlab.rl.runner import MjlabOnPolicyRunner as MjlabOnPolicyRunner
+from mjlab.rl.vecenv_wrapper import RslRlVecEnvWrapper as RslRlVecEnvWrapper

mjlab/src/mjlab/rl/config.py

@@ -0,0 +1,128 @@
+"""RSL-RL configuration."""
+
+from dataclasses import dataclass, field
+from typing import Any, Literal, Tuple
+
+
+@dataclass
+class RslRlModelCfg:
+  """Config for a single neural network model (Actor or Critic)."""
+
+  hidden_dims: Tuple[int, ...] = (128, 128, 128)
+  """The hidden dimensions of the network."""
+  activation: str = "elu"
+  """The activation function."""
+  obs_normalization: bool = False
+  """Whether to normalize the observations. Default is False."""
+  init_noise_std: float = 1.0
+  """The initial noise standard deviation."""
+  noise_std_type: Literal["scalar", "log"] = "scalar"
+  """The type of noise standard deviation."""
+  stochastic: bool = False
+  """Whether the model output is stochastic."""
+  cnn_cfg: dict[str, Any] | None = None
+  """CNN encoder config. When set, class_name should be "CNNModel".
+
+  Passed to ``rsl_rl.modules.CNN``. Common keys: output_channels,
+  kernel_size, stride, padding, activation, global_pool, max_pool.
+  """
+  class_name: str = "MLPModel"
+  """Model class name resolved by RSL-RL (MLPModel or CNNModel)."""
+
+
+@dataclass
+class RslRlPpoAlgorithmCfg:
+  """Config for the PPO algorithm."""
+
+  num_learning_epochs: int = 5
+  """The number of learning epochs per update."""
+  num_mini_batches: int = 4
+  """The number of mini-batches per update.
+  mini batch size = num_envs * num_steps / num_mini_batches
+  """
+  learning_rate: float = 1e-3
+  """The learning rate."""
+  schedule: Literal["adaptive", "fixed"] = "adaptive"
+  """The learning rate schedule."""
+  gamma: float = 0.99
+  """The discount factor."""
+  lam: float = 0.95
+  """The lambda parameter for Generalized Advantage Estimation (GAE)."""
+  entropy_coef: float = 0.005
+  """The coefficient for the entropy loss."""
+  desired_kl: float = 0.01
+  """The desired KL divergence between the new and old policies."""
+  max_grad_norm: float = 1.0
+  """The maximum gradient norm for the policy."""
+  value_loss_coef: float = 1.0
+  """The coefficient for the value loss."""
+  use_clipped_value_loss: bool = True
+  """Whether to use clipped value loss."""
+  clip_param: float = 0.2
+  """The clipping parameter for the policy."""
+  normalize_advantage_per_mini_batch: bool = False
+  """Whether to normalize the advantage per mini-batch. Default is False. If True, the
+  advantage is normalized over the mini-batches only. Otherwise, the advantage is
+  normalized over the entire collected trajectories.
+  """
+  optimizer: Literal["adam", "adamw", "sgd", "rmsprop"] = "adam"
+  """The optimizer to use."""
+  share_cnn_encoders: bool = False
+  """Share CNN encoders between actor and critic."""
+  class_name: str = "PPO"
+  """Algorithm class name resolved by RSL-RL."""
+
+
+@dataclass
+class RslRlBaseRunnerCfg:
+  seed: int = 42
+  """The seed for the experiment. Default is 42."""
+  num_steps_per_env: int = 24
+  """The number of steps per environment update."""
+  max_iterations: int = 300
+  """The maximum number of iterations."""
+  obs_groups: dict[str, tuple[str, ...]] = field(
+    default_factory=lambda: {"actor": ("actor",), "critic": ("critic",)},
+  )
+  save_interval: int = 50
+  """The number of iterations between saves."""
+  experiment_name: str = "exp1"
+  """Directory name used to group runs under
+  ``logs/rsl_rl/{experiment_name}/``."""
+  run_name: str = ""
+  """Optional label appended to the timestamped run directory
+  (e.g. ``2025-01-27_14-30-00_{run_name}``). Also becomes the
+  display name for the run in wandb."""
+  logger: Literal["wandb", "tensorboard"] = "wandb"
+  """The logger to use. Default is wandb."""
+  wandb_project: str = "mjlab"
+  """The wandb project name."""
+  wandb_tags: Tuple[str, ...] = ()
+  """Tags for the wandb run. Default is empty tuple."""
+  resume: bool = False
+  """Whether to resume the experiment. Default is False."""
+  load_run: str = ".*"
+  """The run directory to load. Default is ".*" which means all runs. If regex
+  expression, the latest (alphabetical order) matching run will be loaded.
+  """
+  load_checkpoint: str = "model_.*.pt"
+  """The checkpoint file to load. Default is "model_.*.pt" (all). If regex expression,
+  the latest (alphabetical order) matching file will be loaded.
+  """
+  clip_actions: float | None = None
+  """The clipping range for action values. If None (default), no clipping is applied."""
+  upload_model: bool = True
+  """Whether to upload model files (.pt, .onnx) to W&B on save. Set to
+  False to keep metric logging but avoid storage usage. Default is True."""
+
+
+@dataclass
+class RslRlOnPolicyRunnerCfg(RslRlBaseRunnerCfg):
+  class_name: str = "OnPolicyRunner"
+  """The runner class name. Default is OnPolicyRunner."""
+  actor: RslRlModelCfg = field(default_factory=lambda: RslRlModelCfg(stochastic=True))
+  """The actor configuration."""
+  critic: RslRlModelCfg = field(default_factory=lambda: RslRlModelCfg(stochastic=False))
+  """The critic configuration."""
+  algorithm: RslRlPpoAlgorithmCfg = field(default_factory=RslRlPpoAlgorithmCfg)
+  """The algorithm configuration."""

mjlab/src/mjlab/rl/exporter_utils.py

@@ -0,0 +1,82 @@
+"""Shared utilities for ONNX policy export across RL tasks."""
+
+import onnx
+import torch
+
+from mjlab.entity import Entity
+from mjlab.envs import ManagerBasedRlEnv
+from mjlab.envs.mdp.actions import JointPositionAction
+
+
+def list_to_csv_str(arr, *, decimals: int = 3, delimiter: str = ",") -> str:
+  """Convert list to CSV string with specified decimal precision."""
+  fmt = f"{{:.{decimals}f}}"
+  return delimiter.join(
+    fmt.format(x)
+    if isinstance(x, (int, float))
+    else str(x)  # numbers → format, strings → as-is
+    for x in arr
+  )
+
+
+def get_base_metadata(
+  env: ManagerBasedRlEnv, run_path: str
+) -> dict[str, list | str | float]:
+  """Get base metadata common to all RL policy exports.
+
+  Args:
+    env: The RL environment.
+    run_path: W&B run path or other identifier.
+
+  Returns:
+    Dictionary of metadata fields that are common across all tasks.
+  """
+  robot: Entity = env.scene["robot"]
+  joint_action = env.action_manager.get_term("joint_pos")
+  assert isinstance(joint_action, JointPositionAction)
+  # Build mapping from joint name to actuator ID for natural joint order.
+  # Each spec actuator controls exactly one joint (via its target field).
+  joint_name_to_ctrl_id = {}
+  for actuator in robot.spec.actuators:
+    joint_name = actuator.target.split("/")[-1]
+    joint_name_to_ctrl_id[joint_name] = actuator.id
+  # Get actuator IDs in natural joint order (same order as robot.joint_names).
+  ctrl_ids_natural = [
+    joint_name_to_ctrl_id[jname]
+    for jname in robot.joint_names  # global joint order
+    if jname in joint_name_to_ctrl_id  # skip non-actuated joints
+  ]
+  joint_stiffness = env.sim.mj_model.actuator_gainprm[ctrl_ids_natural, 0]
+  joint_damping = -env.sim.mj_model.actuator_biasprm[ctrl_ids_natural, 2]
+  return {
+    "run_path": run_path,
+    "joint_names": list(robot.joint_names),
+    "joint_stiffness": joint_stiffness.tolist(),
+    "joint_damping": joint_damping.tolist(),
+    "default_joint_pos": robot.data.default_joint_pos[0].cpu().tolist(),
+    "command_names": list(env.command_manager.active_terms),
+    "observation_names": env.observation_manager.active_terms["actor"],
+    "action_scale": joint_action._scale[0].cpu().tolist()
+    if isinstance(joint_action._scale, torch.Tensor)
+    else joint_action._scale,
+  }
+
+
+def attach_metadata_to_onnx(
+  onnx_path: str, metadata: dict[str, list | str | float]
+) -> None:
+  """Attach metadata to an ONNX model file.
+
+  Args:
+    onnx_path: Path to the ONNX model file.
+    metadata: Dictionary of metadata key-value pairs to attach.
+  """
+  model = onnx.load(onnx_path)
+
+  for k, v in metadata.items():
+    entry = onnx.StringStringEntryProto()
+    entry.key = k
+    entry.value = list_to_csv_str(v) if isinstance(v, list) else str(v)
+    model.metadata_props.append(entry)
+
+  onnx.save(model, onnx_path)

mjlab/src/mjlab/rl/runner.py

@@ -0,0 +1,121 @@
+import os
+
+import torch
+from rsl_rl.env import VecEnv
+from rsl_rl.runners import OnPolicyRunner
+
+from mjlab.rl.vecenv_wrapper import RslRlVecEnvWrapper
+
+
+class MjlabOnPolicyRunner(OnPolicyRunner):
+  """Base runner that persists environment state across checkpoints."""
+
+  env: RslRlVecEnvWrapper
+
+  def __init__(
+    self,
+    env: VecEnv,
+    train_cfg: dict,
+    log_dir: str | None = None,
+    device: str = "cpu",
+  ) -> None:
+    # Strip None-valued cnn_cfg so MLPModel doesn't receive it.
+    for key in ("actor", "critic"):
+      if key in train_cfg and train_cfg[key].get("cnn_cfg") is None:
+        train_cfg[key].pop("cnn_cfg", None)
+    super().__init__(env, train_cfg, log_dir, device)
+
+  def export_policy_to_onnx(
+    self, path: str, filename: str = "policy.onnx", verbose: bool = False
+  ) -> None:
+    """Export policy to ONNX format using legacy export path.
+
+    Overrides the base implementation to set dynamo=False, avoiding warnings about
+    dynamic_axes being deprecated with the new TorchDynamo export path
+    (torch>=2.9 default).
+    """
+    onnx_model = self.alg.get_policy().as_onnx(verbose=verbose)
+    onnx_model.to("cpu")
+    onnx_model.eval()
+    os.makedirs(path, exist_ok=True)
+    torch.onnx.export(
+      onnx_model,
+      onnx_model.get_dummy_inputs(),  # type: ignore[operator]
+      os.path.join(path, filename),
+      export_params=True,
+      opset_version=18,
+      verbose=verbose,
+      input_names=onnx_model.input_names,  # type: ignore[arg-type]
+      output_names=onnx_model.output_names,  # type: ignore[arg-type]
+      dynamic_axes={},
+      dynamo=False,
+    )
+
+  def save(self, path: str, infos=None) -> None:
+    """Save checkpoint.
+
+    Extends the base implementation to persist the environment's
+    common_step_counter and to respect the ``upload_model`` config flag.
+    """
+    env_state = {"common_step_counter": self.env.unwrapped.common_step_counter}
+    infos = {**(infos or {}), "env_state": env_state}
+    # Inline base OnPolicyRunner.save() to conditionally gate W&B upload.
+    saved_dict = self.alg.save()
+    saved_dict["iter"] = self.current_learning_iteration
+    saved_dict["infos"] = infos
+    torch.save(saved_dict, path)
+    if self.cfg["upload_model"]:
+      self.logger.save_model(path, self.current_learning_iteration)
+
+  def load(
+    self,
+    path: str,
+    load_cfg: dict | None = None,
+    strict: bool = True,
+    map_location: str | None = None,
+  ) -> dict:
+    """Load checkpoint.
+
+    Extends the base implementation to:
+    1. Restore common_step_counter to preserve curricula state.
+    2. Migrate legacy checkpoints (actor.* -> mlp.*, actor_obs_normalizer.*
+      -> obs_normalizer.*) to the current format (rsl-rl>=4.0).
+    """
+    loaded_dict = torch.load(path, map_location=map_location, weights_only=False)
+
+    if "model_state_dict" in loaded_dict:
+      print(f"Detected legacy checkpoint at {path}. Migrating to new format...")
+      model_state_dict = loaded_dict.pop("model_state_dict")
+      actor_state_dict = {}
+      critic_state_dict = {}
+
+      for key, value in model_state_dict.items():
+        # Migrate actor keys.
+        if key.startswith("actor."):
+          new_key = key.replace("actor.", "mlp.")
+          actor_state_dict[new_key] = value
+        elif key.startswith("actor_obs_normalizer."):
+          new_key = key.replace("actor_obs_normalizer.", "obs_normalizer.")
+          actor_state_dict[new_key] = value
+        elif key in ["std", "log_std"]:
+          actor_state_dict[key] = value
+
+        # Migrate critic keys.
+        if key.startswith("critic."):
+          new_key = key.replace("critic.", "mlp.")
+          critic_state_dict[new_key] = value
+        elif key.startswith("critic_obs_normalizer."):
+          new_key = key.replace("critic_obs_normalizer.", "obs_normalizer.")
+          critic_state_dict[new_key] = value
+
+      loaded_dict["actor_state_dict"] = actor_state_dict
+      loaded_dict["critic_state_dict"] = critic_state_dict
+
+    load_iteration = self.alg.load(loaded_dict, load_cfg, strict)
+    if load_iteration:
+      self.current_learning_iteration = loaded_dict["iter"]
+
+    infos = loaded_dict["infos"]
+    if infos and "env_state" in infos:
+      self.env.unwrapped.common_step_counter = infos["env_state"]["common_step_counter"]
+    return infos

mjlab/src/mjlab/rl/spatial_softmax.py

@@ -0,0 +1,205 @@
+"""CNN with a spatial softmax layer."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import torch
+import torch.nn as nn
+from rsl_rl.models.cnn_model import CNNModel
+from rsl_rl.models.mlp_model import MLPModel
+from rsl_rl.modules import CNN
+from tensordict import TensorDict
+
+
+class SpatialSoftmax(nn.Module):
+  """Spatial soft-argmax over feature maps.
+
+  Given input of shape ``(B, C, H, W)``, computes a softmax over each channel's spatial
+  locations and returns the expected (x, y) coordinates, yielding output shape
+  ``(B, C * 2)``.
+
+  Args:
+    height: Height of the input feature maps.
+    width: Width of the input feature maps.
+    temperature: Temperature for the spatial softmax. Lower values produce sharper
+      distributions.
+  """
+
+  def __init__(self, height: int, width: int, temperature: float = 1.0) -> None:
+    super().__init__()
+    # Create normalised coordinate grids in [-1, 1].
+    pos_x, pos_y = torch.meshgrid(
+      torch.linspace(-1.0, 1.0, height),
+      torch.linspace(-1.0, 1.0, width),
+      indexing="ij",
+    )
+    # Register as buffers so they move with the module's device.
+    self.register_buffer("pos_x", pos_x.reshape(1, 1, -1))
+    self.register_buffer("pos_y", pos_y.reshape(1, 1, -1))
+    self.temperature = temperature
+
+  def forward(self, x: torch.Tensor) -> torch.Tensor:
+    """Compute spatial soft-argmax.
+
+    Args:
+        x: Feature maps of shape ``(B, C, H, W)``.
+
+    Returns:
+        Keypoint coordinates of shape ``(B, C * 2)``.
+    """
+    B, C, H, W = x.shape
+    # Flatten spatial dims: (B, C, H*W).
+    features = x.reshape(B, C, -1)
+    # Spatial softmax.
+    weights = torch.softmax(features / self.temperature, dim=-1)
+    # Expected coordinates.
+    pos_x: torch.Tensor = self.pos_x  # type: ignore[assignment]
+    pos_y: torch.Tensor = self.pos_y  # type: ignore[assignment]
+    expected_x = (weights * pos_x).sum(dim=-1)
+    expected_y = (weights * pos_y).sum(dim=-1)
+    # Interleave: (B, C*2).
+    return torch.stack([expected_x, expected_y], dim=-1).reshape(B, C * 2)
+
+
+class SpatialSoftmaxCNN(nn.Module):
+  """CNN encoder with spatial-softmax pooling.
+
+  Wraps ``rsl_rl.modules.CNN`` (created with ``global_pool="none"``
+  and ``flatten=False``) followed by :class:`SpatialSoftmax`. Exposes the same
+  interface as ``CNN``: :attr:`output_dim` (int) and :attr:`output_channels`
+  (``None``, signalling flattened output).
+
+  Args:
+    input_dim: ``(H, W)`` of the input images.
+    input_channels: Number of input channels.
+    temperature: Temperature for the spatial softmax.
+    **cnn_kwargs: Remaining keyword arguments forwarded to ``rsl_rl.modules.CNN``.
+  """
+
+  def __init__(
+    self,
+    input_dim: tuple[int, int],
+    input_channels: int,
+    temperature: float = 1.0,
+    **cnn_kwargs: Any,
+  ) -> None:
+    super().__init__()
+    # Override pooling/flatten — spatial softmax replaces these.
+    cnn_kwargs.pop("global_pool", None)
+    cnn_kwargs.pop("flatten", None)
+    self.cnn = CNN(
+      input_dim=input_dim,
+      input_channels=input_channels,
+      global_pool="none",
+      flatten=False,
+      **cnn_kwargs,
+    )
+    # cnn.output_dim is (H, W) when flatten=False.
+    out_h, out_w = self.cnn.output_dim  # type: ignore[misc]
+    num_channels: int = self.cnn.output_channels  # type: ignore[assignment]
+    self.spatial_softmax = SpatialSoftmax(out_h, out_w, temperature)
+    self._output_dim = num_channels * 2
+
+  @property
+  def output_dim(self) -> int:
+    """Total flattened output dimension (C * 2)."""
+    return self._output_dim
+
+  @property
+  def output_channels(self) -> None:
+    """Always ``None`` (output is flattened keypoints)."""
+    return None
+
+  def forward(self, x: torch.Tensor) -> torch.Tensor:
+    features = self.cnn(x)
+    return self.spatial_softmax(features)
+
+
+class SpatialSoftmaxCNNModel(CNNModel):
+  """CNN model that uses spatial-softmax pooling.
+
+  Drop-in replacement for ``rsl_rl.models.CNNModel``.  The only difference is that each
+  CNN encoder is wrapped with :class:`SpatialSoftmaxCNN` instead of a plain ``CNN``.
+
+  The ``spatial_softmax_temperature`` parameter is extracted from ``cnn_cfg`` before
+  the remaining keys are forwarded to ``CNN``.
+  """
+
+  def __init__(
+    self,
+    obs: TensorDict,
+    obs_groups: dict[str, list[str]],
+    obs_set: str,
+    output_dim: int,
+    cnn_cfg: dict[str, dict] | dict[str, Any],
+    cnns: nn.ModuleDict | None = None,
+    hidden_dims: tuple[int] | list[int] = [256, 256, 256],  # noqa: B006
+    activation: str = "elu",
+    obs_normalization: bool = False,
+    stochastic: bool = False,
+    init_noise_std: float = 1.0,
+    noise_std_type: str = "scalar",
+    state_dependent_std: bool = False,
+  ) -> None:
+    # Separate 1D / 2D observation groups (sets self.obs_groups_2d,
+    # obs_dims_2d, obs_channels_2d; returns 1D info for MLPModel).
+    self._get_obs_dim(obs, obs_groups, obs_set)
+
+    if cnns is not None:
+      if set(cnns.keys()) != set(self.obs_groups_2d):
+        raise ValueError(
+          "The 2D observations must be identical for all models sharing CNN encoders."
+        )
+      print(
+        "Sharing CNN encoders between models, the CNN "
+        "configurations of the receiving model are ignored."
+      )
+      _cnns = cnns
+    else:
+      # Expand a single flat config to per-group configs.
+      if not all(isinstance(v, dict) for v in cnn_cfg.values()):
+        cnn_cfg = {group: cnn_cfg for group in self.obs_groups_2d}
+      assert len(cnn_cfg) == len(self.obs_groups_2d), (
+        "The number of CNN configurations must match the "
+        "number of 2D observation groups."
+      )
+      _cnns = {}
+      for idx, obs_group in enumerate(self.obs_groups_2d):
+        group_cfg = dict(cnn_cfg[obs_group])
+        group_cfg.pop("spatial_softmax", None)
+        temperature = group_cfg.pop("spatial_softmax_temperature", 1.0)
+        _cnns[obs_group] = SpatialSoftmaxCNN(
+          input_dim=self.obs_dims_2d[idx],
+          input_channels=self.obs_channels_2d[idx],
+          temperature=temperature,
+          **group_cfg,
+        )
+
+    self.cnn_latent_dim = 0
+    for cnn in _cnns.values():
+      if cnn.output_channels is not None:
+        raise ValueError(
+          "The output of the CNN must be flattened before passing it to the MLP."
+        )
+      self.cnn_latent_dim += int(cnn.output_dim)  # type: ignore[arg-type]
+
+    MLPModel.__init__(
+      self,
+      obs,
+      obs_groups,
+      obs_set,
+      output_dim,
+      hidden_dims,
+      activation,
+      obs_normalization,
+      stochastic,
+      init_noise_std,
+      noise_std_type,
+      state_dependent_std,
+    )
+
+    if isinstance(_cnns, nn.ModuleDict):
+      self.cnns = _cnns
+    else:
+      self.cnns = nn.ModuleDict(_cnns)

mjlab/src/mjlab/rl/vecenv_wrapper.py

@@ -0,0 +1,107 @@
+import torch
+from rsl_rl.env import VecEnv
+from tensordict import TensorDict
+
+from mjlab.envs import ManagerBasedRlEnv, ManagerBasedRlEnvCfg
+from mjlab.utils.spaces import Space
+
+
+class RslRlVecEnvWrapper(VecEnv):
+  def __init__(
+    self,
+    env: ManagerBasedRlEnv,
+    clip_actions: float | None = None,
+  ):
+    self.env = env
+    self.clip_actions = clip_actions
+
+    self.num_envs = self.unwrapped.num_envs
+    self.device = torch.device(self.unwrapped.device)
+    self.max_episode_length = self.unwrapped.max_episode_length
+    self.num_actions = self.unwrapped.action_manager.total_action_dim
+    self._modify_action_space()
+
+    # Reset at the start since rsl_rl does not call reset.
+    self.env.reset()
+
+  @property
+  def cfg(self) -> ManagerBasedRlEnvCfg:
+    return self.unwrapped.cfg
+
+  @property
+  def render_mode(self) -> str | None:
+    return self.env.render_mode
+
+  @property
+  def observation_space(self) -> Space:
+    return self.env.observation_space
+
+  @property
+  def action_space(self) -> Space:
+    return self.env.action_space
+
+  @classmethod
+  def class_name(cls) -> str:
+    return cls.__name__
+
+  @property
+  def unwrapped(self) -> ManagerBasedRlEnv:
+    return self.env
+
+  # Properties.
+
+  @property
+  def episode_length_buf(self) -> torch.Tensor:
+    return self.unwrapped.episode_length_buf
+
+  @episode_length_buf.setter
+  def episode_length_buf(self, value: torch.Tensor) -> None:  # pyright: ignore[reportIncompatibleVariableOverride]
+    self.unwrapped.episode_length_buf = value
+
+  def seed(self, seed: int = -1) -> int:
+    return self.unwrapped.seed(seed)
+
+  def get_observations(self) -> TensorDict:
+    obs_dict = self.unwrapped.observation_manager.compute()
+    return TensorDict(obs_dict, batch_size=[self.num_envs])
+
+  def reset(self) -> tuple[TensorDict, dict]:
+    obs_dict, extras = self.env.reset()
+    return TensorDict(obs_dict, batch_size=[self.num_envs]), extras
+
+  def step(
+    self, actions: torch.Tensor
+  ) -> tuple[TensorDict, torch.Tensor, torch.Tensor, dict]:
+    if self.clip_actions is not None:
+      actions = torch.clamp(actions, -self.clip_actions, self.clip_actions)
+    obs_dict, rew, terminated, truncated, extras = self.env.step(actions)
+    term_or_trunc = terminated | truncated
+    assert isinstance(rew, torch.Tensor)
+    assert isinstance(term_or_trunc, torch.Tensor)
+    dones = term_or_trunc.to(dtype=torch.long)
+    if not self.cfg.is_finite_horizon:
+      extras["time_outs"] = truncated
+    return (
+      TensorDict(obs_dict, batch_size=[self.num_envs]),
+      rew,
+      dones,
+      extras,
+    )
+
+  def close(self) -> None:
+    return self.env.close()
+
+  # Private methods.
+
+  def _modify_action_space(self) -> None:
+    if self.clip_actions is None:
+      return
+
+    from mjlab.utils.spaces import Box, batch_space
+
+    self.unwrapped.single_action_space = Box(
+      shape=(self.num_actions,), low=-self.clip_actions, high=self.clip_actions
+    )
+    self.unwrapped.action_space = batch_space(
+      self.unwrapped.single_action_space, self.num_envs
+    )

mjlab/src/mjlab/scene/__init__.py

@@ -0,0 +1,2 @@
+from mjlab.scene.scene import Scene as Scene
+from mjlab.scene.scene import SceneCfg as SceneCfg

mjlab/src/mjlab/scene/scene.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable
+
+import mujoco
+import mujoco_warp as mjwarp
+import numpy as np
+import torch
+
+from mjlab.entity import Entity, EntityCfg
+from mjlab.sensor import BuiltinSensor, Sensor, SensorCfg
+from mjlab.sensor.camera_sensor import CameraSensor
+from mjlab.sensor.raycast_sensor import RayCastSensor
+from mjlab.sensor.sensor_context import SensorContext
+from mjlab.terrains.terrain_importer import TerrainImporter, TerrainImporterCfg
+
+_SCENE_XML = Path(__file__).parent / "scene.xml"
+
+
+@dataclass(kw_only=True)
+class SceneCfg:
+  num_envs: int = 1
+  env_spacing: float = 2.0
+  terrain: TerrainImporterCfg | None = None
+  entities: dict[str, EntityCfg] = field(default_factory=dict)
+  sensors: tuple[SensorCfg, ...] = field(default_factory=tuple)
+  extent: float | None = None
+  spec_fn: Callable[[mujoco.MjSpec], None] | None = None
+
+
+class Scene:
+  def __init__(self, scene_cfg: SceneCfg, device: str) -> None:
+    self._cfg = scene_cfg
+    self._device = device
+    self._entities: dict[str, Entity] = {}
+    self._sensors: dict[str, Sensor] = {}
+    self._terrain: TerrainImporter | None = None
+    self._default_env_origins: torch.Tensor | None = None
+    self._sensor_context: SensorContext | None = None
+
+    self._spec = mujoco.MjSpec.from_file(str(_SCENE_XML))
+    if self._cfg.extent is not None:
+      self._spec.stat.extent = self._cfg.extent
+    self._add_terrain()
+    self._add_entities()
+    self._add_sensors()
+    if self._cfg.spec_fn is not None:
+      self._cfg.spec_fn(self._spec)
+
+  def compile(self) -> mujoco.MjModel:
+    return self._spec.compile()
+
+  def to_zip(self, path: Path) -> None:
+    """Export the scene to a zip file.
+
+    Warning: The generated zip may require manual adjustment of asset paths
+    to be reloadable. Specifically, you may need to add assetdir="assets"
+    to the compiler directive in the XML.
+
+    Args:
+      path: Output path for the zip file.
+
+    TODO: Verify if this is fixed in future MuJoCo releases.
+    """
+    with path.open("wb") as f:
+      mujoco.MjSpec.to_zip(self._spec, f)
+
+  # Attributes.
+
+  @property
+  def spec(self) -> mujoco.MjSpec:
+    return self._spec
+
+  @property
+  def env_origins(self) -> torch.Tensor:
+    if self._terrain is not None:
+      assert self._terrain.env_origins is not None
+      return self._terrain.env_origins
+    assert self._default_env_origins is not None
+    return self._default_env_origins
+
+  @property
+  def env_spacing(self) -> float:
+    return self._cfg.env_spacing
+
+  @property
+  def entities(self) -> dict[str, Entity]:
+    return self._entities
+
+  @property
+  def sensors(self) -> dict[str, Sensor]:
+    return self._sensors
+
+  @property
+  def terrain(self) -> TerrainImporter | None:
+    return self._terrain
+
+  @property
+  def num_envs(self) -> int:
+    return self._cfg.num_envs
+
+  @property
+  def device(self) -> str:
+    return self._device
+
+  def __getitem__(self, key: str) -> Any:
+    if key == "terrain":
+      if self._terrain is None:
+        raise KeyError("No terrain configured in this scene.")
+      return self._terrain
+
+    if key in self._sensors:
+      return self._sensors[key]
+    if key in self._entities:
+      return self._entities[key]
+
+    # Not found, raise helpful error.
+    available = list(self._entities.keys()) + list(self._sensors.keys())
+    if self._terrain is not None:
+      available.append("terrain")
+    raise KeyError(f"Scene element '{key}' not found. Available: {available}")
+
+  # Methods.
+
+  @property
+  def sensor_context(self) -> SensorContext | None:
+    """Shared sensing resources, or None if no cameras/raycasts."""
+    return self._sensor_context
+
+  def initialize(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+  ):
+    self._default_env_origins = torch.zeros(
+      (self._cfg.num_envs, 3), device=self._device, dtype=torch.float32
+    )
+    for ent in self._entities.values():
+      ent.initialize(mj_model, model, data, self._device)
+    for sensor in self._sensors.values():
+      sensor.initialize(mj_model, model, data, self._device)
+
+    # Create SensorContext if any sensors require it.
+    ctx_sensors = [s for s in self._sensors.values() if s.requires_sensor_context]
+    if ctx_sensors:
+      camera_sensors = [s for s in ctx_sensors if isinstance(s, CameraSensor)]
+      raycast_sensors = [s for s in ctx_sensors if isinstance(s, RayCastSensor)]
+      self._sensor_context = SensorContext(
+        mj_model=mj_model,
+        model=model,
+        data=data,
+        camera_sensors=camera_sensors,
+        raycast_sensors=raycast_sensors,
+        device=self._device,
+      )
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    for ent in self._entities.values():
+      ent.reset(env_ids)
+    for sensor in self._sensors.values():
+      sensor.reset(env_ids)
+
+  def update(self, dt: float) -> None:
+    for ent in self._entities.values():
+      ent.update(dt)
+    for sensor in self._sensors.values():
+      sensor.update(dt)
+
+  def write_data_to_sim(self) -> None:
+    for ent in self._entities.values():
+      ent.write_data_to_sim()
+
+  # Private methods.
+
+  def _add_entities(self) -> None:
+    # Collect keyframes from each entity to merge into a single scene keyframe.
+    # Order matters: qpos/ctrl are concatenated in entity iteration order.
+    key_qpos: list[np.ndarray] = []
+    key_ctrl: list[np.ndarray] = []
+    for ent_name, ent_cfg in self._cfg.entities.items():
+      ent = ent_cfg.build()
+      self._entities[ent_name] = ent
+      # Extract keyframe before attach (must delete before attach to avoid corruption).
+      if ent.spec.keys:
+        if len(ent.spec.keys) > 1:
+          warnings.warn(
+            f"Entity '{ent_name}' has {len(ent.spec.keys)} keyframes; only the "
+            "first one will be used.",
+            stacklevel=2,
+          )
+        key_qpos.append(np.array(ent.spec.keys[0].qpos))
+        key_ctrl.append(np.array(ent.spec.keys[0].ctrl))
+        ent.spec.delete(ent.spec.keys[0])
+      frame = self._spec.worldbody.add_frame()
+      self._spec.attach(ent.spec, prefix=f"{ent_name}/", frame=frame)
+    # Add merged keyframe to scene spec.
+    if key_qpos:
+      combined_qpos = np.concatenate(key_qpos)
+      combined_ctrl = np.concatenate(key_ctrl)
+      self._spec.add_key(
+        name="init_state",
+        qpos=combined_qpos.tolist(),
+        ctrl=combined_ctrl.tolist(),
+      )
+
+  def _add_terrain(self) -> None:
+    if self._cfg.terrain is None:
+      return
+    self._cfg.terrain.num_envs = self._cfg.num_envs
+    self._cfg.terrain.env_spacing = self._cfg.env_spacing
+    self._terrain = TerrainImporter(self._cfg.terrain, self._device)
+    frame = self._spec.worldbody.add_frame()
+    self._spec.attach(self._terrain.spec, prefix="", frame=frame)
+
+  def _add_sensors(self) -> None:
+    for sensor_cfg in self._cfg.sensors:
+      sns = sensor_cfg.build()
+      sns.edit_spec(self._spec, self._entities)
+      self._sensors[sensor_cfg.name] = sns
+
+    for sns in self._spec.sensors:
+      if sns.name not in self._sensors:
+        self._sensors[sns.name] = BuiltinSensor.from_existing(sns.name)

mjlab/src/mjlab/scene/scene.xml

@@ -0,0 +1,12 @@
+<!-- Visualization defaults for mjlab scenes. Only applies when using native MuJoCo viewer. -->
+<mujoco model="mjlab scene">
+  <visual>
+    <headlight diffuse="0.6 0.6 0.6" ambient="0.3 0.3 0.3" specular="0 0 0"/>
+    <rgba force="1 0 0 1" haze="0.15 0.25 0.35 1"/>
+    <global azimuth="135" elevation="-25" offwidth="1920" offheight="1080"/>
+    <map force="0.005"/>
+    <scale forcewidth="0.25" contactwidth="0.4" contactheight="0.15" framelength="5.0" framewidth="0.3"/>
+    <quality shadowsize="8192"/>
+  </visual>
+  <statistic meansize="0.03"/>
+</mujoco>