---
title: Rigid
canonical_url: "https://www.modelscope.cn/datasets/RoboFlywheel/Rigid"
md_url: "https://www.modelscope.cn/datasets/RoboFlywheel/Rigid.md"
repository: RoboFlywheel/Rigid
chinese_name: RoboFlywheel-Rigid-Light
last_updated: 2026-10-16
license: "Apache License 2.0"
storage_size: "542 GB"
downloads: 2313270
stars: 4
---

# Rigid

> Rigid - RoboFlywheel 在 ModelScope 开源的数据集。RoboFlywheel-Rigid — Light Release

RoboFlywheel/Rigid 是 ModelScope 魔搭社区上的数据集，存储大小 542 GB，采用 Apache License 2.0 许可。

- **Repository**: RoboFlywheel/Rigid
- **License**: Apache License 2.0
- **Storage size**: 542 GB
- **Downloads**: 2313270
- **Stars**: 4
- **Last updated**: 2026-10-16

Source: https://www.modelscope.cn/datasets/RoboFlywheel/Rigid

---

# RoboFlywheel-Rigid — Light Release

**RoboFlywheel-Rigid** is a simulation-ready rigid-object library for robot learning
(grasping, manipulation, tabletop rearrangement, physical-reasoning benchmarks).
This **light** package ships **10,000 assets** across **30 domains** and **1,207
populated classes** (of a 1,212-class taxonomy) — cookware, kitchen prep, lab glassware,
hand/power tools, electronics, office, personal care, home decor, automotive, garden
and toys.

Every asset here was processed end to end: identity & geometry QC → physics properties
(mass, center of mass, full 3×3 inertia, friction) → convex collision decomposition →
per-engine descriptions (URDF / MJCF / USD). All 10,000 assets are complete
(`_SUCCESS` present, `v13_status = ok`).

It is a class-balanced subset of the **full v1.3 release** (524,564 assets); leaf ids
are shared, so any object found here also exists there with identical content.

## Contents at a glance

| Item | Value |
| --- | --- |
| Assets | **10,000** |
| Top-level domains | 30 (`0` – `29`) |
| Populated classes | 1,207 (out of a 1,212-class taxonomy) |
| Assets per class | 3 – 9 (avg 8.3) |
| Physical parts per asset | 1 – 61 (avg 5.5) |
| Collision hulls per asset | 1 – 316 (avg 25.7) |
| Class provenance | 7,868 kept original class · 2,071 reclassified into a better-matching class · 61 assigned to newly defined classes |
| Engines | PyBullet · MuJoCo · Genesis · SAPIEN 3 · Isaac Sim |

Every asset directory is self-contained with relative paths and is **Z-up**
(content-level normalization — **do not add an extra rotation at load time**).
The single source of truth for physics properties is `part_physics.json`
(mass / com / 3×3 inertia / mu1 / mu2 / real_bbox / n_collision_hulls).

## Package layout

```
light/
├── assets/<domain_id>/<class_id>/<leaf>/     # 10,000 asset directories
├── tables/
│   ├── master_table.parquet | .sqlite        # per-asset metadata (identity, geometry QC, physics, provenance)
│   ├── release_mapping.csv | .parquet        # original object_id → released leaf (10,000 rows)
│   └── taxonomy_v1.csv                       # 1,212-class taxonomy (domain/class ids + names)
├── category_mapping/<d>_<c>_<ClassName>/members.csv   # per-class member list, with provenance
└── metadata/                                 # ModelScope mirror only
    ├── manifest.jsonl                        # per-file: source_key (OSS) → repo path, size, etag, mtime
    └── summary.json                          # mirror snapshot: 407,777 files, ~582 GB
```

This package is mirrored to the ModelScope dataset repository **`RoboFlywheel/Rigid`**
(public, Apache-2.0) from `oss://roinn-file2/zhangrui/simready_export/release/light/`.
`metadata/manifest.jsonl` is the authoritative path mapping for that mirror: every
entry carries the original OSS `source_key`, so individual files can be verified or
re-synced.

Leaf directory names are `<domain_id>_<class_id>_<index4>`, e.g. `assets/0/1/0_1_0000`.
`release_mapping.csv` is the join key back to the source pool: it maps the original
`object_id` (pre-release identity) to `new_leaf` (this release), together with the
redirect method used when an object was reclassified.

## Per-asset layout

```
<leaf>/
├── m_<leaf>.urdf                # Primary description: visuals + all collision hulls inlined + 6-component inertia + textures (PyBullet/Genesis/SAPIEN)
├── coacd_multi.urdf             # Collision-mesh URDF (root/link_original, compatible with older downstreams)
├── mjcf/
│   ├── m_<leaf>.xml             # fullinertia + friction="mu1 mu2 1e-4" + textures (MuJoCo/Genesis first choice)
│   └── mesh/                    # self-contained: m_<leaf>.obj + material_0.png + m_<leaf>_collision_*.obj
├── mesh/                        # m_<leaf>.obj (Z-up) + <leaf>.obj (original) + m_<leaf>_collision.obj (merged hulls, same as v0.2) + material.mtl + material_0.png
├── part_physics.json
├── affordance/                  # semantic annotations (v1.0 original frame, not used in physics simulation)
├── <leaf>.usd                   # Isaac deliverable (baked: MassAPI / PhysicsMaterial / UsdUVTexture embedded)
└── _SUCCESS
```

Collision bodies: whole-object CoACD decomposition (threshold=0.05, max_convex_hull=64,
≤64 vertices per hull); parameters are recorded in `part_physics.json.collision`.

## Common step: read the physics properties first

```python
import json
pp = json.load(open(f"{asset_dir}/part_physics.json"))
mu1, mu2 = pp["whole_mu1"], pp["whole_mu2"]     # URDF has no friction field — pb/genesis/sapien must apply these at runtime
```

## PyBullet — URDF + changeDynamics

```python
import pybullet as p
p.connect(p.DIRECT)
bid = p.loadURDF(f"{asset_dir}/m_<leaf>.urdf")       # root link floats by default; pass useFixedBase=True to weld it
for l in range(-1, p.getNumJoints(bid)):
    p.changeDynamics(bid, l, lateralFriction=mu1, spinningFriction=mu2, rollingFriction=1e-4)
# Textures: the URDF <material><texture> is already inlined (effective when getVisualShapeData textureUniqueId >= 0)
# Note: collision AABB readings come out ~4-5mm larger than the hull mesh = Bullet's convex margin, not a data error
```

## MuJoCo — MJCF preferred (full fidelity, native)

```python
import mujoco
m = mujoco.MjModel.from_xml_path(f"{asset_dir}/mjcf/m_<leaf>.xml")   # friction / textures / fullinertia are native
# ⚠ Do NOT go through URDF: MuJoCo's URDF spec path ignores <visual> (no textures) and welds the root link into a static body
```

## Genesis — URDF + explicit friction

```python
import genesis as gs
gs.init(backend=gs.cpu)                              # only once per process
sc = gs.Scene(show_viewer=False)
ent = sc.add_entity(gs.morphs.URDF(file=f"{asset_dir}/m_<leaf>.urdf", fixed=True),
                    material=gs.materials.Rigid(friction=mu1))       # friction must be passed explicitly
sc.build()
```

## SAPIEN 3 — URDF + PhysxMaterial per shape

```python
import sapien, sapien.physx as px
scene = sapien.Scene()
loader = scene.create_urdf_loader()
# A single-link, jointless URDF is classified as an actor rather than an articulation:
# loader.load() always raises "URDF contains multiple objects";
# load_multiple returns (articulations, actors) — every asset in this library lands in actors
articulations, actors = loader.load_multiple(f"{asset_dir}/m_<leaf>.urdf")
a = actors[0]
mat = px.PhysxMaterial(mu1, mu1, 0.0)                 # static = dynamic = mu1; PhysX has no torsional friction field
rb = a.find_component_by_type(px.PhysxRigidBaseComponent)
for sh in rb.get_collision_shapes():
    sh.physical_material = mat                        # without this you silently get the 0.5 default and lose all friction
```

## Isaac Sim — baked USD (the only reliable path)

```python
from pxr import Usd
stage = Usd.Stage.Open(f"{asset_dir}/<leaf>.usd")     # or add_reference_to_stage
# RigidBody/MassAPI (mass+com+inertia principal axes)/per-hull CollisionAPI/PhysicsMaterial(mu1)/UsdUVTexture(sRGB) are all baked
# ⚠ Do NOT use the URDF/MJCF importer: external geometry stays in the importer's in-memory stage (active stage ends up with 0 meshes / 0 mass / 0 textures)
```

## Notes and caveats

- **Friction does not come for free**: the URDF standard has no friction field, and the
  PyBullet/Genesis/SAPIEN parsers all ignore it → you must read the values from
  `part_physics.json` and apply them at import time as shown above. MJCF and USD carry
  them natively, no extra work needed.
- **mu2 (torsional friction)**: only MuJoCo (2nd slot of `friction`) and PyBullet
  (`spinningFriction`) support it natively; Genesis/SAPIEN/Isaac only take mu1
  (impact limited to spin damping).
- **Orientation**: already normalized to Z-up at content level (visuals + hulls + com +
  inertia rotated together; recorded in `part_physics.up_axis_fix`).
- **`real_bbox` is a declared value, not a measured one** (VLM/anchoring source; an
  individual axis can be off by 2-3×): use it only for Z-up orientation normalization.
  For gripper sizing or scene placement, read the measured AABB of the mesh or the hulls
  — not `real_bbox`.
- **`affordance/`**: semantic annotations stay in the v1.0 original frame; if the asset
  was rotated (`up_axis_fix.rotated` non-empty), apply the same rotation to the
  annotations before use.
- **Isaac collision-body rendering**: collision bodies are hidden in the USD with a
  cutout (opacity=0) while physics stays active; do not hide them via purpose/visibility
  (that turns physics off too).
- **USD materials**: the visual material is OmniPBR (`OmniPBR_Opacity.mdl` sourceAsset,
  verified to sample textures correctly under Isaac RTX), and also carries a
  UsdPreviewSurface at preview purpose for standard USD tooling; non-Isaac viewers
  (e.g. usdview) go through the preview channel.
- **`_SUCCESS` semantics**: marks a complete generation of this release (v1.3); it
  contains `n_collision_hulls` and the source v1.0 provenance line. A directory without
  `_SUCCESS` was not fully processed.