---
license: cc-by-4.0
pretty_name: SimReady GLB
tags:
- 3d
- gltf
- glb
- web
- three.js
- simready
- nvidia
size_categories:
- 1K<n<10K
configs:
- config_name: default
  data_files:
  - split: train
    path:
    - "thumbs/*.webp"
    - "thumbs/metadata.jsonl"
---

# SimReady GLB

![A grid of SimReady models rendered from this dataset](assets/hero.webp)

**[Open the 3D viewer](https://huggingface.co/spaces/codepawl/simready-glb-viewer)** to search all 2,595 models and
orbit any of them in the browser.

Web-ready glTF binary (`.glb`) copies of the 3D models in
[nvidia/simready-assets](https://huggingface.co/datasets/nvidia/simready-assets). Each file loads directly in
three.js, Babylon.js, model-viewer or any glTF 2.0 viewer.

Models by NVIDIA SimReady, licensed CC BY 4.0. This dataset converts and compresses them. It does not change what
they show. If you use these files, credit NVIDIA as the original author and link the source dataset.

| | Blender export | This dataset |
|---|---|---|
| Assets | 2,595 | 2,595 |
| Total size | 228.1 GB | 3.2 GB |
| Triangles | 821M | 415M |
| Largest texture edge | 4096 px | 1024 px |

Example: the V8 engine (`engineAssembly_v8_engine_a01`) is an 888 MB glb out of Blender and
7.4 MB here. Its first frame in Chrome took 9.4 s before and 0.57 s after.

## What is in it

- `glb/<asset>.glb`: one file per SimReady asset folder, named like the folder in the source dataset.
- `thumbs/<asset>.webp`: a 512 px render of each glb, with `thumbs/metadata.jsonl` holding its category, size,
  triangles and draw calls. The Dataset Viewer above shows this table.
- `manifest.jsonl`: one line per asset with size, triangles, draw calls and textures before and after optimization,
  plus the number of hulls, concave parts and drives.
- `newton_loader/`: the loader for NVIDIA Newton.

## Download

All files, about 3.2 GB:

```bash
hf download codepawl/simready-glb --repo-type dataset --local-dir simready-glb
```

One category, for example every food model:

```bash
hf download codepawl/simready-glb --repo-type dataset --include "glb/food_*" --local-dir simready-glb
```

One file from Python:

```python
from huggingface_hub import hf_hub_download

path = hf_hub_download("codepawl/simready-glb", "glb/engineAssembly_v8_engine_a01.glb", repo_type="dataset")
```

## Loading in three.js

The geometry uses `EXT_meshopt_compression` and the textures use `EXT_texture_webp`, so set the meshopt decoder:

```js
import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js';

const loader = new GLTFLoader();
loader.setMeshoptDecoder(MeshoptDecoder);
loader.load('engineAssembly_v8_engine_a01.glb', (gltf) => scene.add(gltf.scene));
```

## Physics and moving parts

2,587 files carry the rigid bodies, mass and physics materials of their SimReady USD. 929 of
them also carry joints, 5,550 in all: door hinges, drawer slides, buttons, wheels and lids. Each file holds
this data in two forms:

- `KHR_physics_rigid_bodies`, the Khronos glTF physics extension. Each part has a `motion` with its mass, center of
  mass and inertia. Each mesh has a convex hull `collider` with friction and restitution. Each joint has its limits.
  Loaders that do not read the extension ignore it.
- Plain node extras, which three.js puts in `object.userData`. A moving part has
  `joints: [{ type, parent, pivot, axis, min, max, unit }]`, with the pivot and axis in model space at rest.
  Revolute limits are in degrees and prismatic limits are in meters. Parts also have `mass` in kg and `density` in
  kg/m³.

Open a door or a drawer in three.js from its rest pose (the part's parent is at the model origin):

```js
import * as THREE from 'three';

function movePart(part, value) {
  const { type, pivot, axis } = part.userData.joints[0];
  const direction = new THREE.Vector3(...axis);
  if (type === 'prismatic') {
    part.position.addScaledVector(direction, value);
    return;
  }
  const turn = new THREE.Quaternion().setFromAxisAngle(direction, THREE.MathUtils.degToRad(value));
  const center = new THREE.Vector3(...pivot);
  part.position.sub(center).applyQuaternion(turn).add(center);
  part.quaternion.premultiply(turn);
}

movePart(gltf.scene.getObjectByName('door_01_obj_00'), 90);
```

The 3D viewer shows a slider for each moving part. The files from before the physics data are kept at the `v1` tag:
add `--revision v1` to the download command.

## Simulating in NVIDIA Newton

Each file with physics data also carries the data that a simulator needs and a viewer does not:

- 17,507 collision hulls in `extras.collisionHulls` of each body node. 2,852 of the 8,496 parts are concave.
  A concave part gets up to 8 hulls, so a cabinet or a bin stays hollow. A hull has at most 48 points, or 32 in a concave part.
- 2,145 joint drives in 333 files, in the `drives` array of the joint in `KHR_physics_rigid_bodies`.
- Inertia of 256 small parts in 67 files, which the earlier rounding had set to zero.

These additions make the set 0.17% larger: 3,180.2 MB to 3,185.5 MB, with a median file of 0.416 MB. Meshes, materials and
textures are byte-identical to the earlier files in all 2,595 files. The hulls sit after the old binary data, so
existing loaders read the files as before.

Half of the files have hulls within 3.9 mm of the part's own convex shape. The figure is 12 mm at the 95th percentile
and 177 mm in the worst file. A hull side that is nearly flat along an axis is then made exactly flat, which moves its
points outward by up to 2 cm. Newton's contact code turns an uneven bottom into false depth, which kicks the part upward.

`newton_loader/simready_newton` adds a file to a Newton model. It needs Newton 1.7, SciPy and meshoptimizer.

```python
import newton
import newton.solvers
from simready_newton import add_simready_glb

builder = newton.ModelBuilder(up_axis=newton.Axis.Y)
builder.add_ground_plane()
add_simready_glb(builder, "glb/bin_waste_a01.glb", position=(0.0, 0.5, 0.0))
model = builder.finalize()
solver = newton.solvers.SolverXPBD(model, iterations=8, joint_linear_relaxation=0.3, joint_angular_relaxation=0.2)
```

Use these two relaxation values with `SolverXPBD`. The default linear value of 0.7 went NaN on
`scaffold_rolling_steel_a03` within a few frames. The default angular value of 0.4 went NaN on
`climate_shopFan_pedestal_a01` when every joint was pushed at once. The loader read all 2,595 files with no failures.
8 files have no rigid bodies, so it adds nothing for them.

In a file with joints, the loader raises any part's inertia below 1e-4 kg·m² to that value. A part's rotation is slower
than the source says, and it no longer shakes or goes NaN. Set `jointed_part_inertia_floor` to change the value. Files
with one rigid body use 1e-6 kg·m² (`inertia_floor`).

43 files across the categories were simulated at 60 fps with 8 substeps. 42 of them were compared with their SimReady USD:

| Check | Result |
| --- | --- |
| Mass, center of mass, joint type, pivot, axis, limits, friction, restitution | Match |
| Dropped from 20 cm stays finite | 43 of 43 |
| Dropped from 20 cm is at rest after 3 s | 31 of 43 |
| Dropped from 20 cm is at rest after 9 s (the 12 files left) | 10 of 12 |
| Every joint pushed at once on a pinned base stays finite | 43 of 43 |

At rest means under 0.05 m/s and 0.5 rad/s. The push test stops pushing a free axle above 200 rad/s. `conveyor_belt_a61`
stayed finite at 400 rad/s and went NaN at 800 rad/s, so keep free axles below that at 480 substeps per second.

## How the files were made

1. Download `simready_usd/` from each asset folder. `source_assets/` is skipped because it holds a second copy of
   the textures for MDL shaders.
2. Check that `.metadata/LICENSE.txt` is CC BY 4.0.
3. Import the USD in Blender 5.2 and remove the collision, proxy and grasp helper prims. Export a glb with the
   original textures.
4. Optimize with glTF Transform 4.5. Remove the USD instance prototypes Blender brings in next to the placed parts,
   remove duplicate mesh instances, then dedup, prune and weld.
5. Resize textures to 1024 px as WebP. Compress geometry with meshopt at its high level
   (`EXT_meshopt_compression` with octahedral normals and quantized attributes).
6. Read the rigid bodies, mass, physics materials and joints from the USD layers and write them into the glb JSON.
   The USD is Z-up, so joint frames and axes are turned to the glb's Y-up.
7. Cut each concave part into convex pieces and keep the hull points that stick out most. Make nearly flat hull sides
   exactly flat. Read the drives and the full inertia from the USD. Append the hulls after the binary data.

Assets with UDIM textures have each tile split into its own material before the export, with its UVs moved into 0-1.
Blender's own UDIM handling in the glTF exporter drops the faces of some tiles.

No mesh simplification is applied. The triangle drop comes from removed duplicates and helper geometry.

The conversion scripts are in
[codepawl/3d-builds](https://github.com/codepawl/3d-builds/tree/main/works/2026-10-28-simready-showcase/batch).

## Known gaps

SimReady collides with signed distance fields built from each render mesh. The `collider` of each mesh in
`KHR_physics_rigid_bodies` stays one convex hull, which every engine can build, so hollow parts collide as if filled
there. Use `extras.collisionHulls` to keep them hollow. `KHR_physics_rigid_bodies` is still a Khronos review draft, so
check that your engine reads it. The node extras work with any loader. USD simulation settings are not carried
over. Materials are converted to glTF PBR, so MDL-only shader effects are lost.

In Newton, parts of one file do not collide with each other, because SimReady's overlapping parts jam their hinges
otherwise. Nothing latches a door or a drawer, so use a drive to hold them closed. Two sample files do not stay still:

- `electrical_power_terminal_a01` is 5.1 m tall and 0.52 m deep, and it falls over when it stands free. Load it with
  `fixed_base=True`.
- `paint_supplies_brush_a05`, a 44 g brush, still rocks after 9 s. With `rigid_contact_relaxation=0.2` it settles in 9 s.

Inertia differs from the USD where the loader raises it to its floor. Only 43 of the 2,595 files had these simulation
checks, so other files can have the same problems.

Two joints in the USD are left out because they hold nothing: the fixed joint of
`ladder_multiPurpose_aluminium_a05` points at a part with no rigid body, and one fixed joint of
`serviceTool_brakeCaliper_pistonWindBackKit_a01` joins a body to itself.

## Changelog

- 2026-11-01: Added collision hulls that keep concave parts hollow, joint drives and the inertia of small parts.
  Added a loader for NVIDIA Newton. The set grows by 0.17%. Meshes, materials and textures do not change.
- 2026-10-29: Added physics from the USD files: rigid bodies, mass, physics materials and 5,550 joints, as
  `KHR_physics_rigid_bodies` and as node extras. The viewer shows a slider for each moving part. The files before this
  change are at the `v1` tag.
- 2026-10-29: Geometry is encoded at meshopt's high level. The set went from 4.0 GB to 3.2 GB with the same
  triangles and no visible change in any of the 2,595 thumbnails.
- 2026-10-29: 52 files with UDIM textures were missing geometry, because Blender's glTF exporter dropped
  the faces of some texture tiles (for example crate_plywood_b01 kept only its metal frame). They are exported again
  with the tiles split before the export.
- 2026-10-29: 1,305 files carried a second copy of some parts at the origin, the USD instance prototypes
  Blender imports next to the placed parts (for example the eyeglasses showed two pairs of arms). Those copies are
  removed. Added thumbnails, the Dataset Viewer table and the 3D viewer Space.
- 2026-10-28: first release.