Add files using upload-large-folder tool

.claude/plans/CLAUDE.md

@@ -0,0 +1,7 @@
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+*No recent activity*
+</claude-mem-context>

mjlab/.claude/settings.json

@@ -0,0 +1,33 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(find:*)",
+      "Bash(make check:*)",
+      "Bash(make test:*)",
+      "Bash(make docs:*)",
+      "Bash(git fetch:*)",
+      "Bash(git commit:*)",
+      "Bash(git checkout:*)",
+      "Bash(git reset:*)",
+      "Bash(gh api:*)",
+      "Bash(git ls-tree:*)"
+    ]
+  },
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "uv run ruff format"
+          }
+        ]
+      }
+    ]
+  },
+  "enabledPlugins": {
+    "code-simplifier@claude-plugins-official": true,
+    "pr-review-toolkit@claude-plugins-official": true
+  }
+}

mjlab/docs/_templates/versioning.html

@@ -0,0 +1,13 @@
+{% if versions %}
+<div class="sidebar-version-switcher">
+  <label class="sidebar-version-label" for="version-select">Version</label>
+  <select id="version-select" class="sidebar-version-select" onchange="location = this.value;">
+    {%- for item in versions.branches %}
+    <option value="{{ item.url }}" {% if item == current_version %}selected{% endif %}>{{ item.name }}</option>
+    {%- endfor %}
+    {%- for item in versions.tags|reverse %}
+    <option value="{{ item.url }}" {% if item == current_version %}selected{% endif %}>{{ item.name }}</option>
+    {%- endfor %}
+  </select>
+</div>
+{% endif %}

mjlab/docs/conf.py

@@ -0,0 +1,176 @@
+import os
+import sys
+
+import sphinx_book_theme
+
+sys.path.insert(0, os.path.abspath("../src"))
+sys.path.insert(0, os.path.abspath("../src/mjlab"))
+
+
+project = "mjlab"
+copyright = "2025, The mjlab Developers"
+author = "The mjlab Developers"
+
+extensions = [
+  "sphinx.ext.autodoc",
+  "sphinx.ext.autosummary",
+  "autodocsumm",
+  "myst_parser",
+  "sphinx.ext.napoleon",
+  "sphinxemoji.sphinxemoji",
+  "sphinx.ext.intersphinx",
+  "sphinx.ext.mathjax",
+  "sphinx.ext.todo",
+  "sphinx.ext.viewcode",
+  "sphinxcontrib.bibtex",
+  "sphinxcontrib.icon",
+  "sphinx_copybutton",
+  "sphinx_design",
+  "sphinx_tabs.tabs",
+  "sphinx_multiversion",
+]
+
+mathjax3_config = {
+  "tex": {
+    "inlineMath": [["\\(", "\\)"]],
+    "displayMath": [["\\[", "\\]"]],
+  },
+}
+
+panels_add_bootstrap_css = False
+panels_add_fontawesome_css = True
+
+source_suffix = {
+  ".rst": "restructuredtext",
+  ".md": "markdown",
+}
+
+nitpick_ignore = [
+  ("py:obj", "slice(None)"),
+]
+
+nitpick_ignore_regex = [
+  (r"py:.*", r"pxr.*"),
+  (r"py:.*", r"trimesh.*"),
+]
+
+# emoji style
+sphinxemoji_style = "twemoji"
+autodoc_typehints = "signature"
+autoclass_content = "class"
+autodoc_class_signature = "separated"
+autodoc_member_order = "bysource"
+autodoc_inherit_docstrings = True
+bibtex_bibfiles = ["source/_static/refs.bib"]
+autosummary_generate = True
+autosummary_generate_overwrite = False
+autodoc_default_options = {
+  "members": True,
+  "undoc-members": True,
+  "show-inheritance": True,
+  "member-order": "bysource",
+  "autosummary": True,
+}
+intersphinx_mapping = {
+  "python": ("https://docs.python.org/3", None),
+}
+
+exclude_patterns = [
+  "_build",
+  "_redirect",
+  "_templates",
+  "Thumbs.db",
+  ".DS_Store",
+  "README.md",
+  "licenses/*",
+]
+
+autodoc_mock_imports = [
+  "matplotlib",
+  "scipy",
+  "carb",
+  "warp",
+  "pxr",
+  "h5py",
+  "hid",
+  "prettytable",
+  "tqdm",
+  "tensordict",
+  "trimesh",
+  "toml",
+  "mujoco_warp",
+  "gymnasium",
+  "rsl_rl",
+  "viser",
+  "wandb",
+  "torchvision",
+]
+
+suppress_warnings = [
+  "ref.python",
+  "docutils",
+]
+
+language = "en"
+
+html_title = "mjlab Documentation"
+html_theme_path = [sphinx_book_theme.get_html_theme_path()]
+html_theme = "sphinx_book_theme"
+html_favicon = "source/_static/favicon.ico"
+html_show_copyright = True
+html_show_sphinx = False
+html_last_updated_fmt = ""
+
+html_static_path = ["source/_static"]
+html_css_files = ["css/custom.css"]
+
+html_theme_options = {
+  "path_to_docs": "docs/",
+  "collapse_navigation": True,
+  "repository_url": "https://github.com/mujocolab/mjlab",
+  "use_repository_button": True,
+  "use_issues_button": True,
+  "use_edit_page_button": True,
+  "show_toc_level": 2,
+  "use_sidenotes": True,
+  "logo": {
+    "text": "The mjlab Documentation",
+  },
+  "icon_links": [
+    {
+      "name": "Benchmarks",
+      "url": "https://mujocolab.github.io/mjlab/nightly/",
+      "icon": "fa-solid fa-chart-line",
+      "type": "fontawesome",
+    },
+  ],
+  "icon_links_label": "Quick Links",
+}
+
+templates_path = [
+  "_templates",
+]
+
+smv_remote_whitelist = r"^.*$"
+smv_branch_whitelist = os.getenv("SMV_BRANCH_WHITELIST", r"^(main|devel)$")
+smv_tag_whitelist = os.getenv("SMV_TAG_WHITELIST", r"^v[1-9]\d*\.\d+\.\d+$")
+
+html_sidebars = {
+  "**": [
+    "navbar-logo.html",
+    "search-field.html",
+    "versioning.html",
+    "sbt-sidebar-nav.html",
+  ]
+}
+
+
+def skip_member(app, what, name, obj, skip, options):
+  exclusions = ["from_dict", "to_dict", "replace", "copy", "validate", "__post_init__"]
+  if name in exclusions:
+    return True
+  return None
+
+
+def setup(app):
+  app.connect("autodoc-skip-member", skip_member)

mjlab/docs/index.rst

@@ -0,0 +1,90 @@
+Welcome to mjlab!
+=================
+
+.. figure:: source/_static/mjlab-banner.jpg
+   :width: 100%
+   :alt: mjlab
+
+What is mjlab?
+==============
+
+**mjlab = Isaac Lab's API + MuJoCo's simplicity + GPU acceleration**
+
+We took Isaac Lab's proven manager-based architecture and RL abstractions,
+then built them directly on MuJoCo Warp. No translation layers, no Omniverse
+overhead. Just fast, transparent physics.
+
+You can try mjlab *without installing anything* by using `uvx`:
+
+.. code-block:: bash
+
+   # Install uv if you haven't already
+   curl -LsSf https://astral.sh/uv/install.sh | sh
+
+   # Run the mjlab demo (no local installation needed)
+   uvx --from mjlab demo
+
+If this runs, your setup is compatible with mjlab *for evaluation*.
+
+License & citation
+==================
+
+mjlab is licensed under the Apache License, Version 2.0.
+Please refer to the `LICENSE file <https://github.com/mujocolab/mjlab/blob/main/LICENSE/>`_ for details.
+
+If you use mjlab in your research, we would appreciate a citation:
+
+.. code-block:: bibtex
+
+    @article{Zakka_mjlab_A_Lightweight_2026,
+        author = {Zakka, Kevin and Liao, Qiayuan and Yi, Brent and Le Lay, Louis and Sreenath, Koushil and Abbeel, Pieter},
+        title = {{mjlab: A Lightweight Framework for GPU-Accelerated Robot Learning}},
+        url = {https://arxiv.org/abs/2601.22074},
+        year = {2026}
+    }
+
+Acknowledgments
+===============
+
+mjlab would not exist without the excellent work of the Isaac Lab team, whose API design
+and abstractions mjlab builds upon.
+
+Thanks also to the MuJoCo Warp team — especially Erik Frey and Taylor Howell — for
+answering our questions, giving helpful feedback, and implementing features based
+on our requests countless times.
+
+Table of Contents
+=================
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Getting Started
+
+   source/installation
+   source/migration_isaac_lab
+
+.. toctree::
+   :maxdepth: 1
+   :caption: About the Project
+
+   source/motivation
+   source/faq
+   source/changelog
+
+.. toctree::
+   :maxdepth: 2
+   :caption: API Reference
+
+   source/api/index
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Core Concepts
+
+   source/randomization
+   source/nan_guard
+   source/observation
+   source/actuators
+   source/sensors
+   source/raycast_sensor
+   source/distributed_training

mjlab/docs/source/actuators.rst

@@ -0,0 +1,627 @@
+.. _actuators:
+
+Actuators
+=========
+
+Actuators convert high-level commands (position, velocity, effort) into
+low-level efforts that drive joints. Implementations use either
+built-in actuators (physics engine computes torques and integrates damping
+forces implicitly) or explicit actuators (user computes torques explicitly,
+integrator cannot account for their velocity derivatives).
+
+Choosing an Actuator Type
+-------------------------
+
+**Built-in actuators** (``BuiltinPositionActuator``, ``BuiltinVelocityActuator``): Use
+MuJoCo's native implementations. The physics engine computes torques and
+integrates damping forces implicitly, providing the best numerical stability.
+
+**Explicit actuators** (``IdealPdActuator``, ``DcMotorActuator``,
+``LearnedMlpActuator``): Compute torques explicitly so the simulator cannot
+account for velocity derivatives. Use when you need custom control laws or
+actuator dynamics that can't be expressed with built-in types (e.g.,
+velocity-dependent torque limits, learned actuator networks).
+
+**XML actuators** (``XmlPositionActuator``, ``XmlMotorActuator``,
+``XmlVelocityActuator``): Wrap actuators already defined in your robot's XML
+file.
+
+**Delayed actuators** (``DelayedActuator``): Generic wrapper that adds command
+delays to any actuator type. Use for modeling communication latency.
+
+TL;DR
+-----
+
+**Basic PD control:**
+
+.. code-block:: python
+
+    from mjlab.actuator import BuiltinPositionActuatorCfg
+    from mjlab.entity import EntityCfg, EntityArticulationInfoCfg
+
+    robot_cfg = EntityCfg(
+        spec_fn=lambda: load_robot_spec(),
+        articulation=EntityArticulationInfoCfg(
+            actuators=(
+                BuiltinPositionActuatorCfg(
+                    target_names_expr=(".*_hip_.*", ".*_knee_.*"),
+                    stiffness=80.0,
+                    damping=10.0,
+                    effort_limit=100.0,
+                ),
+            ),
+        ),
+    )
+
+**Add delays:**
+
+.. code-block:: python
+
+    from mjlab.actuator import DelayedActuatorCfg, BuiltinPositionActuatorCfg
+
+    DelayedActuatorCfg(
+        base_cfg=BuiltinPositionActuatorCfg(
+            target_names_expr=(".*",),
+            stiffness=80.0,
+            damping=10.0,
+        ),
+        delay_target="position",
+        delay_min_lag=2,  # Minimum 2 physics steps
+        delay_max_lag=5,  # Maximum 5 physics steps
+    )
+
+
+Actuator Interface
+------------------
+
+All actuators implement a unified ``compute()`` interface that receives an
+``ActuatorCmd`` (containing position, velocity, and effort targets) and returns
+control signals for the low-level MuJoCo actuators driving each joint. The
+abstraction provides lifecycle hooks for model modification, initialization,
+reset, and runtime updates.
+
+**Core interface:**
+
+.. code-block:: python
+
+    def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+        """Convert high-level commands to control signals.
+
+        Args:
+            cmd: Command containing position_target, velocity_target, effort_target
+                (each is a [num_envs, num_targets] tensor or None)
+
+        Returns:
+            Control signals for this actuator ([num_envs, num_targets] tensor)
+        """
+
+**Lifecycle hooks:**
+
+- ``edit_spec``: Modify MjSpec before compilation (add actuators, set gains)
+- ``initialize``: Post-compilation setup (resolve indices, allocate buffers)
+- ``reset``: Per-environment reset logic
+- ``update``: Pre-step updates
+- ``compute``: Convert commands to control signals
+
+**Properties:**
+
+- ``target_ids``: Tensor of local target indices controlled by this actuator
+- ``target_names``: List of target names controlled by this actuator
+- ``ctrl_ids``: Tensor of global control input indices for this actuator
+
+Actuator Types
+--------------
+
+Built-in Actuators
+^^^^^^^^^^^^^^^^^^
+
+Built-in actuators use MuJoCo's native actuator types via the MjSpec API. The physics
+engine computes the control law and integrates velocity-dependent damping forces
+implicitly, providing best numerical stability.
+
+**BuiltinPositionActuator**: Creates ``<position>`` actuators for PD control.
+
+**BuiltinVelocityActuator**: Creates ``<velocity>`` actuators for velocity control.
+
+**BuiltinMotorActuator**: Creates ``<motor>`` actuators for direct torque control.
+
+.. code-block:: python
+
+    from mjlab.actuator import BuiltinPositionActuatorCfg, BuiltinVelocityActuatorCfg
+
+    # Mobile manipulator: PD for arm joints, velocity control for wheels.
+    actuators = (
+        BuiltinPositionActuatorCfg(
+            target_names_expr=(".*_shoulder_.*", ".*_elbow_.*", ".*_wrist_.*"),
+            stiffness=100.0,
+            damping=10.0,
+            effort_limit=150.0,
+        ),
+        BuiltinVelocityActuatorCfg(
+            target_names_expr=(".*_wheel_.*",),
+            damping=20.0,
+            effort_limit=50.0,
+        ),
+    )
+
+
+Explicit Actuators
+^^^^^^^^^^^^^^^^^^
+
+These actuators explicitly compute efforts and forward them to an underlying <motor>
+actuator acting as a passthrough. This enables custom control laws and actuator
+dynamics that can't be expressed with built-in types.
+
+.. important::
+
+     Explicit actuators may be less numerically stable
+     than built-in actuators because the integrator cannot account for the
+     velocity derivatives of the control forces, especially with high damping
+     gains.
+
+**IdealPdActuator**: Base class that implements an ideal PD controller.
+
+**DcMotorActuator**: Example of a more realistic actuator model built on top
+of ``IdealPdActuator``. Adds velocity-dependent torque saturation to model DC
+motor torque-speed curves (back-EMF effects). It implements a linear
+torque-speed curve: maximum torque at zero velocity, zero torque at maximum
+velocity.
+
+.. code-block:: python
+
+    from mjlab.actuator import IdealPdActuatorCfg, DcMotorActuatorCfg
+
+    # Ideal PD for hips, DC motor model with torque-speed curve for knees.
+    actuators = (
+        IdealPdActuatorCfg(
+            target_names_expr=(".*_hip_.*",),
+            stiffness=80.0,
+            damping=10.0,
+            effort_limit=100.0,
+        ),
+        DcMotorActuatorCfg(
+            target_names_expr=(".*_knee_.*",),
+            stiffness=80.0,
+            damping=10.0,
+            effort_limit=25.0,       # Continuous torque limit
+            saturation_effort=50.0,  # Peak torque at stall
+            velocity_limit=30.0,     # No-load speed (rad/s)
+        ),
+    )
+
+
+**DcMotorActuator parameters:**
+
+- ``saturation_effort``: Peak motor torque at zero velocity (stall torque)
+- ``velocity_limit``: Maximum motor velocity (no-load speed, *rad/s*)
+- ``effort_limit``: Continuous torque limit (from base class)
+
+**LearnedMlpActuator**: Neural network-based actuator that uses a trained MLP
+to predict torque outputs from joint state history. Useful when analytical
+models can't capture complex actuator dynamics like delays, nonlinearities, and
+friction effects. Inherits DC motor velocity-based torque limits.
+
+.. code-block:: python
+
+    from mjlab.actuator import LearnedMlpActuatorCfg
+
+    actuators = (
+        LearnedMlpActuatorCfg(
+            target_names_expr=(".*_ankle_.*",),
+            network_file="models/ankle_actuator.pt",  # TorchScript model
+            pos_scale=1.0,        # Input scaling for position errors
+            vel_scale=0.05,       # Input scaling for velocities
+            torque_scale=10.0,    # Output scaling for torques
+            input_order="pos_vel",
+            history_length=3,     # Use current + 2 previous timesteps
+            saturation_effort=50.0,
+            velocity_limit=30.0,
+            effort_limit=25.0,
+        ),
+    )
+
+**LearnedMlpActuator parameters:**
+
+- ``network_file``: Path to TorchScript MLP model (``.pt`` file)
+- ``pos_scale``: Scaling factor for position error inputs
+- ``vel_scale``: Scaling factor for velocity inputs
+- ``torque_scale``: Scaling factor for network torque outputs
+- ``input_order``: ``pos_vel`` (position then velocity) or ``vel_pos``
+- ``history_length``: Number of timesteps to use (e.g., 3 = current + 2 past)
+- ``saturation_effort``, ``velocity_limit``, ``effort_limit``: Same as
+  DcMotorActuator
+
+The network receives scaled inputs
+``[pos_error[t], pos_error[t-1], ..., vel[t], vel[t-1], ...]`` and outputs torques
+that are scaled and clipped by DC motor limits.
+
+XML Actuators
+^^^^^^^^^^^^^
+
+XML actuators wrap actuators already defined in your robot's XML file. The
+config finds existing actuators by matching their ``target`` joint name against
+the ``target_names_expr`` patterns. Each joint must have exactly one matching
+actuator.
+
+**XmlPositionActuator**: Wraps existing ``<position>`` actuators
+
+**XmlVelocityActuator**: Wraps existing ``<velocity>`` actuators
+
+**XmlMotorActuator**: Wraps existing ``<motor>`` actuators
+
+.. code-block:: python
+
+    from mjlab.actuator import XmlPositionActuatorCfg
+
+    # Robot XML already has:
+    # <actuator>
+    #   <position name="hip_joint" joint="hip_joint" kp="100"/>
+    # </actuator>
+
+    # Wrap existing XML actuators.
+    actuators = (
+        XmlPositionActuatorCfg(target_names_expr=("hip_joint",)),
+    )
+
+Delayed Actuator
+^^^^^^^^^^^^^^^^
+
+Generic wrapper that adds command delays to any actuator. Useful for modeling
+actuator latency and communication delays. The delay operates on command
+targets before they reach the actuator's control law.
+
+.. code-block:: python
+
+    from mjlab.actuator import DelayedActuatorCfg, IdealPdActuatorCfg
+
+    # Add 2-5 step delay to position commands.
+    actuators = (
+        DelayedActuatorCfg(
+            base_cfg=IdealPdActuatorCfg(
+                target_names_expr=(".*",),
+                stiffness=80.0,
+                damping=10.0,
+            ),
+            delay_target="position",     # Delay position commands
+            delay_min_lag=2,
+            delay_max_lag=5,
+            delay_hold_prob=0.3,         # 30% chance to keep previous lag
+            delay_update_period=10,      # Update lag every 10 steps
+        ),
+    )
+
+
+**Multi-target delays:**
+
+.. code-block:: python
+
+    DelayedActuatorCfg(
+        base_cfg=IdealPdActuatorCfg(...),
+        delay_target=("position", "velocity", "effort"),
+        delay_min_lag=2,
+        delay_max_lag=5,
+    )
+
+Delays are quantized to physics timesteps. For example, with 500Hz physics
+(2ms/step), ``delay_min_lag=2`` represents a 4ms minimum delay.
+
+.. note::
+
+     Each target gets an independent delay buffer with its own lag
+     schedule. This provides maximum flexibility for modeling different latency
+     characteristics for position, velocity, and effort commands.
+
+PD Control and Integrator Choice
+--------------------------------
+
+The distinction between **built-in** and **explicit** PD control only makes sense
+in the context of how MuJoCo integrates velocity-dependent forces. This section
+explains how each actuator style interacts with the integrator, and why
+mjlab uses ``<implicitfast>`` **by default**.
+
+Built-in vs Explicit PD Control
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+**BuiltinPositionActuator** uses MuJoCo's internal PD implementation:
+
+- Creates ``<position>`` actuators in the MjSpec
+- Physics engine computes the PD law and integrates velocity-dependent damping
+  forces implicitly
+
+**IdealPdActuator** implements PD control explicitly:
+
+- Creates ``<motor>`` actuators in the MjSpec
+- Computes torques explicitly: ``τ = Kp·pos_error + Kd·vel_error``
+- The integrator cannot account for the velocity derivatives of these forces
+
+They match closely in the linear, unconstrained regime and small time steps.
+However, built-in PD is more numerically robust and as such can be used with
+larger gains and larger timesteps.
+
+Integrator Behavior in MuJoCo
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The choice of integrator in MuJoCo strongly affects stability for
+velocity-dependent forces:
+
+- ``euler`` is semi-implicit but treats joint damping implicitly. Other
+  forces, including explicit actuator damping, are integrated explicitly.
+- ``implicitfast`` treats *all known velocity-dependent forces implicitly*,
+  stabilizing systems with large damping or stiff actuation.
+
+mjlab Recommendation
+^^^^^^^^^^^^^^^^^^^^
+
+mjlab actuators apply damping inside the actuator (not in joints). Because of
+this, **Euler** cannot integrate the damping implicitly, making it less stable.
+The ``implicitfast`` integrator, however, handles both proportional and
+damping terms of the actuator implicitly, improving stability without
+additional cost.
+
+.. note::
+
+     mjlab defaults to ``<implicitfast>``, as it is MuJoCo's recommended
+     integrator and provides superior stability for actuator-side damping.
+
+Authoring Actuator Configs
+--------------------------
+
+Since actuator parameters are uniform within each config, use separate actuator
+configs for joints that need different parameters:
+
+.. code-block:: python
+
+    from mjlab.actuator import BuiltinPositionActuatorCfg
+
+    # G1 humanoid with different gains per joint group.
+    G1_ACTUATORS = (
+        BuiltinPositionActuatorCfg(
+            target_names_expr=(".*_hip_.*", "waist_yaw_joint"),
+            stiffness=180.0,
+            damping=18.0,
+            effort_limit=88.0,
+            armature=0.0015,
+        ),
+        BuiltinPositionActuatorCfg(
+            target_names_expr=("left_hip_pitch_joint", "right_hip_pitch_joint"),
+            stiffness=200.0,
+            damping=20.0,
+            effort_limit=88.0,
+            armature=0.0015,
+        ),
+        BuiltinPositionActuatorCfg(
+            target_names_expr=(".*_knee_joint",),
+            stiffness=150.0,
+            damping=15.0,
+            effort_limit=139.0,
+            armature=0.0025,
+        ),
+        BuiltinPositionActuatorCfg(
+            target_names_expr=(".*_ankle_.*",),
+            stiffness=40.0,
+            damping=5.0,
+            effort_limit=25.0,
+            armature=0.0008,
+        ),
+    )
+
+This design choice reflects a deliberate simplification in mjlab: each
+``ActuatorCfg`` represents a single actuator type (e.g., a specific motor/gearbox
+model) applied uniformly across all joints it drives. Hardware parameters such
+as ``armature`` (reflected rotor inertia) and ``gear`` describe properties of the
+actuator hardware, even though they are implemented in MuJoCo as joint or
+actuator fields. In other frameworks (like Isaac Lab), these fields may accept
+``float | dict[str, float]`` to support per-joint variation. mjlab instead
+encourages one config per actuator type or per joint group, keeping the hardware
+model physically consistent and explicit. The main trade-off is verbosity in
+special cases, such as parallel linkages, where per-joint overrides could have
+been convenient, but the benefit is clearer semantics and simpler maintenance.
+
+Computing Hardware Parameters from Motor Specs
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+mjlab provides utilities in ``mjlab.utils.actuator`` to compute actuator
+parameters from physical motor specifications. This is particularly useful for
+computing reflected inertia (``armature``) and deriving appropriate control gains
+from hardware datasheets.
+
+**Example: Unitree G1 motor configuration**
+
+.. code-block:: python
+
+    from math import pi
+
+    from mjlab.utils.actuator import (
+        reflected_inertia_from_two_stage_planetary,
+        ElectricActuator
+    )
+
+    # Motor specs from manufacturer datasheet.
+    ROTOR_INERTIAS_7520_14 = (
+        0.489e-4,  # Motor rotor inertia (kg·m**2)
+        0.098e-4,  # Planet carrier inertia
+        0.533e-4,  # Output stage inertia
+    )
+    GEARS_7520_14 = (
+        1,            # First stage (motor to planet)
+        4.5,          # Second stage (planet to carrier)
+        1 + (48/22),  # Third stage (carrier to output)
+    )
+
+    # Compute reflected inertia at joint output.
+    # J_reflected = J_motor*(N₁*N₂)**2 + J_carrier*N₂**2 + J_output.
+    ARMATURE_7520_14 = reflected_inertia_from_two_stage_planetary(
+        ROTOR_INERTIAS_7520_14, GEARS_7520_14
+    )
+
+    # Create motor spec container.
+    ACTUATOR_7520_14 = ElectricActuator(
+        reflected_inertia=ARMATURE_7520_14,
+        velocity_limit=32.0,   # rad/s at joint
+        effort_limit=88.0,     # N·m continuous torque
+    )
+
+    # Derive PD gains from natural frequency and damping ratio.
+    NATURAL_FREQ = 10 * 2*pi  # 10 Hz bandwidth.
+    DAMPING_RATIO = 2.0       # Overdamped, see note below.
+    STIFFNESS = ARMATURE_7520_14 * NATURAL_FREQ**2
+    DAMPING = 2 * DAMPING_RATIO * ARMATURE_7520_14 * NATURAL_FREQ
+
+    # Use in actuator config.
+    from mjlab.actuator import BuiltinPositionActuatorCfg
+
+    actuator = BuiltinPositionActuatorCfg(
+        target_names_expr=(".*_hip_pitch_joint",),
+        stiffness=STIFFNESS,
+        damping=DAMPING,
+        effort_limit=ACTUATOR_7520_14.effort_limit,
+        armature=ACTUATOR_7520_14.reflected_inertia,
+    )
+
+.. note::
+
+     The example uses `DAMPING_RATIO = 2.0`
+     (overdamped) rather than the critically damped value of 1.0. This is because
+     the reflected inertia calculation only accounts for the motor's rotor inertia,
+     not the apparent inertia of the links being moved. In practice, the total
+     effective inertia at the joint is higher than just the reflected motor inertia,
+     so using an overdamped ratio provides better stability margins when the true
+     system inertia is underestimated.
+
+**Parallel linkage approximation:**
+
+For joints driven by parallel linkages (like the G1's ankles with dual motors),
+the effective armature in the nominal configuration can be approximated as the
+sum of the individual motor armatures:
+
+.. code-block:: python
+
+    # Two 5020 motors driving ankle through parallel linkage.
+    G1_ACTUATOR_ANKLE = BuiltinPositionActuatorCfg(
+        target_names_expr=(".*_ankle_pitch_joint", ".*_ankle_roll_joint"),
+        stiffness=STIFFNESS_5020 * 2,
+        damping=DAMPING_5020 * 2,
+        effort_limit=ACTUATOR_5020.effort_limit * 2,
+        armature=ACTUATOR_5020.reflected_inertia * 2,
+    )
+
+
+Using Actuators in Environments
+-------------------------------
+
+Action Terms
+^^^^^^^^^^^^
+
+Actuators are typically controlled via action terms in the action manager:
+
+.. code-block:: python
+
+    from mjlab.envs.mdp.actions import JointPositionActionCfg
+
+    JointPositionActionCfg(
+        entity_name="robot",
+        actuator_names=(".*",),  # Regex patterns for joint selection
+        scale=1.0,
+        use_default_offset=True,  # Use robot's default joint positions as offset
+    )
+
+**Available action terms:**
+
+- ``JointPositionAction``: Sets position targets (for PD actuators)
+- ``JointVelocityAction``: Sets velocity targets (for velocity actuators)
+- ``JointEffortAction``: Sets effort/torque targets (for torque actuators)
+- ``DifferentialIKAction``: Task-space control via damped least-squares IK
+
+The action manager calls ``entity.set_joint_position_target()``,
+``set_joint_velocity_target()``, or ``set_joint_effort_target()`` under the hood,
+which populate the ``ActuatorCmd`` passed to each actuator's ``compute()`` method.
+
+Differential IK Action
+""""""""""""""""""""""
+
+``DifferentialIKAction`` converts task-space commands (Cartesian position
+and/or orientation) into joint-space targets via damped least-squares (DLS)
+inverse kinematics. It runs one IK step per decimation substep via
+``apply_actions()``, or can be iterated externally via ``compute_dq()``.
+
+The action dimension is determined automatically by the active objectives:
+
+- ``orientation_weight == 0`` → **3D** (position only)
+- ``orientation_weight > 0, use_relative_mode=True`` → **6D** (delta pos +
+  delta axis-angle)
+- ``orientation_weight > 0, use_relative_mode=False`` → **7D** (absolute
+  pos + quaternion)
+
+.. code-block:: python
+
+    from mjlab.envs.mdp.actions import DifferentialIKActionCfg
+
+    DifferentialIKActionCfg(
+        entity_name="robot",
+        actuator_names=("joint.*",),   # Regex for controlled joints
+        frame_name="grasp_site",       # End-effector element name
+        frame_type="site",             # "body", "site", or "geom"
+        use_relative_mode=False,       # Absolute target mode
+        damping=0.05,                  # DLS damping (lambda)
+        max_dq=0.5,                    # Per-step joint displacement limit
+        position_weight=1.0,           # Position tracking weight
+        orientation_weight=1.0,        # Orientation tracking weight
+        joint_limit_weight=0.1,        # Soft joint-limit avoidance
+        posture_weight=0.0,            # Null-space posture regularization
+        posture_target={".*": 0.0},    # Posture target (regex → value)
+    )
+
+**Standalone usage (outside RL):**
+
+The ``compute_dq()`` method returns joint displacements without writing to
+actuator targets, enabling multi-iteration IK in standalone scripts:
+
+.. code-block:: python
+
+    from mjlab.envs.mdp.actions import DifferentialIKAction
+
+    action: DifferentialIKAction = cfg.build(env)
+    action.process_actions(target_pose)
+    for _ in range(20):  # Multiple IK iterations
+        dq = action.compute_dq()
+        q = entity.data.joint_pos[:, action._joint_ids] + dq
+        entity.write_joint_position_to_sim(q, joint_ids=action._joint_ids)
+        sim.forward()
+
+**Weighted objectives:**
+
+All objectives (position, orientation, joint limits, posture) are stacked
+into a single DLS system. Setting a weight to zero disables that objective
+with no overhead in the solve. Weights can be changed at runtime (e.g. from
+GUI sliders in the ``scripts/demos/ik_control.py`` demo).
+
+Domain Randomization
+^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    from mjlab.envs.mdp import events
+    from mjlab.managers.event_manager import EventTermCfg
+    from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+    EventTermCfg(
+        func=events.randomize_pd_gains,
+        mode="reset",
+        params={
+            "entity_cfg": SceneEntityCfg("robot", actuator_names=(".*",)),
+            "kp_range": (0.8, 1.2),
+            "kd_range": (0.8, 1.2),
+            "distribution": "uniform",
+            "operation": "scale",  # or "abs" for absolute values
+        },
+    )
+
+    EventTermCfg(
+        func=events.randomize_effort_limits,
+        mode="reset",
+        params={
+            "entity_cfg": SceneEntityCfg("robot", actuator_names=(".*_leg_.*",)),
+            "effort_limit_range": (0.7, 1.0),  # Reduce effort by 0-30%
+            "operation": "scale",
+        },
+    )

mjlab/docs/source/changelog.rst

@@ -0,0 +1,116 @@
+=========
+Changelog
+=========
+
+Upcoming version (not yet released)
+-----------------------------------
+
+Added
+^^^^^
+
+- Added ``upload_model`` option to ``RslRlBaseRunnerCfg`` to control W&B model
+  file uploads (``.pt`` and ``.onnx``) while keeping metric logging enabled
+  (:gh:`654`).
+
+Changed
+^^^^^^^
+
+- Replaced the single ``scale`` parameter in ``DifferentialIKActionCfg`` with
+  separate ``delta_pos_scale`` and ``delta_ori_scale`` for independent scaling
+  of position and orientation components.
+
+Fixed
+^^^^^
+
+- Bundled ``ffmpeg`` for ``mediapy`` via ``imageio-ffmpeg``, removing the
+  requirement for a system ``ffmpeg`` install. Thanks to
+  `@rdeits-bd <https://github.com/rdeits-bd>`_ for the suggestion.
+- Fixed ``height_scan`` returning ~0 for missed rays; now defaults to
+  ``max_distance``. Replaced ``clip=(-1, 1)`` with ``scale`` normalization
+  in the velocity task config. Thanks to `@eufrizz <https://github.com/eufrizz>`_
+  for reporting and the initial fix (`#642 <https://github.com/mujocolab/mjlab/pull/642>`_).
+- Fixed ghost mesh visualization for fixed-base entities by extending
+  ``DebugVisualizer.add_ghost_mesh`` to optionally accept ``mocap_pos`` and
+  ``mocap_quat`` (`#645 <https://github.com/mujocolab/mjlab/pull/645>`_).
+
+Version 1.1.1 (February 14, 2026)
+---------------------------------
+
+Added
+^^^^^
+
+- Added reward term visualization to the native viewer (toggle with ``P``) (`#629 <https://github.com/mujocolab/mjlab/pull/629>`_).
+- Added ``DifferentialIKAction`` for task-space control via damped
+  least-squares IK. Supports weighted position/orientation tracking,
+  soft joint-limit avoidance, and null-space posture regularization.
+  Includes an interactive viser demo (``scripts/demos/differential_ik.py``) (`#632 <https://github.com/mujocolab/mjlab/pull/632>`_).
+
+Fixed
+^^^^^
+
+- Fixed ``play.py`` defaulting to the base rsl-rl ``OnPolicyRunner`` instead
+  of ``MjlabOnPolicyRunner``, which caused a ``TypeError`` from an unexpected
+  ``cnn_cfg`` keyword argument (`#626 <https://github.com/mujocolab/mjlab/pull/626>`_). Contribution by
+  `@griffinaddison <https://github.com/griffinaddison>`_.
+
+Changed
+^^^^^^^
+
+- Removed ``body_mass``, ``body_inertia``, ``body_pos``, and ``body_quat``
+  from ``FIELD_SPECS`` in domain randomization. These fields have derived
+  quantities that require ``set_const`` to recompute; without that call,
+  randomizing them silently breaks physics (`#631 <https://github.com/mujocolab/mjlab/pull/631>`_).
+- Replaced ``moviepy`` with ``mediapy`` for video recording. ``mediapy``
+  handles cloud storage paths (GCS, S3) natively (`#637 <https://github.com/mujocolab/mjlab/pull/637>`_).
+
+.. figure:: _static/changelog/native_reward.png
+   :width: 80%
+
+Version 1.1.0 (February 12, 2026)
+---------------------------------
+
+Added
+^^^^^
+
+- Added RGB and depth camera sensors and BVH-accelerated raycasting (`#597 <https://github.com/mujocolab/mjlab/pull/597>`_).
+- Added ``MetricsManager`` for logging custom metrics during training (`#596 <https://github.com/mujocolab/mjlab/pull/596>`_).
+- Added terrain visualizer (`#609 <https://github.com/mujocolab/mjlab/pull/609>`_). Contribution by
+  `@mktk1117 <https://github.com/mktk1117>`_.
+
+.. figure:: _static/changelog/terrain_visualizer.jpg
+   :width: 80%
+
+- Added many new terrains including ``HfDiscreteObstaclesTerrainCfg``,
+  ``HfPerlinNoiseTerrainCfg``, ``BoxSteppingStonesTerrainCfg``,
+  ``BoxNarrowBeamsTerrainCfg``, ``BoxRandomStairsTerrainCfg``, and
+  more. Added flat patch sampling for heightfield terrains (`#542 <https://github.com/mujocolab/mjlab/pull/542>`_, `#581 <https://github.com/mujocolab/mjlab/pull/581>`_).
+- Added site group visualization to the Viser viewer (Geoms and Sites
+  tabs unified into a single Groups tab) (`#551 <https://github.com/mujocolab/mjlab/pull/551>`_).
+- Added ``env_ids`` parameter to ``Entity.write_ctrl_to_sim`` (`#567 <https://github.com/mujocolab/mjlab/pull/567>`_).
+
+Changed
+^^^^^^^
+
+- Upgraded ``rsl-rl-lib`` to 4.0.0 and replaced the custom ONNX
+  exporter with rsl-rl's built-in ``as_onnx()`` (`#589 <https://github.com/mujocolab/mjlab/pull/589>`_, `#595 <https://github.com/mujocolab/mjlab/pull/595>`_).
+- ``sim.forward()`` is now called unconditionally after the decimation
+  loop. See :ref:`faq-sim-forward` for details (`#591 <https://github.com/mujocolab/mjlab/pull/591>`_).
+- Unnamed freejoints are now automatically named to prevent
+  ``KeyError`` during entity init (`#545 <https://github.com/mujocolab/mjlab/pull/545>`_).
+
+Fixed
+^^^^^
+
+- Fixed ``randomize_pd_gains`` crash with ``num_envs > 1`` (`#564 <https://github.com/mujocolab/mjlab/pull/564>`_).
+- Fixed ``ctrl_ids`` index error with multiple actuated entities (`#573 <https://github.com/mujocolab/mjlab/pull/573>`_).
+  Reported by `@bwrooney82 <https://github.com/bwrooney82>`_.
+- Fixed Viser viewer rendering textured robots as gray (`#544 <https://github.com/mujocolab/mjlab/pull/544>`_).
+- Fixed Viser plane rendering ignoring MuJoCo size parameter (`#540 <https://github.com/mujocolab/mjlab/pull/540>`_).
+- Fixed ``HfDiscreteObstaclesTerrainCfg`` spawn height (`#552 <https://github.com/mujocolab/mjlab/pull/552>`_).
+- Fixed ``RaycastSensor`` visualization ignoring the all-envs toggle (`#607 <https://github.com/mujocolab/mjlab/pull/607>`_).
+  Contribution by `@oxkitsune <https://github.com/oxkitsune>`_.
+
+Version 1.0.0 (January 28, 2026)
+--------------------------------
+
+Initial release of mjlab.

mjlab/docs/source/distributed_training.rst

@@ -0,0 +1,118 @@
+.. _distributed-training:
+
+Distributed Training
+====================
+
+mjlab supports multi-GPU distributed training using
+`torchrunx <https://github.com/apoorvkh/torchrunx>`_. Distributed training
+parallelizes RL workloads across multiple GPUs by running independent rollouts
+on each device and synchronizing gradients during policy updates. Throughput
+scales nearly linearly with GPU count.
+
+TL;DR
+-----
+
+**Single GPU (default):**
+
+.. code-block:: bash
+
+    uv run train <task-name> <task-specific CLI args>
+    # or explicitly: --gpu-ids 0
+
+
+**Multi-GPU:**
+
+.. code-block:: bash
+
+    uv run train <task-name> \
+        --gpu-ids 0 1 \
+        <task-specific CLI args>
+
+
+**All GPUs:**
+
+.. code-block:: bash
+
+    uv run train <task-name> \
+        --gpu-ids all \
+        <task-specific CLI args>
+
+
+**CPU mode:**
+
+.. code-block:: bash
+
+    uv run train <task-name> \
+        --gpu-ids None \
+        <task-specific CLI args>
+    # or: CUDA_VISIBLE_DEVICES="" uv run train <task-name> ...
+
+
+**Key points:**
+
+- ``--gpu-ids`` specifies GPU indices (e.g., ``--gpu-ids 0 1`` for 2 GPUs)
+- GPU indices are relative to ``CUDA_VISIBLE_DEVICES`` if set
+- ``CUDA_VISIBLE_DEVICES=2,3 uv run train ... --gpu-ids 0 1`` uses physical GPUs 2 and 3
+- Each GPU runs the full ``num-envs`` count (e.g., 2 GPUs × 4096 envs = 8192 total)
+- Single-GPU and CPU modes run directly; multi-GPU uses ``torchrunx`` for process
+  spawning
+
+Configuration
+-------------
+
+**torchrunx Logging:**
+
+By default, torchrunx process logs are saved to ``{log_dir}/torchrunx/``. You can
+customize this:
+
+.. code-block:: bash
+
+    # Disable torchrunx file logging.
+    uv run train <task-name> --gpu-ids 0 1 --torchrunx-log-dir ""
+
+    # Custom log directory.
+    uv run train <task-name> --gpu-ids 0 1 --torchrunx-log-dir /path/to/logs
+
+    # Or use environment variable (takes precedence over flag).
+    TORCHRUNX_LOG_DIR=/tmp/logs uv run train <task-name> --gpu-ids 0 1
+
+
+The priority is ``TORCHRUNX_LOG_DIR`` env var, ``--torchrunx-log-dir`` flag, default
+``{log_dir}/torchrunx``.
+
+**Single-Writer Operations:**
+
+Only rank 0 performs file I/O operations (config files, videos, wandb logging)
+to avoid race conditions. All workers participate in training, but logging
+artifacts are written once by the main process.
+
+How It Works
+------------
+
+mjlab's role is simple: **isolate mjwarp simulations on each GPU** using
+``wp.ScopedDevice``. This ensures each process's environments stay on their
+assigned device. ``torchrunx`` handles the rest.
+
+**Process spawning.** Multi-GPU training uses ``torchrunx.Launcher(...).run(...)``
+to spawn N independent processes (one per GPU) and sets environment variables
+(``RANK``, ``LOCAL_RANK``, ``WORLD_SIZE``) to coordinate them. Each process executes
+the training function with its assigned GPU.
+
+**Independent rollouts.** Each process maintains its own:
+
+- Environment instances (with ``num-envs`` parallel environments), isolated on
+  its assigned GPU via ``wp.ScopedDevice``
+- Policy network copy
+- Experience buffer (sized ``num_steps_per_env × num-envs``)
+
+Each process uses ``seed = cfg.seed + local_rank`` to ensure different random
+experiences across GPUs, increasing sample diversity.
+
+**Gradient synchronization.** During the update phase, ``rsl_rl`` synchronizes
+gradients after each mini-batch through its ``reduce_parameters()`` method:
+
+1. Each process computes gradients independently on its local mini-batch
+2. All policy gradients are flattened into a single tensor
+3. ``torch.distributed.all_reduce`` averages gradients across all GPUs
+4. Averaged gradients are copied back to each parameter, keeping policies
+   synchronized

mjlab/docs/source/faq.rst

@@ -0,0 +1,458 @@
+.. _faq:
+
+FAQ & Troubleshooting
+=====================
+
+This page collects common questions about **platform support**, **performance**,
+**training stability**, and **visualization**, along with practical debugging
+tips and links to further resources.
+
+Platform Support
+----------------
+
+Does it work on macOS?
+~~~~~~~~~~~~~~~~~~~~~~
+
+Yes, but only with limited performance. mjlab runs on macOS
+using **CPU-only** execution through MuJoCo Warp.
+
+- **Training is not recommended on macOS**, as it lacks GPU acceleration.
+- **Evaluation works**, but is significantly slower than on Linux with CUDA.
+
+For serious training workloads, we strongly recommend **Linux with an NVIDIA GPU**.
+
+Does it work on Windows?
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+We have performed preliminary testing on **Windows** and **WSL**, but some
+workflows are not guaranteed to be stable.
+
+- Windows support may **lag behind** Linux.
+- Windows will be **tested less frequently**, since Linux is the primary
+  development and deployment platform.
+- Community contributions that improve Windows support are very welcome.
+
+CUDA Compatibility
+~~~~~~~~~~~~~~~~~~
+
+Not all CUDA versions are supported by MuJoCo Warp.
+
+- See `mujoco_warp#101 <https://github.com/google-deepmind/mujoco_warp/issues/101>`_
+  for details on CUDA compatibility.
+- **Recommended**: CUDA **12.4+** (for conditional execution support in CUDA
+  graphs).
+
+Performance
+-----------
+
+Is it faster than Isaac Lab?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Based on our experience over the last few months, mjlab is **on par or
+faster** than Isaac Lab.
+
+What GPU do you recommend?
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- **RTX 40-series GPUs** (or newer)
+- **L40s, H100**
+
+Does mjlab support multi-GPU training?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Yes, mjlab supports **multi-GPU distributed training** using
+`torchrunx <https://github.com/apoorvkh/torchrunx>`_.
+
+- Use ``--gpu-ids 0 1`` (or ``--gpu-ids all``) when running the ``train``
+  command.
+- See the :doc:`distributed_training` for configuration details and examples.
+
+Training & Debugging
+--------------------
+
+My training crashes with NaN errors
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A typical error when using ``rsl_rl`` looks like:
+
+.. code-block:: bash
+
+   RuntimeError: normal expects all elements of std >= 0.0
+
+This occurs when NaN/Inf values in the **physics state** propagate to the
+policy network, causing its output standard deviation to become negative or NaN.
+
+There are many possible causes, including potential bugs in **MuJoCo Warp**
+(which is still in beta). mjlab offers two complementary mechanisms to help
+you handle this:
+
+1. **For training stability** - NaN termination
+
+Add a ``nan_detection`` termination to reset environments that hit NaN:
+
+.. code-block:: python
+
+   from dataclasses import dataclass, field
+
+   from mjlab.envs.mdp.terminations import nan_detection
+   from mjlab.managers.termination_manager import TerminationTermCfg
+
+   @dataclass
+   class TerminationCfg:
+      # Your other terminations...
+      nan_term: TerminationTermCfg = field(
+         default_factory=lambda: TerminationTermCfg(
+               func=nan_detection,
+               time_out=False,
+         )
+      )
+
+This marks NaN environments as terminated so they can reset while training
+continues. Terminations are logged as
+``Episode_Termination/nan_term`` in your metrics.
+
+.. warning::
+
+   This is a **band-aid solution**. If NaNs correlate with your task objective
+   (for example, NaNs occur exactly when the agent tries to grasp an object),
+   the policy will never learn to complete that part of the task. Always
+   investigate the **root cause** using ``nan_guard`` in addition to this
+   termination.
+
+2. **For debugging** - NaN guard
+
+Enable ``nan_guard`` to capture the simulation state when NaNs occur:
+
+.. code-block:: bash
+
+   uv run train.py --enable-nan-guard True
+
+See the :doc:`NaN Guard documentation <nan_guard>` for details.
+
+The ``nan_guard`` tool makes it easier to:
+
+- Inspect the simulation state at the moment NaNs appear.
+- Build a minimal reproducible example (MRE).
+- Report potential framework bugs to the
+  `MuJoCo Warp team <https://github.com/google-deepmind/mujoco_warp/issues>`_.
+
+Reporting well-isolated issues helps improve the framework for everyone.
+
+.. _faq-sim-forward:
+
+When do I need to call ``sim.forward()``?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Short answer: you almost certainly don't.
+
+``sim.forward()`` wraps MuJoCo's ``mj_forward``, which runs the full forward
+dynamics pipeline (kinematics, contacts, forces, constraint solving, sensors)
+but skips integration, leaving ``qpos``/``qvel`` unchanged. It brings all
+derived quantities in ``mjData`` (``xpos``, ``xquat``, ``site_xpos``,
+``cvel``, ``sensordata``, etc.) into a consistent state with the current
+``qpos``/``qvel``.
+The environment's ``step()`` method calls it once per step, right before
+observation computation, so observations, commands, and interval events
+always see fresh derived quantities. Termination and reward managers run
+*before* this call and therefore see derived quantities that are stale by
+one physics substep, a deliberate tradeoff that avoids a second
+``forward()`` call while keeping the MDP well-defined (the staleness is
+consistent across all envs and all steps).
+
+The one case where this matters is if you write an event or command that
+both writes state and reads derived quantities in the same function. For
+example, if Event A calls ``entity.write_root_velocity_to_sim()`` (which
+modifies ``qvel``) and then immediately reads ``entity.data.root_link_vel_w``
+(which comes from ``cvel``), the read will see stale values from before the
+write.
+
+.. warning::
+
+   Write methods (``write_root_state_to_sim``, ``write_joint_state_to_sim``,
+   etc.) modify ``qpos``/``qvel`` directly. Read properties
+   (``root_link_pose_w``, ``body_link_vel_w``, etc.) return derived
+   quantities that are only current as of the last ``sim.forward()`` call.
+   If you need to write then read in the same function, call
+   ``env.sim.forward()`` between them.
+
+For a deeper explanation, see `Discussion #289
+<https://github.com/mujocolab/mjlab/discussions/289>`_.
+
+Why aren't my training runs reproducible even with a fixed seed?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+MuJoCo Warp does not yet guarantee determinism, so running the same
+simulation with identical inputs may produce slightly different outputs.
+This is a known limitation being tracked in
+`mujoco_warp#562 <https://github.com/google-deepmind/mujoco_warp/issues/562>`_.
+
+Until determinism is implemented upstream, mjlab training runs will not be
+perfectly reproducible even when setting a seed.
+
+Rendering & Visualization
+-------------------------
+
+What visualization options are available?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+mjlab currently supports two visualizers for policy evaluation and
+debugging:
+
+- **Native MuJoCo visualizer** - the built-in visualizer that ships with MuJoCo.
+- **Viser** - `Viser <https://github.com/nerfstudio-project/viser>`_,
+  a web-based 3D visualization tool.
+
+We are exploring **training-time visualization** (e.g., live rollout viewers),
+but this is not yet available.
+
+As an alternative, mjlab supports **video logging to Weights & Biases
+(W&B)**, so you can monitor rollout videos directly in the experiment dashboard.
+
+What about camera/pixel rendering for vision-based RL?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Camera rendering for **pixel-based agents** is not yet available.
+
+The MuJoCo Warp team is actively developing **camera support**. Once mature, it
+will be integrated into mjlab for vision-based RL workflows.
+
+How many environments can I visualize at once?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Visualizers are **limited to 32 environments maximum** for performance reasons.
+
+- **Offscreen renderer** (for video recording): Hard-capped at 32 envs
+  (see ``_MAX_ENVS`` in ``viewer/offscreen_renderer.py:12``)
+- **Native/Viser viewers**: Limited by MuJoCo's geometry buffer
+  (default 10,000 geoms, configurable via ``max_geom`` parameter)
+
+With thousands of environments, only a subset will be rendered. The viewer
+shows whichever environments fit within the geometry budget.
+
+Why are my fixed-base robots all stacked at the origin instead of in a grid?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Fixed-base robots require an **explicit reset event** to position them at
+their ``env_origins``. If your robots appear stacked at (0, 0, 0):
+
+**Common causes:**
+
+1. **Missing reset event** - Most common issue.
+2. **env_spacing is 0 or very small** - Check your ``SceneCfg(env_spacing=...)``.
+   Even with proper reset events, if ``env_spacing=0.0``, all robots will
+   be at the same position. If ``env_spacing`` is very small (e.g., 0.01),
+   they'll be clustered in a tiny area that looks like a line from a distance.
+
+**Solution**: Add a reset event that calls ``reset_root_state_uniform``:
+
+.. code-block:: python
+
+   # In your ManagerBasedRlEnvCfg
+   events = {
+     # For positioning the base of the robot at env_origins.
+     "reset_base": EventTermCfg(
+       func=mdp.reset_root_state_uniform,
+       mode="reset",
+       params={
+         "pose_range": {},  # Empty = use default pose + env_origins
+         "velocity_range": {},
+       },
+     ),
+     # ... other events
+   }
+
+This pattern is used in the example manipulation task (see ``lift_cube_env_cfg.py:84-93``).
+
+**Why this is needed**: Fixed-base robots are automatically wrapped in mocap
+bodies by ``auto_wrap_fixed_base_mocap()``, but mocap positioning only happens
+when you explicitly call a reset event. The ``env_origins`` offset is applied
+inside ``reset_root_state_uniform()`` at line 127 of ``envs/mdp/events.py``.
+
+See `issue #560 <https://github.com/mujocolab/mjlab/issues/560>`_ for examples.
+
+How does env_origins determine robot layout?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Robot spacing depends on your terrain configuration:
+
+**Plane terrain** (``terrain_type="plane"``):
+  - Creates an approximately square grid automatically
+  - Grid size: ``ceil(sqrt(num_envs))`` rows x cols
+  - Spacing controlled by ``env_spacing`` parameter (default: 2.0m)
+  - Examples with ``env_spacing=2.0``:
+    - 32 envs → 7x5 grid spanning 12m x 8m
+    - 4096 envs → 64x64 grid spanning 126m x 126m
+  - **Important**: If ``env_spacing=0``, all robots will be at (0, 0, 0)
+  - Implementation: ``terrain_importer.py:_compute_env_origins_grid()``
+
+**Procedural terrain** (``terrain_type="generator"``):
+  - Origins loaded from pre-generated terrain sub-patches
+  - Grid size: ``TerrainGeneratorCfg.num_rows x num_cols``
+  - Row index = difficulty level (curriculum mode)
+  - Column index = terrain type variant
+  - **Important allocation behavior**: Columns (terrain types) are evenly distributed
+    across environments, but rows (difficulty levels) are randomly sampled. This means
+    multiple environments can spawn on the same (row, col) patch, leaving others unoccupied,
+    even when ``num_envs > num_patches``.
+  - Example: 5x5 grid (25 patches), 100 envs → each column gets exactly 20 envs,
+    but those 20 are randomly distributed across 5 rows, so some patches remain empty.
+  - Supports ``randomize_env_origins()`` to shuffle positions during training
+
+How do I ensure each terrain type gets its own column?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Set ``curriculum=True`` in your ``TerrainGeneratorCfg``. This makes column
+allocation deterministic, with each column getting one terrain type based on
+normalized proportions.
+
+Example with 2 terrain types:
+
+.. code-block:: python
+
+   TerrainGeneratorCfg(
+     num_rows=3,
+     num_cols=2,
+     curriculum=True,  # Required for deterministic column allocation!
+     sub_terrains={
+       "flat": BoxFlatTerrainCfg(proportion=0.5),  # Gets column 0
+       "pillars": HfDiscreteObstaclesTerrainCfg(
+         proportion=0.5,  # Gets column 1
+       ),
+     },
+   )
+
+Without ``curriculum=True``, every patch is randomly sampled and you'll get
+a random mix of both terrain types scattered across all patches.
+
+**Note**: When ``num_cols`` equals the number of terrain types, each terrain
+gets exactly one column regardless of proportion values (they're normalized).
+When ``num_cols > num_terrain_types``, proportions determine how many columns
+each terrain type occupies.
+
+What is flat patch sampling and how does it affect robot spawning?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Flat patch sampling detects flat regions on heightfield terrains where robots
+can safely spawn. It uses morphological filtering on the heightfield to find
+circular areas where height variation is within a tolerance.
+
+Configure it on any sub-terrain via ``flat_patch_sampling``:
+
+.. code-block:: python
+
+   from mjlab.terrains.terrain_generator import FlatPatchSamplingCfg
+
+   "obstacles": HfDiscreteObstaclesTerrainCfg(
+     ...,
+     flat_patch_sampling={
+       "spawn": FlatPatchSamplingCfg(
+         num_patches=10,      # patches to sample per sub-terrain
+         patch_radius=0.5,    # flatness check radius (meters)
+         max_height_diff=0.05,  # max height variation within radius
+       ),
+     },
+   )
+
+Then use ``reset_root_state_from_flat_patches`` as your reset event to spawn
+robots on detected patches instead of at the sub-terrain center.
+
+**Key details:**
+
+- Only heightfield (``Hf*``) terrains support actual flat patch detection.
+  Box terrains (``Box*``) don't have heightfield data to analyze.
+- If any sub-terrain in the grid configures ``flat_patch_sampling``, the
+  flat patches array is allocated for **all** cells. Sub-terrains that don't
+  produce patches have their slots filled with the sub-terrain's spawn origin,
+  so ``reset_root_state_from_flat_patches`` always gets valid positions.
+- Without ``flat_patch_sampling``, use ``reset_root_state_uniform`` which
+  spawns at the sub-terrain origin (``env_origins``) plus an optional random
+  offset.
+
+Development & Extensions
+------------------------
+
+Can I develop custom tasks in my own repository?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Yes, mjlab has a **plugin system** that lets you develop tasks in separate
+repositories while still integrating seamlessly with the core:
+
+- Your tasks appear as regular entries for the ``train`` and ``play`` commands.
+- You can version and maintain your task repositories independently.
+
+A complete guide will be available in a future release.
+
+Assets & Compatibility
+----------------------
+
+What robots are included?
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+mjlab includes two **reference robots**:
+
+- **Unitree Go1** (quadruped).
+- **Unitree G1** (humanoid).
+
+These robots serve as:
+
+- Minimal examples for **robot integration**.
+- Stable, well-tested baselines for **benchmark tasks**.
+
+To keep the core library lean, we do **not** plan to aggressively expand the
+built-in robot library. Additional robots may be provided in separate
+repositories or community-maintained packages.
+
+Can I use USD or URDF models?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+No, mjlab expects **MJCF (MuJoCo XML)** models.
+
+- You will need to **convert** USD or URDF assets to MJCF.
+- For many common robots, you can directly use
+  `MuJoCo Menagerie <https://github.com/google-deepmind/mujoco_menagerie>`_,
+  which ships high-quality MJCF models and assets.
+
+Getting Help
+------------
+
+GitHub Issues
+~~~~~~~~~~~~~
+
+Use GitHub issues for:
+
+- **Bug reports**
+- **Performance regressions**
+- **Documentation gaps**
+
+When filing a bug, please include:
+
+- CUDA driver and runtime versions
+- GPU model
+- A minimal reproduction script
+- Complete error logs and stack traces
+- Appropriate labels (for example: ``bug``, ``performance``, ``docs``)
+
+`Open an issue <https://github.com/mujocolab/mjlab/issues>`_
+
+Discussions
+~~~~~~~~~~~
+
+Use GitHub Discussions for:
+
+- Usage questions (config, debugging, best practices)
+- Performance tuning tips
+- Asset conversion and modeling questions
+- Design discussions and roadmap ideas
+
+`Start a discussion <https://github.com/mujocolab/mjlab/discussions>`_
+
+Known Limitations
+-----------------
+
+We're tracking missing features for the stable release in
+https://github.com/mujocolab/mjlab/issues/100. Check our
+`open issues <https://github.com/mujocolab/mjlab/issues>`_ to see what's actively
+being worked on.
+
+If something isn't working or if we've missed something, please
+`file a bug report <https://github.com/mujocolab/mjlab/issues/new>`_.

mjlab/docs/source/installation.rst

@@ -0,0 +1,296 @@
+.. _installation:
+
+Installation Guide
+==================
+
+This guide presents different installation paths so you can
+choose the one that best fits your use case.
+
+.. contents::
+   :local:
+   :depth: 1
+
+.. note::
+
+    **System Requirements**
+
+    - **Operating System**: Linux recommended
+    - **Python**: 3.10 or higher
+    - **GPU**: NVIDIA GPU
+    - **CUDA version**: CUDA 12.4+ Recommended
+
+    See :ref:`faq` for more details on what is exactly supported.
+
+
+How to choose an installation method?
+-------------------------------------
+
+Select the card that best matches how you plan to use ``mjlab``.
+
+.. grid:: 2
+   :gutter: 2
+
+   .. grid-item-card:: Method 1 - Use mjlab as a dependency (uv)
+      :link: install-uv-dependency
+      :link-type: ref
+
+      You are **using mjlab as a dependency** in your own project managed by ``uv``. **(Recommended for most users)**
+
+   .. grid-item-card:: Method 2 - Develop / contribute (uv)
+      :link: install-uv-develop
+      :link-type: ref
+
+      You are **trying mjlab** or **contributing to mjlab itself** directly from inside the mjlab repository, with ``uv`` managing the environment.
+
+   .. grid-item-card:: Method 3 - Classic pip / venv / conda
+      :link: install-pip
+      :link-type: ref
+
+      You are using **classic tools** (``pip`` / ``venv`` / ``conda``) and **do not use uv**.
+
+   .. grid-item-card:: Method 4 - Docker / clusters
+      :link: install-docker
+      :link-type: ref
+
+      You are **running in containers or on clusters** and prefer a **Docker-based** setup.
+
+
+.. _install-uv-dependency:
+
+Method 1 - Use mjlab as a dependency (uv)
+-----------------------------------------
+
+This is our recommended way to use ``mjlab``. You have
+your own project and want to use ``mjlab`` as a dependency
+using ``uv``.
+
+1. Install uv
+^^^^^^^^^^^^^
+
+If you do not have ``uv`` installed, run:
+
+.. code-block:: bash
+
+   curl -LsSf https://astral.sh/uv/install.sh | sh
+
+2. Initialize your project
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Initialize a managed Python project:
+
+.. code-block:: bash
+
+   # Create a new package-based project
+   uv init --package my_mjlab_project
+   cd my_mjlab_project
+
+3. Add mjlab dependencies
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+There are different options to add ``mjlab`` as a dependency.
+We recommend using the latest stable version from PyPI. If you need
+the latest features, use the direct GitHub installation. Finally, if you
+need to use a feature you have developed locally, use the local editable
+install. These options are interchangeable: you can switch at any time.
+
+.. tab-set::
+
+   .. tab-item:: PyPI
+
+      Once in your project, install the latest snapshot from PyPI:
+
+      .. code:: bash
+
+         uv add mjlab
+
+   .. tab-item:: Source
+
+      Once in your project, install directly from GitHub without cloning:
+
+      .. code:: bash
+
+         uv add "mjlab @ git+https://github.com/mujocolab/mjlab"
+
+   .. tab-item:: Local
+
+      Clone the repository:
+
+      .. code:: bash
+
+         git clone https://github.com/mujocolab/mjlab.git
+
+      Once in your project, add it as an editable dependency:
+
+      .. code:: bash
+
+         uv add --editable /path/to/cloned/mjlab
+
+.. tip::
+
+   For a complete example of how to structure a project that integrates a custom robot
+   with an existing ``mjlab`` task, check out the
+   `ANYmal C Velocity Tracking <https://github.com/mujocolab/anymal_c_velocity>`_ repository.
+
+Verification
+^^^^^^^^^^^^
+
+After installation, verify that ``mjlab`` is working by running the demo:
+
+.. code-block:: bash
+
+   uv run demo
+
+
+.. _install-uv-develop:
+
+Method 2 - Develop / contribute (uv)
+------------------------------------
+
+This method is for developing ``mjlab`` itself or contributing to the project.
+
+.. code:: bash
+
+   git clone https://github.com/mujocolab/mjlab.git
+   cd mjlab
+   uv sync
+
+Verification
+^^^^^^^^^^^^
+
+After installation, verify that ``mjlab`` is working by running the demo:
+
+.. code-block:: bash
+
+   uv run demo
+
+
+.. _install-pip:
+
+Method 3 - Classic pip / venv / conda
+-------------------------------------
+
+While ``mjlab`` is designed to work with `uv <https://docs.astral.sh/uv/>`_, you can
+also use it with any pip-based virtual environment (``venv``, ``conda``, ``virtualenv``, etc.).
+
+Create and activate your virtual environment
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. tab-set::
+
+   .. tab-item:: venv
+
+      Using ``venv`` (standard library):
+
+      .. code:: bash
+
+         python -m venv mjlab-env
+         source mjlab-env/bin/activate
+
+   .. tab-item:: conda
+
+      Using ``conda``:
+
+      .. code:: bash
+
+         conda create -n mjlab python=3.13
+         conda activate mjlab
+
+
+Install mjlab and dependencies via pip
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. tab-set::
+
+   .. tab-item:: PyPI
+
+      From PyPI:
+
+      .. code:: bash
+
+         pip install mjlab
+
+   .. tab-item:: Source
+
+      From Source:
+
+      .. code:: bash
+
+         git clone https://github.com/mujocolab/mjlab.git
+         cd mjlab
+         pip install -e .
+
+
+Verification
+^^^^^^^^^^^^
+
+After installation, verify that ``mjlab`` is working by running the demo:
+
+.. code-block:: bash
+
+   demo
+
+
+.. _install-docker:
+
+Method 4 - Docker / clusters
+----------------------------
+
+This method is recommended if you prefer running ``mjlab`` in containers (for example on
+servers or clusters).
+
+
+Prerequisites
+^^^^^^^^^^^^^
+
+- Install Docker: `Docker installation guide <https://docs.docker.com/engine/install/>`_.
+- Install an appropriate NVIDIA driver for your system and the
+  `NVIDIA Container Toolkit <https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html>`_.
+
+  - Be sure to register the container runtime with Docker and restart, as described in
+    the Docker configuration section of the NVIDIA install guide.
+
+
+Build the Docker image
+^^^^^^^^^^^^^^^^^^^^^^
+
+From the root of the repository:
+
+.. code-block:: bash
+
+   make docker-build
+
+
+Run mjlab in Docker
+^^^^^^^^^^^^^^^^^^^
+
+Use the included helper script to run an ``mjlab`` Docker container with useful arguments preconfigured:
+
+.. code-block:: bash
+
+   ./scripts/run_docker.sh
+
+Examples:
+
+- Demo with viewer:
+
+  .. code-block:: bash
+
+     ./scripts/run_docker.sh uv run demo
+
+- Training example:
+
+  .. code-block:: bash
+
+     ./scripts/run_docker.sh uv run train Mjlab-Velocity-Flat-Unitree-G1 --env.scene.num-envs 4096
+
+
+Having some troubles?
+---------------------
+
+1. **Check the FAQ**
+
+    Consult the mjlab :ref:`faq` for answers to common installation and runtime issues
+
+2. **Still stuck?**
+
+    Open an issue on GitHub: https://github.com/mujocolab/mjlab/issues

mjlab/docs/source/migration_isaac_lab.rst

@@ -0,0 +1,283 @@
+.. _migration-isaaclab:
+
+Migrating from Isaac Lab
+========================
+
+.. warning::
+
+   This guide is a work in progress. As more users migrate, we will update this
+   page with additional patterns and edge cases. If something is not covered,
+   please open an issue on GitHub or start a discussion:
+
+   - Issues: https://github.com/mujocolab/mjlab/issues
+   - Discussions: https://github.com/mujocolab/mjlab/discussions
+
+TL;DR
+-----
+
+Most Isaac Lab *manager-based* task configs can be ported to ``mjlab`` with
+only small changes:
+
+- The overall **MDP structure is the same** (managers for rewards, observations,
+  actions, commands, terminations, events, curriculum).
+- The **environment base classes are similar**, but naming is slightly
+  different.
+- The biggest change is **configuration style**: Isaac Lab uses nested
+  ``@configclass`` definitions; ``mjlab`` uses dictionaries of config objects.
+
+If you are familiar with Isaac Lab's manager-based API, migration is mostly
+mechanical.
+
+Key Differences
+---------------
+
+1. Import Paths
+~~~~~~~~~~~~~~~
+
+Isaac Lab:
+
+.. code-block:: python
+
+   from isaaclab.envs import ManagerBasedRLEnv
+
+mjlab:
+
+.. code-block:: python
+
+   from mjlab.envs import ManagerBasedRlEnvCfg
+
+.. note::
+
+   ``mjlab`` uses a consistent ``CamelCase`` naming convention (for example,
+   ``RlEnv`` instead of ``RLEnv``).
+
+2. Configuration Structure
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Isaac Lab uses nested ``@configclass`` blocks for manager terms. ``mjlab``
+instead uses **plain dictionaries** mapping names to config objects, which makes
+it easy to construct variants, merge configs, or generate them programmatically.
+
+**Isaac Lab:**
+
+.. code-block:: python
+
+   @configclass
+   class RewardsCfg:
+       """Reward terms for the MDP."""
+
+       motion_global_anchor_pos = RewTerm(
+           func=mdp.motion_global_anchor_position_error_exp,
+           weight=0.5,
+           params={"command_name": "motion", "std": 0.3},
+       )
+       motion_global_anchor_ori = RewTerm(
+           func=mdp.motion_global_anchor_orientation_error_exp,
+           weight=0.5,
+           params={"command_name": "motion", "std": 0.4},
+       )
+
+**mjlab:**
+
+.. code-block:: python
+
+   rewards = {
+       "motion_global_anchor_pos": RewardTermCfg(
+           func=mdp.motion_global_anchor_position_error_exp,
+           weight=0.5,
+           params={"command_name": "motion", "std": 0.3},
+       ),
+       "motion_global_anchor_ori": RewardTermCfg(
+           func=mdp.motion_global_anchor_orientation_error_exp,
+           weight=0.5,
+           params={"command_name": "motion", "std": 0.4},
+       ),
+   }
+
+   cfg = ManagerBasedRlEnvCfg(
+       scene=scene,
+       rewards=rewards,
+       # ... other manager dictionaries:
+       # observations=..., actions=..., commands=..., terminations=...,
+       # events=..., curriculum=...
+   )
+
+This pattern applies to all managers:
+
+- ``rewards``
+- ``observations``
+- ``actions``
+- ``commands``
+- ``terminations``
+- ``events``
+- ``curriculum``
+
+3. Scene Configuration
+~~~~~~~~~~~~~~~~~~~~~~
+
+Scene setup is **simpler** in ``mjlab``:
+
+- No Omniverse / USD scene graph, no ``prim_path`` management.
+- Assets are pure MuJoCo (MJCF) with modifier dataclasses applied to
+  ``mujoco.MjSpec``.
+- Lights, materials, textures, and sensors are configured as part of
+  ``SceneCfg`` and robot configs.
+
+**Isaac Lab:**
+
+.. code-block:: python
+
+   from whole_body_tracking.robots.g1 import G1_ACTION_SCALE, G1_CYLINDER_CFG
+   from isaaclab.scene import InteractiveSceneCfg
+   from isaaclab.sensors import ContactSensorCfg
+   from isaaclab.terrains import TerrainImporterCfg
+   import isaaclab.sim as sim_utils
+   from isaaclab.assets import ArticulationCfg, AssetBaseCfg
+
+   @configclass
+   class MySceneCfg(InteractiveSceneCfg):
+       """Configuration for the terrain scene with a legged robot."""
+
+       # ground terrain
+       terrain = TerrainImporterCfg(
+           prim_path="/World/ground",
+           terrain_type="plane",
+           collision_group=-1,
+           physics_material=sim_utils.RigidBodyMaterialCfg(
+               friction_combine_mode="multiply",
+               restitution_combine_mode="multiply",
+               static_friction=1.0,
+               dynamic_friction=1.0,
+           ),
+           visual_material=sim_utils.MdlFileCfg(
+               mdl_path="{NVIDIA_NUCLEUS_DIR}/Materials/Base/Architecture/Shingles_01.mdl",
+               project_uvw=True,
+           ),
+       )
+       # lights
+       light = AssetBaseCfg(
+           prim_path="/World/light",
+           spawn=sim_utils.DistantLightCfg(
+               color=(0.75, 0.75, 0.75), intensity=3000.0
+           ),
+       )
+       sky_light = AssetBaseCfg(
+           prim_path="/World/skyLight",
+           spawn=sim_utils.DomeLightCfg(
+               color=(0.13, 0.13, 0.13), intensity=1000.0
+           ),
+       )
+       robot = G1_CYLINDER_CFG.replace(prim_path="{ENV_REGEX_NS}/Robot")
+
+**mjlab:**
+
+.. code-block:: python
+
+   from dataclasses import replace
+
+   from mjlab.scene import SceneCfg
+   from mjlab.asset_zoo.robots.unitree_g1.g1_constants import get_g1_robot_cfg
+   from mjlab.utils.spec_config import ContactSensorCfg
+   from mjlab.terrains import TerrainImporterCfg
+
+   # Configure contact sensor
+   self_collision_sensor = ContactSensorCfg(
+       name="self_collision",
+       subtree1="pelvis",
+       subtree2="pelvis",
+       data=("found",),
+       reduce="netforce",
+       num=10,  # report up to 10 contacts
+   )
+
+   # Add sensor to robot config
+   g1_cfg = replace(get_g1_robot_cfg(), sensors=(self_collision_sensor,))
+
+   # Create scene
+   SCENE_CFG = SceneCfg(
+       terrain=TerrainImporterCfg(terrain_type="plane"),
+       entities={"robot": g1_cfg},
+   )
+
+Key changes:
+
+- No USD ``prim_path`` or cloning; the scene is described directly in MuJoCo.
+- Materials, lights, and visual properties are applied via
+  ``MjSpec``-modifier dataclasses.
+- See ``mjlab.utils.spec_config`` in the repository for helpers that apply
+  these changes for you.
+- ``asset_name`` has been unified to ``entity_name`` across all configurations.
+
+Complete Example Comparison
+---------------------------
+
+A good way to learn the pattern is to compare concrete tasks that have already
+been ported:
+
+- Isaac Lab implementation (Beyond Mimic):
+
+  - https://github.com/HybridRobotics/whole_body_tracking/blob/main/source/whole_body_tracking/whole_body_tracking/tasks/tracking/tracking_env_cfg.py
+
+- mjlab implementation:
+
+  - https://github.com/mujocolab/mjlab/blob/main/src/mjlab/tasks/tracking/tracking_env_cfg.py
+
+You will see that:
+
+- Manager dictionaries in ``mjlab`` mirror Isaac Lab's config classes,
+- Reward, observation, command, and termination logic is almost identical,
+- Scene and asset setup are simplified to pure MuJoCo.
+
+Migration Checklist
+-------------------
+
+Use this as a quick checklist when porting a task:
+
+1. **Base class and imports**
+
+   - Replace Isaac Lab imports (for example,
+     ``from isaaclab.envs import ManagerBasedRLEnv``) with the corresponding
+     ``mjlab`` imports (for example,
+     ``from mjlab.envs import ManagerBasedRlEnvCfg``).
+
+2. **Manager configuration**
+
+   - Convert each Isaac Lab ``@configclass`` manager (``RewardsCfg``,
+     ``ObservationsCfg``, etc.) into a dictionary of config objects.
+   - Pass these dictionaries into ``ManagerBasedRlEnvCfg``.
+
+3. **Scene and assets**
+
+   - Replace ``InteractiveSceneCfg`` with a ``SceneCfg`` instance.
+   - Replace USD / ``prim_path`` logic with MuJoCo asset configs and scene
+     entities (for example, a robot from ``asset_zoo``).
+
+4. **Sensors and contact handling**
+
+   - Convert Isaac Lab ``ContactSensorCfg`` to
+     ``mjlab.utils.spec_config.ContactSensorCfg`` and attach it to the robot
+     config.
+
+5. **RL entry points**
+
+   - Make sure your training script or entry point uses the correct task id and
+     environment config (for example, via Gymnasium registration or direct
+     construction, depending on how your project is structured).
+
+Tips and Support
+----------------
+
+1. Check the examples in the repository under:
+
+   - ``src/mjlab/tasks/``
+
+2. If you get stuck:
+
+   - Open an issue: https://github.com/mujocolab/mjlab/issues
+   - Start a discussion: https://github.com/mujocolab/mjlab/discussions
+
+3. Keep in mind MuJoCo vs Isaac Sim differences:
+
+   - Some Omniverse / USD rendering features do not have direct equivalents.
+   - Focus first on matching the **physics and observations**, then polish
+     visuals if needed.

mjlab/docs/source/motivation.rst

@@ -0,0 +1,134 @@
+.. _motivation:
+
+Why mjlab?
+==========
+
+The Problem
+-----------
+
+GPU-accelerated robotics simulation has great tools, 
+but each has tradeoffs:
+
+**Isaac Lab**: Excellent API and RL abstractions, but 
+heavy installation, slow startup, and Omniverse overhead 
+make rapid iteration painful.
+
+**MJX**: Fast and lightweight, but JAX's learning curve 
+and poor collision scaling (if using the ``jax`` 
+`implementation <https://github.com/google-deepmind/mujoco/blob/32e08f9507c9bdc5a1a5411c6fa9f0346542b038/mjx/mujoco/mjx/_src/types.py#L28-L33>`_ 
+rather than the ``warp`` one) limit adoption.
+
+**Newton**: Brand new generic simulator supporting 
+multiple solvers (MuJoCo, VBD, etc.) with USD-based 
+format instead of MJCF/XML. Doesn't yet have the 
+ecosystem and community resources that MuJoCo has built 
+over the years.
+
+Our Solution
+------------
+
+**mjlab = Isaac Lab's API + MuJoCo's simplicity + 
+GPU acceleration**
+
+We took Isaac Lab's proven manager-based architecture 
+and RL abstractions, then built them directly on MuJoCo 
+Warp. No translation layers, no Omniverse overhead. 
+Just fast, transparent physics.
+
+Why Not Use Isaac Lab with Newton?
+   Isaac Lab recently added 
+   `experimental Newton support <https://github.com/isaac-sim/IsaacLab/tree/dev/newton>`_, 
+   which is great for existing Isaac users who want to 
+   try MuJoCo via Newton's backend.
+
+   If you want a comprehensive platform (RL, imitation 
+   learning, photorealistic rendering, etc.), use Isaac 
+   Lab. If you want a focused tool for RL and sim2real 
+   with MuJoCo, use mjlab.
+
+
+Why Not Add MuJoCo Warp to Isaac Lab?
+   This would be fantastic for the ecosystem! 
+   NVIDIA's team is exploring this with their 
+   recent `experimental Newton integration <https://github.com/isaac-sim/IsaacLab/tree/dev/newton>`_, 
+   which is exciting.
+
+   But for us, we wanted to start with something 
+   more focused that we could realistically 
+   maintain. Isaac Lab is architected around 
+   Omniverse/Isaac Sim's powerful capabilities, 
+   which makes sense given everything it supports. 
+   Integrating MuJoCo Warp there would mean working 
+   within that broader framework and supporting 
+   use cases beyond our scope.
+
+   Maintaining multi-backend compatibility 
+   naturally involves tradeoffs in complexity 
+   and dependency management. By starting fresh, we could:
+
+   - Write a lean codebase optimized specifically for MuJoCo Warp
+   - Keep dependencies minimal and installation fast
+   - Maintain direct access to native mjModel/mjData structures
+   - Iterate quickly without navigating a larger platform's constraints
+
+   Think of mjlab as a love letter to Isaac 
+   Lab's brilliant API design. We're bringing 
+   those manager-based abstractions to researchers 
+   who want something smaller and MuJoCo-specific. 
+   It's complementary, not competitive.
+
+Philosophy
+----------
+
+**Bare Metal Performance**
+
+- Direct MuJoCo Warp integration, no translation layers
+- Native mjModel/mjData structures MuJoCo users know and love
+- GPU-accelerated with minimal overhead
+
+**Developer Experience First**
+
+- One-line installation: ``uvx --from mjlab demo``
+- Blazing fast startup
+- Standard Python debugging (pdb anywhere!)
+- Fast iteration cycles
+
+**Focused Scope**
+
+- Rigid-body robotics and RL, not trying to do everything
+- Clean, maintainable codebase over feature bloat
+- MuJoCo-native implementation, not a generic wrapper
+
+When to Use mjlab
+-----------------
+
+**Use mjlab if you want:**
+
+- Fast iteration and debugging
+- Direct MuJoCo physics control
+- Proven RL abstractions (Isaac Lab-style)
+- GPU acceleration without heavyweight dependencies
+- Simple installation and deployment
+
+**Use Isaac Lab if you need:**
+
+- Photorealistic rendering
+- USD pipeline integration
+- Omniverse ecosystem features
+
+**Use Newton if you need:**
+
+- Multi-physics solver support (e.g., deformables)
+- Differentiable simulation
+
+
+The Bottom Line
+---------------
+
+mjlab isn't trying to replace everything. It's 
+built for researchers who love MuJoCo's simplicity 
+and want Isaac Lab's RL abstractions with GPU acceleration, 
+minus the overhead.
+
+
+

mjlab/docs/source/nan_guard.rst

@@ -0,0 +1,148 @@
+.. _nan-guard:
+
+NaN Guard
+=========
+
+The NaN guard captures simulation states when NaN/Inf is detected, helping debug
+numerical instability issues.
+
+TL;DR
+-----
+
+**Running into NaN issues during training?** Enable the NaN guard with a single flag:
+
+.. code-block:: bash
+
+    uv run train.py --enable-nan-guard True
+
+
+This will automatically capture and save simulation states when NaN/Inf is
+detected, making it easy to debug what went wrong.
+
+You can also enable it programmatically in your simulation config:
+
+.. code-block:: python
+
+    from mjlab.sim.sim import SimulationCfg
+    from mjlab.utils.nan_guard import NanGuardCfg
+
+    cfg = SimulationCfg(
+        nan_guard=NanGuardCfg(
+            enabled=True,
+            buffer_size=100,
+            output_dir="/tmp/mjlab/nan_dumps",
+            max_envs_to_dump=5,
+        ),
+    )
+
+Configuration
+-------------
+
+``enabled`` (default: ``False``)
+Enable/disable NaN detection and dumping. When disabled, has minimal overhead.
+
+``buffer_size`` (default: ``100``)
+Number of recent simulation states to keep in rolling buffer.
+
+``output_dir`` (default: ``"/tmp/mjlab/nan_dumps"``)
+Directory where NaN dump files are saved.
+
+``max_envs_to_dump`` (default: ``5``) Maximum number of NaN environments to dump
+to disk. All environments are tracked in the buffer, but only the first N NaN
+environments are saved to reduce dump size.
+
+Behavior
+--------
+
+- **Captures** simulation state before each step (using ``mj_getState``)
+- **Detects** NaN/Inf in ``qpos``, ``qvel``, ``qacc``, ``qacc_warmstart`` after each step
+- **Dumps** buffer and model to disk on first detection
+- **Exits** only dumps once per training run to avoid spam
+
+Output Format
+-------------
+
+Each NaN detection creates timestamped files plus latest symlinks:
+
+- ``nan_dump_TIMESTAMP.npz`` - Compressed state buffer
+  - ``states_step_NNNNNN`` - Captured states for each step (shape: ``[num_envs_dumped, state_size]``)
+  - ``_metadata`` - Dict with ``num_envs_total``, ``nan_env_ids``, ``dumped_env_ids``, etc.
+- ``model_TIMESTAMP.mjb`` - MuJoCo model in binary format
+- ``nan_dump_latest.npz`` - Symlink to most recent dump
+- ``model_latest.mjb`` - Symlink to most recent model
+
+Visualizing Dumps
+-----------------
+
+Use the interactive viewer to scrub through captured states:
+
+.. code-block:: bash
+
+    # View latest dump.
+    uv run viz-nan /tmp/mjlab/nan_dumps/nan_dump_latest.npz
+
+    # Or view a specific dump.
+    uv run viz-nan /tmp/mjlab/nan_dumps/nan_dump_20251014_123456.npz
+
+
+.. figure:: _static/content/nan_debug.gif
+   :alt: NaN Debug Viewer
+
+   NaN debug viewer.
+
+The viewer provides:
+
+- Step slider to scrub through the buffer
+- Environment slider to compare different environments
+- Info panel showing which environments have NaN/Inf
+- 3D visualization of the robot and terrain at each state
+
+This makes it easy to see exactly what went wrong and compare crashed
+environments against clean ones.
+
+Performance
+-----------
+
+When disabled (``enabled=False``), all operations are no-ops with
+negligible overhead. When enabled, overhead scales with ``buffer_size`` and
+``max_envs_to_capture``.
+
+Related Features
+----------------
+
+NaN Detection Termination
+-------------------------
+
+While ``nan_guard`` helps **debug** NaN issues by capturing states, you can also
+**prevent** training crashes using the ``nan_detection`` termination:
+
+.. code-block:: python
+
+    from mjlab.envs.mdp.terminations import nan_detection
+    from mjlab.managers.termination_manager import TerminationTermCfg
+
+    # In your termination config:
+    nan_term: TerminationTermCfg = field(
+        default_factory=lambda: TerminationTermCfg(
+            func=nan_detection,
+            time_out=False
+        )
+    )
+
+
+This marks NaN environments as terminated, allowing them to reset while training
+continues. Terminations are logged as ``Episode_Termination/nan_term`` in your
+metrics.
+
+.. important::
+
+     ``nan_detection`` is a band-aid, not a cure. If NaNs occur
+     during your task objective (e.g., your task is to grasp objects but NaNs
+     happen when grasping), the policy will never learn to complete the task since
+     it resets before receiving rewards. Monitor your ``Episode_Termination/nan_term``
+     metrics carefully.
+
+**When to use which:**
+
+- ``nan_guard``: Debug and understand why NaNs occur (always do this first)
+- ``nan_detection``: Keep training stable while working on a permanent fix

mjlab/docs/source/observation.rst

@@ -0,0 +1,333 @@
+.. _observation:
+
+Observation History and Delay
+=============================
+
+Observations have two temporal features: history and delay. History stacks past
+frames for temporal context, while delay can be used to model sensor latency.
+
+TL;DR
+-----
+
+**Add history to stack frames:**
+
+.. code-block:: python
+
+    from mjlab.managers.observation_manager import ObservationTermCfg
+
+    joint_vel: ObservationTermCfg = ObservationTermCfg(
+        func=joint_vel,
+        history_length=5,        # Keep last 5 frames
+        flatten_history_dim=True # Flatten for MLP: (12,) * 5 = (60,)
+    )
+
+
+**Add delay to model sensor latency:**
+
+.. code-block:: python
+
+    # At 50Hz control (20ms/step): lag=2-3 → 40-60ms latency
+    camera: ObservationTermCfg = ObservationTermCfg(
+        func=camera_obs,
+        delay_min_lag=2,
+        delay_max_lag=3,
+    )
+
+
+**Combine both:**
+
+.. code-block:: python
+
+    joint_pos: ObservationTermCfg = ObservationTermCfg(
+        func=joint_pos,
+        delay_min_lag=1,
+        delay_max_lag=3,      # Delayed observations
+        history_length=5,     # Stack 5 delayed frames
+        flatten_history_dim=True
+    )
+    # Pipeline: compute → delay → stack → flatten
+
+
+Observation History
+-------------------
+
+History stacks past observations to provide temporal context.
+
+Basic Usage
+^^^^^^^^^^^
+
+**Flattened history (for MLPs):**
+
+.. code-block:: python
+
+    joint_vel: ObservationTermCfg = ObservationTermCfg(
+        func=joint_vel,           # Returns (num_envs, 12)
+        history_length=3,
+        flatten_history_dim=True  # Output: (num_envs, 36)
+    )
+
+
+**Structured history (for RNNs):**
+
+.. code-block:: python
+
+    joint_vel: ObservationTermCfg = ObservationTermCfg(
+        func=joint_vel,            # Returns (num_envs, 12)
+        history_length=3,
+        flatten_history_dim=False  # Output: (num_envs, 3, 12)
+    )
+
+
+Group-Level Override
+^^^^^^^^^^^^^^^^^^^^
+
+Apply history to all terms in a group:
+
+
+.. code-block:: python
+
+    @dataclass
+    class PolicyCfg(ObservationGroupCfg):
+        concatenate_terms: bool = True
+        history_length: int = 5           # Applied to all terms
+        flatten_history_dim: bool = True
+
+        joint_pos: ObservationTermCfg = ObservationTermCfg(func=joint_pos)
+        joint_vel: ObservationTermCfg = ObservationTermCfg(func=joint_vel)
+        # Both terms get 5-frame history, flattened
+
+
+Term-level settings override group settings:
+
+
+.. code-block:: python
+
+    @dataclass
+    class PolicyCfg(ObservationGroupCfg):
+        history_length: int = 3  # Default for group
+
+        joint_pos: ObservationTermCfg = ObservationTermCfg(
+            func=joint_pos,
+            history_length=5  # Override: use 5 instead of 3
+        )
+
+
+
+Reset Behavior
+^^^^^^^^^^^^^^
+
+History buffers are cleared on environment reset. The first observation after
+reset is backfilled across all history slots, ensuring valid data from step 0.
+
+
+.. code-block:: python
+
+    # At reset
+    buffer = [obs_0, obs_0, obs_0]  # Backfilled
+
+    # After 2 steps
+    buffer = [obs_0, obs_1, obs_2]  # Normal accumulation
+
+
+History Flattening Order (Term-Major vs Time-Major)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+When ``flatten_history_dim=True`` and ``concatenate_terms=True``, mjlab uses
+**term-major** ordering, where each term's full history is flattened before
+concatenating terms:
+
+
+.. code-block:: bash
+
+    Term A: shape (num_envs, obs_dim_A) with history_length=3
+    Term B: shape (num_envs, obs_dim_B) with history_length=3
+
+    mjlab output (TERM-MAJOR):
+    [A_t0, A_t1, A_t2, B_t0, B_t1, B_t2, ...]
+     └─ all A history ─┘  └─ all B history ─┘
+
+
+An alternative approach is **time-major** (or frame-major) ordering, where
+complete observation frames are built at each timestep before concatenating
+across time:
+
+
+.. code-block:: bash
+
+    TIME-MAJOR (alternative approach):
+    [A_t0, B_t0, ..., A_t1, B_t1, ..., A_t2, B_t2, ...]
+     └─ frame t0 ──┘     └─ frame t1 ──┘     └─ frame t2 ──┘
+
+
+**Sim2sim compatibility:** If you need to transfer policies to/from frameworks
+that use time-major ordering, you will need to reorder observations. This
+affects policies trained with history but not those without.
+
+Observation Delay
+-----------------
+
+Real robots have sensors with communication delays (WiFi, USB). The delay system
+models sensor latency by returning observations from earlier timesteps.
+
+Delay Parameters
+^^^^^^^^^^^^^^^^
+
+``delay_min_lag`` / ``delay_max_lag`` (default: 0) Lag range in steps. Uniformly
+samples an integer lag from ``[min_lag, max_lag]`` (both inclusive).
+``lag=0`` means current observation, ``lag=2`` means 2 steps ago.
+
+``delay_per_env`` (default: True) If True, each environment gets a different
+lag. If False, all environments share the same lag.
+
+``delay_hold_prob`` (default: 0.0)
+Probability [0, 1] of keeping the previous lag instead of resampling.
+
+``delay_update_period`` (default: 0) How often (in steps) to resample the lag.
+If 0, resample every step. If N > 0, the lag value stays constant for N steps
+before being resampled (creates temporally correlated latency patterns).
+
+``delay_per_env_phase`` (default: True) If True and ``delay_update_period > 0``,
+stagger resample timing across environments with random phase offsets.
+
+.. note::
+
+   ``delay_update_period`` controls how often the *lag value* is resampled, not
+   how often observations are refreshed. You still get a new (delayed) observation
+   every step - the lag just stays constant for N steps before being resampled.
+
+**Visualizing delay (50Hz control = 20ms/step):**
+
+.. code-block:: bash
+
+    Sensor captures:  A     B     C     D     E     F     G     H
+                      ↓     ↓     ↓     ↓     ↓     ↓     ↓     ↓
+    Control steps:    0     1     2     3     4     5     6     7
+                     20ms  40ms  60ms  80ms  100ms 120ms 140ms 160ms
+
+    No delay (baseline - perfect sensor):
+    You receive:      A     B     C     D     E     F     G     H
+                      ↑ current observation every step
+
+    Delay with lag=2:
+    You receive:      A     A     A     B     C     D     E     F
+                      ↑clamp↑     ↑     ↑     ↑     ↑     ↑     ↑
+                    Steps 0-1: lag clamped (buffer not full yet)
+                    Step 2+: 40ms delay, every step gets NEW observation
+
+
+**Example - Camera with 40-60ms latency at 50Hz control:**
+
+
+.. code-block:: python
+
+    camera: ObservationTermCfg = ObservationTermCfg(
+        func=camera_obs,
+        delay_min_lag=2,  # 40ms latency
+        delay_max_lag=3,  # 60ms latency
+    )
+
+Computing Delays from Real-World Latency
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Convert real-world latency to simulation steps:
+
+
+delay_steps = latency_ms / (1000 / control_hz)
+
+
+**Example at 50Hz control (20ms per step):**
+- 40ms latency = 40 / 20 = 2 steps
+- 60ms latency = 60 / 20 = 3 steps
+- 100ms latency = 100 / 20 = 5 steps
+
+**Example at 100Hz control (10ms per step):**
+- 40ms latency = 40 / 10 = 4 steps
+- 60ms latency = 60 / 10 = 6 steps
+
+.. note::
+
+     Delays are quantized to control timesteps. At 50Hz control (20ms/step),
+     you can only represent 0ms, 20ms, 40ms, 60ms, etc. To approximate a 45ms sensor,
+     use ``delay_min_lag=2, delay_max_lag=3`` which uniformly samples lag ∈ {2, 3}
+     (both inclusive), giving either 40ms or 60ms delay.
+
+Examples
+^^^^^^^^
+
+**Joint encoders (no delay):**
+
+.. code-block:: python
+
+    joint_pos: ObservationTermCfg = ObservationTermCfg(func=joint_pos)
+    # delay_min_lag=delay_max_lag=0 by default.
+
+
+**Camera with 40-60ms latency at 50Hz control:**
+
+.. code-block:: python
+
+    # 40-60ms latency = 2-3 steps at 50Hz (20ms/step)
+    camera: ObservationTermCfg = ObservationTermCfg(
+        func=camera_obs,
+        delay_min_lag=2,  # 40ms
+        delay_max_lag=3,  # 60ms
+    )
+
+
+**Mixed system - fast encoders and slow camera:**
+
+.. code-block:: python
+
+    @dataclass
+    class PolicyCfg(ObservationGroupCfg):
+        # Fast encoders (no delay)
+        joint_pos: ObservationTermCfg = ObservationTermCfg(
+            func=joint_pos,
+        )
+
+        # Camera with 40-80ms latency
+        camera: ObservationTermCfg = ObservationTermCfg(
+            func=camera_obs,
+            delay_min_lag=2,  # 40ms
+            delay_max_lag=4,  # 80ms
+        )
+
+
+Processing Pipeline
+-------------------
+
+Observations flow through this pipeline:
+
+
+compute → noise → clip → scale → delay → history → flatten
+
+
+**Why delay before history?** History stacks delayed observations. This models
+real systems where you buffer old sensor readings, not future ones.
+
+Example with both:
+
+.. code-block:: python
+
+    joint_vel: ObservationTermCfg = ObservationTermCfg(
+        func=joint_vel,
+        scale=0.1,             # Scale raw values
+        delay_min_lag=1,       # 20ms delay at 50Hz
+        delay_max_lag=2,       # 40ms delay at 50Hz
+        history_length=3,      # Stack 3 delayed frames
+        flatten_history_dim=True
+    )
+    # Pipeline:
+    # 1. compute() returns (num_envs, 12)
+    # 2. scale: multiply by 0.1
+    # 3. delay: return observation from 1-2 steps ago
+    # 4. history: stack last 3 delayed frames → (num_envs, 3, 12)
+    # 5. flatten: reshape → (num_envs, 36)
+
+
+Performance
+-----------
+
+Delay buffers are only created when ``delay_max_lag > 0``. Terms with no delay
+(the default) have zero overhead. Similarly, history buffers are only created
+when ``history_length > 0``.

mjlab/docs/source/randomization.rst

@@ -0,0 +1,223 @@
+Domain Randomization
+====================
+
+Domain randomization varies physical parameters during training so that policies
+are robust to modeling errors and real-world variation. This guide shows
+how to attach randomization terms to your environment using ``EventTerm`` and
+``mdp.randomize_field``.
+
+TL;DR
+-----
+
+Use an ``EventTerm`` that calls ``mdp.randomize_field`` with a target **field**, a
+**value range** (or per-axis ranges), and an **operation** describing how to
+apply the draw.
+
+.. code-block:: python
+
+    from mjlab.managers.event_manager import EventTermCfg
+    from mjlab.managers.scene_entity_config import SceneEntityCfg
+    from mjlab.envs import mdp
+
+    foot_friction: EventTermCfg = EventTermCfg(
+        mode="reset",  # randomize each episode
+        func=mdp.randomize_field,
+        domain_randomization=True,  # marks this as domain randomization
+        params={
+            "asset_cfg": SceneEntityCfg("robot", geom_names=[".*_foot.*"]),
+            "field": "geom_friction",
+            "ranges": (0.3, 1.2),
+            "operation": "abs",
+        },
+    )
+
+Domain Randomization Flag
+-------------------------
+
+When creating an ``EventTermCfg`` for domain randomization, set ``domain_randomization=True``.
+This allows the environment to track which fields are being randomized:
+
+.. code-block:: python
+
+    EventTermCfg(
+        mode="reset",
+        func=mdp.randomize_field,
+        domain_randomization=True,  # required for DR tracking
+        params={"field": "geom_friction", ...},
+    )
+
+This flag is especially useful when using custom class-based event terms instead of
+``mdp.randomize_field``.
+
+Event Modes
+-----------
+
+* ``"startup"`` - randomize once at initialization
+* ``"reset"`` - randomize at every episode reset
+* ``"interval"`` - randomize at regular time intervals
+
+Available Fields
+----------------
+
+**Joint/DOF:** ``dof_armature``, ``dof_frictionloss``, ``dof_damping``, ``jnt_range``,
+``jnt_stiffness``, ``qpos0``
+
+**Body:** ``body_mass``, ``body_ipos``, ``body_iquat``, ``body_inertia``, ``body_pos``,
+``body_quat``
+
+**Geom:** ``geom_friction``, ``geom_pos``, ``geom_quat``, ``geom_rgba``
+
+**Site:** ``site_pos``, ``site_quat``
+
+Randomization Parameters
+------------------------
+
+**Distribution:** ``"uniform"`` (default), ``"log_uniform"`` (values must be > 0),
+``"gaussian"`` (``mean, std``)
+
+**Operation:** ``"abs"`` (default, set), ``"scale"`` (multiply), ``"add"`` (offset)
+
+Axis selection
+^^^^^^^^^^^^^^
+
+Multi-dimensional fields can be randomized per-axis.
+
+**Friction.** Geoms have three coefficients ``[tangential, torsional, rolling]``.
+For ``condim=3`` (standard frictional contact), only **axis 0 (tangential)**
+affects contact behavior:
+
+.. code-block:: python
+
+    # Tangential friction (affects condim=3)
+    params={"field": "geom_friction", "ranges": {0: (0.3, 1.2)}}
+
+    # Tangential + torsional (torsional matters for condim >= 4)
+    params={"field": "geom_friction", "ranges": {0: (0.5, 1.0), 1: (0.001, 0.01)}}
+
+    # X and Y position
+    params={"field": "body_pos", "axes": [0, 1], "ranges": (-0.1, 0.1)}
+
+
+Examples
+--------
+
+Friction (reset)
+^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    foot_friction: EventTermCfg = EventTermCfg(
+        mode="reset",
+        func=mdp.randomize_field,
+        domain_randomization=True,
+        params={
+            "asset_cfg": SceneEntityCfg("robot", geom_names=[".*_foot.*"]),
+            "field": "geom_friction",
+            "ranges": (0.3, 1.2),
+            "operation": "abs",
+        },
+    )
+
+.. note::
+
+     Give your robot's collision geoms higher **priority** than terrain
+     (geom priority defaults to 0). Then you only need to randomize robot friction.
+     MuJoCo will use the higher-priority geom's friction in (robot, terrain)
+     contacts.
+
+.. code-block:: python
+
+    from mjlab.utils.spec_config import CollisionCfg
+
+    robot_collision = CollisionCfg(
+        geom_names_expr=[".*_foot.*"],
+        priority=1,
+        friction=(0.6,),
+        condim=3,
+    )
+
+
+Joint Offset (startup)
+^^^^^^^^^^^^^^^^^^^^^^
+
+Randomize default joint positions to simulate joint offset calibration errors:
+
+.. code-block:: python
+
+    joint_offset: EventTermCfg = EventTermCfg(
+        mode="startup",
+        func=mdp.randomize_field,
+        domain_randomization=True,
+        params={
+            "asset_cfg": SceneEntityCfg("robot", joint_names=[".*"]),
+            "field": "qpos0",
+            "ranges": (-0.01, 0.01),
+            "operation": "add",
+        },
+    )
+
+
+Center of Mass (COM) (startup)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    com: EventTermCfg = EventTermCfg(
+        mode="startup",
+        func=mdp.randomize_field,
+        domain_randomization=True,
+        params={
+            "asset_cfg": SceneEntityCfg("robot", body_names=["torso"]),
+            "field": "body_ipos",
+            "ranges": {0: (-0.02, 0.02), 1: (-0.02, 0.02)},
+            "operation": "add",
+        },
+    ) 
+
+Custom Class-Based Event Terms
+------------------------------
+
+You can create custom event terms using classes instead of functions. This is useful
+for event terms that need to maintain state or perform initialization logic:
+
+.. code-block:: python
+
+    class RandomizeTerrainFriction:
+        """Custom event term that randomizes terrain friction."""
+
+        def __init__(self, cfg, env):
+            # Find the terrain geom index during initialization
+            self._terrain_idx = None
+            for idx, geom in enumerate(env.scene.spec.geoms):
+                if geom.name == "terrain":
+                    self._terrain_idx = idx
+
+            if self._terrain_idx is None:
+                raise ValueError("Terrain geom not found in the model.")
+
+        def __call__(self, env, env_ids, ranges):
+            """Called each time the event is triggered."""
+            from mjlab.utils.math import sample_uniform
+            env.sim.model.geom_friction[env_ids, self._terrain_idx, 0] = sample_uniform(
+                ranges[0], ranges[1], len(env_ids), env.device
+            )
+
+
+    # Use the custom class in your environment config
+    terrain_friction: EventTermCfg = EventTermCfg(
+        mode="reset",
+        func=RandomizeTerrainFriction,
+        domain_randomization=True,
+        params={"field": "geom_friction", "ranges": (0.3, 1.2)},
+    )
+
+
+Migrating from Isaac Lab
+------------------------
+
+Isaac Lab exposes explicit friction combination modes (``multiply``, ``average``,
+``min``, ``max``). MuJoCo instead uses **priority-based selection**: if one
+contacting geom has higher ``priority``, its friction is used; otherwise the
+**element-wise maximum** is used. See the
+`MuJoCo contact documentation <https://mujoco.readthedocs.io/en/stable/computation/index.html#contact>`_
+for details.

mjlab/docs/source/raycast_sensor.rst

@@ -0,0 +1,346 @@
+.. _raycast_sensor:
+
+RayCast Sensor
+==============
+
+The RayCast sensor provides GPU-accelerated raycasting for terrain scanning,
+obstacle detection, and depth sensing. It supports flexible ray patterns,
+multiple frame attachment options, and configurable alignment modes.
+
+.. raw:: html
+
+   <video controls style="display: block; margin: 0 auto; max-width: 100%; height: auto;">
+     <source src="../_static/raycast_demo.mp4" type="video/mp4">
+   </video>
+
+Quick Start
+-----------
+
+.. code-block:: python
+
+  from mjlab.sensor import RayCastSensorCfg, GridPatternCfg, ObjRef
+
+  raycast_cfg = RayCastSensorCfg(
+    name="terrain_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(size=(1.0, 1.0), resolution=0.1),
+    max_distance=5.0,
+  )
+
+  scene_cfg = SceneCfg(
+    entities={"robot": robot_cfg},
+    sensors=(raycast_cfg,),
+  )
+
+  # Access at runtime.
+  sensor = env.scene["terrain_scan"]
+  data = sensor.data
+  distances = data.distances      # [B, N] distance to hit, -1 if miss
+  hit_pos = data.hit_pos_w        # [B, N, 3] world-space hit positions
+  normals = data.normals_w        # [B, N, 3] surface normals
+
+
+Ray Patterns
+------------
+
+Ray patterns define the spatial distribution and direction of rays emitted
+from the sensor frame. Two pattern types are available for different use cases.
+
+Grid Pattern
+^^^^^^^^^^^^
+
+Parallel rays arranged in a 2D grid with fixed spatial resolution.
+
+.. image:: _static/pattern_grid.jpg
+   :width: 600
+   :align: center
+   :alt: Parallel grid ray pattern with fixed footprint
+
+.. note::
+
+   The grid pattern produces a *fixed ground footprint* that does not change
+   with sensor height. Ray spacing is defined in world units (meters).
+
+.. raw:: html
+
+   <video autoplay loop muted playsinline style="display: block; margin: 0 auto; max-width: 100%; height: auto;">
+     <source src="../_static/pattern_grid.mp4" type="video/mp4">
+   </video>
+
+.. code-block:: python
+
+  from mjlab.sensor import GridPatternCfg
+
+  pattern = GridPatternCfg(
+    size=(1.0, 1.0),              # Grid dimensions in meters
+    resolution=0.1,               # Spacing between rays
+    direction=(0.0, 0.0, -1.0),   # Ray direction (down)
+  )
+
+**Characteristics:**
+
+- All rays are parallel
+- Spacing defined in meters
+- Ground footprint is height-invariant
+- Good for: height maps, terrain scanning, spatially uniform sampling
+
+
+Pinhole Camera Pattern
+^^^^^^^^^^^^^^^^^^^^^^
+
+Diverging rays emitted from a single origin, analogous to a depth camera or
+LiDAR sensor.
+
+.. raw:: html
+
+   <video autoplay loop muted playsinline style="display: block; margin: 0 auto; max-width: 100%; height: auto;">
+     <source src="../_static/pattern_pinhole.mp4" type="video/mp4">
+   </video>
+
+.. note::
+
+   Unlike the grid pattern, the pinhole pattern has a *fixed angular field of view*.
+   As the sensor moves higher, the ground coverage increases.
+
+.. code-block:: python
+
+  from mjlab.sensor import PinholeCameraPatternCfg
+
+  # Explicit parameters.
+  pattern = PinholeCameraPatternCfg(
+    width=16,
+    height=12,
+    fovy=45.0,  # Vertical FOV in degrees
+  )
+
+  # From a MuJoCo camera.
+  pattern = PinholeCameraPatternCfg.from_mujoco_camera("robot/depth_cam")
+
+  # From intrinsic matrix.
+  pattern = PinholeCameraPatternCfg.from_intrinsic_matrix(
+    intrinsic_matrix=[500, 0, 320, 0, 500, 240, 0, 0, 1],
+    width=640,
+    height=480,
+  )
+
+**Characteristics:**
+
+- Rays diverge from a single point
+- Coverage defined in angular units (degrees)
+- Ground footprint increases with height
+- Good for: depth cameras, LiDAR, perspective sensing
+
+
+Pattern Comparison
+^^^^^^^^^^^^^^^^^^
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 40 40
+
+   * - Aspect
+     - Grid
+     - Pinhole
+   * - Ray direction
+     - Parallel
+     - Diverging
+   * - Spacing unit
+     - Meters
+     - Degrees (FOV)
+   * - Height affects coverage
+     - No
+     - Yes
+   * - Projection model
+     - Orthographic
+     - Perspective
+
+
+Frame Attachment
+----------------
+
+Rays attach to a frame in the scene via ``ObjRef``.
+
+.. code-block:: python
+
+  frame = ObjRef(type="body", name="base", entity="robot")
+  frame = ObjRef(type="site", name="scan_site", entity="robot")
+  frame = ObjRef(type="geom", name="sensor_mount", entity="robot")
+
+The ``exclude_parent_body`` option (default: ``True``) prevents rays from
+hitting the body to which they are attached.
+
+
+Ray Alignment
+-------------
+
+The ``ray_alignment`` setting controls how rays orient relative to the frame
+when the body rotates.
+
+.. raw:: html
+
+   <video autoplay loop muted playsinline
+          style="display: block; margin: 0 auto; max-width: 100%; height: auto;">
+     <source src="../_static/ray_alignment_comparison.mp4" type="video/mp4">
+   </video>
+
+.. list-table::
+   :header-rows: 1
+   :widths: 15 45 40
+
+   * - Mode
+     - Description
+     - Use Case
+   * - ``"base"``
+     - Full position and rotation
+     - Body-mounted sensors
+   * - ``"yaw"``
+     - Ignores pitch and roll
+     - Terrain height maps
+   * - ``"world"``
+     - Fixed world direction
+     - Gravity-aligned sensing
+
+.. code-block:: python
+
+  RayCastSensorCfg(
+    name="height_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(size=(1.0, 1.0), resolution=0.1),
+    ray_alignment="yaw",
+  )
+
+
+Geom Group Filtering
+--------------------
+
+MuJoCo geoms can be assigned to groups 0-5. Use ``include_geom_groups`` to
+restrict which geoms rays can hit.
+
+.. code-block:: python
+
+  RayCastSensorCfg(
+    name="terrain_only",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(),
+    include_geom_groups=(0, 1),
+  )
+
+
+Output Data
+-----------
+
+The sensor returns ``RayCastData``:
+
+.. code-block:: python
+
+  @dataclass
+  class RayCastData:
+    distances: Tensor   # [B, N] distance to hit, -1 if miss
+    hit_pos_w: Tensor   # [B, N, 3] world-space hit positions
+    normals_w: Tensor   # [B, N, 3] surface normals
+    pos_w: Tensor       # [B, 3] sensor frame position
+    quat_w: Tensor      # [B, 4] sensor frame orientation (w, x, y, z)
+
+``B`` is the number of environments and ``N`` is the number of rays.
+
+
+Debug Visualization
+-------------------
+
+Enable visualization with ``debug_vis=True``:
+
+.. code-block:: python
+
+  RayCastSensorCfg(
+    name="scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(),
+    debug_vis=True,
+  )
+
+
+Examples
+--------
+
+Height Map for Locomotion
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    # Dense grid for terrain-aware locomotion.
+    height_scan = RayCastSensorCfg(
+      name="height_scan",
+      frame=ObjRef(type="body", name="base", entity="robot"),
+      pattern=GridPatternCfg(
+        size=(1.6, 1.0),
+        resolution=0.1,
+        direction=(0.0, 0.0, -1.0),
+      ),
+      ray_alignment="yaw",  # Stay level on slopes
+      max_distance=2.0,
+      exclude_parent_body=True,
+    )
+
+    # In observation function.
+    def height_obs(env: ManagerBasedRlEnv) -> torch.Tensor:
+      sensor = env.scene["height_scan"]
+      return sensor.data.distances  # [B, N]
+
+
+Depth Camera Simulation
+^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    # Simulate a depth camera.
+    depth_cam = RayCastSensorCfg(
+      name="depth",
+      frame=ObjRef(type="site", name="camera_site", entity="robot"),
+      pattern=PinholeCameraPatternCfg.from_mujoco_camera("robot/depth_cam"),
+      max_distance=10.0,
+    )
+
+    # Reshape to image.
+    def depth_image(env: ManagerBasedRlEnv) -> torch.Tensor:
+      sensor = env.scene["depth"]
+      distances = sensor.data.distances  # [B, W*H]
+      return distances.view(-1, 12, 16)  # [B, H, W]
+
+
+Obstacle Detection
+^^^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    # Forward-facing obstacle scan.
+    obstacle_scan = RayCastSensorCfg(
+      name="obstacle",
+      frame=ObjRef(type="body", name="head", entity="robot"),
+      pattern=GridPatternCfg(
+        size=(0.5, 0.3),
+        resolution=0.1,
+        direction=(-1.0, 0.0, 0.0),  # Forward
+      ),
+      max_distance=3.0,
+      include_geom_groups=(0,),  # Filtering to only group 0 geoms
+    )
+
+
+Running the Demo
+----------------
+
+A demo script is included to visualize the sensor on varied terrain:
+
+.. code-block:: bash
+
+    # Grid pattern (default)
+    uv run mjpython scripts/demos/raycast_sensor.py --pattern grid
+
+    # Pinhole camera pattern
+    uv run mjpython scripts/demos/raycast_sensor.py --pattern pinhole
+
+    # With yaw alignment
+    uv run mjpython scripts/demos/raycast_sensor.py --alignment yaw
+
+    # Viser viewer (for remote/headless)
+    uv run python scripts/demos/raycast_sensor.py --viewer viser

mjlab/docs/source/sensors.rst

@@ -0,0 +1,334 @@
+.. _sensors:
+
+Sensors
+=======
+
+Sensors provide a configurable way to measure physical quantities 
+in your simulation. They live at the scene level alongside entities 
+and terrain, can reference multiple entities (e.g., detect contact 
+between robot and terrain), and return structured data for use in 
+rewards, terminations, and observations.
+
+Quick Note: Entity Data vs Sensors
+----------------------------------
+
+**Before diving into sensors**, it's helpful to understand that mjlab provides two complementary ways to access simulation data:
+
+**Entity Data** (``entity.data.*``)
+
+- Common quantities are available out of the box with zero configuration
+- Provides convenient coordinate frame transformations between world and body frames, COM and link frames
+- Offers a familiar API for users coming from Isaac Lab
+- Example: ``robot.data.root_link_lin_vel_b``, ``robot.data.joint_pos``
+
+**Sensors** (this system)
+
+- Provides reusable, configurable sensor definitions that can be shared across tasks
+- Extensible through subclassing to add custom logic like noise, filtering, or processing
+- Maps directly to real robot sensors like IMUs, force sensors, and cameras
+- Example: ``env.scene["feet_contact"].data``, ``env.scene["robot/imu"].data``
+
+**Use them together:**
+
+- Use entity data for quick access to state and transforms
+- Use sensors for measurements that span entities or need configuration
+- Mix both approaches freely in your rewards and observations based on your needs
+
+.. code-block:: python
+
+    from mjlab.sensor import BuiltinSensorCfg, ContactSensorCfg, ContactMatch, ObjRef
+
+    scene_cfg = SceneCfg(
+        entities={"robot": robot_cfg},
+        sensors=(
+            BuiltinSensorCfg(
+                name="imu_acc",
+                sensor_type="accelerometer",
+                obj=ObjRef(type="site", name="imu_site", entity="robot"),
+            ),
+            ContactSensorCfg(
+                name="feet_contact",
+                primary=ContactMatch(mode="geom", pattern=r".*_foot$", entity="robot"),
+                secondary=ContactMatch(mode="body", pattern="terrain"),
+                fields=("found", "force"),
+            ),
+        ),
+    )
+
+    # Access at runtime.
+    imu_acc_data = env.scene["robot/imu_acc"].data  # [B, 3] acceleration
+    feet_contact = env.scene["feet_contact"].data   # ContactData with .found, .force
+
+
+Sensor Types
+------------
+
+mjlab provides three sensor implementations:
+
+BuiltinSensor
+^^^^^^^^^^^^^
+Wraps MuJoCo's native sensor types (57 total) for measuring forces, positions,
+velocities, and other physical quantities. Returns raw `torch.Tensor` data.
+
+ContactSensor
+^^^^^^^^^^^^^
+Detects contacts between bodies, geoms, or subtrees. Returns structured
+`ContactData` with forces, positions, air time metrics, etc.
+
+RayCastSensor
+^^^^^^^^^^^^^
+GPU-accelerated raycasting for terrain scanning and depth sensing. Supports
+grid and pinhole camera patterns with configurable alignment modes.
+See :ref:`raycast_sensor` for full documentation.
+
+BuiltinSensor
+-------------
+
+Sensor Types
+^^^^^^^^^^^^
+
++-----------+----------------------------------------------------------------------------------------------------------------------------------------------------+
+| Category  | Available Sensors                                                                                                                                  |
++===========+====================================================================================================================================================+
+| **Site**  | ``accelerometer``, ``velocimeter``, ``gyro``, ``force``, ``torque``, ``magnetometer``, ``rangefinder``                                             |
++-----------+----------------------------------------------------------------------------------------------------------------------------------------------------+
+| **Joint** | ``jointpos``, ``jointvel``, ``jointlimitpos``, ``jointlimitvel``, ``jointlimitfrc``, ``jointactuatorfrc``                                          |
++-----------+----------------------------------------------------------------------------------------------------------------------------------------------------+
+| **Frame** | ``framepos``, ``framequat``, ``framexaxis``, ``frameyaxis``, ``framezaxis``, ``framelinvel``, ``frameangvel``, ``framelinacc``, ``frameangacc``    |
++-----------+----------------------------------------------------------------------------------------------------------------------------------------------------+
+| **Other** | ``actuatorpos``, ``actuatorvel``, ``actuatorfrc``, ``subtreecom``, ``subtreelinvel``, ``subtreeangmom``, ``clock``, ``e_potential``, ``e_kinetic`` |
++-----------+----------------------------------------------------------------------------------------------------------------------------------------------------+
+
+Usage
+^^^^^
+
+BuiltinSensor returns a ``torch.Tensor`` with 
+shape ``[N_envs, dim]`` where dim depends on the 
+sensor type (e.g., 3 for vectors, 4 for quaternions). 
+Configure with ``BuiltinSensorCfg``, specifying the 
+sensor type, attached object via ``ObjRef``, and 
+optional parameters like ``cutoff`` to limit 
+output magnitude or ``ref`` for frame sensors.
+
+Examples
+^^^^^^^^
+
+.. code-block:: python
+
+    # Accelerometer.
+    imu_acc = BuiltinSensorCfg(
+        name="imu_acc",
+        sensor_type="accelerometer",
+        obj=ObjRef(type="site", name="imu_site", entity="robot"),
+    )
+
+    # Joint limits.
+    joint_limit = BuiltinSensorCfg(
+        name="knee_limit",
+        sensor_type="jointlimitpos",
+        obj=ObjRef(type="joint", name="knee_joint", entity="robot"),
+        cutoff=0.1,
+    )
+
+    # Frame tracking (relative position).
+    ee_pos = BuiltinSensorCfg(
+        name="ee_pos",
+        sensor_type="framepos",
+        obj=ObjRef(type="body", name="end_effector", entity="robot"),
+        ref=ObjRef(type="body", name="base", entity="robot"),
+    )
+
+ContactSensor
+-------------
+
+ContactSensor detects and reports contact between 
+bodies, geoms, or entire subtrees in your simulation. 
+It's particularly useful for foot contact detection, 
+self-collision monitoring, and measuring ground reaction 
+forces. The sensor tracks contacts between a "primary" set 
+of objects (e.g., robot feet) and an optional "secondary" 
+set (e.g., terrain), returning structured data including 
+forces, positions, and timing information.
+
+Pattern Matching
+^^^^^^^^^^^^^^^^
+Use ``ContactMatch`` to specify what to track:
+
+.. code-block:: python
+
+    ContactMatch(
+        mode="geom",              # "geom", "body", or "subtree"
+        pattern=r".*_foot$",      # Regex or list of names
+        entity="robot",           # Optional entity scope
+        exclude=(r".*_heel$",),   # Optional exclusions
+    )
+
+
+Patterns can be:
+- **List of exact names:** ``["left_foot", "right_foot"]``
+- **Regex:** ``r".*_collision$"`` (expands to all matches)
+- **With exclusions:** Filter out specific matches
+
+Configuration
+^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    ContactSensorCfg(
+        name="feet_ground",
+        primary=ContactMatch(...),     # What to track
+        secondary=ContactMatch(...),   # Optional filter
+        fields=("found", "force"),     # Data to extract
+        reduce="maxforce",              # Contact selection
+        num_slots=1,                    # Contacts per primary
+        track_air_time=False,           # Landing/takeoff tracking
+        global_frame=False,             # Force frame
+    )
+    
+
+**Fields:** ``"found"``, ``"force"``, ``"torque"``, ``"dist"``, ``"pos"``, ``"normal"``, ``"tangent"``
+
+**Reduction modes:**
+- ``"none"`` - Fast, non-deterministic
+- ``"mindist"`` - Closest contacts
+- ``"maxforce"`` - Strongest contacts
+- ``"netforce"`` - Returns single synthetic contact at force-weighted centroid with net wrench
+
+Output: ContactData
+^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    @dataclass
+    class ContactData:
+        found: Tensor | None        # [B, N] contact count
+        force: Tensor | None        # [B, N, 3]
+        torque: Tensor | None       # [B, N, 3]
+        dist: Tensor | None         # [B, N] penetration
+        pos: Tensor | None          # [B, N, 3] position
+        normal: Tensor | None       # [B, N, 3] primary→secondary
+        tangent: Tensor | None      # [B, N, 3]
+
+        # With track_air_time=True.
+        current_air_time: Tensor | None
+        last_air_time: Tensor | None
+        current_contact_time: Tensor | None
+        last_contact_time: Tensor | None
+
+
+Shape: ``[B, N * num_slots]`` where N = number of primary matches
+
+Understanding num_slots
+^^^^^^^^^^^^^^^^^^^^^^^
+
+- ``num_slots=1`` (most common): Single representative contact per match
+- ``num_slots > 1``: Multiple contact points per geom/body
+- ``reduce="netforce"``: Always returns exactly one contact regardless of num_slots
+
+.. code-block:: python
+
+    # 4 feet, 1 contact each → [B, 4].
+    ContactSensorCfg(primary=ContactMatch(pattern=["LF", "RF", "LH", "RH"]), num_slots=1)
+
+    # 4 feet, 3 contacts each → [B, 12].
+    ContactSensorCfg(primary=ContactMatch(pattern=["LF", "RF", "LH", "RH"]), num_slots=3)
+
+
+Examples
+^^^^^^^^
+
+.. code-block:: python
+
+    # Foot contacts with forces.
+    feet = ContactSensorCfg(
+        name="feet_ground",
+        primary=ContactMatch(mode="geom", pattern=r".*_foot$", entity="robot"),
+        secondary=ContactMatch(mode="body", pattern="terrain"),
+        fields=("found", "force", "pos"),
+        reduce="maxforce",
+    )
+
+    # Self-collision detection.
+    self_collision = ContactSensorCfg(
+        name="self_collision",
+        primary=ContactMatch(mode="subtree", pattern="pelvis", entity="robot"),
+        secondary=ContactMatch(mode="subtree", pattern="pelvis", entity="robot"),
+        fields=("found",),
+    )
+
+    # Air time tracking for gait analysis.
+    feet_air = ContactSensorCfg(
+        name="feet_air",
+        primary=ContactMatch(pattern=["LF", "RF", "LH", "RH"], entity="robot"),
+        track_air_time=True,
+        fields=("found",),
+    )
+
+    # Net ground reaction force.
+    grf = ContactSensorCfg(
+        name="grf",
+        primary=ContactMatch(mode="subtree", pattern=["left_ankle", "right_ankle"], entity="robot"),
+        secondary=ContactMatch(mode="body", pattern="terrain"),
+        fields=("force",),
+        reduce="netforce",
+    )
+
+Auto-discovery
+--------------
+
+Sensors defined in an entity's XML are automatically discovered and prefixed with the entity's name.
+
+.. code-block:: xml
+
+    <!-- In robot.xml -->
+    <sensor>
+        <accelerometer name="trunk_imu" site="imu_site"/>
+        <jointpos name="hip_sensor" joint="hip_joint"/>
+    </sensor>
+
+.. code-block:: python
+
+    imu = env.scene["robot/trunk_imu"]
+    hip = env.scene["robot/hip_sensor"]
+
+
+Usage Patterns
+--------------
+
+**In observations**
+
+.. code-block:: python
+
+    def imu_acc_obs(env: ManagerBasedRlEnv) -> torch.Tensor:
+        sensor = env.scene["robot/imu_acc"]
+        return sensor.data  # [N_envs, 3]
+
+
+**In rewards**
+
+.. code-block:: python
+
+    def foot_slip(env: ManagerBasedRlEnv) -> torch.Tensor:
+        sensor = env.scene["feet_ground"]
+        vel = sensor.data.force[..., :2].norm(dim=-1)
+        in_contact = sensor.data.found > 0
+        return -torch.where(in_contact, vel, 0.0).mean(dim=1)
+
+
+**In terminations**
+
+.. code-block:: python
+
+    def illegal_contact(env: ManagerBasedRlEnv) -> torch.Tensor:
+        sensor = env.scene["nonfoot_contact"]
+        return torch.any(sensor.data.found, dim=-1)  # [B]
+
+
+**Air time helpers**
+
+.. code-block:: python
+
+    sensor = env.scene["feet_air"]
+    first_contact = sensor.compute_first_contact(dt=0.01)  # Just landed
+    first_air = sensor.compute_first_air(dt=0.01)          # Just took off
+

mjlab/notebooks/create_new_task.ipynb

@@ -0,0 +1,856 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "view-in-github"
+   },
+   "source": [
+    "<a href=\"https://colab.research.google.com/github/mujocolab/mjlab/blob/main/notebooks/create_new_task.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "PO76KS1i-MwA"
+   },
+   "source": [
+    "# **🤖 CartPole Tutorial with mjlab**\n",
+    "\n",
+    "This notebook demonstrates how to create a custom reinforcement learning task using mjlab. We'll build a CartPole environment from scratch, including:\n",
+    "\n",
+    "1. **Robot Definition** - Define the CartPole model in MuJoCo XML\n",
+    "2. **Task Configuration** - Set up observations, actions, rewards, and terminations\n",
+    "3. **Training** - Train a policy using PPO\n",
+    "4. **Evaluation** - Visualize the simulation with the trained policy\n",
+    "\n",
+    "> **Note**: This tutorial demonstrates how to create a new task in mjlab. For more context, see the [official documentation](https://mujocolab.github.io/mjlab/)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3ywZTgfR3C_w"
+   },
+   "source": [
+    "## **📦 Setup and Installation**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true,
+    "id": "dtLMJHzy3Nee"
+   },
+   "outputs": [],
+   "source": "# Clone the mjlab repository\n!if [ ! -d \"mjlab\" ]; then git clone -q https://github.com/mujocolab/mjlab.git; fi\n%cd /content/mjlab\n\n# Install mjlab in editable mode\n!pip install -e . -q\n\nprint(\"✓ Installation complete!\")"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "SSf2943z3b0s"
+   },
+   "source": [
+    "### **🔑 WandB Setup**\n",
+    "\n",
+    "Configure Weights & Biases for experiment tracking. Add your WandB API key to Colab Secrets:\n",
+    "- `WANDB_API_KEY`: from [wandb.ai/authorize](https://wandb.ai/authorize)\n",
+    "- `WANDB_ENTITY`: your wandb entity name"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "KC9ywCnm3dGg"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "from google.colab import userdata\n",
+    "\n",
+    "try:\n",
+    "  # Set this to use wandb logger\n",
+    "  os.environ[\"WANDB_API_KEY\"] = userdata.get(\"WANDB_API_KEY\")\n",
+    "  os.environ[\"WANDB_ENTITY\"] = userdata.get(\"WANDB_ENTITY\")\n",
+    "\n",
+    "  print(\"✓ WandB configured successfully!\")\n",
+    "except (AttributeError, KeyError):\n",
+    "  # Set this to disable wandb logger\n",
+    "  os.environ[\"WANDB_MODE\"] = \"disabled\"\n",
+    "\n",
+    "  print(\"⚠ WandB secrets not found. Training will proceed without WandB logging.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "mispfmy73lmq"
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## **🤖 Step 1: Define the Robot**\n",
+    "\n",
+    "We'll create a simple CartPole robot with:\n",
+    "- A sliding cart (1 DOF)\n",
+    "- A hinged pole (1 DOF)\n",
+    "- A velocity actuator to control the cart"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-FvJYPWD3scd"
+   },
+   "source": [
+    "### **📁 Structure Directories**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "OP-yET-R3ofN"
+   },
+   "outputs": [],
+   "source": [
+    "# Create the cartpole robot directory structure\n",
+    "!mkdir -p /content/mjlab/src/mjlab/asset_zoo/robots/cartpole/\n",
+    "!mkdir -p /content/mjlab/src/mjlab/asset_zoo/robots/cartpole/xmls\n",
+    "\n",
+    "print(\"✓ Directory structure created\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MRyN1Pok3u25"
+   },
+   "source": [
+    "### **📝 Create MuJoCo XML Model**\n",
+    "\n",
+    "This XML defines the CartPole physics:\n",
+    "- **Ground plane** for visualization\n",
+    "- **Cart body** with a sliding joint (±2m range)\n",
+    "- **Pole body** with a hinge joint (±90° range)\n",
+    "- **Velocity actuator** for cart control"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "gWGyFX5V3yWc"
+   },
+   "outputs": [],
+   "source": [
+    "%%writefile /content/mjlab/src/mjlab/asset_zoo/robots/cartpole/xmls/cartpole.xml\n",
+    "<mujoco model=\"cartpole\">\n",
+    "  <compiler angle=\"degree\" coordinate=\"local\" inertiafromgeom=\"true\"/>\n",
+    "  <worldbody>\n",
+    "    <geom name=\"ground\" type=\"plane\" pos=\"0 0 0\" size=\"5 5 0.1\" rgba=\"0.8 0.9 0.8 1\"/>\n",
+    "    <body name=\"cart\" pos=\"0 0 0.1\">\n",
+    "      <geom type=\"box\" size=\"0.2 0.1 0.1\" rgba=\"0.2 0.2 0.8 1\" mass=\"1.0\"/>\n",
+    "      <joint name=\"slide\" type=\"slide\" axis=\"1 0 0\" limited=\"true\" range=\"-2 2\"/>\n",
+    "      <body name=\"pole\" pos=\"0 0 0.1\">\n",
+    "        <geom type=\"capsule\" size=\"0.05 0.5\" fromto=\"0 0 0 0 0 1\" rgba=\"0.8 0.2 0.2 1\" mass=\"2.0\"/>\n",
+    "        <joint name=\"hinge\" type=\"hinge\" axis=\"0 1 0\" range=\"-90 90\"/>\n",
+    "      </body>\n",
+    "    </body>\n",
+    "  </worldbody>\n",
+    "  <actuator>\n",
+    "    <velocity name=\"slide_velocity\" joint=\"slide\" ctrlrange=\"-20 20\" kv=\"20\"/>\n",
+    "  </actuator>\n",
+    "</mujoco>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MpYCG9jI31dZ"
+   },
+   "source": [
+    "### **⚙️ Create Robot Configuration**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "HDhiyDTn4AVa"
+   },
+   "outputs": [],
+   "source": [
+    "%%writefile /content/mjlab/src/mjlab/asset_zoo/robots/cartpole/cartpole_constants.py\n",
+    "from pathlib import Path\n",
+    "import mujoco\n",
+    "\n",
+    "from mjlab import MJLAB_SRC_PATH\n",
+    "from mjlab.entity import Entity, EntityCfg, EntityArticulationInfoCfg\n",
+    "from mjlab.actuator import XmlVelocityActuatorCfg\n",
+    "\n",
+    "CARTPOLE_XML: Path = (\n",
+    "  MJLAB_SRC_PATH / \"asset_zoo\" / \"robots\" / \"cartpole\" / \"xmls\" / \"cartpole.xml\"\n",
+    ")\n",
+    "assert CARTPOLE_XML.exists(), f\"XML not found: {CARTPOLE_XML}\"\n",
+    "\n",
+    "def get_spec() -> mujoco.MjSpec:\n",
+    "  return mujoco.MjSpec.from_file(str(CARTPOLE_XML))\n",
+    "\n",
+    "def get_cartpole_robot_cfg() -> EntityCfg:\n",
+    "  \"\"\"Get a fresh CartPole robot configuration instance.\"\"\"\n",
+    "  actuators = (\n",
+    "    XmlVelocityActuatorCfg(\n",
+    "      target_names_expr=(\"slide\",),\n",
+    "    ),\n",
+    "  )\n",
+    "  articulation = EntityArticulationInfoCfg(actuators=actuators)\n",
+    "  return EntityCfg(\n",
+    "    spec_fn=get_spec,\n",
+    "    articulation=articulation\n",
+    "  )\n",
+    "\n",
+    "# if __name__ == \"__main__\":\n",
+    "#   import mujoco.viewer as viewer\n",
+    "#   robot = Entity(get_cartpole_robot_cfg())\n",
+    "#   viewer.launch(robot.spec.compile())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "-WSaDod04FwN"
+   },
+   "outputs": [],
+   "source": [
+    "# Create __init__.py for the cartpole robot package\n",
+    "%%writefile /content/mjlab/src/mjlab/asset_zoo/robots/cartpole/__init__.py\n",
+    "# Empty __init__.py to mark the directory as a Python package"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "W1tiBPfp_oVP"
+   },
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "\n",
+    "# Append src dir to python path\n",
+    "mjlab_src = \"/content/mjlab/src\"\n",
+    "if mjlab_src not in sys.path:\n",
+    "  sys.path.insert(0, mjlab_src)\n",
+    "  print(f\"✓ Added {mjlab_src} to Python path\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ToWF84qC4Hfg"
+   },
+   "source": [
+    "### **✅ Verify Robot Setup**\n",
+    "\n",
+    "Let's test that the robot can be loaded correctly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "5tVsvqzQ4J9h"
+   },
+   "outputs": [],
+   "source": [
+    "from mjlab.asset_zoo.robots.cartpole.cartpole_constants import get_cartpole_robot_cfg\n",
+    "\n",
+    "from mjlab.entity import Entity\n",
+    "\n",
+    "# Load the robot\n",
+    "robot = Entity(get_cartpole_robot_cfg())\n",
+    "model = robot.spec.compile()\n",
+    "\n",
+    "# Display robot information\n",
+    "print(\"✓ CartPole robot loaded successfully!\")\n",
+    "print(f\"  • Degrees of Freedom (DOF): {model.nv}\")\n",
+    "print(f\"  • Number of Actuators: {model.nu}\")\n",
+    "print(f\"  • Bodies: {model.nbody}\")\n",
+    "print(f\"  • Joints: {model.njnt}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "e2_9dixlHON1"
+   },
+   "source": [
+    "### **📋 Register the Robot**\n",
+    "\n",
+    "Add the CartPole robot to the asset zoo registry."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "8qDIF__lHPcb"
+   },
+   "outputs": [],
+   "source": [
+    "# Add CartPole import to robots __init__.py\n",
+    "with open(\"/content/mjlab/src/mjlab/asset_zoo/robots/__init__.py\", \"a\") as f:\n",
+    "  f.write(\"\\n# CartPole robot\\n\")\n",
+    "  f.write(\"from mjlab.asset_zoo.robots.cartpole.cartpole_constants import \")\n",
+    "  f.write(\"get_cartpole_robot_cfg as get_cartpole_robot_cfg\\n\")\n",
+    "\n",
+    "print(\"✓ CartPole robot registered in asset zoo\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6lVD_L6PHWNm"
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## **🎯 Step 2: Define the Task (MDP)**\n",
+    "\n",
+    "Now we'll define the Markov Decision Process:\n",
+    "- **Observations**: pole angle, angular velocity, cart position, cart velocity\n",
+    "- **Actions**: cart velocity commands\n",
+    "- **Rewards**: upright reward + effort penalty\n",
+    "- **Terminations**: pole tips over or timeout\n",
+    "- **Events**: random pushes for robustness"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RQxe4TBrHb-I"
+   },
+   "source": [
+    "### **📁 Create Task Directory**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "nWBqdkziHc2G"
+   },
+   "outputs": [],
+   "source": [
+    "!mkdir -p /content/mjlab/src/mjlab/tasks/cartpole\n",
+    "\n",
+    "print(\"✓ Task directory created\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "GJfjPpm0Hhj1"
+   },
+   "source": [
+    "### **📝 Create Environment Configuration**\n",
+    "\n",
+    "This file contains the MDP (Markov Decision Process) components:\n",
+    "1. **Scene Config**: 64 parallel environments\n",
+    "2. **Actions**: Joint velocity control with 20.0 scale\n",
+    "3. **Observations**: Normalized state variables\n",
+    "4. **Rewards**: Upright reward (5.0) + effort penalty (-0.01)\n",
+    "5. **Events**: Joint resets + random pushes\n",
+    "6. **Terminations**: Pole tipped (>30°) or timeout (10s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "javx9XDIHkFI"
+   },
+   "outputs": [],
+   "source": [
+    "%%writefile /content/mjlab/src/mjlab/tasks/cartpole/env_cfg.py\n",
+    "\"\"\"CartPole task environment configuration.\"\"\"\n",
+    "\n",
+    "import math\n",
+    "import torch\n",
+    "\n",
+    "from mjlab.envs import ManagerBasedRlEnvCfg\n",
+    "from mjlab.envs.mdp.actions import JointVelocityActionCfg\n",
+    "from mjlab.managers.observation_manager import ObservationGroupCfg, ObservationTermCfg\n",
+    "from mjlab.managers.reward_manager import RewardTermCfg\n",
+    "from mjlab.managers.termination_manager import TerminationTermCfg\n",
+    "from mjlab.managers.event_manager import EventTermCfg\n",
+    "from mjlab.managers.scene_entity_config import SceneEntityCfg\n",
+    "from mjlab.scene import SceneCfg\n",
+    "from mjlab.sim import MujocoCfg, SimulationCfg\n",
+    "from mjlab.viewer import ViewerConfig\n",
+    "from mjlab.asset_zoo.robots.cartpole.cartpole_constants import get_cartpole_robot_cfg\n",
+    "from mjlab.envs import mdp\n",
+    "\n",
+    "\n",
+    "def cartpole_env_cfg(play: bool = False) -> ManagerBasedRlEnvCfg:\n",
+    "  \"\"\"Create CartPole environment configuration.\n",
+    "\n",
+    "  Args:\n",
+    "    play: If True, disables corruption and extends episode length for evaluation.\n",
+    "  \"\"\"\n",
+    "\n",
+    "  # ==============================================================================\n",
+    "  # Scene Configuration\n",
+    "  # ==============================================================================\n",
+    "\n",
+    "  scene_cfg = SceneCfg(\n",
+    "    num_envs=64 if not play else 16,  # Fewer envs for play mode\n",
+    "    extent=1.0,   # Spacing between environments\n",
+    "    entities={\"robot\": get_cartpole_robot_cfg()},\n",
+    "  )\n",
+    "\n",
+    "  viewer_cfg = ViewerConfig(\n",
+    "    origin_type=ViewerConfig.OriginType.ASSET_BODY,\n",
+    "    entity_name=\"robot\",\n",
+    "    body_name=\"pole\",\n",
+    "    distance=3.0,\n",
+    "    elevation=10.0,\n",
+    "    azimuth=90.0,\n",
+    "  )\n",
+    "\n",
+    "  sim_cfg = SimulationCfg(\n",
+    "    mujoco=MujocoCfg(\n",
+    "      timestep=0.02,  # 50 Hz control\n",
+    "      iterations=1,\n",
+    "    ),\n",
+    "  )\n",
+    "\n",
+    "  # ==============================================================================\n",
+    "  # Actions\n",
+    "  # ==============================================================================\n",
+    "\n",
+    "  actions = {\n",
+    "    \"joint_pos\": JointVelocityActionCfg(\n",
+    "      entity_name=\"robot\",\n",
+    "      actuator_names=(\".*\",),\n",
+    "      scale=20.0,\n",
+    "      use_default_offset=False,\n",
+    "    ),\n",
+    "  }\n",
+    "\n",
+    "  # ==============================================================================\n",
+    "  # Observations\n",
+    "  # ==============================================================================\n",
+    "\n",
+    "  actor_terms = {\n",
+    "    \"angle\": ObservationTermCfg(\n",
+    "      func=lambda env: env.sim.data.qpos[:, 1:2] / math.pi\n",
+    "    ),\n",
+    "    \"ang_vel\": ObservationTermCfg(\n",
+    "      func=lambda env: env.sim.data.qvel[:, 1:2] / 5.0\n",
+    "    ),\n",
+    "    \"cart_pos\": ObservationTermCfg(\n",
+    "      func=lambda env: env.sim.data.qpos[:, 0:1] / 2.0\n",
+    "    ),\n",
+    "    \"cart_vel\": ObservationTermCfg(\n",
+    "      func=lambda env: env.sim.data.qvel[:, 0:1] / 20.0\n",
+    "    ),\n",
+    "  }\n",
+    "\n",
+    "  observations = {\n",
+    "    \"actor\": ObservationGroupCfg(\n",
+    "      terms=actor_terms,\n",
+    "      concatenate_terms=True,\n",
+    "      enable_corruption=not play,  # Disable corruption in play mode\n",
+    "    ),\n",
+    "    \"critic\": ObservationGroupCfg(\n",
+    "      terms=actor_terms,  # Critic uses same observations\n",
+    "      concatenate_terms=True,\n",
+    "      enable_corruption=False,\n",
+    "    ),\n",
+    "  }\n",
+    "\n",
+    "  # ==============================================================================\n",
+    "  # Rewards\n",
+    "  # ==============================================================================\n",
+    "\n",
+    "  def compute_upright_reward(env):\n",
+    "    \"\"\"Reward for keeping pole upright (cosine of angle).\"\"\"\n",
+    "    return env.sim.data.qpos[:, 1].cos()\n",
+    "\n",
+    "  def compute_effort_penalty(env):\n",
+    "    \"\"\"Penalty for control effort.\"\"\"\n",
+    "    return -0.01 * (env.sim.data.ctrl[:, 0] ** 2)\n",
+    "\n",
+    "  rewards = {\n",
+    "    \"upright\": RewardTermCfg(func=compute_upright_reward, weight=5.0),\n",
+    "    \"effort\": RewardTermCfg(func=compute_effort_penalty, weight=1.0),\n",
+    "  }\n",
+    "\n",
+    "  # ==============================================================================\n",
+    "  # Events\n",
+    "  # ==============================================================================\n",
+    "\n",
+    "  def random_push_cart(env, env_ids, force_range=(-5, 5)):\n",
+    "    \"\"\"Apply random force to cart for robustness training.\"\"\"\n",
+    "    n = len(env_ids)\n",
+    "    random_forces = (\n",
+    "      torch.rand(n, device=env.device) *\n",
+    "      (force_range[1] - force_range[0]) +\n",
+    "      force_range[0]\n",
+    "    )\n",
+    "    env.sim.data.qfrc_applied[env_ids, 0] = random_forces\n",
+    "\n",
+    "  events = {\n",
+    "    \"reset_robot_joints\": EventTermCfg(\n",
+    "      func=mdp.reset_joints_by_offset,\n",
+    "      mode=\"reset\",\n",
+    "      params={\n",
+    "        \"asset_cfg\": SceneEntityCfg(\"robot\"),\n",
+    "        \"position_range\": (-0.1, 0.1),\n",
+    "        \"velocity_range\": (-0.1, 0.1),\n",
+    "      },\n",
+    "    ),\n",
+    "  }\n",
+    "\n",
+    "  # Add random pushes only in training mode\n",
+    "  if not play:\n",
+    "    events[\"random_push\"] = EventTermCfg(\n",
+    "      func=random_push_cart,\n",
+    "      mode=\"interval\",\n",
+    "      interval_range_s=(1.0, 2.0),\n",
+    "      params={\"force_range\": (-20.0, 20.0)},\n",
+    "    )\n",
+    "\n",
+    "  # ==============================================================================\n",
+    "  # Terminations\n",
+    "  # ==============================================================================\n",
+    "\n",
+    "  def check_pole_tipped(env):\n",
+    "    \"\"\"Check if pole has tipped beyond 30 degrees.\"\"\"\n",
+    "    return env.sim.data.qpos[:, 1].abs() > math.radians(30)\n",
+    "\n",
+    "  terminations = {\n",
+    "    \"timeout\": TerminationTermCfg(func=mdp.time_out, time_out=True),\n",
+    "    \"tipped\": TerminationTermCfg(func=check_pole_tipped, time_out=False),\n",
+    "  }\n",
+    "\n",
+    "  # ==============================================================================\n",
+    "  # Environment Configuration\n",
+    "  # ==============================================================================\n",
+    "\n",
+    "  return ManagerBasedRlEnvCfg(\n",
+    "    scene=scene_cfg,\n",
+    "    observations=observations,\n",
+    "    actions=actions,\n",
+    "    rewards=rewards,\n",
+    "    events=events,\n",
+    "    terminations=terminations,\n",
+    "    sim=sim_cfg,\n",
+    "    viewer=viewer_cfg,\n",
+    "    decimation=1,           # No action repeat\n",
+    "    episode_length_s=int(1e9) if play else 10.0,  # Infinite for play, 10s for training\n",
+    "  )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "fC5maMjzSj_X"
+   },
+   "source": [
+    "### **⚙️ Create RL Configuration**\n",
+    "\n",
+    "This file defines the PPO (Proximal Policy Optimization) training parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "C81zZm6mSj_X"
+   },
+   "outputs": [],
+   "source": [
+    "%%writefile /content/mjlab/src/mjlab/tasks/cartpole/rl_cfg.py\n",
+    "\"\"\"RL configuration for CartPole task.\"\"\"\n",
+    "\n",
+    "from mjlab.rl.config import (\n",
+    "  RslRlOnPolicyRunnerCfg,\n",
+    "  RslRlModelCfg,\n",
+    "  RslRlPpoAlgorithmCfg,\n",
+    ")\n",
+    "\n",
+    "\n",
+    "def cartpole_ppo_runner_cfg() -> RslRlOnPolicyRunnerCfg:\n",
+    "  \"\"\"Create RL runner configuration for CartPole task.\"\"\"\n",
+    "  return RslRlOnPolicyRunnerCfg(\n",
+    "    actor=RslRlModelCfg(\n",
+    "      hidden_dims=(256, 128, 64),  # Smaller network for simpler task\n",
+    "      activation=\"elu\",\n",
+    "      obs_normalization=True,\n",
+    "      stochastic=True,\n",
+    "      init_noise_std=1.0,\n",
+    "    ),\n",
+    "    critic=RslRlModelCfg(\n",
+    "      hidden_dims=(256, 128, 64),\n",
+    "      activation=\"elu\",\n",
+    "      obs_normalization=True,\n",
+    "      stochastic=False,\n",
+    "      init_noise_std=1.0,\n",
+    "    ),\n",
+    "    algorithm=RslRlPpoAlgorithmCfg(\n",
+    "      value_loss_coef=1.0,\n",
+    "      use_clipped_value_loss=True,\n",
+    "      clip_param=0.2,\n",
+    "      entropy_coef=0.01,\n",
+    "      num_learning_epochs=5,\n",
+    "      num_mini_batches=4,\n",
+    "      learning_rate=1.0e-3,\n",
+    "      schedule=\"adaptive\",\n",
+    "      gamma=0.99,\n",
+    "      lam=0.95,\n",
+    "      desired_kl=0.01,\n",
+    "      max_grad_norm=1.0,\n",
+    "    ),\n",
+    "    experiment_name=\"cartpole\",\n",
+    "    save_interval=50,\n",
+    "    num_steps_per_env=24,\n",
+    "    max_iterations=5_000,  # Fewer iterations for simpler task\n",
+    "  )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Oc8-AHGcHt78"
+   },
+   "source": [
+    "### **📋 Register the Task Environment**\n",
+    "\n",
+    "Register the CartPole task with mjlab registry."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "YitUGUBRHxD4"
+   },
+   "outputs": [],
+   "source": [
+    "%%writefile /content/mjlab/src/mjlab/tasks/cartpole/__init__.py\n",
+    "\"\"\"CartPole task registration.\"\"\"\n",
+    "\n",
+    "from mjlab.tasks.registry import register_mjlab_task\n",
+    "from mjlab.rl.runner import MjlabOnPolicyRunner\n",
+    "\n",
+    "from .env_cfg import cartpole_env_cfg\n",
+    "from .rl_cfg import cartpole_ppo_runner_cfg\n",
+    "\n",
+    "register_mjlab_task(\n",
+    "  task_id=\"Mjlab-Cartpole\",\n",
+    "  env_cfg=cartpole_env_cfg(),\n",
+    "  play_env_cfg=cartpole_env_cfg(play=True),\n",
+    "  rl_cfg=cartpole_ppo_runner_cfg(),\n",
+    "  runner_cls=MjlabOnPolicyRunner,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "K7wqLZR1rnGn"
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## **🚀 Step 3: Train the Agent**\n",
+    "\n",
+    "Now let's train a PPO policy to balance the CartPole!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Hht_hF4trqP2"
+   },
+   "outputs": [],
+   "source": [
+    "!python -m mjlab.scripts.train Mjlab-Cartpole --agent.max-iterations 201 --agent.save-interval 20"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "xCaqPznGrx8H"
+   },
+   "source": [
+    "### **📁 Locate Training Checkpoints**\n",
+    "\n",
+    "After training, checkpoints are saved locally."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "uPnmHYu8r0uY"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import re\n",
+    "from pathlib import Path\n",
+    "\n",
+    "# Find the most recent training run\n",
+    "log_dir = Path(\"/content/mjlab/logs/rsl_rl/cartpole\")\n",
+    "if log_dir.exists():\n",
+    "  runs = sorted(log_dir.glob(\"*\"), key=os.path.getmtime, reverse=True)\n",
+    "  if runs:\n",
+    "    latest_run = runs[0]\n",
+    "    print(f\"✓ Latest training run: {latest_run.name}\\n\")\n",
+    "\n",
+    "    # List checkpoints - sorted by iteration number\n",
+    "    checkpoints = list(latest_run.glob(\"model_*.pt\"))\n",
+    "    if checkpoints:\n",
+    "      # Extract iteration number and sort numerically\n",
+    "      def get_iteration(ckpt):\n",
+    "        match = re.search(r\"model_(\\d+)\\.pt\", ckpt.name)\n",
+    "        return int(match.group(1)) if match else 0\n",
+    "\n",
+    "      checkpoints = sorted(checkpoints, key=get_iteration)\n",
+    "\n",
+    "      print(f\"Found {len(checkpoints)} checkpoints:\")\n",
+    "      for ckpt in checkpoints[-5:]:  # Show last 5\n",
+    "        size_mb = ckpt.stat().st_size / (1024 * 1024)\n",
+    "        iteration = get_iteration(ckpt)\n",
+    "        print(f\"  • {ckpt.name} (iteration {iteration}, {size_mb:.2f} MB)\")\n",
+    "\n",
+    "      # Store the last checkpoint path\n",
+    "      last_checkpoint = str(checkpoints[-1])\n",
+    "      print(f\"\\n💾 Last checkpoint: {last_checkpoint}\")\n",
+    "    else:\n",
+    "      print(\"⚠ No checkpoints found yet\")\n",
+    "  else:\n",
+    "    print(\"⚠ No training runs found\")\n",
+    "else:\n",
+    "  print(\"⚠ Log directory not found. Have you run training yet?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "eWFS9Pw7r2uH"
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## **🎮 Step 4: Visualize the Trained Policy**\n",
+    "\n",
+    "Let's see the trained policy in action!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "78PgHtpfr5sb"
+   },
+   "source": [
+    "### **🌐 Launch Viser API**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "_9tGiFyBr2bW"
+   },
+   "outputs": [],
+   "source": [
+    "import subprocess\n",
+    "import sys\n",
+    "\n",
+    "process = subprocess.Popen(\n",
+    "  [\n",
+    "    \"python\",\n",
+    "    \"-m\",\n",
+    "    \"mjlab.scripts.play\",\n",
+    "    \"Mjlab-Cartpole\",\n",
+    "    \"--checkpoint_file\",\n",
+    "    last_checkpoint,\n",
+    "    \"--num_envs\",\n",
+    "    \"4\",\n",
+    "  ],\n",
+    "  stdout=subprocess.PIPE,\n",
+    "  stderr=subprocess.STDOUT,\n",
+    "  universal_newlines=True,\n",
+    "  bufsize=1,\n",
+    ")\n",
+    "\n",
+    "detected_port = None\n",
+    "\n",
+    "for line in process.stdout:\n",
+    "  print(line, end=\"\")\n",
+    "  sys.stdout.flush()\n",
+    "\n",
+    "  # Extract port number from viser output\n",
+    "  port_match = re.search(r\":(\\d{4})\", line)\n",
+    "  if port_match and \"viser\" in line.lower():\n",
+    "    detected_port = int(port_match.group(1))\n",
+    "    print(\"\\n\" + \"=\" * 34)\n",
+    "    print(f\"✅ Server is running on port {detected_port}!\")\n",
+    "    print(\"=\" * 34)\n",
+    "    break"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XgzJXyBXssZS"
+   },
+   "source": [
+    "### **🖥️ Embed Client as iframe**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ll89QnuSuUxx"
+   },
+   "outputs": [],
+   "source": [
+    "from google.colab import output\n",
+    "\n",
+    "port = detected_port if detected_port else 8081\n",
+    "output.serve_kernel_port_as_iframe(port=port, height=700)"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "include_colab_link": true,
+   "provenance": [],
+   "toc_visible": true
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

mjlab/notebooks/demo.ipynb

@@ -0,0 +1,99 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Use W&B offline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!wandb offline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## **Or** login using an API from your W&B account"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!wandb login"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Now you are set to run the demo!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "AqSj5JwRz_Lw",
+    "outputId": "4c299831-6279-430e-ca8e-f2a58e8f4720"
+   },
+   "outputs": [],
+   "source": "import subprocess\nimport sys\n\nprocess = subprocess.Popen(\n  [\n    \"uvx\",\n    \"--refresh\",\n    \"--from\",\n    \"mjlab==1.1.0\",\n    \"demo\",\n  ],\n  stdout=subprocess.PIPE,\n  stderr=subprocess.STDOUT,\n  universal_newlines=True,\n  bufsize=1,\n)\n\nfor line in process.stdout:\n  print(line, end=\"\")\n  sys.stdout.flush()\n\n  if \"serving\" in line.lower() or \"running on\" in line.lower() or \"8081\" in line:\n    print(\"\\n\" + \"=\" * 50)\n    print(\"✅ Server is running! Execute the next cell to view.\")\n    print(\"=\" * 50)\n    break"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 421
+    },
+    "id": "i7xycbkt1MFB",
+    "outputId": "7fae85cc-1678-4f59-f700-688fbdc6fb84"
+   },
+   "outputs": [],
+   "source": [
+    "from google.colab import output\n",
+    "\n",
+    "output.serve_kernel_port_as_iframe(8081)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "1IhDzu_i1uQt"
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

mjlab/scripts/fix_mjpython_macos.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# Fix mjpython on macOS by creating a symlink to libpython.
+# This is needed because mjpython expects libpython in .venv/lib/
+
+set -e
+
+VENV_DIR=".venv"
+
+if [[ "$(uname)" != "Darwin" ]]; then
+    echo "This script is only needed on macOS."
+    exit 0
+fi
+
+if [[ ! -d "$VENV_DIR" ]]; then
+    echo "Error: .venv directory not found. Run 'uv sync' first."
+    exit 1
+fi
+
+# Get Python version and prefix from the venv.
+PYTHON_VERSION=$("$VENV_DIR/bin/python" -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')")
+PYTHON_PREFIX=$("$VENV_DIR/bin/python" -c "import sys; print(sys.base_prefix)")
+DYLIB_NAME="libpython${PYTHON_VERSION}.dylib"
+
+# Find the dylib in the Python installation.
+DYLIB_PATH="$PYTHON_PREFIX/lib/$DYLIB_NAME"
+
+if [[ ! -f "$DYLIB_PATH" ]]; then
+    echo "Error: Could not find $DYLIB_PATH"
+    exit 1
+fi
+
+# Create the symlink.
+mkdir -p "$VENV_DIR/lib"
+ln -sf "$DYLIB_PATH" "$VENV_DIR/lib/$DYLIB_NAME"
+
+echo "Created symlink: $VENV_DIR/lib/$DYLIB_NAME -> $DYLIB_PATH"

mjlab/scripts/run_docker.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env sh
+#
+# Injects useful arguments for running mjlab in docker.
+# See docs/source/installation.rst for usage.
+#
+# Patterned after the uv-in-docker example:
+# https://github.com/astral-sh/uv-docker-example/blob/5748835918ec293d547bbe0e42df34e140aca1eb/run.sh
+#
+# Key arguments:
+#   --rm                Remove the container after exiting
+#   --runtime=nvidia    Use NVIDIA Container runtime to give GPU access
+#   --gpus all          Expose all GPUs by default
+#   -v .:/app           Mount current directory to /app (code changes don't require rebuild)
+#   -v /app/.venv       Mount venv separately (keeps developer's environment out of container)
+#   -p 8080:8080        Publish port 8080 for viewing mjlab web interface on the host
+#   -it (conditional)   Launch in interactive mode if running in a terminal
+#                       (Note: if running training, there's a blocking wandb prompt before training begins)
+#   docker build        Build and launch the image (tag matches the Makefile)
+#   "$@"                Forward all arguments to the docker image
+
+
+if [ -t 1 ]; then
+    INTERACTIVE="-it"
+else
+    INTERACTIVE=""
+fi
+
+docker run \
+    --rm \
+    --runtime=nvidia \
+    --gpus all \
+    --volume .:/app \
+    --volume /app/.venv \
+    --publish 8080:8080 \
+    $INTERACTIVE \
+    $(docker build -qt mjlab .) \
+    "$@"

mjlab/tests/conftest.py

@@ -0,0 +1,174 @@
+"""Shared test fixtures and utilities."""
+
+import os
+from pathlib import Path
+
+import mujoco
+import pytest
+import torch
+import warp as wp
+
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+
+@pytest.fixture(scope="session", autouse=True)
+def configure_test_environment():
+  """Configure test environment settings automatically for all tests."""
+  wp.config.quiet = True
+
+
+def get_test_device() -> str:
+  """Get device for testing, preferring CUDA if available.
+
+  Can be overridden with FORCE_CPU=1 environment variable to test
+  CPU-only behavior on GPU machines.
+  """
+  if os.environ.get("FORCE_CPU") == "1":
+    return "cpu"
+  return "cuda" if torch.cuda.is_available() else "cpu"
+
+
+@pytest.fixture
+def fixtures_dir() -> Path:
+  """Path to test fixtures directory."""
+  return Path(__file__).parent / "fixtures"
+
+
+def load_fixture_xml(fixture_name: str) -> str:
+  """Load XML content from fixture file.
+
+  Args:
+    fixture_name: Name of the fixture file (without .xml extension) or full path.
+
+  Returns:
+    XML content as string.
+  """
+  fixtures_path = Path(__file__).parent / "fixtures"
+  if not fixture_name.endswith(".xml"):
+    fixture_name = f"{fixture_name}.xml"
+  fixture_file = fixtures_path / fixture_name
+  return fixture_file.read_text()
+
+
+def create_entity_with_actuator(xml_string: str, actuator_cfg):
+  """Create entity with actuator from XML string.
+
+  Args:
+    xml_string: MuJoCo XML model string.
+    actuator_cfg: Actuator configuration.
+
+  Returns:
+    Entity instance.
+  """
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(xml_string),
+    articulation=EntityArticulationInfoCfg(actuators=(actuator_cfg,)),
+  )
+  return Entity(cfg)
+
+
+def create_entity_from_fixture(fixture_name: str, actuator_cfg=None):
+  """Create entity from fixture file.
+
+  Args:
+    fixture_name: Name of the fixture file (without .xml extension).
+    actuator_cfg: Optional actuator configuration.
+
+  Returns:
+    Entity instance.
+  """
+  xml_string = load_fixture_xml(fixture_name)
+  if actuator_cfg is not None:
+    return create_entity_with_actuator(xml_string, actuator_cfg)
+  cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(xml_string))
+  return Entity(cfg)
+
+
+def initialize_entity(entity: Entity, device: str, num_envs: int = 1):
+  """Initialize entity with simulation.
+
+  Args:
+    entity: Entity to initialize.
+    device: Device to use ("cpu" or "cuda").
+    num_envs: Number of environments.
+
+  Returns:
+    Tuple of (entity, simulation).
+  """
+  model = entity.compile()
+  sim_cfg = SimulationCfg()
+  sim = Simulation(num_envs=num_envs, cfg=sim_cfg, model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+  return entity, sim
+
+
+# =============================================================================
+# XML Fixture Loaders
+# =============================================================================
+
+
+@pytest.fixture
+def fixed_base_box_xml() -> str:
+  """Load fixed base box XML fixture."""
+  return load_fixture_xml("fixed_base_box")
+
+
+@pytest.fixture
+def floating_base_box_xml() -> str:
+  """Load floating base box XML fixture."""
+  return load_fixture_xml("floating_base_box")
+
+
+@pytest.fixture
+def fixed_base_articulated_xml() -> str:
+  """Load fixed base articulated robot XML fixture."""
+  return load_fixture_xml("fixed_base_articulated")
+
+
+@pytest.fixture
+def floating_base_articulated_xml() -> str:
+  """Load floating base articulated robot XML fixture."""
+  return load_fixture_xml("floating_base_articulated")
+
+
+@pytest.fixture
+def biped_xml() -> str:
+  """Load biped robot XML fixture with ground plane."""
+  return load_fixture_xml("biped")
+
+
+@pytest.fixture
+def robot_with_floor_xml() -> str:
+  """XML for a floating body above a ground plane."""
+  return """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1" pos="0 0 0"/>
+        <body name="base" pos="0 0 2">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="5.0"/>
+          <site name="base_site" pos="0 0 -0.1"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+
+@pytest.fixture
+def falling_box_xml() -> str:
+  """XML for a box that can fall onto a ground plane."""
+  return """
+    <mujoco>
+      <worldbody>
+        <body name="ground" pos="0 0 0">
+          <geom name="ground_geom" type="plane" size="5 5 0.1" rgba="0.5 0.5 0.5 1"/>
+        </body>
+        <body name="box" pos="0 0 0.5">
+          <freejoint name="box_joint"/>
+          <geom name="box_geom" type="box" size="0.1 0.1 0.1" rgba="0.8 0.3 0.3 1"
+            mass="1.0"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """

mjlab/tests/smoke_test.py

@@ -0,0 +1,36 @@
+"""Smoke test for mjlab package."""
+
+import io
+import sys
+import warnings
+from contextlib import redirect_stderr, redirect_stdout
+
+try:
+  import pytest
+except ModuleNotFoundError:
+  pytest = None  # type: ignore[assignment]
+
+
+@pytest.mark.slow if pytest else lambda f: f
+def test_basic_functionality() -> None:
+  """Test that mjlab can create and close an environment."""
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+  from mjlab.tasks.velocity.config.go1.env_cfgs import unitree_go1_flat_env_cfg
+
+  # Suppress env spam.
+  with warnings.catch_warnings():
+    warnings.simplefilter("ignore")
+    with redirect_stdout(io.StringIO()), redirect_stderr(io.StringIO()):
+      env = ManagerBasedRlEnv(unitree_go1_flat_env_cfg(), device="cpu")
+      assert env.sim.data.time == 0.0
+      env.close()
+
+
+if __name__ == "__main__":
+  try:
+    test_basic_functionality()
+    print("✓ Smoke test passed!")
+    sys.exit(0)
+  except Exception as e:
+    print(f"✗ Smoke test failed: {e}")
+    sys.exit(1)

mjlab/tests/test_action_manager.py

@@ -0,0 +1,118 @@
+"""Tests for action manager functionality."""
+
+from unittest.mock import Mock
+
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.managers.action_manager import ActionManager
+
+
+@pytest.fixture
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+def _make_mock_action_term(action_dim: int):
+  """Create a mock action term factory."""
+
+  def factory(env):
+    term = Mock()
+    term.action_dim = action_dim
+    term.raw_action = torch.zeros(env.num_envs, action_dim, device=env.device)
+    term.process_actions = Mock()
+    term.apply_actions = Mock()
+    term.reset = Mock()
+    return term
+
+  return factory
+
+
+@pytest.fixture
+def mock_env(device):
+  """Create a mock environment for testing."""
+  env = Mock()
+  env.num_envs = 4
+  env.device = device
+  return env
+
+
+@pytest.fixture
+def action_term_cfg():
+  """Create a simple action term config."""
+  cfg = Mock()
+  cfg.build = _make_mock_action_term(action_dim=3)
+  cfg.entity_name = "robot"
+  return cfg
+
+
+def test_action_history_tracking(mock_env, action_term_cfg, device):
+  """Test that action, prev_action, and prev_prev_action track history correctly."""
+  manager = ActionManager({"action": action_term_cfg}, mock_env)
+
+  # Initial state: all zeros.
+  assert torch.all(manager.action == 0.0)
+  assert torch.all(manager.prev_action == 0.0)
+  assert torch.all(manager.prev_prev_action == 0.0)
+
+  # Process actions and verify history shifts correctly.
+  actions = [
+    torch.tensor([[float(i)] * 3] * mock_env.num_envs, device=device)
+    for i in range(1, 5)
+  ]
+
+  manager.process_action(actions[0])
+  assert torch.allclose(manager.action, actions[0])
+  assert torch.all(manager.prev_action == 0.0)
+  assert torch.all(manager.prev_prev_action == 0.0)
+
+  manager.process_action(actions[1])
+  assert torch.allclose(manager.action, actions[1])
+  assert torch.allclose(manager.prev_action, actions[0])
+  assert torch.all(manager.prev_prev_action == 0.0)
+
+  manager.process_action(actions[2])
+  assert torch.allclose(manager.action, actions[2])
+  assert torch.allclose(manager.prev_action, actions[1])
+  assert torch.allclose(manager.prev_prev_action, actions[0])
+
+  manager.process_action(actions[3])
+  assert torch.allclose(manager.action, actions[3])
+  assert torch.allclose(manager.prev_action, actions[2])
+  assert torch.allclose(manager.prev_prev_action, actions[1])
+
+
+def test_action_history_reset(mock_env, action_term_cfg, device):
+  """Test that reset clears action history for all or specific environments."""
+  manager = ActionManager({"action": action_term_cfg}, mock_env)
+
+  # Populate history.
+  actions = [
+    torch.tensor([[float(i)] * 3] * mock_env.num_envs, device=device)
+    for i in range(1, 4)
+  ]
+  for a in actions:
+    manager.process_action(a)
+
+  # Partial reset: only envs 0 and 2.
+  manager.reset(env_ids=torch.tensor([0, 2]))
+
+  # Reset envs should be zeros.
+  for env_id in [0, 2]:
+    assert torch.all(manager.action[env_id] == 0.0)
+    assert torch.all(manager.prev_action[env_id] == 0.0)
+    assert torch.all(manager.prev_prev_action[env_id] == 0.0)
+
+  # Non-reset envs should retain history.
+  for env_id in [1, 3]:
+    assert torch.allclose(manager.action[env_id], actions[2][env_id])
+    assert torch.allclose(manager.prev_action[env_id], actions[1][env_id])
+    assert torch.allclose(manager.prev_prev_action[env_id], actions[0][env_id])
+
+  # Full reset.
+  manager.reset()
+  assert torch.all(manager.action == 0.0)
+  assert torch.all(manager.prev_action == 0.0)
+  assert torch.all(manager.prev_prev_action == 0.0)

mjlab/tests/test_actions.py

@@ -0,0 +1,196 @@
+"""Tests for actions."""
+
+from pathlib import Path
+from unittest.mock import Mock
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device, load_fixture_xml
+
+from mjlab.actuator.actuator import TransmissionType
+from mjlab.actuator.builtin_actuator import BuiltinMotorActuatorCfg
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.envs import ManagerBasedRlEnv
+from mjlab.envs.mdp.actions import (
+  JointPositionActionCfg,
+  SiteEffortActionCfg,
+  TendonEffortActionCfg,
+  TendonLengthActionCfg,
+  TendonVelocityActionCfg,
+)
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+
+@pytest.fixture
+def device():
+  return get_test_device()
+
+
+@pytest.fixture
+def fixtures_dir():
+  return Path(__file__).parent / "fixtures"
+
+
+def make_entity(xml_or_path, target_expr, transmission_type, device, from_file=False):
+  """Create and initialize entity."""
+
+  def spec_fn():
+    if from_file:
+      return mujoco.MjSpec.from_file(str(xml_or_path))
+    return mujoco.MjSpec.from_string(xml_or_path)
+
+  cfg = EntityCfg(
+    spec_fn=spec_fn,
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinMotorActuatorCfg(
+          target_names_expr=target_expr,
+          transmission_type=transmission_type,
+          effort_limit=10.0,
+        ),
+      )
+    ),
+  )
+  entity = Entity(cfg)
+  model = entity.compile()
+  sim = Simulation(num_envs=4, cfg=SimulationCfg(), model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+  return entity
+
+
+def make_env(entity, name, device):
+  """Create mock environment."""
+  env = Mock(spec=ManagerBasedRlEnv)
+  env.num_envs = 4
+  env.device = device
+  env.scene = {name: entity}
+  return env
+
+
+def test_base_action_applies_scale_and_offset(fixtures_dir, device):
+  """BaseAction: processed = raw * scale + offset."""
+  entity = make_entity(
+    fixtures_dir / "tendon_finger.xml",
+    ("finger_tendon",),
+    TransmissionType.TENDON,
+    device,
+    from_file=True,
+  )
+  env = make_env(entity, "finger", device)
+
+  cfg = TendonLengthActionCfg(
+    entity_name="finger",
+    actuator_names=("finger_tendon",),
+    scale=2.0,
+    offset=0.5,
+  )
+  action = cfg.build(env)
+
+  raw = torch.tensor([[1.0], [2.0], [3.0], [4.0]], device=device)
+  action.process_actions(raw)
+
+  assert torch.allclose(action._processed_actions, raw * 2.0 + 0.5)
+
+
+def test_base_action_reset_zeros_specific_envs(fixtures_dir, device):
+  """BaseAction.reset() zeros raw_action for specified env_ids only."""
+  entity = make_entity(
+    fixtures_dir / "tendon_finger.xml",
+    ("finger_tendon",),
+    TransmissionType.TENDON,
+    device,
+    from_file=True,
+  )
+  env = make_env(entity, "finger", device)
+
+  cfg = TendonLengthActionCfg(entity_name="finger", actuator_names=("finger_tendon",))
+  action = cfg.build(env)
+
+  action.process_actions(torch.ones(4, 1, device=device))
+  action.reset(env_ids=torch.tensor([0, 2], device=device))
+
+  assert torch.all(action.raw_action[[0, 2]] == 0.0)
+  assert torch.all(action.raw_action[[1, 3]] == 1.0)
+
+
+@pytest.mark.parametrize(
+  "cfg_cls,target_attr,fixture,target_expr,transmission,entity_name",
+  [
+    # Joints.
+    (
+      JointPositionActionCfg,
+      "joint_pos_target",
+      "floating_base_articulated",
+      ("joint.*",),
+      TransmissionType.JOINT,
+      "robot",
+    ),
+    # Tendons.
+    (
+      TendonLengthActionCfg,
+      "tendon_len_target",
+      "tendon_finger.xml",
+      ("finger_tendon",),
+      TransmissionType.TENDON,
+      "finger",
+    ),
+    (
+      TendonVelocityActionCfg,
+      "tendon_vel_target",
+      "tendon_finger.xml",
+      ("finger_tendon",),
+      TransmissionType.TENDON,
+      "finger",
+    ),
+    (
+      TendonEffortActionCfg,
+      "tendon_effort_target",
+      "tendon_finger.xml",
+      ("finger_tendon",),
+      TransmissionType.TENDON,
+      "finger",
+    ),
+    # Sites.
+    (
+      SiteEffortActionCfg,
+      "site_effort_target",
+      "quadcopter.xml",
+      ("rotor_.*",),
+      TransmissionType.SITE,
+      "drone",
+    ),
+  ],
+)
+def test_action_sets_entity_target(
+  fixtures_dir,
+  device,
+  cfg_cls,
+  target_attr,
+  fixture,
+  target_expr,
+  transmission,
+  entity_name,
+):
+  """Each action type writes to correct entity.data field."""
+  if fixture.endswith(".xml"):
+    entity = make_entity(
+      fixtures_dir / fixture, target_expr, transmission, device, from_file=True
+    )
+  else:
+    entity = make_entity(
+      load_fixture_xml(fixture), target_expr, transmission, device, from_file=False
+    )
+
+  env = make_env(entity, entity_name, device)
+  cfg = cfg_cls(entity_name=entity_name, actuator_names=target_expr)
+  action = cfg.build(env)
+
+  target = torch.arange(4 * action.action_dim, device=device, dtype=torch.float32)
+  target = target.reshape(4, action.action_dim) * 0.1
+
+  action.process_actions(target)
+  action.apply_actions()
+
+  entity_target = getattr(entity.data, target_attr)
+  assert torch.allclose(entity_target, target)

mjlab/tests/test_actuator.py

@@ -0,0 +1,86 @@
+"""Tests for actuator module."""
+
+import pytest
+import torch
+from conftest import (
+  create_entity_with_actuator,
+  get_test_device,
+  initialize_entity,
+  load_fixture_xml,
+)
+
+from mjlab.actuator import (
+  BuiltinPositionActuatorCfg,
+  IdealPdActuatorCfg,
+)
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+@pytest.fixture(scope="module")
+def robot_xml():
+  return load_fixture_xml("floating_base_articulated")
+
+
+def test_builtin_pd_actuator_compute(device, robot_xml):
+  """BuiltinPositionActuator writes position targets to ctrl."""
+  actuator_cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint.*",), stiffness=50.0, damping=5.0
+  )
+  entity = create_entity_with_actuator(robot_xml, actuator_cfg)
+  entity, sim = initialize_entity(entity, device)
+
+  entity.set_joint_position_target(torch.tensor([[0.5, -0.3]], device=device))
+  entity.write_data_to_sim()
+
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([0.5, -0.3], device=device))
+
+
+def test_ideal_pd_actuator_compute(device, robot_xml):
+  """IdealPdActuator computes torques via explicit PD control."""
+  actuator_cfg = IdealPdActuatorCfg(
+    target_names_expr=("joint.*",), effort_limit=100.0, stiffness=50.0, damping=5.0
+  )
+  entity = create_entity_with_actuator(robot_xml, actuator_cfg)
+  entity, sim = initialize_entity(entity, device)
+
+  entity.write_joint_state_to_sim(
+    position=torch.tensor([[0.0, 0.0]], device=device),
+    velocity=torch.tensor([[0.0, 0.0]], device=device),
+  )
+
+  entity.set_joint_position_target(torch.tensor([[0.1, -0.1]], device=device))
+  entity.set_joint_velocity_target(torch.tensor([[0.0, 0.0]], device=device))
+  entity.set_joint_effort_target(torch.tensor([[0.0, 0.0]], device=device))
+  entity.write_data_to_sim()
+
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([5.0, -5.0], device=device))
+
+
+def test_targets_cleared_on_reset(device, robot_xml):
+  """Entity.reset() zeros all targets."""
+  actuator_cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint.*",), stiffness=50.0, damping=5.0
+  )
+  entity = create_entity_with_actuator(robot_xml, actuator_cfg)
+  entity, sim = initialize_entity(entity, device)
+
+  entity.set_joint_position_target(torch.tensor([[0.5, -0.3]], device=device))
+  entity.write_data_to_sim()
+
+  assert not torch.allclose(
+    entity.data.joint_pos_target, torch.zeros(1, 2, device=device)
+  )
+
+  entity.reset()
+
+  assert torch.allclose(entity.data.joint_pos_target, torch.zeros(1, 2, device=device))
+  assert torch.allclose(entity.data.joint_vel_target, torch.zeros(1, 2, device=device))
+  assert torch.allclose(
+    entity.data.joint_effort_target, torch.zeros(1, 2, device=device)
+  )

mjlab/tests/test_actuator_builtin_group.py

@@ -0,0 +1,168 @@
+"""Tests for BuiltinActuatorGroup."""
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device, load_fixture_xml
+
+from mjlab.actuator import (
+  BuiltinMotorActuatorCfg,
+  BuiltinPositionActuatorCfg,
+  IdealPdActuatorCfg,
+)
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+ROBOT_XML = load_fixture_xml("floating_base_articulated")
+
+ROBOT_XML_3JOINT = """
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="1.0"/>
+      <body name="link1" pos="0 0 0">
+        <joint name="joint1" type="hinge" axis="0 0 1" range="-1.57 1.57"/>
+        <geom name="link1_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+      <body name="link2" pos="0 0 0">
+        <joint name="joint2" type="hinge" axis="0 0 1" range="-1.57 1.57"/>
+        <geom name="link2_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+      <body name="link3" pos="0 0 0">
+        <joint name="joint3" type="hinge" axis="0 0 1" range="-1.57 1.57"/>
+        <geom name="link3_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+def create_entity(actuator_cfgs, robot_xml=ROBOT_XML):
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(robot_xml),
+    articulation=EntityArticulationInfoCfg(actuators=actuator_cfgs),
+  )
+  return Entity(cfg)
+
+
+def initialize_entity(entity, device, num_envs=1):
+  model = entity.compile()
+  sim_cfg = SimulationCfg()
+  sim = Simulation(num_envs=num_envs, cfg=sim_cfg, model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+  return entity, sim
+
+
+def test_position_actuator_batched(device):
+  """BuiltinPositionActuator writes position targets via batched path."""
+  actuator_cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint.*",), stiffness=50.0, damping=5.0
+  )
+  entity = create_entity((actuator_cfg,))
+  entity, sim = initialize_entity(entity, device)
+
+  entity.set_joint_position_target(torch.tensor([[0.5, -0.3]], device=device))
+  entity.write_data_to_sim()
+
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([0.5, -0.3], device=device))
+
+
+def test_motor_actuator_batched(device):
+  """BuiltinMotorActuator writes effort targets via batched path."""
+  actuator_cfg = BuiltinMotorActuatorCfg(
+    target_names_expr=("joint.*",), effort_limit=100.0
+  )
+  entity = create_entity((actuator_cfg,))
+  entity, sim = initialize_entity(entity, device)
+
+  entity.set_joint_effort_target(torch.tensor([[10.0, -5.0]], device=device))
+  entity.write_data_to_sim()
+
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([10.0, -5.0], device=device))
+
+
+def test_mixed_builtin_actuators(device):
+  """Multiple builtin actuator types can coexist and all use batched path."""
+  position_cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint1",), stiffness=50.0, damping=5.0
+  )
+  motor_cfg = BuiltinMotorActuatorCfg(target_names_expr=("joint2",), effort_limit=100.0)
+  entity = create_entity((position_cfg, motor_cfg))
+  entity, sim = initialize_entity(entity, device)
+
+  entity.set_joint_position_target(torch.tensor([[0.5, 0.0]], device=device))
+  entity.set_joint_effort_target(torch.tensor([[0.0, -3.0]], device=device))
+  entity.write_data_to_sim()
+
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([0.5, -3.0], device=device))
+
+
+def test_builtin_and_custom_actuators(device):
+  """Builtin actuators use batched path, custom actuators use compute()."""
+  builtin_cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint1",), stiffness=50.0, damping=5.0
+  )
+  custom_cfg = IdealPdActuatorCfg(
+    target_names_expr=("joint2",), effort_limit=100.0, stiffness=50.0, damping=5.0
+  )
+  entity = create_entity((builtin_cfg, custom_cfg))
+  entity, sim = initialize_entity(entity, device)
+
+  entity.write_joint_state_to_sim(
+    position=torch.tensor([[0.0, 0.0]], device=device),
+    velocity=torch.tensor([[0.0, 0.0]], device=device),
+  )
+
+  entity.set_joint_position_target(torch.tensor([[0.5, 0.2]], device=device))
+  entity.set_joint_velocity_target(torch.tensor([[0.0, 0.0]], device=device))
+  entity.set_joint_effort_target(torch.tensor([[0.0, 0.0]], device=device))
+  entity.write_data_to_sim()
+
+  ctrl = sim.data.ctrl[0]
+  # joint1: builtin position -> ctrl = 0.5
+  # joint2: ideal pd -> ctrl = kp * (0.2 - 0.0) = 50.0 * 0.2 = 10.0
+  assert torch.allclose(ctrl, torch.tensor([0.5, 10.0], device=device))
+
+
+def test_builtin_group_mismatched_indices(device):
+  """Test that controls are written correctly when actuators use different joints.
+
+  Regression test for ctrl_ids/joint_ids swap bug in BuiltinActuatorGroup.
+  When actuators are added in different order than joints, ctrl_ids != joint_ids.
+  This test verifies controls are written to the correct MuJoCo actuator indices.
+  """
+  # Add actuators in different order than joints.
+  # Actuators: position on joint2, motor on joint1+joint3.
+  # Natural joint order: joint1, joint2, joint3.
+  # MuJoCo actuator IDs (definition order): act0=joint2, act1=joint1, act2=joint3.
+  position_cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint2",), stiffness=50.0, damping=5.0
+  )
+  motor_cfg = BuiltinMotorActuatorCfg(
+    target_names_expr=("joint1", "joint3"), effort_limit=100.0
+  )
+  entity = create_entity((position_cfg, motor_cfg), robot_xml=ROBOT_XML_3JOINT)
+  entity, sim = initialize_entity(entity, device, num_envs=1)
+
+  # Set targets indexed by joint_id: joint1=10.0, joint2=20.0, joint3=30.0
+  entity.set_joint_position_target(torch.tensor([[10.0, 20.0, 30.0]], device=device))
+  entity.set_joint_effort_target(torch.tensor([[100.0, 200.0, 300.0]], device=device))
+  entity.write_data_to_sim()
+
+  # Expected ctrl values in MuJoCo actuator definition order:
+  # ctrl[0] = joint2 position = 20.0 (actuator 0 controls joint2)
+  # ctrl[1] = joint1 effort = 100.0 (actuator 1 controls joint1)
+  # ctrl[2] = joint3 effort = 300.0 (actuator 2 controls joint3)
+  assert torch.allclose(
+    sim.data.ctrl[0], torch.tensor([20.0, 100.0, 300.0], device=device)
+  ), f"Got {sim.data.ctrl[0]}, expected [20.0, 100.0, 300.0]"