README.md

---
language:
  - en
  - zh
license: other
license_name: mit-and-upstream-terms
license_link: https://huggingface.co/datasets/uooon/LIBERO-GeoMotion/blob/main/THIRD_PARTY_NOTICES/NOTICE
tags:
  - robotics
  - simulation
  - manipulation
pretty_name: LIBERO-GeoMotion
---

<h1 align="center">LIBERO-GeoMotion</h1>

<p align="center"><strong>English</strong> | <a href="https://huggingface.co/datasets/uooon/LIBERO-GeoMotion/blob/main/README.zh-CN.md">简体中文</a></p>

<p align="center">
  <strong>A simulation benchmark for geometry-constrained robot manipulation</strong><br>
  36 fixed scenes · 9 task families · 6 expert demonstrations
</p>

<p align="center">
  <a href="#installation">Installation</a> ·
  <a href="#verify-your-installation">Verify your installation</a> ·
  <a href="#python-api">Python API</a> ·
  <a href="#evaluation">Evaluation</a> ·
  <a href="#troubleshooting">Troubleshooting</a>
</p>

Welcome to **LIBERO-GeoMotion**! This repository provides a standalone LIBERO-based environment for evaluating robot manipulation under geometric constraints: moving through narrow passages, placing objects with a required orientation, avoiding obstacles, and closing drawers or cabinet doors after storage.

LIBERO-GeoMotion was introduced in our paper [Large Multimodal Models for Direct Robot Control: GPT-6 as a Beginning](https://arxiv.org/abs/2610.28259). See the [GPT-GEAR repository](https://github.com/6UOOON9/GPT-GEAR) for the accompanying robot control and evaluation framework.

The distribution includes the simulation runtime, scene definitions, required base assets, fixed initial states, and six expert demonstrations. **You can install and run it directly, without a separate LIBERO-plus checkout or asset download.** MuJoCo, robosuite, and other Python dependencies are installed by pip.

Start with one scene to check your installation, then run the full scene checks or connect your own policy through the Python API.

<a id="installation"></a>

## 🔧 Installation

### 1. Prepare the system

| Component | Requirement |
|---|---|
| Operating system | Linux; the system package commands below target Ubuntu / Debian |
| Python | **3.12**; the package requires `>=3.12,<3.13` |
| Python environment | A dedicated virtual environment to keep simulator dependencies separate |
| Default rendering | OSMesa for offscreen rendering without a display or GPU |
| Optional GPU rendering | EGL with a working GPU driver and EGL runtime |

Install the OSMesa and ImageMagick system libraries:

```bash
sudo apt-get update
sudo apt-get install -y libosmesa6 libmagickwand-dev
```

OSMesa provides the default rendering backend; ImageMagick is used by the bundled image-processing code through Wand. These system libraries are required in addition to the Python packages.

The following steps assume `python3.12` is available and supports `venv`. If your distribution packages virtual-environment support separately, install its matching `python3.12-venv` package first.

### 2. Install the environment

Download or clone this repository, open a terminal in its root directory, and run:

```bash
python3.12 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install -e . -c constraints-tested.txt
geomotion --help
```

[`constraints-tested.txt`](constraints-tested.txt) records the validated Linux dependency versions. Passing it with `-c` constrains the packages needed by this project; it does not install every package listed in the file. The editable install (`-e .`) uses the code and assets in this checkout, so keep the repository in place.

In each new terminal, run `source .venv/bin/activate` again from the repository root. This distribution provides the `libero` Python namespace; keep other LIBERO installations in separate environments.

<a id="verify-your-installation"></a>

## ✅ Verify your installation

### 1. Check installation

```bash
geomotion doctor
```

The command loads the task suite and reports dependency versions. A successful JSON result contains `"passed": true`, `"tasks": 36`, and reference IDs `[0, 4, 8, 26, 28, 34]`. It does not create a simulation scene or test rendering.

### 2. Run your first scene

```bash
geomotion smoke --ids 0
```

This creates task 0, restores its fixed initial state, checks both 256 × 256 camera images, and executes one action. A successful result contains `"passed": true`, `"initial_state_error": 0.0`, and an `elapsed_seconds` value close to `0.05` (20 Hz control).

**No viewer window opens:** the check renders offscreen. `success_after_one_step` reports task completion after that single action; `false` is normal and does not mean the installation failed.

### 3. Check all scenes and replay the experts

Once the first scene works, you can run the broader checks:

```bash
geomotion smoke --ids all --output validation/smoke.json
geomotion replay-experts --ids all --output validation/experts.json
```

The smoke command checks all 36 scenes. Expert replay checks the **six included demonstrations**, verifies their initial states, and executes their recorded actions through the simulator. Each successful replay reports `"success": true`. Replay takes longer than a single smoke check and runs without camera observations.

Use comma-separated IDs for a smaller selection, such as `geomotion smoke --ids 0,4,8`. For `replay-experts`, only IDs `0,4,8,26,28,34` are available. The optional `--output` writes a JSON report after a successful check.

### Optional: use GPU rendering

The CLI defaults to OSMesa. If your machine has a working EGL setup, select it explicitly:

```bash
geomotion smoke --ids 0 --renderer egl
```

In Python, use `geomotion.make_env(0, renderer="egl")` before importing MuJoCo or other OpenGL-dependent modules. Switch renderers in a fresh process; in a notebook, restart the kernel first.

<a id="python-api"></a>

## 🐍 Python API

This minimal example loads one scene, prints its instruction and image shapes, executes one stationary command with the gripper open, and closes the environment:

```python
import geomotion

suite = geomotion.get_suite()
print("Tasks:", suite.n_tasks)
print("Instruction:", suite.get_task(0).language)

env, obs = geomotion.make_env(0)
try:
    print("Agent view:", obs["agentview_image"].shape)          # (256, 256, 3)
    print("Wrist view:", obs["robot0_eye_in_hand_image"].shape)  # (256, 256, 3)
    action = [0, 0, 0, 0, 0, 0, -1]
    obs, reward, done, info = env.step(action)
    print("Task success:", bool(env.check_success()))
finally:
    env.close()
```

For policy evaluation, replace the example action with your policy output and repeat for at most **4,000 actions**, stopping as soon as `env.check_success()` is true. The example action only exercises the interface; it is not a task-solving policy.

Actions are seven native `OSC_POSE` control values in `[-1, 1]`: three translation components, three rotation components, and one gripper command (`-1` opens; `+1` closes). Use `geomotion.make_env(task_id)` for each new episode to restore the packaged initial state. Calling bare `env.reset()` does not restore that state.

By default, runtime configuration is written under `~/.cache/libero-geomotion/` (or `$XDG_CACHE_HOME/libero-geomotion/`), in a directory specific to the installation. You can set `config_dir` in `make_env()` to choose another directory. If `LIBERO_CONFIG_PATH` is already set, the runtime uses that directory unless `config_dir` is supplied.

<a id="evaluation"></a>

## 📐 Tasks and evaluation

Task IDs are fixed from **0 to 35**. The published suite is `libero_rp`.

| Task family | Task IDs |
|---|---|
| Narrow-Passage Transport | 0–3 |
| Upright Book Placement | 4–7 |
| Oriented Bottle Placement | 8–11 |
| Plate Pushing Around Obstacles | 12–15 |
| Book Storage in a Drawer | 16–19 |
| Single-Mug Alignment and Closure | 20–23 |
| Mango Transport and Avoidance | 24–27 |
| Package Storage and Drawer Closure | 28–33 |
| Dual-Mug Alignment and Closure | 34–35 |

The default evaluation settings are:

| Setting | Value |
|---|---|
| Robot and controller | Panda, delta `OSC_POSE` |
| Initialization | Fixed initial state 0, seed 0, no warmup steps |
| Control frequency | 20 Hz |
| RGB observations | `agentview` and `robot0_eye_in_hand`, each 256 × 256 |
| Episode budget | 4,000 native actions |
| Termination | Stop on `env.check_success()` or the action budget; do not rely on `done` |

Success uses the official task predicates, including placement, orientation, release, stability, door/drawer state, and task-specific process or safety constraints. Simulator geometry, object poses, and predicate internals are evaluator-only information; policy inputs are the task instruction, camera images, robot proprioception, and explicitly selected references.

Report per-scene and per-family success, and distinguish the overall scene mean from the family macro-average because family sizes differ. See the [`evaluation_protocol.json`](geomotion/resources/evaluation_protocol.json), [`task_families.json`](geomotion/resources/task_families.json), and [task manifest](libero_rotation_planning/benchmark/task_manifest.json) for the complete settings and task descriptions.

## 🎬 Expert demonstrations

The suite contains **9 task families: 6 have one reference demonstration each, and 3 have no reference demonstration**. The six demonstrations are bundled under [`geomotion/resources/expert_reference/`](geomotion/resources/expert_reference/), for scene IDs **0, 4, 8, 26, 28, and 34**. Each matches its own test scene's fixed initial state. The 3 families without reference demonstrations are **Plate Pushing Around Obstacles, Book Storage in a Drawer, and Single-Mug Alignment and Closure**. Make the reference selection explicit when reporting evaluation results.

To export the included HDF5 demonstrations into portable videos, text, and trajectories:

```bash
geomotion export-references --ids all --output ./geomotion-references-256
```

Each `task_NNN/` directory contains lossless `agentview.mp4` and `wrist.mp4`, each 256 × 256, `videos.json`, `trajectory.json` / `trajectory.jsonl`, and the original expert instructions (`steps.md`). Export renders every saved pre-action state at the evaluation resolution and reconstructs grip-site poses without stepping physics. The final trajectory record has a null action.

Use `--ids 0,4` to export a subset. Existing `task_NNN/` directories are never overwritten; choose a new output directory for another export.

In the packaged HDF5 demonstrations, observations and simulator states precede each paired action; rewards and success flags follow it. Runtime scene loading uses the packaged BDDL and assets. The six files in `expert_reference/text/` contain demonstration steps and measured keypoints, and supply the exported `steps.md`.

<a id="troubleshooting"></a>

## 🛠️ Troubleshooting

| Symptom | What to check |
|---|---|
| pip rejects the Python version | Run `python --version` inside the active environment. This release requires Python 3.12. |
| `geomotion: command not found` | Activate `.venv` and repeat the editable install with that environment's `python -m pip`. You can also use `python -m geomotion.cli --help`. |
| OSMesa cannot load, or OpenGL initialization fails | Check that `libosmesa6` is installed in the system or container running Python. Try `geomotion smoke --ids 0 --renderer osmesa` in a fresh process. |
| Wand cannot find ImageMagick / MagickWand | Install `libmagickwand-dev` in the system or container running Python. |
| EGL initialization fails | Check the GPU driver and EGL availability inside the runtime. Use `--renderer osmesa` to run without GPU rendering. |
| `renderer is already initialized` or `LIBERO config already initialized` | Start a fresh Python process or restart the notebook kernel, and configure GeoMotion before importing the simulator. |
| Expert ID is rejected | Replay and export support only `0,4,8,26,28,34`; smoke checks support all IDs from 0 to 35. |

When reporting a problem, include the command you ran, the full traceback, your OS and Python version, the selected renderer, and the `geomotion doctor` output if it runs successfully. This makes installation issues easier to reproduce.

## 📦 Building a wheel (optional)

For an installation that does not depend on the source checkout, build a wheel from the repository root:

```bash
python -m pip install build
python -m build
```

Install the resulting wheel in a fresh Python 3.12 environment with `python -m pip install /path/to/libero_geomotion-0.3.0-py3-none-any.whl`. The wheel includes the packaged scene assets and demonstrations. The system libraries from the installation section are still needed; rerun `geomotion doctor` and `geomotion smoke --ids 0` after installation.

## 🤝 Acknowledgments

We thank the [official LIBERO-Plus repository](https://github.com/sylvestf/LIBERO-plus) for the simulation runtime and assets.

New code and documentation use the [MIT license](LICENSE); bundled upstream code and assets retain their [third-party notices](THIRD_PARTY_NOTICES/NOTICE).

## 📖 Citation

If you use LIBERO-GeoMotion in your research, please cite our paper [Large Multimodal Models for Direct Robot Control: GPT-6 as a Beginning](https://arxiv.org/abs/2610.28259):

```bibtex
@misc{zhou2026largemultimodalmodelsdirect,
  title={Large Multimodal Models for Direct Robot Control: GPT-6 as a Beginning},
  author={Youwei Zhou and Bohan Hou and Yankai Fu and Yaoxu Lyu and Yifan Ye and Shilin Shan and Chen Guo and Jiaming Liu and Ran He and Caifeng Shan and Shanghang Zhang and Jianfei Yang and Zhihe Lu},
  year={2026},
  eprint={2610.28259},
  archivePrefix={arXiv},
  primaryClass={cs.RO},
  url={https://arxiv.org/abs/2610.28259}
}
```