codepawl/abo-glb

Amazon Berkeley Objects GLB

The 7,953 3D models of Amazon Berkeley Objects (ABO), made small enough to load in a browser. Each product is one .glb with its full PBR material (colour, normal, metallic and roughness maps), at real size in metres, Y up. Most stand on Y = 0.

	Amazon's files	This dataset
Models	7,953	7,953
Total size	165.6 GB	12.2 GB
Average file	20.8 MB	1.5 MB
Triangles	340,137,126	340,137,126 (not simplified)
Textures	PNG or JPEG, up to 4096 px	WebP, up to 2048 px
Geometry	plain buffers	EXT_meshopt_compression

Example: the Stone & Beam Bradbury Chesterfield leather sofa is 57.1 MB in ABO and 2.2 MB here.

Every model also comes as a GPU-ready copy with KTX2 textures, three simpler levels of detail, collision shapes and a copy for desktop engines. See For games and WebGPU and Godot.

Credit and licence

The 3D models, images and listing text are by Amazon.com, from the Amazon Berkeley Objects dataset, licensed CC BY 4.0. The dataset was built by Matthieu Guillaumin, Thomas Dideriksen, Kenan Deng, Himanshu Arora, Arnab Dhua, Xi (Brian) Zhang, Tomas Yago-Vicente (Amazon.com), Jasmine Collins, Shubham Goel and Jitendra Malik (UC Berkeley).

This dataset changes the files: it re-encodes the textures, resizes them to at most 2048 px and compresses the geometry. The lods/ copies also have fewer triangles. The other files do not change what the models show. A copy of the licence is in LICENSE-CC-BY-4.0.txt. CodePawl is not affiliated with Amazon, and Amazon does not endorse this dataset. Brand and product names belong to their owners.

If you use the models in a publication, cite the ABO paper:

@article{collins2022abo,
  title={ABO: Dataset and Benchmarks for Real-World 3D Object Understanding},
  author={Collins, Jasmine and Goel, Shubham and Deng, Kenan and Luthra, Achleshwar and
          Xu, Leon and Gundogdu, Erhan and Zhang, Xi and Yago Vicente, Tomas F and
          Dideriksen, Thomas and Arora, Himanshu and Guillaumin, Matthieu and
          Malik, Jitendra},
  journal={CVPR},
  year={2022}
}

What is in it

• objects/<id>/<id>.glb: one file per product, WebP textures. The id is ABO's 3dmodel_id, an Amazon product code.
• objects_ktx2/<id>/<id>.glb: the same model with KTX2 (Basis Universal) textures and mipmaps, 9.2 GB in total.
• lods/<id>/<id>_lod1.glb, _lod2, _lod3: simplified copies with KTX2 textures, 4.7 GB in total.
• engine/<id>/<id>.glb: the KTX2 copy with plain, uncompressed geometry, for engines that cannot read meshopt, such as Godot. 16.6 GB in total.
• collision/<id>/<id>_collision.glb: the model cut into convex parts, one node per part, at most 64 points each. Median 12 parts a model, 269.2 MB in total.
• collision_hulls.json: one convex hull per model (at most 64 points, in the glb's frame) with its faces and volume.
• thumbs/<id>.webp: a 512 px render of each pack file, with thumbs/metadata.jsonl for the Dataset Viewer.
• metadata.jsonl: one line per model: English product name where a listing has one, product type, brand, colour, material, style, the catalogue size and weight, every Amazon item id that uses the model, the model's measured size in metres, triangles, and bytes before and after.

Most types: chair (1,184), sofa (859), rug (817), wall art (599), table (584), home furniture and decor (549), lamp (345), stool seating (340), ottoman (288), pillow (275), headboard (206), light fixture (195).

Download

All files, about 12.2 GB:

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

One model from Python:

from huggingface_hub import hf_hub_download

path = hf_hub_download("codepawl/abo-glb", "objects/B0714QGC72/B0714QGC72.glb", repo_type="dataset")

Loading in 67js

67js is a WebGL2 engine for scenes that AI agents build and render. The preview above is 67js drawing the pack files. Its glTF addon reads the meshopt geometry, the WebP textures and all four PBR maps. WebP textures need a 67js release after 0.15.0. Until then, build 67js from the main branch.

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

import { Renderer67 } from '67js';
import { loadGltf } from '67js/addons/gltf';
import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js';

const url = 'https://huggingface.co/datasets/codepawl/abo-glb/resolve/main/objects/B0714QGC72/B0714QGC72.glb';
const asset = await loadGltf(url, { decoders: { meshopt: MeshoptDecoder } });
const renderer = new Renderer67(document.querySelector('canvas'), asset.parts, { samples: 4 });
renderer.render({ eye: [1.6, 1.1, 2.4], target: [0, 0.4, 0] });

Loading in three.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('B0714QGC72.glb', (gltf) => scene.add(gltf.scene));

For games and WebGPU

The WebP files are small to download, but a browser decodes WebP into plain RGBA, 4 bytes a pixel. The KTX2 copies stay compressed on the GPU: Basis Universal transcodes to BC7 on desktop and ASTC on phones, 1 byte a pixel.

Level	Triangles, whole pack	Texture edge	Files, whole pack
lod0 (objects_ktx2/)	340,137,126	2048 px (normal map 1024 px)	9.2 GB
lod1	170,725,368	1024 px	3.1 GB
lod2	69,775,173	512 px	1.1 GB
lod3	24,144,651	256 px	0.4 GB

Texture memory on the GPU with mip chains, worked out from the texture sizes in each file:

	WebP copy	KTX2 copy
One model, median	64 MiB	12 MiB
All 7,953 models	482 GiB	91 GiB

Whole set, 7,953 objects

Level	Triangles, sum	Triangles vs lod0 (median per object)	File size, sum	File size median (p10, p90)	Texture
lod0	340,137,126	100%	9236.9 MB	1066 (p10 449, p90 1801) KiB	2048 px
lod1	170,725,368	50%	3063.9 MB	330 (p10 156, p90 561) KiB	1024 px
lod2	69,775,173	20%	1144.8 MB	115 (p10 59, p90 203) KiB	512 px
lod3	24,144,651	6%	448.7 MB	40 (p10 23, p90 81) KiB	256 px

WebP pack (objects/): 12228.0 MB, median 1194 (p10 318, p90 3091) KiB. KTX2 pack (objects_ktx2/): 9236.9 MB. All LODs together: 4657.4 MB.

Measured load time and VRAM: 20 objects, 5 runs each (3 for LODs)

Measured on an RTX 3060 in headless Chrome 156 with the WebGPU backend. KTX2 textures transcode to BC7 on this GPU.

Metric	WebP pack	KTX2	Change
Texture VRAM, MiB (three, as uploaded)	64.00 (p10 64.00, p90 64.00)	12.00 (p10 12.00, p90 12.00)	0.19x
Geometry VRAM, KiB (three)	293 (p10 42, p90 1239)	293 (p10 42, p90 1239)	1.00x
Texture + geometry, MiB (three)	64.27 (p10 64.01, p90 69.17)	12.27 (p10 12.01, p90 17.17)	0.19x
Texture VRAM, MiB (67js accounting)	64.00 (p10 64.00, p90 64.00)	12.00 (p10 12.00, p90 12.00)	0.19x
three load ms (fetch + parse + decode)	104.1 (p10 51.8, p90 329.1)	69.6 (p10 40.2, p90 182.2)	0.67x
three load + first frame ms	114.7 (p10 60.2, p90 338.4)	75.6 (p10 48.3, p90 187.0)	0.66x
67js load ms	171.7 (p10 101.4, p90 576.3)	103.2 (p10 81.0, p90 203.0)	0.60x

Texture formats seen: three webp rgba8, three ktx2 bc7, 67js webp rgba8, 67js ktx2 bc7.

LOD	Triangles (median)	Texture + geometry VRAM, MiB (three)	three load ms	67js load ms
lod0 (objects_ktx2)	19484	12.27	69.6	103.2
lod1	9742	3.15	23.7	39.0
lod2	3896	0.82	9.3	20.1
lod3	1168	0.21	6.9	14.6

Encoding: colour and metallic-roughness maps are ETC1S, normal maps are UASTC at half the edge so that their directions survive. Each KTX2 texture was encoded from Amazon's own image, not from the WebP copy. The LODs come from meshoptimizer's simplifier at 50%, 20% and 6% of the triangles, and stop early when the error grows too large.

Load a KTX2 model in three.js with WebGPURenderer:

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 renderer = new WebGPURenderer({ antialias: true });
await renderer.init(); // the transcoder needs to know which compressed formats this device takes

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('https://huggingface.co/datasets/codepawl/abo-glb/resolve/main/objects_ktx2/B0714QGC72/B0714QGC72.glb');
scene.add(gltf.scene); // far away: lods/B0714QGC72/B0714QGC72_lod2.glb

The same file in 67js:

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 ktx2 = new KTX2Loader().setTranscoderPath('https://cdn.jsdelivr.net/npm/three@0.187.0/examples/jsm/libs/basis/');
ktx2.workerConfig = ktx2WorkerConfigFor(renderer.context); // renderer: your Renderer67
const asset = await loadGltf('https://huggingface.co/datasets/codepawl/abo-glb/resolve/main/objects_ktx2/B0714QGC72/B0714QGC72.glb', {
  decoders: { ktx2, meshopt: MeshoptDecoder },
});

Godot

Tested in Godot 4.7.2. Godot does not read EXT_meshopt_compression or KHR_mesh_quantization, so use the engine/ copy. Godot reads its KTX2 textures and makes its own LODs on import.

Put engine/<id>/<id>.glb and collision/<id>/<id>_collision.glb in the project. Each node in the collision file ends in -convcolonly, so Godot imports it as a StaticBody3D with a ConvexPolygonShape3D and no visible mesh. For a body that moves, put the shapes under a RigidBody3D next to the model.

In other engines, read each node of the collision file as one convex mesh. 64 points fit the PhysX limit of 255 vertices that Unity and Unreal use. Unity and Unreal imports have not been tested.

How the files were made

1. List the 7,953 GLB files under 3dmodels/original/ in ABO's public S3 bucket (165.6 GB on 2026-11-04).
2. Download each file and check its byte size against the listing.
3. Optimize with glTF Transform: dedup, prune and weld. Convert every texture to WebP at quality 88, at most 2048 px. Compress the geometry with meshopt. Triangles, materials and node transforms stay as they are.
4. From the same source file, write the KTX2 copy and the three LODs with toktx 4.4.2.
5. Build the convex hull with quickhull3d and cut it to 64 points by farthest point sampling.
6. Cut the lod2 copy into convex parts on the GPU with cuacd (threshold 0.08). Clamp each part to the model's bounds, because cuacd's remesh grew the parts by about 1.4 cm. Cut each part to 64 points the same way.
7. Remove the meshopt and quantization extensions from the KTX2 copy with glTF Transform for engine/.
8. Join the ABO listings to each model by 3dmodel_id for the names and product data.
9. Render a 512 px thumbnail of every pack file in headless Chrome.

Before the full run, 32 objects were rendered from Amazon's file and from the pack file with the same camera. The mean pixel difference was 0.12 to 1.75 out of 255.

Known gaps

ABO places some products by use, so 1,338 models reach below Y = 0: most are wall art (598), pillows (192), light fixtures (179) and mirrors (107). Wall art and mirrors have their back on Z = 0. Listing text comes from many Amazon stores, so some names are in other languages and some fields are empty. The textures are lossy WebP or Basis, so use ABO's own files when you need the 4096 px maps. collision_hulls.json holds one convex hull, so a chair or a shelf collides as one solid block there. Use collision/ for the parts. Each model is one rigid mesh with no rig and no separate moving parts, so doors, drawers and wheels do not animate.