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(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.

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.