Why AR on the web needs both GLB and USDZ
There is no single 3D format that every phone will open in AR. Here is why, and what it means for anyone shipping 3D on a product page.
If you have ever shipped a 3D model to a product page and watched the AR button do nothing on an iPhone, this is why.
There is no single 3D file format that every platform will open in augmented reality. Not one. The web solved this problem for images decades ago and never solved it for 3D, so anyone putting a product model on a storefront has to ship the same asset twice.
Three renderers, two formats
A visitor tapping “view in your space” is not using your website’s renderer. They are handing the model to an operating system component, and there are three of them in play.
Quick Look is Apple’s. It is built into iOS, iPadOS and macOS, it opens from Safari without an app install, and it reads USDZ — Pixar’s Universal Scene Description packaged as an uncompressed zip. It does not read glTF. There is no flag to make it read glTF.
Scene Viewer is Google’s, on Android. It reads GLB, the binary form of glTF. It does not read USDZ.
WebXR renders in the browser itself rather than handing off, which means the page’s own renderer stays in control. In practice that means GLB.
Two of the three want GLB, one wants USDZ, and the one that wants USDZ is roughly half of e-commerce traffic in most Western markets. You need both.
What this looks like in the markup
The common way to render 3D on a product page is Google’s model-viewer web component. The
relevant part of the configuration is short:
<model-viewer
src="model.glb"
ios-src="model.usdz"
ar
ar-modes="webxr scene-viewer quick-look"
camera-controls>
</model-viewer>
src feeds the inline viewer and Scene Viewer. ios-src is the escape hatch that hands Quick
Look a USDZ instead. ar-modes lists the AR paths in priority order, and the component walks
the list until it finds one the device supports.
The failure mode is instructive. If you omit ios-src, nothing breaks at build time, nothing
warns you, and the page still works — the inline 3D viewer renders fine on an iPhone because
that is just WebGL. The AR button appears, because the component cannot know in advance that
the handoff will fail. Tapping it does nothing. You only discover this by picking up an iPhone,
which is exactly the device most e-commerce teams test last.
Why not just convert on the fly?
You can, but not in the request path. Converting between GLB and USDZ is not a format re-wrap — it means importing a scene graph, resolving materials, and re-exporting through a tool that understands both. In practice that means driving Blender headless, and it takes seconds to minutes per model depending on mesh density. That is fine as a background job at upload time. It is not fine while a customer waits for a product page.
So the conversion happens once, on upload, and both files are stored. In the Blendspace pipeline every accepted upload produces both a GLB and a USDZ, and uploading one of them short-circuits: give it a GLB and it keeps your original and generates only the USDZ.
The part nobody warns you about: material extensions
Here is the failure that costs people an afternoon.
glTF has an extension mechanism. Material extensions like KHR_materials_specular and
KHR_materials_ior let you specify specular response and index of refraction with more
physical accuracy than the base spec allows. Blender exports them happily. Desktop glTF
viewers render them correctly. Your model looks right everywhere you check.
Then it reaches Quick Look, whose extension support is narrower, and the material renders wrong — often as a flat grey or an implausible sheen. The model is not corrupt. The exporter is not buggy. The viewer simply does not implement that extension, and the glTF spec says a viewer may ignore extensions it does not understand.
The fix is to strip those extensions from the GLB before serving it and let the base colour
texture in pbrMetallicRoughness carry the appearance. Every target viewer implements
pbrMetallicRoughness. You lose a small amount of physical accuracy that a product thumbnail
at 400 pixels tall was never going to show anyway, and you gain a model that looks the same
everywhere.
If you are stripping GLB chunks yourself, remember the container rules: the JSON chunk must be padded to a four-byte boundary, with spaces rather than nulls. Rewrite the JSON without fixing the padding and you get a file that some parsers accept and others reject, which is a worse outcome than an obvious failure.
Practical checklist
If you are shipping 3D to a storefront, whatever tooling you use:
- Ship both GLB and USDZ. Not one with a promise to add the other later.
- Test AR on a real iPhone and a real Android device. The desktop viewer working proves nothing about either.
- Model in metres and centre the origin. AR placement is real-world scale from the model origin, so a model authored in centimetres appears at the wrong size in someone’s room.
- Keep textures at 2K or below and decimate the mesh. Mobile AR is a bandwidth and memory budget, not a render farm.
- Check materials in Quick Look specifically, not only in a desktop glTF viewer. It is the strictest target in the chain.
None of this is exotic, but all of it is invisible until an iPhone in someone’s hand does nothing when they tap the button.
Related
- Supported 3D file formats — the exact inputs, outputs and limits in the Blendspace pipeline.
- Frequently asked questions