Open-sourcing an A1 robotic arm XML model for MuJoCo

[czxhunzi]

Intro

Hi!

I am an engineer at a robotics company working on our own A1 robotic arm. We use MuJoCo for simulation and control development, and we would like to open-source the robot’s XML/MJCF model and related assets for the community.

My setup

MuJoCo version: 3.x

API: Python

OS: Ubuntu 22.04

Architecture: x86_64

Python version: 3.10

My question

Is there a recommended way to share or contribute robot models with the MuJoCo community?
Is there an official repository, model zoo, or community channel for submitting open-source MuJoCo robot assets/examples?
If direct contribution to an official repository is not available, what would be the best way to make the model discoverable and useful to MuJoCo users?

Minimal model and/or code that explain my question

If you encountered the issue in a complex model, please simplify it as much as possible (while still reproducing the issue).

Model:

minimal XML

<mujoco>
  <worldbody>
    <light pos="0 0 1"/>
    <geom type="sphere" size="1" rgba="1 0 0 1"/>
  </worldbody>
</mujoco>

Code:

import mujoco
import mediapy as media
model = mujoco.MjModel.from_xml_string(xml)
data = mujoco.MjData(model)

with mujoco.Renderer(model) as renderer:
  mujoco.mj_forward(model, data)
  renderer.update_scene(data)

  media.show_image(renderer.render())

Confirmations

• I searched the latest documentation thoroughly before posting.
• I searched previous Issues and Discussions, I am certain this has not been raised before.

[ATemova]

Yes — the official home for this is MuJoCo Menagerie, the model collection curated by Google DeepMind (github.com/google-deepmind/mujoco_menagerie). It's exactly for community-contributed, high-quality MJCF models of real hardware, and it has a manipulators/arms category already (e.g. the Franka Panda, and there's a Unitree A1 in there too, so mind the naming clash with your own "A1"). Contributions of brand-new models are explicitly welcomed.

The process (from their CONTRIBUTING.md):

1. Open an issue first. Before writing any PR, open a new issue on the Menagerie repo proposing the model. They ask you to coordinate up front for anything major — it avoids wasted effort and lets them agree on scope before you build.

2. You'll need a CLA. Contributions require a Contributor License Agreement, which your employer can sign at cla.developers.google.com. Since you're doing this on behalf of a company, get that started early — you (or the company) keep copyright; the CLA just lets Google redistribute it as part of the project.

3. Match their MJCF style and tooling. Setup is uv-based:

   • make install (one-time: installs pre-commit + git hook)
   • make all (runs everything CI runs: lint + format + license + XML + tests)

   XML formatting is enforced by their format_xml.py (run via the pre-commit hook), so run uv run format_xml.py --write path/to/model.xml. They also have style conventions — attribute ordering (compiler, asset, defaults first, then worldbody/actuators), a per-model README specifying the minimum MuJoCo version, a CHANGELOG.md in the model directory, and adding yourself to CONTRIBUTORS.md.

4. Submit the PR once you've agreed on the issue and it passes make all.

Quality expectations worth knowing before you invest the effort: Menagerie models aren't just a raw URDF→MJCF dump. They expect tuned inertials, decomposed convex collision meshes (their obj2mjcf tool helps), sensible actuator/joint parameters, and a scene.xml for the viewer. As a reference point, the Stretch 3 model was a roughly year-long on-and-off collaboration — an arm is less than that, but budget real tuning time. If you already have a clean URDF, MuJoCo can do the initial URDF→MJCF conversion (drag-and-drop into python -m mujoco.viewer, then "Save xml"), which gives you a starting point to refine.

If Menagerie isn't the right fit or you want it discoverable immediately: two complementary routes —

• robot_descriptions.py (github.com/robot-descriptions/robot_descriptions.py) — a loader library that indexes robot models (including MuJoCo ones) so users can pip install and load yours by name. Great for discoverability even if the assets live in your own repo.
• Your own public repo with an Apache-2.0 or similarly permissive license, a clear README, and a scene.xml, then announce it on the MuJoCo Discussions and the Google DeepMind MuJoCo community channels. Menagerie can also link/reference well-maintained external models.

Given you're a company open-sourcing your own hardware's model, the Menagerie issue-first route is the highest-signal path — it's the canonical place arm users look, and getting listed there is the best discoverability you can get. Just sort the CLA out on the company side early, since that's usually the slowest step.