testing

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "ros.distro": "humble"
+}

README.md

@@ -1,13 +1,289 @@
----
-title: IsaacLab Arena Envs
-emoji: 🤖
-colorFrom: blue
-colorTo: purple
-sdk: static
-pinned: false
----
-
 # IsaacLab Arena Environments
 
-Environment configurations for IsaacLab Arena integration with LeRobot.
+[![Hugging Face](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-EnvHub-blue)](https://huggingface.co/nvkartik/isaaclab-arena-envs)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+GPU-accelerated simulation environments for robotics learning, compatible with [LeRobot](https://github.com/huggingface/lerobot) and the [EnvHub](https://huggingface.co/docs/lerobot/envhub) ecosystem.
+
+## Quick Start
+
+Load the environment directly from Hugging Face Hub:
+
+```python
+from lerobot.envs.factory import make_env
+
+# Load IsaacLab Arena environment
+envs_dict = make_env(
+    "nvkartik/isaaclab-arena-envs",
+    n_envs=4,
+    trust_remote_code=True
+)
+
+# Access the environment
+env = envs_dict["gr1_microwave"][0]
+
+# Run an episode
+obs, info = env.reset()
+for _ in range(300):
+    action = env.action_space.sample()
+    obs, reward, terminated, truncated, info = env.step(action)
+    if terminated.any() or truncated.any():
+        break
+
+env.close()
+```
+
+## Installation
+
+### Prerequisites
+
+Before using this environment, you must install IsaacSim, IsaacLab, and IsaacLab-Arena:
+
+```bash
+# 1. Install LeRobot (if not already installed)
+pip install lerobot
+
+# 2. Install Isaac Sim 5.1.0
+uv pip install "isaacsim[all,extscache]==5.1.0" --extra-index-url https://pypi.nvidia.com
+export ACCEPT_EULA=Y
+export PRIVACY_CONSENT=Y
+
+# 3. Install Isaac Lab 2.3.0
+git clone https://github.com/isaac-sim/IsaacLab.git
+cd IsaacLab
+git checkout v2.3.0
+./isaaclab.sh -i
+cd ..
+
+# 4. Install IsaacLab Arena
+git clone https://github.com/isaac-sim/IsaacLab-Arena.git
+cd IsaacLab-Arena
+uv pip install -e .
+cd ..
+
+# 5. Install additional dependencies
+uv pip install qpsolvers==4.8.1 onnxruntime lightwheel-sdk vuer[all]
+uv pip install numpy==1.26.0 lxml==4.9.4 packaging==23.2
+```
+
+### Using with EnvHub
+
+Once the prerequisites are installed, you can load environments directly from the Hub:
+
+```python
+from lerobot.envs.factory import make_env
+
+envs_dict = make_env("nvkartik/isaaclab-arena-envs", n_envs=4, trust_remote_code=True)
+```
+
+## Available Environments
+
+| Alias | Description | Robot | Action Dim |
+|-------|-------------|-------|------------|
+| `gr1_microwave` | Open a microwave door | GR1 | 36 |
+| `galileo_pnp` | Pick and place task | Galileo | - |
+| `g1_locomanip_pnp` | Locomotion + manipulation | G1 | - |
+| `kitchen_pnp` | Kitchen pick and place | - | - |
+| `press_button` | Button pressing task | - | - |
+
+## Configuration
+
+Configuration is loaded from `configs/config.yaml`. Key options:
+
+```yaml
+# Environment Selection
+environment: gr1_microwave
+task: "Reach out to the microwave and open it."
+
+# Episode Configuration
+episode_length: 300
+
+# Observation Configuration
+state_keys: robot_joint_pos
+camera_keys: robot_pov_cam_rgb
+state_dim: 54
+action_dim: 36
+
+# Simulation Settings
+headless: true
+enable_cameras: false
+device: "cuda:0"
+
+# Robot Configuration
+embodiment: gr1_pink
+object: power_drill
+```
+
+### Overriding Configuration
+
+You can modify the `configs/config.yaml` file to change environment settings:
+
+```yaml
+# Enable video recording
+enable_cameras: true
+headless: true
+
+# Different robot/task
+environment: galileo_pnp
+embodiment: galileo
+```
+
+## Observation & Action Spaces
+
+### Observations
+
+The environment returns dictionary observations:
+
+```python
+obs, info = env.reset()
+# obs["policy"] contains state observations (robot_joint_pos, etc.)
+# obs["camera_obs"] contains camera images (when enable_cameras=True)
+```
+
+### Actions
+
+Actions are continuous joint position targets:
+
+```python
+# Default: 36-dimensional for GR1 robot
+action = env.action_space.sample()  # shape: (n_envs, 36)
+```
+
+## Video Recording
+
+To record videos during evaluation:
+
+1. Enable cameras in `config.yaml`:
+   ```yaml
+   enable_cameras: true
+   headless: true
+   ```
+
+2. Use gymnasium's RecordVideo wrapper:
+   ```python
+   from gymnasium.wrappers import RecordVideo
+
+   env = envs_dict["gr1_microwave"][0]
+   env = RecordVideo(env, video_folder="./videos")
+   ```
+
+## Integration with LeRobot
+
+### Policy Evaluation
+
+```bash
+python -m lerobot.scripts.eval \
+    --policy.path=outputs/train/my_policy/checkpoints/last/pretrained_model \
+    --env.type=hub \
+    --env.hub_id=nvkartik/isaaclab-arena-envs \
+    --env.trust_remote_code=true \
+    --eval.n_episodes=10
+```
+
+### Training
+
+```bash
+python -m lerobot.scripts.train \
+    --policy.type=diffusion \
+    --env.type=hub \
+    --env.hub_id=nvkartik/isaaclab-arena-envs \
+    --env.trust_remote_code=true \
+    --dataset.repo_id=my_org/my_dataset
+```
+
+## Repository Structure
+
+```
+isaaclab-arena-envs/
+├── env.py                 # Main environment definition (EnvHub entry point)
+├── configs/
+│   └── config.yaml        # Environment configuration
+├── requirements.txt       # Python dependencies
+├── pyproject.toml         # Package metadata
+└── README.md              # This file
+```
+
+## Development
+
+### Local Testing
+
+```python
+# Test locally without Hub
+from env import make_env
+
+envs_dict = make_env(n_envs=2)
+env = envs_dict["gr1_microwave"][0]
+obs, info = env.reset()
+print(f"Observation space: {env.observation_space}")
+print(f"Action space: {env.action_space}")
+env.close()
+```
+
+### Uploading to Hub
+
+```bash
+# Install huggingface_hub
+pip install huggingface_hub
+
+# Login
+huggingface-cli login
+
+# Create and upload
+huggingface-cli repo create isaaclab-arena-envs --type model
+git init
+git add .
+git commit -m "Initial IsaacLab Arena environment"
+git remote add origin https://huggingface.co/nvkartik/isaaclab-arena-envs
+git push -u origin main
+```
+
+## Troubleshooting
+
+### "Module not found" errors
+
+Ensure IsaacSim, IsaacLab, and IsaacLab-Arena are properly installed:
+
+```bash
+python -c "import isaacsim; print('IsaacSim OK')"
+python -c "import isaaclab; print('IsaacLab OK')"
+python -c "import isaaclab_arena; print('IsaacLab-Arena OK')"
+```
+
+### CUDA/GPU issues
+
+- Ensure you have a compatible NVIDIA GPU (RTX 2070+ recommended)
+- Check CUDA installation: `nvidia-smi`
+- Set device in config: `device: "cuda:0"`
+
+### Headless mode issues
+
+For remote/cluster execution, ensure:
+```yaml
+headless: true
+enable_cameras: true  # if you need video recording
+```
+
+## License
+
+Apache 2.0 License. See [LICENSE](LICENSE) for details.
+
+## Citations
+
+If you use this environment in your research, please cite:
+
+```bibtex
+@software{isaaclab_arena_envs,
+  title = {IsaacLab Arena Environments for LeRobot},
+  author = {Sachdev, Kartik},
+  year = {2025},
+  url = {https://huggingface.co/nvkartik/isaaclab-arena-envs}
+}
+```
+
+## Related Links
+
+- [LeRobot](https://github.com/huggingface/lerobot) - Open-source robotics learning library
+- [EnvHub Documentation](https://huggingface.co/docs/lerobot/envhub) - LeRobot environment hub
+- [IsaacLab](https://github.com/isaac-sim/IsaacLab) - NVIDIA's robot learning framework
+- [IsaacLab Arena](https://github.com/isaac-sim/IsaacLab-Arena) - Community environments for IsaacLab
 

__init__.py

@@ -1,13 +1,16 @@
-# Copyright (c) 2025, LeRobot Project Developers.
-# All rights reserved.
-#
-# SPDX-License-Identifier: Apache-2.0
-"""
-LeRobot Arena Hub - IsaacLab Arena environment integrations.
+"""IsaacLab Arena EnvHub Environment.
+
+This package provides an EnvHub-compatible environment for IsaacLab Arena integration
+with LeRobot. Load it from the Hugging Face Hub with:
 
-This module provides make_env functions for various IsaacLab Arena tasks.
+    from lerobot.envs.factory import make_env
+    envs_dict = make_env("nvkartik/isaaclab-arena-envs", n_envs=4, trust_remote_code=True)
+
+See README.md for complete documentation and installation instructions.
 """
 
-from lerobot.envs.arena_hub.envs import microwave_g1
+from .env import make_env
+
+__all__ = ["make_env"]
+__version__ = "0.1.0"
 
-__all__ = ["microwave_g1"]

configs/configs/config.yaml

@@ -0,0 +1,98 @@
+# IsaacLab Arena EnvHub Configuration
+#
+# This file configures the IsaacLab Arena environment for EnvHub usage.
+# All fields have sensible defaults - only specify what you need to override.
+#
+# Usage:
+#   from lerobot.envs.factory import make_env
+#   envs_dict = make_env("nvkartik/isaaclab-arena-envs", n_envs=4, trust_remote_code=True)
+
+# ============================================================================
+# Environment Selection
+# ============================================================================
+# Available aliases:
+#   - gr1_microwave: GR1 robot opening a microwave
+#   - galileo_pnp: Galileo pick and place task
+#   - g1_locomanip_pnp: G1 locomotion + manipulation pick and place
+#   - kitchen_pnp: Kitchen environment pick and place
+#   - press_button: Button pressing task
+#
+# Or use full module path: module.path.ClassName
+environment: gr1_microwave
+
+# Task description (used for policy conditioning, auto-generated if not provided)
+task: "Reach out to the microwave and open it."
+
+# ============================================================================
+# Episode Configuration
+# ============================================================================
+episode_length: 300
+
+# ============================================================================
+# Observation Configuration
+# ============================================================================
+# State observation keys (comma-separated for multiple)
+# Available keys depend on environment, common ones:
+#   - robot_joint_pos: Robot joint positions
+#   - left_eef_pos, right_eef_pos: End effector positions
+state_keys: robot_joint_pos
+
+# Camera observation keys (comma-separated for multiple)
+# Available keys depend on environment, common ones:
+#   - robot_pov_cam_rgb: Robot's point-of-view camera
+#   - front_cam_rgb: Front-facing camera
+camera_keys: robot_pov_cam_rgb
+
+# Dimension configuration (must match environment)
+state_dim: 54
+action_dim: 36
+
+# Camera resolution (when enable_cameras=true)
+camera_height: 512
+camera_width: 512
+
+# ============================================================================
+# Simulation Settings
+# ============================================================================
+# Run without GUI (required for remote/cluster execution)
+headless: true
+
+# Enable camera rendering (required for video recording)
+# Note: Enabling cameras has performance impact
+enable_cameras: false
+
+# CUDA device for simulation
+device: "cuda:0"
+
+# Disable Fabric for debugging (slower but more compatible)
+disable_fabric: false
+
+# ============================================================================
+# Robot Configuration
+# ============================================================================
+# Robot embodiment to use
+# Available: gr1_pink, galileo, g1, etc.
+embodiment: gr1_pink
+
+# Object to interact with (environment-specific)
+object: power_drill
+
+# Enable mimic mode for teleoperation
+mimic: false
+
+# Teleoperation device (optional)
+teleop_device: null
+
+# ============================================================================
+# Reproducibility & Advanced
+# ============================================================================
+seed: 42
+
+# Enable Pinocchio for inverse kinematics
+enable_pinocchio: true
+
+# Video recording settings (when enable_cameras=true)
+video: false
+video_length: 100
+video_interval: 200
+

env.py

@@ -0,0 +1,538 @@
+"""IsaacLab Arena EnvHub Environment.
+
+This module provides an EnvHub-compatible environment for IsaacLab Arena integration.
+Load it from the Hugging Face Hub with:
+
+    from lerobot.envs.factory import make_env
+    envs_dict = make_env("nvkartik/isaaclab-arena-envs", n_envs=4, trust_remote_code=True)
+
+Or use locally during development:
+
+    from env import make_env
+    envs_dict = make_env(n_envs=4)
+
+Configuration is loaded from configs/config.yaml.
+See README.md for full documentation.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import logging
+import os
+from pathlib import Path
+from typing import Any
+
+import gymnasium as gym
+import numpy as np
+import torch
+import yaml
+
+# Module path for environment class resolution
+ISAACLAB_ARENA_ENV_MODULE = os.environ.get("ISAACLAB_ARENA_ENV_MODULE", "isaaclab_arena_environments")
+
+# Environment aliases for common configurations
+ENVIRONMENT_ALIASES: dict[str, str] = {
+    "gr1_microwave": (
+        f"{ISAACLAB_ARENA_ENV_MODULE}.gr1_open_microwave_environment.Gr1OpenMicrowaveEnvironment"
+    ),
+    "galileo_pnp": (
+        f"{ISAACLAB_ARENA_ENV_MODULE}.galileo_pick_and_place_environment.GalileoPickAndPlaceEnvironment"
+    ),
+    "g1_locomanip_pnp": (
+        f"{ISAACLAB_ARENA_ENV_MODULE}"
+        ".galileo_g1_locomanip_pick_and_place_environment"
+        ".GalileoG1LocomanipPickAndPlaceEnvironment"
+    ),
+    "kitchen_pnp": (
+        f"{ISAACLAB_ARENA_ENV_MODULE}.kitchen_pick_and_place_environment.KitchenPickAndPlaceEnvironment"
+    ),
+    "press_button": (f"{ISAACLAB_ARENA_ENV_MODULE}.press_button_environment.PressButtonEnvironment"),
+}
+
+# Default configuration values
+DEFAULT_CONFIG: dict[str, Any] = {
+    "environment": "gr1_microwave",
+    "task": None,  # Auto-generated if not provided
+    "episode_length": 300,
+    "num_envs": 1,
+    "state_keys": "robot_joint_pos",
+    "camera_keys": "robot_pov_cam_rgb",
+    "state_dim": 54,
+    "action_dim": 36,
+    "headless": True,
+    "enable_cameras": False,
+    "device": "cuda:0",
+    "embodiment": "gr1_pink",
+    "object": "power_drill",
+    "seed": 42,
+    "enable_pinocchio": True,
+    "disable_fabric": False,
+    "mimic": False,
+    "teleop_device": None,
+    "camera_height": 512,
+    "camera_width": 512,
+    "video": False,
+    "video_length": 100,
+    "video_interval": 200,
+}
+
+
+def resolve_environment_alias(environment: str) -> str:
+    """Resolve an environment alias to its full module path."""
+    return ENVIRONMENT_ALIASES.get(environment, environment)
+
+
+class IsaacLabVectorEnvWrapper:
+    """Wrapper adapting IsaacLab batched GPU env to VectorEnv interface.
+
+    IsaacLab handles vectorization internally on GPU, unlike gym's
+    SyncVectorEnv/AsyncVectorEnv. This provides the expected interface
+    for LeRobot evaluation.
+
+    Video Recording:
+        Supports gymnasium.wrappers.RecordVideo (IsaacLab native approach).
+        Requires enable_cameras=True in config when running headless.
+        See: isaac-sim.github.io/IsaacLab/main/source/how-to/record_video.html
+    """
+
+    metadata = {"render_modes": ["rgb_array"], "render_fps": 30}
+
+    def __init__(
+        self,
+        env,
+        episode_length: int = 500,
+        task: str | None = None,
+        render_mode: str | None = "rgb_array",
+        simulation_app=None,
+    ):
+        self._env = env
+        self._num_envs = env.num_envs
+        self._episode_length = episode_length
+        self._closed = False
+        self.render_mode = render_mode
+        self._simulation_app = simulation_app
+
+        self.observation_space = env.observation_space
+        self.action_space = env.action_space
+        self.task = task
+
+        # Use env metadata if available
+        if hasattr(env, "metadata") and env.metadata:
+            self.metadata = {**self.metadata, **env.metadata}
+
+    @property
+    def unwrapped(self):
+        return self
+
+    @property
+    def num_envs(self) -> int:
+        return self._num_envs
+
+    @property
+    def _max_episode_steps(self) -> int:
+        return self._episode_length
+
+    @property
+    def device(self) -> str:
+        return getattr(self._env, "device", "cpu")
+
+    def reset(
+        self,
+        *,
+        seed: int | list[int] | None = None,
+        options: dict[str, Any] | None = None,
+    ) -> tuple[dict[str, Any], dict[str, Any]]:
+        """Reset all environments."""
+        # IsaacLab expects a single seed
+        if isinstance(seed, (list, tuple, range)):
+            seed = seed[0] if len(seed) > 0 else None
+
+        obs, info = self._env.reset(seed=seed, options=options)
+
+        if "final_info" not in info:
+            info["final_info"] = {"is_success": np.zeros(self._num_envs, dtype=bool)}
+
+        return obs, info
+
+    def step(
+        self, actions: np.ndarray | torch.Tensor
+    ) -> tuple[dict[str, Any], np.ndarray, np.ndarray, np.ndarray, dict[str, Any]]:
+        """Step all environments."""
+        if isinstance(actions, np.ndarray):
+            actions = torch.from_numpy(actions).to(self._env.device)
+
+        obs, reward, terminated, truncated, info = self._env.step(actions)
+
+        # Convert to numpy for gym compatibility
+        reward = reward.cpu().numpy().astype(np.float32)
+        terminated = terminated.cpu().numpy().astype(bool)
+        truncated = truncated.cpu().numpy().astype(bool)
+
+        # Extract success status
+        is_success = self._get_success(terminated, truncated)
+        info["final_info"] = {"is_success": is_success}
+
+        return obs, reward, terminated, truncated, info
+
+    def _get_success(self, terminated: np.ndarray, truncated: np.ndarray) -> np.ndarray:
+        """Extract per-environment success status from termination manager."""
+        is_success = np.zeros(self._num_envs, dtype=bool)
+
+        term_manager = self._env.termination_manager
+        success_tensor = term_manager.get_term("success")
+        if isinstance(success_tensor, torch.Tensor):
+            is_success = success_tensor.cpu().numpy().astype(bool)
+        else:
+            is_success = np.array(success_tensor, dtype=bool)
+
+        return is_success & (terminated | truncated)
+
+    def call(self, method_name: str, *args, **kwargs) -> list[Any]:
+        """Call a method on the underlying environment(s)."""
+        if method_name == "_max_episode_steps":
+            return [self._episode_length] * self._num_envs
+        if method_name == "task":
+            return [self.task] * self._num_envs
+        if method_name == "render":
+            return self.render_all()
+
+        if hasattr(self._env, method_name):
+            attr = getattr(self._env, method_name)
+            result = attr(*args, **kwargs) if callable(attr) else attr
+            if isinstance(result, list):
+                return result
+            return [result] * self._num_envs
+
+        raise AttributeError(f"Environment has no method/attribute '{method_name}'")
+
+    def render_all(self) -> list[np.ndarray]:
+        """Render all environments and return list of frames.
+
+        Public method for LeRobot eval video recording.
+        Returns a list of RGB frames, one per environment.
+        """
+        frames = self.render()
+        if frames is None:
+            placeholder = np.zeros((480, 640, 3), dtype=np.uint8)
+            return [placeholder] * self._num_envs
+
+        if frames.ndim == 3:  # Single frame (H, W, C)
+            return [frames] * self._num_envs
+        if frames.ndim == 4:  # Batch (N, H, W, C)
+            return [frames[i] for i in range(min(len(frames), self._num_envs))]
+
+        placeholder = np.zeros((480, 640, 3), dtype=np.uint8)
+        return [placeholder] * self._num_envs
+
+    def render(self) -> np.ndarray | None:
+        """Render the environment (gymnasium RecordVideo compatible).
+
+        Returns rgb_array for video recording per IsaacLab native approach.
+        Requires enable_cameras=True in config when running headless.
+        """
+        if self.render_mode != "rgb_array":
+            return None
+
+        frames = self._env.render() if hasattr(self._env, "render") else None
+        if frames is None:
+            return None
+
+        if isinstance(frames, torch.Tensor):
+            frames = frames.cpu().numpy()
+
+        # Return first env frame for RecordVideo compatibility
+        if frames.ndim == 4:
+            return frames[0]
+        return frames
+
+    def close(self) -> None:
+        """Close the environment and release resources."""
+        if not self._closed:
+            logging.info("Closing IsaacLab Arena environment...")
+            self._env.close()
+            if self._simulation_app is not None:
+                self._simulation_app.app.close()
+            self._closed = True
+            logging.info("Environment closed")
+
+    @property
+    def envs(self) -> list[IsaacLabVectorEnvWrapper]:
+        """Return list of sub-environments for VectorEnv compatibility."""
+        return [self] * self._num_envs
+
+    def __del__(self):
+        self.close()
+
+
+def _validate_env_config(
+    env,
+    state_keys: tuple[str, ...],
+    camera_keys: tuple[str, ...],
+    cfg_state_dim: int,
+    cfg_action_dim: int,
+) -> None:
+    """Validate observation keys and dimensions against IsaacLab managers."""
+    obs_manager = env.observation_manager
+    active_terms = obs_manager.active_terms
+    policy_terms = set(active_terms.get("policy", []))
+    camera_terms = set(active_terms.get("camera_obs", []))
+
+    # Validate keys exist
+    missing_state = [k for k in state_keys if k not in policy_terms]
+    if missing_state:
+        raise ValueError(f"Invalid state_keys: {missing_state}. Available: {sorted(policy_terms)}")
+
+    missing_cam = [k for k in camera_keys if k not in camera_terms]
+    if missing_cam:
+        raise ValueError(f"Invalid camera_keys: {missing_cam}. Available: {sorted(camera_terms)}")
+
+    # Validate dimensions
+    env_action_dim = env.action_space.shape[-1]
+    if cfg_action_dim != env_action_dim:
+        raise ValueError(f"action_dim mismatch: config={cfg_action_dim}, env={env_action_dim}")
+
+    # Compute expected state dimension
+    policy_dims = obs_manager.group_obs_dim.get("policy", [])
+    policy_names = active_terms.get("policy", [])
+    term_dims = dict(zip(policy_names, policy_dims, strict=False))
+
+    expected_state_dim = 0
+    for key in state_keys:
+        if key in term_dims:
+            shape = term_dims[key]
+            dim = 1
+            for s in shape if isinstance(shape, (tuple, list)) else [shape]:
+                dim *= s
+            expected_state_dim += dim
+
+    if cfg_state_dim != expected_state_dim:
+        raise ValueError(
+            f"state_dim mismatch: config={cfg_state_dim}, "
+            f"computed={expected_state_dim}. "
+            f"Term dims: {term_dims}"
+        )
+
+    logging.info(f"Validated: state_keys={state_keys}, camera_keys={camera_keys}")
+
+
+def _find_config_file(config_path: str | Path | None = None) -> Path | None:
+    """Find the config.yaml file in standard locations.
+
+    Search order:
+    1. Explicit config_path if provided
+    2. configs/config.yaml relative to this module
+    3. config.yaml relative to this module
+    4. ISAACLAB_ARENA_CONFIG_PATH environment variable
+    """
+    if config_path is not None:
+        path = Path(config_path)
+        if path.exists():
+            return path
+
+    # Get the directory containing this module
+    module_dir = Path(__file__).parent
+
+    # Search in standard locations
+    search_paths = [
+        module_dir / "configs" / "config.yaml",
+        module_dir / "config.yaml",
+        Path("configs/config.yaml"),
+        Path("config.yaml"),
+    ]
+
+    # Also check environment variable
+    env_path = os.environ.get("ISAACLAB_ARENA_CONFIG_PATH")
+    if env_path:
+        search_paths.insert(0, Path(env_path))
+
+    for path in search_paths:
+        if path.exists():
+            return path
+
+    return None
+
+
+def _load_config_from_yaml(config_path: str | Path | None = None) -> dict:
+    """Load configuration from YAML file."""
+    config = DEFAULT_CONFIG.copy()
+
+    yaml_path = _find_config_file(config_path)
+    if yaml_path is not None:
+        logging.info(f"Loading config from: {yaml_path}")
+        with open(yaml_path) as f:
+            yaml_config = yaml.safe_load(f) or {}
+        config.update(yaml_config)
+    else:
+        logging.info("No config.yaml found, using defaults")
+
+    return config
+
+
+def _create_isaaclab_env(config: dict, n_envs: int) -> dict[str, dict[int, gym.vector.VectorEnv]]:
+    """Create IsaacLab Arena environment from configuration.
+
+    Args:
+        config: Configuration dictionary.
+        n_envs: Number of parallel environments.
+
+    Returns:
+        Dict mapping environment name to {task_id: VectorEnv}.
+    """
+    from isaaclab.app import AppLauncher
+
+    if config.get("enable_pinocchio", True):
+        import pinocchio  # noqa: F401
+
+    # Override num_envs
+    config["num_envs"] = n_envs
+
+    # Create argparse namespace for IsaacLab
+    as_isaaclab_argparse = argparse.Namespace(**config)
+
+    logging.info("Launching IsaacLab simulation app...")
+    app_launcher = AppLauncher(as_isaaclab_argparse)
+
+    from isaaclab_arena.environments.arena_env_builder import ArenaEnvBuilder
+
+    environment = config.get("environment")
+    if environment is None:
+        raise ValueError("cfg.environment must be specified")
+
+    # Resolve alias and create environment
+    environment_path = resolve_environment_alias(environment)
+    logging.info(f"Creating environment: {environment_path}")
+
+    module_path, class_name = environment_path.rsplit(".", 1)
+    environment_module = importlib.import_module(module_path)
+    environment_class = getattr(environment_module, class_name)()
+
+    env_builder = ArenaEnvBuilder(environment_class.get_env(as_isaaclab_argparse), as_isaaclab_argparse)
+
+    # Determine render_mode
+    render_mode = "rgb_array" if config.get("enable_cameras", False) else None
+
+    raw_env = env_builder.make_registered()
+
+    # Set render_mode on underlying env
+    if render_mode and hasattr(raw_env, "render_mode"):
+        raw_env.render_mode = render_mode
+        logging.info(f"Set render_mode={render_mode} on underlying IsaacLab env")
+
+    # Validate config
+    state_keys = tuple(k.strip() for k in config.get("state_keys", "").split(",") if k.strip())
+    camera_keys = tuple(k.strip() for k in config.get("camera_keys", "").split(",") if k.strip())
+    _validate_env_config(
+        raw_env, state_keys, camera_keys,
+        config.get("state_dim", 54),
+        config.get("action_dim", 36)
+    )
+
+    # Get task description
+    task = config.get("task")
+    if task is None:
+        task = f"Complete the {environment.replace('_', ' ')} task."
+
+    # Wrap and return
+    wrapped_env = IsaacLabVectorEnvWrapper(
+        raw_env,
+        episode_length=config.get("episode_length", 300),
+        task=task,
+        render_mode=render_mode,
+        simulation_app=app_launcher,
+    )
+    logging.info(f"Created: {environment} with {wrapped_env.num_envs} envs, render_mode={render_mode}")
+
+    return {environment: {0: wrapped_env}}
+
+
+def make_env(
+    n_envs: int = 1,
+    use_async_envs: bool = False,
+    config_path: str | Path | None = None,
+) -> dict[str, dict[int, gym.vector.VectorEnv]]:
+    """Create IsaacLab Arena environments (EnvHub-compatible API).
+
+    This function provides the standard EnvHub interface for loading
+    environments from the Hugging Face Hub. Configuration is loaded
+    from configs/config.yaml.
+
+    Args:
+        n_envs: Number of parallel environments (default: 1).
+        use_async_envs: Ignored for IsaacLab (GPU-based batched execution).
+        config_path: Optional explicit path to config.yaml file.
+
+    Returns:
+        Dict mapping environment name to {task_id: VectorEnv}.
+        Format: {suite_name: {0: wrapped_vector_env}}
+
+    Example:
+        >>> from env import make_env
+        >>> envs_dict = make_env(n_envs=4)
+        >>> env = envs_dict["gr1_microwave"][0]
+        >>> obs, info = env.reset()
+
+    Configuration:
+        Create a configs/config.yaml file with your settings:
+
+        ```yaml
+        environment: gr1_microwave
+        task: "Reach out to the microwave and open it."
+        episode_length: 300
+        headless: true
+        enable_cameras: false
+        ```
+
+    Note:
+        IsaacLab environments use GPU-based batched execution, so
+        `use_async_envs` is ignored. The returned wrapper provides
+        VectorEnv compatibility.
+    """
+    if n_envs < 1:
+        raise ValueError("`n_envs` must be at least 1")
+
+    # Load config from YAML
+    config = _load_config_from_yaml(config_path)
+
+    logging.info(
+        f"EnvHub make_env: environment={config.get('environment')}, n_envs={n_envs}"
+    )
+    logging.info(
+        f"Config: headless={config.get('headless')}, "
+        f"enable_cameras={config.get('enable_cameras')}"
+    )
+
+    return _create_isaaclab_env(config, n_envs)
+
+
+# For direct script execution
+if __name__ == "__main__":
+    import tqdm
+
+    logging.basicConfig(level=logging.INFO)
+
+    print("Creating IsaacLab Arena environment...")
+    envs_dict = make_env(n_envs=1)
+
+    suite_name = next(iter(envs_dict))
+    env = envs_dict[suite_name][0]
+
+    print(f"Environment: {suite_name}")
+    print(f"Num envs: {env.num_envs}")
+    print(f"Observation space: {env.observation_space}")
+    print(f"Action space: {env.action_space}")
+
+    obs, info = env.reset()
+    print(f"Observation keys: {obs.keys() if isinstance(obs, dict) else 'array'}")
+
+    print("Running zero-action rollout...")
+    for _ in tqdm.tqdm(range(100)):
+        with torch.inference_mode():
+            action_dim = env.action_space.shape[-1]
+            actions = torch.zeros((env.num_envs, action_dim), device=env.device)
+            obs, rewards, terminated, truncated, info = env.step(actions)
+
+    env.close()
+    print("Done!")
+

install.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+# IsaacLab Arena EnvHub Installation Script
+#
+# This script installs all dependencies required for IsaacLab Arena environments.
+#
+# Usage:
+#   chmod +x install.sh
+#   ./install.sh
+#
+# Prerequisites:
+#   - NVIDIA GPU (RTX 2070+ recommended)
+#   - Ubuntu 20.04+ or compatible Linux distribution
+#   - Python 3.10+
+#   - CUDA 12.x
+
+set -e
+
+echo "=========================================="
+echo "IsaacLab Arena EnvHub Installation"
+echo "=========================================="
+
+# Check for uv or pip
+if command -v uv &> /dev/null; then
+    PIP_CMD="uv pip"
+    echo "Using uv for package management"
+else
+    PIP_CMD="pip"
+    echo "Using pip for package management"
+fi
+
+# Step 1: Install Isaac Sim 5.1.0
+echo ""
+echo "[1/5] Installing Isaac Sim 5.1.0..."
+echo "Note: This requires accepting NVIDIA's EULA"
+export ACCEPT_EULA=Y
+export PRIVACY_CONSENT=Y
+$PIP_CMD install "isaacsim[all,extscache]==5.1.0" --extra-index-url https://pypi.nvidia.com
+
+# Step 2: Clone and install Isaac Lab 2.3.0
+echo ""
+echo "[2/5] Installing Isaac Lab 2.3.0..."
+if [ ! -d "IsaacLab" ]; then
+    git clone https://github.com/isaac-sim/IsaacLab.git
+fi
+cd IsaacLab
+git checkout v2.3.0
+./isaaclab.sh -i
+cd ..
+
+# Step 3: Clone and install IsaacLab Arena
+echo ""
+echo "[3/5] Installing IsaacLab Arena..."
+if [ ! -d "IsaacLab-Arena" ]; then
+    git clone https://github.com/isaac-sim/IsaacLab-Arena.git
+fi
+cd IsaacLab-Arena
+$PIP_CMD install -e .
+cd ..
+
+# Step 4: Install additional dependencies
+echo ""
+echo "[4/5] Installing additional dependencies..."
+$PIP_CMD install qpsolvers==4.8.1
+$PIP_CMD install onnxruntime lightwheel-sdk "vuer[all]"
+$PIP_CMD install numpy==1.26.0 lxml==4.9.4 packaging==23.2
+
+# Step 5: Install Python dependencies for env.py
+echo ""
+echo "[5/5] Installing EnvHub dependencies..."
+$PIP_CMD install gymnasium>=0.29.0 torch>=2.0.0 pyyaml>=6.0
+
+echo ""
+echo "=========================================="
+echo "Installation Complete!"
+echo "=========================================="
+echo ""
+echo "You can now use IsaacLab Arena with LeRobot EnvHub:"
+echo ""
+echo "  from lerobot.envs.factory import make_env"
+echo "  envs_dict = make_env('nvkartik/isaaclab-arena-envs', n_envs=4, trust_remote_code=True)"
+echo ""
+echo "Or test locally:"
+echo ""
+echo "  python env.py"
+echo ""
+

pyproject.toml

@@ -0,0 +1,76 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "isaaclab-arena-envs"
+version = "0.1.0"
+description = "IsaacLab Arena environments for LeRobot EnvHub integration"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+authors = [
+    { name = "Kartik Sachdev", email = "nvkartik@users.noreply.github.com" }
+]
+keywords = [
+    "robotics",
+    "simulation",
+    "reinforcement-learning",
+    "isaaclab",
+    "lerobot",
+    "envhub",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+# Core dependencies for the env.py module
+# Note: IsaacSim, IsaacLab, and IsaacLab-Arena must be installed separately
+# See README.md for full installation instructions
+dependencies = [
+    "gymnasium>=0.29.0",
+    "numpy>=1.26.0,<2.0",
+    "torch>=2.0.0",
+    "pyyaml>=6.0",
+]
+
+[project.optional-dependencies]
+# Development dependencies
+dev = [
+    "pytest>=7.0",
+    "ruff>=0.1.0",
+]
+
+[project.urls]
+Homepage = "https://huggingface.co/nvkartik/isaaclab-arena-envs"
+Repository = "https://huggingface.co/nvkartik/isaaclab-arena-envs"
+Documentation = "https://huggingface.co/docs/lerobot"
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "env.py",
+    "configs/",
+    "README.md",
+    "requirements.txt",
+]
+
+[tool.ruff]
+line-length = 110
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W"]
+ignore = ["E501"]
+

requirements.txt

@@ -0,0 +1,47 @@
+# IsaacLab Arena EnvHub Requirements
+# ==================================
+#
+# This file lists dependencies for the IsaacLab Arena EnvHub environment.
+#
+# IMPORTANT: IsaacSim, IsaacLab, and IsaacLab-Arena must be installed separately!
+# See README.md for complete installation instructions.
+#
+# Install these dependencies with:
+#   pip install -r requirements.txt
+
+# Core Python dependencies (env.py)
+gymnasium>=0.29.0
+numpy>=1.26.0,<2.0
+torch>=2.0.0
+pyyaml>=6.0
+
+# Required by IsaacLab-Arena
+qpsolvers==4.8.1
+lxml==4.9.4
+packaging==23.2
+
+# Optional: for ONNX policy inference
+# onnxruntime
+
+# Optional: for VR/teleoperation
+# lightwheel-sdk
+# vuer[all]
+
+# =============================================================================
+# EXTERNAL DEPENDENCIES (install separately, not via pip)
+# =============================================================================
+#
+# 1. Isaac Sim 5.1.0:
+#    uv pip install "isaacsim[all,extscache]==5.1.0" --extra-index-url https://pypi.nvidia.com
+#    export ACCEPT_EULA=Y
+#    export PRIVACY_CONSENT=Y
+#
+# 2. Isaac Lab 2.3.0:
+#    git clone https://github.com/isaac-sim/IsaacLab.git
+#    cd IsaacLab && git checkout v2.3.0
+#    ./isaaclab.sh -i
+#
+# 3. IsaacLab Arena:
+#    git clone https://github.com/isaac-sim/IsaacLab-Arena.git
+#    cd IsaacLab-Arena && uv pip install -e .
+