codepawl/scanned-objects-glb

Scanned Objects GLB

Web-ready glTF binary (.glb) copies of the 1,033 household products in Google Scanned Objects, taken from the official copies on Gazebo Fuel. Each file loads directly in three.js, Babylon.js, model-viewer or any glTF 2.0 viewer, at real size in metres, Y up.

Scans by Google Research, licensed CC BY 4.0 (Copyright 2020 Google LLC). This dataset converts and compresses them. It does not change what they show. If you use these files, credit Google Research and link the source.

Brands, logos and product names printed on the packaging belong to their owners. They appear because the scans are of real retail products; this dataset claims no rights in them and implies no endorsement.

Use it in 67js

The files load in 67js, a WebGL2 renderer. The geometry is meshopt compressed, so pass the decoder to loadGltf. The snippet below loads the Clue board game from this repository and draws it on a page with one <canvas>.

npm install 67js@npm:@codepawlhq/67js meshoptimizer

import { Renderer67 } from '67js';
import { loadGltf } from '67js/addons/gltf';
import { MeshoptDecoder } from 'meshoptimizer';

const GLB_URL = 'https://huggingface.co/datasets/codepawl/scanned-objects-glb/resolve/main/objects/Clue_Board_Game_Classic_Edition/Clue_Board_Game_Classic_Edition.glb';
const asset = await loadGltf(GLB_URL, { decoders: { meshopt: MeshoptDecoder } });
const renderer = new Renderer67(document.querySelector('canvas'), asset.parts, { samples: 4 });
renderer.render({ eye: [0, 0.3, 0.8], target: [0, 0.05, 0] });

The objects are a few centimetres to about half a metre across, so keep the camera close.

To search all 1,033 objects and orbit any of them, serve a local copy with any static server (npx serve scanned-objects-glb) and open /viewer/.

	Source (OBJ + PNG)	This dataset
Objects	1,033	1,033
Total size	13.7 GB unpacked, 8.7 GB as zip	344.8 MB
Triangles	16,664,572	16,664,572 (not simplified)
Texture	4096 px PNG	2048 px WebP

Example: the Clue board game is 25.0 MB as OBJ and PNG and 873 KB here. On a local server in headless Chrome, the 45 objects that still had an uncompressed copy took 13.4 s to load and draw as plain glb and 2.7 s as these files.

What is in it

• objects/<id>/<id>.glb: one file per scan, named like the model on Gazebo Fuel.
• thumbs/<id>.webp: a 512 px render of each glb, with thumbs/metadata.jsonl for the Dataset Viewer.
• metadata.jsonl: one line per object: name, shelf category, brand, MPN, SKU from the source, size in metres, estimated mass, triangles, texture size and bytes before and after.
• collision_hulls.json: one convex hull per object (up to 40 points, in the glb's frame) with its volume and mass estimate, ready for a physics engine.
• objects_ktx2/<id>/<id>.glb: the same objects with KTX2 textures for games and WebGPU, plus gpu_variants.jsonl.
• lods/<id>/<id>_lod1.glb to _lod3.glb: simplified levels with smaller KTX2 textures.
• viewer/: the static three.js browser.
• assets/: the banner video and the picture of all objects at the top of this card.

Download

All files, about 344.8 MB:

hf download codepawl/scanned-objects-glb --repo-type dataset --local-dir scanned-objects-glb

One file from Python:

from huggingface_hub import hf_hub_download

path = hf_hub_download("codepawl/scanned-objects-glb", "objects/Clue_Board_Game_Classic_Edition/Clue_Board_Game_Classic_Edition.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('Clue_Board_Game_Classic_Edition.glb', (gltf) => scene.add(gltf.scene));

For web games and WebGPU: KTX2 and LODs

A WebP texture is decoded to full RGBA on the GPU. objects_ktx2/ has the same 1,033 objects with KTX2 textures (ETC1S, full mip chain, KHR_texture_basisu), which stay block compressed in VRAM. lods/ adds three simpler levels of each object as separate files, because neither three.js nor 67js reads MSFT_lod. Every level has the same origin, scale and orientation, so switching level is a plain swap. The files in objects/ did not change.

Level	File	Triangles kept	Texture	VRAM, median	File, median
WebP pack	objects/<id>/<id>.glb	100%	2048 px WebP	21.5 MiB	297 KiB
lod0	objects_ktx2/<id>/<id>.glb	100%	2048 px KTX2	5.5 MiB	336 KiB
lod1	lods/<id>/<id>_lod1.glb	50%	1024 px	1.4 MiB	129 KiB
lod2	lods/<id>/<id>_lod2.glb	20%	512 px	0.38 MiB	56 KiB
lod3	lods/<id>/<id>_lod3.glb	6%	256 px	0.10 MiB	22 KiB

Load time for one object, median of 20 objects with 5 loads each:

	WebP pack	KTX2 lod0
three.js WebGPURenderer, load	41.3 ms	23.2 ms
three.js WebGPURenderer, load and first frame	48.1 ms	27.0 ms
67js, load	49.0 ms	30.4 ms

three.js WebGLRenderer was measured on a smaller sample, 5 objects with 3 loads each. It loaded the WebP file in 45.1 ms and the KTX2 file in 26.3 ms. With the first frame, they took 67.3 ms and 35.4 ms. It also transcoded KTX2 to BC7.

Measured on an RTX 3060 in headless Chrome (ANGLE D3D11, WebGPU backend), three.js r187 and 67js 0.15.0, files from localhost. VRAM counts texture and geometry bytes as uploaded: the KTX2 files transcode to BC7 on this GPU, and WebP is RGBA8 with mips. The GPU was shared with other jobs, so the ratios are more reliable than the milliseconds. Phones (ASTC or ETC2) and Safari were not measured. The KTX2 set is 373.6 MB against 344.8 MB for the WebP set, and the LODs add 247.7 MB.

three.js with WebGPU:

import * as THREE from 'three';
import { WebGPURenderer } from 'three/webgpu';
import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
import { KTX2Loader } from 'three/addons/loaders/KTX2Loader.js';
import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js';

const BASE = 'https://huggingface.co/datasets/codepawl/scanned-objects-glb/resolve/main';
const renderer = new WebGPURenderer({ antialias: true });
await renderer.init(); // call before detectSupport, so the loader knows the device's formats

const ktx2Loader = new KTX2Loader()
  .setTranscoderPath('https://cdn.jsdelivr.net/npm/three@0.187.0/examples/jsm/libs/basis/')
  .detectSupport(renderer);
const loader = new GLTFLoader().setKTX2Loader(ktx2Loader).setMeshoptDecoder(MeshoptDecoder);
const gltf = await loader.loadAsync(`${BASE}/objects_ktx2/11pro_SL_TRX_FG/11pro_SL_TRX_FG.glb`);

67js does not bundle the decoders, so pass the three.js KTX2 loader and meshopt decoder:

import { KTX2Loader } from 'three/addons/loaders/KTX2Loader.js';
import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js';
import { loadGltf, ktx2WorkerConfigFor } from '67js/addons/gltf';

const BASE = 'https://huggingface.co/datasets/codepawl/scanned-objects-glb/resolve/main';
const context = document.createElement('canvas').getContext('webgl2'); // with a Renderer67, use renderer.context
const ktx2 = new KTX2Loader().setTranscoderPath('https://cdn.jsdelivr.net/npm/three@0.187.0/examples/jsm/libs/basis/');
ktx2.workerConfig = ktx2WorkerConfigFor(context); // without it the loader throws

const asset = await loadGltf(`${BASE}/objects_ktx2/11pro_SL_TRX_FG/11pro_SL_TRX_FG.glb`, { decoders: { ktx2, meshopt: MeshoptDecoder } });
ktx2.dispose();

Both snippets ran against that URL. three.js reported the WebGPU backend and a BC7 texture with 12 mips, and 67js reported one BC7 2048 px texture with no warnings. The textures were encoded with KTX-Software 4.4.2 toktx (ETC1S, --clevel 0 --qlevel 128 --genmipmap). ETC1S was chosen over UASTC because these scans have only a colour map. The LODs use meshopt simplify with error caps of 0.01, 0.03 and 0.08.

Game engines: Unreal Engine 5.8 does not import these files, because its glTF importer does not read EXT_meshopt_compression. For Unreal, decode a file from objects/ first. The command below writes plain geometry and PNG textures. A SimReady file made this way imported into Unreal 5.8 with its textures:

npx @gltf-transform/cli png Clue_Board_Game_Classic_Edition.glb Clue_plain.glb --formats "*"

Unity and Godot were not tested. collision_hulls.json holds one convex hull per object for any physics engine.

Categories and mass

The source gives a product name and, for some objects, a retail category that is often missing or wrong (a shoe filed under bottles and cups, for example). Each object gets one shelf category: shoe (254), toy (224), household (102), electronics (97), kitchen (80), food and drink (71), health and beauty (55), bottles and cups (37), board game (33), bag (30), media (29), other (13), baby gear (6), clothing (2). 553 come from the source category and 467 from keyword rules on the product name; 13 match neither and are left as other. The rules are in categories.mjs of the conversion scripts; expect a few misfiles.

The source has no mass. mass_estimate_kg is the hull volume times a rough bulk density for the category (a boxed toy is mostly air), so treat it as a starting value, not a measurement.

How the files were made

1. Download every model of the GoogleResearch owner from Gazebo Fuel (1,033 on 2026-11-02; the Google blog says 1,030). Each archive holds meshes/model.obj, model.mtl, a 4096 px PNG and metadata.pbtxt.
2. Read the OBJ, turn it from Z up to Y up, keep metres. Write one glTF mesh with the PNG as base colour.
3. Optimize with glTF Transform: dedup, prune, weld, texture to 2048 px WebP at quality 88, meshopt at its high level.
4. Build a convex hull from the full scan with scipy, simplified to 40 points.
5. Render a 512 px thumbnail of every pack file in headless Chrome.

Before the full run, 10 objects were rendered from the uncompressed glb and from the pack file with the same camera. The mean pixel difference was 0.02 to 0.50 out of 255; a 1024 px texture doubled it, so 2048 px was kept.

Known gaps

The scans are single meshes with one texture, so lids, straps and soft parts do not move. Shiny and transparent surfaces were scanned as matte colour. Hulls are convex, so a bowl or a shoe collides as if filled. Mass is estimated.