Blog · Format primers

What is a GLB file? Understanding glTF Binary

Last updated 11 June 2026

A GLB file is a single, self-contained binary file that holds a 3D model — its geometry, textures, materials, and any embedded animations. It's the "shipping" form of glTF, the format the Khronos Group designed to be "the JPEG of 3D": small, fast to load, and identical-looking everywhere it's opened.

The short version

GLB is the binary form of glTF. The two formats describe the same thing — they just package it differently:

• .gltf is a JSON file describing the model, usually accompanied by a separate .bin file for geometry data and several external image files for textures.
• .glb bundles all of that into a single binary file. One file in, model out — nothing missing, nothing to lose.

For sharing a 3D model with someone, GLB is almost always the right choice. The .gltf form is more useful during authoring when you want to swap textures or edit the JSON, but it's brittle for distribution because external files can go missing.

Where glTF came from

glTF was created by the Khronos Group — the same standards body behind OpenGL, Vulkan and WebGL — and version 1.0 shipped in October 2015. Khronos explicitly positioned it as "the JPEG of 3D" — a royalty-free runtime format whose job is transmission and loading speed, not authoring.

That distinction matters. Formats like OBJ, FBX and Blender's native .blend were designed for editing — they preserve every curve, modifier and history step of a model. glTF deliberately throws all of that away and stores only what's needed to render the finished thing. The trade is enormous file-size and load-time savings, in exchange for not being editable in the same way.

glTF 2.0 launched in 2017 and introduced the PBR material model that's now standard across the entire format. Since then it has accumulated a steady stream of extensions — optional add-ons covering things like Draco geometry compression, KTX2 / Basis texture compression, transmission for glass and water, sheen for fabric, clearcoat for car paint, anisotropy for brushed metal, and AR-specific metadata.

What's actually inside a GLB

The file layout is unusually clean for a 3D format. A GLB consists of:

1. A 12-byte header — magic number glTF, version (currently 2), total length.
2. A JSON chunk containing the scene structure: nodes, meshes, materials, animations, references into binary data.
3. A binary chunk containing the geometry buffers (vertex positions, normals, UVs, indices) and the texture image bytes.

The JSON manifest is the brains of the file. It describes a scene graph — nodes with transforms, optionally instancing meshes, optionally controlled by animations. Each mesh references a set of geometry buffers in the binary chunk via byte offsets and lengths. Each material references textures (also in the binary chunk) and provides PBR parameters.

Geometry

glTF geometry uses GPU-native primitive layouts — positions, normals, UVs, tangents, vertex colours, joint indices and weights for skinning, plus an index buffer. The data is stored in a form that a WebGL or modern OpenGL renderer can upload to the GPU with essentially no transformation. That's where the load-speed advantage over OBJ or FBX comes from — neither of those is GPU-shaped.

Materials — PBR by default

glTF picked metallic-roughness PBR as its standard material model. A material has:

• Base colour — the diffuse colour or albedo, often supplied as both a factor (RGBA tint) and a texture.
• Metallic-roughness — how metallic the surface is (a metal vs a dielectric) and how rough it is (matte vs polished), again either as factors or textures.
• Normal map — surface detail without adding geometry.
• Emissive — surfaces that emit light independently of scene lighting.
• Occlusion — pre-baked ambient occlusion.

Because PBR is grounded in physics, the same material looks consistent in Blender, three.js, Unity, Unreal, Apple Quick Look and Google Scene Viewer. Send a GLB and the recipient sees what you saw.

Animations

glTF supports animation tracks that target node properties (translation, rotation, scale), morph target weights, and skinned mesh joints. Multiple animations can coexist in the same file — a character GLB might contain "idle", "walk" and "jump" tracks, played by name at runtime. Interpolation is built in (step, linear, cubic spline) so you only store keyframes, not every interpolated value.

The compression extensions

Raw GLB is already smaller than the alternatives, but the format's extension system pushes it dramatically smaller still.

Draco

Draco is a Google-developed mesh compression library that can shrink positions, normals, UVs and indices by 80–95%. It's expressed as the KHR_draco_mesh_compression extension. A 30 MB raw GLB often becomes 3–5 MB with Draco — at the cost of a few hundred milliseconds of WebAssembly decode at the receiving end. Most modern exporters (Blender's glTF plugin, three.js's GLTFExporter, gltf-transform) support it.

KTX2 / Basis Universal

Texture compression. JPEG and PNG are fine for viewing in a browser image tag, but they have to be fully decoded into RAM before being uploaded to the GPU. KTX2 with Basis Universal transcodes once into a GPU-native compressed format, saving both memory bandwidth and runtime memory. Larger PBR scenes benefit massively.

Meshopt

An alternative to Draco that decodes faster (no WASM startup cost) and ships with simpler tooling. The trade-off is slightly lower compression ratios than Draco for the same input. Picked by some pipelines (most notably Sketchfab and some Web AR services) for the latency advantage.

When to use GLB

GLB is the right choice when:

• You're shipping a 3D model to the web — three.js, Babylon.js, model-viewer, R3F all load GLB natively.
• You're producing content for AR — iOS Quick Look uses USDZ but Android Scene Viewer expects GLB, and most pipelines author in GLB and convert.
• You want to send a textured, materialed model to someone without sending a folder of files.
• You need fast load times because the recipient might be on mobile data or behind a poor connection.
• You want consistent PBR rendering across every viewer the recipient might use.

When GLB is the wrong choice

GLB is bad for editing. If you want someone to be able to modify the model in Blender or Maya as if it were a native scene, send a .blend or .fbx or .obj instead. glTF deliberately bakes the model into a render-ready form and most of the source authoring data — subdivision modifiers, parametric history, named layers — is gone.

GLB is also overkill for 3D printing. Slicers don't care about your PBR materials or animations, and many don't accept GLB at all. Stick with STL or 3MF for printing.

How to view a GLB file

Most modern 3D tools accept GLB:

• In your browser: open open3d.app/viewer and drag the file in. PBR, Draco and animations all work.
• On iPhone or Android phone: open3d.app in the phone's browser, or any GLB viewer app.
• Blender: File → Import → glTF 2.0.
• Unity: via the official glTFast or UnityGLTF packages.
• Unreal Engine: via the Datasmith glTF importer or third-party plugins.
• Khronos's own glTF Viewer at github.khronos.org/glTF-Sample-Viewer-Release/.

FAQ