run precommit and fix issues

Merge branch 'main' into feature/basic-peft-support
Add peft as extra dependency, mark tests
2026-05-12 15:19:43 +00:00 · 2025-12-22 14:50:58 +01:00 · 2025-12-22 14:29:51 +01:00 · 2025-12-20 19:20:12 +01:00 · 2025-12-20 19:18:56 +01:00 · 2025-12-19 12:23:37 +01:00
295 changed files with 4862 additions and 20086 deletions
@@ -22,21 +22,20 @@ Short, imperative summary (e.g., "fix(robots): handle None in sensor parser"). S
 - Short, concrete bullets of the modifications (files/behaviour).
 - Short note if this introduces breaking changes and migration steps.

-## How was this tested (or how to run locally)
+## How was this tested

 - Tests added: list new tests or test files.
 - Manual checks / dataset runs performed.
- Instructions for the reviewer

-Example:
+## How to run locally (reviewer)

- Ran the relevant tests:
+- Run the relevant tests:

  ```bash
  pytest -q tests/ -k <keyword>
  ```

- Reproduce with a quick example or CLI (if applicable):
+- Run a quick example or CLI (if applicable):

  ```bash
  lerobot-train --some.option=true
@@ -18,11 +18,6 @@ name: Documentation
 on:
  # Allows running this workflow manually from the Actions tab
  workflow_dispatch:
-    inputs:
-      version:
-        description: 'Version tag (e.g. v0.1.2) - Leave empty for standard main build'
-        required: false
-        type: string

  # Triggers the workflow on push events to main for the docs folder
  push:
@@ -38,9 +33,6 @@ on:
    paths:
      - "docs/**"

-  release:
-    types: [published]
-
 # Ensures that only the latest commit for a PR or branch is built, canceling older runs.
 concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
@@ -51,7 +43,7 @@ jobs:
  build_main_docs:
    name: Build Main Docs
    if: >
-      (github.event_name == 'push' || github.event_name == 'workflow_dispatch' || github.event_name == 'release') &&
+      (github.event_name == 'push' || github.event_name == 'workflow_dispatch') &&
      github.repository == 'huggingface/lerobot'
    permissions:
      contents: read
@@ -59,13 +51,7 @@ jobs:
    with:
      commit_sha: ${{ github.sha }}
      package: lerobot
-      additional_args: >-
-        --not_python_module
-        ${{
-          (github.event_name == 'release' && format('--version {0}', github.event.release.tag_name)) ||
-          (inputs.version != '' && format('--version {0}', inputs.version)) ||
-          ''
-        }}
+      additional_args: --not_python_module
    secrets:
      token: ${{ secrets.HUGGINGFACE_PUSH }}
      hf_token: ${{ secrets.HF_DOC_BUILD_PUSH }}
@@ -62,7 +62,7 @@ jobs:
      HF_HOME: /mnt/cache/.cache/huggingface
      HF_LEROBOT_HOME: /mnt/cache/.cache/huggingface/lerobot
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
        with:
          persist-credentials: false
          lfs: true
@@ -61,7 +61,7 @@ jobs:
      HF_HOME: /mnt/cache/.cache/huggingface
      HF_LEROBOT_HOME: /mnt/cache/.cache/huggingface/lerobot
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
        with:
          lfs: true
          persist-credentials: false
@@ -85,7 +85,7 @@ jobs:
          python-version: ${{ env.PYTHON_VERSION }}

      - name: Install lerobot with all extras
-        run: uv sync --extra all # TODO(Steven): Make flash-attn optional
+        run: uv sync --all-extras --no-extra groot --no-extra wallx # TODO(Steven): Make flash-attn optional

      - name: Run pytest (all extras)
        run: uv run pytest tests -vv --maxfail=10
@@ -101,11 +101,9 @@ jobs:
    runs-on:
      group: aws-general-8-plus
    if: |
-      github.repository == 'huggingface/lerobot' && (
-        (github.event_name == 'pull_request_review' && github.event.review.state == 'approved' && github.event.pull_request.head.repo.fork == false) ||
-        github.event_name == 'push' ||
-        github.event_name == 'workflow_dispatch'
-      )
+      (github.event_name == 'pull_request_review' && github.event.review.state == 'approved' && github.event.pull_request.head.repo.fork == false) ||
+      github.event_name == 'push' ||
+      github.event_name == 'workflow_dispatch'
    outputs:
      image_tag: ${{ steps.set_tag.outputs.image_tag }}
    env:
@@ -129,7 +127,7 @@ jobs:
          sudo apt-get update
          sudo apt-get install git-lfs
          git lfs install
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
        with:
          lfs: true
          persist-credentials: false
@@ -188,18 +186,15 @@ jobs:
    steps:
      - name: Get Docker Hub Token and Delete Image
        # zizmor: ignore[template-injection]
-        env:
-          DOCKERHUB_LEROBOT_USERNAME: ${{ secrets.DOCKERHUB_LEROBOT_USERNAME }}
-          DOCKERHUB_LEROBOT_PASSWORD: ${{ secrets.DOCKERHUB_LEROBOT_PASSWORD }}
-          IMAGE_FULL: ${{ needs.build-and-push-docker.outputs.image_tag }}
        run: |
-          IMAGE_NAME=$(echo "$IMAGE_FULL" | cut -d':' -f1)
-          IMAGE_TAG=$(echo "$IMAGE_FULL" | cut -d':' -f2-)
+          IMAGE_NAME=$(echo "${{ needs.build-and-push-docker.outputs.image_tag }}" | cut -d':' -f1)
+          IMAGE_TAG=$(echo "${{ needs.build-and-push-docker.outputs.image_tag }}" | cut -d':' -f2)
+
          echo "Attempting to delete image: $IMAGE_NAME:$IMAGE_TAG"

          TOKEN=$(curl -s -H "Content-Type: application/json" \
                       -X POST \
-                       -d "{\"username\": \"$DOCKERHUB_LEROBOT_USERNAME\", \"password\": \"$DOCKERHUB_LEROBOT_PASSWORD\"}" \
+                       -d '{"username": "${{ secrets.DOCKERHUB_LEROBOT_USERNAME }}", "password": "${{ secrets.DOCKERHUB_LEROBOT_PASSWORD }}"}' \
                       https://hub.docker.com/v2/users/login/ | jq -r .token)

          if [ "$TOKEN" == "null" ] || [ -z "$TOKEN" ]; then
@@ -210,7 +205,7 @@ jobs:
          HTTP_RESPONSE=$(curl -s -o /dev/null -w "%{http_code}" \
                               -H "Authorization: JWT ${TOKEN}" \
                               -X DELETE \
-                               https://hub.docker.com/v2/repositories/${IMAGE_NAME}/tags/$IMAGE_TAG)
+                               https://hub.docker.com/v2/repositories/${IMAGE_NAME}/tags/${IMAGE_TAG}/)

          if [ "$HTTP_RESPONSE" -eq 204 ]; then
            echo "Successfully deleted Docker image tag: $IMAGE_NAME:$IMAGE_TAG"
@@ -42,26 +42,38 @@ jobs:

            // Keyword Heuristics

-            if (matches(/\b(bug|error|crash|exception)\b/i)) labelsToAdd.add('bug');
-            if (matches(/\b(new feature|enhancement|improvement|proposal|feature request)\b/i)) labelsToAdd.add('enhancement');
-            if (matches(/\b(question|how to|clarify|explain|how do i|help me|question about)\b/i)) labelsToAdd.add('question');
-            if (matches(/\b(documentation|docs?|readme|tutorial|wiki|typo|docstring)\b/i)) labelsToAdd.add('documentation');
-            if (matches(/\b(example|sample|demo|notebook)s?\b/i)) labelsToAdd.add('examples');
+            // Domain Specific
+            if (matches(/\b(bug|error|issue|fault|crash|exception)\b/i)) labelsToAdd.add('bug');
+            if (matches(/\b(feature|enhancement|improvement|support|implement|proposal)\b/i)) labelsToAdd.add('enhancement');
+            if (matches(/\b(question|help|how to||clarify|explain|unclear)\b/i)) labelsToAdd.add('question');
+            if (matches(/\b(maintenance|documentation|docs|readme|tutorial|guide|wiki)\b/i)) labelsToAdd.add('documentation');
+            if (matches(/\b(example|script|sample|demo|notebook)s?\b/i)) labelsToAdd.add('examples');
            if (matches(/\b(datasets?|data loader|data augmentation|data preprocessing)\b/i)) labelsToAdd.add('dataset');
            if (matches(/\b(mujoco|isaac|simulation|sim)\b/i)) labelsToAdd.add('simulation');
-            if (matches(/\b(train|training|optimizer|gradient|wandb|sac)\b/i)) labelsToAdd.add('training');
-            if (matches(/\b(rerun|plot|render|rendering|visualizer)/i)) labelsToAdd.add('visualization');
-            if (matches(/\b(cameras?|opencv|realsense|lidars?|sensors?|imus?|microphones?|rgbd|encoders?)\b/i)) labelsToAdd.add('sensors');
-            if (matches(/\b(urdf|actuators?|calibration|end-effector|kinematics)\b/i)) labelsToAdd.add('robots');
+            if (matches(/\b(train|training|loss|optimizer|backward|gradient|wandb|sac)\b/i)) labelsToAdd.add('training');
+            if (matches(/\b(rerun|plot|video|render|visualiz|gif)/i)) labelsToAdd.add('visualization');
+            if (matches(/\b(camera|realsense|lidar|depth|sensor|imu|microphone|rgbd)\b/i)) labelsToAdd.add('sensors');
+            if (matches(/\b(aloha|koch|so-100|so100|mobile|teleop|manipulator|robots?)\b/i)) labelsToAdd.add('robots');
            if (matches(/\b(teleop|teleoperator|controller|leader|follower|joystick|gamepad)\b/i)) labelsToAdd.add('teleoperators');
-            if (matches(/\b(policy|policies|model?)\b/i)) labelsToAdd.add('policies');
-            if (matches(/\b(processor|pipeline|preprocessor|postprocessor)s?\b/i)) labelsToAdd.add('processor');
-            if (matches(/\b(eval|evaluate|evaluation|metrics?|score|benchmarks?)\b/i)) labelsToAdd.add('evaluation');
+            if (matches(/\b(policy|policies|p0licy)\b/i)) labelsToAdd.add('policies');
+            if (matches(/\b(processors?|pipeline)\b/i)) labelsToAdd.add('processor');
+            if (matches(/\b(eval|evaluate|evaluation|metrics?|score|benchmark)\b/i)) labelsToAdd.add('evaluation');
+
+            // Infrastructure & Code Quality
            if (matches(/\b(tests?|pytest|unittest|failing test)\b/i)) labelsToAdd.add('tests');
-            if (matches(/\b(ci|github actions?|github workflows?|gha|docker|pypi)\b/i)) labelsToAdd.add('CI');
-            if (matches(/\b(perf|latency|throughput|fps|speed|performance|slow|fast|slower|faster|memory usage)\b/i)) labelsToAdd.add('performance');
-            if (matches(/\b(dependency|dependencies|pip|install error|importerror|package not found|pyproject)\b/i)) labelsToAdd.add('dependencies');
-            if (matches(/\b(configuration|config|arguments?|input feature|dracuss)\b/i)) labelsToAdd.add('configuration');
+            if (matches(/\b(ci|github actions|workflow|gha|actions?|pipeline)\b/i)) {
+              labelsToAdd.add('CI');
+              labelsToAdd.add('github_actions');
+            }
+            if (matches(/\b(perf|latency|throughput|fps|speed|performance)\b/i)) labelsToAdd.add('performance');
+            if (matches(/\b(dependency|requirements|pip|conda|install error|importerror|package not found)\b/i)) labelsToAdd.add('dependencies');
+            if (matches(/\b(python|pyproject|requirements(\.txt)?|pip install|typing error)\b/i)) labelsToAdd.add('python');
+
+            // Documentation & Meta
+            if (matches(/\b(doc|documentation|docs|readme|typo|how to)\b/i)) labelsToAdd.add('documentation');
+            if (matches(/\b(refactor|cleanup|restructure|rename|modernize code)\b/i)) labelsToAdd.add('refactor');
+            if (matches(/\b(release|changelog|version bump|cut a release|tag v)\b/i)) labelsToAdd.add('release');
+            if (matches(/\b(breaking change|major change)\b/i)) labelsToAdd.add('breaking change');

            // Apply Labels
            const labels = Array.from(labelsToAdd).filter(Boolean);
@@ -52,7 +52,7 @@ jobs:
          sudo apt-get update
          sudo apt-get install git-lfs
          git lfs install
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
        with:
          lfs: true
          persist-credentials: false
@@ -87,7 +87,7 @@ jobs:
          sudo apt-get update
          sudo apt-get install git-lfs
          git lfs install
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
        with:
          lfs: true
          persist-credentials: false
@@ -43,12 +43,12 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
        with:
          persist-credentials: false

      - name: Set up Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
        with:
          python-version: '3.10'

@@ -38,12 +38,12 @@ jobs:

    steps:
      - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
        with:
          persist-credentials: false

      - name: Set up Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
        with:
          python-version: '3.10'

@@ -135,7 +135,7 @@ jobs:
    env:
      MUJOCO_GL: egl
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
        with:
          lfs: true
          persist-credentials: false
@@ -177,3 +177,4 @@ jobs:

 # TODO(Steven): Publish draft/pre-release and to test pypi weekly
 # TODO(Steven): Separate build and publish job
+# TODO(Steven): Tag documentation with the same version as the package
@@ -43,7 +43,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
-        uses: actions/checkout@v6 # zizmor: ignore[unpinned-uses]
+        uses: actions/checkout@v4 # zizmor: ignore[unpinned-uses]
        with:
          fetch-depth: 0
          persist-credentials: false
@@ -20,8 +20,8 @@ on:
  workflow_dispatch:

  # Run on the 1st and 15th of every month at 09:00 UTC
-  # schedule:
-  #  - cron: '0 2 1,15 * *'
+  schedule:
+    - cron: '0 2 1,15 * *'

 permissions:
  contents: read
@@ -49,7 +49,7 @@ jobs:
      HF_HOME: /mnt/cache/.cache/huggingface
      HF_LEROBOT_HOME: /mnt/cache/.cache/huggingface/lerobot
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
        with:
          lfs: true
          persist-credentials: false
@@ -78,7 +78,7 @@ jobs:
          echo "Dependencies unbound:" && cat pyproject.toml

      - name: Install lerobot with all extras
-        run: uv sync --extra all # TODO(Steven): Make flash-attn optional
+        run: uv sync --all-extras --no-extra groot --no-extra wallx # TODO(Steven): Make flash-attn optional

      - name: Run pytest (all extras)
        run: uv run pytest tests -vv
@@ -91,7 +91,6 @@ jobs:
    name: Build and Push Docker
    runs-on:
      group: aws-general-8-plus
-    if: github.repository == 'huggingface/lerobot'
    outputs:
      image_tag: ${{ env.DOCKER_IMAGE_NAME }}
    env:
@@ -102,7 +101,7 @@ jobs:
          sudo apt-get update
          sudo apt-get install git-lfs
          git lfs install
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
        with:
          lfs: true
          persist-credentials: false
@@ -163,19 +162,15 @@ jobs:
    steps:
      - name: Get Docker Hub Token and Delete Image
        # zizmor: ignore[template-injection]
-        env:
-          DOCKERHUB_LEROBOT_USERNAME: ${{ secrets.DOCKERHUB_LEROBOT_USERNAME }}
-          DOCKERHUB_LEROBOT_PASSWORD: ${{ secrets.DOCKERHUB_LEROBOT_PASSWORD }}
-          IMAGE_FULL: ${{ needs.build-and-push-docker.outputs.image_tag }}
        run: |
-          IMAGE_NAME=$(echo "$IMAGE_FULL" | cut -d':' -f1)
-          IMAGE_TAG=$(echo "$IMAGE_FULL" | cut -d':' -f2)
+          IMAGE_NAME=$(echo "${{ needs.build-and-push-docker.outputs.image_tag }}" | cut -d':' -f1)
+          IMAGE_TAG=$(echo "${{ needs.build-and-push-docker.outputs.image_tag }}" | cut -d':' -f2)

          echo "Attempting to delete image: $IMAGE_NAME:$IMAGE_TAG"

          TOKEN=$(curl -s -H "Content-Type: application/json" \
                       -X POST \
-                       -d "{\"username\": \"$DOCKERHUB_LEROBOT_USERNAME\", \"password\": \"$DOCKERHUB_LEROBOT_PASSWORD\"}" \
+                       -d '{"username": "${{ secrets.DOCKERHUB_LEROBOT_USERNAME }}", "password": "${{ secrets.DOCKERHUB_LEROBOT_PASSWORD }}"}' \
                       https://hub.docker.com/v2/users/login/ | jq -r .token)

          if [ "$TOKEN" == "null" ] || [ -z "$TOKEN" ]; then
@@ -186,7 +181,7 @@ jobs:
          HTTP_RESPONSE=$(curl -s -o /dev/null -w "%{http_code}" \
                               -H "Authorization: JWT ${TOKEN}" \
                               -X DELETE \
-                               https://hub.docker.com/v2/repositories/${IMAGE_NAME}/tags/$IMAGE_TAG)
+                               https://hub.docker.com/v2/repositories/${IMAGE_NAME}/tags/${IMAGE_TAG}/)

          if [ "$HTTP_RESPONSE" -eq 204 ]; then
            echo "Successfully deleted Docker image tag: $IMAGE_NAME:$IMAGE_TAG"
@@ -1,83 +1,323 @@
-# How to contribute to 🤗 LeRobot
+# How to contribute to 🤗 LeRobot?

-Everyone is welcome to contribute, and we value everybody's contribution. Code is not the only way to help the community. Answering questions, helping others, reaching out, and improving the documentation are immensely valuable.
+Everyone is welcome to contribute, and we value everybody's contribution. Code
+is thus not the only way to help the community. Answering questions, helping
+others, reaching out and improving the documentations are immensely valuable to
+the community.

-Whichever way you choose to contribute, please be mindful to respect our [code of conduct](./CODE_OF_CONDUCT.md).
+It also helps us if you spread the word: reference the library from blog posts
+on the awesome projects it made possible, shout out on Twitter when it has
+helped you, or simply ⭐️ the repo to say "thank you".

-## Ways to Contribute
+Whichever way you choose to contribute, please be mindful to respect our
+[code of conduct](https://github.com/huggingface/lerobot/blob/main/CODE_OF_CONDUCT.md).

-You can contribute in many ways:
+## You can contribute in so many ways!

- **Fixing issues:** Resolve bugs or improve existing code.
- **New features:** Develop new features.
- **Extend:** Implement new models/policies, robots, or simulation environments and upload datasets to the Hugging Face Hub.
- **Documentation:** Improve examples, guides, and docstrings.
- **Feedback:** Submit tickets related to bugs or desired new features.
+Some of the ways you can contribute to 🤗 LeRobot:

-If you are unsure where to start, join our [Discord Channel](https://discord.gg/q8Dzzpym3f).
+- Fixing outstanding issues with the existing code.
+- Implementing new models, datasets or simulation environments.
+- Contributing to the examples or to the documentation.
+- Submitting issues related to bugs or desired new features.

-## Development Setup
+Following the guides below, feel free to open issues and PRs and to coordinate your efforts with the community on our [Discord Channel](https://discord.gg/VjFz58wn3R). For specific inquiries, reach out to [Remi Cadene](mailto:remi.cadene@huggingface.co).

-To contribute code, you need to set up a development environment.
+If you are not sure how to contribute or want to know the next features we working on, look on this project page: [LeRobot TODO](https://github.com/orgs/huggingface/projects/46)

-### 1. Fork and Clone
+## Submitting a new issue or feature request

-Fork the repository on GitHub, then clone your fork:
-
-```bash
-git clone https://github.com/<your-handle>/lerobot.git
-cd lerobot
-git remote add upstream https://github.com/huggingface/lerobot.git
-```
-
-### 2. Environment Installation
-
-Please follow our [Installation Guide](./docs/source/installation.mdx) for the environment setup & installation from source.
-
-## Running Tests & Quality Checks
-
-### Code Style (Pre-commit)
-
-Install `pre-commit` hooks to run checks automatically before you commit:
-
-```bash
-pre-commit install
-```
-
-To run checks manually on all files:
-
-```bash
-pre-commit run --all-files
-```
-
-### Running Tests
-
-We use `pytest`. First, ensure you have test artifacts by installing **git-lfs**:
+Do your best to follow these guidelines when submitting an issue or a feature
+request. It will make it easier for us to come back to you quickly and with good
+feedback.
+
+### Did you find a bug?
+
+The 🤗 LeRobot library is robust and reliable thanks to the users who notify us of
+the problems they encounter. So thank you for reporting an issue.
+
+First, we would really appreciate it if you could **make sure the bug was not
+already reported** (use the search bar on Github under Issues).
+
+Did not find it? :( So we can act quickly on it, please follow these steps:
+
+- Include your **OS type and version**, the versions of **Python** and **PyTorch**.
+- A short, self-contained, code snippet that allows us to reproduce the bug in
+  less than 30s.
+- The full traceback if an exception is raised.
+- Attach any other additional information, like screenshots, you think may help.
+
+### Do you want a new feature?
+
+A good feature request addresses the following points:
+
+1. Motivation first:
+
+- Is it related to a problem/frustration with the library? If so, please explain
+  why. Providing a code snippet that demonstrates the problem is best.
+- Is it related to something you would need for a project? We'd love to hear
+  about it!
+- Is it something you worked on and think could benefit the community?
+  Awesome! Tell us what problem it solved for you.
+
+2. Write a _paragraph_ describing the feature.
+3. Provide a **code snippet** that demonstrates its future use.
+4. In case this is related to a paper, please attach a link.
+5. Attach any additional information (drawings, screenshots, etc.) you think may help.
+
+If your issue is well written we're already 80% of the way there by the time you
+post it.
+
+## Adding new policies, datasets or environments
+
+Look at our implementations for [datasets](./src/lerobot/datasets/), [policies](./src/lerobot/policies/),
+environments ([aloha](https://github.com/huggingface/gym-aloha),
+[pusht](https://github.com/huggingface/gym-pusht))
+and follow the same api design.
+
+When implementing a new dataset loadable with LeRobotDataset follow these steps:
+
+- Update `available_datasets_per_env` in `lerobot/__init__.py`
+
+When implementing a new environment (e.g. `gym_aloha`), follow these steps:
+
+- Update `available_tasks_per_env` and `available_datasets_per_env` in `lerobot/__init__.py`
+
+When implementing a new policy class (e.g. `DiffusionPolicy`) follow these steps:
+
+- Update `available_policies` and `available_policies_per_env`, in `lerobot/__init__.py`
+- Set the required `name` class attribute.
+- Update variables in `tests/test_available.py` by importing your new Policy class
+
+## Submitting a pull request (PR)
+
+Before writing code, we strongly advise you to search through the existing PRs or
+issues to make sure that nobody is already working on the same thing. If you are
+unsure, it is always a good idea to open an issue to get some feedback.
+
+You will need basic `git` proficiency to be able to contribute to
+🤗 LeRobot. `git` is not the easiest tool to use but it has the greatest
+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro
+Git](https://git-scm.com/book/en/v2) is a very good reference.
+
+Follow these steps to start contributing:
+
+1. Fork the [repository](https://github.com/huggingface/lerobot) by
+   clicking on the 'Fork' button on the repository's page. This creates a copy of the code
+   under your GitHub user account.
+
+2. Clone your fork to your local disk, and add the base repository as a remote. The following command
+   assumes you have your public SSH key uploaded to GitHub. See the following guide for more
+   [information](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository).
+
+   ```bash
+   git clone git@github.com:<your Github handle>/lerobot.git
+   cd lerobot
+   git remote add upstream https://github.com/huggingface/lerobot.git
+   ```
+
+3. Create a new branch to hold your development changes, and do this for every new PR you work on.
+
+   Start by synchronizing your `main` branch with the `upstream/main` branch (more details in the [GitHub Docs](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/syncing-a-fork)):
+
+   ```bash
+   git checkout main
+   git fetch upstream
+   git rebase upstream/main
+   ```
+
+   Once your `main` branch is synchronized, create a new branch from it:
+
+   ```bash
+   git checkout -b a-descriptive-name-for-my-changes
+   ```
+
+   🚨 **Do not** work on the `main` branch.
+
+4. for development, we advise to use a tool like `poetry` or `uv` instead of just `pip` to easily track our dependencies.
+   Follow the instructions to [install poetry](https://python-poetry.org/docs/#installation) (use a version >=2.1.0) or to [install uv](https://docs.astral.sh/uv/getting-started/installation/#installation-methods) if you don't have one of them already.
+
+   Set up a development environment with conda:
+
+   ```bash
+   conda create -y -n lerobot-dev python=3.10 && conda activate lerobot-dev
+   ```
+
+   If you're using `uv`, it can manage python versions so you can instead do:
+
+   ```bash
+   uv venv --python 3.10 && source .venv/bin/activate
+   ```
+
+   To develop on 🤗 LeRobot, you will at least need to install the `dev` and `test` extras dependencies along with the core library:
+
+   using `poetry`
+
+   ```bash
+   poetry sync --extras "dev test"
+   ```
+
+   using `uv`
+
+   ```bash
+   uv sync --extra dev --extra test
+   ```
+
+   You can also install the project with all its dependencies (including environments):
+
+   using `poetry`
+
+   ```bash
+   poetry sync --all-extras
+   ```
+
+   using `uv`
+
+   ```bash
+   uv sync --all-extras
+   ```
+
+   > **Note:** If you don't install simulation environments with `--all-extras`, the tests that require them will be skipped when running the pytest suite locally. However, they _will_ be tested in the CI. In general, we advise you to install everything and test locally before pushing.
+
+   Whichever command you chose to install the project (e.g. `poetry sync --all-extras`), you should run it again when pulling code with an updated version of `pyproject.toml` and `poetry.lock` in order to synchronize your virtual environment with the new dependencies.
+
+   The equivalent of `pip install some-package`, would just be:
+
+   using `poetry`
+
+   ```bash
+   poetry add some-package
+   ```
+
+   using `uv`
+
+   ```bash
+   uv add some-package
+   ```
+
+   When making changes to the poetry sections of the `pyproject.toml`, you should run the following command to lock dependencies.
+   using `poetry`
+
+   ```bash
+   poetry lock
+   ```
+
+   using `uv`
+
+   ```bash
+   uv lock
+   ```
+
+5. Develop the features on your branch.
+
+   As you work on the features, you should make sure that the test suite
+   passes. You should run the tests impacted by your changes like this (see
+   below an explanation regarding the environment variable):
+
+   ```bash
+   pytest tests/<TEST_TO_RUN>.py
+   ```
+
+6. Follow our style.
+
+   `lerobot` relies on `ruff` to format its source code
+   consistently. Set up [`pre-commit`](https://pre-commit.com/) to run these checks
+   automatically as Git commit hooks.
+
+   Install `pre-commit` hooks:
+
+   ```bash
+   pre-commit install
+   ```
+
+   You can run these hooks whenever you need on staged files with:
+
+   ```bash
+   pre-commit
+   ```
+
+   Once you're happy with your changes, add changed files using `git add` and
+   make a commit with `git commit` to record your changes locally:
+
+   ```bash
+   git add modified_file.py
+   git commit
+   ```
+
+   Note, if you already committed some changes that have a wrong formatting, you can use:
+
+   ```bash
+   pre-commit run --all-files
+   ```
+
+   Please write [good commit messages](https://chris.beams.io/posts/git-commit/).
+
+   It is a good idea to sync your copy of the code with the original
+   repository regularly. This way you can quickly account for changes:
+
+   ```bash
+   git fetch upstream
+   git rebase upstream/main
+   ```
+
+   Push the changes to your account using:
+
+   ```bash
+   git push -u origin a-descriptive-name-for-my-changes
+   ```
+
+7. Once you are satisfied (**and the checklist below is happy too**), go to the
+   webpage of your fork on GitHub. Click on 'Pull request' to send your changes
+   to the project maintainers for review.
+
+8. It's ok if maintainers ask you for changes. It happens to core contributors
+   too! So everyone can see the changes in the Pull request, work in your local
+   branch and push the changes to your fork. They will automatically appear in
+   the pull request.
+
+### Checklist
+
+1. The title of your pull request should be a summary of its contribution;
+2. If your pull request addresses an issue, please mention the issue number in
+   the pull request description to make sure they are linked (and people
+   consulting the issue know you are working on it);
+3. To indicate a work in progress please prefix the title with `[WIP]`, or preferably mark
+   the PR as a draft PR. These are useful to avoid duplicated work, and to differentiate
+   it from PRs ready to be merged;
+4. Make sure existing tests pass;
+
+### Tests
+
+An extensive test suite is included to test the library behavior and several examples. Library tests can be found in the [tests folder](https://github.com/huggingface/lerobot/tree/main/tests).
+
+Install [git lfs](https://git-lfs.com/) to retrieve test artifacts (if you don't have it already).
+
+On Mac:

 ```bash
+brew install git-lfs
 git lfs install
+```
+
+On Ubuntu:
+
+```bash
+sudo apt-get install git-lfs
+git lfs install
+```
+
+Pull artifacts if they're not in [tests/artifacts](tests/artifacts)
+
+```bash
 git lfs pull
 ```

-Run the full suite (this may require extras installed):
+We use `pytest` in order to run the tests. From the root of the
+repository, here's how to run tests with `pytest` for the library:

 ```bash
-pytest -sv ./tests
+python -m pytest -sv ./tests
 ```

-Or run a specific test file during development:
-
-```bash
-pytest -sv tests/test_specific_feature.py
-```
-
-## Submitting Issues & Pull Requests
-
-Use the templates for required fields and examples.
-
- **Issues:** Follow the [ticket template](./.github/ISSUE_TEMPLATE/bug-report.yml).
- **Pull requests:** Rebase on `upstream/main`, use a descriptive branch (don't work on `main`), run `pre-commit` and tests locally, and follow the [PR template](./.github/PULL_REQUEST_TEMPLATE.md).
-
-One member of the LeRobot team will then review your contribution.
-
-Thank you for contributing to LeRobot!
+You can specify a smaller set of tests in order to test only the feature
+you're working on.
@@ -10,7 +10,6 @@
 [![Status](https://img.shields.io/pypi/status/lerobot)](https://pypi.org/project/lerobot/)
 [![Version](https://img.shields.io/pypi/v/lerobot)](https://pypi.org/project/lerobot/)
 [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.1-ff69b4.svg)](https://github.com/huggingface/lerobot/blob/main/CODE_OF_CONDUCT.md)
-[![Discord](https://img.shields.io/badge/Discord-Join_Us-5865F2?style=flat&logo=discord&logoColor=white)](https://discord.gg/q8Dzzpym3f)

 </div>

@@ -100,11 +99,11 @@ lerobot-train \
  --dataset.repo_id=lerobot/aloha_mobile_cabinet
 ```

-| Category                   | Models                                                                                                                                                                                                       |
-| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| **Imitation Learning**     | [ACT](./docs/source/policy_act_README.md), [Diffusion](./docs/source/policy_diffusion_README.md), [VQ-BeT](./docs/source/policy_vqbet_README.md)                                                             |
-| **Reinforcement Learning** | [HIL-SERL](./docs/source/hilserl.mdx), [TDMPC](./docs/source/policy_tdmpc_README.md) & QC-FQL (coming soon)                                                                                                  |
-| **VLAs Models**            | [Pi0Fast](./docs/source/pi0fast.mdx), [Pi0.5](./docs/source/pi05.mdx), [GR00T N1.5](./docs/source/policy_groot_README.md), [SmolVLA](./docs/source/policy_smolvla_README.md), [XVLA](./docs/source/xvla.mdx) |
+| Category                   | Models                                                                                                                                                                 |
+| -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Imitation Learning**     | [ACT](./docs/source/policy_act_README.md), [Diffusion](./docs/source/policy_diffusion_README.md), [VQ-BeT](./docs/source/policy_vqbet_README.md)                       |
+| **Reinforcement Learning** | [HIL-SERL](./docs/source/hilserl.mdx), [TDMPC](./docs/source/policy_tdmpc_README.md) & QC-FQL (coming soon)                                                            |
+| **VLAs Models**            | [Pi0.5](./docs/source/pi05.mdx), [GR00T N1.5](./docs/source/policy_groot_README.md), [SmolVLA](./docs/source/policy_smolvla_README.md), [XVLA](./docs/source/xvla.mdx) |

 Similarly to the hardware, you can easily implement your own policy & leverage LeRobot's data collection, training, and visualization tools, and share your model to the HF Hub

@@ -128,8 +127,7 @@ Learn how to implement your own simulation environment or benchmark and distribu
 ## Resources

 - **[Documentation](https://huggingface.co/docs/lerobot/index):** The complete guide to tutorials & API.
- **[Chinese Tutorials: LeRobot+SO-ARM101中文教程-同济子豪兄](https://zihao-ai.feishu.cn/wiki/space/7589642043471924447)** Detailed doc for assembling, teleoperate, dataset, train, deploy. Verified by Seed Studio and 5 global hackathon players.
- **[Discord](https://discord.gg/q8Dzzpym3f):** Join the `LeRobot` server to discuss with the community.
+- **[Discord](https://discord.gg/3gxM6Avj):** Join the `LeRobot` server to discuss with the community.
 - **[X](https://x.com/LeRobotHF):** Follow us on X to stay up-to-date with the latest developments.
 - **[Robot Learning Tutorial](https://huggingface.co/spaces/lerobot/robot-learning-tutorial):** A free, hands-on course to learn robot learning using LeRobot.

@@ -1,48 +0,0 @@
-# Security Policy
-
-## Project Status & Philosophy
-
-`lerobot` has so far been primarily a research and prototyping tool, which is why deployment security hasn’t been a strong focus until now. As `lerobot` continues to be adopted and deployed in production, we are paying much closer attention to these kinds of issues.
-
-Fortunately, being an open-source project, the community can also help by reporting and fixing vulnerabilities. We appreciate your efforts to responsibly disclose your findings and will make every effort to acknowledge your contributions.
-
-## Reporting a Vulnerability
-
-To report a security issue, please use the GitHub Security Advisory ["Report a Vulnerability"](https://github.com/huggingface/lerobot/security/advisories/new) tab.
-
-The `lerobot` team will send a response indicating the next steps in handling your report. After the initial reply to your report, the security team will keep you informed of the progress towards a fix and full announcement, and may ask for additional information or guidance.
-
-#### Hugging Face Security Team
-
-Since this project is part of the Hugging Face ecosystem, feel free to submit vulnerability reports directly to: **[security@huggingface.co](mailto:security@huggingface.co)**. Someone from the HF security team will review the report and recommend next steps.
-
-#### Open Source Disclosures
-
-If reporting a vulnerability specific to the open-source codebase (and not the underlying Hub infrastructure), you may also use [Huntr](https://huntr.com), a vulnerability disclosure program for open source software.
-
-## Supported Versions
-
-Currently, we treat `lerobot` as a rolling release. We prioritize security updates for the latest available version (`main` branch).
-
-| Version  | Supported |
-| -------- | --------- |
-| Latest   | ✅        |
-| < Latest | ❌        |
-
-## Secure Usage Guidelines
-
-`lerobot` is tightly coupled to the Hugging Face Hub for sharing data and pretrained policies. When downloading artifacts uploaded by others, you expose yourself to risks. Please read below for recommendations to keep your runtime and robot environment safe.
-
-### Remote Artefacts (Weights & Policies)
-
-Models and policies uploaded to the Hugging Face Hub come in different formats. We heavily recommend uploading and downloading models in the [`safetensors`](https://github.com/huggingface/safetensors) format.
-
-`safetensors` was developed specifically to prevent arbitrary code execution on your system, which is critical when running software on physical hardware/robots.
-
-To avoid loading models from unsafe formats (e.g., `pickle`), you should ensure you are prioritizing `safetensors` files.
-
-### Remote Code
-
-Some models or environments on the Hub may require `trust_remote_code=True` to run custom architecture code.
-
-Please **always** verify the content of the modeling files when using this argument. We recommend setting a specific `revision` (commit hash) when loading remote code to ensure you protect yourself from unverified updates to the repository.
@@ -28,9 +28,9 @@ We don't expect the same optimal settings for a dataset of images from a simulat
 For these reasons, we run this benchmark on four representative datasets:

 - `lerobot/pusht_image`: (96 x 96 pixels) simulation with simple geometric shapes, fixed camera.
- `lerobot/aloha_mobile_shrimp_image`: (480 x 640 pixels) real-world indoor, moving camera.
- `lerobot/paris_street`: (720 x 1280 pixels) real-world outdoor, moving camera.
- `lerobot/kitchen`: (1080 x 1920 pixels) real-world indoor, fixed camera.
+- `aliberts/aloha_mobile_shrimp_image`: (480 x 640 pixels) real-world indoor, moving camera.
+- `aliberts/paris_street`: (720 x 1280 pixels) real-world outdoor, moving camera.
+- `aliberts/kitchen`: (1080 x 1920 pixels) real-world indoor, fixed camera.

 Note: The datasets used for this benchmark need to be image datasets, not video datasets.

@@ -179,7 +179,7 @@ python benchmark/video/run_video_benchmark.py \
    --output-dir outputs/video_benchmark \
    --repo-ids \
        lerobot/pusht_image \
-        lerobot/aloha_mobile_shrimp_image \
+        aliberts/aloha_mobile_shrimp_image \
    --vcodec libx264 libx265 \
    --pix-fmt yuv444p yuv420p \
    --g 2 20 None \
@@ -203,9 +203,9 @@ python benchmark/video/run_video_benchmark.py \
    --output-dir outputs/video_benchmark \
    --repo-ids \
        lerobot/pusht_image \
-        lerobot/aloha_mobile_shrimp_image \
-        lerobot/paris_street \
-        lerobot/kitchen \
+        aliberts/aloha_mobile_shrimp_image \
+        aliberts/paris_street \
+        aliberts/kitchen \
    --vcodec libx264 libx265 \
    --pix-fmt yuv444p yuv420p \
    --g 1 2 3 4 5 6 10 15 20 40 None \
@@ -221,9 +221,9 @@ python benchmark/video/run_video_benchmark.py \
    --output-dir outputs/video_benchmark \
    --repo-ids \
        lerobot/pusht_image \
-        lerobot/aloha_mobile_shrimp_image \
-        lerobot/paris_street \
-        lerobot/kitchen \
+        aliberts/aloha_mobile_shrimp_image \
+        aliberts/paris_street \
+        aliberts/kitchen \
    --vcodec libsvtav1 \
    --pix-fmt yuv420p \
    --g 1 2 3 4 5 6 10 15 20 40 None \
@@ -252,37 +252,37 @@ Since we're using av1 encoding, we're choosing the `pyav` decoder as `video_read

 These tables show the results for `g=2` and `crf=30`, using `timestamps-modes=6_frames` and `backend=pyav`

-| video_images_size_ratio           | vcodec     | pix_fmt |           |           |           |
-| --------------------------------- | ---------- | ------- | --------- | --------- | --------- |
-|                                   | libx264    |         | libx265   |           | libsvtav1 |
-| repo_id                           | yuv420p    | yuv444p | yuv420p   | yuv444p   | yuv420p   |
-| lerobot/pusht_image               | **16.97%** | 17.58%  | 18.57%    | 18.86%    | 22.06%    |
-| lerobot/aloha_mobile_shrimp_image | 2.14%      | 2.11%   | 1.38%     | **1.37%** | 5.59%     |
-| lerobot/paris_street              | 2.12%      | 2.13%   | **1.54%** | **1.54%** | 4.43%     |
-| lerobot/kitchen                   | 1.40%      | 1.39%   | **1.00%** | **1.00%** | 2.52%     |
+| video_images_size_ratio            | vcodec     | pix_fmt |           |           |           |
+| ---------------------------------- | ---------- | ------- | --------- | --------- | --------- |
+|                                    | libx264    |         | libx265   |           | libsvtav1 |
+| repo_id                            | yuv420p    | yuv444p | yuv420p   | yuv444p   | yuv420p   |
+| lerobot/pusht_image                | **16.97%** | 17.58%  | 18.57%    | 18.86%    | 22.06%    |
+| aliberts/aloha_mobile_shrimp_image | 2.14%      | 2.11%   | 1.38%     | **1.37%** | 5.59%     |
+| aliberts/paris_street              | 2.12%      | 2.13%   | **1.54%** | **1.54%** | 4.43%     |
+| aliberts/kitchen                   | 1.40%      | 1.39%   | **1.00%** | **1.00%** | 2.52%     |

-| video_images_load_time_ratio      | vcodec  | pix_fmt |          |         |           |
-| --------------------------------- | ------- | ------- | -------- | ------- | --------- |
-|                                   | libx264 |         | libx265  |         | libsvtav1 |
-| repo_id                           | yuv420p | yuv444p | yuv420p  | yuv444p | yuv420p   |
-| lerobot/pusht_image               | 6.45    | 5.19    | **1.90** | 2.12    | 2.47      |
-| lerobot/aloha_mobile_shrimp_image | 11.80   | 7.92    | 0.71     | 0.85    | **0.48**  |
-| lerobot/paris_street              | 2.21    | 2.05    | 0.36     | 0.49    | **0.30**  |
-| lerobot/kitchen                   | 1.46    | 1.46    | 0.28     | 0.51    | **0.26**  |
+| video_images_load_time_ratio       | vcodec  | pix_fmt |          |         |           |
+| ---------------------------------- | ------- | ------- | -------- | ------- | --------- |
+|                                    | libx264 |         | libx265  |         | libsvtav1 |
+| repo_id                            | yuv420p | yuv444p | yuv420p  | yuv444p | yuv420p   |
+| lerobot/pusht_image                | 6.45    | 5.19    | **1.90** | 2.12    | 2.47      |
+| aliberts/aloha_mobile_shrimp_image | 11.80   | 7.92    | 0.71     | 0.85    | **0.48**  |
+| aliberts/paris_street              | 2.21    | 2.05    | 0.36     | 0.49    | **0.30**  |
+| aliberts/kitchen                   | 1.46    | 1.46    | 0.28     | 0.51    | **0.26**  |

-|                                   |          | vcodec   | pix_fmt      |          |           |              |
-| --------------------------------- | -------- | -------- | ------------ | -------- | --------- | ------------ |
-|                                   |          | libx264  |              | libx265  |           | libsvtav1    |
-| repo_id                           | metric   | yuv420p  | yuv444p      | yuv420p  | yuv444p   | yuv420p      |
-| lerobot/pusht_image               | avg_mse  | 2.90E-04 | **2.03E-04** | 3.13E-04 | 2.29E-04  | 2.19E-04     |
-|                                   | avg_psnr | 35.44    | 37.07        | 35.49    | **37.30** | 37.20        |
-|                                   | avg_ssim | 98.28%   | **98.85%**   | 98.31%   | 98.84%    | 98.72%       |
-| lerobot/aloha_mobile_shrimp_image | avg_mse  | 2.76E-04 | 2.59E-04     | 3.17E-04 | 3.06E-04  | **1.30E-04** |
-|                                   | avg_psnr | 35.91    | 36.21        | 35.88    | 36.09     | **40.17**    |
-|                                   | avg_ssim | 95.19%   | 95.18%       | 95.00%   | 95.05%    | **97.73%**   |
-| lerobot/paris_street              | avg_mse  | 6.89E-04 | 6.70E-04     | 4.03E-03 | 4.02E-03  | **3.09E-04** |
-|                                   | avg_psnr | 33.48    | 33.68        | 32.05    | 32.15     | **35.40**    |
-|                                   | avg_ssim | 93.76%   | 93.75%       | 89.46%   | 89.46%    | **95.46%**   |
-| lerobot/kitchen                   | avg_mse  | 2.50E-04 | 2.24E-04     | 4.28E-04 | 4.18E-04  | **1.53E-04** |
-|                                   | avg_psnr | 36.73    | 37.33        | 36.56    | 36.75     | **39.12**    |
-|                                   | avg_ssim | 95.47%   | 95.58%       | 95.52%   | 95.53%    | **96.82%**   |
+|                                    |          | vcodec   | pix_fmt      |          |           |              |
+| ---------------------------------- | -------- | -------- | ------------ | -------- | --------- | ------------ |
+|                                    |          | libx264  |              | libx265  |           | libsvtav1    |
+| repo_id                            | metric   | yuv420p  | yuv444p      | yuv420p  | yuv444p   | yuv420p      |
+| lerobot/pusht_image                | avg_mse  | 2.90E-04 | **2.03E-04** | 3.13E-04 | 2.29E-04  | 2.19E-04     |
+|                                    | avg_psnr | 35.44    | 37.07        | 35.49    | **37.30** | 37.20        |
+|                                    | avg_ssim | 98.28%   | **98.85%**   | 98.31%   | 98.84%    | 98.72%       |
+| aliberts/aloha_mobile_shrimp_image | avg_mse  | 2.76E-04 | 2.59E-04     | 3.17E-04 | 3.06E-04  | **1.30E-04** |
+|                                    | avg_psnr | 35.91    | 36.21        | 35.88    | 36.09     | **40.17**    |
+|                                    | avg_ssim | 95.19%   | 95.18%       | 95.00%   | 95.05%    | **97.73%**   |
+| aliberts/paris_street              | avg_mse  | 6.89E-04 | 6.70E-04     | 4.03E-03 | 4.02E-03  | **3.09E-04** |
+|                                    | avg_psnr | 33.48    | 33.68        | 32.05    | 32.15     | **35.40**    |
+|                                    | avg_ssim | 93.76%   | 93.75%       | 89.46%   | 89.46%    | **95.46%**   |
+| aliberts/kitchen                   | avg_mse  | 2.50E-04 | 2.24E-04     | 4.28E-04 | 4.18E-04  | **1.53E-04** |
+|                                    | avg_psnr | 36.73    | 37.33        | 36.56    | 36.75     | **39.12**    |
+|                                    | avg_ssim | 95.47%   | 95.58%       | 95.52%   | 95.53%    | **96.82%**   |
@@ -73,7 +73,7 @@ ENV HOME=/home/user_lerobot \
 RUN uv venv --python python${PYTHON_VERSION}

 # Install Python dependencies for caching
-COPY --chown=user_lerobot:user_lerobot setup.py pyproject.toml README.md MANIFEST.in ./
+COPY --chown=user_lerobot:user_lerobot pyproject.toml README.md MANIFEST.in ./
 COPY --chown=user_lerobot:user_lerobot src/ src/

 ARG UNBOUND_DEPS=false
@@ -59,7 +59,7 @@ ENV HOME=/home/user_lerobot \
 RUN uv venv

 # Install Python dependencies for caching
-COPY --chown=user_lerobot:user_lerobot setup.py pyproject.toml README.md MANIFEST.in ./
+COPY --chown=user_lerobot:user_lerobot pyproject.toml README.md MANIFEST.in ./
 COPY --chown=user_lerobot:user_lerobot src/ src/

 ARG UNBOUND_DEPS=false
@@ -7,6 +7,8 @@
 - sections:
  - local: il_robots
    title: Imitation Learning for Robots
+  - local: cameras
+    title: Cameras
  - local: bring_your_own_policies
    title: Bring Your Own Policies
  - local: integrate_hardware
@@ -27,8 +29,6 @@
    title: Porting Large Datasets
  - local: using_dataset_tools
    title: Using the Dataset Tools
-  - local: dataset_subtask
-    title: Using Subtasks in the Dataset
  title: "Datasets"
 - sections:
  - local: act
@@ -37,16 +37,12 @@
    title: SmolVLA
  - local: pi0
    title: π₀ (Pi0)
-  - local: pi0fast
-    title: π₀-FAST (Pi0Fast)
  - local: pi05
    title: π₀.₅ (Pi05)
  - local: groot
    title: NVIDIA GR00T N1.5
  - local: xvla
    title: X-VLA
-  - local: walloss
-    title: WALL-OSS
  title: "Policies"
 - sections:
  - local: sarm
@@ -63,8 +59,6 @@
    title: Environments from the Hub
  - local: envhub_leisaac
    title: Control & Train Robots in Sim (LeIsaac)
-  - local: envhub_isaaclab_arena
-    title: NVIDIA IsaacLab Arena Environments
  - local: libero
    title: Using Libero
  - local: metaworld
@@ -99,19 +93,11 @@
    title: Unitree G1
  - local: earthrover_mini_plus
    title: Earth Rover Mini
-  - local: omx
-    title: OMX
-  - local: openarm
-    title: OpenArm
  title: "Robots"
 - sections:
  - local: phone_teleop
    title: Phone
  title: "Teleoperators"
- sections:
-  - local: cameras
-    title: Cameras
-  title: "Sensors"
 - sections:
  - local: torch_accelerators
    title: PyTorch accelerators
@@ -121,8 +107,6 @@
    title: Notebooks
  - local: feetech
    title: Updating Feetech Firmware
-  - local: damiao
-    title: Damiao Motors and CAN Bus
  title: "Resources"
 - sections:
  - local: contributing
@@ -169,7 +169,7 @@ python -m lerobot.async_inference.robot_client \
 <!-- prettier-ignore-start -->
 ```python
 import threading
-from lerobot.robots.so_follower import SO100FollowerConfig
+from lerobot.robots.so100_follower import SO100FollowerConfig
 from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
 from lerobot.async_inference.configs import RobotClientConfig
 from lerobot.async_inference.robot_client import RobotClient
@@ -195,7 +195,6 @@ client_cfg = RobotClientConfig(
    robot=robot_cfg,
    server_address="localhost:8080",
    policy_device="mps",
-    client_device="cpu",
    policy_type="smolvla",
    pretrained_name_or_path="<user>/smolvla_async",
    chunk_size_threshold=0.5,
@@ -1,22 +1,12 @@
 # Cameras

-LeRobot offers multiple options for video capture:
+LeRobot offers multiple options for video capture, including phone cameras, built-in laptop cameras, external webcams, and Intel RealSense cameras. To efficiently record frames from most cameras, you can use either the `OpenCVCamera` or `RealSenseCamera` class. For additional compatibility details on the `OpenCVCamera` class, refer to the [Video I/O with OpenCV Overview](https://docs.opencv.org/4.x/d0/da7/videoio_overview.html).

-| Class             | Supported Cameras                   |
-| ----------------- | ----------------------------------- |
-| `OpenCVCamera`    | Phone, built-in laptop, USB webcams |
-| `ZMQCamera`       | Network-connected cameras           |
-| `RealSenseCamera` | Intel RealSense (with depth)        |
-| `Reachy2Camera`   | Reachy 2 robot cameras              |
+### Finding your camera

-> [!TIP]
-> For `OpenCVCamera` compatibility details, see the [Video I/O with OpenCV Overview](https://docs.opencv.org/4.x/d0/da7/videoio_overview.html).
+To instantiate a camera, you need a camera identifier. This identifier might change if you reboot your computer or re-plug your camera, a behavior mostly dependant on your operating system.

-### Find your camera
-
-Every camera requires a unique identifier to be instantiated, allowing you to distinguish between multiple connected devices.
-
-`OpenCVCamera` and `RealSenseCamera` support auto-discovery. Run the command below to list available devices and their identifiers. Note that these identifiers may change after rebooting your computer or re-plugging the camera, depending on your operating system.
+To find the camera indices of the cameras plugged into your system, run the following script:

 ```bash
 lerobot-find-cameras opencv # or realsense for Intel Realsense cameras
@@ -24,7 +14,7 @@ lerobot-find-cameras opencv # or realsense for Intel Realsense cameras

 The output will look something like this if you have two cameras connected:

-```bash
+```
 --- Detected Cameras ---
 Camera #0:
  Name: OpenCV Camera @ 0
@@ -43,37 +33,13 @@ Camera #0:
 > [!WARNING]
 > When using Intel RealSense cameras in `macOS`, you could get this [error](https://github.com/IntelRealSense/librealsense/issues/12307): `Error finding RealSense cameras: failed to set power state`, this can be solved by running the same command with `sudo` permissions. Note that using RealSense cameras in `macOS` is unstable.

-`ZMQCamera` and `Reachy2Camera` do not support auto-discovery. They must be configured manually by providing their network address and port or robot SDK settings.
+## Use Cameras

-## Use cameras
+Below are two examples, demonstrating how to work with the API.

-### Frame access modes
-
-All camera classes implement three access modes for capturing frames:
-
-| Method                    | Behavior                                                                                                                                                   | Blocks?        | Best For                                 |
-| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------- | ---------------------------------------- |
-| `read()`                  | Waits for the camera hardware to return a frame. May block for a long time depending on the camera and SDK.                                                | Yes            | Simple scripts, sequential capture       |
-| `async_read(timeout_ms)`  | Returns the latest unconsumed frame from background thread. Blocks only if buffer is empty, up to `timeout_ms`. Raises `TimeoutError` if no frame arrives. | With a timeout | Control loops synchronized to camera FPS |
-| `read_latest(max_age_ms)` | Peeks at the most recent frame in buffer (may be stale). Raises `TimeoutError` if frame is older than `max_age_ms`.                                        | No             | UI visualization, logging, monitoring    |
-
-### Usage examples
-
-The following examples show how to use the camera API to configure and capture frames from different camera types.
-
- **Blocking and non-blocking frame capture** using an OpenCV-based camera
+- **Asynchronous frame capture** using an OpenCV-based camera
 - **Color and depth capture** using an Intel RealSense camera

-> [!WARNING]
-> Failing to cleanly disconnect cameras can cause resource leaks. Use the context manager protocol to ensure automatic cleanup:
->
-> ```python
-> with OpenCVCamera(config) as camera:
->     ...
-> ```
->
-> You can also call `connect()` and `disconnect()` manually, but always use a `finally` block for the latter.
-
 <hfoptions id="shell_restart">
 <hfoption id="Open CV Camera">

@@ -94,30 +60,16 @@ config = OpenCVCameraConfig(
 )

 # Instantiate and connect an `OpenCVCamera`, performing a warm-up read (default).
-with OpenCVCamera(config) as camera:
-
-    # Read a frame synchronously — blocks until hardware delivers a new frame
-    frame = camera.read()
-    print(f"read() call returned frame with shape:", frame.shape)
-
-    # Read a frame asynchronously with a timeout — returns the latest unconsumed frame or waits up to timeout_ms for a new one
-    try:
-        for i in range(10):
-            frame = camera.async_read(timeout_ms=200)
-            print(f"async_read call returned frame {i} with shape:", frame.shape)
-    except TimeoutError as e:
-        print(f"No frame received within timeout: {e}")
-
-    # Instantly return a frame - returns the most recent frame captured by the camera
-    try:
-        initial_frame = camera.read_latest(max_age_ms=1000)
-        for i in range(10):
-            frame = camera.read_latest(max_age_ms=1000)
-            print(f"read_latest call returned frame {i} with shape:", frame.shape)
-            print(f"Was a new frame received by the camera? {not (initial_frame == frame).any()}")
-    except TimeoutError as e:
-        print(f"Frame too old: {e}")
+camera = OpenCVCamera(config)
+camera.connect()

+# Read frames asynchronously in a loop via `async_read(timeout_ms)`
+try:
+    for i in range(10):
+        frame = camera.async_read(timeout_ms=200)
+        print(f"Async frame {i} shape:", frame.shape)
+finally:
+    camera.disconnect()
 ```
 <!-- prettier-ignore-end -->

@@ -159,10 +111,10 @@ finally:
 </hfoption>
 </hfoptions>

-## Use your phone's camera
+## Use your phone

 <hfoptions id="use phone">
-<hfoption id="iPhone & macOS">
+<hfoption id="Mac">

 To use your iPhone as a camera on macOS, enable the Continuity Camera feature:

@@ -172,49 +124,83 @@ To use your iPhone as a camera on macOS, enable the Continuity Camera feature:

 For more details, visit [Apple support](https://support.apple.com/en-gb/guide/mac-help/mchl77879b8a/mac).

+Your iPhone should be detected automatically when running the camera setup script in the next section.
+
 </hfoption>
-<hfoption id="OBS virtual camera">
+<hfoption id="Linux">

-If you want to use your phone as a camera using OBS, follow these steps to set up a virtual camera.
+If you want to use your phone as a camera on Linux, follow these steps to set up a virtual camera

-1. _(Linux only) Install `v4l2loopback-dkms` and `v4l-utils`_. These packages create virtual camera devices and verify their settings. Install with:
+1. _Install `v4l2loopback-dkms` and `v4l-utils`_. Those packages are required to create virtual camera devices (`v4l2loopback`) and verify their settings with the `v4l2-ctl` utility from `v4l-utils`. Install them using:

-```bash
+<!-- prettier-ignore-start -->
+```python
 sudo apt install v4l2loopback-dkms v4l-utils
 ```
+<!-- prettier-ignore-end -->

-2. _Install the [DroidCam app](https://droidcam.app) on your phone_. This app is available for both iOS and Android.
-3. _Download and install [OBS Studio](https://obsproject.com)_.
-4. _Download and install the [DroidCam OBS plugin](https://droidcam.app/obs)_.
-5. _Start OBS Studio_.
+2. _Install [DroidCam](https://droidcam.app) on your phone_. This app is available for both iOS and Android.
+3. _Install [OBS Studio](https://obsproject.com)_. This software will help you manage the camera feed. Install it using [Flatpak](https://flatpak.org):

-6. _Add your phone as a source_. Follow the instructions [here](https://droidcam.app/obs/usage). Be sure to set the resolution to `640x480` to avoid the watermarks.
-7. _Adjust resolution settings_. In OBS Studio, go to `File > Settings > Video` or `OBS > Preferences... > Video`. Change the `Base(Canvas) Resolution` and the `Output(Scaled) Resolution` to `640x480` by manually typing it.
+<!-- prettier-ignore-start -->
+```python
+flatpak install flathub com.obsproject.Studio
+```
+<!-- prettier-ignore-end -->
+
+4. _Install the DroidCam OBS plugin_. This plugin integrates DroidCam with OBS Studio. Install it with:
+
+<!-- prettier-ignore-start -->
+```python
+flatpak install flathub com.obsproject.Studio.Plugin.DroidCam
+```
+<!-- prettier-ignore-end -->
+
+5. _Start OBS Studio_. Launch with:
+
+<!-- prettier-ignore-start -->
+```python
+flatpak run com.obsproject.Studio
+```
+<!-- prettier-ignore-end -->
+
+6. _Add your phone as a source_. Follow the instructions [here](https://droidcam.app/obs/usage). Be sure to set the resolution to `640x480`.
+7. _Adjust resolution settings_. In OBS Studio, go to `File > Settings > Video`. Change the `Base(Canvas) Resolution` and the `Output(Scaled) Resolution` to `640x480` by manually typing it in.
 8. _Start virtual camera_. In OBS Studio, follow the instructions [here](https://obsproject.com/kb/virtual-camera-guide).
-9. _Verify the virtual camera setup and resolution_.
-   - **Linux**: Use `v4l2-ctl` to list devices and check resolution:
-     ```bash
-     v4l2-ctl --list-devices  # find VirtualCam and note its /dev/videoX path
-     v4l2-ctl -d /dev/videoX --get-fmt-video  # replace with your VirtualCam path
-     ```
-     You should see `VirtualCam` listed and resolution `640x480`.
-   - **macOS**: Open Photo Booth or FaceTime and select "OBS Virtual Camera" as the input.
-   - **Windows**: The native Camera app doesn't support virtual cameras. Use a video conferencing app (Zoom, Teams) or run `lerobot-find-cameras opencv` directly to verify.
+9. _Verify the virtual camera setup_. Use `v4l2-ctl` to list the devices:

-<details>
-<summary><strong>Troubleshooting</strong></summary>
+<!-- prettier-ignore-start -->
+```python
+v4l2-ctl --list-devices
+```
+<!-- prettier-ignore-end -->

-> The virtual camera resolution is incorrect.
+You should see an entry like:

-Delete the virtual camera source and recreate it. The resolution cannot be changed after creation.
+```
+VirtualCam (platform:v4l2loopback-000):
+/dev/video1
+```

-> Error reading frame in background thread for OpenCVCamera(X): OpenCVCamera(X) frame width=640 or height=480 do not match configured width=1920 or height=1080.
+10. _Check the camera resolution_. Use `v4l2-ctl` to ensure that the virtual camera output resolution is `640x480`. Change `/dev/video1` to the port of your virtual camera from the output of `v4l2-ctl --list-devices`.

-This error is caused by OBS Virtual Camera advertising a `1920x1080` resolution despite rescaling. The only fix for now is to comment out the width and height check in `_postprocess_image()`.
+<!-- prettier-ignore-start -->
+```python
+v4l2-ctl -d /dev/video1 --get-fmt-video
+```
+<!-- prettier-ignore-end -->

-</details>
+You should see an entry like:
+
+```
+>>> Format Video Capture:
+>>>	Width/Height      : 640/480
+>>>	Pixel Format      : 'YUYV' (YUYV 4:2:2)
+```
+
+Troubleshooting: If the resolution is not correct you will have to delete the Virtual Camera port and try again as it cannot be changed.
+
+If everything is set up correctly, you can proceed with the rest of the tutorial.

 </hfoption>
 </hfoptions>
-
-If everything is set up correctly, your phone will appear as a standard OpenCV camera and can be used with `OpenCVCamera`.
@@ -1,165 +0,0 @@
-# Damiao Motors and CAN Bus
-
-This guide covers setup and usage of Damiao motors with LeRobot via CAN bus communication.
-
-Currently, only Linux is supported, as the OpenArms CAN adapter only has drivers for Linux.
-
-## Linux CAN Setup
-
-Before using Damiao motors, you need to set up the CAN interface on your Linux system.
-
-### Install CAN Utilities
-
-```bash
-sudo apt-get install can-utils
-```
-
-### Configure CAN Interface (Manual)
-
-For standard CAN FD (recommended for OpenArms):
-
-```bash
-sudo ip link set can0 down
-sudo ip link set can0 type can bitrate 1000000 dbitrate 5000000 fd on
-sudo ip link set can0 up
-```
-
-For standard CAN (without FD):
-
-```bash
-sudo ip link set can0 down
-sudo ip link set can0 type can bitrate 1000000
-sudo ip link set can0 up
-```
-
-### Configure CAN Interface (Using LeRobot)
-
-LeRobot provides a utility script to setup and test CAN interfaces:
-
-```bash
-# Setup multiple interfaces (e.g., OpenArms Followers with 2 CAN buses)
-lerobot-setup-can --mode=setup --interfaces=can0,can1
-```
-
-## Debugging CAN Communication
-
-Use the built-in debug tools to test motor communication:
-
-```bash
-# Test motors on all interfaces
-lerobot-setup-can --mode=test --interfaces=can0,can1
-
-# Run speed/latency test
-lerobot-setup-can --mode=speed --interfaces=can0
-```
-
-The test mode will scan for motors (IDs 0x01-0x08) and report which ones respond. Example output:
-
-```
-can0: UP (CAN FD)
-  Motor 0x01 (joint_1): ✓ FOUND
-    → Response 0x11 [FD]: 00112233...
-  Motor 0x02 (joint_2): ✓ FOUND
-  Motor 0x03 (joint_3): ✗ No response
-  ...
-  Summary: 2/8 motors found
-```
-
-## Usage
-
-### Basic Setup
-
-```python
-from lerobot.motors import Motor
-from lerobot.motors.damiao import DamiaoMotorsBus
-
-# Define your motors with send/receive CAN IDs
-motors = {
-    "joint_1": Motor(id=0x01, motor_type_str="dm8009", recv_id=0x11),
-    "joint_2": Motor(id=0x02, motor_type_str="dm4340", recv_id=0x12),
-    "joint_3": Motor(id=0x03, motor_type_str="dm4310", recv_id=0x13),
-}
-
-# Create the bus
-bus = DamiaoMotorsBus(
-    port="can0",  # Linux socketcan interface
-    motors=motors,
-)
-
-# Connect
-bus.connect()
-```
-
-### Reading Motor States
-
-```python
-# Read single motor position (degrees)
-position = bus.read("Present_Position", "joint_1")
-
-# Read from multiple motors
-positions = bus.sync_read("Present_Position")  # All motors
-positions = bus.sync_read("Present_Position", ["joint_1", "joint_2"])
-
-# Read all states at once (position, velocity, torque)
-states = bus.sync_read_all_states()
-# Returns: {'joint_1': {'position': 45.2, 'velocity': 1.3, 'torque': 0.5}, ...}
-```
-
-### Writing Motor Commands
-
-```python
-# Enable torque
-bus.enable_torque()
-
-# Set goal position (degrees)
-bus.write("Goal_Position", "joint_1", 45.0)
-
-# Set positions for multiple motors
-bus.sync_write("Goal_Position", {
-    "joint_1": 45.0,
-    "joint_2": -30.0,
-    "joint_3": 90.0,
-})
-
-# Disable torque
-bus.disable_torque()
-```
-
-## Configuration Options
-
-| Parameter      | Default   | Description                                                 |
-| -------------- | --------- | ----------------------------------------------------------- |
-| `port`         | -         | CAN interface (`can0`) or serial port (`/dev/cu.usbmodem*`) |
-| `use_can_fd`   | `True`    | Enable CAN FD for higher data rates                         |
-| `bitrate`      | `1000000` | Nominal bitrate (1 Mbps)                                    |
-| `data_bitrate` | `5000000` | CAN FD data bitrate (5 Mbps)                                |
-
-## Motor Configuration
-
-Each motor requires:
-
- `id`: CAN ID for sending commands
- `motor_type`: One of the supported motor types (e.g., `"dm8009"`, `"dm4340"`)
- `recv_id`: CAN ID for receiving responses
-
-OpenArms default IDs follow the pattern: send ID `0x0N`, receive ID `0x1N` where N is the joint number.
-
-## Troubleshooting
-
-### No Response from Motors
-
-1. **Check power**
-2. **Verify CAN wiring**: Check CAN-H, CAN-L, and GND connections
-3. **Check motor IDs**: Use Damiao Debugging Tools to verify/configure IDs
-4. **Test CAN interface**: Run `candump can0` to see if messages are being received
-5. **Run diagnostics**: `lerobot-setup-can --mode=test --interfaces=can0`
-
-### Motor Timeout Parameter
-
-If motors were configured with timeout=0, they won't respond to commands. Use Damiao Debugging Tools to set a non-zero timeout value.
-
-### Verify CAN FD Status
-
-```bash
-ip -d link show can0 | grep fd
-```
@@ -1,278 +0,0 @@
-# Using Subtasks in LeRobot Datasets
-
-Subtask support in robotics datasets has proven effective in improving robot reasoning and understanding. Subtasks are particularly useful for:
-
- **Hierarchical policies**: Building policies that include subtask predictions to visualize robot reasoning in real time
- **Reward modeling**: Helping reward models understand task progression (e.g., SARM-style stage-aware reward models)
- **Task decomposition**: Breaking down complex manipulation tasks into atomic, interpretable steps
-
-LeRobotDataset now supports subtasks as part of its dataset structure, alongside tasks.
-
-## What are Subtasks?
-
-While a **task** describes the overall goal (e.g., "Pick up the apple and place it in the basket"), **subtasks** break down the execution into finer-grained steps:
-
-1. "Approach the apple"
-2. "Grasp the apple"
-3. "Lift the apple"
-4. "Move to basket"
-5. "Release the apple"
-
-Each frame in the dataset can be annotated with its corresponding subtask, enabling models to learn and predict these intermediate stages.
-
-<img
-  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/subtask-asset.png"
-  alt="An overview of subtask annotation showing how frames are labeled with intermediate subtask stages"
-  width="80%"
-/>
-
-<p>
-  <em>Figure: Overview of subtask annotation.</em>
-</p>
-
-**Reference:** _Subtask-learning based for robot self-assembly in flexible collaborative assembly in manufacturing_, Original Article, Published: 19 April 2022.
-
-## Dataset Structure
-
-Subtask information is stored in the dataset metadata:
-
-```
-my-dataset/
-├── data/
-│   └── ...
-├── meta/
-│   ├── info.json
-│   ├── stats.json
-│   ├── tasks.parquet
-│   ├── subtasks.parquet      # Subtask index → subtask string mapping
-│   └── episodes/
-│       └── ...
-└── videos/
-    └── ...
-```
-
-### Subtasks Parquet File
-
-The `meta/subtasks.parquet` file maps subtask indices to their natural language descriptions:
-
-| subtask_index | subtask (index column) |
-| ------------- | ---------------------- |
-| 0             | "Approach the apple"   |
-| 1             | "Grasp the apple"      |
-| 2             | "Lift the apple"       |
-| ...           | ...                    |
-
-### Frame-Level Annotations
-
-Each frame in the dataset can include a `subtask_index` field that references the subtasks parquet file:
-
-```python
-# Example frame data in the parquet file
-{
-    "index": 42,
-    "timestamp": 1.4,
-    "episode_index": 0,
-    "task_index": 0,
-    "subtask_index": 2,  # References "Lift the apple"
-    "observation.state": [...],
-    "action": [...],
-}
-```
-
-## Annotating Datasets with Subtasks
-
-We provide a HuggingFace Space for easily annotating any LeRobotDataset with subtasks:
-
-**[https://huggingface.co/spaces/lerobot/annotate](https://huggingface.co/spaces/lerobot/annotate)**
-
-After completing your annotation:
-
-1. Click "Push to Hub" to upload your annotated dataset
-2. You can also run the annotation space locally by following the instructions at [github.com/huggingface/lerobot-annotate](https://github.com/huggingface/lerobot-annotate)
-
-## Loading Datasets with Subtasks
-
-When you load a dataset with subtask annotations, the subtask information is automatically available:
-
-```python
-from lerobot.datasets.lerobot_dataset import LeRobotDataset
-
-# Load a dataset with subtask annotations
-dataset = LeRobotDataset("jadechoghari/collect-fruit-annotated")
-
-# Access a sample
-sample = dataset[100]
-
-# The sample includes both task and subtask information
-print(sample["task"])        # "Collect the fruit"
-print(sample["subtask"])     # "Grasp the apple"
-print(sample["task_index"])  # tensor(0)
-print(sample["subtask_index"])  # tensor(2)
-```
-
-### Checking for Subtask Support
-
-You can check if a dataset has subtask annotations:
-
-```python
-# Check if subtasks are available
-has_subtasks = (
-    "subtask_index" in dataset.features
-    and dataset.meta.subtasks is not None
-)
-
-if has_subtasks:
-    print(f"Dataset has {len(dataset.meta.subtasks)} unique subtasks")
-    print("Subtasks:", list(dataset.meta.subtasks.index))
-```
-
-## Using Subtasks for Training
-
-### With the Tokenizer Processor
-
-The `TokenizerProcessor` automatically handles subtask tokenization for Vision-Language Action (VLA) models:
-
-```python
-from lerobot.processor.tokenizer_processor import TokenizerProcessor
-from lerobot.processor.pipeline import ProcessorPipeline
-
-# Create a tokenizer processor
-tokenizer_processor = TokenizerProcessor(
-    tokenizer_name_or_path="google/paligemma-3b-pt-224",
-    padding="max_length",
-    max_length=64,
-)
-
-# The processor will automatically tokenize subtasks if present in the batch
-# and add them to the observation under:
-# - "observation.subtask.tokens"
-# - "observation.subtask.attention_mask"
-```
-
-When subtasks are available in the batch, the tokenizer processor adds:
-
- `observation.subtask.tokens`: Tokenized subtask text
- `observation.subtask.attention_mask`: Attention mask for the subtask tokens
-
-### DataLoader with Subtasks
-
-```python
-import torch
-from lerobot.datasets.lerobot_dataset import LeRobotDataset
-
-dataset = LeRobotDataset("jadechoghari/collect-fruit-annotated")
-
-dataloader = torch.utils.data.DataLoader(
-    dataset,
-    batch_size=16,
-    shuffle=True,
-)
-
-for batch in dataloader:
-    # Access subtask information in the batch
-    subtasks = batch["subtask"]  # List of subtask strings
-    subtask_indices = batch["subtask_index"]  # Tensor of subtask indices
-
-    # Use for training hierarchical policies or reward models
-    print(f"Batch subtasks: {set(subtasks)}")
-```
-
-## Example Datasets with Subtask Annotations
-
-Try loading a dataset with subtask annotations:
-
-```python
-from lerobot.datasets.lerobot_dataset import LeRobotDataset
-
-# Example dataset with subtask annotations
-dataset = LeRobotDataset("jadechoghari/collect-fruit-annotated")
-
-# Explore the subtasks
-print("Available subtasks:")
-for subtask_name in dataset.meta.subtasks.index:
-    print(f"  - {subtask_name}")
-
-# Get subtask distribution
-subtask_counts = {}
-for i in range(len(dataset)):
-    sample = dataset[i]
-    subtask = sample["subtask"]
-    subtask_counts[subtask] = subtask_counts.get(subtask, 0) + 1
-
-print("\nSubtask distribution:")
-for subtask, count in sorted(subtask_counts.items(), key=lambda x: -x[1]):
-    print(f"  {subtask}: {count} frames")
-```
-
-## Use Cases
-
-### 1. Hierarchical Policy Training
-
-Train policies that predict both actions and current subtask:
-
-```python
-class HierarchicalPolicy(nn.Module):
-    def __init__(self, num_subtasks):
-        super().__init__()
-        self.action_head = nn.Linear(hidden_dim, action_dim)
-        self.subtask_head = nn.Linear(hidden_dim, num_subtasks)
-
-    def forward(self, observations):
-        features = self.encoder(observations)
-        actions = self.action_head(features)
-        subtask_logits = self.subtask_head(features)
-        return actions, subtask_logits
-```
-
-### 2. Stage-Aware Reward Modeling (SARM)
-
-Build reward models that understand task progression:
-
-```python
-# SARM predicts:
-# - Stage: Which subtask is being executed (discrete)
-# - Progress: How far along the subtask (continuous 0-1)
-
-class SARMRewardModel(nn.Module):
-    def forward(self, observations):
-        features = self.encoder(observations)
-        stage_logits = self.stage_classifier(features)
-        progress = self.progress_regressor(features)
-        return stage_logits, progress
-```
-
-### 3. Progress Visualization
-
-Monitor robot execution by tracking subtask progression:
-
-```python
-def visualize_execution(model, observations):
-    for t, obs in enumerate(observations):
-        action, subtask_logits = model(obs)
-        predicted_subtask = subtask_names[subtask_logits.argmax()]
-        print(f"t={t}: Executing '{predicted_subtask}'")
-```
-
-## API Reference
-
-### LeRobotDataset Properties
-
-| Property                    | Type                   | Description                                |
-| --------------------------- | ---------------------- | ------------------------------------------ |
-| `meta.subtasks`             | `pd.DataFrame \| None` | DataFrame mapping subtask names to indices |
-| `features["subtask_index"]` | `dict`                 | Feature spec for subtask_index if present  |
-
-### Sample Keys
-
-When subtasks are available, each sample includes:
-
-| Key             | Type           | Description                          |
-| --------------- | -------------- | ------------------------------------ |
-| `subtask_index` | `torch.Tensor` | Integer index of the current subtask |
-| `subtask`       | `str`          | Natural language subtask description |
-
-## Related Resources
-
- [SARM Paper](https://arxiv.org/pdf/2509.25358) - Stage-Aware Reward Modeling for Long Horizon Robot Manipulation
- [LeRobot Annotate Space](https://huggingface.co/spaces/lerobot/annotate) - Interactive annotation tool
- [LeRobotDataset v3.0](./lerobot-dataset-v3) - Dataset format documentation
@@ -1,11 +1,5 @@
 # EarthRover Mini Plus

-<img
-  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/Earth_Rover_Mini_5_240c9adc-4f9e-44b7-982f-5d1dc24af1d8.png.webp"
-  alt="EarthRover Mini Plus"
-  width="70%"
-/>
-
 The EarthRover Mini Plus is a fully open source mobile robot that connects through the cloud using the Frodobots SDK. This lets you control the robot and record datasets for training AI models.

 ## What You Need
@@ -18,42 +12,23 @@ The EarthRover Mini Plus is a fully open source mobile robot that connects throu

 ### Setting Up the Frodobots SDK

-The robot needs the [Frodobots SDK](https://github.com/frodobots-org/earth-rovers-sdk) running on your computer. Here's how:
+The robot needs the [Frodobots SDK](https://github.com/Frodobots/earth-rovers-sdk) running on your computer. Here's how:

 1. Download and install the SDK:

 ```bash
-git clone https://github.com/frodobots-org/earth-rovers-sdk.git
+git clone https://github.com/Frodobots/earth-rovers-sdk.git
 cd earth-rovers-sdk
 pip install -r requirements.txt
 ```

-2. Save Credentials:
-
-Write your .env variables with the SDK API key and bot name provided by the Frodobots team.
-
-```bash
-SDK_API_TOKEN=your_sdk_api_token_here
-BOT_SLUG=your_bot_slug_here
-CHROME_EXECUTABLE_PATH=/path/to/chrome_or_chromium
-# Default value is MAP_ZOOM_LEVEL=18 https://wiki.openstreetmap.org/wiki/Zoom_levels
-MAP_ZOOM_LEVEL=18
-MISSION_SLUG=your_mission_slug_here
-# Image quality between 0.1 and 1.0 (default: 0.8)
-# Recommended: 0.8 for better performance
-IMAGE_QUALITY=0.8
-# Image format: jpeg, png or webp (default: png)
-# Recommended: jpeg for better performance and lower bandwidth usage
-IMAGE_FORMAT=jpeg
-```
-
-3. Start the SDK:
+2. Start the SDK:

 ```bash
 hypercorn main:app --reload
 ```

-4. Open your web browser and go to `http://localhost:8000`, then click "Join"
+3. Open your web browser and go to `http://localhost:8000`, then click "Join"

 The SDK gives you:

@@ -185,7 +160,7 @@ echo $HF_USER
 Use the standard recording command:

 ```bash
-lerobot-record \
+python src/lerobot/scripts/lerobot_record.py \
    --robot.type=earthrover_mini_plus \
    --teleop.type=keyboard_rover \
    --dataset.repo_id=your_username/dataset_name \
@@ -2,32 +2,14 @@

 The **EnvHub** feature allows you to load simulation environments directly from the Hugging Face Hub with a single line of code. This unlocks a powerful new model for collaboration: instead of environments being locked away inside monolithic libraries, anyone can publish custom environments and share them with the community.

-## What is EnvHub?
+## Overview

-EnvHub lets you create custom robotics simulation environments with your own robot models and scenarios, and make them easily usable by anyone through the LeRobot framework.
+With EnvHub, you can:

-EnvHub packages are stored on the Hugging Face Hub, and can be seamlessly pulled and used in your AI robotics projects through LeRobot with a single line of code.
-
-Thanks to EnvHub, you can:
-
-1. **Create and publish environments** to the Hugging Face Hub as Git repositories, and distribute complex physics simulations without packaging hassles
-2. **Load environments** dynamically, without installing them as packages
-3. **Version and track** environment changes using Git semantics
-4. **Discover** new simulation tasks shared by the community
-
-This design means you can go from discovering an interesting environment on the Hub to running experiments in seconds, or create your own custom robot and environment without worrying about dependency conflicts or complex installation procedures.
-
-When you create an EnvHub package, you can build anything you want inside it and use any simulation tool you like: this is your own space to play with. The only requirement is that the package contains an `env.py` file that defines the environment and allows LeRobot to load and use your EnvHub package.
-
-This `env.py` file needs to expose a small API so LeRobot can load and run it. In particular, you must provide a `make_env(n_envs: int = 1, use_async_envs: bool = False)` or `make_env(n_envs: int = 1, use_async_envs: bool = False, cfg: EnvConfig)` function, which is the main entry point for LeRobot. It should return one of:
-
- A `gym.vector.VectorEnv` (most common)
- A single `gym.Env` (will be automatically wrapped)
- A dict mapping `{suite_name: {task_id: VectorEnv}}` (for multi-task benchmarks)
-
-You can also pass an `EnvConfig` object to `make_env` to configure the environment (e.g. the number of environments, task, camera name, initial states, control mode, episode length, etc.).
-
-Finally, your environment must implement the standard `gym.vector.VectorEnv` interface so it works with LeRobot, including methods like `reset` and `step`.
+- Load environments from the Hub instantly
+- Share your custom simulation tasks with the community
+- Version control your environments using Git
+- Distribute complex physics simulations without packaging hassles

 ## Quick Start

@@ -47,6 +29,17 @@ env = make_env("lerobot/cartpole-env", trust_remote_code=True)
  hash for reproducibility and security.
 </Tip>

+## What is EnvHub?
+
+EnvHub is a framework that allows researchers and developers to:
+
+1. **Publish environments** to the Hugging Face Hub as Git repositories
+2. **Load environments** dynamically without installing them as packages
+3. **Version and track** environment changes using Git semantics
+4. **Discover** new simulation tasks shared by the community
+
+This design means you can go from discovering an interesting environment on the Hub to running experiments in seconds, without worrying about dependency conflicts or complex installation procedures.
+
 ## Repository Structure

 To make your environment loadable from the Hub, your repository must contain at minimum:
@@ -1,510 +0,0 @@
-# NVIDIA IsaacLab Arena & LeRobot
-
-LeRobot EnvHub now supports **GPU-accelerated simulation** with IsaacLab Arena for policy evaluation at scale.
-Train and evaluate imitation learning policies with high-fidelity simulation — all integrated into the LeRobot ecosystem.
-
-<img
-  src="https://huggingface.co/nvidia/isaaclab-arena-envs/resolve/main/assets/Gr1OpenMicrowaveEnvironment.png"
-  alt="IsaacLab Arena - GR1 Microwave Environment"
-  style={{ maxWidth: "100%", borderRadius: "8px", marginBottom: "1rem" }}
-/>
-
-[IsaacLab Arena](https://github.com/isaac-sim/IsaacLab-Arena) integrates with NVIDIA IsaacLab to provide:
-
- 🤖 **Humanoid embodiments**: GR1, G1, Galileo with various configurations
- 🎯 **Manipulation & loco-manipulation tasks**: Door opening, pick-and-place, button pressing, and more
- ⚡ **GPU-accelerated rollouts**: Parallel environment execution on NVIDIA GPUs
- 🖼️ **RTX Rendering**: Evaluate vision-based policies with realistic rendering, reflections and refractions
- 📦 **LeRobot-compatible datasets**: Ready for training with GR00T N1x, PI0, SmolVLA, ACT, and Diffusion policies
- 🔄 **EnvHub integration**: Load environments from HuggingFace EnvHub with one line
-
-## Installation
-
-### Prerequisites
-
-Hardware requirements are shared with Isaac Sim, and are detailed in [Isaac Sim Requirements](https://docs.isaacsim.omniverse.nvidia.com/5.1.0/installation/requirements.html).
-
- NVIDIA GPU with CUDA support
- NVIDIA driver compatible with IsaacSim 5.1.0
- Linux (Ubuntu 22.04 / 24.04)
-
-### Setup
-
-```bash
-# 1. Create conda environment
-conda create -y -n lerobot-arena python=3.11
-conda activate lerobot-arena
-conda install -y -c conda-forge ffmpeg=7.1.1
-
-# 2. Install Isaac Sim 5.1.0
-pip install "isaacsim[all,extscache]==5.1.0" --extra-index-url https://pypi.nvidia.com
-
-# Accept NVIDIA EULA (required)
-export ACCEPT_EULA=Y
-export PRIVACY_CONSENT=Y
-
-# 3. Install IsaacLab 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
-git checkout release/0.1.1
-pip install -e .
-cd ..
-
-
-# 5. Install LeRobot
-git clone https://github.com/huggingface/lerobot.git
-cd lerobot
-pip install -e .
-cd ..
-
-
-# 6. Install additional dependencies
-pip install onnxruntime==1.23.2 lightwheel-sdk==1.0.1 vuer[all]==0.0.70 qpsolvers==4.8.1
-pip install numpy==1.26.0 # Isaac Sim 5.1 depends on numpy==1.26.0, this will be fixed in next release
-```
-
-## Evaluating Policies
-
-### Pre-trained Policies
-
-The following trained policies are available:
-
-| Policy                      | Architecture | Task          | Link                                                                     |
-| :-------------------------- | :----------- | :------------ | :----------------------------------------------------------------------- |
-| pi05-arena-gr1-microwave    | PI0.5        | GR1 Microwave | [HuggingFace](https://huggingface.co/nvidia/pi05-arena-gr1-microwave)    |
-| smolvla-arena-gr1-microwave | SmolVLA      | GR1 Microwave | [HuggingFace](https://huggingface.co/nvidia/smolvla-arena-gr1-microwave) |
-
-### Evaluate SmolVLA
-
-```bash
-pip install -e ".[smolvla]"
-pip install numpy==1.26.0 # revert numpy to version 1.26
-```
-
-```bash
-lerobot-eval \
-    --policy.path=nvidia/smolvla-arena-gr1-microwave \
-    --env.type=isaaclab_arena \
-    --env.hub_path=nvidia/isaaclab-arena-envs \
-    --rename_map='{"observation.images.robot_pov_cam_rgb": "observation.images.robot_pov_cam"}' \
-    --policy.device=cuda \
-    --env.environment=gr1_microwave \
-    --env.embodiment=gr1_pink \
-    --env.object=mustard_bottle \
-    --env.headless=false \
-    --env.enable_cameras=true \
-    --env.video=true \
-    --env.video_length=10 \
-    --env.video_interval=15 \
-    --env.state_keys=robot_joint_pos \
-    --env.camera_keys=robot_pov_cam_rgb \
-    --trust_remote_code=True \
-    --eval.batch_size=1
-```
-
-### Evaluate PI0.5
-
-```bash
-pip install -e ".[pi]"
-pip install numpy==1.26.0 # revert numpy to version 1.26
-```
-
-<Tip>PI0.5 requires disabling torch compile for evaluation:</Tip>
-
-```bash
-TORCH_COMPILE_DISABLE=1 TORCHINDUCTOR_DISABLE=1 lerobot-eval \
-    --policy.path=nvidia/pi05-arena-gr1-microwave \
-    --env.type=isaaclab_arena \
-    --env.hub_path=nvidia/isaaclab-arena-envs \
-    --rename_map='{"observation.images.robot_pov_cam_rgb": "observation.images.robot_pov_cam"}' \
-    --policy.device=cuda \
-    --env.environment=gr1_microwave \
-    --env.embodiment=gr1_pink \
-    --env.object=mustard_bottle \
-    --env.headless=false \
-    --env.enable_cameras=true \
-    --env.video=true \
-    --env.video_length=15 \
-    --env.video_interval=15 \
-    --env.state_keys=robot_joint_pos \
-    --env.camera_keys=robot_pov_cam_rgb \
-    --trust_remote_code=True \
-    --eval.batch_size=1
-```
-
-<Tip>
-  To change the number of parallel environments, use the ```--eval.batch_size```
-  flag.
-</Tip>
-
-### What to Expect
-
-During evaluation, you will see a progress bar showing the running success rate:
-
-```
-Stepping through eval batches:   8%|██████▍    | 4/50 [00:45<08:06, 10.58s/it, running_success_rate=25.0%]
-```
-
-### Video Recording
-
-To enable video recording during evaluation, add the following flags to your command:
-
-```bash
--env.video=true \
--env.video_length=15 \
--env.video_interval=15
-```
-
-For more details on video recording, see the [IsaacLab Recording Documentation](https://isaac-sim.github.io/IsaacLab/main/source/how-to/record_video.html).
-
-<Tip>
-When running headless with `--env.headless=true`, you must also enable cameras explicitly for camera enabled environments:
-
-```bash
--env.headless=true --env.enable_cameras=true
-```
-
-</Tip>
-
-### Output Directory
-
-Evaluation videos are saved to the output directory with the following structure:
-
-```
-outputs/eval/<date>/<timestamp>_<env>_<policy>/videos/<task>_<env_id>/eval_episode_<n>.mp4
-```
-
-For example:
-
-```
-outputs/eval/2026-01-02/14-38-01_isaaclab_arena_smolvla/videos/gr1_microwave_0/eval_episode_0.mp4
-```
-
-## Training Policies
-
-To learn more about training policies with LeRobot, please refer to the training documentation:
-
- [SmolVLA](./smolvla)
- [Pi0.5](./pi05)
- [GR00T N1.5](./groot)
-
-Sample IsaacLab Arena datasets are available on HuggingFace Hub for experimentation:
-
-| Dataset                                                                                                   | Description                | Frames |
-| :-------------------------------------------------------------------------------------------------------- | :------------------------- | :----- |
-| [Arena-GR1-Manipulation-Task](https://huggingface.co/datasets/nvidia/Arena-GR1-Manipulation-Task-v3)      | GR1 microwave manipulation | ~4K    |
-| [Arena-G1-Loco-Manipulation-Task](https://huggingface.co/datasets/nvidia/Arena-G1-Loco-Manipulation-Task) | G1 loco-manipulation       | ~4K    |
-
-## Environment Configuration
-
-### Full Configuration Options
-
-```python
-from lerobot.envs.configs import IsaaclabArenaEnv
-
-config = IsaaclabArenaEnv(
-    # Environment selection
-    environment="gr1_microwave",      # Task environment
-    embodiment="gr1_pink",            # Robot embodiment
-    object="power_drill",             # Object to manipulate
-
-    # Simulation settings
-    episode_length=300,               # Max steps per episode
-    headless=True,                    # Run without GUI
-    device="cuda:0",                  # GPU device
-    seed=42,                          # Random seed
-
-    # Observation configuration
-    state_keys="robot_joint_pos",     # State observation keys (comma-separated)
-    camera_keys="robot_pov_cam_rgb",  # Camera observation keys (comma-separated)
-    state_dim=54,                     # Expected state dimension
-    action_dim=36,                    # Expected action dimension
-    camera_height=512,                # Camera image height
-    camera_width=512,                 # Camera image width
-    enable_cameras=True,              # Enable camera observations
-
-    # Video recording
-    video=False,                      # Enable video recording
-    video_length=100,                 # Frames per video
-    video_interval=200,               # Steps between recordings
-
-    # Advanced
-    mimic=False,                      # Enable mimic mode
-    teleop_device=None,               # Teleoperation device
-    disable_fabric=False,             # Disable fabric optimization
-    enable_pinocchio=True,            # Enable Pinocchio for IK
-)
-```
-
-### Using Environment Hub directly for advanced usage
-
-Create a file called `test_env_load_arena.py` or [download from the EnvHub](https://huggingface.co/nvidia/isaaclab-arena-envs/blob/main/tests/test_env_load_arena.py):
-
-```python
-import logging
-from dataclasses import asdict
-from pprint import pformat
-import torch
-import tqdm
-from lerobot.configs import parser
-from lerobot.configs.eval import EvalPipelineConfig
-
-
-@parser.wrap()
-def main(cfg: EvalPipelineConfig):
-    """Run random action rollout for IsaacLab Arena environment."""
-    logging.info(pformat(asdict(cfg)))
-
-    from lerobot.envs.factory import make_env
-
-    env_dict = make_env(
-        cfg.env,
-        n_envs=cfg.env.num_envs,
-        trust_remote_code=True,
-    )
-    env = next(iter(env_dict.values()))[0]
-    env.reset()
-    for _ in tqdm.tqdm(range(cfg.env.episode_length)):
-        with torch.inference_mode():
-            actions = env.action_space.sample()
-            obs, rewards, terminated, truncated, info = env.step(actions)
-            if terminated.any() or truncated.any():
-                obs, info = env.reset()
-    env.close()
-
-
-if __name__ == "__main__":
-    main()
-```
-
-Run with:
-
-```bash
-python test_env_load_arena.py \
-    --env.environment=g1_locomanip_pnp \
-    --env.embodiment=gr1_pink \
-    --env.object=cracker_box \
-    --env.num_envs=4 \
-    --env.enable_cameras=true \
-    --env.seed=1000 \
-    --env.video=true \
-    --env.video_length=10 \
-    --env.video_interval=15 \
-    --env.headless=false \
-    --env.hub_path=nvidia/isaaclab-arena-envs \
-    --env.type=isaaclab_arena
-```
-
-## Creating New Environments
-
-First create a new IsaacLab Arena environment by following the [IsaacLab Arena Documentation](https://isaac-sim.github.io/IsaacLab-Arena/release/0.1.1/index.html).
-
-Clone our EnvHub repo:
-
-```bash
-git clone https://huggingface.co/nvidia/isaaclab-arena-envs
-```
-
-Modify the `example_envs.yaml` file based on your new environment.
-[Upload](./envhub#step-3-upload-to-the-hub) your modified repo to HuggingFace EnvHub.
-
-<Tip>
-  Your IsaacLab Arena environment code must be locally available during
-  evaluation. Users can clone your environment repository separately, or you can
-  bundle the environment code and assets directly in your EnvHub repo.
-</Tip>
-
-Then, when evaluating, use your new environment:
-
-```bash
-lerobot-eval \
-    --env.hub_path=<your-env-hub-path>/isaaclab-arena-envs \
-    --env.environment=<your new environment> \
-    ...other flags...
-```
-
-We look forward to your contributions!
-
-## Troubleshooting
-
-### CUDA out of memory
-
-Reduce `batch_size` or use a GPU with more VRAM:
-
-```bash
--eval.batch_size=1
-```
-
-### EULA not accepted
-
-Set environment variables before running:
-
-```bash
-export ACCEPT_EULA=Y
-export PRIVACY_CONSENT=Y
-```
-
-### Video recording not working
-
-Enable cameras when running headless:
-
-```bash
--env.video=true --env.enable_cameras=true --env.headless=true
-```
-
-### Policy output dimension mismatch
-
-Ensure `action_dim` matches your policy:
-
-```bash
--env.action_dim=36
-```
-
-### libGLU.so.1 Errors during Isaac Sim initialization
-
-Ensure you have the following dependencies installed, this is likely to happen on headless machines.
-
-```bash
-sudo apt update && sudo apt install -y libglu1-mesa libxt6
-```
-
-## See Also
-
- [EnvHub Documentation](./envhub.mdx) - General EnvHub usage
- [IsaacLab Arena GitHub](https://github.com/isaac-sim/IsaacLab-Arena)
- [IsaacLab Documentation](https://isaac-sim.github.io/IsaacLab/)
-
-## Lightwheel LW-BenchHub
-
-[Lightwheel](https://www.lightwheel.ai) is bringing `Lightwheel-Libero-Tasks` and `Lightwheel-RoboCasa-Tasks` with 268 tasks to the LeRobot ecosystem.
-LW-BenchHub collects and generates large-scale datasets via teleoperation that comply with the LeRobot specification, enabling out-of-the-box training and evaluation workflows.
-With the unified interface provided by EnvHub, developers can quickly build end-to-end experimental pipelines.
-
-### Install
-
-Assuming you followed the [Installation](#installation) steps, you can install LW-BenchHub with:
-
-```bash
-conda install pinocchio -c conda-forge -y
-pip install numpy==1.26.0 # revert numpy to version 1.26
-
-sudo apt-get install git-lfs && git lfs install
-
-git clone https://github.com/LightwheelAI/lw_benchhub
-git lfs pull # Ensure LFS files (e.g., .usd assets) are downloaded
-
-cd lw_benchhub
-pip install -e .
-```
-
-For more detailed instructions, please refer to the [LW-BenchHub Documentation](https://docs.lightwheel.net/lw_benchhub/usage/Installation).
-
-### Lightwheel Tasks Dataset
-
-LW-BenchHub datasets are available on HuggingFace Hub:
-
-| Dataset                                                                                                       | Description             | Tasks | Frames |
-| :------------------------------------------------------------------------------------------------------------ | :---------------------- | :---- | :----- |
-| [Lightwheel-Tasks-X7S](https://huggingface.co/datasets/LightwheelAI/Lightwheel-Tasks-X7S)                     | X7S LIBERO and RoboCasa | 117   | ~10.3M |
-| [Lightwheel-Tasks-Double-Piper](https://huggingface.co/datasets/LightwheelAI/Lightwheel-Tasks-Double-Piper)   | Double-Piper LIBERO     | 130   | ~6.0M  |
-| [Lightwheel-Tasks-G1-Controller](https://huggingface.co/datasets/LightwheelAI/Lightwheel-Tasks-G1-Controller) | G1-Controller LIBERO    | 62    | ~2.7M  |
-| [Lightwheel-Tasks-G1-WBC](https://huggingface.co/datasets/LightwheelAI/Lightwheel-Tasks-G1-WBC)               | G1-WBC RoboCasa         | 32    | ~1.5M  |
-
-For training policies, refer to the [Training Policies](#training-policies) section.
-
-### Evaluating Policies
-
-#### Pre-trained Policies
-
-The following trained policies are available:
-
-| Policy                   | Architecture | Task                           | Layout     | Robot           | Link                                                                                  |
-| :----------------------- | :----------- | :----------------------------- | :--------- | :-------------- | :------------------------------------------------------------------------------------ |
-| smolvla-double-piper-pnp | SmolVLA      | L90K1PutTheBlackBowlOnThePlate | libero-1-1 | DoublePiper-Abs | [HuggingFace](https://huggingface.co/LightwheelAI/smolvla-double-piper-pnp/tree/main) |
-
-#### Evaluate SmolVLA
-
-```bash
-lerobot-eval \
-  --policy.path=LightwheelAI/smolvla-double-piper-pnp \
-  --env.type=isaaclab_arena \
-  --rename_map='{"observation.images.left_hand_camera_rgb": "observation.images.left_hand", "observation.images.right_hand_camera_rgb": "observation.images.right_hand", "observation.images.first_person_camera_rgb": "observation.images.first_person"}' \
-  --env.hub_path=LightwheelAI/lw_benchhub_env \
-  --env.kwargs='{"config_path": "configs/envhub/example.yml"}' \
-  --trust_remote_code=true \
-  --env.state_keys=joint_pos \
-  --env.action_dim=12 \
-  --env.camera_keys=left_hand_camera_rgb,right_hand_camera_rgb,first_person_camera_rgb \
-  --policy.device=cuda \
-  --eval.batch_size=10 \
-  --eval.n_episodes=100
-```
-
-### Environment Configuration
-
-Evaluation can be quickly launched by modifying the `robot`, `task`, and `layout` settings in the configuration file.
-
-#### Full Configuration Options
-
-```yml
-# =========================
-# Basic Settings
-# =========================
-disable_fabric: false
-device: cuda:0
-sensitivity: 1.0
-step_hz: 50
-enable_cameras: true
-execute_mode: eval
-episode_length_s: 20.0 # Episode length in seconds, increase if episodes timeout during eval
-
-# =========================
-# Robot Settings
-# =========================
-robot: DoublePiper-Abs # Robot type, DoublePiper-Abs, X7S-Abs, G1-Controller or G1-Controller-DecoupledWBC
-robot_scale: 1.0
-
-# =========================
-# Task & Scene Settings
-# =========================
-task: L90K1PutTheBlackBowlOnThePlate # Task name
-scene_backend: robocasa
-task_backend: robocasa
-debug_assets: null
-layout: libero-1-1 # Layout and style ID
-sources:
-  - objaverse
-  - lightwheel
-  - aigen_objs
-object_projects: []
-usd_simplify: false
-seed: 42
-
-# =========================
-# Object Placement Retry Settings
-# =========================
-max_scene_retry: 4
-max_object_placement_retry: 3
-
-resample_objects_placement_on_reset: true
-resample_robot_placement_on_reset: true
-
-# =========================
-# Replay Configuration Settings
-# =========================
-replay_cfgs:
-  add_camera_to_observation: true
-  render_resolution: [640, 480]
-```
-
-### See Also
-
- [LW-BenchHub GitHub](https://github.com/LightwheelAI/LW-BenchHub)
- [LW-BenchHub Documentation](https://docs.lightwheel.net/lw_benchhub/)
@@ -137,8 +137,7 @@ from lerobot.teleoperators import (  # noqa: F401
    Teleoperator,
    TeleoperatorConfig,
    make_teleoperator_from_config,
-    so_leader,
-    bi_so_leader,
+    so101_leader,
 )
 from lerobot.utils.robot_utils import precise_sleep
 from lerobot.utils.utils import init_logging
@@ -197,7 +196,7 @@ def teleop_loop(teleop: Teleoperator, env: gym.Env, fps: int):
            obs, info = env.reset()

        dt_s = time.perf_counter() - loop_start
-        precise_sleep(max(1 / fps - dt_s, 0.0))
+        precise_sleep(1 / fps - dt_s)
        loop_s = time.perf_counter() - loop_start
        print(f"\ntime: {loop_s * 1e3:.2f}ms ({1 / loop_s:.0f} Hz)")

@@ -223,7 +222,7 @@ def teleoperate(cfg: TeleoperateConfig):

 def main():
    teleoperate(TeleoperateConfig(
-        teleop=so_leader.SO101LeaderConfig(
+        teleop=so101_leader.SO101LeaderConfig(
            port="/dev/ttyACM0",
            id='leader',
            use_degrees=False,
@@ -12,12 +12,6 @@ Developers and researchers can post-train GR00T N1.5 with their own real or synt

 GR00T N1.5 (specifically the GR00T-N1.5-3B model) is built using pre-trained vision and language encoders. It utilizes a flow matching action transformer to model a chunk of actions, conditioned on vision, language, and proprioception.

-<img
-  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/lerobot-groot-paper1%20(1).png"
-  alt="An overview of GR00T"
-  width="80%"
-/>
-
 Its strong performance comes from being trained on an expansive and diverse humanoid dataset, which includes:

 - Real captured data from robots.
@@ -109,7 +103,7 @@ Once you have trained your model using your parameters you can run inference in

 ```bash
 lerobot-record \
-  --robot.type=bi_so_follower \
+  --robot.type=bi_so100_follower \
  --robot.left_arm_port=/dev/ttyACM1 \
  --robot.right_arm_port=/dev/ttyACM0 \
  --robot.id=bimanual_follower \
@@ -224,7 +224,7 @@ lerobot-record \
    --teleop.port=/dev/tty.usbmodem1201 \
    --teleop.id=right \
    --teleop.side=right \
-    --dataset.repo_id=<USER>/hand_record_test_with_video_data \
+    --dataset.repo_id=nepyope/hand_record_test_with_video_data \
    --dataset.single_task="Hand recording test with video data" \
    --dataset.num_episodes=1 \
    --dataset.episode_time_s=5 \
@@ -241,7 +241,7 @@ lerobot-replay \
    --robot.port=/dev/tty.usbmodem58760432281 \
    --robot.id=right \
    --robot.side=right \
-    --dataset.repo_id=<USER>/hand_record_test_with_camera \
+    --dataset.repo_id=nepyope/hand_record_test_with_camera \
    --dataset.episode=0
 ```

@@ -249,13 +249,13 @@ lerobot-replay \

 ```bash
 lerobot-train \
-  --dataset.repo_id=<USER>/hand_record_test_with_video_data \
+  --dataset.repo_id=nepyope/hand_record_test_with_video_data \
  --policy.type=act \
  --output_dir=outputs/train/hopejr_hand \
  --job_name=hopejr \
  --policy.device=mps \
  --wandb.enable=true \
-  --policy.repo_id=<USER>/hand_test_policy
+  --policy.repo_id=nepyope/hand_test_policy
 ```

 ### Evaluate
@@ -270,7 +270,7 @@ lerobot-record \
  --robot.side=right \
  --robot.cameras='{"main": {"type": "opencv", "index_or_path": 0, "width": 640, "height": 480, "fps": 30}}' \
  --display_data=false \
-  --dataset.repo_id=<USER>/eval_hopejr \
+  --dataset.repo_id=nepyope/eval_hopejr \
  --dataset.single_task="Evaluate hopejr hand policy" \
  --dataset.num_episodes=10 \
  --policy.path=outputs/train/hopejr_hand/checkpoints/last/pretrained_model
@@ -58,8 +58,8 @@ lerobot-teleoperate \

 <!-- prettier-ignore-start -->
 ```python
-from lerobot.teleoperators.so_leader import SO101LeaderConfig, SO101Leader
-from lerobot.robots.so_follower import SO101FollowerConfig, SO101Follower
+from lerobot.teleoperators.so101_leader import SO101LeaderConfig, SO101Leader
+from lerobot.robots.so101_follower import SO101FollowerConfig, SO101Follower

 robot_config = SO101FollowerConfig(
    port="/dev/tty.usbmodem58760431541",
@@ -195,9 +195,9 @@ lerobot-record \
 from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
 from lerobot.datasets.lerobot_dataset import LeRobotDataset
 from lerobot.datasets.utils import hw_to_dataset_features
-from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
-from lerobot.teleoperators.so_leader.config_so100_leader import SO100LeaderConfig
-from lerobot.teleoperators.so_leader.so100_leader import SO100Leader
+from lerobot.robots.so100_follower import SO100Follower, SO100FollowerConfig
+from lerobot.teleoperators.so100_leader.config_so100_leader import SO100LeaderConfig
+from lerobot.teleoperators.so100_leader.so100_leader import SO100Leader
 from lerobot.utils.control_utils import init_keyboard_listener
 from lerobot.utils.utils import log_say
 from lerobot.utils.visualization_utils import init_rerun
@@ -408,8 +408,8 @@ lerobot-replay \
 import time

 from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.robots.so_follower.config_so100_follower import SO100FollowerConfig
-from lerobot.robots.so_follower.so100_follower import SO100Follower
+from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
+from lerobot.robots.so100_follower.so100_follower import SO100Follower
 from lerobot.utils.robot_utils import precise_sleep
 from lerobot.utils.utils import log_say

@@ -432,7 +432,7 @@ for idx in range(dataset.num_frames):
    }
    robot.send_action(action)

-    precise_sleep(max(1.0 / dataset.fps - (time.perf_counter() - t0), 0.0))
+    precise_sleep(1.0 / dataset.fps - (time.perf_counter() - t0))

 robot.disconnect()
 ```
@@ -531,8 +531,8 @@ from lerobot.datasets.lerobot_dataset import LeRobotDataset
 from lerobot.datasets.utils import hw_to_dataset_features
 from lerobot.policies.act.modeling_act import ACTPolicy
 from lerobot.policies.factory import make_pre_post_processors
-from lerobot.robots.so_follower.config_so100_follower import SO100FollowerConfig
-from lerobot.robots.so_follower.so100_follower import SO100Follower
+from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
+from lerobot.robots.so100_follower.so100_follower import SO100Follower
 from lerobot.scripts.lerobot_record import record_loop
 from lerobot.utils.control_utils import init_keyboard_listener
 from lerobot.utils.utils import log_say
@@ -1,15 +1,13 @@
 # Installation

-This guide uses conda (via miniforge) to manage environments. If you prefer another environment manager (e.g. `uv`, `venv`), ensure you have Python >=3.10 and ffmpeg installed with the `libsvtav1` encoder, then skip ahead to [Install LeRobot](#step-3-install-lerobot-).
-
-## Step 1: Install [`miniforge`](https://conda-forge.org/download/)
+## Install [`miniforge`](https://conda-forge.org/download/)

 ```bash
 wget "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
 bash Miniforge3-$(uname)-$(uname -m).sh
 ```

-## Step 2: Environment Setup
+## Environment Setup

 Create a virtual environment with Python 3.10, using conda:

@@ -40,7 +38,7 @@ conda install ffmpeg -c conda-forge
 >
 > - _[On Linux only]_ If you want to bring your own ffmpeg: Install [ffmpeg build dependencies](https://trac.ffmpeg.org/wiki/CompilationGuide/Ubuntu#GettheDependencies) and [compile ffmpeg from source with libsvtav1](https://trac.ffmpeg.org/wiki/CompilationGuide/Ubuntu#libsvtav1), and make sure you use the corresponding ffmpeg binary to your install with `which ffmpeg`.

-## Step 3: Install LeRobot 🤗
+## Install LeRobot 🤗

 ### From Source

@@ -18,7 +18,7 @@ If you're using Feetech or Dynamixel motors, LeRobot provides built-in bus inter
 - [`DynamixelMotorsBus`](https://github.com/huggingface/lerobot/blob/main/src/lerobot/motors/dynamixel/dynamixel.py) – for controlling Dynamixel servos

 Please refer to the [`MotorsBus`](https://github.com/huggingface/lerobot/blob/main/src/lerobot/motors/motors_bus.py) abstract class to learn about its API.
-For a good example of how it can be used, you can have a look at our own [SO101 follower implementation](https://github.com/huggingface/lerobot/blob/main/src/lerobot/robots/so_follower/so101_follower/so101_follower.py)
+For a good example of how it can be used, you can have a look at our own [SO101 follower implementation](https://github.com/huggingface/lerobot/blob/main/src/lerobot/robots/so101_follower/so101_follower.py)

 Use these if compatible. Otherwise, you'll need to find or write a Python interface (not covered in this tutorial):

@@ -1,11 +1,5 @@
 # LeKiwi

-<img
-  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/1740517739083.jpeg"
-  alt="LeKiwi"
-  width="70%"
-/>
-
 In the steps below, we explain how to assemble the LeKiwi mobile robot.

 ## Source the parts
@@ -210,7 +204,7 @@ lerobot-calibrate \

 <!-- prettier-ignore-start -->
 ```python
-from lerobot.teleoperators.so_leader import SO100LeaderConfig, SO100Leader
+from lerobot.teleoperators.so100_leader import SO100LeaderConfig, SO100Leader

 config = SO100LeaderConfig(
    port="/dev/tty.usbmodem58760431551",
@@ -42,7 +42,6 @@ lerobot-eval \
 ```

 - `--env.task` picks the suite (`libero_object`, `libero_spatial`, etc.).
- `--env.task_ids` picks task ids to run (`[0]`, `[1,2,3]`, etc.). Omit this flag (or set it to `null`) to run all tasks in the suite.
 - `--eval.batch_size` controls how many environments run in parallel.
 - `--eval.n_episodes` sets how many episodes to run in total.

@@ -1,197 +0,0 @@
-## Order and Assemble the parts
-
-First, assemble the OMX hardware following the official assembly guide.
-
-OMX Assembly Guide: https://ai.robotis.com/omx/assembly_guide_omx.html
-
-OMX robots are shipped preconfigured from the factory. Motor IDs, communication parameters, and joint offsets are already set, so no additional motor setup or calibration is required before using LeRobot.
-
-## Install LeRobot 🤗
-
-To install LeRobot, follow our [Installation Guide](./installation)
-
-In addition to these instructions, you need to install the Dynamixel SDK:
-
-```bash
-pip install -e ".[dynamixel]"
-```
-
-## Connect the robot
-
-To find the port for each bus servo adapter, run this script:
-
-```bash
-lerobot-find-port
-```
-
-This command runs and when prompted, disconnect the USB cable from either the leader or follower arm and press Enter. The output will show 'The port of this MotorsBus is [port]'. This identifies the port for the disconnected arm. Repeat for the other arm to identify both ports.
-
-<hfoptions id="find_port">
-<hfoption id="Mac">
-
-Example output on macOS:
-
-```
-Finding all available ports for the MotorBus.
-['/dev/tty.usbmodem575E0032081', '/dev/tty.usbmodem575E0031751']
-Remove the USB cable from your MotorsBus and press Enter when done.
-
-[...Disconnect corresponding leader or follower arm and press Enter...]
-
-The port of this MotorsBus is /dev/tty.usbmodem575E0032081
-Reconnect the USB cable.
-```
-
-Where the found port is: `/dev/tty.usbmodem575E0032081` corresponding to your leader or follower arm.
-
-</hfoption>
-<hfoption id="Linux">
-
-On Linux, we strongly recommend using udev rules to assign persistent and human-readable device names to the OMX leader and follower arms. This avoids issues where device names such as ttyACM0 and ttyACM1 change when the robot is unplugged, replugged, or when the system is rebooted.
-
-#### 1. Find your device serial numbers
-
-You should have obtained the port numbers like ../../ttyACM? for the leader and follower using `lerobot-find-port`. You can match those results with the serial numbers using the `ls -l /dev/serial/by-id/` command.
-To create udev rules, you need the unique serial number for each OMX device. The easiest way is to list devices under:
-
-```bash
-ls -l /dev/serial/by-id/
-```
-
-You will see output similar to:
-
-```bash
-usb-ROBOTIS_OpenRB-150_228BDD7B503059384C2E3120FF0A2B19-if00 -> ../../ttyACM0
-usb-ROBOTIS_OpenRB-150_67E1ED68503059384C2E3120FF092234-if00 -> ../../ttyACM1
-```
-
-In each line, the serial number is the long string after `usb-ROBOTIS_OpenRB-150_` and before `-if00`.
-
-Follower serial: `228BDD7B503059384C2E3120FF0A2B19`
-
-Leader serial: `67E1ED68503059384C2E3120FF092234`
-
-#### 2. Create the udev rule
-
-Create a new udev rule file:
-
-```bash
-sudo nano /etc/udev/rules.d/99-omx.rules
-```
-
-Paste the following lines, replacing the serial numbers with the values you found above:
-
-```bash
-SUBSYSTEM=="tty", ATTRS{idVendor}=="0403", ATTRS{serial}=="228BDD7B503059384C2E3120FF0A2B19", SYMLINK+="omx_follower"
-SUBSYSTEM=="tty", ATTRS{idVendor}=="0403", ATTRS{serial}=="67E1ED68503059384C2E3120FF092234", SYMLINK+="omx_leader"
-```
-
-Save the file and reload udev rules:
-
-```bash
-sudo udevadm control --reload-rules
-sudo udevadm trigger
-```
-
-Now unplug and replug both devices once.
-
-#### 3. Verify the symlinks
-
-Check that the persistent device names exist:
-
-```bash
-ls -l /dev/omx_follower /dev/omx_leader
-```
-
-You should see them pointing to ttyACM\* devices:
-
-```bash
-/dev/omx_follower -> ttyACM*
-/dev/omx_leader   -> ttyACM*
-```
-
-These names remain stable across reboots and reconnections.
-
-</hfoption>
-</hfoptions>
-
-## Teleoperate
-
-After identifying the correct ports, you can directly teleoperate the follower arm using the leader arm.
-
-<hfoptions id="teleoperate">
-<hfoption id="Mac">
-
-### Teleoperate without camera
-
-```bash
-lerobot-teleoperate \
-  --robot.type=omx_follower \
-  --robot.port=<your_follower_port> \
-  --robot.id=omx_follower_arm \
-  --teleop.type=omx_leader \
-  --teleop.port=<your_leader_port> \
-  --teleop.id=omx_leader_arm
-```
-
-During teleoperation, motions of the leader arm are mirrored in real time by the follower arm. OMX is already preconfigured, teleoperation can begin immediately without any calibration steps.
-
-### Teleoperate with camera
-
-You can also enable camera input during teleoperation by providing a camera configuration for the follower arm.
-
-```bash
-lerobot-teleoperate \
-  --robot.type=omx_follower \
-  --robot.port=<your_follower_port> \
-  --robot.id=omx_follower_arm \
-  --robot.cameras="{front: {type: opencv, index_or_path: '/dev/video0', width: 640, height: 480, fps: 30}}" \
-  --teleop.type=omx_leader \
-  --teleop.port=<your_leader_port> \
-  --teleop.id=omx_leader_arm \
-  --display_data=true
-```
-
-When the camera is enabled, the camera stream is displayed in real time and synchronized with the robot state. This setup is useful for visual monitoring and can be reused later for demonstration recording and imitation learning.
-
-</hfoption>
-<hfoption id="Linux">
-
-### Teleoperate without camera
-
-```bash
-lerobot-teleoperate \
-  --robot.type=omx_follower \
-  --robot.port=/dev/omx_follower \
-  --robot.id=omx_follower_arm \
-  --teleop.type=omx_leader \
-  --teleop.port=/dev/omx_leader \
-  --teleop.id=omx_leader_arm
-```
-
-During teleoperation, motions of the leader arm are mirrored in real time by the follower arm. OMX is already preconfigured, teleoperation can begin immediately without any calibration steps.
-
-### Teleoperate with camera
-
-You can also enable camera input during teleoperation by providing a camera configuration for the follower arm.
-
-```bash
-lerobot-teleoperate \
-  --robot.type=omx_follower \
-  --robot.port=/dev/omx_follower \
-  --robot.id=omx_follower_arm \
-  --robot.cameras="{front: {type: opencv, index_or_path: '/dev/video0', width: 640, height: 480, fps: 30}}" \
-  --teleop.type=omx_leader \
-  --teleop.port=/dev/omx_leader \
-  --teleop.id=omx_leader_arm \
-  --display_data=true
-```
-
-When the camera is enabled, the camera stream is displayed in real time and synchronized with the robot state. This setup is useful for visual monitoring and can be reused later for demonstration recording and imitation learning.
-
-</hfoption>
-</hfoptions>
-
-Congrats 🎉, your robot is all set to learn a task on its own.
-
-> If you have any questions or need help, please reach out on [Discord](https://discord.com/invite/robotis).
@@ -1,276 +0,0 @@
-# OpenArm
-
-[OpenArm](https://openarm.dev) is an open-source 7DOF humanoid arm designed for physical AI research and deployment.
-
-To get your OpenArm, assembled or DIY, and join the global community, browse verified and certified manufacturers worldwide at [openarm.dev](https://openarm.dev).
-
-## What's Unique?
-
- **Human-Scale Design**: OpenArm is designed with human-like proportions, scaled for a person around 160-165cm tall. This provides an optimal balance between practical reach and manageable inertia for safe, responsive operation.
-
- **Safety-First Architecture**: Built with QDD backdrivable motors and high compliance, OpenArm prioritizes safe human-robot interaction while maintaining practical payload capabilities (6.0kg peak / 4.1kg nominal) for real-world tasks.
-
- **Built for Durability**: Critical structural components use aluminum and stainless steel construction, ensuring robust performance for repetitive data collection and continuous research use.
-
- **Fully Accessible & Buildable**: Every component, from CNC parts and 3D-printed casings to electrical wiring is designed to be purchasable and buildable by individual researchers and labs, with complete fabrication data provided.
-
- **Practical & Affordable**: At $6,500 USD for a complete bimanual system, OpenArm delivers research-grade capabilities at a fraction of traditional humanoid robot costs.
-
-## Platform Requirements
-
-<Tip warning={true}>
-  **Linux Only**: OpenArm currently only works on Linux. The CAN bus USB adapter
-  does not have macOS drivers and has not been tested on Windows.
-</Tip>
-
-## Safety Guide
-
-Before operating OpenArm, please read the [official safety guide](https://docs.openarm.dev/getting-started/safety-guide). Key points:
-
- **Secure installation**: Fasten the arm to a flat, stable surface with screws or clamps
- **Safe distance**: Keep body parts and objects outside the range of motion during operation
- **Protective equipment**: Always wear safety goggles; use additional PPE as needed
- **Payload limits**: Do not exceed specified payload limits (6.0kg peak / 4.1kg nominal per arm)
- **Emergency stop**: Know the location and operation of the emergency stop device
- **Regular inspection**: Check for loose screws, damaged mechanical limits, unusual noises, and wiring damage
-
-## Hardware Setup
-
-Follow the official [OpenArm hardware documentation](https://docs.openarm.dev) for:
-
- Bill of materials and sourcing
- 3D printing instructions
- Mechanical assembly
- Electrical wiring
-
-The hardware repositories are available at [github.com/enactic/openarm](https://github.com/enactic/openarm).
-
-## CAN Bus Setup
-
-OpenArm uses CAN bus communication with Damiao motors. Once you have the CAN bus USB adapter plugged into your Linux PC, follow the [Damiao Motors and CAN Bus guide](./damiao) to configure the interface.
-
-Quick setup:
-
-```bash
-# Setup CAN interfaces
-lerobot-setup-can --mode=setup --interfaces=can0,can1
-
-# Test motor communication
-lerobot-setup-can --mode=test --interfaces=can0,can1
-```
-
-## Install LeRobot 🤗
-
-Follow our [Installation Guide](./installation), then install the Damiao motor support:
-
-```bash
-pip install -e ".[damiao]"
-```
-
-## Usage
-
-### Follower Arm (Robot)
-
-<hfoptions id="follower">
-<hfoption id="Command">
-
-```bash
-lerobot-calibrate \
-    --robot.type=openarm_follower \
-    --robot.port=can0 \
-    --robot.side=right \
-    --robot.id=my_openarm_follower
-```
-
-</hfoption>
-<hfoption id="API example">
-
-```python
-from lerobot.robots.openarm_follower import OpenArmFollower, OpenArmFollowerConfig
-
-config = OpenArmFollowerConfig(
-    port="can0",
-    side="right",  # or "left" for left arm
-    id="my_openarm_follower",
-)
-
-follower = OpenArmFollower(config)
-follower.connect()
-
-# Read current state
-obs = follower.get_observation()
-print(obs)
-
-# Send action (position in degrees)
-action = {
-    "joint_1.pos": 0.0,
-    "joint_2.pos": 0.0,
-    "joint_3.pos": 0.0,
-    "joint_4.pos": 45.0,
-    "joint_5.pos": 0.0,
-    "joint_6.pos": 0.0,
-    "joint_7.pos": 0.0,
-    "gripper.pos": 0.0,
-}
-follower.send_action(action)
-
-follower.disconnect()
-```
-
-</hfoption>
-</hfoptions>
-
-### Leader Arm (Teleoperator)
-
-The leader arm is used for teleoperation - manually moving it to control the follower arm.
-
-<hfoptions id="leader">
-<hfoption id="Command">
-
-```bash
-lerobot-calibrate \
-    --teleop.type=openarm_leader \
-    --teleop.port=can1 \
-    --teleop.id=my_openarm_leader
-```
-
-</hfoption>
-<hfoption id="API example">
-
-```python
-from lerobot.teleoperators.openarm_leader import OpenArmLeader, OpenArmLeaderConfig
-
-config = OpenArmLeaderConfig(
-    port="can1",
-    id="my_openarm_leader",
-    manual_control=True,  # Disable torque for manual movement
-)
-
-leader = OpenArmLeader(config)
-leader.connect()
-
-# Read current position (as action to send to follower)
-action = leader.get_action()
-print(action)
-
-leader.disconnect()
-```
-
-</hfoption>
-</hfoptions>
-
-### Teleoperation
-
-To teleoperate OpenArm with leader-follower control:
-
-```bash
-lerobot-teleoperate \
-    --robot.type=openarm_follower \
-    --robot.port=can0 \
-    --robot.side=right \
-    --robot.id=my_follower \
-    --teleop.type=openarm_leader \
-    --teleop.port=can1 \
-    --teleop.id=my_leader
-```
-
-### Bimanual Teleoperation
-
-To teleoperate a bimanual OpenArm setup with two leader and two follower arms:
-
-```bash
-lerobot-teleoperate \
-    --robot.type=bi_openarm_follower \
-    --robot.left_arm_config.port=can0 \
-    --robot.left_arm_config.side=left \
-    --robot.right_arm_config.port=can1 \
-    --robot.right_arm_config.side=right \
-    --robot.id=my_bimanual_follower \
-    --teleop.type=bi_openarm_leader \
-    --teleop.left_arm_config.port=can2 \
-    --teleop.right_arm_config.port=can3 \
-    --teleop.id=my_bimanual_leader
-```
-
-### Recording Data
-
-To record a dataset during teleoperation:
-
-```bash
-lerobot-record \
-    --robot.type=openarm_follower \
-    --robot.port=can0 \
-    --robot.side=right \
-    --robot.id=my_follower \
-    --teleop.type=openarm_leader \
-    --teleop.port=can1 \
-    --teleop.id=my_leader \
-    --repo-id=my_hf_username/my_openarm_dataset \
-    --fps=30 \
-    --num-episodes=10
-```
-
-## Configuration Options
-
-### Follower Configuration
-
-| Parameter             | Default   | Description                                                |
-| --------------------- | --------- | ---------------------------------------------------------- |
-| `port`                | -         | CAN interface (e.g., `can0`)                               |
-| `side`                | `None`    | Arm side: `"left"`, `"right"`, or `None` for custom limits |
-| `use_can_fd`          | `True`    | Enable CAN FD for higher data rates                        |
-| `can_bitrate`         | `1000000` | Nominal bitrate (1 Mbps)                                   |
-| `can_data_bitrate`    | `5000000` | CAN FD data bitrate (5 Mbps)                               |
-| `max_relative_target` | `None`    | Safety limit for relative target positions                 |
-| `position_kp`         | Per-joint | Position control proportional gains                        |
-| `position_kd`         | Per-joint | Position control derivative gains                          |
-
-### Leader Configuration
-
-| Parameter          | Default   | Description                         |
-| ------------------ | --------- | ----------------------------------- |
-| `port`             | -         | CAN interface (e.g., `can1`)        |
-| `manual_control`   | `True`    | Disable torque for manual movement  |
-| `use_can_fd`       | `True`    | Enable CAN FD for higher data rates |
-| `can_bitrate`      | `1000000` | Nominal bitrate (1 Mbps)            |
-| `can_data_bitrate` | `5000000` | CAN FD data bitrate (5 Mbps)        |
-
-## Motor Configuration
-
-OpenArm uses Damiao motors with the following default configuration:
-
-| Joint                       | Motor Type | Send ID | Recv ID |
-| --------------------------- | ---------- | ------- | ------- |
-| joint_1 (Shoulder pan)      | DM8009     | 0x01    | 0x11    |
-| joint_2 (Shoulder lift)     | DM8009     | 0x02    | 0x12    |
-| joint_3 (Shoulder rotation) | DM4340     | 0x03    | 0x13    |
-| joint_4 (Elbow flex)        | DM4340     | 0x04    | 0x14    |
-| joint_5 (Wrist roll)        | DM4310     | 0x05    | 0x15    |
-| joint_6 (Wrist pitch)       | DM4310     | 0x06    | 0x16    |
-| joint_7 (Wrist rotation)    | DM4310     | 0x07    | 0x17    |
-| gripper                     | DM4310     | 0x08    | 0x18    |
-
-## Troubleshooting
-
-### No Response from Motors
-
-1. Check power supply connections
-2. Verify CAN wiring (CAN-H, CAN-L, GND)
-3. Run diagnostics: `lerobot-setup-can --mode=test --interfaces=can0`
-4. See the [Damiao troubleshooting guide](./damiao#troubleshooting) for more details
-
-### CAN Interface Not Found
-
-Ensure the CAN interface is configured:
-
-```bash
-ip link show can0
-```
-
-## Resources
-
- [OpenArm Website](https://openarm.dev)
- [OpenArm Documentation](https://docs.openarm.dev)
- [OpenArm GitHub](https://github.com/enactic/openarm)
- [Safety Guide](https://docs.openarm.dev/getting-started/safety-guide)
- [Damiao Motors and CAN Bus](./damiao)
@@ -44,7 +44,7 @@ Modify the examples to use `PhoneOS.IOS` or `PhoneOS.ANDROID` in `PhoneConfig`.

 Teleoperation example:

-```python
+```36:43:examples/phone_so100_teleop.py
 from lerobot.teleoperators.phone.config_phone import PhoneConfig, PhoneOS

 teleop_config = PhoneConfig(phone_os=PhoneOS.IOS)  # or PhoneOS.ANDROID
@@ -103,7 +103,7 @@ Additionally you can customize mapping or safety limits by editing the processor

 - Kinematics are used in multiple steps. We use [Placo](https://github.com/Rhoban/placo) which is a wrapper around Pinocchio for handling our kinematics. We construct the kinematics object by passing the robot's URDF and target frame. We set `target_frame_name` to the gripper frame.

-  ```python
+  ```examples/phone_to_so100/teleoperate.py
  kinematics_solver = RobotKinematics(
    urdf_path="./SO101/so101_new_calib.urdf",
    target_frame_name="gripper_frame_link",
@@ -114,7 +114,7 @@ Additionally you can customize mapping or safety limits by editing the processor

 - The `MapPhoneActionToRobotAction` step converts the calibrated phone pose and inputs into target deltas and gripper commands, below is shown what the step outputs.

-  ```python
+  ```src/lerobot/teleoperators/phone/phone_processor.py
  action["enabled"] = enabled
        action["target_x"] = -pos[1] if enabled else 0.0
        action["target_y"] = pos[0] if enabled else 0.0
@@ -127,7 +127,7 @@ Additionally you can customize mapping or safety limits by editing the processor

 - The `EEReferenceAndDelta` step converts target deltas to an absolute desired EE pose, storing a reference on enable, the `end_effector_step_sizes` are the step sizes for the EE pose and can be modified to change the motion speed.

-  ```python
+  ```examples/phone_to_so100/teleoperate.py
  EEReferenceAndDelta(
      kinematics=kinematics_solver,
      end_effector_step_sizes={"x": 0.5, "y": 0.5, "z": 0.5},
@@ -138,7 +138,7 @@ Additionally you can customize mapping or safety limits by editing the processor

 - The `EEBoundsAndSafety` step clamps EE motion to a workspace and checks for large ee step jumps to ensure safety. The `end_effector_bounds` are the bounds for the EE pose and can be modified to change the workspace. The `max_ee_step_m` are the step limits for the EE pose and can be modified to change the safety limits.

-  ```python
+  ```examples/phone_to_so100/teleoperate.py
  EEBoundsAndSafety(
      end_effector_bounds={"min": [-1.0, -1.0, -1.0], "max": [1.0, 1.0, 1.0]},
      max_ee_step_m=0.10,
@@ -147,7 +147,7 @@ Additionally you can customize mapping or safety limits by editing the processor

 - The `GripperVelocityToJoint` step turns a velocity‑like gripper input into absolute gripper position using the current measured state. The `speed_factor` is the factor by which the velocity is multiplied.

-  ```python
+  ```examples/phone_to_so100/teleoperate.py
  GripperVelocityToJoint(speed_factor=20.0)
  ```

@@ -157,7 +157,7 @@ We use different IK initial guesses in the kinematic steps. As initial guess eit

 - Closed loop (used in record/eval): sets `initial_guess_current_joints=True` so IK starts from the measured joints each frame.

-  ```python
+  ```examples/phone_to_so100/record.py
  InverseKinematicsEEToJoints(
      kinematics=kinematics_solver,
      motor_names=list(robot.bus.motors.keys()),
@@ -167,7 +167,7 @@ We use different IK initial guesses in the kinematic steps. As initial guess eit

 - Open loop (used in replay): sets `initial_guess_current_joints=False` so IK continues from the previous IK solution rather than the measured state. This preserves action stability when we replay without feedback.

-  ```python
+  ```examples/phone_to_so100/replay.py
  InverseKinematicsEEToJoints(
      kinematics=kinematics_solver,
      motor_names=list(robot.bus.motors.keys()),
@@ -6,12 +6,6 @@

 π₀ represents a breakthrough in robotics as the first general-purpose robot foundation model developed by [Physical Intelligence](https://www.physicalintelligence.company/blog/pi0). Unlike traditional robot programs that are narrow specialists programmed for repetitive motions, π₀ is designed to be a generalist policy that can understand visual inputs, interpret natural language instructions, and control a variety of different robots across diverse tasks.

-<img
-  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/lerobot-pi0%20(1).png"
-  alt="An overview of Pi0"
-  width="85%"
-/>
-
 ### The Vision for Physical Intelligence

 As described by Physical Intelligence, while AI has achieved remarkable success in digital domains, from chess-playing to drug discovery, human intelligence still dramatically outpaces AI in the physical world. To paraphrase Moravec's paradox, winning a game of chess represents an "easy" problem for AI, but folding a shirt or cleaning up a table requires solving some of the most difficult engineering problems ever conceived. π₀ represents a first step toward developing artificial physical intelligence that enables users to simply ask robots to perform any task they want, just like they can with large language models.
@@ -60,7 +54,7 @@ policy.type=pi0
 For training π₀, you can use the standard LeRobot training script with the appropriate configuration:

 ```bash
-lerobot-train \
+python src/lerobot/scripts/lerobot_train.py \
    --dataset.repo_id=your_dataset \
    --policy.type=pi0 \
    --output_dir=./outputs/pi0_training \
@@ -70,8 +64,6 @@ lerobot-train \
    --policy.compile_model=true \
    --policy.gradient_checkpointing=true \
    --policy.dtype=bfloat16 \
-    --policy.freeze_vision_encoder=false \
-    --policy.train_expert_only=false \
    --steps=3000 \
    --policy.device=cuda \
    --batch_size=32
@@ -87,15 +79,6 @@ lerobot-train \
  - [lerobot/pi0_base](https://huggingface.co/lerobot/pi0_base)
  - [lerobot/pi0_libero](https://huggingface.co/lerobot/pi0_libero) (specifically trained on the Libero dataset)

-### Training Parameters Explained
-
-| Parameter               | Default | Description                                 |
-| ----------------------- | ------- | ------------------------------------------- |
-| `freeze_vision_encoder` | `false` | Do not freeze the vision encoder            |
-| `train_expert_only`     | `false` | Do not freeze the VLM, train all parameters |
-
-**💡 Tip**: Setting `train_expert_only=true` freezes the VLM and trains only the action expert and projections, allowing finetuning with reduced memory usage.
-
 ## License

 This model follows the **Apache 2.0 License**, consistent with the original [OpenPI repository](https://github.com/Physical-Intelligence/openpi).
@@ -56,7 +56,7 @@ policy.type=pi05
 Here's a complete training command for finetuning the base π₀.₅ model on your own dataset:

 ```bash
-lerobot-train \
+python src/lerobot/scripts/lerobot_train.py\
    --dataset.repo_id=your_dataset \
    --policy.type=pi05 \
    --output_dir=./outputs/pi05_training \
@@ -67,8 +67,6 @@ lerobot-train \
    --policy.gradient_checkpointing=true \
    --wandb.enable=true \
    --policy.dtype=bfloat16 \
-    --policy.freeze_vision_encoder=false \
-    --policy.train_expert_only=false \
    --steps=3000 \
    --policy.device=cuda \
    --batch_size=32
@@ -84,15 +82,6 @@ lerobot-train \
  - [lerobot/pi05_base](https://huggingface.co/lerobot/pi05_base)
  - [lerobot/pi05_libero](https://huggingface.co/lerobot/pi05_libero) (specifically trained on the Libero dataset)

-### Training Parameters Explained
-
-| Parameter               | Default | Description                                 |
-| ----------------------- | ------- | ------------------------------------------- |
-| `freeze_vision_encoder` | `false` | Do not freeze the vision encoder            |
-| `train_expert_only`     | `false` | Do not freeze the VLM, train all parameters |
-
-**💡 Tip**: Setting `train_expert_only=true` freezes the VLM and trains only the action expert and projections, allowing finetuning with reduced memory usage.
-
 If your dataset is not converted with `quantiles`, you can convert it with the following command:

 ```bash
@@ -1,246 +0,0 @@
-# π₀-FAST (Pi0-FAST)
-
-π₀-FAST is a **Vision-Language-Action model for general robot control** that uses autoregressive next-token prediction to model continuous robot actions.
-
-## Model Overview
-
-π₀-FAST combines the power of Vision-Language Models with a novel action tokenization approach called **FAST (Frequency-space Action Sequence Tokenization)**. This enables training autoregressive VLAs on highly dexterous tasks that are impossible with standard binning-based discretization, while training **up to 5x faster** than diffusion-based approaches like π₀.
-
-<img
-  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/lerobot-pifast.png"
-  alt="An overview of Pi0-FAST"
-  width="85%"
-/>
-
-### Why FAST?
-
-Standard approaches for robot action tokenization use simple per-dimension, per-timestep binning schemes. While passable for simple behaviors, this rapidly breaks down for complex and dexterous skills that require precision and high-frequency control.
-
-FAST solves this by compressing action sequences using signal processing techniques, resulting in a dense sequence of action tokens that can be predicted autoregressively—just like language tokens.
-
-### How FAST Tokenization Works
-
-The FAST tokenizer compresses action sequences through the following steps:
-
-1. **Normalize**: Take a continuous action chunk of shape `(H, D)` where `H` is the horizon and `D` is the action dimension. Normalize using one of the supported normalization methods (Quantiles recommended to handle outliers).
-
-2. **Discrete Cosine Transform (DCT)**: Apply DCT (via scipy) to each action dimension separately. DCT is a compression algorithm commonly used in image and audio codecs (JPEG, MP3).
-
-3. **Quantization**: Round and remove insignificant coefficients for each action dimension, producing a sparse frequency matrix.
-
-4. **Flatten**: Flatten the matrix into a 1D vector, with low-frequency components first.
-
-5. **Byte Pair Encoding (BPE)**: Train a BPE tokenizer to compress the DCT coefficients into dense action tokens, typically achieving **10x compression** over prior tokenization approaches.
-
-This approach can transform **any existing VLM** into a VLA by training it to predict these FAST tokens.
-
-## Installation Requirements
-
-1. Install LeRobot by following our [Installation Guide](./installation).
-2. Install π₀-FAST dependencies by running:
-
-   ```bash
-   pip install -e ".[pi]"
-   ```
-
-   > [!NOTE]
-   > For lerobot 0.4.0, if you want to install the pi tag, you will have to do: `pip install "lerobot[pi]@git+https://github.com/huggingface/lerobot.git"`.
-   >
-   > This will be solved in the next patch release
-
-## Training a Custom FAST Tokenizer
-
-You have two options for the FAST tokenizer:
-
-1. **Use the pre-trained tokenizer**: The `physical-intelligence/fast` tokenizer was trained on 1M+ real robot action sequences and works as a general-purpose tokenizer.
-
-2. **Train your own tokenizer**: For maximum performance on your specific dataset, you can finetune the tokenizer on your own data.
-
-### Training Your Own Tokenizer
-
-```bash
-lerobot-train-tokenizer \
-    --repo_id "user/my-lerobot-dataset" \
-    --action_horizon 10 \
-    --encoded_dims "0:6" \
-    --vocab_size 1024 \
-    --scale 10.0 \
-    --normalization_mode QUANTILES \
-    --output_dir "./my_fast_tokenizer" \
-    --push_to_hub \
-    --hub_repo_id "username/my-action-tokenizer"
-```
-
-### Key Tokenizer Parameters
-
-| Parameter              | Description                                                                       | Default      |
-| ---------------------- | --------------------------------------------------------------------------------- | ------------ |
-| `--repo_id`            | LeRobot dataset repository ID                                                     | Required     |
-| `--action_horizon`     | Number of future actions in each chunk                                            | `10`         |
-| `--encoded_dims`       | Comma-separated dimension ranges to encode (e.g., `"0:6,7:23"`)                   | `"0:6,7:23"` |
-| `--vocab_size`         | BPE vocabulary size                                                               | `1024`       |
-| `--scale`              | DCT scaling factor for quantization                                               | `10.0`       |
-| `--normalization_mode` | Normalization mode (`MEAN_STD`, `MIN_MAX`, `QUANTILES`, `QUANTILE10`, `IDENTITY`) | `QUANTILES`  |
-| `--sample_fraction`    | Fraction of chunks to sample per episode                                          | `0.1`        |
-
-## Usage
-
-To use π₀-FAST in LeRobot, specify the policy type as:
-
-```python
-policy.type=pi0_fast
-```
-
-## Training
-
-For training π₀-FAST, you can use the LeRobot training script:
-
-```bash
-lerobot-train \
-    --dataset.repo_id=your_dataset \
-    --policy.type=pi0_fast \
-    --output_dir=./outputs/pi0fast_training \
-    --job_name=pi0fast_training \
-    --policy.pretrained_path=lerobot/pi0_fast_base \
-    --policy.dtype=bfloat16 \
-    --policy.gradient_checkpointing=true \
-    --policy.chunk_size=10 \
-    --policy.n_action_steps=10 \
-    --policy.max_action_tokens=256 \
-    --steps=100000 \
-    --batch_size=4 \
-    --policy.device=cuda
-```
-
-### Key Training Parameters
-
-| Parameter                              | Description                                        | Default                      |
-| -------------------------------------- | -------------------------------------------------- | ---------------------------- |
-| `--policy.gradient_checkpointing=true` | Reduces memory usage significantly during training | `false`                      |
-| `--policy.dtype=bfloat16`              | Use mixed precision training for efficiency        | `float32`                    |
-| `--policy.chunk_size`                  | Number of action steps to predict (action horizon) | `50`                         |
-| `--policy.n_action_steps`              | Number of action steps to execute                  | `50`                         |
-| `--policy.max_action_tokens`           | Maximum number of FAST tokens per action chunk     | `256`                        |
-| `--policy.action_tokenizer_name`       | FAST tokenizer to use                              | `physical-intelligence/fast` |
-| `--policy.compile_model=true`          | Enable torch.compile for faster training           | `false`                      |
-
-## Inference
-
-### KV-Caching for Fast Inference
-
-π₀-FAST supports **KV-caching**, a widely used optimization in LLM inference. This caches the key-value pairs from the attention mechanism, avoiding redundant computation during autoregressive decoding.
-
-```python
-# KV-caching is enabled by default
-policy.use_kv_cache=true
-```
-
-### Inference Example
-
-```python
-from lerobot.policies.pi0_fast import PI0FastPolicy, PI0FastConfig
-
-# Load the policy
-policy = PI0FastPolicy.from_pretrained("your-model-path")
-
-# During inference
-actions = policy.predict_action_chunk(batch)
-```
-
-## Model Architecture
-
-π₀-FAST uses a PaliGemma-based architecture:
-
- **Vision Encoder**: SigLIP vision tower for image understanding
- **Language Model**: Gemma 2B for processing language instructions and predicting action tokens
-
-The model takes images, text instructions, and robot state as input, and outputs discrete FAST tokens that are decoded back to continuous actions.
-
-## Configuration Options
-
-| Parameter            | Description                                     | Default    |
-| -------------------- | ----------------------------------------------- | ---------- |
-| `paligemma_variant`  | VLM backbone variant (`gemma_300m`, `gemma_2b`) | `gemma_2b` |
-| `max_state_dim`      | Maximum state vector dimension (padded)         | `32`       |
-| `max_action_dim`     | Maximum action vector dimension (padded)        | `32`       |
-| `temperature`        | Sampling temperature (0.0 for greedy)           | `0.0`      |
-| `max_decoding_steps` | Maximum decoding steps                          | `256`      |
-| `use_kv_cache`       | Enable KV caching for faster inference          | `true`     |
-
-## Comparison with π₀
-
-| Feature               | π₀                        | π₀-FAST                      |
-| --------------------- | ------------------------- | ---------------------------- |
-| Action Representation | Flow Matching (Diffusion) | Autoregressive Tokens (FAST) |
-| Training Speed        | 1x                        | **5x faster**                |
-| Dexterity             | High                      | High                         |
-| Inference Method      | Iterative Denoising       | Autoregressive Decoding      |
-| KV-Caching            | N/A                       | Supported                    |
-
-## Reproducing π₀Fast results
-
-We reproduce the results of π₀Fast on the LIBERO benchmark using the LeRobot implementation. We take the LeRobot PiFast base model [lerobot/pi0fast-base](https://huggingface.co/lerobot/pi0fast-base) and finetune for an additional 40kk steps in bfloat16, with batch size of 256 on 8 H100 GPUs using the [HuggingFace LIBERO dataset](https://huggingface.co/datasets/HuggingFaceVLA/libero).
-
-The finetuned model can be found here:
-
- **π₀Fast LIBERO**: [lerobot/pi0fast-libero](https://huggingface.co/lerobot/pi0fast-libero)
-
-With the following training command:
-
-```bash
-lerobot-train \
-  --dataset.repo_id=lerobot/libero \
-  --output_dir=outputs/libero_pi0fast \
-  --job_name=libero_pi0fast \
-  --policy.path=lerobot/pi0fast_base \
-  --policy.dtype=bfloat16 \
-  --steps=100000 \
-  --save_freq=20000 \
-  --batch_size=4 \
-  --policy.device=cuda \
-  --policy.scheduler_warmup_steps=4000 \
-  --policy.scheduler_decay_steps=100000 \
-  --policy.scheduler_decay_lr=1e-5 \
-  --policy.gradient_checkpointing=true \
-  --policy.chunk_size=10 \
-  --policy.n_action_steps=10 \
-  --policy.max_action_tokens=256 \
-  --policy.empty_cameras=1 \
-```
-
-We then evaluate the finetuned model using the LeRobot LIBERO implementation, by running the following command:
-
-```bash
-tasks="libero_object,libero_spatial,libero_goal,libero_10"
-lerobot-eval \
-  --policy.path=lerobot/pi0fast-libero \
-  --policy.max_action_tokens=256 \
-  --env.type=libero \
-  --policy.gradient_checkpointing=false \
-  --env.task=${tasks} \
-  --eval.batch_size=1 \
-  --eval.n_episodes=1 \
-  --rename_map='{"observation.images.image":"observation.images.base_0_rgb","observation.images.image2":"observation.images.left_wrist_0_rgb"}'
-```
-
-**Note:** We set `n_action_steps=10`, similar to the original OpenPI implementation.
-
-### Results
-
-We obtain the following results on the LIBERO benchmark:
-
-| Model       | LIBERO Spatial | LIBERO Object | LIBERO Goal | LIBERO 10 | Average  |
-| ----------- | -------------- | ------------- | ----------- | --------- | -------- |
-| **π₀-fast** | 70.0           | 100.0         | 100.0       | 60.0      | **82.5** |
-
-The full evaluation output folder, including videos, is available [here](https://drive.google.com/drive/folders/1HXpwPTRm4hx6g1sF2P7OOqGG0TwPU7LQ?usp=sharing)
-
-## License
-
-This model follows the **Apache 2.0 License**, consistent with the original [OpenPI repository](https://github.com/Physical-Intelligence/openpi).
-
-## References
-
- [FAST: Efficient Robot Action Tokenization](https://www.physicalintelligence.company/research/fast) - Physical Intelligence Blog
- [OpenPI Repository](https://github.com/Physical-Intelligence/openpi) - Original implementation
- [FAST Tokenizer on Hugging Face](https://huggingface.co/physical-intelligence/fast) - Pre-trained tokenizer
@@ -1,45 +0,0 @@
-# WALL-OSS
-
-This repository contains the Hugging Face port of [**WALL-OSS**](https://x2robot.com/en/research/68bc2cde8497d7f238dde690), a Vision-Language-Action model for cross-embodiment robotic control based on Qwen2.5-VL with flow matching/FAST action prediction.
-
---
-
-## Model Overview
-
-| Feature            | Description                                           |
-| ------------------ | ----------------------------------------------------- |
-| Base Model         | Qwen2.5-VL (Vision-Language Model)                    |
-| Action Prediction  | Flow Matching (diffusion) or FAST (discrete tokens)   |
-| Architecture       | Mixture of Experts (MoE) with action-specific routing |
-| Multi-Modal Inputs | Vision (images/videos), Language, Proprioception      |
-
---
-
-## Additional Resources
-
-Paper: https://arxiv.org/pdf/2509.11766
-
-Official Repository: https://github.com/X-Square-Robot/wall-x
-
-Hugging Face: https://huggingface.co/x-square-robot
-
---
-
-## Citation
-
-If you use this work, please cite:
-
-```bibtex
-@article{zhai2025igniting,
-    title   = {Igniting VLMs Toward the Embodied Space},
-    author  = {Zhai, Andy and Liu, Brae and Fang, Bruno and Cai, Chalse and Ma, Ellie and Yin, Ethan and Wang, Hao and Zhou, Hugo and Wang, James and Shi, Lights and Liang, Lucy and Wang, Make and Wang, Qian and Gan, Roy and Yu, Ryan and Li, Shalfun and Liu, Starrick and Chen, Sylas and Chen, Vincent and Xu, Zach},
-    journal = {arXiv preprint arXiv:2509.11766},
-    year    = {2025}
-}
-```
-
---
-
-## License
-
-This model follows the **Apache 2.0 License**, consistent with the original [WallX repository](https://github.com/X-Square-Robot/wall-x).
@@ -30,7 +30,7 @@ Each of these pipelines handle different conversions between different action an

 Below is an example of the three pipelines that we use in the phone to SO-100 follower examples:

-```python
+```69:90:examples/phone_so100_record.py
 phone_to_robot_ee_pose_processor = RobotProcessorPipeline[RobotAction, RobotAction]( # teleop -> dataset action
    steps=[
        MapPhoneActionToRobotAction(platform=teleop_config.phone_os),
@@ -84,7 +84,7 @@ Dataset features are determined by the keys saved in the dataset. Each step can

 Below is and example of how we declare features with the `transform_features` method in the phone to SO-100 follower examples:

-```python
+```src/lerobot/robots/so100_follower/robot_kinematic_processor.py
    def transform_features(
        self, features: dict[PipelineFeatureType, dict[str, PolicyFeature]]
    ) -> dict[PipelineFeatureType, dict[str, PolicyFeature]]:
@@ -103,7 +103,7 @@ Here we declare what PolicyFeatures we modify in this step, so we know what feat

 Below is an example of how we aggregate and merge features in the phone to SO-100 record example:

-```python
+```121:145:examples/phone_so100_record.py
 features=combine_feature_dicts(
        # Run the feature contract of the pipelines
        # This tells you how the features would look like after the pipeline steps
@@ -38,7 +38,6 @@ docker run --rm -it \
  start_rviz:=true start_sdk_server:=true mujoco:=true
 ```

-> [!NOTE]
 > If MuJoCo runs slowly (low simulation frequency), append `-e LD_LIBRARY_PATH="/opt/host-libs:$LD_LIBRARY_PATH" \` to the previous command to improve performance:
 >
 > ```
@@ -142,7 +141,7 @@ If you choose this option but still want to use the VR teleoperation application
 First add reachy2 and reachy2_teleoperator to the imports of the record script. Then you can use the following command:

 ```bash
-lerobot-record \
+python -m lerobot.record \
    --robot.type=reachy2 \
    --robot.ip_address=192.168.0.200 \
    --robot.id=r2-0000 \
@@ -151,7 +150,6 @@ lerobot-record \
    --teleop.type=reachy2_teleoperator \
    --teleop.ip_address=192.168.0.200 \
    --teleop.with_mobile_base=false \
-    --robot.with_torso_camera=true \
    --dataset.repo_id=pollen_robotics/record_test \
    --dataset.single_task="Reachy 2 recording test" \
    --dataset.num_episodes=1 \
@@ -167,7 +165,7 @@ lerobot-record \
 **Extended setup overview (all options included):**

 ```bash
-lerobot-record \
+python -m lerobot.record \
    --robot.type=reachy2 \
    --robot.ip_address=192.168.0.200 \
    --robot.use_external_commands=true \
@@ -179,8 +177,6 @@ lerobot-record \
    --robot.with_left_teleop_camera=true \
    --robot.with_right_teleop_camera=true \
    --robot.with_torso_camera=false \
-    --robot.camera_width=640 \
-    --robot.camera_height=480 \
    --robot.disable_torque_on_disconnect=false \
    --robot.max_relative_target=5.0 \
    --teleop.type=reachy2_teleoperator \
@@ -216,10 +212,9 @@ Must be set to true if a compliant Reachy 2 is used to control another one.
 From our initial tests, recording **all** joints when only some are moving can reduce model quality with certain policies.
 To avoid this, you can exclude specific parts from recording and replay using:

-```bash
+````
 --robot.with_<part>=false
-```
-
+```,
 with `<part>` being one of : `mobile_base`, `l_arm`, `r_arm", `neck`, `antennas`.
 It determine whether the corresponding part is recorded in the observations. True if not set.

@@ -227,60 +222,49 @@ By default, **all parts are recorded**.

 The same per-part mechanism is available in `reachy2_teleoperator` as well.

-```bash
--teleop.with\_<part>
-```
+````

+--teleop.with\_<part>
+
+```
 with `<part>` being one of : `mobile_base`, `l_arm`, `r_arm", `neck`, `antennas`.
 Determine whether the corresponding part is recorded in the actions. True if not set.

 > **Important:** In a given session, the **enabled parts must match** on both the robot and the teleoperator.
-> For example, if the robot runs with `--robot.with_mobile_base=false`, the teleoperator must disable the same part `--teleoperator.with_mobile_base=false`.
+For example, if the robot runs with `--robot.with_mobile_base=false`, the teleoperator must disable the same part `--teleoperator.with_mobile_base=false`.

 ##### Use the relevant cameras

-You can do the same for **cameras**. Enable or disable each camera with default parameters using:
+You can do the same for **cameras**. By default, only the **teleoperation cameras** are recorded (both `left_teleop_camera` and `right_teleop_camera`). Enable or disable each camera with:

-```bash
--robot.with_left_teleop_camera=<true|false> \
--robot.with_right_teleop_camera=<true|false> \
+```
+
+--robot.with_left_teleop_camera=<true|false>
+--robot.with_right_teleop_camera=<true|false>
 --robot.with_torso_camera=<true|false>
-```

-By default, no camera is recorded, all camera arguments are set to `false`.
-If you want to, you can use custom `width` and `height` parameters for Reachy 2's cameras using the `--robot.camera_width` & `--robot.camera_height` argument:
+````

-```bash
--robot.camera_width=1920 \
--robot.camera_height=1080
-```
-
-This will change the resolution of all 3 default robot cameras (enabled by the above bool arguments).
-
-If you want, you can add additional cameras other than the ones in the robot as usual with:
-
-```bash
--robot.cameras="{ extra: {type: opencv, index_or_path: 42, width: 640, height: 480, fps: 30}}" \
-```

 ## Step 2: Replay

 Make sure the robot is configured with the same parts as the dataset:

 ```bash
-lerobot-replay \
+python -m lerobot.replay \
    --robot.type=reachy2 \
    --robot.ip_address=192.168.0.200 \
    --robot.use_external_commands=false \
    --robot.with_mobile_base=false \
    --dataset.repo_id=pollen_robotics/record_test \
    --dataset.episode=0
-```
+    --display_data=true
+````

 ## Step 3: Train

 ```bash
-lerobot-train \
+python -m lerobot.scripts.train \
  --dataset.repo_id=pollen_robotics/record_test \
  --policy.type=act \
  --output_dir=outputs/train/reachy2_test \
@@ -293,9 +277,10 @@ lerobot-train \
 ## Step 4: Evaluate

 ```bash
-lerobot-eval \
+python -m lerobot.record \
  --robot.type=reachy2 \
  --robot.ip_address=192.168.0.200 \
+  --display_data=false \
  --dataset.repo_id=pollen_robotics/eval_record_test \
  --dataset.single_task="Evaluate reachy2 policy" \
  --dataset.num_episodes=10 \
@@ -4,12 +4,6 @@ SARM (Stage-Aware Reward Modeling) is a video-based reward modeling framework fo

 **Paper**: [SARM: Stage-Aware Reward Modeling for Long Horizon Robot Manipulation](https://arxiv.org/abs/2509.25358)

-<img
-  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/lerobot-sarm.png"
-  alt="An overview of SARM"
-  width="80%"
-/>
-
 ## Why Reward Models?

 Standard behavior cloning treats all demonstration frames equally, but real-world robot datasets are messy. They contain hesitations, corrections, and variable-quality trajectories. Reward models solve this by learning a generalizable notion of **task progress** from demonstrations: given video frames and a task description, they predict how close the robot is to completing the task (0→1). This learned "progress signal" can be used in multiple ways, two promising applications are: (1) **weighted imitation learning** (RA-BC), where high-progress frames receive more weight during policy training, and (2) **reinforcement learning**, where the reward model provides dense rewards for online or offline policy improvement.
@@ -269,7 +263,7 @@ This generates visualizations showing video frames with subtask boundaries overl
 Train with **no annotations** - uses linear progress from 0 to 1:

 ```bash
-lerobot-train \
+python src/lerobot/scripts/lerobot_train.py \
  --dataset.repo_id=your-username/your-dataset \
  --policy.type=sarm \
  --policy.annotation_mode=single_stage \
@@ -288,7 +282,7 @@ lerobot-train \
 Train with **dense annotations only** (sparse auto-generated):

 ```bash
-lerobot-train \
+python src/lerobot/scripts/lerobot_train.py \
  --dataset.repo_id=your-username/your-dataset \
  --policy.type=sarm \
  --policy.annotation_mode=dense_only \
@@ -307,7 +301,7 @@ lerobot-train \
 Train with **both sparse and dense annotations**:

 ```bash
-lerobot-train \
+python src/lerobot/scripts/lerobot_train.py \
  --dataset.repo_id=your-username/your-dataset \
  --policy.type=sarm \
  --policy.annotation_mode=dual \
@@ -468,7 +462,7 @@ This script:
 Once you have the progress file, train your policy with RA-BC weighting. The progress file is auto-detected from the dataset path (`sarm_progress.parquet`). Currently PI0, PI0.5 and SmolVLA are supported with RA-BC:

 ```bash
-lerobot-train \
+python src/lerobot/scripts/lerobot_train.py \
  --dataset.repo_id=your-username/your-dataset \
  --policy.type=pi0 \
  --use_rabc=true \
@@ -103,7 +103,7 @@ lerobot-setup-motors \

 <!-- prettier-ignore-start -->
 ```python
-from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
+from lerobot.robots.so100_follower import SO100Follower, SO100FollowerConfig

 config = SO100FollowerConfig(
    port="/dev/tty.usbmodem585A0076841",
@@ -177,7 +177,7 @@ lerobot-setup-motors \

 <!-- prettier-ignore-start -->
 ```python
-from lerobot.teleoperators.so_leader import SO100Leader, SO100LeaderConfig
+from lerobot.teleoperators.so100_leader import SO100Leader, SO100LeaderConfig

 config = SO100LeaderConfig(
    port="/dev/tty.usbmodem585A0076841",
@@ -579,7 +579,7 @@ lerobot-calibrate \

 <!-- prettier-ignore-start -->
 ```python
-from lerobot.robots.so_follower import SO100FollowerConfig, SO100Follower
+from lerobot.robots.so100_follower import SO100FollowerConfig, SO100Follower

 config = SO100FollowerConfig(
    port="/dev/tty.usbmodem585A0076891",
@@ -617,7 +617,7 @@ lerobot-calibrate \

 <!-- prettier-ignore-start -->
 ```python
-from lerobot.teleoperators.so_leader import SO100LeaderConfig, SO100Leader
+from lerobot.teleoperators.so100_leader import SO100LeaderConfig, SO100Leader

 config = SO100LeaderConfig(
    port="/dev/tty.usbmodem58760431551",
@@ -1,18 +1,5 @@
 # SO-101

-<div style="display: flex; align-items: center; gap: 10px;">
-  <img
-    src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/SO101_Follower.webp"
-    alt="SO-101"
-    width="60%"
-  />
-  <img
-    src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/SO101_Leader.webp"
-    alt="SO-101"
-    width="60%"
-  />
-</div>
-
 In the steps below, we explain how to assemble our flagship robot, the SO-101.

 ## Source the parts
@@ -138,7 +125,7 @@ lerobot-setup-motors \

 <!-- prettier-ignore-start -->
 ```python
-from lerobot.robots.so_follower import SO101Follower, SO101FollowerConfig
+from lerobot.robots.so101_follower import SO101Follower, SO101FollowerConfig

 config = SO101FollowerConfig(
    port="/dev/tty.usbmodem585A0076841",
@@ -214,7 +201,7 @@ lerobot-setup-motors \

 <!-- prettier-ignore-start -->
 ```python
-from lerobot.teleoperators.so_leader import SO101Leader, SO101LeaderConfig
+from lerobot.teleoperators.so101_leader import SO101Leader, SO101LeaderConfig

 config = SO101LeaderConfig(
    port="/dev/tty.usbmodem585A0076841",
@@ -377,7 +364,7 @@ lerobot-calibrate \

 <!-- prettier-ignore-start -->
 ```python
-from lerobot.robots.so_follower import SO101FollowerConfig, SO101Follower
+from lerobot.robots.so101_follower import SO101FollowerConfig, SO101Follower

 config = SO101FollowerConfig(
    port="/dev/tty.usbmodem585A0076891",
@@ -426,7 +413,7 @@ lerobot-calibrate \

 <!-- prettier-ignore-start -->
 ```python
-from lerobot.teleoperators.so_leader import SO101LeaderConfig, SO101Leader
+from lerobot.teleoperators.so101_leader import SO101LeaderConfig, SO101Leader

 config = SO101LeaderConfig(
    port="/dev/tty.usbmodem58760431551",
@@ -1,21 +1,21 @@
-# Unitree G1
+# Unitree G1 Robot Setup and Control

 This guide covers the complete setup process for the Unitree G1 humanoid, from initial connection to running gr00t_wbc locomotion.

-## About
+## About the Unitree G1

-We support both 29 and 23 DOF G1 EDU version. We introduce:
+We offer support for both 29 and 23 DOF G1. We introduce:

- **`unitree g1` robot class, handling low level read/write from/to the humanoid**
- **ZMQ socket bridge** for remote communication and camera streaming, allowing for remote policy deployment over wlan, eth or directly on the robot
- **Locomotion policies** from NVIDIA gr00t and Amazon FAR Holosoma
- **Simulation mode** for testing policies without the physical robot in mujoco
+- **`unitree g1` robot class, handling low level communication with the humanoid**
+- **ZMQ socket bridge** for remote communication over WiFi, allowing one to deploy policies remotely instead of over ethernet or directly on the Orin
+- **GR00T locomotion policy** for bipedal walking and balance
+- **MuJoCo simulation mode** for testing policies without the physical robot

 ---

-## Connection guide
+## Part 1: Connect to Robot over Ethernet

-### Step 1: Configure Ethernet Interface
+### Step 1: Configure Your Computer's Ethernet Interface

 Set a static IP on the same subnet as the robot:

@@ -26,7 +26,7 @@ sudo ip addr add 192.168.123.200/24 dev enp131s0
 sudo ip link set enp131s0 up
 ```

-**Note**: The G1's Ethernet IP is fixed at `192.168.123.164`. Your computer must use `192.168.123.x` with x ≠ 164.
+**Note**: The robot's Ethernet IP is fixed at `192.168.123.164`. Your computer must use `192.168.123.x` where x ≠ 164.

 ### Step 2: SSH into the Robot

@@ -35,24 +35,25 @@ ssh unitree@192.168.123.164
 # Password: 123
 ```

-You should now be connected to the G1's Orin.
+You should now be connected to the robot's onboard computer.

 ---

 ## Part 2: Enable WiFi on the Robot

-Wlan0 is disabled by default on the G1. To enable it:
+Once connected via Ethernet, follow these steps to enable WiFi:

 ### Step 1: Enable WiFi Hardware

 ```bash
+# Unblock WiFi radio
 sudo rfkill unblock wifi
 sudo rfkill unblock all

-# Bring up wlan0
+# Bring up WiFi interface
 sudo ip link set wlan0 up

-# Enable NetworkManager control of wlan0
+# Enable NetworkManager control
 sudo nmcli radio wifi on
 sudo nmcli device set wlan0 managed yes
 sudo systemctl restart NetworkManager
@@ -72,7 +73,7 @@ sudo iptables -A FORWARD -i wlp132s0f0 -o enp131s0 -m state --state RELATED,ESTA
 sudo iptables -A FORWARD -i enp131s0 -o wlp132s0f0 -j ACCEPT
 ```

-**On the G1:**
+**On the robot:**

 ```bash
 # Add laptop as default gateway
@@ -110,7 +111,7 @@ ssh unitree@<YOUR_ROBOT_IP>
 # Password: 123
 ```

-Replace `<YOUR_ROBOT_IP>` with your robot's actual WiFi IP address.
+Replace `<YOUR_ROBOT_IP>` with your robot's actual WiFi IP address (e.g., `172.18.129.215`).

 ---

@@ -146,9 +147,9 @@ python src/lerobot/robots/unitree_g1/run_g1_server.py

 ---

-## Part 4: Controlling the robot
+## Part 4: Running GR00T Locomotion

-With the robot server running, you can now control the robot remotely. Let's launch a locomotion policy
+With the robot server running, you can now control the robot from your laptop.

 ### Step 1: Install LeRobot on your machine

@@ -171,128 +172,34 @@ Edit the config file to match your robot's WiFi IP:
 robot_ip: str = "<YOUR_ROBOT_IP>"  # Replace with your robot's WiFi IP.
 ```

+**Note**: When running directly on the G1 (not remotely), set `robot_ip: str = "127.0.0.1"` instead.
+
 ### Step 3: Run the Locomotion Policy

 ```bash
 # Run GR00T locomotion controller
 python examples/unitree_g1/gr00t_locomotion.py --repo-id "nepyope/GR00T-WholeBodyControl_g1"
-
-# Run Holosoma locomotion controller
-python examples/unitree_g1/holosoma_locomotion.py
-
 ```

+### Step 4: Control with Remote
+
+- **Left stick**: Forward/backward and left/right movement
+- **Right stick**: Rotation
+- **R1 button**: Raise waist height
+- **R2 button**: Lower waist height
+
 Press `Ctrl+C` to stop the policy.

 ---

-## Running in Simulation Mode (MuJoCo)
+## Extra: Running in Simulation Mode (MuJoCo)

-You can test policies before deploying on the physical robot using MuJoCo simulation. Set `is_simulation=True` in config or pass `--robot.is_simulation=true` via CLI.
-
-### Calibrate Exoskeleton Teleoperator
-
-```bash
-lerobot-calibrate \
-    --teleop.type=unitree_g1 \
-    --teleop.left_arm_config.port=/dev/ttyACM1 \
-    --teleop.right_arm_config.port=/dev/ttyACM0 \
-    --teleop.id=exo
-```
-
-### Teleoperate in Simulation
-
-```bash
-lerobot-teleoperate \
-    --robot.type=unitree_g1 \
-    --robot.is_simulation=true \
-    --teleop.type=unitree_g1 \
-    --teleop.left_arm_config.port=/dev/ttyACM1 \
-    --teleop.right_arm_config.port=/dev/ttyACM0 \
-    --teleop.id=exo \
-    --fps=100
-```
-
-### Record Dataset in Simulation
-
-```bash
-lerobot-record \
-    --robot.type=unitree_g1 \
-    --robot.is_simulation=true \
-    --robot.cameras='{"global_view": {"type": "zmq", "server_address": "localhost", "port": 5555, "camera_name": "head_camera", "width": 640, "height": 480, "fps": 30}}' \
-    --teleop.type=unitree_g1 \
-    --teleop.left_arm_config.port=/dev/ttyACM1 \
-    --teleop.right_arm_config.port=/dev/ttyACM0 \
-    --teleop.id=exo \
-    --dataset.repo_id=your-username/dataset-name \
-    --dataset.single_task="Test" \
-    --dataset.num_episodes=2 \
-    --dataset.episode_time_s=5 \
-    --dataset.reset_time_s=5 \
-    --dataset.push_to_hub=true
-```
-
-Example simulation dataset: [nepyope/teleop_test_sim](https://huggingface.co/datasets/nepyope/teleop_test_sim)
-
---
-
-## Running on Real Robot
-
-Once the robot server is running on the G1 (see Part 3), you can teleoperate and record on the real robot.
-
-### Start the Camera Server
-
-On the robot, start the ZMQ image server:
-
-```bash
-python src/lerobot/cameras/zmq/image_server.py
-```
-
-Keep this running in a separate terminal for camera streaming during recording.
-
-### Teleoperate Real Robot
-
-```bash
-lerobot-teleoperate \
-    --robot.type=unitree_g1 \
-    --robot.is_simulation=false \
-    --teleop.type=unitree_g1 \
-    --teleop.left_arm_config.port=/dev/ttyACM1 \
-    --teleop.right_arm_config.port=/dev/ttyACM0 \
-    --teleop.id=exo \
-    --fps=100
-```
-
-### Record Dataset on Real Robot
-
-```bash
-lerobot-record \
-    --robot.type=unitree_g1 \
-    --robot.is_simulation=false \
-    --robot.cameras='{"global_view": {"type": "zmq", "server_address": "172.18.129.215", "port": 5555, "camera_name": "head_camera", "width": 640, "height": 480, "fps": 30}}' \
-    --teleop.type=unitree_g1 \
-    --teleop.left_arm_config.port=/dev/ttyACM1 \
-    --teleop.right_arm_config.port=/dev/ttyACM0 \
-    --teleop.id=exo \
-    --dataset.repo_id=your-username/dataset-name \
-    --dataset.single_task="Test" \
-    --dataset.num_episodes=2 \
-    --dataset.episode_time_s=5 \
-    --dataset.reset_time_s=5 \
-    --dataset.push_to_hub=true
-```
-
-**Note**: Update `server_address` to match your robot's camera server IP.
-
-Example real robot dataset: [nepyope/teleop_test_real](https://huggingface.co/datasets/nepyope/teleop_test_real)
-
---
+You can now test and develop policies without a physical robot using MuJoCo. to do so set `is_simulation=True` in config.

 ## Additional Resources

 - [Unitree SDK Documentation](https://github.com/unitreerobotics/unitree_sdk2_python)
- [GR00T-WholeBodyControl](https://github.com/NVlabs/GR00T-WholeBodyControl)
- [Holosoma](https://github.com/amazon-far/holosoma)
+- [GR00T Policy Repository](https://huggingface.co/nepyope/GR00T-WholeBodyControl_g1)
 - [LeRobot Documentation](https://github.com/huggingface/lerobot)
 - [Unitree_IL_Lerobot](https://github.com/unitreerobotics/unitree_IL_lerobot)

@@ -12,7 +12,6 @@ LeRobot provides several utilities for manipulating datasets:
 4. **Add Features** - Add new features to a dataset
 5. **Remove Features** - Remove features from a dataset
 6. **Convert to Video** - Convert image-based datasets to video format for efficient storage
-7. **Show the Info of Datasets** - Show the summary of datasets information such as number of episode etc.

 The core implementation is in `lerobot.datasets.dataset_tools`.
 An example script detailing how to use the tools API is available in `examples/dataset/use_dataset_tools.py`.
@@ -96,26 +95,26 @@ Convert an image-based dataset to video format, creating a new LeRobotDataset wh
 # Local-only: Save to a custom output directory (no hub push)
 lerobot-edit-dataset \
    --repo_id lerobot/pusht_image \
-    --operation.type convert_image_to_video \
+    --operation.type convert_to_video \
    --operation.output_dir /path/to/output/pusht_video

 # Save with new repo_id (local storage)
 lerobot-edit-dataset \
    --repo_id lerobot/pusht_image \
    --new_repo_id lerobot/pusht_video \
-    --operation.type convert_image_to_video
+    --operation.type convert_to_video

 # Convert and push to Hugging Face Hub
 lerobot-edit-dataset \
    --repo_id lerobot/pusht_image \
    --new_repo_id lerobot/pusht_video \
-    --operation.type convert_image_to_video \
+    --operation.type convert_to_video \
    --push_to_hub true

 # Convert with custom video codec and quality settings
 lerobot-edit-dataset \
    --repo_id lerobot/pusht_image \
-    --operation.type convert_image_to_video \
+    --operation.type convert_to_video \
    --operation.output_dir outputs/pusht_video \
    --operation.vcodec libsvtav1 \
    --operation.pix_fmt yuv420p \
@@ -125,23 +124,16 @@ lerobot-edit-dataset \
 # Convert only specific episodes
 lerobot-edit-dataset \
    --repo_id lerobot/pusht_image \
-    --operation.type convert_image_to_video \
+    --operation.type convert_to_video \
    --operation.output_dir outputs/pusht_video \
    --operation.episode_indices "[0, 1, 2, 5, 10]"

 # Convert with multiple workers for parallel processing
 lerobot-edit-dataset \
    --repo_id lerobot/pusht_image \
-    --operation.type convert_image_to_video \
+    --operation.type convert_to_video \
    --operation.output_dir outputs/pusht_video \
    --operation.num_workers 8
-
-# For memory-constrained systems, users can now specify limits:
-lerobot-edit-dataset \
-    --repo_id lerobot/pusht_image \
-    --operation.type convert_to_video \
-    --operation.max_episodes_per_batch 50 \
-    --operation.max_frames_per_batch 10000
 ```

 **Parameters:**
@@ -157,30 +149,6 @@ lerobot-edit-dataset \

 **Note:** The resulting dataset will be a proper LeRobotDataset with all cameras encoded as videos in the `videos/` directory, with parquet files containing only metadata (no raw image data). All episodes, stats, and tasks are preserved.

-### Show the information of datasets
-
-Show the information of datasets such as number of episode, number of frame, File size and so on.
-No change will be made to the dataset
-
-```bash
-
-# Show dataset information without feature details
-lerobot-edit-dataset \
-    --repo_id lerobot/pusht_image \
-    --operation.type info \
-
-# Show dataset information with feature details
-lerobot-edit-dataset \
-    --repo_id lerobot/pusht_image \
-    --operation.type info \
-    --operation.show_features true
-
-```
-
-**Parameters:**
-
- `parameters`: The flag to control show or no show dataset information with feature details.(default=false)
-
 ### Push to Hub

 Add the `--push_to_hub true` flag to any command to automatically upload the resulting dataset to the Hugging Face Hub:
@@ -1,80 +0,0 @@
-# WALL-OSS
-
-WALL-OSS is an open-source foundation model for embodied intelligence, proposed by the [XSquare Robot](https://x2robot.com/en/research/68bc2cde8497d7f238dde690) team in 2025. The LeRobot implementation is adapted from their open-source [WallX](https://github.com/X-Square-Robot/wall-x) repository.
-
-X Square Robot’s WALL-OSS is now integrated into Hugging Face’s LeRobot ecosystem. This is an exciting collaborative project between the LeRobot and X Square Robot teams. You can now post-train, evaluate, and deploy WALL-OSS directly through LeRobot. With this, we’re aiming to make it easier for the open-source robotics community to customize and deploy WALL-OSS foundation models. Read and explore WALL-OSS [paper](https://arxiv.org/pdf/2509.11766) and [code](https://github.com/X-Square-Robot/wall-x).
-
-## Model Overview
-
-The WALL-OSS team is building the embodied foundation model to capture and compress the world's most valuable data: the continuous, high-fidelity stream of physical interaction. By creating a direct feedback loop between the model's decisions and the body's lived experience, the emergence of a truly generalizable intelligence is enabled—one that understands not just how the world works, but how to act effectively within it.
-
-<img
-  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/walloss-lerobot-paper.png"
-  alt="An overview of WALL-OSS"
-  width="85%"
-/>
-
-Technically, WALL-OSS introduces a tightly coupled multimodal architecture (tightly-coupled MoE structure) that integrates both discrete and continuous action modeling strategies. Through a two-stage training pipeline (Inspiration → Integration), the model gradually unifies semantic reasoning and high-frequency action generation. Its core innovations include:
-
- **Embodied perception–enhanced multimodal pretraining**: Large-scale training on unified vision–language–action data to strengthen spatial, causal, and manipulation understanding.
- **Unified Cross-Level Chain-of-Thought (Uni-CoT)**: A single differentiable framework that unifies high-level instruction reasoning, sub-task decomposition, and fine-grained action synthesis, forming a continuous chain from “understanding” to “execution.”
- **Mixture-of-Experts (MoE) action heads**: Dynamically activating experts depending on the task phase and modeling actions in discrete or continuous space to maintain stable VLM priors.
- **Two-stage training paradigm**:
-  - **Inspiration stage**: Injecting discrete action priors to strengthen spatial understanding and semantic-action alignment.
-  - **Integration stage**: Using flow matching to achieve high-frequency continuous control.
-
-## Installation Requirements
-
-1. Install LeRobot by following our [Installation Guide](./installation).
-2. Install WallX dependencies by running:
-
-   ```bash
-   pip install -e ".[wallx]"
-   ```
-
-## Usage
-
-To use WallX in LeRobot, specify the policy type as:
-
-```python
-policy.type=wall_x
-```
-
-## Training
-
-For training WallX, you can use the standard LeRobot training script with the appropriate configuration:
-
-```bash
-lerobot-train \
-    --dataset.repo_id=your_dataset \
-    --policy.type=wall_x \
-    --output_dir=./outputs/wallx_training \
-    --job_name=wallx_training \
-    --policy.repo_id=your_repo_id \
-    --policy.pretrained_name_or_path=x-square-robot/wall-oss-flow \
-    --policy.prediction_mode=diffusion \
-    --policy.attn_implementation=eager \
-    --steps=3000 \
-    --policy.device=cuda \
-    --batch_size=32
-```
-
-### Training Arguments
-
-| Argument                       | Description                                                                                                                                                   |
-| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `--dataset.repo_id`            | The Hugging Face Hub repository ID for your training dataset (e.g., `lerobot/aloha_sim_insertion_human`)                                                      |
-| `--policy.type`                | Specifies using the WallX policy architecture                                                                                                                 |
-| `--output_dir`                 | Local directory where training checkpoints and logs will be saved                                                                                             |
-| `--job_name`                   | A name identifier for this training run (used in logging/tracking)                                                                                            |
-| `--policy.repo_id`             | Your Hugging Face Hub repo ID where the trained model will be pushed                                                                                          |
-| `--policy.pretrained_path`     | Path to pretrained WallX weights to initialize from (the official WALL-OSS checkpoint)                                                                        |
-| `--policy.prediction_mode`     | The action prediction strategy: `diffusion` or `fast` - `diffusion` uses iterative denoising for action generation, `fast` uses next token prediction instead |
-| `--policy.attn_implementation` | Attention implementation backend - `eager` uses standard PyTorch attention (alternatives include `flash_attention_2` or `sdpa`)                               |
-| `--steps`                      | Total number of training steps to run                                                                                                                         |
-| `--policy.device`              | Device to train on (`cuda` for GPU, `cpu` for CPU)                                                                                                            |
-| `--batch_size`                 | Number of samples per training batch                                                                                                                          |
-
-## License
-
-This model follows the **Apache 2.0 License**, consistent with the original [WallX repository](https://github.com/X-Square-Robot/wall-x).
@@ -154,7 +154,7 @@ lerobot-train \

 ```bash
 lerobot-train \
-  --dataset.repo_id=<USER>/bimanual-so100-handover-cube \
+  --dataset.repo_id=pepijn223/bimanual-so100-handover-cube \
  --output_dir=./outputs/xvla_bimanual \
  --job_name=xvla_so101_training \
  --policy.path="lerobot/xvla-base" \
@@ -22,7 +22,7 @@ lerobot-replay \
    --robot.type=so100_follower \
    --robot.port=/dev/tty.usbmodem58760431541 \
    --robot.id=black \
-    --dataset.repo_id=<USER>/record-test \
+    --dataset.repo_id=aliberts/record-test \
    --dataset.episode=2
 ```
 """
@@ -41,7 +41,8 @@ from lerobot.robots import (  # noqa: F401
    RobotConfig,
    koch_follower,
    make_robot_from_config,
-    so_follower,
+    so100_follower,
+    so101_follower,
 )
 from lerobot.utils.constants import ACTION
 from lerobot.utils.robot_utils import precise_sleep
@@ -81,25 +82,24 @@ def replay(cfg: ReplayConfig):
    actions = dataset.hf_dataset.select_columns(ACTION)
    robot.connect()

-    try:
-        log_say("Replaying episode", cfg.play_sounds, blocking=True)
-        for idx in range(dataset.num_frames):
-            start_episode_t = time.perf_counter()
+    log_say("Replaying episode", cfg.play_sounds, blocking=True)
+    for idx in range(dataset.num_frames):
+        start_episode_t = time.perf_counter()

-            action_array = actions[idx][ACTION]
-            action = {}
-            for i, name in enumerate(dataset.features[ACTION]["names"]):
-                key = f"{name.removeprefix('main_')}.pos"
-                action[key] = action_array[i].item()
+        action_array = actions[idx][ACTION]
+        action = {}
+        for i, name in enumerate(dataset.features[ACTION]["names"]):
+            key = f"{name.removeprefix('main_')}.pos"
+            action[key] = action_array[i].item()

-            action["shoulder_lift.pos"] = -(action["shoulder_lift.pos"] - 90)
-            action["elbow_flex.pos"] -= 90
-            robot.send_action(action)
+        action["shoulder_lift.pos"] = -(action["shoulder_lift.pos"] - 90)
+        action["elbow_flex.pos"] -= 90
+        robot.send_action(action)

-            dt_s = time.perf_counter() - start_episode_t
-            precise_sleep(max(1 / dataset.fps - dt_s, 0.0))
-    finally:
-        robot.disconnect()
+        dt_s = time.perf_counter() - start_episode_t
+        precise_sleep(1 / dataset.fps - dt_s)
+
+    robot.disconnect()


 if __name__ == "__main__":
@@ -78,24 +78,40 @@ def main():
    listener, events = init_keyboard_listener()
    init_rerun(session_name="lekiwi_evaluate")

-    try:
-        if not robot.is_connected:
-            raise ValueError("Robot is not connected!")
+    if not robot.is_connected:
+        raise ValueError("Robot is not connected!")

-        print("Starting evaluate loop...")
-        recorded_episodes = 0
-        while recorded_episodes < NUM_EPISODES and not events["stop_recording"]:
-            log_say(f"Running inference, recording eval episode {recorded_episodes} of {NUM_EPISODES}")
+    print("Starting evaluate loop...")
+    recorded_episodes = 0
+    while recorded_episodes < NUM_EPISODES and not events["stop_recording"]:
+        log_say(f"Running inference, recording eval episode {recorded_episodes} of {NUM_EPISODES}")

-            # Main record loop
+        # Main record loop
+        record_loop(
+            robot=robot,
+            events=events,
+            fps=FPS,
+            policy=policy,
+            preprocessor=preprocessor,  # Pass the pre and post policy processors
+            postprocessor=postprocessor,
+            dataset=dataset,
+            control_time_s=EPISODE_TIME_SEC,
+            single_task=TASK_DESCRIPTION,
+            display_data=True,
+            teleop_action_processor=teleop_action_processor,
+            robot_action_processor=robot_action_processor,
+            robot_observation_processor=robot_observation_processor,
+        )
+
+        # Reset the environment if not stopping or re-recording
+        if not events["stop_recording"] and (
+            (recorded_episodes < NUM_EPISODES - 1) or events["rerecord_episode"]
+        ):
+            log_say("Reset the environment")
            record_loop(
                robot=robot,
                events=events,
                fps=FPS,
-                policy=policy,
-                preprocessor=preprocessor,  # Pass the pre and post policy processors
-                postprocessor=postprocessor,
-                dataset=dataset,
                control_time_s=EPISODE_TIME_SEC,
                single_task=TASK_DESCRIPTION,
                display_data=True,
@@ -104,42 +120,24 @@ def main():
                robot_observation_processor=robot_observation_processor,
            )

-            # Reset the environment if not stopping or re-recording
-            if not events["stop_recording"] and (
-                (recorded_episodes < NUM_EPISODES - 1) or events["rerecord_episode"]
-            ):
-                log_say("Reset the environment")
-                record_loop(
-                    robot=robot,
-                    events=events,
-                    fps=FPS,
-                    control_time_s=EPISODE_TIME_SEC,
-                    single_task=TASK_DESCRIPTION,
-                    display_data=True,
-                    teleop_action_processor=teleop_action_processor,
-                    robot_action_processor=robot_action_processor,
-                    robot_observation_processor=robot_observation_processor,
-                )
+        if events["rerecord_episode"]:
+            log_say("Re-record episode")
+            events["rerecord_episode"] = False
+            events["exit_early"] = False
+            dataset.clear_episode_buffer()
+            continue

-            if events["rerecord_episode"]:
-                log_say("Re-record episode")
-                events["rerecord_episode"] = False
-                events["exit_early"] = False
-                dataset.clear_episode_buffer()
-                continue
+        # Save episode
+        dataset.save_episode()
+        recorded_episodes += 1

-            # Save episode
-            dataset.save_episode()
-            recorded_episodes += 1
+    # Clean up
+    log_say("Stop recording")
+    robot.disconnect()
+    listener.stop()

-    finally:
-        # Clean up
-        log_say("Stop recording")
-        robot.disconnect()
-        listener.stop()
-
-        dataset.finalize()
-        dataset.push_to_hub()
+    dataset.finalize()
+    dataset.push_to_hub()


 if __name__ == "__main__":
@@ -21,7 +21,7 @@ from lerobot.robots.lekiwi.config_lekiwi import LeKiwiClientConfig
 from lerobot.robots.lekiwi.lekiwi_client import LeKiwiClient
 from lerobot.scripts.lerobot_record import record_loop
 from lerobot.teleoperators.keyboard import KeyboardTeleop, KeyboardTeleopConfig
-from lerobot.teleoperators.so_leader import SO100Leader, SO100LeaderConfig
+from lerobot.teleoperators.so100_leader import SO100Leader, SO100LeaderConfig
 from lerobot.utils.constants import ACTION, OBS_STR
 from lerobot.utils.control_utils import init_keyboard_listener
 from lerobot.utils.utils import log_say
@@ -74,23 +74,40 @@ def main():
    listener, events = init_keyboard_listener()
    init_rerun(session_name="lekiwi_record")

-    try:
-        if not robot.is_connected or not leader_arm.is_connected or not keyboard.is_connected:
-            raise ValueError("Robot or teleop is not connected!")
+    if not robot.is_connected or not leader_arm.is_connected or not keyboard.is_connected:
+        raise ValueError("Robot or teleop is not connected!")

-        print("Starting record loop...")
-        recorded_episodes = 0
-        while recorded_episodes < NUM_EPISODES and not events["stop_recording"]:
-            log_say(f"Recording episode {recorded_episodes}")
+    print("Starting record loop...")
+    recorded_episodes = 0
+    while recorded_episodes < NUM_EPISODES and not events["stop_recording"]:
+        log_say(f"Recording episode {recorded_episodes}")

-            # Main record loop
+        # Main record loop
+        record_loop(
+            robot=robot,
+            events=events,
+            fps=FPS,
+            dataset=dataset,
+            teleop=[leader_arm, keyboard],
+            control_time_s=EPISODE_TIME_SEC,
+            single_task=TASK_DESCRIPTION,
+            display_data=True,
+            teleop_action_processor=teleop_action_processor,
+            robot_action_processor=robot_action_processor,
+            robot_observation_processor=robot_observation_processor,
+        )
+
+        # Reset the environment if not stopping or re-recording
+        if not events["stop_recording"] and (
+            (recorded_episodes < NUM_EPISODES - 1) or events["rerecord_episode"]
+        ):
+            log_say("Reset the environment")
            record_loop(
                robot=robot,
                events=events,
                fps=FPS,
-                dataset=dataset,
                teleop=[leader_arm, keyboard],
-                control_time_s=EPISODE_TIME_SEC,
+                control_time_s=RESET_TIME_SEC,
                single_task=TASK_DESCRIPTION,
                display_data=True,
                teleop_action_processor=teleop_action_processor,
@@ -98,44 +115,26 @@ def main():
                robot_observation_processor=robot_observation_processor,
            )

-            # Reset the environment if not stopping or re-recording
-            if not events["stop_recording"] and (
-                (recorded_episodes < NUM_EPISODES - 1) or events["rerecord_episode"]
-            ):
-                log_say("Reset the environment")
-                record_loop(
-                    robot=robot,
-                    events=events,
-                    fps=FPS,
-                    teleop=[leader_arm, keyboard],
-                    control_time_s=RESET_TIME_SEC,
-                    single_task=TASK_DESCRIPTION,
-                    display_data=True,
-                    teleop_action_processor=teleop_action_processor,
-                    robot_action_processor=robot_action_processor,
-                    robot_observation_processor=robot_observation_processor,
-                )
+        if events["rerecord_episode"]:
+            log_say("Re-record episode")
+            events["rerecord_episode"] = False
+            events["exit_early"] = False
+            dataset.clear_episode_buffer()
+            continue

-            if events["rerecord_episode"]:
-                log_say("Re-record episode")
-                events["rerecord_episode"] = False
-                events["exit_early"] = False
-                dataset.clear_episode_buffer()
-                continue
+        # Save episode
+        dataset.save_episode()
+        recorded_episodes += 1

-            # Save episode
-            dataset.save_episode()
-            recorded_episodes += 1
-    finally:
-        # Clean up
-        log_say("Stop recording")
-        robot.disconnect()
-        leader_arm.disconnect()
-        keyboard.disconnect()
-        listener.stop()
+    # Clean up
+    log_say("Stop recording")
+    robot.disconnect()
+    leader_arm.disconnect()
+    keyboard.disconnect()
+    listener.stop()

-        dataset.finalize()
-        dataset.push_to_hub()
+    dataset.finalize()
+    dataset.push_to_hub()


 if __name__ == "__main__":
@@ -42,27 +42,25 @@ def main():
    # Connect to the robot
    robot.connect()

-    try:
-        if not robot.is_connected:
-            raise ValueError("Robot is not connected!")
+    if not robot.is_connected:
+        raise ValueError("Robot is not connected!")

-        print("Starting replay loop...")
-        log_say(f"Replaying episode {EPISODE_IDX}")
-        for idx in range(len(episode_frames)):
-            t0 = time.perf_counter()
+    print("Starting replay loop...")
+    log_say(f"Replaying episode {EPISODE_IDX}")
+    for idx in range(len(episode_frames)):
+        t0 = time.perf_counter()

-            # Get recorded action from dataset
-            action = {
-                name: float(actions[idx][ACTION][i])
-                for i, name in enumerate(dataset.features[ACTION]["names"])
-            }
+        # Get recorded action from dataset
+        action = {
+            name: float(actions[idx][ACTION][i]) for i, name in enumerate(dataset.features[ACTION]["names"])
+        }

-            # Send action to robot
-            _ = robot.send_action(action)
+        # Send action to robot
+        _ = robot.send_action(action)

-            precise_sleep(max(1.0 / dataset.fps - (time.perf_counter() - t0), 0.0))
-    finally:
-        robot.disconnect()
+        precise_sleep(max(1.0 / dataset.fps - (time.perf_counter() - t0), 0.0))
+
+    robot.disconnect()


 if __name__ == "__main__":
@@ -18,7 +18,7 @@ import time

 from lerobot.robots.lekiwi import LeKiwiClient, LeKiwiClientConfig
 from lerobot.teleoperators.keyboard.teleop_keyboard import KeyboardTeleop, KeyboardTeleopConfig
-from lerobot.teleoperators.so_leader import SO100Leader, SO100LeaderConfig
+from lerobot.teleoperators.so100_leader import SO100Leader, SO100LeaderConfig
 from lerobot.utils.robot_utils import precise_sleep
 from lerobot.utils.visualization_utils import init_rerun, log_rerun_data

@@ -34,11 +34,12 @@ from lerobot.processor.converters import (
    transition_to_observation,
    transition_to_robot_action,
 )
-from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
-from lerobot.robots.so_follower.robot_kinematic_processor import (
+from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
+from lerobot.robots.so100_follower.robot_kinematic_processor import (
    ForwardKinematicsJointsToEE,
    InverseKinematicsEEToJoints,
 )
+from lerobot.robots.so100_follower.so100_follower import SO100Follower
 from lerobot.scripts.lerobot_record import record_loop
 from lerobot.utils.control_utils import init_keyboard_listener
 from lerobot.utils.utils import log_say
@@ -142,24 +143,38 @@ def main():
    listener, events = init_keyboard_listener()
    init_rerun(session_name="phone_so100_evaluate")

-    try:
-        if not robot.is_connected:
-            raise ValueError("Robot is not connected!")
+    if not robot.is_connected:
+        raise ValueError("Robot is not connected!")

-        print("Starting evaluate loop...")
-        episode_idx = 0
-        for episode_idx in range(NUM_EPISODES):
-            log_say(f"Running inference, recording eval episode {episode_idx + 1} of {NUM_EPISODES}")
+    print("Starting evaluate loop...")
+    episode_idx = 0
+    for episode_idx in range(NUM_EPISODES):
+        log_say(f"Running inference, recording eval episode {episode_idx + 1} of {NUM_EPISODES}")

-            # Main record loop
+        # Main record loop
+        record_loop(
+            robot=robot,
+            events=events,
+            fps=FPS,
+            policy=policy,
+            preprocessor=preprocessor,  # Pass the pre and post policy processors
+            postprocessor=postprocessor,
+            dataset=dataset,
+            control_time_s=EPISODE_TIME_SEC,
+            single_task=TASK_DESCRIPTION,
+            display_data=True,
+            teleop_action_processor=make_default_teleop_action_processor(),
+            robot_action_processor=robot_ee_to_joints_processor,
+            robot_observation_processor=robot_joints_to_ee_pose_processor,
+        )
+
+        # Reset the environment if not stopping or re-recording
+        if not events["stop_recording"] and ((episode_idx < NUM_EPISODES - 1) or events["rerecord_episode"]):
+            log_say("Reset the environment")
            record_loop(
                robot=robot,
                events=events,
                fps=FPS,
-                policy=policy,
-                preprocessor=preprocessor,  # Pass the pre and post policy processors
-                postprocessor=postprocessor,
-                dataset=dataset,
                control_time_s=EPISODE_TIME_SEC,
                single_task=TASK_DESCRIPTION,
                display_data=True,
@@ -168,41 +183,24 @@ def main():
                robot_observation_processor=robot_joints_to_ee_pose_processor,
            )

-            # Reset the environment if not stopping or re-recording
-            if not events["stop_recording"] and (
-                (episode_idx < NUM_EPISODES - 1) or events["rerecord_episode"]
-            ):
-                log_say("Reset the environment")
-                record_loop(
-                    robot=robot,
-                    events=events,
-                    fps=FPS,
-                    control_time_s=EPISODE_TIME_SEC,
-                    single_task=TASK_DESCRIPTION,
-                    display_data=True,
-                    teleop_action_processor=make_default_teleop_action_processor(),
-                    robot_action_processor=robot_ee_to_joints_processor,
-                    robot_observation_processor=robot_joints_to_ee_pose_processor,
-                )
+        if events["rerecord_episode"]:
+            log_say("Re-record episode")
+            events["rerecord_episode"] = False
+            events["exit_early"] = False
+            dataset.clear_episode_buffer()
+            continue

-            if events["rerecord_episode"]:
-                log_say("Re-record episode")
-                events["rerecord_episode"] = False
-                events["exit_early"] = False
-                dataset.clear_episode_buffer()
-                continue
+        # Save episode
+        dataset.save_episode()
+        episode_idx += 1

-            # Save episode
-            dataset.save_episode()
-            episode_idx += 1
-    finally:
-        # Clean up
-        log_say("Stop recording")
-        robot.disconnect()
-        listener.stop()
+    # Clean up
+    log_say("Stop recording")
+    robot.disconnect()
+    listener.stop()

-        dataset.finalize()
-        dataset.push_to_hub()
+    dataset.finalize()
+    dataset.push_to_hub()


 if __name__ == "__main__":
@@ -26,14 +26,15 @@ from lerobot.processor.converters import (
    transition_to_observation,
    transition_to_robot_action,
 )
-from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
-from lerobot.robots.so_follower.robot_kinematic_processor import (
+from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
+from lerobot.robots.so100_follower.robot_kinematic_processor import (
    EEBoundsAndSafety,
    EEReferenceAndDelta,
    ForwardKinematicsJointsToEE,
    GripperVelocityToJoint,
    InverseKinematicsEEToJoints,
 )
+from lerobot.robots.so100_follower.so100_follower import SO100Follower
 from lerobot.scripts.lerobot_record import record_loop
 from lerobot.teleoperators.phone.config_phone import PhoneConfig, PhoneOS
 from lerobot.teleoperators.phone.phone_processor import MapPhoneActionToRobotAction
@@ -149,23 +150,38 @@ def main():
    listener, events = init_keyboard_listener()
    init_rerun(session_name="phone_so100_record")

-    try:
-        if not robot.is_connected or not phone.is_connected:
-            raise ValueError("Robot or teleop is not connected!")
+    if not robot.is_connected or not phone.is_connected:
+        raise ValueError("Robot or teleop is not connected!")

-        print("Starting record loop. Move your phone to teleoperate the robot...")
-        episode_idx = 0
-        while episode_idx < NUM_EPISODES and not events["stop_recording"]:
-            log_say(f"Recording episode {episode_idx + 1} of {NUM_EPISODES}")
+    print("Starting record loop. Move your phone to teleoperate the robot...")
+    episode_idx = 0
+    while episode_idx < NUM_EPISODES and not events["stop_recording"]:
+        log_say(f"Recording episode {episode_idx + 1} of {NUM_EPISODES}")

-            # Main record loop
+        # Main record loop
+        record_loop(
+            robot=robot,
+            events=events,
+            fps=FPS,
+            teleop=phone,
+            dataset=dataset,
+            control_time_s=EPISODE_TIME_SEC,
+            single_task=TASK_DESCRIPTION,
+            display_data=True,
+            teleop_action_processor=phone_to_robot_ee_pose_processor,
+            robot_action_processor=robot_ee_to_joints_processor,
+            robot_observation_processor=robot_joints_to_ee_pose,
+        )
+
+        # Reset the environment if not stopping or re-recording
+        if not events["stop_recording"] and (episode_idx < NUM_EPISODES - 1 or events["rerecord_episode"]):
+            log_say("Reset the environment")
            record_loop(
                robot=robot,
                events=events,
                fps=FPS,
                teleop=phone,
-                dataset=dataset,
-                control_time_s=EPISODE_TIME_SEC,
+                control_time_s=RESET_TIME_SEC,
                single_task=TASK_DESCRIPTION,
                display_data=True,
                teleop_action_processor=phone_to_robot_ee_pose_processor,
@@ -173,43 +189,25 @@ def main():
                robot_observation_processor=robot_joints_to_ee_pose,
            )

-            # Reset the environment if not stopping or re-recording
-            if not events["stop_recording"] and (
-                episode_idx < NUM_EPISODES - 1 or events["rerecord_episode"]
-            ):
-                log_say("Reset the environment")
-                record_loop(
-                    robot=robot,
-                    events=events,
-                    fps=FPS,
-                    teleop=phone,
-                    control_time_s=RESET_TIME_SEC,
-                    single_task=TASK_DESCRIPTION,
-                    display_data=True,
-                    teleop_action_processor=phone_to_robot_ee_pose_processor,
-                    robot_action_processor=robot_ee_to_joints_processor,
-                    robot_observation_processor=robot_joints_to_ee_pose,
-                )
+        if events["rerecord_episode"]:
+            log_say("Re-recording episode")
+            events["rerecord_episode"] = False
+            events["exit_early"] = False
+            dataset.clear_episode_buffer()
+            continue

-            if events["rerecord_episode"]:
-                log_say("Re-recording episode")
-                events["rerecord_episode"] = False
-                events["exit_early"] = False
-                dataset.clear_episode_buffer()
-                continue
+        # Save episode
+        dataset.save_episode()
+        episode_idx += 1

-            # Save episode
-            dataset.save_episode()
-            episode_idx += 1
-    finally:
-        # Clean up
-        log_say("Stop recording")
-        robot.disconnect()
-        phone.disconnect()
-        listener.stop()
+    # Clean up
+    log_say("Stop recording")
+    robot.disconnect()
+    phone.disconnect()
+    listener.stop()

-        dataset.finalize()
-        dataset.push_to_hub()
+    dataset.finalize()
+    dataset.push_to_hub()


 if __name__ == "__main__":
@@ -23,10 +23,11 @@ from lerobot.processor.converters import (
    robot_action_observation_to_transition,
    transition_to_robot_action,
 )
-from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
-from lerobot.robots.so_follower.robot_kinematic_processor import (
+from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
+from lerobot.robots.so100_follower.robot_kinematic_processor import (
    InverseKinematicsEEToJoints,
 )
+from lerobot.robots.so100_follower.so100_follower import SO100Follower
 from lerobot.utils.constants import ACTION
 from lerobot.utils.robot_utils import precise_sleep
 from lerobot.utils.utils import log_say
@@ -73,34 +74,32 @@ def main():
    # Connect to the robot
    robot.connect()

-    try:
-        if not robot.is_connected:
-            raise ValueError("Robot is not connected!")
+    if not robot.is_connected:
+        raise ValueError("Robot is not connected!")

-        print("Starting replay loop...")
-        log_say(f"Replaying episode {EPISODE_IDX}")
-        for idx in range(len(episode_frames)):
-            t0 = time.perf_counter()
+    print("Starting replay loop...")
+    log_say(f"Replaying episode {EPISODE_IDX}")
+    for idx in range(len(episode_frames)):
+        t0 = time.perf_counter()

-            # Get recorded action from dataset
-            ee_action = {
-                name: float(actions[idx][ACTION][i])
-                for i, name in enumerate(dataset.features[ACTION]["names"])
-            }
+        # Get recorded action from dataset
+        ee_action = {
+            name: float(actions[idx][ACTION][i]) for i, name in enumerate(dataset.features[ACTION]["names"])
+        }

-            # Get robot observation
-            robot_obs = robot.get_observation()
+        # Get robot observation
+        robot_obs = robot.get_observation()

-            # Dataset EE -> robot joints
-            joint_action = robot_ee_to_joints_processor((ee_action, robot_obs))
+        # Dataset EE -> robot joints
+        joint_action = robot_ee_to_joints_processor((ee_action, robot_obs))

-            # Send action to robot
-            _ = robot.send_action(joint_action)
+        # Send action to robot
+        _ = robot.send_action(joint_action)

-            precise_sleep(max(1.0 / dataset.fps - (time.perf_counter() - t0), 0.0))
-    finally:
-        # Clean up
-        robot.disconnect()
+        precise_sleep(1.0 / dataset.fps - (time.perf_counter() - t0))
+
+    # Clean up
+    robot.disconnect()


 if __name__ == "__main__":
@@ -21,13 +21,14 @@ from lerobot.processor.converters import (
    robot_action_observation_to_transition,
    transition_to_robot_action,
 )
-from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
-from lerobot.robots.so_follower.robot_kinematic_processor import (
+from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
+from lerobot.robots.so100_follower.robot_kinematic_processor import (
    EEBoundsAndSafety,
    EEReferenceAndDelta,
    GripperVelocityToJoint,
    InverseKinematicsEEToJoints,
 )
+from lerobot.robots.so100_follower.so100_follower import SO100Follower
 from lerobot.teleoperators.phone.config_phone import PhoneConfig, PhoneOS
 from lerobot.teleoperators.phone.phone_processor import MapPhoneActionToRobotAction
 from lerobot.teleoperators.phone.teleop_phone import Phone
@@ -27,8 +27,8 @@ measuring consistency and ground truth alignment.
 Usage:
    # Basic usage with smolvla policy
    uv run python examples/rtc/eval_dataset.py \
-        --policy.path=<USER>/smolvla_check_rtc_last3 \
-        --dataset.repo_id=<USER>/check_rtc \
+        --policy.path=helper2424/smolvla_check_rtc_last3 \
+        --dataset.repo_id=helper2424/check_rtc \
        --rtc.execution_horizon=8 \
        --device=mps \
        --rtc.max_guidance_weight=10.0 \
@@ -58,16 +58,16 @@ Usage:
        --device=cuda

    uv run python examples/rtc/eval_dataset.py \
-        --policy.path=<USER>/reuben_pi0 \
-        --dataset.repo_id=<USER>/so101_cube_in_cup \
+        --policy.path=lipsop/reuben_pi0 \
+        --dataset.repo_id=ReubenLim/so101_cube_in_cup \
        --rtc.execution_horizon=8 \
        --device=cuda

    # With torch.compile for faster inference (PyTorch 2.0+)
    # Note: CUDA graphs disabled by default due to in-place ops in denoising loop
    uv run python examples/rtc/eval_dataset.py \
-        --policy.path=<USER>/smolvla_check_rtc_last3 \
-        --dataset.repo_id=<USER>/check_rtc \
+        --policy.path=helper2424/smolvla_check_rtc_last3 \
+        --dataset.repo_id=helper2424/check_rtc \
        --rtc.execution_horizon=8 \
        --device=mps \
        --use_torch_compile=true \
@@ -75,8 +75,8 @@ Usage:

    # With torch.compile on CUDA (CUDA graphs disabled by default)
    uv run python examples/rtc/eval_dataset.py \
-        --policy.path=<USER>/smolvla_check_rtc_last3 \
-        --dataset.repo_id=<USER>/check_rtc \
+        --policy.path=helper2424/smolvla_check_rtc_last3 \
+        --dataset.repo_id=helper2424/check_rtc \
        --rtc.execution_horizon=8 \
        --device=cuda \
        --use_torch_compile=true \
@@ -84,8 +84,8 @@ Usage:

    # Enable CUDA graphs (advanced - may cause tensor aliasing errors)
    uv run python examples/rtc/eval_dataset.py \
-        --policy.path=<USER>/smolvla_check_rtc_last3 \
-        --dataset.repo_id=<USER>/check_rtc \
+        --policy.path=helper2424/smolvla_check_rtc_last3 \
+        --dataset.repo_id=helper2424/check_rtc \
        --use_torch_compile=true \
        --torch_compile_backend=inductor \
        --torch_compile_mode=max-autotune \
@@ -28,7 +28,7 @@ For simulation environments, see eval_with_simulation.py
 Usage:
    # Run RTC with Real robot with RTC
    uv run examples/rtc/eval_with_real_robot.py \
-        --policy.path=<USER>/smolvla_check_rtc_last3 \
+        --policy.path=helper2424/smolvla_check_rtc_last3 \
        --policy.device=mps \
        --rtc.enabled=true \
        --rtc.execution_horizon=20 \
@@ -41,7 +41,7 @@ Usage:

    # Run RTC with Real robot without RTC
    uv run examples/rtc/eval_with_real_robot.py \
-        --policy.path=<USER>/smolvla_check_rtc_last3 \
+        --policy.path=helper2424/smolvla_check_rtc_last3 \
        --policy.device=mps \
        --rtc.enabled=false \
        --robot.type=so100_follower \
@@ -53,7 +53,7 @@ Usage:

    # Run RTC with Real robot with pi0.5 policy
    uv run examples/rtc/eval_with_real_robot.py \
-        --policy.path=<USER>/pi05_check_rtc \
+        --policy.path=helper2424/pi05_check_rtc \
        --policy.device=mps \
        --rtc.enabled=true \
        --rtc.execution_horizon=20 \
@@ -94,9 +94,9 @@ from lerobot.rl.process import ProcessSignalHandler
 from lerobot.robots import (  # noqa: F401
    Robot,
    RobotConfig,
-    bi_so_follower,
    koch_follower,
-    so_follower,
+    so100_follower,
+    so101_follower,
 )
 from lerobot.robots.utils import make_robot_from_config
 from lerobot.utils.constants import OBS_IMAGES
@@ -34,11 +34,12 @@ from lerobot.processor.converters import (
    transition_to_observation,
    transition_to_robot_action,
 )
-from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
-from lerobot.robots.so_follower.robot_kinematic_processor import (
+from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
+from lerobot.robots.so100_follower.robot_kinematic_processor import (
    ForwardKinematicsJointsToEE,
    InverseKinematicsEEToJoints,
 )
+from lerobot.robots.so100_follower.so100_follower import SO100Follower
 from lerobot.scripts.lerobot_record import record_loop
 from lerobot.utils.control_utils import init_keyboard_listener
 from lerobot.utils.utils import log_say
@@ -142,24 +143,38 @@ def main():
    listener, events = init_keyboard_listener()
    init_rerun(session_name="so100_so100_evaluate")

-    try:
-        if not robot.is_connected:
-            raise ValueError("Robot is not connected!")
+    if not robot.is_connected:
+        raise ValueError("Robot is not connected!")

-        print("Starting evaluate loop...")
-        episode_idx = 0
-        for episode_idx in range(NUM_EPISODES):
-            log_say(f"Running inference, recording eval episode {episode_idx + 1} of {NUM_EPISODES}")
+    print("Starting evaluate loop...")
+    episode_idx = 0
+    for episode_idx in range(NUM_EPISODES):
+        log_say(f"Running inference, recording eval episode {episode_idx + 1} of {NUM_EPISODES}")

-            # Main record loop
+        # Main record loop
+        record_loop(
+            robot=robot,
+            events=events,
+            fps=FPS,
+            policy=policy,
+            preprocessor=preprocessor,  # Pass the pre and post policy processors
+            postprocessor=postprocessor,
+            dataset=dataset,
+            control_time_s=EPISODE_TIME_SEC,
+            single_task=TASK_DESCRIPTION,
+            display_data=True,
+            teleop_action_processor=make_default_teleop_action_processor(),
+            robot_action_processor=robot_ee_to_joints_processor,
+            robot_observation_processor=robot_joints_to_ee_pose_processor,
+        )
+
+        # Reset the environment if not stopping or re-recording
+        if not events["stop_recording"] and ((episode_idx < NUM_EPISODES - 1) or events["rerecord_episode"]):
+            log_say("Reset the environment")
            record_loop(
                robot=robot,
                events=events,
                fps=FPS,
-                policy=policy,
-                preprocessor=preprocessor,  # Pass the pre and post policy processors
-                postprocessor=postprocessor,
-                dataset=dataset,
                control_time_s=EPISODE_TIME_SEC,
                single_task=TASK_DESCRIPTION,
                display_data=True,
@@ -168,41 +183,24 @@ def main():
                robot_observation_processor=robot_joints_to_ee_pose_processor,
            )

-            # Reset the environment if not stopping or re-recording
-            if not events["stop_recording"] and (
-                (episode_idx < NUM_EPISODES - 1) or events["rerecord_episode"]
-            ):
-                log_say("Reset the environment")
-                record_loop(
-                    robot=robot,
-                    events=events,
-                    fps=FPS,
-                    control_time_s=EPISODE_TIME_SEC,
-                    single_task=TASK_DESCRIPTION,
-                    display_data=True,
-                    teleop_action_processor=make_default_teleop_action_processor(),
-                    robot_action_processor=robot_ee_to_joints_processor,
-                    robot_observation_processor=robot_joints_to_ee_pose_processor,
-                )
+        if events["rerecord_episode"]:
+            log_say("Re-record episode")
+            events["rerecord_episode"] = False
+            events["exit_early"] = False
+            dataset.clear_episode_buffer()
+            continue

-            if events["rerecord_episode"]:
-                log_say("Re-record episode")
-                events["rerecord_episode"] = False
-                events["exit_early"] = False
-                dataset.clear_episode_buffer()
-                continue
+        # Save episode
+        dataset.save_episode()
+        episode_idx += 1

-            # Save episode
-            dataset.save_episode()
-            episode_idx += 1
-    finally:
-        # Clean up
-        log_say("Stop recording")
-        robot.disconnect()
-        listener.stop()
+    # Clean up
+    log_say("Stop recording")
+    robot.disconnect()
+    listener.stop()

-        dataset.finalize()
-        dataset.push_to_hub()
+    dataset.finalize()
+    dataset.push_to_hub()


 if __name__ == "__main__":
@@ -27,14 +27,16 @@ from lerobot.processor.converters import (
    transition_to_observation,
    transition_to_robot_action,
 )
-from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
-from lerobot.robots.so_follower.robot_kinematic_processor import (
+from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
+from lerobot.robots.so100_follower.robot_kinematic_processor import (
    EEBoundsAndSafety,
    ForwardKinematicsJointsToEE,
    InverseKinematicsEEToJoints,
 )
+from lerobot.robots.so100_follower.so100_follower import SO100Follower
 from lerobot.scripts.lerobot_record import record_loop
-from lerobot.teleoperators.so_leader import SO100Leader, SO100LeaderConfig
+from lerobot.teleoperators.so100_leader.config_so100_leader import SO100LeaderConfig
+from lerobot.teleoperators.so100_leader.so100_leader import SO100Leader
 from lerobot.utils.control_utils import init_keyboard_listener
 from lerobot.utils.utils import log_say
 from lerobot.utils.visualization_utils import init_rerun
@@ -146,23 +148,38 @@ def main():
    listener, events = init_keyboard_listener()
    init_rerun(session_name="recording_phone")

-    try:
-        if not leader.is_connected or not follower.is_connected:
-            raise ValueError("Robot or teleop is not connected!")
+    if not leader.is_connected or not follower.is_connected:
+        raise ValueError("Robot or teleop is not connected!")

-        print("Starting record loop...")
-        episode_idx = 0
-        while episode_idx < NUM_EPISODES and not events["stop_recording"]:
-            log_say(f"Recording episode {episode_idx + 1} of {NUM_EPISODES}")
+    print("Starting record loop...")
+    episode_idx = 0
+    while episode_idx < NUM_EPISODES and not events["stop_recording"]:
+        log_say(f"Recording episode {episode_idx + 1} of {NUM_EPISODES}")

-            # Main record loop
+        # Main record loop
+        record_loop(
+            robot=follower,
+            events=events,
+            fps=FPS,
+            teleop=leader,
+            dataset=dataset,
+            control_time_s=EPISODE_TIME_SEC,
+            single_task=TASK_DESCRIPTION,
+            display_data=True,
+            teleop_action_processor=leader_joints_to_ee,
+            robot_action_processor=ee_to_follower_joints,
+            robot_observation_processor=follower_joints_to_ee,
+        )
+
+        # Reset the environment if not stopping or re-recording
+        if not events["stop_recording"] and (episode_idx < NUM_EPISODES - 1 or events["rerecord_episode"]):
+            log_say("Reset the environment")
            record_loop(
                robot=follower,
                events=events,
                fps=FPS,
                teleop=leader,
-                dataset=dataset,
-                control_time_s=EPISODE_TIME_SEC,
+                control_time_s=RESET_TIME_SEC,
                single_task=TASK_DESCRIPTION,
                display_data=True,
                teleop_action_processor=leader_joints_to_ee,
@@ -170,44 +187,25 @@ def main():
                robot_observation_processor=follower_joints_to_ee,
            )

-            # Reset the environment if not stopping or re-recording
-            if not events["stop_recording"] and (
-                episode_idx < NUM_EPISODES - 1 or events["rerecord_episode"]
-            ):
-                log_say("Reset the environment")
-                record_loop(
-                    robot=follower,
-                    events=events,
-                    fps=FPS,
-                    teleop=leader,
-                    control_time_s=RESET_TIME_SEC,
-                    single_task=TASK_DESCRIPTION,
-                    display_data=True,
-                    teleop_action_processor=leader_joints_to_ee,
-                    robot_action_processor=ee_to_follower_joints,
-                    robot_observation_processor=follower_joints_to_ee,
-                )
+        if events["rerecord_episode"]:
+            log_say("Re-recording episode")
+            events["rerecord_episode"] = False
+            events["exit_early"] = False
+            dataset.clear_episode_buffer()
+            continue

-            if events["rerecord_episode"]:
-                log_say("Re-recording episode")
-                events["rerecord_episode"] = False
-                events["exit_early"] = False
-                dataset.clear_episode_buffer()
-                continue
+        # Save episode
+        dataset.save_episode()
+        episode_idx += 1

-            # Save episode
-            dataset.save_episode()
-            episode_idx += 1
+    # Clean up
+    log_say("Stop recording")
+    leader.disconnect()
+    follower.disconnect()
+    listener.stop()

-    finally:
-        # Clean up
-        log_say("Stop recording")
-        leader.disconnect()
-        follower.disconnect()
-        listener.stop()
-
-        dataset.finalize()
-        dataset.push_to_hub()
+    dataset.finalize()
+    dataset.push_to_hub()


 if __name__ == "__main__":
@@ -24,10 +24,11 @@ from lerobot.processor.converters import (
    robot_action_observation_to_transition,
    transition_to_robot_action,
 )
-from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
-from lerobot.robots.so_follower.robot_kinematic_processor import (
+from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
+from lerobot.robots.so100_follower.robot_kinematic_processor import (
    InverseKinematicsEEToJoints,
 )
+from lerobot.robots.so100_follower.so100_follower import SO100Follower
 from lerobot.utils.constants import ACTION
 from lerobot.utils.robot_utils import precise_sleep
 from lerobot.utils.utils import log_say
@@ -74,35 +75,32 @@ def main():
    # Connect to the robot
    robot.connect()

-    try:
-        if not robot.is_connected:
-            raise ValueError("Robot is not connected!")
+    if not robot.is_connected:
+        raise ValueError("Robot is not connected!")

-        print("Starting replay loop...")
-        log_say(f"Replaying episode {EPISODE_IDX}")
-        for idx in range(len(episode_frames)):
-            t0 = time.perf_counter()
+    print("Starting replay loop...")
+    log_say(f"Replaying episode {EPISODE_IDX}")
+    for idx in range(len(episode_frames)):
+        t0 = time.perf_counter()

-            # Get recorded action from dataset
-            ee_action = {
-                name: float(actions[idx][ACTION][i])
-                for i, name in enumerate(dataset.features[ACTION]["names"])
-            }
+        # Get recorded action from dataset
+        ee_action = {
+            name: float(actions[idx][ACTION][i]) for i, name in enumerate(dataset.features[ACTION]["names"])
+        }

-            # Get robot observation
-            robot_obs = robot.get_observation()
+        # Get robot observation
+        robot_obs = robot.get_observation()

-            # Dataset EE -> robot joints
-            joint_action = robot_ee_to_joints_processor((ee_action, robot_obs))
+        # Dataset EE -> robot joints
+        joint_action = robot_ee_to_joints_processor((ee_action, robot_obs))

-            # Send action to robot
-            _ = robot.send_action(joint_action)
+        # Send action to robot
+        _ = robot.send_action(joint_action)

-            precise_sleep(max(1.0 / dataset.fps - (time.perf_counter() - t0), 0.0))
+        precise_sleep(1.0 / dataset.fps - (time.perf_counter() - t0))

-    finally:
-        # Clean up
-        robot.disconnect()
+    # Clean up
+    robot.disconnect()


 if __name__ == "__main__":
@@ -23,13 +23,15 @@ from lerobot.processor.converters import (
    robot_action_to_transition,
    transition_to_robot_action,
 )
-from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
-from lerobot.robots.so_follower.robot_kinematic_processor import (
+from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
+from lerobot.robots.so100_follower.robot_kinematic_processor import (
    EEBoundsAndSafety,
    ForwardKinematicsJointsToEE,
    InverseKinematicsEEToJoints,
 )
-from lerobot.teleoperators.so_leader import SO100Leader, SO100LeaderConfig
+from lerobot.robots.so100_follower.so100_follower import SO100Follower
+from lerobot.teleoperators.so100_leader.config_so100_leader import SO100LeaderConfig
+from lerobot.teleoperators.so100_leader.so100_leader import SO100Leader
 from lerobot.utils.robot_utils import precise_sleep
 from lerobot.utils.visualization_utils import init_rerun, log_rerun_data

@@ -5,7 +5,8 @@ from lerobot.datasets.lerobot_dataset import LeRobotDatasetMetadata
 from lerobot.policies.act.modeling_act import ACTPolicy
 from lerobot.policies.factory import make_pre_post_processors
 from lerobot.policies.utils import build_inference_frame, make_robot_action
-from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
+from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
+from lerobot.robots.so100_follower.so100_follower import SO100Follower

 MAX_EPISODES = 5
 MAX_STEPS_PER_EPISODE = 20
@@ -4,7 +4,7 @@ from lerobot.async_inference.configs import RobotClientConfig
 from lerobot.async_inference.helpers import visualize_action_queue_size
 from lerobot.async_inference.robot_client import RobotClient
 from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
-from lerobot.robots.so_follower import SO100FollowerConfig
+from lerobot.robots.so100_follower import SO100FollowerConfig


 def main():
@@ -30,7 +30,6 @@ def main():
        robot=robot_cfg,
        server_address=server_address,
        policy_device="mps",
-        client_device="cpu",
        policy_type="act",
        pretrained_name_or_path="<user>/robot_learning_tutorial_act",
        chunk_size_threshold=0.5,  # g
@@ -5,7 +5,8 @@ from lerobot.datasets.lerobot_dataset import LeRobotDatasetMetadata
 from lerobot.policies.diffusion.modeling_diffusion import DiffusionPolicy
 from lerobot.policies.factory import make_pre_post_processors
 from lerobot.policies.utils import build_inference_frame, make_robot_action
-from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
+from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
+from lerobot.robots.so100_follower.so100_follower import SO100Follower

 MAX_EPISODES = 5
 MAX_STEPS_PER_EPISODE = 20
@@ -5,7 +5,8 @@ from lerobot.datasets.utils import hw_to_dataset_features
 from lerobot.policies.factory import make_pre_post_processors
 from lerobot.policies.pi0.modeling_pi0 import PI0Policy
 from lerobot.policies.utils import build_inference_frame, make_robot_action
-from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
+from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
+from lerobot.robots.so100_follower.so100_follower import SO100Follower

 MAX_EPISODES = 5
 MAX_STEPS_PER_EPISODE = 20
@@ -4,6 +4,7 @@ from pathlib import Path
 from queue import Empty, Full

 import torch
+import torch.optim as optim

 from lerobot.datasets.lerobot_dataset import LeRobotDataset
 from lerobot.datasets.utils import hw_to_dataset_features
@@ -11,11 +12,10 @@ from lerobot.envs.configs import HILSerlProcessorConfig, HILSerlRobotEnvConfig
 from lerobot.policies.sac.configuration_sac import SACConfig
 from lerobot.policies.sac.modeling_sac import SACPolicy
 from lerobot.policies.sac.reward_model.modeling_classifier import Classifier
-from lerobot.rl.algorithms.sac import SACAlgorithm, SACAlgorithmConfig
 from lerobot.rl.buffer import ReplayBuffer
 from lerobot.rl.gym_manipulator import make_robot_env
-from lerobot.robots.so_follower import SO100FollowerConfig
-from lerobot.teleoperators.so_leader import SO100LeaderConfig
+from lerobot.robots.so100_follower import SO100FollowerConfig
+from lerobot.teleoperators.so100_leader import SO100LeaderConfig
 from lerobot.teleoperators.utils import TeleopEvents

 LOG_EVERY = 10
@@ -40,9 +40,8 @@ def run_learner(
    policy_learner.train()
    policy_learner.to(device)

-    algo_config = SACAlgorithmConfig.from_policy_config(policy_learner.config)
-    algorithm = SACAlgorithm(policy=policy_learner, config=algo_config)
-    algorithm.make_optimizers()
+    # Create Adam optimizer from scratch - simple and clean
+    optimizer = optim.Adam(policy_learner.parameters(), lr=lr)

    print(f"[LEARNER] Online buffer capacity: {online_buffer.capacity}")
    print(f"[LEARNER] Offline buffer capacity: {offline_buffer.capacity}")
@@ -84,26 +83,24 @@ def run_learner(
                else:
                    batch[key] = online_batch[key]

-            def batch_iter(b=batch):
-                while True:
-                    yield b
+            loss, _ = policy_learner.forward(batch)

-            stats = algorithm.update(batch_iter())
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
            training_step += 1

            if training_step % LOG_EVERY == 0:
-                log_dict = stats.to_log_dict()
                print(
-                    f"[LEARNER] Training step {training_step}, "
-                    f"critic_loss: {log_dict.get('critic', 'N/A'):.4f}, "
+                    f"[LEARNER] Training step {training_step}, Loss: {loss.item():.4f}, "
                    f"Buffers: Online={len(online_buffer)}, Offline={len(offline_buffer)}"
                )

            # Send updated parameters to actor every 10 training steps
            if training_step % SEND_EVERY == 0:
                try:
-                    weights = algorithm.get_weights()
-                    parameters_queue.put_nowait(weights)
+                    state_dict = {k: v.cpu() for k, v in policy_learner.state_dict().items()}
+                    parameters_queue.put_nowait(state_dict)
                    print("[LEARNER] Sent updated parameters to actor")
                except Full:
                    # Missing write due to queue not being consumed (should happen rarely)
@@ -147,15 +144,15 @@ def run_actor(

            while step < MAX_STEPS_PER_EPISODE and not shutdown_event.is_set():
                try:
-                    new_weights = parameters_queue.get_nowait()
-                    policy_actor.load_state_dict(new_weights)
+                    new_params = parameters_queue.get_nowait()
+                    policy_actor.load_state_dict(new_params)
                    print("[ACTOR] Updated policy parameters from learner")
                except Empty:  # No new updated parameters available from learner, waiting
                    pass

-                # Get action from policy (returns full action: continuous + discrete)
+                # Get action from policy
                policy_obs = make_policy_obs(obs, device=device)
-                action_tensor = policy_actor.select_action(policy_obs)
+                action_tensor = policy_actor.select_action(policy_obs)  # predicts a single action
                action = action_tensor.squeeze(0).cpu().numpy()

                # Step environment
@@ -5,7 +5,8 @@ from lerobot.datasets.utils import hw_to_dataset_features
 from lerobot.policies.factory import make_pre_post_processors
 from lerobot.policies.smolvla.modeling_smolvla import SmolVLAPolicy
 from lerobot.policies.utils import build_inference_frame, make_robot_action
-from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
+from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
+from lerobot.robots.so100_follower.so100_follower import SO100Follower

 MAX_EPISODES = 5
 MAX_STEPS_PER_EPISODE = 20
@@ -13,9 +13,16 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+"""
+Example: GR00T Locomotion with Pre-loaded Policies
+
+This example demonstrates the NEW pattern for loading GR00T policies externally
+and passing them to the robot class.
+"""

 import argparse
 import logging
+import threading
 import time
 from collections import deque

@@ -24,26 +31,24 @@ import onnxruntime as ort
 from huggingface_hub import hf_hub_download

 from lerobot.robots.unitree_g1.config_unitree_g1 import UnitreeG1Config
-from lerobot.robots.unitree_g1.g1_utils import G1_29_JointIndex
 from lerobot.robots.unitree_g1.unitree_g1 import UnitreeG1

-logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)

-
 GROOT_DEFAULT_ANGLES = np.zeros(29, dtype=np.float32)
-GROOT_DEFAULT_ANGLES[[0, 6]] = -0.1  # Hip pitch
-GROOT_DEFAULT_ANGLES[[3, 9]] = 0.3  # Knee
-GROOT_DEFAULT_ANGLES[[4, 10]] = -0.2  # Ankle pitch
+GROOT_DEFAULT_ANGLES[[0, 6]] = -0.1  # hip pitch
+GROOT_DEFAULT_ANGLES[[3, 9]] = 0.3  # knee
+GROOT_DEFAULT_ANGLES[[4, 10]] = -0.2  # ankle pitch

 MISSING_JOINTS = []
-G1_MODEL = "g1_23"  # Or "g1_29"
+G1_MODEL = "g1_23"  # or "g1_29"
 if G1_MODEL == "g1_23":
-    MISSING_JOINTS = [12, 14, 20, 21, 27, 28]  # Waist yaw/pitch, wrist pitch/yaw
+    MISSING_JOINTS = [12, 14, 20, 21, 27, 28]  # waist yaw/pitch, wrist pitch/yaw
+
+LOCOMOTION_ACTION_SCALE = 0.25
+
+LOCOMOTION_CONTROL_DT = 0.02

-# Control parameters
-ACTION_SCALE = 0.25
-CONTROL_DT = 0.02  # 50Hz
 ANG_VEL_SCALE: float = 0.25
 DOF_POS_SCALE: float = 1.0
 DOF_VEL_SCALE: float = 0.05
@@ -56,12 +61,12 @@ DEFAULT_GROOT_REPO_ID = "nepyope/GR00T-WholeBodyControl_g1"
 def load_groot_policies(
    repo_id: str = DEFAULT_GROOT_REPO_ID,
 ) -> tuple[ort.InferenceSession, ort.InferenceSession]:
-    """Load GR00T dual-policy system (Balance + Walk) from the hub.
+    """Load GR00T dual-policy system (Balance + Walk) from Hugging Face Hub.

    Args:
        repo_id: Hugging Face Hub repository ID containing the ONNX policies.
    """
-    logger.info(f"Loading GR00T dual-policy system from the hub ({repo_id})...")
+    logger.info(f"Loading GR00T dual-policy system from Hugging Face Hub ({repo_id})...")

    # Download ONNX policies from Hugging Face Hub
    balance_path = hf_hub_download(
@@ -83,7 +88,15 @@ def load_groot_policies(


 class GrootLocomotionController:
-    """GR00T lower-body locomotion controller for the Unitree G1."""
+    """
+    Handles GR00T-style locomotion control for the Unitree G1 robot.
+
+    This controller manages:
+    - Dual-policy system (Balance + Walk)
+    - 29-joint observation processing
+    - 15D action output (legs + waist)
+    - Policy inference and motor command generation
+    """

    def __init__(self, policy_balance, policy_walk, robot, config):
        self.policy_balance = policy_balance
@@ -91,9 +104,9 @@ class GrootLocomotionController:
        self.robot = robot
        self.config = config

-        self.cmd = np.array([0.0, 0.0, 0.0], dtype=np.float32)  # vx, vy, theta_dot
+        self.locomotion_cmd = np.array([0.0, 0.0, 0.0], dtype=np.float32)  # vx, vy, theta_dot

-        # Robot state
+        # GR00T-specific state
        self.groot_qj_all = np.zeros(29, dtype=np.float32)
        self.groot_dqj_all = np.zeros(29, dtype=np.float32)
        self.groot_action = np.zeros(15, dtype=np.float32)
@@ -103,39 +116,47 @@ class GrootLocomotionController:
        self.groot_height_cmd = 0.74  # Default base height
        self.groot_orientation_cmd = np.array([0.0, 0.0, 0.0], dtype=np.float32)

-        # Input to GR00T is 6 frames (6*86D=516)
+        # input to gr00t is 6 frames (6*86D=516)
        for _ in range(6):
            self.groot_obs_history.append(np.zeros(86, dtype=np.float32))

+        # Thread management
+        self.locomotion_running = False
+        self.locomotion_thread = None
+
        logger.info("GrootLocomotionController initialized")

-    def run_step(self):
-        # Get current observation
-        obs = self.robot.get_observation()
+    def groot_locomotion_run(self):
+        # get current observation
+        robot_state = self.robot.get_observation()

-        if not obs:
+        if robot_state is None:
            return

-        # Get command from remote controller
-        if obs["remote.buttons"][0]:  # R1 - raise waist
-            self.groot_height_cmd += 0.001
-            self.groot_height_cmd = np.clip(self.groot_height_cmd, 0.50, 1.00)
-        if obs["remote.buttons"][4]:  # R2 - lower waist
-            self.groot_height_cmd -= 0.001
-            self.groot_height_cmd = np.clip(self.groot_height_cmd, 0.50, 1.00)
+        # get command from remote controller
+        if robot_state.wireless_remote is not None:
+            self.robot.remote_controller.set(robot_state.wireless_remote)
+            if self.robot.remote_controller.button[0]:  # R1 - raise waist
+                self.groot_height_cmd += 0.001
+                self.groot_height_cmd = np.clip(self.groot_height_cmd, 0.50, 1.00)
+            if self.robot.remote_controller.button[4]:  # R2 - lower waist
+                self.groot_height_cmd -= 0.001
+                self.groot_height_cmd = np.clip(self.groot_height_cmd, 0.50, 1.00)
+        else:
+            self.robot.remote_controller.lx = 0.0
+            self.robot.remote_controller.ly = 0.0
+            self.robot.remote_controller.rx = 0.0
+            self.robot.remote_controller.ry = 0.0

-        self.cmd[0] = obs["remote.ly"]  # Forward/backward
-        self.cmd[1] = obs["remote.lx"] * -1  # Left/right
-        self.cmd[2] = obs["remote.rx"] * -1  # Rotation rate
+        self.locomotion_cmd[0] = self.robot.remote_controller.ly  # forward/backward
+        self.locomotion_cmd[1] = self.robot.remote_controller.lx * -1  # left/right
+        self.locomotion_cmd[2] = self.robot.remote_controller.rx * -1  # rotation rate

-        # Get joint positions and velocities from flat dict
-        for motor in G1_29_JointIndex:
-            name = motor.name
-            idx = motor.value
-            self.groot_qj_all[idx] = obs[f"{name}.q"]
-            self.groot_dqj_all[idx] = obs[f"{name}.dq"]
+        for i in range(29):
+            self.groot_qj_all[i] = robot_state.motor_state[i].q
+            self.groot_dqj_all[i] = robot_state.motor_state[i].dq

-        # Adapt observation for g1_23dof
+        # adapt observation for g1_23dof
        for idx in MISSING_JOINTS:
            self.groot_qj_all[idx] = 0.0
            self.groot_dqj_all[idx] = 0.0
@@ -144,18 +165,18 @@ class GrootLocomotionController:
        qj_obs = self.groot_qj_all.copy()
        dqj_obs = self.groot_dqj_all.copy()

-        # Express IMU data in gravity frame of reference
-        quat = [obs["imu.quat.w"], obs["imu.quat.x"], obs["imu.quat.y"], obs["imu.quat.z"]]
-        ang_vel = np.array([obs["imu.gyro.x"], obs["imu.gyro.y"], obs["imu.gyro.z"]], dtype=np.float32)
+        # express imu data in gravity frame of reference
+        quat = robot_state.imu_state.quaternion
+        ang_vel = np.array(robot_state.imu_state.gyroscope, dtype=np.float32)
        gravity_orientation = self.robot.get_gravity_orientation(quat)

-        # Scale joint positions and velocities before policy inference
+        # scale joint positions and velocities before policy inference
        qj_obs = (qj_obs - GROOT_DEFAULT_ANGLES) * DOF_POS_SCALE
        dqj_obs = dqj_obs * DOF_VEL_SCALE
        ang_vel_scaled = ang_vel * ANG_VEL_SCALE

-        # Build single frame observation
-        self.groot_obs_single[:3] = self.cmd * np.array(CMD_SCALE)
+        # build single frame observation
+        self.groot_obs_single[:3] = self.locomotion_cmd * np.array(CMD_SCALE)
        self.groot_obs_single[3] = self.groot_height_cmd
        self.groot_obs_single[4:7] = self.groot_orientation_cmd
        self.groot_obs_single[7:10] = ang_vel_scaled
@@ -173,76 +194,113 @@ class GrootLocomotionController:
            end_idx = start_idx + 86
            self.groot_obs_stacked[start_idx:end_idx] = obs_frame

-        cmd_magnitude = np.linalg.norm(self.cmd)
+        # Run policy inference (ONNX) with 516D stacked observation
+
+        cmd_magnitude = np.linalg.norm(self.locomotion_cmd)
+
        selected_policy = (
            self.policy_balance if cmd_magnitude < 0.05 else self.policy_walk
-        )  # Balance/standing policy for small commands, walking policy for movement commands
+        )  # balance/standing policy for small commands, walking policy for movement commands

-        # Run policy inference
+        # run policy inference
        ort_inputs = {selected_policy.get_inputs()[0].name: np.expand_dims(self.groot_obs_stacked, axis=0)}
        ort_outs = selected_policy.run(None, ort_inputs)
        self.groot_action = ort_outs[0].squeeze()

-        # Transform action back to target joint positions
-        target_dof_pos_15 = GROOT_DEFAULT_ANGLES[:15] + self.groot_action * ACTION_SCALE
+        # transform action back to target joint positions
+        target_dof_pos_15 = GROOT_DEFAULT_ANGLES[:15] + self.groot_action * LOCOMOTION_ACTION_SCALE

-        # Build action dict (only first 15 joints for GR00T)
-        action_dict = {}
+        # command motors
        for i in range(15):
-            motor_name = G1_29_JointIndex(i).name
-            action_dict[f"{motor_name}.q"] = float(target_dof_pos_15[i])
+            motor_idx = i
+            self.robot.msg.motor_cmd[motor_idx].q = target_dof_pos_15[i]
+            self.robot.msg.motor_cmd[motor_idx].qd = 0
+            self.robot.msg.motor_cmd[motor_idx].kp = self.robot.kp[motor_idx]
+            self.robot.msg.motor_cmd[motor_idx].kd = self.robot.kd[motor_idx]
+            self.robot.msg.motor_cmd[motor_idx].tau = 0

-        # Zero out missing joints for g1_23dof
+        # adapt action for g1_23dof
        for joint_idx in MISSING_JOINTS:
-            motor_name = G1_29_JointIndex(joint_idx).name
-            action_dict[f"{motor_name}.q"] = 0.0
+            self.robot.msg.motor_cmd[joint_idx].q = 0.0
+            self.robot.msg.motor_cmd[joint_idx].qd = 0
+            self.robot.msg.motor_cmd[joint_idx].kp = self.robot.kp[joint_idx]
+            self.robot.msg.motor_cmd[joint_idx].kd = self.robot.kd[joint_idx]
+            self.robot.msg.motor_cmd[joint_idx].tau = 0

-        # Send action to robot
-        self.robot.send_action(action_dict)
+        # send action to robot
+        self.robot.send_action(self.robot.msg)

-
-def run(repo_id: str = DEFAULT_GROOT_REPO_ID) -> None:
-    """Main function to run the GR00T locomotion controller.
-
-    Args:
-        repo_id: Hugging Face Hub repository ID for GR00T policies.
-    """
-    # Load policies
-    policy_balance, policy_walk = load_groot_policies(repo_id=repo_id)
-
-    # Initialize robot
-    config = UnitreeG1Config()
-    robot = UnitreeG1(config)
-
-    robot.connect()
-
-    # Initialize gr00T locomotion controller
-    groot_controller = GrootLocomotionController(
-        policy_balance=policy_balance,
-        policy_walk=policy_walk,
-        robot=robot,
-        config=config,
-    )
-
-    try:
-        robot.reset(CONTROL_DT, GROOT_DEFAULT_ANGLES)
-
-        logger.info("Use joystick: LY=fwd/back, LX=left/right, RX=rotate, R1=raise waist, R2=lower waist")
-        logger.info("Press Ctrl+C to stop")
-
-        # Run step
-        while not robot._shutdown_event.is_set():
+    def _locomotion_thread_loop(self):
+        """Background thread that runs the locomotion policy at specified rate."""
+        logger.info("Locomotion thread started")
+        while self.locomotion_running:
            start_time = time.time()
-            groot_controller.run_step()
+            try:
+                self.groot_locomotion_run()
+            except Exception as e:
+                logger.error(f"Error in locomotion loop: {e}")
+
+            # Sleep to maintain control rate
            elapsed = time.time() - start_time
-            sleep_time = max(0, CONTROL_DT - elapsed)
+            sleep_time = max(0, LOCOMOTION_CONTROL_DT - elapsed)
            time.sleep(sleep_time)
-    except KeyboardInterrupt:
-        logger.info("Stopping locomotion...")
-    finally:
-        if robot.is_connected:
-            robot.disconnect()
-        logger.info("Done!")
+        logger.info("Locomotion thread stopped")
+
+    def start_locomotion_thread(self):
+        if self.locomotion_running:
+            logger.warning("Locomotion thread already running")
+            return
+
+        logger.info("Starting locomotion control thread...")
+        self.locomotion_running = True
+        self.locomotion_thread = threading.Thread(target=self._locomotion_thread_loop, daemon=True)
+        self.locomotion_thread.start()
+
+        logger.info("Locomotion control thread started!")
+
+    def stop_locomotion_thread(self):
+        if not self.locomotion_running:
+            return
+
+        logger.info("Stopping locomotion control thread...")
+        self.locomotion_running = False
+        if self.locomotion_thread:
+            self.locomotion_thread.join(timeout=2.0)
+        logger.info("Locomotion control thread stopped")
+
+    def reset_robot(self):
+        """Move robot legs to default standing position over 2 seconds (arms are not moved)."""
+        total_time = 3.0
+        num_step = int(total_time / self.robot.control_dt)
+
+        # Only control legs, not arms (first 12 joints)
+        default_pos = GROOT_DEFAULT_ANGLES  # First 12 values are leg angles
+        dof_size = len(default_pos)
+
+        # Get current lowstate
+        robot_state = self.robot.get_observation()
+
+        # Record the current leg positions
+        init_dof_pos = np.zeros(dof_size, dtype=np.float32)
+        for i in range(dof_size):
+            init_dof_pos[i] = robot_state.motor_state[i].q
+
+        # Move legs to default pos
+        for i in range(num_step):
+            alpha = i / num_step
+            for motor_idx in range(dof_size):
+                target_pos = default_pos[motor_idx]
+                self.robot.msg.motor_cmd[motor_idx].q = (
+                    init_dof_pos[motor_idx] * (1 - alpha) + target_pos * alpha
+                )
+                self.robot.msg.motor_cmd[motor_idx].qd = 0
+                self.robot.msg.motor_cmd[motor_idx].kp = self.robot.kp[motor_idx]
+                self.robot.msg.motor_cmd[motor_idx].kd = self.robot.kd[motor_idx]
+                self.robot.msg.motor_cmd[motor_idx].tau = 0
+            self.robot.msg.crc = self.robot.crc.Crc(self.robot.msg)
+            self.robot.lowcmd_publisher.Write(self.robot.msg)
+            time.sleep(self.robot.control_dt)
+        logger.info("Reached default position (legs only)")


 if __name__ == "__main__":
@@ -255,4 +313,35 @@ if __name__ == "__main__":
    )
    args = parser.parse_args()

-    run(repo_id=args.repo_id)
+    # load policies
+    policy_balance, policy_walk = load_groot_policies(repo_id=args.repo_id)
+
+    # initialize robot
+    config = UnitreeG1Config()
+    robot = UnitreeG1(config)
+
+    # initialize gr00t locomotion controller
+    groot_controller = GrootLocomotionController(
+        policy_balance=policy_balance,
+        policy_walk=policy_walk,
+        robot=robot,
+        config=config,
+    )
+
+    # reset legs and start locomotion thread
+    try:
+        groot_controller.reset_robot()
+        groot_controller.start_locomotion_thread()
+
+        # log status
+        logger.info("Robot initialized with GR00T locomotion policies")
+        logger.info("Locomotion controller running in background thread")
+        logger.info("Press Ctrl+C to stop")
+
+        # keep robot alive
+        while True:
+            time.sleep(1.0)
+    except KeyboardInterrupt:
+        print("\nStopping locomotion...")
+        groot_controller.stop_locomotion_thread()
+        print("Done!")
@@ -1,264 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import json
-import logging
-import time
-
-import numpy as np
-import onnx
-import onnxruntime as ort
-from huggingface_hub import hf_hub_download
-
-from lerobot.robots.unitree_g1.config_unitree_g1 import UnitreeG1Config
-from lerobot.robots.unitree_g1.g1_utils import G1_29_JointIndex
-from lerobot.robots.unitree_g1.unitree_g1 import UnitreeG1
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-DEFAULT_ANGLES = np.zeros(29, dtype=np.float32)
-DEFAULT_ANGLES[[0, 6]] = -0.312  # Hip pitch
-DEFAULT_ANGLES[[3, 9]] = 0.669  # Knee
-DEFAULT_ANGLES[[4, 10]] = -0.363  # Ankle pitch
-DEFAULT_ANGLES[[15, 22]] = 0.2  # Shoulder pitch
-DEFAULT_ANGLES[16] = 0.2  # Left shoulder roll
-DEFAULT_ANGLES[23] = -0.2  # Right shoulder roll
-DEFAULT_ANGLES[[18, 25]] = 0.6  # Elbow
-
-MISSING_JOINTS = []
-G1_MODEL = "g1_23"  # Or "g1_29"
-if G1_MODEL == "g1_23":
-    MISSING_JOINTS = [12, 14, 20, 21, 27, 28]  # Waist yaw/pitch, wrist pitch/yaw
-
-# Control parameters
-ACTION_SCALE = 0.25
-CONTROL_DT = 0.02  # 50Hz
-ANG_VEL_SCALE = 0.25
-DOF_POS_SCALE = 1.0
-DOF_VEL_SCALE = 0.05
-GAIT_PERIOD = 1.0
-
-
-DEFAULT_HOLOSOMA_REPO_ID = "nepyope/holosoma_locomotion"
-
-# Policy filename mapping
-POLICY_FILES = {
-    "fastsac": "fastsac_g1_29dof.onnx",
-    "ppo": "ppo_g1_29dof.onnx",
-}
-
-
-def load_policy(
-    repo_id: str = DEFAULT_HOLOSOMA_REPO_ID,
-    policy_type: str = "fastsac",
-) -> tuple[ort.InferenceSession, np.ndarray, np.ndarray]:
-    """Load Holosoma locomotion policy and extract KP/KD from metadata.
-
-    Args:
-        repo_id: Hugging Face Hub repo ID
-        policy_type: Either "fastsac" (default) or "ppo"
-
-    Returns:
-        (policy, kp, kd) tuple
-    """
-    if policy_type not in POLICY_FILES:
-        raise ValueError(f"Unknown policy type: {policy_type}. Choose from: {list(POLICY_FILES.keys())}")
-
-    filename = POLICY_FILES[policy_type]
-    logger.info(f"Loading {policy_type.upper()} policy from: {repo_id}/{filename}")
-    policy_path = hf_hub_download(repo_id=repo_id, filename=filename)
-
-    policy = ort.InferenceSession(policy_path)
-    logger.info(f"Policy loaded: {policy.get_inputs()[0].shape} → {policy.get_outputs()[0].shape}")
-
-    # Extract KP/KD from ONNX metadata
-    model = onnx.load(policy_path)
-    metadata = {prop.key: prop.value for prop in model.metadata_props}
-
-    if "kp" not in metadata or "kd" not in metadata:
-        raise ValueError("ONNX model must contain 'kp' and 'kd' in metadata")
-
-    kp = np.array(json.loads(metadata["kp"]), dtype=np.float32)
-    kd = np.array(json.loads(metadata["kd"]), dtype=np.float32)
-    logger.info(f"Loaded KP/KD from ONNX ({len(kp)} joints)")
-
-    return policy, kp, kd
-
-
-class HolosomaLocomotionController:
-    """Holosoma whole-body locomotion controller for Unitree G1."""
-
-    def __init__(self, policy, robot, kp: np.ndarray, kd: np.ndarray):
-        self.policy = policy
-        self.robot = robot
-
-        # Override robot's PD gains with policy gains
-        self.robot.kp = kp
-        self.robot.kd = kd
-
-        self.cmd = np.zeros(3, dtype=np.float32)
-
-        # Robot state
-        self.qj = np.zeros(29, dtype=np.float32)
-        self.dqj = np.zeros(29, dtype=np.float32)
-        self.obs = np.zeros(100, dtype=np.float32)
-        self.last_action = np.zeros(29, dtype=np.float32)
-
-        # Gait phase
-        self.phase = np.array([[0.0, np.pi]], dtype=np.float32)
-        self.phase_dt = 2 * np.pi / ((1.0 / CONTROL_DT) * GAIT_PERIOD)
-        self.is_standing = True
-
-    def run_step(self):
-        # Get current observation
-        obs = self.robot.get_observation()
-
-        if not obs:
-            return
-
-        # Get command from remote controller
-        ly = obs["remote.ly"] if abs(obs["remote.ly"]) > 0.1 else 0.0
-        lx = obs["remote.lx"] if abs(obs["remote.lx"]) > 0.1 else 0.0
-        rx = obs["remote.rx"] if abs(obs["remote.rx"]) > 0.1 else 0.0
-        self.cmd[:] = [ly, -lx, -rx]
-
-        # Get joint positions and velocities
-        for motor in G1_29_JointIndex:
-            name = motor.name
-            idx = motor.value
-            self.qj[idx] = obs[f"{name}.q"]
-            self.dqj[idx] = obs[f"{name}.dq"]
-
-        # Adapt observation for g1_23dof
-        for idx in MISSING_JOINTS:
-            self.qj[idx] = 0.0
-            self.dqj[idx] = 0.0
-
-        # Express IMU data in gravity frame of reference
-        quat = [obs["imu.quat.w"], obs["imu.quat.x"], obs["imu.quat.y"], obs["imu.quat.z"]]
-        ang_vel = np.array([obs["imu.gyro.x"], obs["imu.gyro.y"], obs["imu.gyro.z"]], dtype=np.float32)
-        gravity = self.robot.get_gravity_orientation(quat)
-
-        # Scale joint positions and velocities before policy inference
-        qj_obs = (self.qj - DEFAULT_ANGLES) * DOF_POS_SCALE
-        dqj_obs = self.dqj * DOF_VEL_SCALE
-        ang_vel_s = ang_vel * ANG_VEL_SCALE
-
-        # Update gait phase
-        if np.linalg.norm(self.cmd[:2]) < 0.01 and abs(self.cmd[2]) < 0.01:
-            self.phase[0, :] = np.pi
-            self.is_standing = True
-        elif self.is_standing:
-            self.phase = np.array([[0.0, np.pi]], dtype=np.float32)
-            self.is_standing = False
-        else:
-            self.phase = np.fmod(self.phase + self.phase_dt + np.pi, 2 * np.pi) - np.pi
-
-        sin_ph = np.sin(self.phase[0])
-        cos_ph = np.cos(self.phase[0])
-
-        # Build observations
-        self.obs[0:29] = self.last_action
-        self.obs[29:32] = ang_vel_s
-        self.obs[32] = self.cmd[2]
-        self.obs[33:35] = self.cmd[:2]
-        self.obs[35:37] = cos_ph
-        self.obs[37:66] = qj_obs
-        self.obs[66:95] = dqj_obs
-        self.obs[95:98] = gravity
-        self.obs[98:100] = sin_ph
-
-        # Run policy inference
-        ort_in = {self.policy.get_inputs()[0].name: self.obs.reshape(1, -1).astype(np.float32)}
-        raw_action = self.policy.run(None, ort_in)[0].squeeze()
-        action = np.clip(raw_action, -100.0, 100.0)
-        self.last_action = action.copy()
-
-        # Transform action back to target joint positions
-        target = DEFAULT_ANGLES + action * ACTION_SCALE
-
-        # Build action dict
-        action_dict = {}
-        for motor in G1_29_JointIndex:
-            action_dict[f"{motor.name}.q"] = float(target[motor.value])
-
-        # Zero out missing joints for g1_23dof
-        for joint_idx in MISSING_JOINTS:
-            motor_name = G1_29_JointIndex(joint_idx).name
-            action_dict[f"{motor_name}.q"] = 0.0
-
-        # Send action to robot
-        self.robot.send_action(action_dict)
-
-
-def run(repo_id: str = DEFAULT_HOLOSOMA_REPO_ID, policy_type: str = "fastsac") -> None:
-    """Main function to run the Holosoma locomotion controller.
-
-    Args:
-        repo_id: Hugging Face Hub repository ID for Holosoma policies.
-        policy_type: Policy type to use ('fastsac' or 'ppo').
-    """
-    # Load policy and gains
-    policy, kp, kd = load_policy(repo_id=repo_id, policy_type=policy_type)
-
-    # Initialize robot
-    config = UnitreeG1Config()
-    robot = UnitreeG1(config)
-    robot.connect()
-
-    holosoma_controller = HolosomaLocomotionController(policy, robot, kp, kd)
-
-    try:
-        robot.reset(CONTROL_DT, DEFAULT_ANGLES)
-
-        logger.info("Use joystick: LY=fwd/back, LX=left/right, RX=rotate")
-        logger.info("Press Ctrl+C to stop")
-
-        # Run step
-        while not robot._shutdown_event.is_set():
-            start_time = time.time()
-            holosoma_controller.run_step()
-            elapsed = time.time() - start_time
-            sleep_time = max(0, CONTROL_DT - elapsed)
-            time.sleep(sleep_time)
-    except KeyboardInterrupt:
-        logger.info("Stopping locomotion...")
-    finally:
-        if robot.is_connected:
-            robot.disconnect()
-        logger.info("Done!")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Holosoma Locomotion Controller for Unitree G1")
-    parser.add_argument(
-        "--repo-id",
-        type=str,
-        default=DEFAULT_HOLOSOMA_REPO_ID,
-        help=f"Hugging Face Hub repo ID for Holosoma policies (default: {DEFAULT_HOLOSOMA_REPO_ID})",
-    )
-    parser.add_argument(
-        "--policy",
-        type=str,
-        choices=["fastsac", "ppo"],
-        default="fastsac",
-        help="Policy type to use: 'fastsac' (default) or 'ppo'",
-    )
-    args = parser.parse_args()
-
-    run(repo_id=args.repo_id, policy_type=args.policy)
@@ -25,9 +25,9 @@ discord = "https://discord.gg/s3KuuzsPFb"

 [project]
 name = "lerobot"
-version = "0.4.4"
+version = "0.4.3"
 description = "🤗 LeRobot: State-of-the-art Machine Learning for Real-World Robotics in Pytorch"
-dynamic = ["readme"]
+readme = "README.md"
 license = { text = "Apache-2.0" }
 requires-python = ">=3.10"
 authors = [
@@ -74,11 +74,11 @@ dependencies = [
    "packaging>=24.2,<26.0",
    "pynput>=1.7.7,<1.9.0",
    "pyserial>=3.5,<4.0",
-    "wandb>=0.24.0,<0.25.0",
+    "wandb>=0.20.0,<0.22.0", # TODO: Bumb dependency (compatible with protobuf)

-    "torch>=2.2.1,<2.11.0", # TODO: Bump dependency
-    "torchcodec>=0.2.1,<0.11.0; sys_platform != 'win32' and (sys_platform != 'linux' or (platform_machine != 'aarch64' and platform_machine != 'arm64' and platform_machine != 'armv7l')) and (sys_platform != 'darwin' or platform_machine != 'x86_64')", # TODO: Bump dependency
-    "torchvision>=0.21.0,<0.26.0", # TODO: Bump dependency
+    "torch>=2.2.1,<2.8.0", # TODO: Bumb dependency
+    "torchcodec>=0.2.1,<0.6.0; sys_platform != 'win32' and (sys_platform != 'linux' or (platform_machine != 'aarch64' and platform_machine != 'arm64' and platform_machine != 'armv7l')) and (sys_platform != 'darwin' or platform_machine != 'x86_64')", # TODO: Bumb dependency
+    "torchvision>=0.21.0,<0.23.0", # TODO: Bumb dependency

    "draccus==0.10.0", # TODO: Remove ==
    "gymnasium>=1.1.1,<2.0.0",
@@ -97,27 +97,21 @@ dependencies = [
 pygame-dep = ["pygame>=2.5.1,<2.7.0"]
 placo-dep = ["placo>=0.9.6,<0.10.0"]
 transformers-dep = ["transformers>=4.57.1,<5.0.0"]
-grpcio-dep = ["grpcio==1.73.1", "protobuf>=6.31.1,<6.32.0"]
+grpcio-dep = ["grpcio==1.73.1", "protobuf==6.31.0"] # TODO: Bumb dependency (compatible with wandb)

 # Motors
 feetech = ["feetech-servo-sdk>=1.0.0,<2.0.0"]
 dynamixel = ["dynamixel-sdk>=3.7.31,<3.9.0"]
-damiao = ["python-can>=4.2.0,<5.0.0"]

 # Robots
-openarms = ["lerobot[damiao]"]
 gamepad = ["lerobot[pygame-dep]", "hidapi>=0.14.0,<0.15.0"]
 hopejr = ["lerobot[feetech]", "lerobot[pygame-dep]"]
 lekiwi = ["lerobot[feetech]", "pyzmq>=26.2.1,<28.0.0"]
 unitree_g1 = [
    "pyzmq>=26.2.1,<28.0.0",
-    "onnxruntime>=1.16.0,<2.0.0",
-    "pin>=3.0.0,<4.0.0",
-    "meshcat>=0.3.0,<0.4.0",
-    "matplotlib>=3.9.0,<4.0.0",
-    "casadi>=3.6.0,<4.0.0",
+    "onnxruntime>=1.16.0"
 ]
-reachy2 = ["reachy2_sdk>=1.0.15,<1.1.0"]
+reachy2 = ["reachy2_sdk>=1.0.14,<1.1.0"]
 kinematics = ["lerobot[placo-dep]"]
 intelrealsense = [
    "pyrealsense2>=2.55.1.6486,<2.57.0 ; sys_platform != 'darwin'",
@@ -133,7 +127,7 @@ wallx = [
    "torchdiffeq==0.2.5",
    "qwen_vl_utils==0.0.11"
 ]
-pi = ["transformers @ git+https://github.com/huggingface/transformers.git@fix/lerobot_openpi", "scipy>=1.10.1,<1.15"]
+pi = ["transformers @ git+https://github.com/huggingface/transformers.git@fix/lerobot_openpi"]
 smolvla = ["lerobot[transformers-dep]", "num2words>=0.5.14,<0.6.0", "accelerate>=1.7.0,<2.0.0", "safetensors>=0.4.3,<1.0.0"]
 groot = [
    "lerobot[transformers-dep]",
@@ -146,13 +140,13 @@ groot = [
    "ninja>=1.11.1,<2.0.0",
    "flash-attn>=2.5.9,<3.0.0 ; sys_platform != 'darwin'"
 ]
-sarm = ["lerobot[transformers-dep]", "faker>=33.0.0,<35.0.0", "matplotlib>=3.10.3,<4.0.0", "qwen-vl-utils>=0.0.14,<0.1.0"]
+sarm = ["lerobot[transformers-dep]", "faker>=33.0.0,<35.0.0", "matplotlib>=3.10.3,<4.0.0", "qwen-vl-utils>=0.0.14"]
 xvla = ["lerobot[transformers-dep]"]
 hilserl = ["lerobot[transformers-dep]", "gym-hil>=0.1.13,<0.2.0", "lerobot[grpcio-dep]", "lerobot[placo-dep]"]

 # Features
 async = ["lerobot[grpcio-dep]", "matplotlib>=3.10.3,<4.0.0"]
-peft = ["lerobot[transformers-dep]", "peft>=0.18.0,<1.0.0"]
+peft = ["lerobot[transformers-dep]", "peft>=0.18.0"]

 # Development
 dev = ["pre-commit>=3.7.0,<5.0.0", "debugpy>=1.8.1,<1.9.0", "lerobot[grpcio-dep]", "grpcio-tools==1.73.1", "mypy>=1.19.1"]
@@ -175,7 +169,7 @@ all = [
    "lerobot[kinematics]",
    "lerobot[intelrealsense]",
    # "lerobot[wallx]",
-    # "lerobot[pi]", TODO(Pepijn): Update pi to transformers v5
+    "lerobot[pi]",
    "lerobot[smolvla]",
    # "lerobot[groot]", TODO(Steven): Gr00t requires specific installation instructions for flash-attn
    "lerobot[xvla]",
@@ -203,13 +197,11 @@ lerobot-setup-motors="lerobot.scripts.lerobot_setup_motors:main"
 lerobot-teleoperate="lerobot.scripts.lerobot_teleoperate:main"
 lerobot-eval="lerobot.scripts.lerobot_eval:main"
 lerobot-train="lerobot.scripts.lerobot_train:main"
-lerobot-train-tokenizer="lerobot.scripts.lerobot_train_tokenizer:main"
 lerobot-dataset-viz="lerobot.scripts.lerobot_dataset_viz:main"
 lerobot-info="lerobot.scripts.lerobot_info:main"
 lerobot-find-joint-limits="lerobot.scripts.lerobot_find_joint_limits:main"
 lerobot-imgtransform-viz="lerobot.scripts.lerobot_imgtransform_viz:main"
 lerobot-edit-dataset="lerobot.scripts.lerobot_edit_dataset:main"
-lerobot-setup-can="lerobot.scripts.lerobot_setup_can:main"

 # ---------------- Tool Configurations ----------------
 [tool.setuptools.packages.find]
@@ -285,7 +277,6 @@ default.extend-ignore-identifiers-re = [
    "thw",
    "inpt",
    "ROBOTIS",
-    "OT_VALUE"
 ]

 # TODO: Uncomment when ready to use
@@ -360,9 +351,9 @@ ignore_errors = false
 module = "lerobot.cameras.*"
 ignore_errors = false

-[[tool.mypy.overrides]]
-module = "lerobot.motors.*"
-ignore_errors = false
+# [[tool.mypy.overrides]]
+# module = "lerobot.motors.*"
+# ignore_errors = false

 # [[tool.mypy.overrides]]
 # module = "lerobot.robots.*"
@@ -416,10 +407,6 @@ conflicts = [
        { extra = "wallx" },
        { extra = "xvla" },
    ],
-    [
-        { extra = "wallx" },
-        { extra = "sarm" },
-    ],
    [
        { extra = "wallx" },
        { extra = "hilserl" },
@@ -430,47 +417,6 @@ conflicts = [
    ],
    [
        { extra = "wallx" },
-        { extra = "peft" },
-    ],
-    [
-        { extra = "wallx" },
-        { extra = "all" },
-    ],
-    # pi uses custom branch which conflicts with transformers-dep
-    [
-        { extra = "pi" },
-        { extra = "transformers-dep" },
-    ],
-    [
-        { extra = "pi" },
-        { extra = "smolvla" },
-    ],
-    [
-        { extra = "pi" },
-        { extra = "groot" },
-    ],
-    [
-        { extra = "pi" },
-        { extra = "xvla" },
-    ],
-    [
-        { extra = "pi" },
-        { extra = "sarm" },
-    ],
-    [
-        { extra = "pi" },
-        { extra = "hilserl" },
-    ],
-    [
-        { extra = "pi" },
-        { extra = "libero" },
-    ],
-    [
-        { extra = "pi" },
-        { extra = "peft" },
-    ],
-    [
-        { extra = "pi" },
        { extra = "all" },
    ],
 ]
@@ -1,72 +0,0 @@
-# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-from setuptools import setup
-
-
-def get_version_from_toml() -> str:
-    """Return the project's version string parsed from `pyproject.toml`.
-
-    The function scans `pyproject.toml` line-by-line looking for a line
-    that starts with ``version`` (for example: ``version = "1.2.3"``)
-    and returns the value without surrounding quotes. If no such line is
-    found a :class:`ValueError` is raised.
-
-    Returns:
-        The version string from `pyproject.toml` (e.g. ``"1.2.3"`` ->
-        ``1.2.3``).
-    """
-
-    version = None
-    with open("pyproject.toml", encoding="utf-8") as f:
-        for line in f:
-            if line.strip().startswith("version"):
-                version = line.split("=")[1].strip().strip('"')
-                break
-    if version is None:
-        raise ValueError("Version not found in pyproject.toml")
-    return version
-
-
-def read_long_description() -> str:
-    """Read and return the project's long description for setup.
-
-    This function reads `README.md` and replaces image links that point
-    to the local `./media/` directory with absolute raw GitHub URLs that
-    reference the release tag corresponding to the version parsed from
-    `pyproject.toml` (for example, ``v1.2.3``). The modified README
-    content is returned as a string suitable for passing to
-    ``setuptools.setup(long_description=...)``.
-
-    Returns:
-        The README content with rewritten media links.
-    """
-
-    with open("README.md", encoding="utf-8") as f:
-        content = f.read()
-
-    version = get_version_from_toml()
-    git_tag = f"v{version}"
-
-    base_raw_url = f"https://raw.githubusercontent.com/huggingface/lerobot/{git_tag}/"
-    content = content.replace('src="./media/', f'src="{base_raw_url}media/')
-
-    return content
-
-
-setup(
-    long_description=read_long_description(),
-    long_description_content_type="text/markdown",
-)
@@ -126,12 +126,6 @@ class RobotClientConfig:

    # Device configuration
    policy_device: str = field(default="cpu", metadata={"help": "Device for policy inference"})
-    client_device: str = field(
-        default="cpu",
-        metadata={
-            "help": "Device to move actions to after receiving from server (e.g., for downstream planners)"
-        },
-    )

    # Control behavior configuration
    chunk_size_threshold: float = field(default=0.5, metadata={"help": "Threshold for chunk size control"})
@@ -167,9 +161,6 @@ class RobotClientConfig:
        if not self.policy_device:
            raise ValueError("policy_device cannot be empty")

-        if not self.client_device:
-            raise ValueError("client_device cannot be empty")
-
        if self.chunk_size_threshold < 0 or self.chunk_size_threshold > 1:
            raise ValueError(f"chunk_size_threshold must be between 0 and 1, got {self.chunk_size_threshold}")

@@ -193,7 +184,6 @@ class RobotClientConfig:
            "policy_type": self.policy_type,
            "pretrained_name_or_path": self.pretrained_name_or_path,
            "policy_device": self.policy_device,
-            "client_device": self.client_device,
            "chunk_size_threshold": self.chunk_size_threshold,
            "fps": self.fps,
            "actions_per_chunk": self.actions_per_chunk,
@@ -23,7 +23,7 @@ DEFAULT_INFERENCE_LATENCY = 1 / DEFAULT_FPS
 DEFAULT_OBS_QUEUE_TIMEOUT = 2

 # All action chunking policies
-SUPPORTED_POLICIES = ["act", "smolvla", "diffusion", "tdmpc", "vqbet", "pi0", "pi05", "groot"]
+SUPPORTED_POLICIES = ["act", "smolvla", "diffusion", "tdmpc", "vqbet", "pi0", "pi05"]

 # TODO: Add all other robots
-SUPPORTED_ROBOTS = ["so100_follower", "so101_follower", "bi_so_follower", "omx_follower"]
+SUPPORTED_ROBOTS = ["so100_follower", "so101_follower", "bi_so100_follower", "omx_follower"]
@@ -18,7 +18,6 @@ import os
 import time
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any

 import torch

@@ -40,8 +39,8 @@ from lerobot.utils.utils import init_logging

 Action = torch.Tensor

-# observation as received from the robot (can be numpy arrays, floats, etc.)
-RawObservation = dict[str, Any]
+# observation as received from the robot
+RawObservation = dict[str, torch.Tensor]

 # observation as those recorded in LeRobot dataset (keys are different)
 LeRobotObservation = dict[str, torch.Tensor]
@@ -381,8 +381,6 @@ class PolicyServer(services_pb2_grpc.AsyncInferenceServicer):
        action_tensor = torch.stack(processed_actions, dim=1).squeeze(0)
        self.logger.debug(f"Postprocessed action shape: {action_tensor.shape}")

-        action_tensor = action_tensor.detach().cpu()
-
        """5. Convert to TimedAction list"""
        action_chunk = self._time_action_chunk(
            observation_t.get_timestamp(), list(action_tensor), observation_t.get_timestep()
@@ -25,7 +25,6 @@ python src/lerobot/async_inference/robot_client.py \
    --policy_type=act \
    --pretrained_name_or_path=user/model \
    --policy_device=mps \
-    --client_device=cpu \
    --actions_per_chunk=50 \
    --chunk_size_threshold=0.5 \
    --aggregate_fn_name=weighted_average \
@@ -52,11 +51,12 @@ from lerobot.cameras.realsense.configuration_realsense import RealSenseCameraCon
 from lerobot.robots import (  # noqa: F401
    Robot,
    RobotConfig,
-    bi_so_follower,
+    bi_so100_follower,
    koch_follower,
    make_robot_from_config,
    omx_follower,
-    so_follower,
+    so100_follower,
+    so101_follower,
 )
 from lerobot.transport import (
    services_pb2,  # type: ignore
@@ -286,21 +286,6 @@ class RobotClient:
                timed_actions = pickle.loads(actions_chunk.data)  # nosec
                deserialize_time = time.perf_counter() - deserialize_start

-                # Log device type of received actions
-                if len(timed_actions) > 0:
-                    received_device = timed_actions[0].get_action().device.type
-                    self.logger.debug(f"Received actions on device: {received_device}")
-
-                # Move actions to client_device (e.g., for downstream planners that need GPU)
-                client_device = self.config.client_device
-                if client_device != "cpu":
-                    for timed_action in timed_actions:
-                        if timed_action.get_action().device.type != client_device:
-                            timed_action.action = timed_action.get_action().to(client_device)
-                    self.logger.debug(f"Converted actions to device: {client_device}")
-                else:
-                    self.logger.debug(f"Actions kept on device: {client_device}")
-
                self.action_chunk_size = max(self.action_chunk_size, len(timed_actions))

                # Calculate network latency if we have matching observations
@@ -13,5 +13,5 @@
 # limitations under the License.

 from .camera import Camera
-from .configs import CameraConfig, ColorMode, Cv2Backends, Cv2Rotation
+from .configs import CameraConfig, ColorMode, Cv2Rotation
 from .utils import make_cameras_from_configs
@@ -15,12 +15,11 @@
 # limitations under the License.

 import abc
-import warnings
 from typing import Any

 from numpy.typing import NDArray  # type: ignore  # TODO: add type stubs for numpy.typing

-from .configs import CameraConfig
+from .configs import CameraConfig, ColorMode


 class Camera(abc.ABC):
@@ -31,12 +30,20 @@ class Camera(abc.ABC):

    Manages basic camera properties (FPS, resolution) and core operations:
    - Connection/disconnection
-    - Frame capture (sync/async/latest)
+    - Frame capture (sync/async)

    Attributes:
        fps (int | None): Configured frames per second
        width (int | None): Frame width in pixels
        height (int | None): Frame height in pixels
+
+    Example:
+        class MyCamera(Camera):
+            def __init__(self, config): ...
+            @property
+            def is_connected(self) -> bool: ...
+            def connect(self, warmup=True): ...
+            # Plus other required methods
    """

    def __init__(self, config: CameraConfig):
@@ -49,32 +56,6 @@ class Camera(abc.ABC):
        self.width: int | None = config.width
        self.height: int | None = config.height

-    def __enter__(self):
-        """
-        Context manager entry.
-        Automatically connects to the camera.
-        """
-        self.connect()
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback) -> None:
-        """
-        Context manager exit.
-        Automatically disconnects, ensuring resources are released even on error.
-        """
-        self.disconnect()
-
-    def __del__(self) -> None:
-        """
-        Destructor safety net.
-        Attempts to disconnect if the object is garbage collected without cleanup.
-        """
-        try:
-            if self.is_connected:
-                self.disconnect()
-        except Exception:  # nosec B110
-            pass
-
    @property
    @abc.abstractmethod
    def is_connected(self) -> bool:
@@ -108,10 +89,12 @@ class Camera(abc.ABC):
        pass

    @abc.abstractmethod
-    def read(self) -> NDArray[Any]:
-        """Capture and return a single frame from the camera synchronously.
+    def read(self, color_mode: ColorMode | None = None) -> NDArray[Any]:
+        """Capture and return a single frame from the camera.

-        This is a blocking call that will wait for the hardware and its SDK.
+        Args:
+            color_mode: Desired color mode for the output frame. If None,
+                        uses the camera's default color mode.

        Returns:
            np.ndarray: Captured frame as a numpy array.
@@ -120,64 +103,17 @@ class Camera(abc.ABC):

    @abc.abstractmethod
    def async_read(self, timeout_ms: float = ...) -> NDArray[Any]:
-        """Return the most recent new frame.
-
-        This method retrieves the latest frame captured by the background thread.
-        If a new frame is already available in the buffer (captured since the last call),
-        it returns it immediately.
-
-        It blocks up to `timeout_ms` only if the buffer is empty or if the latest frame
-        was already consumed by a previous `async_read` call.
-
-        Essentially, this method return the latest unconsumed frame, waiting if necessary
-        for a new one to arrive within the specified timeout.
-
-        Usage:
-            - Ideal for control loops where you want to ensure every processed frame
-            is fresh, effectively synchronizing your loop to the camera's FPS.
-            - Causes of a timeout usually include: very low camera FPS, heavy processing load,
-            or if the camera is disconnected.
+        """Asynchronously capture and return a single frame from the camera.

        Args:
-            timeout_ms: Maximum time to wait for a new frame in milliseconds.
-                        Defaults to 200ms (0.2s).
+            timeout_ms: Maximum time to wait for a frame in milliseconds.
+                        Defaults to implementation-specific timeout.

        Returns:
            np.ndarray: Captured frame as a numpy array.
-
-        Raises:
-            TimeoutError: If no new frame arrives within `timeout_ms`.
        """
        pass

-    def read_latest(self, max_age_ms: int = 500) -> NDArray[Any]:
-        """Return the most recent frame captured immediately (Peeking).
-
-        This method is non-blocking and returns whatever is currently in the
-        memory buffer. The frame may be stale,
-        meaning it could have been captured a while ago (hanging camera scenario e.g.).
-
-        Usage:
-            Ideal for scenarios requiring zero latency or decoupled frequencies & when
-            we want a guaranteed frame, such as UI visualization, logging, or
-            non-critical monitoring.
-
-        Returns:
-            NDArray[Any]: The frame image (numpy array).
-
-        Raises:
-            TimeoutError: If the latest frame is older than `max_age_ms`.
-            NotConnectedError: If the camera is not connected.
-            RuntimeError: If the camera is connected but has not captured any frames yet.
-        """
-        warnings.warn(
-            f"{self.__class__.__name__}.read_latest() is not implemented. "
-            "Please override read_latest(); it will be required in future releases.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self.async_read()
-
    @abc.abstractmethod
    def disconnect(self) -> None:
        """Disconnect from the camera and release resources."""
@@ -25,10 +25,6 @@ class ColorMode(str, Enum):
    RGB = "rgb"
    BGR = "bgr"

-    @classmethod
-    def _missing_(cls, value: object) -> None:
-        raise ValueError(f"`color_mode` is expected to be in {list(cls)}, but {value} is provided.")
-

 class Cv2Rotation(int, Enum):
    NO_ROTATION = 0
@@ -36,25 +32,6 @@ class Cv2Rotation(int, Enum):
    ROTATE_180 = 180
    ROTATE_270 = -90

-    @classmethod
-    def _missing_(cls, value: object) -> None:
-        raise ValueError(f"`rotation` is expected to be in {list(cls)}, but {value} is provided.")
-
-
-# Subset from https://docs.opencv.org/3.4/d4/d15/group__videoio__flags__base.html
-class Cv2Backends(int, Enum):
-    ANY = 0
-    V4L2 = 200
-    DSHOW = 700
-    PVAPI = 800
-    ANDROID = 1000
-    AVFOUNDATION = 1200
-    MSMF = 1400
-
-    @classmethod
-    def _missing_(cls, value: object) -> None:
-        raise ValueError(f"`backend` is expected to be in {list(cls)}, but {value} is provided.")
-

@dataclass(kw_only=True)
 class CameraConfig(draccus.ChoiceRegistry, abc.ABC):  # type: ignore  # TODO: add type stubs for draccus
@@ -32,11 +32,10 @@ if platform.system() == "Windows" and "OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS"
    os.environ["OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS"] = "0"
 import cv2  # type: ignore  # TODO: add type stubs for OpenCV

-from lerobot.utils.decorators import check_if_already_connected, check_if_not_connected
-from lerobot.utils.errors import DeviceNotConnectedError
+from lerobot.utils.errors import DeviceAlreadyConnectedError, DeviceNotConnectedError

 from ..camera import Camera
-from ..utils import get_cv2_rotation
+from ..utils import get_cv2_backend, get_cv2_rotation
 from .configuration_opencv import ColorMode, OpenCVCameraConfig

 # NOTE(Steven): The maximum opencv device index depends on your operating system. For instance,
@@ -71,24 +70,34 @@ class OpenCVCamera(Camera):
    Example:
        ```python
        from lerobot.cameras.opencv import OpenCVCamera
-        from lerobot.cameras.configuration_opencv import OpenCVCameraConfig
+        from lerobot.cameras.configuration_opencv import OpenCVCameraConfig, ColorMode, Cv2Rotation

        # Basic usage with camera index 0
        config = OpenCVCameraConfig(index_or_path=0)
        camera = OpenCVCamera(config)
        camera.connect()

-        # Read 1 frame synchronously (blocking)
+        # Read 1 frame synchronously
        color_image = camera.read()
+        print(color_image.shape)

-        # Read 1 frame asynchronously (waits for new frame with a timeout)
+        # Read 1 frame asynchronously
        async_image = camera.async_read()

-        # Get the latest frame immediately (no wait, returns timestamp)
-        latest_image, timestamp = camera.read_latest()
-
        # When done, properly disconnect the camera using
        camera.disconnect()
+
+        # Example with custom settings
+        custom_config = OpenCVCameraConfig(
+            index_or_path='/dev/video0', # Or use an index
+            fps=30,
+            width=1280,
+            height=720,
+            color_mode=ColorMode.RGB,
+            rotation=Cv2Rotation.ROTATE_90
+        )
+        custom_camera = OpenCVCamera(custom_config)
+        # ... connect, read, disconnect ...
        ```
    """

@@ -114,11 +123,10 @@ class OpenCVCamera(Camera):
        self.stop_event: Event | None = None
        self.frame_lock: Lock = Lock()
        self.latest_frame: NDArray[Any] | None = None
-        self.latest_timestamp: float | None = None
        self.new_frame_event: Event = Event()

        self.rotation: int | None = get_cv2_rotation(config.rotation)
-        self.backend: int = config.backend
+        self.backend: int = get_cv2_backend()

        if self.height and self.width:
            self.capture_width, self.capture_height = self.width, self.height
@@ -133,23 +141,20 @@ class OpenCVCamera(Camera):
        """Checks if the camera is currently connected and opened."""
        return isinstance(self.videocapture, cv2.VideoCapture) and self.videocapture.isOpened()

-    @check_if_already_connected
    def connect(self, warmup: bool = True) -> None:
        """
        Connects to the OpenCV camera specified in the configuration.

        Initializes the OpenCV VideoCapture object, sets desired camera properties
-        (FPS, width, height), starts the background reading thread and performs initial checks.
-
-        Args:
-            warmup (bool): If True, waits at connect() time until at least one valid frame
-                           has been captured by the background thread. Defaults to True.
+        (FPS, width, height), and performs initial checks.

        Raises:
            DeviceAlreadyConnectedError: If the camera is already connected.
-            ConnectionError: If the specified camera index/path is not found or fails to open.
-            RuntimeError: If the camera opens but fails to apply requested settings.
+            ConnectionError: If the specified camera index/path is not found or the camera is found but fails to open.
+            RuntimeError: If the camera opens but fails to apply requested FPS/resolution settings.
        """
+        if self.is_connected:
+            raise DeviceAlreadyConnectedError(f"{self} is already connected.")

        # Use 1 thread for OpenCV operations to avoid potential conflicts or
        # blocking in multi-threaded applications, especially during data collection.
@@ -165,20 +170,15 @@ class OpenCVCamera(Camera):
            )

        self._configure_capture_settings()
-        self._start_read_thread()

-        if warmup and self.warmup_s > 0:
+        if warmup:
            start_time = time.time()
            while time.time() - start_time < self.warmup_s:
-                self.async_read(timeout_ms=self.warmup_s * 1000)
+                self.read()
                time.sleep(0.1)
-            with self.frame_lock:
-                if self.latest_frame is None:
-                    raise ConnectionError(f"{self} failed to capture frames during warmup.")

        logger.info(f"{self} connected.")

-    @check_if_not_connected
    def _configure_capture_settings(self) -> None:
        """
        Applies the specified FOURCC, FPS, width, and height settings to the connected camera.
@@ -196,8 +196,11 @@ class OpenCVCamera(Camera):
        Raises:
            RuntimeError: If the camera fails to set any of the specified properties
                          to the requested value.
-            DeviceNotConnectedError: If the camera is not connected.
+            DeviceNotConnectedError: If the camera is not connected when attempting
+                                     to configure settings.
        """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"Cannot configure settings for {self} as it is not connected.")

        # Set FOURCC first (if specified) as it can affect available FPS/resolution options
        if self.config.fourcc is not None:
@@ -336,18 +339,6 @@ class OpenCVCamera(Camera):

        return found_cameras_info

-    def _read_from_hardware(self) -> NDArray[Any]:
-        if self.videocapture is None:
-            raise DeviceNotConnectedError(f"{self} videocapture is not initialized")
-
-        ret, frame = self.videocapture.read()
-
-        if not ret:
-            raise RuntimeError(f"{self} read failed (status={ret}).")
-
-        return frame
-
-    @check_if_not_connected
    def read(self, color_mode: ColorMode | None = None) -> NDArray[Any]:
        """
        Reads a single frame synchronously from the camera.
@@ -355,6 +346,11 @@ class OpenCVCamera(Camera):
        This is a blocking call. It waits for the next available frame from the
        camera hardware via OpenCV.

+        Args:
+            color_mode (Optional[ColorMode]): If specified, overrides the default
+                color mode (`self.color_mode`) for this read operation (e.g.,
+                request RGB even if default is BGR).
+
        Returns:
            np.ndarray: The captured frame as a NumPy array in the format
                       (height, width, channels), using the specified or default
@@ -366,31 +362,34 @@ class OpenCVCamera(Camera):
                          received frame dimensions don't match expectations before rotation.
            ValueError: If an invalid `color_mode` is requested.
        """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")

        start_time = time.perf_counter()

-        if color_mode is not None:
-            logger.warning(
-                f"{self} read() color_mode parameter is deprecated and will be removed in future versions."
-            )
+        if self.videocapture is None:
+            raise DeviceNotConnectedError(f"{self} videocapture is not initialized")

-        if self.thread is None or not self.thread.is_alive():
-            raise RuntimeError(f"{self} read thread is not running.")
+        ret, frame = self.videocapture.read()

-        self.new_frame_event.clear()
-        frame = self.async_read(timeout_ms=10000)
+        if not ret or frame is None:
+            raise RuntimeError(f"{self} read failed (status={ret}).")
+
+        processed_frame = self._postprocess_image(frame, color_mode)

        read_duration_ms = (time.perf_counter() - start_time) * 1e3
        logger.debug(f"{self} read took: {read_duration_ms:.1f}ms")

-        return frame
+        return processed_frame

-    def _postprocess_image(self, image: NDArray[Any]) -> NDArray[Any]:
+    def _postprocess_image(self, image: NDArray[Any], color_mode: ColorMode | None = None) -> NDArray[Any]:
        """
        Applies color conversion, dimension validation, and rotation to a raw frame.

        Args:
            image (np.ndarray): The raw image frame (expected BGR format from OpenCV).
+            color_mode (Optional[ColorMode]): The target color mode (RGB or BGR). If None,
+                                             uses the instance's default `self.color_mode`.

        Returns:
            np.ndarray: The processed image frame.
@@ -400,10 +399,11 @@ class OpenCVCamera(Camera):
            RuntimeError: If the raw frame dimensions do not match the configured
                          `width` and `height`.
        """
+        requested_color_mode = self.color_mode if color_mode is None else color_mode

-        if self.color_mode not in (ColorMode.RGB, ColorMode.BGR):
+        if requested_color_mode not in (ColorMode.RGB, ColorMode.BGR):
            raise ValueError(
-                f"Invalid color mode '{self.color_mode}'. Expected {ColorMode.RGB} or {ColorMode.BGR}."
+                f"Invalid color mode '{requested_color_mode}'. Expected {ColorMode.RGB} or {ColorMode.BGR}."
            )

        h, w, c = image.shape
@@ -417,7 +417,7 @@ class OpenCVCamera(Camera):
            raise RuntimeError(f"{self} frame channels={c} do not match expected 3 channels (RGB/BGR).")

        processed_image = image
-        if self.color_mode == ColorMode.RGB:
+        if requested_color_mode == ColorMode.RGB:
            processed_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

        if self.rotation in [cv2.ROTATE_90_CLOCKWISE, cv2.ROTATE_90_COUNTERCLOCKWISE, cv2.ROTATE_180]:
@@ -431,7 +431,7 @@ class OpenCVCamera(Camera):

        On each iteration:
        1. Reads a color frame
-        2. Stores result in latest_frame and updates timestamp (thread-safe)
+        2. Stores result in latest_frame (thread-safe)
        3. Sets new_frame_event to notify listeners

        Stops on DeviceNotConnectedError, logs other errors and continues.
@@ -439,37 +439,30 @@ class OpenCVCamera(Camera):
        if self.stop_event is None:
            raise RuntimeError(f"{self}: stop_event is not initialized before starting read loop.")

-        failure_count = 0
        while not self.stop_event.is_set():
            try:
-                raw_frame = self._read_from_hardware()
-                processed_frame = self._postprocess_image(raw_frame)
-                capture_time = time.perf_counter()
+                color_image = self.read()

                with self.frame_lock:
-                    self.latest_frame = processed_frame
-                    self.latest_timestamp = capture_time
+                    self.latest_frame = color_image
                self.new_frame_event.set()
-                failure_count = 0

            except DeviceNotConnectedError:
                break
            except Exception as e:
-                if failure_count <= 10:
-                    failure_count += 1
-                    logger.warning(f"Error reading frame in background thread for {self}: {e}")
-                else:
-                    raise RuntimeError(f"{self} exceeded maximum consecutive read failures.") from e
+                logger.warning(f"Error reading frame in background thread for {self}: {e}")

    def _start_read_thread(self) -> None:
        """Starts or restarts the background read thread if it's not running."""
-        self._stop_read_thread()
+        if self.thread is not None and self.thread.is_alive():
+            self.thread.join(timeout=0.1)
+        if self.stop_event is not None:
+            self.stop_event.set()

        self.stop_event = Event()
        self.thread = Thread(target=self._read_loop, args=(), name=f"{self}_read_loop")
        self.thread.daemon = True
        self.thread.start()
-        time.sleep(0.1)

    def _stop_read_thread(self) -> None:
        """Signals the background read thread to stop and waits for it to join."""
@@ -482,12 +475,6 @@ class OpenCVCamera(Camera):
        self.thread = None
        self.stop_event = None

-        with self.frame_lock:
-            self.latest_frame = None
-            self.latest_timestamp = None
-            self.new_frame_event.clear()
-
-    @check_if_not_connected
    def async_read(self, timeout_ms: float = 200) -> NDArray[Any]:
        """
        Reads the latest available frame asynchronously.
@@ -495,7 +482,6 @@ class OpenCVCamera(Camera):
        This method retrieves the most recent frame captured by the background
        read thread. It does not block waiting for the camera hardware directly,
        but may wait up to timeout_ms for the background thread to provide a frame.
-        It is “best effort” under high FPS.

        Args:
            timeout_ms (float): Maximum time in milliseconds to wait for a frame
@@ -510,14 +496,17 @@ class OpenCVCamera(Camera):
            TimeoutError: If no frame becomes available within the specified timeout.
            RuntimeError: If an unexpected error occurs.
        """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")

        if self.thread is None or not self.thread.is_alive():
-            raise RuntimeError(f"{self} read thread is not running.")
+            self._start_read_thread()

        if not self.new_frame_event.wait(timeout=timeout_ms / 1000.0):
+            thread_alive = self.thread is not None and self.thread.is_alive()
            raise TimeoutError(
                f"Timed out waiting for frame from camera {self} after {timeout_ms} ms. "
-                f"Read thread alive: {self.thread.is_alive()}."
+                f"Read thread alive: {thread_alive}."
            )

        with self.frame_lock:
@@ -529,41 +518,6 @@ class OpenCVCamera(Camera):

        return frame

-    @check_if_not_connected
-    def read_latest(self, max_age_ms: int = 500) -> NDArray[Any]:
-        """Return the most recent frame captured immediately (Peeking).
-
-        This method is non-blocking and returns whatever is currently in the
-        memory buffer. The frame may be stale,
-        meaning it could have been captured a while ago (hanging camera scenario e.g.).
-
-        Returns:
-            NDArray[Any]: The frame image (numpy array).
-
-        Raises:
-            TimeoutError: If the latest frame is older than `max_age_ms`.
-            DeviceNotConnectedError: If the camera is not connected.
-            RuntimeError: If the camera is connected but has not captured any frames yet.
-        """
-
-        if self.thread is None or not self.thread.is_alive():
-            raise RuntimeError(f"{self} read thread is not running.")
-
-        with self.frame_lock:
-            frame = self.latest_frame
-            timestamp = self.latest_timestamp
-
-        if frame is None or timestamp is None:
-            raise RuntimeError(f"{self} has not captured any frames yet.")
-
-        age_ms = (time.perf_counter() - timestamp) * 1e3
-        if age_ms > max_age_ms:
-            raise TimeoutError(
-                f"{self} latest frame is too old: {age_ms:.1f} ms (max allowed: {max_age_ms} ms)."
-            )
-
-        return frame
-
    def disconnect(self) -> None:
        """
        Disconnects from the camera and cleans up resources.
@@ -584,9 +538,4 @@ class OpenCVCamera(Camera):
            self.videocapture.release()
            self.videocapture = None

-        with self.frame_lock:
-            self.latest_frame = None
-            self.latest_timestamp = None
-            self.new_frame_event.clear()
-
        logger.info(f"{self} disconnected.")
@@ -15,9 +15,9 @@
 from dataclasses import dataclass
 from pathlib import Path

-from ..configs import CameraConfig, ColorMode, Cv2Backends, Cv2Rotation
+from ..configs import CameraConfig, ColorMode, Cv2Rotation

-__all__ = ["OpenCVCameraConfig", "ColorMode", "Cv2Rotation", "Cv2Backends"]
+__all__ = ["OpenCVCameraConfig", "ColorMode", "Cv2Rotation"]


@CameraConfig.register_subclass("opencv")
@@ -50,7 +50,6 @@ class OpenCVCameraConfig(CameraConfig):
        rotation: Image rotation setting (0°, 90°, 180°, or 270°). Defaults to no rotation.
        warmup_s: Time reading frames before returning from connect (in seconds)
        fourcc: FOURCC code for video format (e.g., "MJPG", "YUYV", "I420"). Defaults to None (auto-detect).
-        backend: OpenCV backend identifier (https://docs.opencv.org/3.4/d4/d15/group__videoio__flags__base.html). Defaults to ANY.

    Note:
        - Only 3-channel color output (RGB/BGR) is currently supported.
@@ -63,12 +62,22 @@ class OpenCVCameraConfig(CameraConfig):
    rotation: Cv2Rotation = Cv2Rotation.NO_ROTATION
    warmup_s: int = 1
    fourcc: str | None = None
-    backend: Cv2Backends = Cv2Backends.ANY

    def __post_init__(self) -> None:
-        self.color_mode = ColorMode(self.color_mode)
-        self.rotation = Cv2Rotation(self.rotation)
-        self.backend = Cv2Backends(self.backend)
+        if self.color_mode not in (ColorMode.RGB, ColorMode.BGR):
+            raise ValueError(
+                f"`color_mode` is expected to be {ColorMode.RGB.value} or {ColorMode.BGR.value}, but {self.color_mode} is provided."
+            )
+
+        if self.rotation not in (
+            Cv2Rotation.NO_ROTATION,
+            Cv2Rotation.ROTATE_90,
+            Cv2Rotation.ROTATE_180,
+            Cv2Rotation.ROTATE_270,
+        ):
+            raise ValueError(
+                f"`rotation` is expected to be in {(Cv2Rotation.NO_ROTATION, Cv2Rotation.ROTATE_90, Cv2Rotation.ROTATE_180, Cv2Rotation.ROTATE_270)}, but {self.rotation} is provided."
+            )

        if self.fourcc is not None and (not isinstance(self.fourcc, str) or len(self.fourcc) != 4):
            raise ValueError(
@@ -35,19 +35,18 @@ class Reachy2CameraConfig(CameraConfig):
        name="teleop",
        image_type="left",
        ip_address="192.168.0.200",  # IP address of the robot
-        port=50065,  # Port of the camera server
+        fps=15,
        width=640,
        height=480,
-        fps=30,  # Not configurable for Reachy 2 cameras
        color_mode=ColorMode.RGB,
-    )  # Left teleop camera, 640x480 @ 30FPS
+    )  # Left teleop camera, 640x480 @ 15FPS
    ```

    Attributes:
        name: Name of the camera device. Can be "teleop" or "depth".
        image_type: Type of image stream. For "teleop" camera, can be "left" or "right".
                    For "depth" camera, can be "rgb" or "depth". (depth is not supported yet)
-        fps: Requested frames per second for the color stream. Not configurable for Reachy 2 cameras.
+        fps: Requested frames per second for the color stream.
        width: Requested frame width in pixels for the color stream.
        height: Requested frame height in pixels for the color stream.
        color_mode: Color mode for image output (RGB or BGR). Defaults to RGB.
@@ -63,6 +62,7 @@ class Reachy2CameraConfig(CameraConfig):
    color_mode: ColorMode = ColorMode.RGB
    ip_address: str | None = "localhost"
    port: int = 50065
+    # use_depth: bool = False

    def __post_init__(self) -> None:
        if self.name not in ["teleop", "depth"]:
@@ -74,4 +74,7 @@ class Reachy2CameraConfig(CameraConfig):
                f"`image_type` is expected to be 'left' or 'right' for teleop camera, and 'rgb' or 'depth' for depth camera, but {self.image_type} is provided."
            )

-        self.color_mode = ColorMode(self.color_mode)
+        if self.color_mode not in ["rgb", "bgr"]:
+            raise ValueError(
+                f"`color_mode` is expected to be 'rgb' or 'bgr', but {self.color_mode} is provided."
+            )
@@ -16,13 +16,12 @@
 Provides the Reachy2Camera class for capturing frames from Reachy 2 cameras using Reachy 2's CameraManager.
 """

-from __future__ import annotations
-
 import logging
 import os
 import platform
 import time
-from typing import TYPE_CHECKING, Any
+from threading import Event, Lock, Thread
+from typing import Any

 from numpy.typing import NDArray  # type: ignore  # TODO: add type stubs for numpy.typing

@@ -31,20 +30,10 @@ if platform.system() == "Windows" and "OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS"
    os.environ["OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS"] = "0"
 import cv2  # type: ignore  # TODO: add type stubs for OpenCV
 import numpy as np  # type: ignore  # TODO: add type stubs for numpy
-
-from lerobot.utils.decorators import check_if_not_connected
-from lerobot.utils.import_utils import _reachy2_sdk_available
-
-if TYPE_CHECKING or _reachy2_sdk_available:
-    from reachy2_sdk.media.camera import CameraView
-    from reachy2_sdk.media.camera_manager import CameraManager
-else:
-    CameraManager = None
-
-    class CameraView:
-        LEFT = 0
-        RIGHT = 1
-
+from reachy2_sdk.media.camera import CameraView  # type: ignore  # TODO: add type stubs for reachy2_sdk
+from reachy2_sdk.media.camera_manager import (  # type: ignore  # TODO: add type stubs for reachy2_sdk
+    CameraManager,
+)

 from lerobot.utils.errors import DeviceNotConnectedError

@@ -80,12 +69,17 @@ class Reachy2Camera(Camera):

        self.config = config

+        self.fps = config.fps
        self.color_mode = config.color_mode
-        self.latest_frame: NDArray[Any] | None = None
-        self.latest_timestamp: float | None = None

        self.cam_manager: CameraManager | None = None

+        self.thread: Thread | None = None
+        self.stop_event: Event | None = None
+        self.frame_lock: Lock = Lock()
+        self.latest_frame: NDArray[Any] | None = None
+        self.new_frame_event: Event = Event()
+
    def __str__(self) -> str:
        return f"{self.__class__.__name__}({self.config.name}, {self.config.image_type})"

@@ -106,87 +100,154 @@ class Reachy2Camera(Camera):
    def connect(self, warmup: bool = True) -> None:
        """
        Connects to the Reachy2 CameraManager as specified in the configuration.
-
-        Raises:
-            DeviceNotConnectedError: If the camera is not connected.
        """
        self.cam_manager = CameraManager(host=self.config.ip_address, port=self.config.port)
-        if self.cam_manager is None:
-            raise DeviceNotConnectedError(f"Could not connect to {self}.")
        self.cam_manager.initialize_cameras()

        logger.info(f"{self} connected.")

    @staticmethod
-    def find_cameras() -> list[dict[str, Any]]:
+    def find_cameras(ip_address: str = "localhost", port: int = 50065) -> list[dict[str, Any]]:
        """
-        Detection not implemented for Reachy2 cameras.
-        """
-        raise NotImplementedError("Camera detection is not implemented for Reachy2 cameras.")
+        Detects available Reachy 2 cameras.
+
+        Returns:
+            List[Dict[str, Any]]: A list of dictionaries,
+            where each dictionary contains 'name', 'stereo',
+            and the default profile properties (width, height, fps).
+        """
+        initialized_cameras = []
+        camera_manager = CameraManager(host=ip_address, port=port)
+
+        for camera in [camera_manager.teleop, camera_manager.depth]:
+            if camera is None:
+                continue
+
+            height, width, _, _, _, _, _ = camera.get_parameters()
+
+            camera_info = {
+                "name": camera._cam_info.name,
+                "stereo": camera._cam_info.stereo,
+                "default_profile": {
+                    "width": width,
+                    "height": height,
+                    "fps": 30,
+                },
+            }
+            initialized_cameras.append(camera_info)
+
+        camera_manager.disconnect()
+        return initialized_cameras

-    @check_if_not_connected
    def read(self, color_mode: ColorMode | None = None) -> NDArray[Any]:
        """
        Reads a single frame synchronously from the camera.

-        This method retrieves the most recent frame available in Reachy 2's low-level software.
+        This is a blocking call.
+
+        Args:
+            color_mode (Optional[ColorMode]): If specified, overrides the default
+                color mode (`self.color_mode`) for this read operation (e.g.,
+                request RGB even if default is BGR).

        Returns:
            np.ndarray: The captured frame as a NumPy array in the format
                       (height, width, channels), using the specified or default
                       color mode and applying any configured rotation.
        """
-        start_time = time.perf_counter()
-
-        if self.cam_manager is None:
+        if not self.is_connected:
            raise DeviceNotConnectedError(f"{self} is not connected.")

-        if color_mode is not None:
-            logger.warning(
-                f"{self} read() color_mode parameter is deprecated and will be removed in future versions."
-            )
+        start_time = time.perf_counter()

        frame: NDArray[Any] = np.empty((0, 0, 3), dtype=np.uint8)

-        if self.config.name == "teleop" and hasattr(self.cam_manager, "teleop"):
-            if self.config.image_type == "left":
-                frame = self.cam_manager.teleop.get_frame(
-                    CameraView.LEFT, size=(self.config.width, self.config.height)
-                )[0]
-            elif self.config.image_type == "right":
-                frame = self.cam_manager.teleop.get_frame(
-                    CameraView.RIGHT, size=(self.config.width, self.config.height)
-                )[0]
-        elif self.config.name == "depth" and hasattr(self.cam_manager, "depth"):
-            if self.config.image_type == "depth":
-                frame = self.cam_manager.depth.get_depth_frame()[0]
-            elif self.config.image_type == "rgb":
-                frame = self.cam_manager.depth.get_frame(size=(self.config.width, self.config.height))[0]
+        if self.cam_manager is None:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
        else:
-            raise ValueError(f"Invalid camera name '{self.config.name}'. Expected 'teleop' or 'depth'.")
+            if self.config.name == "teleop" and hasattr(self.cam_manager, "teleop"):
+                if self.config.image_type == "left":
+                    frame = self.cam_manager.teleop.get_frame(CameraView.LEFT, size=(640, 480))[0]
+                elif self.config.image_type == "right":
+                    frame = self.cam_manager.teleop.get_frame(CameraView.RIGHT, size=(640, 480))[0]
+            elif self.config.name == "depth" and hasattr(self.cam_manager, "depth"):
+                if self.config.image_type == "depth":
+                    frame = self.cam_manager.depth.get_depth_frame()[0]
+                elif self.config.image_type == "rgb":
+                    frame = self.cam_manager.depth.get_frame(size=(640, 480))[0]

-        if frame is None:
-            raise RuntimeError(f"Internal error: No frame available for {self}.")
+            if frame is None:
+                return np.empty((0, 0, 3), dtype=np.uint8)

-        if self.color_mode not in (ColorMode.RGB, ColorMode.BGR):
-            raise ValueError(
-                f"Invalid color mode '{self.color_mode}'. Expected {ColorMode.RGB} or {ColorMode.BGR}."
-            )
-        if self.color_mode == ColorMode.RGB:
-            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-
-        self.latest_frame = frame
-        self.latest_timestamp = time.perf_counter()
+            if self.config.color_mode == "rgb":
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

        read_duration_ms = (time.perf_counter() - start_time) * 1e3
        logger.debug(f"{self} read took: {read_duration_ms:.1f}ms")

        return frame

-    @check_if_not_connected
+    def _read_loop(self) -> None:
+        """
+        Internal loop run by the background thread for asynchronous reading.
+
+        On each iteration:
+        1. Reads a color frame
+        2. Stores result in latest_frame (thread-safe)
+        3. Sets new_frame_event to notify listeners
+
+        Stops on DeviceNotConnectedError, logs other errors and continues.
+        """
+        if self.stop_event is None:
+            raise RuntimeError(f"{self}: stop_event is not initialized before starting read loop.")
+
+        while not self.stop_event.is_set():
+            try:
+                color_image = self.read()
+
+                with self.frame_lock:
+                    self.latest_frame = color_image
+                self.new_frame_event.set()
+
+            except DeviceNotConnectedError:
+                break
+            except Exception as e:
+                logger.warning(f"Error reading frame in background thread for {self}: {e}")
+
+    def _start_read_thread(self) -> None:
+        """Starts or restarts the background read thread if it's not running."""
+        if self.thread is not None and self.thread.is_alive():
+            self.thread.join(timeout=0.1)
+        if self.stop_event is not None:
+            self.stop_event.set()
+
+        self.stop_event = Event()
+        self.thread = Thread(target=self._read_loop, args=(), name=f"{self}_read_loop")
+        self.thread.daemon = True
+        self.thread.start()
+
+    def _stop_read_thread(self) -> None:
+        """Signals the background read thread to stop and waits for it to join."""
+        if self.stop_event is not None:
+            self.stop_event.set()
+
+        if self.thread is not None and self.thread.is_alive():
+            self.thread.join(timeout=2.0)
+
+        self.thread = None
+        self.stop_event = None
+
    def async_read(self, timeout_ms: float = 200) -> NDArray[Any]:
        """
-        Same as read()
+        Reads the latest available frame asynchronously.
+
+        This method retrieves the most recent frame captured by the background
+        read thread. It does not block waiting for the camera hardware directly,
+        but may wait up to timeout_ms for the background thread to provide a frame.
+
+        Args:
+            timeout_ms (float): Maximum time in milliseconds to wait for a frame
+                to become available. Defaults to 200ms (0.2 seconds).

        Returns:
            np.ndarray: The latest captured frame as a NumPy array in the format
@@ -197,40 +258,28 @@ class Reachy2Camera(Camera):
            TimeoutError: If no frame becomes available within the specified timeout.
            RuntimeError: If an unexpected error occurs.
        """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")

-        return self.read()
+        if self.thread is None or not self.thread.is_alive():
+            self._start_read_thread()

-    @check_if_not_connected
-    def read_latest(self, max_age_ms: int = 500) -> NDArray[Any]:
-        """Return the most recent frame captured immediately (Peeking).
-
-        This method is non-blocking and returns whatever is currently in the
-        memory buffer. The frame may be stale,
-        meaning it could have been captured a while ago (hanging camera scenario e.g.).
-
-        Returns:
-            tuple[NDArray, float]:
-                - The frame image (numpy array).
-                - The timestamp (time.perf_counter) when this frame was captured.
-
-        Raises:
-            TimeoutError: If the latest frame is older than `max_age_ms`.
-            DeviceNotConnectedError: If the camera is not connected.
-            RuntimeError: If the camera is connected but has not captured any frames yet.
-        """
-
-        if self.latest_frame is None or self.latest_timestamp is None:
-            raise RuntimeError(f"{self} has not captured any frames yet.")
-
-        age_ms = (time.perf_counter() - self.latest_timestamp) * 1e3
-        if age_ms > max_age_ms:
+        if not self.new_frame_event.wait(timeout=timeout_ms / 1000.0):
+            thread_alive = self.thread is not None and self.thread.is_alive()
            raise TimeoutError(
-                f"{self} latest frame is too old: {age_ms:.1f} ms (max allowed: {max_age_ms} ms)."
+                f"Timed out waiting for frame from camera {self} after {timeout_ms} ms. "
+                f"Read thread alive: {thread_alive}."
            )

-        return self.latest_frame
+        with self.frame_lock:
+            frame = self.latest_frame
+            self.new_frame_event.clear()
+
+        if frame is None:
+            raise RuntimeError(f"Internal error: Event set but no frame available for {self}.")
+
+        return frame

-    @check_if_not_connected
    def disconnect(self) -> None:
        """
        Stops the background read thread (if running).
@@ -238,6 +287,11 @@ class Reachy2Camera(Camera):
        Raises:
            DeviceNotConnectedError: If the camera is already disconnected.
        """
+        if not self.is_connected and self.thread is None:
+            raise DeviceNotConnectedError(f"{self} not connected.")
+
+        if self.thread is not None:
+            self._stop_read_thread()

        if self.cam_manager is not None:
            self.cam_manager.disconnect()
@@ -30,8 +30,7 @@ try:
 except Exception as e:
    logging.info(f"Could not import realsense: {e}")

-from lerobot.utils.decorators import check_if_already_connected, check_if_not_connected
-from lerobot.utils.errors import DeviceNotConnectedError
+from lerobot.utils.errors import DeviceAlreadyConnectedError, DeviceNotConnectedError

 from ..camera import Camera
 from ..configs import ColorMode
@@ -73,14 +72,15 @@ class RealSenseCamera(Camera):
        camera = RealSenseCamera(config)
        camera.connect()

-        # Read 1 frame synchronously (blocking)
+        # Read 1 frame synchronously
        color_image = camera.read()
+        print(color_image.shape)

-        # Read 1 frame asynchronously (waits for new frame with a timeout)
+        # Read 1 frame asynchronously
        async_image = camera.async_read()

-        # Get the latest frame immediately (no wait, returns timestamp)
-        latest_image, timestamp = camera.read_latest()
+        # When done, properly disconnect the camera using
+        camera.disconnect()

        # Example with depth capture and custom settings
        custom_config = RealSenseCameraConfig(
@@ -133,9 +133,7 @@ class RealSenseCamera(Camera):
        self.thread: Thread | None = None
        self.stop_event: Event | None = None
        self.frame_lock: Lock = Lock()
-        self.latest_color_frame: NDArray[Any] | None = None
-        self.latest_depth_frame: NDArray[Any] | None = None
-        self.latest_timestamp: float | None = None
+        self.latest_frame: NDArray[Any] | None = None
        self.new_frame_event: Event = Event()

        self.rotation: int | None = get_cv2_rotation(config.rotation)
@@ -153,7 +151,6 @@ class RealSenseCamera(Camera):
        """Checks if the camera pipeline is started and streams are active."""
        return self.rs_pipeline is not None and self.rs_profile is not None

-    @check_if_already_connected
    def connect(self, warmup: bool = True) -> None:
        """
        Connects to the RealSense camera specified in the configuration.
@@ -161,16 +158,14 @@ class RealSenseCamera(Camera):
        Initializes the RealSense pipeline, configures the required streams (color
        and optionally depth), starts the pipeline, and validates the actual stream settings.

-        Args:
-            warmup (bool): If True, waits at connect() time until at least one valid frame
-                           has been captured by the background thread. Defaults to True.
-
        Raises:
            DeviceAlreadyConnectedError: If the camera is already connected.
            ValueError: If the configuration is invalid (e.g., missing serial/name, name not unique).
            ConnectionError: If the camera is found but fails to start the pipeline or no RealSense devices are detected at all.
            RuntimeError: If the pipeline starts but fails to apply requested settings.
        """
+        if self.is_connected:
+            raise DeviceAlreadyConnectedError(f"{self} is already connected.")

        self.rs_pipeline = rs.pipeline()
        rs_config = rs.config()
@@ -186,18 +181,15 @@ class RealSenseCamera(Camera):
            ) from e

        self._configure_capture_settings()
-        self._start_read_thread()

-        # NOTE(Steven/Caroline): Enforcing at least one second of warmup as RS cameras need a bit of time before the first read. If we don't wait, the first read from the warmup will raise.
-        self.warmup_s = max(self.warmup_s, 1)
-
-        start_time = time.time()
-        while time.time() - start_time < self.warmup_s:
-            self.async_read(timeout_ms=self.warmup_s * 1000)
-            time.sleep(0.1)
-        with self.frame_lock:
-            if self.latest_color_frame is None or self.use_depth and self.latest_depth_frame is None:
-                raise ConnectionError(f"{self} failed to capture frames during warmup.")
+        if warmup:
+            time.sleep(
+                1
+            )  # NOTE(Steven): RS cameras need a bit of time to warm up before the first read. If we don't wait, the first read from the warmup will raise.
+            start_time = time.time()
+            while time.time() - start_time < self.warmup_s:
+                self.read()
+                time.sleep(0.1)

        logger.info(f"{self} connected.")

@@ -290,7 +282,6 @@ class RealSenseCamera(Camera):
            if self.use_depth:
                rs_config.enable_stream(rs.stream.depth)

-    @check_if_not_connected
    def _configure_capture_settings(self) -> None:
        """Sets fps, width, and height from device stream if not already configured.

@@ -300,6 +291,8 @@ class RealSenseCamera(Camera):
        Raises:
            DeviceNotConnectedError: If device is not connected.
        """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"Cannot validate settings for {self} as it is not connected.")

        if self.rs_profile is None:
            raise RuntimeError(f"{self}: rs_profile must be initialized before use.")
@@ -319,7 +312,6 @@ class RealSenseCamera(Camera):
                self.width, self.height = actual_width, actual_height
                self.capture_width, self.capture_height = actual_width, actual_height

-    @check_if_not_connected
    def read_depth(self, timeout_ms: int = 200) -> NDArray[Any]:
        """
        Reads a single frame (depth) synchronously from the camera.
@@ -327,6 +319,9 @@ class RealSenseCamera(Camera):
        This is a blocking call. It waits for a coherent set of frames (depth)
        from the camera hardware via the RealSense pipeline.

+        Args:
+            timeout_ms (int): Maximum time in milliseconds to wait for a frame. Defaults to 200ms.
+
        Returns:
            np.ndarray: The depth map as a NumPy array (height, width)
                  of type `np.uint16` (raw depth values in millimeters) and rotation.
@@ -335,50 +330,44 @@ class RealSenseCamera(Camera):
            DeviceNotConnectedError: If the camera is not connected.
            RuntimeError: If reading frames from the pipeline fails or frames are invalid.
        """
-        if timeout_ms:
-            logger.warning(
-                f"{self} read() timeout_ms parameter is deprecated and will be removed in future versions."
-            )

+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
        if not self.use_depth:
            raise RuntimeError(
                f"Failed to capture depth frame '.read_depth()'. Depth stream is not enabled for {self}."
            )

-        if self.thread is None or not self.thread.is_alive():
-            raise RuntimeError(f"{self} read thread is not running.")
+        start_time = time.perf_counter()

-        self.new_frame_event.clear()
-
-        _ = self.async_read(timeout_ms=10000)
-
-        with self.frame_lock:
-            depth_map = self.latest_depth_frame
-
-        if depth_map is None:
-            raise RuntimeError("No depth frame available. Ensure camera is streaming.")
-
-        return depth_map
-
-    def _read_from_hardware(self):
        if self.rs_pipeline is None:
            raise RuntimeError(f"{self}: rs_pipeline must be initialized before use.")

-        ret, frame = self.rs_pipeline.try_wait_for_frames(timeout_ms=10000)
+        ret, frame = self.rs_pipeline.try_wait_for_frames(timeout_ms=timeout_ms)

        if not ret or frame is None:
-            raise RuntimeError(f"{self} read failed (status={ret}).")
+            raise RuntimeError(f"{self} read_depth failed (status={ret}).")

-        return frame
+        depth_frame = frame.get_depth_frame()
+        depth_map = np.asanyarray(depth_frame.get_data())

-    @check_if_not_connected
-    def read(self, color_mode: ColorMode | None = None, timeout_ms: int = 0) -> NDArray[Any]:
+        depth_map_processed = self._postprocess_image(depth_map, depth_frame=True)
+
+        read_duration_ms = (time.perf_counter() - start_time) * 1e3
+        logger.debug(f"{self} read took: {read_duration_ms:.1f}ms")
+
+        return depth_map_processed
+
+    def read(self, color_mode: ColorMode | None = None, timeout_ms: int = 200) -> NDArray[Any]:
        """
        Reads a single frame (color) synchronously from the camera.

        This is a blocking call. It waits for a coherent set of frames (color)
        from the camera hardware via the RealSense pipeline.

+        Args:
+            timeout_ms (int): Maximum time in milliseconds to wait for a frame. Defaults to 200ms.
+
        Returns:
            np.ndarray: The captured color frame as a NumPy array
              (height, width, channels), processed according to `color_mode` and rotation.
@@ -389,36 +378,39 @@ class RealSenseCamera(Camera):
            ValueError: If an invalid `color_mode` is requested.
        """

+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+
        start_time = time.perf_counter()

-        if color_mode is not None:
-            logger.warning(
-                f"{self} read() color_mode parameter is deprecated and will be removed in future versions."
-            )
+        if self.rs_pipeline is None:
+            raise RuntimeError(f"{self}: rs_pipeline must be initialized before use.")

-        if timeout_ms:
-            logger.warning(
-                f"{self} read() timeout_ms parameter is deprecated and will be removed in future versions."
-            )
+        ret, frame = self.rs_pipeline.try_wait_for_frames(timeout_ms=timeout_ms)

-        if self.thread is None or not self.thread.is_alive():
-            raise RuntimeError(f"{self} read thread is not running.")
+        if not ret or frame is None:
+            raise RuntimeError(f"{self} read failed (status={ret}).")

-        self.new_frame_event.clear()
+        color_frame = frame.get_color_frame()
+        color_image_raw = np.asanyarray(color_frame.get_data())

-        frame = self.async_read(timeout_ms=10000)
+        color_image_processed = self._postprocess_image(color_image_raw, color_mode)

        read_duration_ms = (time.perf_counter() - start_time) * 1e3
        logger.debug(f"{self} read took: {read_duration_ms:.1f}ms")

-        return frame
+        return color_image_processed

-    def _postprocess_image(self, image: NDArray[Any], depth_frame: bool = False) -> NDArray[Any]:
+    def _postprocess_image(
+        self, image: NDArray[Any], color_mode: ColorMode | None = None, depth_frame: bool = False
+    ) -> NDArray[Any]:
        """
        Applies color conversion, dimension validation, and rotation to a raw color frame.

        Args:
            image (np.ndarray): The raw image frame (expected RGB format from RealSense).
+            color_mode (Optional[ColorMode]): The target color mode (RGB or BGR). If None,
+                                             uses the instance's default `self.color_mode`.

        Returns:
            np.ndarray: The processed image frame according to `self.color_mode` and `self.rotation`.
@@ -429,9 +421,9 @@ class RealSenseCamera(Camera):
                          `width` and `height`.
        """

-        if self.color_mode and self.color_mode not in (ColorMode.RGB, ColorMode.BGR):
+        if color_mode and color_mode not in (ColorMode.RGB, ColorMode.BGR):
            raise ValueError(
-                f"Invalid requested color mode '{self.color_mode}'. Expected {ColorMode.RGB} or {ColorMode.BGR}."
+                f"Invalid requested color mode '{color_mode}'. Expected {ColorMode.RGB} or {ColorMode.BGR}."
            )

        if depth_frame:
@@ -462,7 +454,7 @@ class RealSenseCamera(Camera):

        On each iteration:
        1. Reads a color frame with 500ms timeout
-        2. Stores result in latest_frame and updates timestamp (thread-safe)
+        2. Stores result in latest_frame (thread-safe)
        3. Sets new_frame_event to notify listeners

        Stops on DeviceNotConnectedError, logs other errors and continues.
@@ -470,41 +462,25 @@ class RealSenseCamera(Camera):
        if self.stop_event is None:
            raise RuntimeError(f"{self}: stop_event is not initialized before starting read loop.")

-        failure_count = 0
        while not self.stop_event.is_set():
            try:
-                frame = self._read_from_hardware()
-                color_frame_raw = frame.get_color_frame()
-                color_frame = np.asanyarray(color_frame_raw.get_data())
-                processed_color_frame = self._postprocess_image(color_frame)
-
-                if self.use_depth:
-                    depth_frame_raw = frame.get_depth_frame()
-                    depth_frame = np.asanyarray(depth_frame_raw.get_data())
-                    processed_depth_frame = self._postprocess_image(depth_frame, depth_frame=True)
-
-                capture_time = time.perf_counter()
+                color_image = self.read(timeout_ms=500)

                with self.frame_lock:
-                    self.latest_color_frame = processed_color_frame
-                    if self.use_depth:
-                        self.latest_depth_frame = processed_depth_frame
-                    self.latest_timestamp = capture_time
+                    self.latest_frame = color_image
                self.new_frame_event.set()
-                failure_count = 0

            except DeviceNotConnectedError:
                break
            except Exception as e:
-                if failure_count <= 10:
-                    failure_count += 1
-                    logger.warning(f"Error reading frame in background thread for {self}: {e}")
-                else:
-                    raise RuntimeError(f"{self} exceeded maximum consecutive read failures.") from e
+                logger.warning(f"Error reading frame in background thread for {self}: {e}")

    def _start_read_thread(self) -> None:
        """Starts or restarts the background read thread if it's not running."""
-        self._stop_read_thread()
+        if self.thread is not None and self.thread.is_alive():
+            self.thread.join(timeout=0.1)
+        if self.stop_event is not None:
+            self.stop_event.set()

        self.stop_event = Event()
        self.thread = Thread(target=self._read_loop, args=(), name=f"{self}_read_loop")
@@ -522,14 +498,7 @@ class RealSenseCamera(Camera):
        self.thread = None
        self.stop_event = None

-        with self.frame_lock:
-            self.latest_color_frame = None
-            self.latest_depth_frame = None
-            self.latest_timestamp = None
-            self.new_frame_event.clear()
-
    # NOTE(Steven): Missing implementation for depth for now
-    @check_if_not_connected
    def async_read(self, timeout_ms: float = 200) -> NDArray[Any]:
        """
        Reads the latest available frame data (color) asynchronously.
@@ -537,7 +506,6 @@ class RealSenseCamera(Camera):
        This method retrieves the most recent color frame captured by the background
        read thread. It does not block waiting for the camera hardware directly,
        but may wait up to timeout_ms for the background thread to provide a frame.
-        It is “best effort” under high FPS.

        Args:
            timeout_ms (float): Maximum time in milliseconds to wait for a frame
@@ -552,18 +520,21 @@ class RealSenseCamera(Camera):
            TimeoutError: If no frame data becomes available within the specified timeout.
            RuntimeError: If the background thread died unexpectedly or another error occurs.
        """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")

        if self.thread is None or not self.thread.is_alive():
-            raise RuntimeError(f"{self} read thread is not running.")
+            self._start_read_thread()

        if not self.new_frame_event.wait(timeout=timeout_ms / 1000.0):
+            thread_alive = self.thread is not None and self.thread.is_alive()
            raise TimeoutError(
                f"Timed out waiting for frame from camera {self} after {timeout_ms} ms. "
-                f"Read thread alive: {self.thread.is_alive()}."
+                f"Read thread alive: {thread_alive}."
            )

        with self.frame_lock:
-            frame = self.latest_color_frame
+            frame = self.latest_frame
            self.new_frame_event.clear()

        if frame is None:
@@ -571,42 +542,6 @@ class RealSenseCamera(Camera):

        return frame

-    # NOTE(Steven): Missing implementation for depth for now
-    @check_if_not_connected
-    def read_latest(self, max_age_ms: int = 500) -> NDArray[Any]:
-        """Return the most recent (color) frame captured immediately (Peeking).
-
-        This method is non-blocking and returns whatever is currently in the
-        memory buffer. The frame may be stale,
-        meaning it could have been captured a while ago (hanging camera scenario e.g.).
-
-        Returns:
-            NDArray[Any]: The frame image (numpy array).
-
-        Raises:
-            TimeoutError: If the latest frame is older than `max_age_ms`.
-            DeviceNotConnectedError: If the camera is not connected.
-            RuntimeError: If the camera is connected but has not captured any frames yet.
-        """
-
-        if self.thread is None or not self.thread.is_alive():
-            raise RuntimeError(f"{self} read thread is not running.")
-
-        with self.frame_lock:
-            frame = self.latest_color_frame
-            timestamp = self.latest_timestamp
-
-        if frame is None or timestamp is None:
-            raise RuntimeError(f"{self} has not captured any frames yet.")
-
-        age_ms = (time.perf_counter() - timestamp) * 1e3
-        if age_ms > max_age_ms:
-            raise TimeoutError(
-                f"{self} latest frame is too old: {age_ms:.1f} ms (max allowed: {max_age_ms} ms)."
-            )
-
-        return frame
-
    def disconnect(self) -> None:
        """
        Disconnects from the camera, stops the pipeline, and cleans up resources.
@@ -630,10 +565,4 @@ class RealSenseCamera(Camera):
            self.rs_pipeline = None
            self.rs_profile = None

-        with self.frame_lock:
-            self.latest_color_frame = None
-            self.latest_depth_frame = None
-            self.latest_timestamp = None
-            self.new_frame_event.clear()
-
        logger.info(f"{self} disconnected.")
@@ -60,8 +60,20 @@ class RealSenseCameraConfig(CameraConfig):
    warmup_s: int = 1

    def __post_init__(self) -> None:
-        self.color_mode = ColorMode(self.color_mode)
-        self.rotation = Cv2Rotation(self.rotation)
+        if self.color_mode not in (ColorMode.RGB, ColorMode.BGR):
+            raise ValueError(
+                f"`color_mode` is expected to be {ColorMode.RGB.value} or {ColorMode.BGR.value}, but {self.color_mode} is provided."
+            )
+
+        if self.rotation not in (
+            Cv2Rotation.NO_ROTATION,
+            Cv2Rotation.ROTATE_90,
+            Cv2Rotation.ROTATE_180,
+            Cv2Rotation.ROTATE_270,
+        ):
+            raise ValueError(
+                f"`rotation` is expected to be in {(Cv2Rotation.NO_ROTATION, Cv2Rotation.ROTATE_90, Cv2Rotation.ROTATE_180, Cv2Rotation.ROTATE_270)}, but {self.rotation} is provided."
+            )

        values = (self.fps, self.width, self.height)
        if any(v is not None for v in values) and any(v is None for v in values):
@@ -14,6 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.

+import platform
 from typing import cast

 from lerobot.utils.import_utils import make_device_from_device_class
@@ -42,11 +43,6 @@ def make_cameras_from_configs(camera_configs: dict[str, CameraConfig]) -> dict[s

            cameras[key] = Reachy2Camera(cfg)

-        elif cfg.type == "zmq":
-            from .zmq.camera_zmq import ZMQCamera
-
-            cameras[key] = ZMQCamera(cfg)
-
        else:
            try:
                cameras[key] = cast(Camera, make_device_from_device_class(cfg))
@@ -67,3 +63,14 @@ def get_cv2_rotation(rotation: Cv2Rotation) -> int | None:
        return int(cv2.ROTATE_90_COUNTERCLOCKWISE)
    else:
        return None
+
+
+def get_cv2_backend() -> int:
+    import cv2
+
+    if platform.system() == "Windows":
+        return int(cv2.CAP_MSMF)  # Use MSMF for Windows instead of AVFOUNDATION
+    # elif platform.system() == "Darwin":  # macOS
+    #     return cv2.CAP_AVFOUNDATION
+    else:  # Linux and others
+        return int(cv2.CAP_ANY)
@@ -1,20 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright 2026 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from .camera_zmq import ZMQCamera
-from .configuration_zmq import ZMQCameraConfig
-
-__all__ = ["ZMQCamera", "ZMQCameraConfig"]
@@ -1,385 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-ZMQCamera - Captures frames from remote cameras via ZeroMQ using JSON protocol in the
-following format:
-    {
-        "timestamps": {"camera_name": float},
-        "images": {"camera_name": "<base64-jpeg>"}
-    }
-"""
-
-import base64
-import json
-import logging
-import time
-from threading import Event, Lock, Thread
-from typing import Any
-
-import cv2
-import numpy as np
-from numpy.typing import NDArray
-
-from lerobot.utils.decorators import check_if_already_connected, check_if_not_connected
-from lerobot.utils.errors import DeviceNotConnectedError
-
-from ..camera import Camera
-from ..configs import ColorMode
-from .configuration_zmq import ZMQCameraConfig
-
-logger = logging.getLogger(__name__)
-
-
-class ZMQCamera(Camera):
-    """
-    Manages camera interactions via ZeroMQ for receiving frames from a remote server.
-
-    This class connects to a ZMQ Publisher, subscribes to frame topics, and decodes
-    incoming JSON messages containing Base64 encoded images. It supports both
-    synchronous and asynchronous frame reading patterns.
-
-    Example usage:
-        ```python
-        from lerobot.cameras.zmq import ZMQCamera, ZMQCameraConfig
-
-        config = ZMQCameraConfig(server_address="192.168.123.164", port=5555, camera_name="head_camera")
-        camera = ZMQCamera(config)
-        camera.connect()
-
-        # Read 1 frame synchronously (blocking)
-        color_image = camera.read()
-
-        # Read 1 frame asynchronously (waits for new frame with a timeout)
-        async_image = camera.async_read()
-
-        # Get the latest frame immediately (no wait, returns timestamp)
-        latest_image, timestamp = camera.read_latest()
-
-        camera.disconnect()
-        ```
-    """
-
-    def __init__(self, config: ZMQCameraConfig):
-        super().__init__(config)
-        import zmq
-
-        self.config = config
-        self.server_address = config.server_address
-        self.port = config.port
-        self.camera_name = config.camera_name
-        self.color_mode = config.color_mode
-        self.timeout_ms = config.timeout_ms
-
-        # ZMQ Context and Socket
-        self.context: zmq.Context | None = None
-        self.socket: zmq.Socket | None = None
-        self._connected = False
-
-        # Threading resources
-        self.thread: Thread | None = None
-        self.stop_event: Event | None = None
-        self.frame_lock: Lock = Lock()
-        self.latest_frame: NDArray[Any] | None = None
-        self.latest_timestamp: float | None = None
-        self.new_frame_event: Event = Event()
-
-    def __str__(self) -> str:
-        return f"ZMQCamera({self.camera_name}@{self.server_address}:{self.port})"
-
-    @property
-    def is_connected(self) -> bool:
-        """Checks if the ZMQ socket is initialized and connected."""
-        return self._connected and self.context is not None and self.socket is not None
-
-    @check_if_already_connected
-    def connect(self, warmup: bool = True) -> None:
-        """Connect to ZMQ camera server.
-
-        Args:
-            warmup (bool): If True, waits for the camera to provide at least one
-                           valid frame before returning. Defaults to True.
-        """
-
-        logger.info(f"Connecting to {self}...")
-
-        try:
-            import zmq
-
-            self.context = zmq.Context()
-            self.socket = self.context.socket(zmq.SUB)
-            self.socket.setsockopt_string(zmq.SUBSCRIBE, "")
-            self.socket.setsockopt(zmq.RCVTIMEO, self.timeout_ms)
-            self.socket.setsockopt(zmq.CONFLATE, True)
-            self.socket.connect(f"tcp://{self.server_address}:{self.port}")
-            self._connected = True
-
-            # Auto-detect resolution if not provided
-            if self.width is None or self.height is None:
-                # Read directly from hardware because the thread isn't running yet
-                temp_frame = self._read_from_hardware()
-                h, w = temp_frame.shape[:2]
-                self.height = h
-                self.width = w
-                logger.info(f"{self} resolution detected: {w}x{h}")
-
-            self._start_read_thread()
-            logger.info(f"{self} connected.")
-
-            if warmup:
-                # Ensure we have captured at least one frame via the thread
-                start_time = time.time()
-                while time.time() - start_time < (self.config.warmup_s):  # Wait a bit more than timeout
-                    self.async_read(timeout_ms=self.config.warmup_s * 1000)
-                    time.sleep(0.1)
-
-                with self.frame_lock:
-                    if self.latest_frame is None:
-                        raise ConnectionError(f"{self} failed to capture frames during warmup.")
-
-        except Exception as e:
-            self._cleanup()
-            raise RuntimeError(f"Failed to connect to {self}: {e}") from e
-
-    def _cleanup(self):
-        """Clean up ZMQ resources."""
-        self._connected = False
-        if self.socket:
-            self.socket.close()
-            self.socket = None
-        if self.context:
-            self.context.term()
-            self.context = None
-
-    @staticmethod
-    def find_cameras() -> list[dict[str, Any]]:
-        """
-        Detection not implemented for ZMQ cameras. These cameras require manual configuration (server address/port).
-        """
-        raise NotImplementedError("Camera detection is not implemented for ZMQ cameras.")
-
-    def _read_from_hardware(self) -> NDArray[Any]:
-        """
-        Reads a single frame directly from the ZMQ socket.
-        """
-        if not self.is_connected or self.socket is None:
-            raise DeviceNotConnectedError(f"{self} is not connected.")
-
-        try:
-            message = self.socket.recv_string()
-        except Exception as e:
-            # Check for ZMQ timeout (EAGAIN/Again) without requiring global zmq import
-            if type(e).__name__ == "Again":
-                raise TimeoutError(f"{self} timeout after {self.timeout_ms}ms") from e
-            raise
-
-        # Decode JSON message
-        data = json.loads(message)
-
-        if "images" not in data:
-            raise RuntimeError(f"{self} invalid message: missing 'images' key")
-
-        images = data["images"]
-
-        # Get image by camera name or first available
-        if self.camera_name in images:
-            img_b64 = images[self.camera_name]
-        elif images:
-            img_b64 = next(iter(images.values()))
-        else:
-            raise RuntimeError(f"{self} no images in message")
-
-        # Decode base64 JPEG
-        img_bytes = base64.b64decode(img_b64)
-        frame = cv2.imdecode(np.frombuffer(img_bytes, np.uint8), cv2.IMREAD_COLOR)
-
-        if frame is None:
-            raise RuntimeError(f"{self} failed to decode image")
-
-        return frame
-
-    @check_if_not_connected
-    def read(self, color_mode: ColorMode | None = None) -> NDArray[Any]:
-        """
-        Reads a single frame synchronously from the camera.
-
-        This is a blocking call. It waits for the next available frame from the
-        camera background thread.
-
-        Returns:
-            np.ndarray: Decoded frame (height, width, 3)
-        """
-        start_time = time.perf_counter()
-
-        if color_mode is not None:
-            logger.warning(
-                f"{self} read() color_mode parameter is deprecated and will be removed in future versions."
-            )
-
-        if self.thread is None or not self.thread.is_alive():
-            raise RuntimeError(f"{self} read thread is not running.")
-
-        self.new_frame_event.clear()
-        frame = self.async_read(timeout_ms=10000)
-
-        read_duration_ms = (time.perf_counter() - start_time) * 1e3
-        logger.debug(f"{self} read took: {read_duration_ms:.1f}ms")
-
-        return frame
-
-    def _read_loop(self) -> None:
-        """
-        Internal loop run by the background thread for asynchronous reading.
-        """
-        if self.stop_event is None:
-            raise RuntimeError(f"{self}: stop_event is not initialized.")
-
-        failure_count = 0
-        while not self.stop_event.is_set():
-            try:
-                frame = self._read_from_hardware()
-                capture_time = time.perf_counter()
-
-                with self.frame_lock:
-                    self.latest_frame = frame
-                    self.latest_timestamp = capture_time
-                self.new_frame_event.set()
-                failure_count = 0
-
-            except DeviceNotConnectedError:
-                break
-            except (TimeoutError, Exception) as e:
-                if failure_count <= 10:
-                    failure_count += 1
-                    logger.warning(f"Read error: {e}")
-                else:
-                    raise RuntimeError(f"{self} exceeded maximum consecutive read failures.") from e
-
-    def _start_read_thread(self) -> None:
-        if self.stop_event is not None:
-            self.stop_event.set()
-        if self.thread is not None and self.thread.is_alive():
-            self.thread.join(timeout=2.0)
-
-        with self.frame_lock:
-            self.latest_frame = None
-            self.latest_timestamp = None
-            self.new_frame_event.clear()
-
-        self.stop_event = Event()
-        self.thread = Thread(target=self._read_loop, daemon=True, name=f"{self}_read_loop")
-        self.thread.start()
-        time.sleep(0.1)
-
-    def _stop_read_thread(self) -> None:
-        if self.stop_event is not None:
-            self.stop_event.set()
-
-        if self.thread is not None and self.thread.is_alive():
-            self.thread.join(timeout=2.0)
-
-        self.thread = None
-        self.stop_event = None
-
-        with self.frame_lock:
-            self.latest_frame = None
-            self.latest_timestamp = None
-            self.new_frame_event.clear()
-
-    @check_if_not_connected
-    def async_read(self, timeout_ms: float = 200) -> NDArray[Any]:
-        """
-        Reads the latest available frame asynchronously.
-
-        Args:
-            timeout_ms (float): Maximum time in milliseconds to wait for a frame
-                to become available. Defaults to 200ms.
-
-        Returns:
-            np.ndarray: The latest captured frame.
-
-        Raises:
-            DeviceNotConnectedError: If the camera is not connected.
-            TimeoutError: If no frame data becomes available within the specified timeout.
-            RuntimeError: If the background thread is not running.
-        """
-
-        if self.thread is None or not self.thread.is_alive():
-            raise RuntimeError(f"{self} read thread is not running.")
-
-        if not self.new_frame_event.wait(timeout=timeout_ms / 1000.0):
-            raise TimeoutError(f"{self} async_read timeout after {timeout_ms}ms")
-
-        with self.frame_lock:
-            frame = self.latest_frame
-            self.new_frame_event.clear()
-
-        if frame is None:
-            raise RuntimeError(f"{self} no frame available")
-
-        return frame
-
-    @check_if_not_connected
-    def read_latest(self, max_age_ms: int = 1000) -> NDArray[Any]:
-        """Return the most recent frame captured immediately (Peeking).
-
-        This method is non-blocking and returns whatever is currently in the
-        memory buffer. The frame may be stale,
-        meaning it could have been captured a while ago (hanging camera scenario e.g.).
-
-        Returns:
-            NDArray[Any]: The frame image (numpy array).
-
-        Raises:
-            TimeoutError: If the latest frame is older than `max_age_ms`.
-            DeviceNotConnectedError: If the camera is not connected.
-            RuntimeError: If the camera is connected but has not captured any frames yet.
-        """
-
-        if self.thread is None or not self.thread.is_alive():
-            raise RuntimeError(f"{self} read thread is not running.")
-
-        with self.frame_lock:
-            frame = self.latest_frame
-            timestamp = self.latest_timestamp
-
-        if frame is None or timestamp is None:
-            raise RuntimeError(f"{self} has not captured any frames yet.")
-
-        age_ms = (time.perf_counter() - timestamp) * 1e3
-        if age_ms > max_age_ms:
-            raise TimeoutError(
-                f"{self} latest frame is too old: {age_ms:.1f} ms (max allowed: {max_age_ms} ms)."
-            )
-
-        return frame
-
-    def disconnect(self) -> None:
-        """Disconnect from ZMQ camera."""
-        if not self.is_connected and self.thread is None:
-            raise DeviceNotConnectedError(f"{self} not connected.")
-
-        if self.thread is not None:
-            self._stop_read_thread()
-
-        self._cleanup()
-
-        with self.frame_lock:
-            self.latest_frame = None
-            self.latest_timestamp = None
-            self.new_frame_event.clear()
-
-        logger.info(f"{self} disconnected.")
@@ -1,44 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright 2026 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from dataclasses import dataclass
-
-from ..configs import CameraConfig, ColorMode
-
-__all__ = ["ZMQCameraConfig", "ColorMode"]
-
-
-@CameraConfig.register_subclass("zmq")
-@dataclass
-class ZMQCameraConfig(CameraConfig):
-    server_address: str
-    port: int = 5555
-    camera_name: str = "zmq_camera"
-    color_mode: ColorMode = ColorMode.RGB
-    timeout_ms: int = 5000
-    warmup_s: int = 1
-
-    def __post_init__(self) -> None:
-        self.color_mode = ColorMode(self.color_mode)
-
-        if self.timeout_ms <= 0:
-            raise ValueError(f"`timeout_ms` must be positive, but {self.timeout_ms} is provided.")
-
-        if not self.server_address:
-            raise ValueError("`server_address` cannot be empty.")
-
-        if self.port <= 0 or self.port > 65535:
-            raise ValueError(f"`port` must be between 1 and 65535, but {self.port} is provided.")
@@ -1,114 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright 2026 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-Streams camera images over ZMQ.
-Uses lerobot's OpenCVCamera for capture, encodes images to base64 and sends them over ZMQ.
-"""
-
-import base64
-import contextlib
-import json
-import logging
-import time
-from collections import deque
-
-import cv2
-import numpy as np
-import zmq
-
-from lerobot.cameras.configs import ColorMode
-from lerobot.cameras.opencv import OpenCVCamera, OpenCVCameraConfig
-
-logger = logging.getLogger(__name__)
-
-
-def encode_image(image: np.ndarray, quality: int = 80) -> str:
-    """Encode RGB image to base64 JPEG string."""
-    _, buffer = cv2.imencode(".jpg", image, [int(cv2.IMWRITE_JPEG_QUALITY), quality])
-    return base64.b64encode(buffer).decode("utf-8")
-
-
-class ImageServer:
-    def __init__(self, config: dict, port: int = 5555):
-        self.fps = config.get("fps", 30)
-        self.cameras: dict[str, OpenCVCamera] = {}
-
-        for name, cfg in config.get("cameras", {}).items():
-            shape = cfg.get("shape", [480, 640])
-            cam_config = OpenCVCameraConfig(
-                index_or_path=cfg.get("device_id", 0),
-                fps=self.fps,
-                width=shape[1],
-                height=shape[0],
-                color_mode=ColorMode.RGB,
-            )
-            camera = OpenCVCamera(cam_config)
-            camera.connect()
-            self.cameras[name] = camera
-            logger.info(f"Camera {name}: {shape[1]}x{shape[0]}")
-
-        # ZMQ PUB socket
-        self.context = zmq.Context()
-        self.socket = self.context.socket(zmq.PUB)
-        self.socket.setsockopt(zmq.SNDHWM, 20)
-        self.socket.setsockopt(zmq.LINGER, 0)
-        self.socket.bind(f"tcp://*:{port}")
-
-        logger.info(f"ImageServer running on port {port}")
-
-    def run(self):
-        frame_count = 0
-        frame_times = deque(maxlen=60)
-
-        try:
-            while True:
-                t0 = time.time()
-
-                # Build message
-                message = {"timestamps": {}, "images": {}}
-                for name, cam in self.cameras.items():
-                    frame = cam.read()  # Returns RGB
-                    message["timestamps"][name] = time.time()
-                    message["images"][name] = encode_image(frame)
-
-                # Send as JSON string (suppress if buffer full)
-                with contextlib.suppress(zmq.Again):
-                    self.socket.send_string(json.dumps(message), zmq.NOBLOCK)
-
-                frame_count += 1
-                frame_times.append(time.time() - t0)
-
-                if frame_count % 60 == 0:
-                    logger.debug(f"FPS: {len(frame_times) / sum(frame_times):.1f}")
-
-                sleep = (1.0 / self.fps) - (time.time() - t0)
-                if sleep > 0:
-                    time.sleep(sleep)
-
-        except KeyboardInterrupt:
-            pass
-        finally:
-            for cam in self.cameras.values():
-                cam.disconnect()
-            self.socket.close()
-            self.context.term()
-
-
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO)
-    config = {"fps": 30, "cameras": {"head_camera": {"device_id": 4, "shape": [480, 640]}}}
-    ImageServer(config, port=5555).run()
@@ -38,8 +38,6 @@ class EvalPipelineConfig:
    seed: int | None = 1000
    # Rename map for the observation to override the image and state keys
    rename_map: dict[str, str] = field(default_factory=dict)
-    # Explicit consent to execute remote code from the Hub (required for hub environments).
-    trust_remote_code: bool = False

    def __post_init__(self) -> None:
        # HACK: We parse again the cli args here to get the pretrained path if there was one.
@@ -45,12 +45,12 @@ class PreTrainedConfig(draccus.ChoiceRegistry, HubMixin, abc.ABC):  # type: igno
    Args:
        n_obs_steps: Number of environment steps worth of observations to pass to the policy (takes the
            current step and additional steps going back).
-        input_features: A dictionary defining the PolicyFeature of the input data for the policy. The key represents
-            the input data name, and the value is PolicyFeature, which consists of FeatureType and shape attributes.
-        output_features: A dictionary defining the PolicyFeature of the output data for the policy. The key represents
-            the output data name, and the value is PolicyFeature, which consists of FeatureType and shape attributes.
-        normalization_mapping: A dictionary that maps from a str value of FeatureType (e.g., "STATE", "VISUAL") to
-            a corresponding NormalizationMode (e.g., NormalizationMode.MIN_MAX)
+        input_shapes: A dictionary defining the shapes of the input data for the policy.
+        output_shapes: A dictionary defining the shapes of the output data for the policy.
+        input_normalization_modes: A dictionary with key representing the modality and the value specifies the
+            normalization mode to apply.
+        output_normalization_modes: Similar dictionary as `input_normalization_modes`, but to unnormalize to
+            the original scale.
    """

    n_obs_steps: int = 1
@@ -129,7 +129,7 @@ class PreTrainedConfig(draccus.ChoiceRegistry, HubMixin, abc.ABC):  # type: igno

    @property
    def robot_state_feature(self) -> PolicyFeature | None:
-        if not self.input_features:
+        if self.input_features is None:
            return None
        for ft_name, ft in self.input_features.items():
            if ft.type is FeatureType.STATE and ft_name == OBS_STATE:
@@ -138,7 +138,7 @@ class PreTrainedConfig(draccus.ChoiceRegistry, HubMixin, abc.ABC):  # type: igno

    @property
    def env_state_feature(self) -> PolicyFeature | None:
-        if not self.input_features:
+        if self.input_features is None:
            return None
        for _, ft in self.input_features.items():
            if ft.type is FeatureType.ENV:
@@ -147,13 +147,13 @@ class PreTrainedConfig(draccus.ChoiceRegistry, HubMixin, abc.ABC):  # type: igno

    @property
    def image_features(self) -> dict[str, PolicyFeature]:
-        if not self.input_features:
+        if self.input_features is None:
            return {}
        return {key: ft for key, ft in self.input_features.items() if ft.type is FeatureType.VISUAL}

    @property
    def action_feature(self) -> PolicyFeature | None:
-        if not self.output_features:
+        if self.output_features is None:
            return None
        for ft_name, ft in self.output_features.items():
            if ft.type is FeatureType.ACTION and ft_name == ACTION:
@@ -211,15 +211,3 @@ class TrainRLServerPipelineConfig(TrainPipelineConfig):
    # NOTE: In RL, we don't need an offline dataset
    # TODO: Make `TrainPipelineConfig.dataset` optional
    dataset: DatasetConfig | None = None  # type: ignore[assignment] # because the parent class has made it's type non-optional
-
-    # Algorithm name registered in RLAlgorithmConfig registry
-    algorithm: str = "sac"
-
-    # Data mixer strategy name. Currently supports "online_offline"
-    mixer: str = "online_offline"
-    # Fraction sampled from online replay when using OnlineOfflineMixer
-    online_ratio: float = 0.5
-
-    # RL trainer iterator
-    async_prefetch: bool = True
-    queue_size: int = 2
@@ -19,7 +19,6 @@ import logging
 import shutil
 from pathlib import Path

-import datasets
 import pandas as pd
 import tqdm

@@ -33,7 +32,6 @@ from lerobot.datasets.utils import (
    DEFAULT_VIDEO_FILE_SIZE_IN_MB,
    DEFAULT_VIDEO_PATH,
    get_file_size_in_mb,
-    get_hf_features_from_features,
    get_parquet_file_size_in_mb,
    to_parquet_with_hf_images,
    update_chunk_file_indices,
@@ -116,9 +114,6 @@ def update_meta_data(
    Adjusts all indices and timestamps to account for previously aggregated
    data and videos in the destination dataset.

-    For data file indices, uses the 'src_to_dst' mapping from aggregate_data()
-    to correctly map source file indices to their destination locations.
-
    Args:
        df: DataFrame containing the metadata to be updated.
        dst_meta: Destination dataset metadata.
@@ -132,50 +127,8 @@ def update_meta_data(

    df["meta/episodes/chunk_index"] = df["meta/episodes/chunk_index"] + meta_idx["chunk"]
    df["meta/episodes/file_index"] = df["meta/episodes/file_index"] + meta_idx["file"]
-
-    # Update data file indices using source-to-destination mapping
-    # This is critical for handling datasets that are already results of a merge
-    data_src_to_dst = data_idx.get("src_to_dst", {})
-    if data_src_to_dst:
-        # Store original indices for lookup
-        df["_orig_data_chunk"] = df["data/chunk_index"].copy()
-        df["_orig_data_file"] = df["data/file_index"].copy()
-
-        # Vectorized mapping from (src_chunk, src_file) to (dst_chunk, dst_file)
-        # This is much faster than per-row iteration for large metadata tables
-        mapping_index = pd.MultiIndex.from_tuples(
-            list(data_src_to_dst.keys()),
-            names=["chunk_index", "file_index"],
-        )
-        mapping_values = list(data_src_to_dst.values())
-        mapping_df = pd.DataFrame(
-            mapping_values,
-            index=mapping_index,
-            columns=["dst_chunk", "dst_file"],
-        )
-
-        # Construct a MultiIndex for each row based on original data indices
-        row_index = pd.MultiIndex.from_arrays(
-            [df["_orig_data_chunk"], df["_orig_data_file"]],
-            names=["chunk_index", "file_index"],
-        )
-
-        # Align mapping to rows; missing keys fall back to the default destination
-        reindexed = mapping_df.reindex(row_index)
-        reindexed[["dst_chunk", "dst_file"]] = reindexed[["dst_chunk", "dst_file"]].fillna(
-            {"dst_chunk": data_idx["chunk"], "dst_file": data_idx["file"]}
-        )
-
-        # Assign mapped destination indices back to the DataFrame
-        df["data/chunk_index"] = reindexed["dst_chunk"].to_numpy()
-        df["data/file_index"] = reindexed["dst_file"].to_numpy()
-
-        # Clean up temporary columns
-        df = df.drop(columns=["_orig_data_chunk", "_orig_data_file"])
-    else:
-        # Fallback to simple offset (backward compatibility for single-file sources)
-        df["data/chunk_index"] = df["data/chunk_index"] + data_idx["chunk"]
-        df["data/file_index"] = df["data/file_index"] + data_idx["file"]
+    df["data/chunk_index"] = df["data/chunk_index"] + data_idx["chunk"]
+    df["data/file_index"] = df["data/file_index"] + data_idx["file"]
    for key, video_idx in videos_idx.items():
        # Store original video file indices before updating
        orig_chunk_col = f"videos/{key}/chunk_index"
@@ -191,7 +144,8 @@ def update_meta_data(
        if src_to_dst:
            # Map each episode to its correct destination file and apply offset
            for idx in df.index:
-                src_key = (df.at[idx, "_orig_chunk"], df.at[idx, "_orig_file"])
+                # Convert to Python int to avoid numpy type mismatch in dict lookup
+                src_key = (int(df.at[idx, "_orig_chunk"]), int(df.at[idx, "_orig_file"]))

                # Get destination chunk/file for this source file
                dst_chunk, dst_file = src_to_dst.get(src_key, (video_idx["chunk"], video_idx["file"]))
@@ -207,7 +161,8 @@ def update_meta_data(
            df[orig_chunk_col] = video_idx["chunk"]
            df[orig_file_col] = video_idx["file"]
            for idx in df.index:
-                src_key = (df.at[idx, "_orig_chunk"], df.at[idx, "_orig_file"])
+                # Convert to Python int to avoid numpy type mismatch in dict lookup
+                src_key = (int(df.at[idx, "_orig_chunk"]), int(df.at[idx, "_orig_file"]))
                offset = src_to_offset.get(src_key, 0)
                df.at[idx, f"videos/{key}/from_timestamp"] += offset
                df.at[idx, f"videos/{key}/to_timestamp"] += offset
@@ -305,10 +260,6 @@ def aggregate_datasets(

        meta_idx = aggregate_metadata(src_meta, dst_meta, meta_idx, data_idx, videos_idx)

-        # Clear the src_to_dst mapping after processing each source dataset
-        # to avoid interference between different source datasets
-        data_idx.pop("src_to_dst", None)
-
        dst_meta.info["total_episodes"] += src_meta.total_episodes
        dst_meta.info["total_frames"] += src_meta.total_frames

@@ -359,6 +310,10 @@ def aggregate_videos(src_meta, dst_meta, videos_idx, video_files_size_in_mb, chu
        dst_file_durations = video_idx["dst_file_durations"]

        for src_chunk_idx, src_file_idx in unique_chunk_file_pairs:
+            # Convert to Python int to ensure consistent dict keys
+            src_chunk_idx = int(src_chunk_idx)
+            src_file_idx = int(src_file_idx)
+
            src_path = src_meta.root / DEFAULT_VIDEO_PATH.format(
                video_key=key,
                chunk_index=src_chunk_idx,
@@ -431,16 +386,10 @@ def aggregate_data(src_meta, dst_meta, data_idx, data_files_size_in_mb, chunk_si
    Reads source data files, updates indices to match the aggregated dataset,
    and writes them to the destination with proper file rotation.

-    Tracks a `src_to_dst` mapping from source (chunk, file) to destination (chunk, file)
-    which is critical for correctly updating episode metadata when source datasets
-    have multiple data files (e.g., from a previous merge operation).
-
    Args:
        src_meta: Source dataset metadata.
        dst_meta: Destination dataset metadata.
        data_idx: Dictionary tracking data chunk and file indices.
-        data_files_size_in_mb: Maximum size for data files in MB.
-        chunk_size: Maximum number of files per chunk.

    Returns:
        dict: Updated data_idx with current chunk and file indices.
@@ -453,47 +402,25 @@ def aggregate_data(src_meta, dst_meta, data_idx, data_files_size_in_mb, chunk_si
    }

    unique_chunk_file_ids = sorted(unique_chunk_file_ids)
-    contains_images = len(dst_meta.image_keys) > 0
-
-    # retrieve features schema for proper image typing in parquet
-    hf_features = get_hf_features_from_features(dst_meta.features) if contains_images else None
-
-    # Track source to destination file mapping for metadata update
-    # This is critical for handling datasets that are already results of a merge
-    src_to_dst: dict[tuple[int, int], tuple[int, int]] = {}

    for src_chunk_idx, src_file_idx in unique_chunk_file_ids:
        src_path = src_meta.root / DEFAULT_DATA_PATH.format(
            chunk_index=src_chunk_idx, file_index=src_file_idx
        )
-        if contains_images:
-            # Use HuggingFace datasets to read source data to preserve image format
-            src_ds = datasets.Dataset.from_parquet(str(src_path))
-            df = src_ds.to_pandas()
-        else:
-            df = pd.read_parquet(src_path)
+        df = pd.read_parquet(src_path)
        df = update_data_df(df, src_meta, dst_meta)

-        # Write data and get the actual destination file it was written to
-        # This avoids duplicating the rotation logic here
-        data_idx, (dst_chunk, dst_file) = append_or_create_parquet_file(
+        data_idx = append_or_create_parquet_file(
            df,
            src_path,
            data_idx,
            data_files_size_in_mb,
            chunk_size,
            DEFAULT_DATA_PATH,
-            contains_images=contains_images,
+            contains_images=len(dst_meta.image_keys) > 0,
            aggr_root=dst_meta.root,
-            hf_features=hf_features,
        )

-        # Record the mapping from source to actual destination
-        src_to_dst[(src_chunk_idx, src_file_idx)] = (dst_chunk, dst_file)
-
-    # Add the mapping to data_idx for use in metadata update
-    data_idx["src_to_dst"] = src_to_dst
-
    return data_idx


@@ -534,7 +461,7 @@ def aggregate_metadata(src_meta, dst_meta, meta_idx, data_idx, videos_idx):
            videos_idx,
        )

-        meta_idx, _ = append_or_create_parquet_file(
+        meta_idx = append_or_create_parquet_file(
            df,
            src_path,
            meta_idx,
@@ -561,8 +488,7 @@ def append_or_create_parquet_file(
    default_path: str,
    contains_images: bool = False,
    aggr_root: Path = None,
-    hf_features: datasets.Features | None = None,
-) -> tuple[dict[str, int], tuple[int, int]]:
+):
    """Appends data to an existing parquet file or creates a new one based on size constraints.

    Manages file rotation when size limits are exceeded to prevent individual files
@@ -577,49 +503,40 @@ def append_or_create_parquet_file(
        default_path: Format string for generating file paths.
        contains_images: Whether the data contains images requiring special handling.
        aggr_root: Root path for the aggregated dataset.
-        hf_features: Optional HuggingFace Features schema for proper image typing.

    Returns:
-        tuple: (updated_idx, (dst_chunk, dst_file)) where updated_idx is the index dict
-               and (dst_chunk, dst_file) is the actual destination file the data was written to.
+        dict: Updated index dictionary with current chunk and file indices.
    """
-    dst_chunk, dst_file = idx["chunk"], idx["file"]
-    dst_path = aggr_root / default_path.format(chunk_index=dst_chunk, file_index=dst_file)
+    dst_path = aggr_root / default_path.format(chunk_index=idx["chunk"], file_index=idx["file"])

    if not dst_path.exists():
        dst_path.parent.mkdir(parents=True, exist_ok=True)
        if contains_images:
-            to_parquet_with_hf_images(df, dst_path, features=hf_features)
+            to_parquet_with_hf_images(df, dst_path)
        else:
            df.to_parquet(dst_path)
-        return idx, (dst_chunk, dst_file)
+        return idx

    src_size = get_parquet_file_size_in_mb(src_path)
    dst_size = get_parquet_file_size_in_mb(dst_path)

    if dst_size + src_size >= max_mb:
        idx["chunk"], idx["file"] = update_chunk_file_indices(idx["chunk"], idx["file"], chunk_size)
-        dst_chunk, dst_file = idx["chunk"], idx["file"]
-        new_path = aggr_root / default_path.format(chunk_index=dst_chunk, file_index=dst_file)
+        new_path = aggr_root / default_path.format(chunk_index=idx["chunk"], file_index=idx["file"])
        new_path.parent.mkdir(parents=True, exist_ok=True)
        final_df = df
        target_path = new_path
    else:
-        if contains_images:
-            # Use HuggingFace datasets to read existing data to preserve image format
-            existing_ds = datasets.Dataset.from_parquet(str(dst_path))
-            existing_df = existing_ds.to_pandas()
-        else:
-            existing_df = pd.read_parquet(dst_path)
+        existing_df = pd.read_parquet(dst_path)
        final_df = pd.concat([existing_df, df], ignore_index=True)
        target_path = dst_path

    if contains_images:
-        to_parquet_with_hf_images(final_df, target_path, features=hf_features)
+        to_parquet_with_hf_images(final_df, target_path)
    else:
        final_df.to_parquet(target_path)

-    return idx, (dst_chunk, dst_file)
+    return idx


 def finalize_aggregation(aggr_meta, all_metadata):
@@ -26,7 +26,6 @@ This module provides utilities for:
 import logging
 import shutil
 from collections.abc import Callable
-from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path

 import datasets
@@ -52,8 +51,7 @@ from lerobot.datasets.utils import (
    write_stats,
    write_tasks,
 )
-from lerobot.datasets.video_utils import encode_video_frames, get_video_info
-from lerobot.utils.constants import HF_LEROBOT_HOME, OBS_IMAGE
+from lerobot.utils.constants import HF_LEROBOT_HOME


 def _load_episode_with_stats(src_dataset: LeRobotDataset, episode_idx: int) -> dict:
@@ -1085,687 +1083,3 @@ def _copy_episodes_metadata_and_stats(
    else:
        if src_dataset.meta.stats:
            write_stats(src_dataset.meta.stats, dst_meta.root)
-
-
-def _save_episode_images_for_video(
-    dataset: LeRobotDataset,
-    imgs_dir: Path,
-    img_key: str,
-    episode_index: int,
-    num_workers: int = 4,
-) -> None:
-    """Save images from a specific episode and camera to disk for video encoding.
-
-    Args:
-        dataset: The LeRobot dataset to extract images from
-        imgs_dir: Directory to save images to
-        img_key: The image key (camera) to extract
-        episode_index: Index of the episode to save
-        num_workers: Number of threads for parallel image saving
-    """
-    # Create directory
-    imgs_dir.mkdir(parents=True, exist_ok=True)
-
-    # Get dataset without torch format for PIL image access
-    hf_dataset = dataset.hf_dataset.with_format(None)
-
-    # Select only this camera's images
-    imgs_dataset = hf_dataset.select_columns(img_key)
-
-    # Get episode start and end indices
-    from_idx = dataset.meta.episodes["dataset_from_index"][episode_index]
-    to_idx = dataset.meta.episodes["dataset_to_index"][episode_index]
-
-    # Get all items for this episode
-    episode_dataset = imgs_dataset.select(range(from_idx, to_idx))
-
-    # Define function to save a single image
-    def save_single_image(i_item_tuple):
-        i, item = i_item_tuple
-        img = item[img_key]
-        # Use frame-XXXXXX.png format to match encode_video_frames expectations
-        img.save(str(imgs_dir / f"frame-{i:06d}.png"), quality=100)
-        return i
-
-    # Save images with proper naming convention for encode_video_frames (frame-XXXXXX.png)
-    items = list(enumerate(episode_dataset))
-
-    with ThreadPoolExecutor(max_workers=num_workers) as executor:
-        futures = [executor.submit(save_single_image, item) for item in items]
-        for future in as_completed(futures):
-            future.result()  # This will raise any exceptions that occurred
-
-
-def _save_batch_episodes_images(
-    dataset: LeRobotDataset,
-    imgs_dir: Path,
-    img_key: str,
-    episode_indices: list[int],
-    num_workers: int = 4,
-) -> list[float]:
-    """Save images from multiple episodes to disk for batch video encoding.
-
-    Args:
-        dataset: The LeRobot dataset to extract images from
-        imgs_dir: Directory to save images to
-        img_key: The image key (camera) to extract
-        episode_indices: List of episode indices to save
-        num_workers: Number of threads for parallel image saving
-
-    Returns:
-        List of episode durations in seconds
-    """
-    imgs_dir.mkdir(parents=True, exist_ok=True)
-    hf_dataset = dataset.hf_dataset.with_format(None)
-    imgs_dataset = hf_dataset.select_columns(img_key)
-
-    # Define function to save a single image with global frame index
-    # Defined once outside the loop to avoid repeated closure creation
-    def save_single_image(i_item_tuple, base_frame_idx, img_key_param):
-        i, item = i_item_tuple
-        img = item[img_key_param]
-        # Use global frame index for naming
-        img.save(str(imgs_dir / f"frame-{base_frame_idx + i:06d}.png"), quality=100)
-        return i
-
-    episode_durations = []
-    frame_idx = 0
-
-    for ep_idx in episode_indices:
-        # Get episode range
-        from_idx = dataset.meta.episodes["dataset_from_index"][ep_idx]
-        to_idx = dataset.meta.episodes["dataset_to_index"][ep_idx]
-        episode_length = to_idx - from_idx
-        episode_durations.append(episode_length / dataset.fps)
-
-        # Get episode images
-        episode_dataset = imgs_dataset.select(range(from_idx, to_idx))
-
-        # Save images
-        items = list(enumerate(episode_dataset))
-        with ThreadPoolExecutor(max_workers=num_workers) as executor:
-            futures = [executor.submit(save_single_image, item, frame_idx, img_key) for item in items]
-            for future in as_completed(futures):
-                future.result()
-
-        frame_idx += episode_length
-
-    return episode_durations
-
-
-def _iter_episode_batches(
-    episode_indices: list[int],
-    episode_lengths: dict[int, int],
-    size_per_frame_mb: float,
-    video_file_size_limit: float,
-    max_episodes: int | None,
-    max_frames: int | None,
-):
-    """Generator that yields batches of episode indices for video encoding.
-
-    Groups episodes into batches that respect size and memory constraints:
-    - Stays under video file size limit
-    - Respects maximum episodes per batch (if specified)
-    - Respects maximum frames per batch (if specified)
-
-    Args:
-        episode_indices: List of episode indices to batch
-        episode_lengths: Dictionary mapping episode index to episode length
-        size_per_frame_mb: Estimated size per frame in MB
-        video_file_size_limit: Maximum video file size in MB
-        max_episodes: Maximum number of episodes per batch (None = no limit)
-        max_frames: Maximum number of frames per batch (None = no limit)
-
-    Yields:
-        List of episode indices for each batch
-    """
-    batch_episodes = []
-    estimated_size = 0.0
-    total_frames = 0
-
-    for ep_idx in episode_indices:
-        ep_length = episode_lengths[ep_idx]
-        ep_estimated_size = ep_length * size_per_frame_mb
-
-        # we check if adding this episode would exceed any constraint
-        would_exceed_size = estimated_size > 0 and estimated_size + ep_estimated_size >= video_file_size_limit
-        would_exceed_episodes = max_episodes is not None and len(batch_episodes) >= max_episodes
-        would_exceed_frames = max_frames is not None and total_frames + ep_length > max_frames
-
-        if batch_episodes and (would_exceed_size or would_exceed_episodes or would_exceed_frames):
-            # yield current batch before adding this episode
-            yield batch_episodes
-            # start a new batch with current episode
-            batch_episodes = [ep_idx]
-            estimated_size = ep_estimated_size
-            total_frames = ep_length
-        else:
-            # add to current batch
-            batch_episodes.append(ep_idx)
-            estimated_size += ep_estimated_size
-            total_frames += ep_length
-
-    # yield final batch if not empty
-    if batch_episodes:
-        yield batch_episodes
-
-
-def _estimate_frame_size_via_calibration(
-    dataset: LeRobotDataset,
-    img_key: str,
-    episode_indices: list[int],
-    temp_dir: Path,
-    fps: int,
-    vcodec: str,
-    pix_fmt: str,
-    g: int,
-    crf: int,
-    fast_decode: int,
-    num_calibration_frames: int = 30,
-) -> float:
-    """Estimate MB per frame by encoding a small calibration sample.
-
-    Encodes a representative sample of frames using the exact codec parameters
-    to measure actual compression ratio, which is more accurate than heuristics.
-
-    Args:
-        dataset: Source dataset with images.
-        img_key: Image key to calibrate (e.g., "observation.images.top").
-        episode_indices: List of episode indices being processed.
-        temp_dir: Temporary directory for calibration files.
-        fps: Frames per second for video encoding.
-        vcodec: Video codec (libsvtav1, h264, hevc).
-        pix_fmt: Pixel format (yuv420p, etc.).
-        g: GOP size (group of pictures).
-        crf: Constant Rate Factor (quality).
-        fast_decode: Fast decode tuning parameter.
-        num_calibration_frames: Number of frames to use for calibration (default: 30).
-
-    Returns:
-        Estimated size in MB per frame based on actual encoding.
-    """
-    calibration_dir = temp_dir / "calibration" / img_key
-    calibration_dir.mkdir(parents=True, exist_ok=True)
-
-    try:
-        # Select a representative episode (prefer middle episode if available)
-        calibration_ep_idx = episode_indices[len(episode_indices) // 2]
-
-        # Get episode range
-        from_idx = dataset.meta.episodes["dataset_from_index"][calibration_ep_idx]
-        to_idx = dataset.meta.episodes["dataset_to_index"][calibration_ep_idx]
-        episode_length = to_idx - from_idx
-
-        # Use up to num_calibration_frames from this episode
-        num_frames = min(num_calibration_frames, episode_length)
-
-        # Get frames from dataset
-        hf_dataset = dataset.hf_dataset.with_format(None)
-        sample_indices = range(from_idx, from_idx + num_frames)
-
-        # Save calibration frames
-        for i, idx in enumerate(sample_indices):
-            img = hf_dataset[idx][img_key]
-            img.save(str(calibration_dir / f"frame-{i:06d}.png"), quality=100)
-
-        # Encode calibration video
-        calibration_video_path = calibration_dir / "calibration.mp4"
-        encode_video_frames(
-            imgs_dir=calibration_dir,
-            video_path=calibration_video_path,
-            fps=fps,
-            vcodec=vcodec,
-            pix_fmt=pix_fmt,
-            g=g,
-            crf=crf,
-            fast_decode=fast_decode,
-            overwrite=True,
-        )
-
-        # Measure actual compressed size
-        video_size_bytes = calibration_video_path.stat().st_size
-        video_size_mb = video_size_bytes / BYTES_PER_MIB
-        size_per_frame_mb = video_size_mb / num_frames
-
-        logging.info(
-            f"  Calibration: {num_frames} frames -> {video_size_mb:.2f} MB "
-            f"= {size_per_frame_mb:.4f} MB/frame for {img_key}"
-        )
-
-        return size_per_frame_mb
-
-    finally:
-        # Clean up calibration files
-        if calibration_dir.exists():
-            shutil.rmtree(calibration_dir)
-
-
-def _copy_data_without_images(
-    src_dataset: LeRobotDataset,
-    dst_meta: LeRobotDatasetMetadata,
-    episode_indices: list[int],
-    img_keys: list[str],
-) -> None:
-    """Copy data files without image columns.
-
-    Args:
-        src_dataset: Source dataset
-        dst_meta: Destination metadata
-        episode_indices: Episodes to include
-        img_keys: Image keys to remove
-    """
-    from lerobot.datasets.utils import DATA_DIR
-
-    data_dir = src_dataset.root / DATA_DIR
-    parquet_files = sorted(data_dir.glob("*/*.parquet"))
-
-    if not parquet_files:
-        raise ValueError(f"No parquet files found in {data_dir}")
-
-    episode_set = set(episode_indices)
-
-    for src_path in tqdm(parquet_files, desc="Processing data files"):
-        df = pd.read_parquet(src_path).reset_index(drop=True)
-
-        # Filter to only include selected episodes
-        df = df[df["episode_index"].isin(episode_set)].copy()
-
-        if len(df) == 0:
-            continue
-
-        # Remove image columns
-        columns_to_drop = [col for col in img_keys if col in df.columns]
-        if columns_to_drop:
-            df = df.drop(columns=columns_to_drop)
-
-        # Get chunk and file indices from path
-        relative_path = src_path.relative_to(src_dataset.root)
-        chunk_dir = relative_path.parts[1]
-        file_name = relative_path.parts[2]
-        chunk_idx = int(chunk_dir.split("-")[1])
-        file_idx = int(file_name.split("-")[1].split(".")[0])
-
-        # Write to destination without pandas index
-        dst_path = dst_meta.root / f"data/chunk-{chunk_idx:03d}/file-{file_idx:03d}.parquet"
-        dst_path.parent.mkdir(parents=True, exist_ok=True)
-        df.to_parquet(dst_path, index=False)
-
-
-# Video conversion constants
-BYTES_PER_KIB = 1024
-BYTES_PER_MIB = BYTES_PER_KIB * BYTES_PER_KIB
-
-
-def modify_tasks(
-    dataset: LeRobotDataset,
-    new_task: str | None = None,
-    episode_tasks: dict[int, str] | None = None,
-) -> LeRobotDataset:
-    """Modify tasks in a LeRobotDataset.
-
-    This function allows you to either:
-    1. Set a single task for the entire dataset (using `new_task`)
-    2. Set specific tasks for specific episodes (using `episode_tasks`)
-
-    You can combine both: `new_task` sets the default, and `episode_tasks` overrides
-    specific episodes.
-
-    The dataset is modified in-place, updating only the task-related files:
-    - meta/tasks.parquet
-    - data/**/*.parquet (task_index column)
-    - meta/episodes/**/*.parquet (tasks column)
-    - meta/info.json (total_tasks)
-
-    Args:
-        dataset: The source LeRobotDataset to modify.
-        new_task: A single task string to apply to all episodes. If None and episode_tasks
-            is also None, raises an error.
-        episode_tasks: Optional dict mapping episode indices to their task strings.
-            Overrides `new_task` for specific episodes.
-
-
-    Examples:
-        Set a single task for all episodes:
-            dataset = modify_tasks(dataset, new_task="Pick up the cube")
-
-        Set different tasks for specific episodes:
-            dataset = modify_tasks(
-                dataset,
-                episode_tasks={0: "Task A", 1: "Task B", 2: "Task A"}
-            )
-
-        Set a default task with overrides:
-            dataset = modify_tasks(
-                dataset,
-                new_task="Default task",
-                episode_tasks={5: "Special task for episode 5"}
-            )
-    """
-    if new_task is None and episode_tasks is None:
-        raise ValueError("Must specify at least one of new_task or episode_tasks")
-
-    if episode_tasks is not None:
-        valid_indices = set(range(dataset.meta.total_episodes))
-        invalid = set(episode_tasks.keys()) - valid_indices
-        if invalid:
-            raise ValueError(f"Invalid episode indices: {invalid}")
-
-    # Ensure episodes metadata is loaded
-    if dataset.meta.episodes is None:
-        dataset.meta.episodes = load_episodes(dataset.root)
-
-    # Build the mapping from episode index to task string
-    episode_to_task: dict[int, str] = {}
-    for ep_idx in range(dataset.meta.total_episodes):
-        if episode_tasks and ep_idx in episode_tasks:
-            episode_to_task[ep_idx] = episode_tasks[ep_idx]
-        elif new_task is not None:
-            episode_to_task[ep_idx] = new_task
-        else:
-            # Keep original task if not overridden and no default provided
-            original_tasks = dataset.meta.episodes[ep_idx]["tasks"]
-            if not original_tasks:
-                raise ValueError(f"Episode {ep_idx} has no tasks and no default task was provided")
-            episode_to_task[ep_idx] = original_tasks[0]
-
-    # Collect all unique tasks and create new task mapping
-    unique_tasks = sorted(set(episode_to_task.values()))
-    new_task_df = pd.DataFrame({"task_index": list(range(len(unique_tasks)))}, index=unique_tasks)
-    task_to_index = {task: idx for idx, task in enumerate(unique_tasks)}
-
-    logging.info(f"Modifying tasks in {dataset.repo_id}")
-    logging.info(f"New tasks: {unique_tasks}")
-
-    root = dataset.root
-
-    # Update data files - modify task_index column
-    logging.info("Updating data files...")
-    data_dir = root / DATA_DIR
-
-    for parquet_path in tqdm(sorted(data_dir.rglob("*.parquet")), desc="Updating data"):
-        df = pd.read_parquet(parquet_path)
-
-        # Build a mapping from episode_index to new task_index for rows in this file
-        episode_indices_in_file = df["episode_index"].unique()
-        ep_to_new_task_idx = {
-            ep_idx: task_to_index[episode_to_task[ep_idx]] for ep_idx in episode_indices_in_file
-        }
-
-        # Update task_index column
-        df["task_index"] = df["episode_index"].map(ep_to_new_task_idx)
-        df.to_parquet(parquet_path, index=False)
-
-    # Update episodes metadata - modify tasks column
-    logging.info("Updating episodes metadata...")
-    episodes_dir = root / "meta" / "episodes"
-
-    for parquet_path in tqdm(sorted(episodes_dir.rglob("*.parquet")), desc="Updating episodes"):
-        df = pd.read_parquet(parquet_path)
-
-        # Update tasks column
-        df["tasks"] = df["episode_index"].apply(lambda ep_idx: [episode_to_task[ep_idx]])
-        df.to_parquet(parquet_path, index=False)
-
-    # Write new tasks.parquet
-    write_tasks(new_task_df, root)
-
-    # Update info.json
-    dataset.meta.info["total_tasks"] = len(unique_tasks)
-    write_info(dataset.meta.info, root)
-
-    # Reload metadata to reflect changes
-    dataset.meta.tasks = new_task_df
-    dataset.meta.episodes = load_episodes(root)
-
-    logging.info(f"Tasks: {unique_tasks}")
-
-    return dataset
-
-
-def convert_image_to_video_dataset(
-    dataset: LeRobotDataset,
-    output_dir: Path,
-    repo_id: str | None = None,
-    vcodec: str = "libsvtav1",
-    pix_fmt: str = "yuv420p",
-    g: int = 2,
-    crf: int = 30,
-    fast_decode: int = 0,
-    episode_indices: list[int] | None = None,
-    num_workers: int = 4,
-    max_episodes_per_batch: int | None = None,
-    max_frames_per_batch: int | None = None,
-) -> LeRobotDataset:
-    """Convert image-to-video dataset.
-
-    Creates a new LeRobotDataset with images encoded as videos, following the proper
-    LeRobot dataset structure with videos stored in chunked MP4 files.
-
-    Args:
-        dataset: The source LeRobot dataset with images
-        output_dir: Directory to save the new video dataset
-        repo_id: Repository ID for the new dataset (default: original_id + "_video")
-        vcodec: Video codec (default: libsvtav1)
-        pix_fmt: Pixel format (default: yuv420p)
-        g: Group of pictures size (default: 2)
-        crf: Constant rate factor (default: 30)
-        fast_decode: Fast decode tuning (default: 0)
-        episode_indices: List of episode indices to convert (None = all episodes)
-        num_workers: Number of threads for parallel processing (default: 4)
-        max_episodes_per_batch: Maximum episodes per video batch to avoid memory issues (None = no limit)
-        max_frames_per_batch: Maximum frames per video batch to avoid memory issues (None = no limit)
-
-    Returns:
-        New LeRobotDataset with images encoded as videos
-    """
-    # Check that it's an image dataset
-    if len(dataset.meta.video_keys) > 0:
-        raise ValueError(
-            f"This operation is for image datasets only. Video dataset provided: {dataset.repo_id}"
-        )
-
-    # Get all image keys
-    hf_dataset = dataset.hf_dataset.with_format(None)
-    img_keys = [key for key in hf_dataset.features if key.startswith(OBS_IMAGE)]
-
-    if len(img_keys) == 0:
-        raise ValueError(f"No image keys found in dataset {dataset.repo_id}")
-
-    # Determine which episodes to process
-    if episode_indices is None:
-        episode_indices = list(range(dataset.meta.total_episodes))
-
-    if repo_id is None:
-        repo_id = f"{dataset.repo_id}_video"
-
-    logging.info(
-        f"Converting {len(episode_indices)} episodes with {len(img_keys)} cameras from {dataset.repo_id}"
-    )
-    logging.info(f"Video codec: {vcodec}, pixel format: {pix_fmt}, GOP: {g}, CRF: {crf}")
-
-    # Create new features dict, converting image features to video features
-    new_features = {}
-    for key, value in dataset.meta.features.items():
-        if key not in img_keys:
-            new_features[key] = value
-        else:
-            # Convert image key to video format
-            new_features[key] = value.copy()
-            new_features[key]["dtype"] = "video"  # Change dtype from "image" to "video"
-            # Video info will be updated after episodes are encoded
-
-    # Create new metadata for video dataset
-    new_meta = LeRobotDatasetMetadata.create(
-        repo_id=repo_id,
-        fps=dataset.meta.fps,
-        features=new_features,
-        robot_type=dataset.meta.robot_type,
-        root=output_dir,
-        use_videos=True,
-        chunks_size=dataset.meta.chunks_size,
-        data_files_size_in_mb=dataset.meta.data_files_size_in_mb,
-        video_files_size_in_mb=dataset.meta.video_files_size_in_mb,
-    )
-
-    # Create temporary directory for image extraction
-    temp_dir = output_dir / "temp_images"
-    temp_dir.mkdir(parents=True, exist_ok=True)
-
-    # Process all episodes and batch encode videos
-    # Use dictionary for O(1) episode metadata lookups instead of O(n) linear search
-    all_episode_metadata = {}
-    fps = int(dataset.fps)
-
-    try:
-        # Build episode metadata entries first
-        logging.info("Building episode metadata...")
-        cumulative_frame_idx = 0
-        for ep_idx in episode_indices:
-            src_episode = dataset.meta.episodes[ep_idx]
-            ep_length = src_episode["length"]
-            ep_meta = {
-                "episode_index": ep_idx,
-                "length": ep_length,
-                "dataset_from_index": cumulative_frame_idx,
-                "dataset_to_index": cumulative_frame_idx + ep_length,
-            }
-            if "data/chunk_index" in src_episode:
-                ep_meta["data/chunk_index"] = src_episode["data/chunk_index"]
-                ep_meta["data/file_index"] = src_episode["data/file_index"]
-            all_episode_metadata[ep_idx] = ep_meta
-            cumulative_frame_idx += ep_length
-
-        # Process each camera and batch encode multiple episodes together
-        video_file_size_limit = new_meta.video_files_size_in_mb
-
-        # Pre-compute episode lengths for batching
-        episode_lengths = {ep_idx: dataset.meta.episodes["length"][ep_idx] for ep_idx in episode_indices}
-
-        for img_key in tqdm(img_keys, desc="Processing cameras"):
-            # Estimate size per frame by encoding a small calibration sample
-            # This provides accurate compression ratio for the specific codec parameters
-            size_per_frame_mb = _estimate_frame_size_via_calibration(
-                dataset=dataset,
-                img_key=img_key,
-                episode_indices=episode_indices,
-                temp_dir=temp_dir,
-                fps=fps,
-                vcodec=vcodec,
-                pix_fmt=pix_fmt,
-                g=g,
-                crf=crf,
-                fast_decode=fast_decode,
-            )
-
-            logging.info(f"Processing camera: {img_key}")
-            chunk_idx, file_idx = 0, 0
-            cumulative_timestamp = 0.0
-
-            # Process episodes in batches to stay under size limit
-            for batch_episodes in _iter_episode_batches(
-                episode_indices=episode_indices,
-                episode_lengths=episode_lengths,
-                size_per_frame_mb=size_per_frame_mb,
-                video_file_size_limit=video_file_size_limit,
-                max_episodes=max_episodes_per_batch,
-                max_frames=max_frames_per_batch,
-            ):
-                total_frames_in_batch = sum(episode_lengths[idx] for idx in batch_episodes)
-                logging.info(
-                    f"  Encoding batch of {len(batch_episodes)} episodes "
-                    f"({batch_episodes[0]}-{batch_episodes[-1]}) = {total_frames_in_batch} frames"
-                )
-
-                # Save images for all episodes in this batch
-                imgs_dir = temp_dir / f"batch_{chunk_idx}_{file_idx}" / img_key
-                episode_durations = _save_batch_episodes_images(
-                    dataset=dataset,
-                    imgs_dir=imgs_dir,
-                    img_key=img_key,
-                    episode_indices=batch_episodes,
-                    num_workers=num_workers,
-                )
-
-                # Encode all batched episodes into single video
-                video_path = new_meta.root / new_meta.video_path.format(
-                    video_key=img_key, chunk_index=chunk_idx, file_index=file_idx
-                )
-                video_path.parent.mkdir(parents=True, exist_ok=True)
-
-                encode_video_frames(
-                    imgs_dir=imgs_dir,
-                    video_path=video_path,
-                    fps=fps,
-                    vcodec=vcodec,
-                    pix_fmt=pix_fmt,
-                    g=g,
-                    crf=crf,
-                    fast_decode=fast_decode,
-                    overwrite=True,
-                )
-
-                # Clean up temporary images
-                shutil.rmtree(imgs_dir)
-
-                # Update metadata for each episode in the batch
-                for ep_idx, duration in zip(batch_episodes, episode_durations, strict=True):
-                    from_timestamp = cumulative_timestamp
-                    to_timestamp = cumulative_timestamp + duration
-                    cumulative_timestamp = to_timestamp
-
-                    # Find episode metadata entry and add video metadata (O(1) dictionary lookup)
-                    ep_meta = all_episode_metadata[ep_idx]
-                    ep_meta[f"videos/{img_key}/chunk_index"] = chunk_idx
-                    ep_meta[f"videos/{img_key}/file_index"] = file_idx
-                    ep_meta[f"videos/{img_key}/from_timestamp"] = from_timestamp
-                    ep_meta[f"videos/{img_key}/to_timestamp"] = to_timestamp
-
-                # Move to next video file for next batch
-                chunk_idx, file_idx = update_chunk_file_indices(chunk_idx, file_idx, new_meta.chunks_size)
-                cumulative_timestamp = 0.0
-
-        # Copy and transform data files (removing image columns)
-        _copy_data_without_images(dataset, new_meta, episode_indices, img_keys)
-
-        # Save episode metadata
-        episodes_df = pd.DataFrame(list(all_episode_metadata.values()))
-        episodes_path = new_meta.root / "meta" / "episodes" / "chunk-000" / "file-000.parquet"
-        episodes_path.parent.mkdir(parents=True, exist_ok=True)
-        episodes_df.to_parquet(episodes_path, index=False)
-
-        # Update metadata info
-        new_meta.info["total_episodes"] = len(episode_indices)
-        new_meta.info["total_frames"] = sum(ep["length"] for ep in all_episode_metadata.values())
-        new_meta.info["total_tasks"] = dataset.meta.total_tasks
-        new_meta.info["splits"] = {"train": f"0:{len(episode_indices)}"}
-
-        # Update video info for all image keys (now videos)
-        # We need to manually set video info since update_video_info() checks video_keys first
-        for img_key in img_keys:
-            if not new_meta.features[img_key].get("info", None):
-                video_path = new_meta.root / new_meta.video_path.format(
-                    video_key=img_key, chunk_index=0, file_index=0
-                )
-                new_meta.info["features"][img_key]["info"] = get_video_info(video_path)
-
-        write_info(new_meta.info, new_meta.root)
-
-        # Copy stats and tasks
-        if dataset.meta.stats is not None:
-            # Remove image stats
-            new_stats = {k: v for k, v in dataset.meta.stats.items() if k not in img_keys}
-            write_stats(new_stats, new_meta.root)
-
-        if dataset.meta.tasks is not None:
-            write_tasks(dataset.meta.tasks, new_meta.root)
-
-    finally:
-        # Clean up temporary directory
-        if temp_dir.exists():
-            shutil.rmtree(temp_dir)
-
-    logging.info(f"Completed converting {dataset.repo_id} to video format")
-    logging.info(f"New dataset saved to: {output_dir}")
-
-    # Return new dataset
-    return LeRobotDataset(repo_id=repo_id, root=output_dir)
@@ -57,7 +57,6 @@ from lerobot.datasets.utils import (
    load_info,
    load_nested_dataset,
    load_stats,
-    load_subtasks,
    load_tasks,
    update_chunk_file_indices,
    validate_episode_buffer,
@@ -79,7 +78,6 @@ from lerobot.datasets.video_utils import (
 from lerobot.utils.constants import HF_LEROBOT_HOME

 CODEBASE_VERSION = "v3.0"
-VALID_VIDEO_CODECS = {"h264", "hevc", "libsvtav1"}


 class LeRobotDatasetMetadata:
@@ -163,7 +161,6 @@ class LeRobotDatasetMetadata:
        self.info = load_info(self.root)
        check_version_compatibility(self.repo_id, self._version, CODEBASE_VERSION)
        self.tasks = load_tasks(self.root)
-        self.subtasks = load_subtasks(self.root)
        self.episodes = load_episodes(self.root)
        self.stats = load_stats(self.root)

@@ -520,7 +517,6 @@ class LeRobotDatasetMetadata:
        _validate_feature_names(features)

        obj.tasks = None
-        obj.subtasks = None
        obj.episodes = None
        obj.stats = None
        obj.info = create_empty_dataset_info(
@@ -544,13 +540,11 @@ class LeRobotDatasetMetadata:
        return obj


-def _encode_video_worker(
-    video_key: str, episode_index: int, root: Path, fps: int, vcodec: str = "libsvtav1"
-) -> Path:
+def _encode_video_worker(video_key: str, episode_index: int, root: Path, fps: int) -> Path:
    temp_path = Path(tempfile.mkdtemp(dir=root)) / f"{video_key}_{episode_index:03d}.mp4"
    fpath = DEFAULT_IMAGE_PATH.format(image_key=video_key, episode_index=episode_index, frame_index=0)
    img_dir = (root / fpath).parent
-    encode_video_frames(img_dir, temp_path, fps, vcodec=vcodec, overwrite=True)
+    encode_video_frames(img_dir, temp_path, fps, overwrite=True)
    shutil.rmtree(img_dir)
    return temp_path

@@ -569,7 +563,6 @@ class LeRobotDataset(torch.utils.data.Dataset):
        download_videos: bool = True,
        video_backend: str | None = None,
        batch_encoding_size: int = 1,
-        vcodec: str = "libsvtav1",
    ):
        """
        2 modes are available for instantiating this class, depending on 2 different use cases:
@@ -656,7 +649,7 @@ class LeRobotDataset(torch.utils.data.Dataset):
            repo_id (str): This is the repo id that will be used to fetch the dataset. Locally, the dataset
                will be stored under root/repo_id.
            root (Path | None, optional): Local directory to use for downloading/writing files. You can also
-                set the HF_LEROBOT_HOME environment variable to point to a different location. Defaults to
+                set the LEROBOT_HOME environment variable to point to a different location. Defaults to
                '~/.cache/huggingface/lerobot'.
            episodes (list[int] | None, optional): If specified, this will only load episodes specified by
                their episode_index in this list. Defaults to None.
@@ -682,13 +675,8 @@ class LeRobotDataset(torch.utils.data.Dataset):
                You can also use the 'pyav' decoder used by Torchvision, which used to be the default option, or 'video_reader' which is another decoder of Torchvision.
            batch_encoding_size (int, optional): Number of episodes to accumulate before batch encoding videos.
                Set to 1 for immediate encoding (default), or higher for batched encoding. Defaults to 1.
-            vcodec (str, optional): Video codec for encoding videos during recording. Options: 'h264', 'hevc',
-                'libsvtav1'. Defaults to 'libsvtav1'. Use 'h264' for faster encoding on systems where AV1
-                encoding is CPU-heavy.
        """
        super().__init__()
-        if vcodec not in VALID_VIDEO_CODECS:
-            raise ValueError(f"Invalid vcodec '{vcodec}'. Must be one of: {sorted(VALID_VIDEO_CODECS)}")
        self.repo_id = repo_id
        self.root = Path(root) if root else HF_LEROBOT_HOME / repo_id
        self.image_transforms = image_transforms
@@ -700,7 +688,6 @@ class LeRobotDataset(torch.utils.data.Dataset):
        self.delta_indices = None
        self.batch_encoding_size = batch_encoding_size
        self.episodes_since_last_encoding = 0
-        self.vcodec = vcodec

        # Unused attributes
        self.image_writer = None
@@ -938,30 +925,17 @@ class LeRobotDataset(torch.utils.data.Dataset):
        else:
            return get_hf_features_from_features(self.features)

-    def _get_query_indices(
-        self, abs_idx: int, ep_idx: int
-    ) -> tuple[dict[str, list[int]], dict[str, torch.Tensor]]:
-        """Compute query indices for delta timestamps.
-
-        Args:
-            abs_idx: The absolute index in the full dataset (not the relative index in filtered episodes).
-            ep_idx: The episode index.
-
-        Returns:
-            A tuple of (query_indices, padding) where:
-            - query_indices: Dict mapping keys to lists of absolute indices to query
-            - padding: Dict mapping "{key}_is_pad" to boolean tensors indicating padded positions
-        """
+    def _get_query_indices(self, idx: int, ep_idx: int) -> tuple[dict[str, list[int | bool]]]:
        ep = self.meta.episodes[ep_idx]
        ep_start = ep["dataset_from_index"]
        ep_end = ep["dataset_to_index"]
        query_indices = {
-            key: [max(ep_start, min(ep_end - 1, abs_idx + delta)) for delta in delta_idx]
+            key: [max(ep_start, min(ep_end - 1, idx + delta)) for delta in delta_idx]
            for key, delta_idx in self.delta_indices.items()
        }
        padding = {  # Pad values outside of current episode range
            f"{key}_is_pad": torch.BoolTensor(
-                [(abs_idx + delta < ep_start) | (abs_idx + delta >= ep_end) for delta in delta_idx]
+                [(idx + delta < ep_start) | (idx + delta >= ep_end) for delta in delta_idx]
            )
            for key, delta_idx in self.delta_indices.items()
        }
@@ -1053,12 +1027,10 @@ class LeRobotDataset(torch.utils.data.Dataset):
        self._ensure_hf_dataset_loaded()
        item = self.hf_dataset[idx]
        ep_idx = item["episode_index"].item()
-        # Use the absolute index from the dataset for delta timestamp calculations
-        abs_idx = item["index"].item()

        query_indices = None
        if self.delta_indices is not None:
-            query_indices, padding = self._get_query_indices(abs_idx, ep_idx)
+            query_indices, padding = self._get_query_indices(idx, ep_idx)
            query_result = self._query_hf_dataset(query_indices)
            item = {**item, **padding}
            for key, val in query_result.items():
@@ -1078,12 +1050,6 @@ class LeRobotDataset(torch.utils.data.Dataset):
        # Add task as a string
        task_idx = item["task_index"].item()
        item["task"] = self.meta.tasks.iloc[task_idx].name
-
-        # add subtask information if available
-        if "subtask_index" in self.features and self.meta.subtasks is not None:
-            subtask_idx = item["subtask_index"].item()
-            item["subtask"] = self.meta.subtasks.iloc[subtask_idx].name
-
        return item

    def __repr__(self):
@@ -1245,7 +1211,6 @@ class LeRobotDataset(torch.utils.data.Dataset):
                            episode_index,
                            self.root,
                            self.fps,
-                            self.vcodec,
                        ): video_key
                        for video_key in self.meta.video_keys
                    }
@@ -1522,7 +1487,7 @@ class LeRobotDataset(torch.utils.data.Dataset):
            episode_index = self.episode_buffer["episode_index"]
            if isinstance(episode_index, np.ndarray):
                episode_index = episode_index.item() if episode_index.size == 1 else episode_index[0]
-            for cam_key in self.meta.image_keys:
+            for cam_key in self.meta.camera_keys:
                img_dir = self._get_image_file_dir(episode_index, cam_key)
                if img_dir.is_dir():
                    shutil.rmtree(img_dir)
@@ -1561,7 +1526,7 @@ class LeRobotDataset(torch.utils.data.Dataset):
        Note: `encode_video_frames` is a blocking call. Making it asynchronous shouldn't speedup encoding,
        since video encoding with ffmpeg is already using multithreading.
        """
-        return _encode_video_worker(video_key, episode_index, self.root, self.fps, self.vcodec)
+        return _encode_video_worker(video_key, episode_index, self.root, self.fps)

    @classmethod
    def create(
@@ -1577,11 +1542,8 @@ class LeRobotDataset(torch.utils.data.Dataset):
        image_writer_threads: int = 0,
        video_backend: str | None = None,
        batch_encoding_size: int = 1,
-        vcodec: str = "libsvtav1",
    ) -> "LeRobotDataset":
        """Create a LeRobot Dataset from scratch in order to record data."""
-        if vcodec not in VALID_VIDEO_CODECS:
-            raise ValueError(f"Invalid vcodec '{vcodec}'. Must be one of: {sorted(VALID_VIDEO_CODECS)}")
        obj = cls.__new__(cls)
        obj.meta = LeRobotDatasetMetadata.create(
            repo_id=repo_id,
@@ -1598,7 +1560,6 @@ class LeRobotDataset(torch.utils.data.Dataset):
        obj.image_writer = None
        obj.batch_encoding_size = batch_encoding_size
        obj.episodes_since_last_encoding = 0
-        obj.vcodec = vcodec

        if image_writer_processes or image_writer_threads:
            obj.start_image_writer(image_writer_processes, image_writer_threads)
@@ -18,12 +18,12 @@ from typing import Any

 from lerobot.configs.types import PipelineFeatureType
 from lerobot.datasets.utils import hw_to_dataset_features
-from lerobot.processor import DataProcessorPipeline, RobotAction, RobotObservation
+from lerobot.processor import DataProcessorPipeline
 from lerobot.utils.constants import ACTION, OBS_IMAGES, OBS_STATE, OBS_STR


 def create_initial_features(
-    action: RobotAction | None = None, observation: RobotObservation | None = None
+    action: dict[str, Any] | None = None, observation: dict[str, Any] | None = None
 ) -> dict[PipelineFeatureType, dict[str, Any]]:
    """
    Creates the initial features dict for the dataset from action and observation specs.
@@ -216,17 +216,16 @@ class ImageTransformsConfig:


 def make_transform_from_config(cfg: ImageTransformConfig):
-    if cfg.type == "SharpnessJitter":
+    if cfg.type == "Identity":
+        return v2.Identity(**cfg.kwargs)
+    elif cfg.type == "ColorJitter":
+        return v2.ColorJitter(**cfg.kwargs)
+    elif cfg.type == "SharpnessJitter":
        return SharpnessJitter(**cfg.kwargs)
-
-    transform_cls = getattr(v2, cfg.type, None)
-    if isinstance(transform_cls, type) and issubclass(transform_cls, Transform):
-        return transform_cls(**cfg.kwargs)
-
-    raise ValueError(
-        f"Transform '{cfg.type}' is not valid. It must be a class in "
-        f"torchvision.transforms.v2 or 'SharpnessJitter'."
-    )
+    elif cfg.type == "RandomAffine":
+        return v2.RandomAffine(**cfg.kwargs)
+    else:
+        raise ValueError(f"Transform '{cfg.type}' is not valid.")


 class ImageTransforms(Transform):
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Pepijn	56fd0ef378	run precommit and fix issues	2025-12-22 14:50:58 +01:00
Pepijn	486c52c14b	Merge branch 'main' into feature/basic-peft-support	2025-12-22 14:29:51 +01:00
nemo	ad4a82b77e	Add peft as extra dependency, mark tests Fast tests currently fail because of the missing dependency.	2025-12-20 19:20:12 +01:00
nemo	4bc75776f7	Formatting	2025-12-20 19:18:56 +01:00
nemo	43ca1dc216	Merge remote-tracking branch 'hf/main' into feature/basic-peft-support	2025-12-19 12:23:37 +01:00
nemo	6a9dac7c20	Add basic documentation	2025-12-19 12:20:50 +01:00
nemo	54c25a4400	Disallow PEFT training on non-pretrained policies At first I thought it would make sense to have this feature in case you want to fine-tune a pre-trained section but in the end it makes more trouble than it's worth. It's still possible to allow this in the future when a concrete need arises.	2025-12-19 11:50:29 +01:00
nemo	e01927f641	Merge remote-tracking branch 'hf/main' into feature/basic-peft-support	2025-12-16 18:35:11 +01:00
nemo	3bc557552b	Adapt state/action projections instead of full-finetuning There doesn't seem to be a benefit to fully fine-tune these layers over just adapting them, so we do that instead.	2025-12-16 18:31:25 +01:00
nemo	51876e7f55	Add test checking that PEFT actually reduces params	2025-12-16 17:58:27 +01:00
nemo	9649f140ca	Make it possible to use PeftModels in eval	2025-12-16 17:57:03 +01:00
nemo	76e64521c2	Use correct loading for PEFT in RTC example	2025-12-05 14:26:30 +01:00
nemo	f5bf6bb028	Make it possible to unset policy features This is necessary to train pre-trained policies on new datasets so that the features are inferred from the new dataset and not from the pretrained policy.	2025-12-05 12:48:07 +01:00
nemo	75266860aa	Revamp pretrained model loading There were quite a few factors that convinced me that the status quo is able to load pretrained models from the PEFT adapter config but in fact that didn't work. This commit fixes the following things: - policies wrapped in PEFT will now have a `name_or_path` attribute containing the name or path of the pretrained model we're fine-tuning - we further assume that SmolVLA without `pretrained_path` and `load_vlm_weights==False` must be an user-side error - we assume that using PEFT on from-scratch-policies must be an user-side-error	2025-12-01 18:30:45 +01:00
nemo	e0b6aca97a	Merge remote-tracking branch 'hf/main' into feature/basic-peft-support	2025-11-28 19:00:16 +01:00
nemo	abfed126ff	Warn when encountering from-scratch-training	2025-11-28 18:18:00 +01:00
nemo	e544562c39	formatting	2025-11-24 18:52:18 +01:00
nemo	83aac1b42e	Make sure push_to_hub works Since PEFT only wraps `push_to_hub` and not `push_model_to_hub`, the reference to `self` in `policy.push_model_to_hub` is the unwrapped policy which, of course, doesn't know anything about PEFT. To make the upload process aware of PEFT, we pass the unwrapped policy down to `push_model_to_hub` as a kwarg. This is not ideal but I think it is the best way for now.	2025-11-24 18:50:02 +01:00
nemo	e9b3889bd2	Clean up loading code - Centralized instantiation of the PEFT wrapper in `make_policy` for inference (e.g. in `lerobot-record`) - Training a PEFT policy also sets `cfg.use_peft` so that all inference code loading the policy can rely on that attribute to identify if PEFT loading is needed - Modified RTC example to also include PEFT policies. Mostly because this is an example I'm currently exploring.	2025-11-24 15:30:26 +01:00
nemo	841c76c7d3	Merge remote-tracking branch 'hf/main' into feature/basic-peft-support	2025-11-21 17:37:15 +01:00
nemo	356f2a6150	Merge remote-tracking branch 'origin/main' into feature/basic-peft-support	2025-11-21 11:29:33 +01:00
nemo	de34e876cc	Update default targets Removed ACT since it doesn't make sense to fine-tune ACT without having it pretrained beforehand. SmolVLA and Pi0/0.5 are much more senseful targets.	2025-10-16 16:13:41 +02:00
nemo	7f42338ae9	Add CLI end-to-end tests Currently there don't seem to be any way to test the CLI commands. Since this change mostly happens in those I thought it best to add a way to test these commands end-to-end. More integrated commands like `lerobot-record` need patching but standalone commands like training seem to work fine.	2025-10-16 16:08:20 +02:00
nemo	6c2fd8970c	Correct way of identifying when to save config	2025-10-16 16:07:22 +02:00
nemo	6fb8539159	Don't unload & merge the PEFT model This can make things hard when using quantized layers (user expects quantized base layers with unquantized adapters for example, merging defaults to upcast the layers leading to higher memory).	2025-10-16 16:06:23 +02:00
nemo	e263a1de13	Better documentation for CLI arguments	2025-10-16 14:39:43 +02:00
nemo	d39e7f0bc4	Log adapter config to WandB	2025-10-14 15:36:06 +02:00
nemo	20d4b5d347	Remove `use_peft` parameter from training script Instead we make the PEFT config optional which has the same effect.	2025-10-14 15:35:38 +02:00
nemo	02408fb244	Remove PEFT compatibility changes in config We'll wait for the PEFT release that fixes this for good.	2025-10-13 16:32:04 +02:00
nemo	390bfffa92	Merge remote-tracking branch 'hf/main' into feature/basic-peft-support	2025-10-09 11:30:55 +02:00
nemo	8a9be85306	Fix failing tests	2025-07-14 16:45:11 +02:00
nemo	57014e5bb1	Merge branch 'main' of github.com:huggingface/lerobot into feature/basic-peft-support	2025-07-08 11:23:40 +02:00
pre-commit-ci[bot]	354d118407	[pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci	2025-06-30 13:40:19 +00:00
nemo	72d02feef4	Formatting	2025-06-30 15:33:51 +02:00
nemo	4788434d9f	Support targets like `all-linear`	2025-06-30 15:33:13 +02:00
nemo	56e7979cfd	Add default config for ACT	2025-06-27 19:27:08 +02:00
nemo	44245e714e	Merge branch 'main' of github.com:huggingface/lerobot into feature/basic-peft-support	2025-06-27 13:55:07 +02:00
nemo	dc67b2ff3f	Store policy config alongside PEFT checkpoint Before this change the PEFT-wrapped policy did not save the policy's config alongside the adapter config / weights which prevented us from changing the policy config. Now the policy config is saved both in full training and PEFT training. This change makes loading the PEFT policy adapter much easier as well.	2025-06-22 19:54:10 +02:00
nemo	7fd8b4c773	Implement loading of PEFT adapters Loading a PEFT adapter is currently done by initializing a policy with default config and then applying the adapter on the resulting model. This has the obvious drawback that any configurations done during training are not applied in the adapted model. Currently the `use_peft` attribute of `PreTrainedConfig` is only set during loading to signal the following code that it has to deal with a PEFT adapter. However we could imagine a scenario where this is already set at training time and stored alongside the adapter.	2025-06-22 19:10:10 +02:00
nemo	98856662c1	Add basic support for PEFT adapter methods This changes adds support for training policies with much less parameters by applying adapter methods such as LoRA on specific parts of the policies and therefore possibly higher learning rates / batch sizes. To make this as accessible as possible I thought it useful to provide defaults for `target_modules` and `modules_to_save`. Currently only SmolVLA has such defaults but when we agree that this change is useful I will set out to generate more such defaults. While the user can override these settings, they are expected to only change the peft_method, rank and init_type parameters.	2025-06-22 13:45:07 +02:00