RoboVerse and MetaSim: installation and platform boundaries

RoboVerse combines MetaSim with robot learning content

RoboVerse addresses the fragmentation that appears when a robot learning project must assemble simulation, assets, tasks, policies, and evaluation code separately. Its intended users are Python developers working with imitation learning, reinforcement learning, VLA models, motion planning, and simulation. The project presents itself as a unified platform, dataset, and benchmark for scalable and generalizable robot learning, while the repository layout shows a concrete implementation split.

There are two packages in the main repository. `packages/metasim/` contains the simulation core, published as `roboverse-metasim` and imported as `metasim`. The repository root provides `roboverse-py`, which contains content, learning code, and examples. These packages are released together from one tag, but installation order matters because the root package declares a dependency on `roboverse-metasim`.

This structure is more useful than presenting RoboVerse as one undifferentiated Python module. A team can inspect the simulation core separately from tasks and learning code, while the documented installation installs both layers for normal use. It also creates boundaries. MetaSim has its own handlers, scenario configuration, task registry, tests, and documentation, whereas RoboVerse content includes robots, tasks, scenes, grounds, queries, and randomization.

MetaSim handlers and scenario data connect simulation backends

The repository identifies MetaSim as the simulation layer and places simulator handlers and scenario configuration beneath `packages/metasim/`. It also describes a task registry. Together, those components indicate that simulations are not isolated scripts: backend-specific handling is combined with structured scenario and task definitions.

The broader repository includes `examples/0_static_scene.py`, followed later by examples for robot control, adding a robot, parallel environments, motion planning, hybrid simulation, advanced rendering, multiple robots, multi-agent datasets, task configuration, camera mounting, lighting, domain randomization, real assets, Gaussian-splatting backgrounds, and EmbodiedGen layouts. That sequence exposes concrete layers of use. A user can begin with a static scene before introducing controllable robots, concurrency, external planners, or rendering features.

`roboverse_learn/` holds RL, IL, and VLA training and evaluation code. This keeps learning workflows separate from the simulator package, although they share the installed MetaSim layer. The `tools/` directory adds maintained integrations for LIBERO, ManiSkill, mjlab, robosuite, RoboTwin, and EmbodiedGen, along with a dashboard and asset upload utilities.

The README names Isaac Lab, Isaac Gym, MuJoCo, SAPIEN, PyBullet, Genesis, cuRobo, PyRep, and Blender as frameworks, renderers, or libraries used by the project. It does not claim that every example uses every backend, so backend support should be checked in the MetaSim documentation for the exact simulator under consideration.

Installing both packages with the README command

The README instructs users to clone the repository and install MetaSim before RoboVerse. This is an editable install, appropriate for working against the checked-out source rather than consuming only published wheels.

The documented installation command clones the repository, changes into its directory, and installs both packages with the `mujoco` extras.

git clone https://github.com/RoboVerseOrg/RoboVerse.git
cd RoboVerse
python -m pip install -e "packages/metasim[mujoco]" -e ".[mujoco]"   # MetaSim first, then RoboVerse

The root `pyproject.toml` requires Python `>=3.10,<3.13`, so use Python 3.10, 3.11, or 3.12. It identifies the root distribution as `roboverse-py` at version `1.0.0b0`, which is a beta version. The dependency declaration currently requires `roboverse-metasim>=1.0.0b0,<1.1`.

For development, the README provides a separate installation command. It adds the `dev`, `examples`, and `mujoco` extras to both packages.

python -m pip install -e "packages/metasim[dev,examples,mujoco]" -e ".[dev,mujoco]"

The installation order is part of the documented procedure because MetaSim is the simulation dependency consumed by `roboverse-py`. Simulator-specific details are delegated to the MetaSim documentation rather than repeated in the top-level README.

The documented tutorial begins with a static scene

The first repository example is `examples/0_static_scene.py`. The README directs users to the static-scene quick-start tutorial, but it does not provide a separate shell command for running that file or publish expected console output for it.

The numbered examples establish an intended progression. After the static scene, the repository includes `examples/1_control_robot.py`, `examples/2_add_new_robot.py`, and `examples/3_parallel_envs.py`. Users can inspect scene construction before moving into robot control and parallel environments.

For contributors, the README documents this test entry point. It runs the RoboVerse content and integration tests under `tests/`.

pytest tests/

The root project puts `pytest` and `pytest-cov` in its `dev` extra, so the development installation is the appropriate starting point for contributors. The README does not document a test matrix across all supported simulators, so a local test success should not be treated as proof that every optional backend is installed correctly.

Optional extras expose the platform's maintenance cost

The dependency surface is larger than the basic install. The root `pyproject.toml` separates dependencies into groups including `assets`, `examples`, `learn`, `sensors`, `vla`, and simulator-related extras such as `genesis`, `isaacgym`, and `isaacsim`. MetaSim also has its own optional dependency mechanism, as shown by the `mujoco` extra in the installation command.

That design is useful when a team needs only simulation and basic content. Installing every learning and backend extra is a different proposition because it adds packages associated with data formats, visualization, model training, assets, and simulator runtimes. The source does not provide a single universal environment specification for every integration, and the README explicitly sends users to simulator-specific MetaSim installation documentation.

Maintenance is active by the repository's push history. The repository is not archived, and the last push was on 2026-10-12. The most recent listed releases are pre-releases: `v1.0.0-alpha` on 2025-08-31 and `v0.1.0-beta` on 2025-08-10. Those labels matter because installation and API compatibility should be checked against the relevant package versions rather than inferred from the platform description.

The repository is also being reorganized. The README says developer scripts in `scripts/` are being consolidated into `tools/`. Script paths, integration utilities, and dependency groups may therefore be review points during adoption.

MetaSim alone is the narrower alternative for simulator work

The clearest alternative is to adopt `roboverse-metasim` without the full `roboverse-py` package. Both live in this repository, but they solve different scopes. MetaSim provides simulator handlers, scenario configuration, a task registry, tests, and documentation. The broader RoboVerse package adds robot and task content, learning workflows, examples, integrations, and utilities.

A team writing a small simulator extension may prefer MetaSim alone because it avoids learning-specific dependencies such as `diffusers`, `hydra-core`, `robomimic`, `stable-baselines3`, `wandb`, and `tensorflow`. The root package still requires core libraries including `gymnasium`, `loguru`, `numpy`, `pyyaml`, `scipy`, and `torch`, even before optional extras are selected. MetaSim-first adoption can therefore reduce the conceptual and dependency scope when RoboVerse training content is unnecessary.

The other apparent choice, using an upstream simulator directly, differs because RoboVerse adds a shared task registry and packaged content rather than only exposing a backend such as MuJoCo or SAPIEN. The repository also includes adapters or maintained integrations for external ecosystems. Whether that abstraction is worthwhile depends on the required simulator, assets, learning framework, and compatibility guarantees. The README does not publish a full parity or migration matrix, so this boundary needs verification before replacing an established stack.

Apache-2.0 does not remove third-party license review

The RoboVerse source is licensed under Apache License 2.0. That applies to the repository's own source, but the project also includes or adapts code from other projects. The README names MIT-licensed components such as FastTD3, CleanRL, stable-baselines3, `diffusion_policy`, robomimic, and robosuite.

RoboVerse states that each affected file carries a header naming the upstream project, its license, and the modifications, with unresolved exceptions listed in `THIRD_PARTY_NOTICES.md`. It also provides a `NOTICE` file. The README identifies `THIRD_PARTY_NOTICES.md` as the authoritative index mapping repository paths to upstream projects, licenses, and license text.

That division matters for redistribution and packaging. The top-level Apache-2.0 declaration should not be treated as a replacement for checking imported, vendored, and adapted components. Users who need a complete obligations inventory must inspect `THIRD_PARTY_NOTICES.md`, the applicable file headers, and dependency licenses. This is a repository maintenance consideration because third-party components are tracked separately from the primary package license.

Editorial conclusion

Adopt RoboVerse when a team needs MetaSim together with reusable tasks, learning code, examples, and robot-learning integrations. Do not adopt the complete package for a small simulator-specific script or when Python 3.13 support is required. Check the selected backend's installation guide first, review the optional dependency groups in `pyproject.toml`, and confirm that every third-party path relevant to the intended distribution has an entry in `THIRD_PARTY_NOTICES.md`.

Frequently asked questions

Official sources

1. License: Apache-2.0
2. Project website
3. README
4. Releases
5. RoboVerseOrg/RoboVerse on GitHub