| --- |
| license: cc-by-4.0 |
| pretty_name: Amazon Berkeley Objects GLB |
| tags: |
| - 3d |
| - gltf |
| - glb |
| - web |
| - three.js |
| - 67js |
| - furniture |
| - pbr |
| - amazon-berkeley-objects |
| size_categories: |
| - 1K<n<10K |
| configs: |
| - config_name: default |
| data_files: |
| - split: train |
| path: |
| - "thumbs/*.webp" |
| - "thumbs/metadata.jsonl" |
| --- |
| |
| # Amazon Berkeley Objects GLB |
|
|
|  |
|
|
| The 7,953 3D models of [Amazon Berkeley Objects](https://amazon-berkeley-objects.s3.amazonaws.com/index.html) |
| (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. |
|
|
| <video src="https://huggingface.co/datasets/codepawl/abo-glb/resolve/main/assets/preview.mp4" autoplay loop muted playsinline width="100%"></video> |
|
|
| | | 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](#for-games-and-webgpu) and [Godot](#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](https://creativecommons.org/licenses/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: |
|
|
| ```bibtex |
| @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: |
|
|
| ```bash |
| hf download codepawl/abo-glb --repo-type dataset --local-dir abo-glb |
| ``` |
|
|
| One model from Python: |
|
|
| ```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](https://github.com/anxuanng/67.js) 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. |
|
|
| ```bash |
| npm install 67js@npm:@codepawlhq/67js three |
| ``` |
|
|
| ```js |
| 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 |
|
|
| ```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`: |
|
|
| ```js |
| 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: |
|
|
| ```js |
| 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](https://github.com/eliphatfs/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. |
|
|
