codepawl/simready-glb

SimReady GLB

Open the 3D 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. 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:

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

One category, for example every food model:

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

One file from 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:

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):

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.

import newton
import newton.solvers
from simready_newton import add_simready_glb

builder = newton.ModelBuilder()  # Z-up by default; the loader stands each Y-up file upright for any up axis
builder.add_ground_plane()
add_simready_glb(builder, "glb/bin_waste_a01.glb", position=(0.0, 0.0, 0.5))
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).

A part with a mass but no inertia in the file gets its inertia from its hulls, scaled to that mass. This applies to 2,026 parts. As in Newton's own USD importer, the file's center of mass replaces the hulls' center without shifting the inertia.

Each part starts in the pose the file shows, in every solver. Some source joints hold a gap across a locked axis, from 1 mm to 1.8 m (a bottle cap 21 cm above its bottle) or up to 37° (a forklift's brake button), which would pull the part out of place. The loader closes these gaps on the first joint frame. A free axis keeps its rest offset as the joint's starting coordinate in builder.joint_q, so MuJoCo and Featherstone, which place parts from the coordinates, start there too. The forklift's seat headrest rests 13.5° outside its own limits, so the limit pushes it back when the simulation starts.

The loader reads only the file's JSON and the hull bytes, never the textures, so most files load in a few milliseconds.

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.

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.

structure_wall_entrance_a01 goes NaN at 8 substeps, even with a fixed base: its 184,601 kg wall is welded to 21 kg barriers. It stays finite at 16 substeps.

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-03: The loader now stands files upright in a builder of any up axis, so Newton's default Z-up builder works. Parts start in their rest pose: joint gaps across locked axes are closed and a free axis's rest offset becomes the joint's starting coordinate. Before, 36 files moved a part out of place at q=0, by up to 1.86 m or 37°; now none do. Two more of 64 tested files come to rest after a drop, and no file got worse. Loading reads only the JSON and the hulls: all 2,595 files load in 23 s instead of 118 s (median 3.5 ms instead of 30 ms). The GLB files do not change.
• 2026-11-03: Fixed the loader's inertia for parts with no inertia in the file. qhull does not orient its hull triangles, so Newton's signed-volume integral cancelled most of the volume and the median part was 63 times off on one axis (reported by jayscambler in discussion #2). Triangles of these hulls now face outward; collision-only hulls are unchanged. These parts now also get the inertia floor, and flat parts with no hull volume (29 buttons and hinges) keep the file's mass instead of ending with zero mass and inertia. checks.movable_joints no longer recurses forever on the loop-closing joints of instrument_adams_pliers_b01. The GLB files do not change.
• 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.