GLB to OBJ conversion turns a packed binary glTF scene into a plain-text Wavefront mesh. In practice you keep the geometry — vertex positions, normals and UVs — and you lose most of what made the GLB convenient: materials, textures, animation and skinning. Knowing that trade in advance is what stops a broken hand-off later, so this guide walks through what the two formats are, what the conversion actually changes, and how to run it in the browser without uploading your file.
What GLB and OBJ Actually Are
Both are containers for 3D data, but they aim at different jobs. GLB is built for delivery; OBJ is built for exchange.
GLB: a complete scene in one file
GLB is the binary form of glTF, the open format maintained by the Khronos Group. A single .glb file can pack meshes, materials, textures, skins and animation clips into one container, which is why it is the default for web viewers, AR and game engines. When you open a GLB in a browser glTF viewer, the geometry and any textures stored inside the file are read with the three.js GLTFLoader, though animation clips are not played by the viewer.
OBJ: a mesh with a sidecar material file
Wavefront OBJ is a plain-text format from the early 1990s. It stores vertex positions, normals, texture coordinates and faces — and that is essentially it. Materials live in a separate .mtl file that references texture images by path. OBJ has no concept of animation, skinning, lights or a scene graph beyond grouping objects by name. Its longevity comes from how many tools read it and how easy it is to diff and inspect by eye.
Why conversion exists
Modern pipelines export GLB because it is complete and compact. Legacy pipelines — older DCC tools, some CAD and sculpting workflows, and a few renderers — still expect OBJ. Conversion is the bridge, and the browser 3D converter is built for exactly that bridge job.
What the Conversion Actually Changes
The important thing to understand is that "converting" is really re-encoding a subset. A GLB can express far more than OBJ can, so anything OBJ has no field for is dropped rather than translated. The table below is the honest summary of a GLB → OBJ pass.
| Data in the GLB | What OBJ can store | After GLB → OBJ |
|---|---|---|
| Vertex positions | Yes | Kept, as plain text |
| Normals | Yes | Kept when present |
| UV / texture coordinates | Yes | Kept when present |
| Vertex colours | No standard field | Dropped |
| PBR materials | Only via a separate .mtl | Not written by the tool |
| Textures / images | Only via .mtl references | Dropped from the converted file |
| Skeletal animation | No support | Dropped |
| Skinning / bones | No support | Dropped |
| Object grouping | Names only | Kept as object names when possible |
| Scene graph / transforms | Limited | Flattened |
| Units | Unspecified | Unchanged; treat size as relative |
Materials
Materials are the first casualty. A GLB carries physically based materials with base colour, metallic, roughness and normal maps baked into the file. The tool writes OBJ as geometry only — it does not emit an .mtl sidecar, so the surfaces fall back to whatever default material the receiving application assigns. If your GLB looked correct and the OBJ opens flat grey, that is expected, not a bug.
Animation
OBJ has no animation channels. A walk cycle, an idle loop or a rigged dance stored in the GLB cannot be represented, so the conversion produces a static mesh in its stored pose. If motion is the point of your asset, convert before rigging or keep the animation in a format that supports it — our own generator exports animated FBX motion data for game engines for that reason.
Textures and vertex colours
Texture images live outside the OBJ spec. Even when a .mtl file exists, it only points at image files that must travel alongside; the converter here does not write that .mtl, so textures are dropped. Vertex colours painted on a scan or a stylised mesh also have no standard OBJ field and are lost. If colour matters, keep the GLB or export an alternative.
Step-by-Step: GLB to OBJ in the Browser
You do not need Blender or a command-line tool for a one-off conversion. The whole job runs locally in your browser — nothing is uploaded, and the result exists only on your device until you download it. The converter below is the same tool as the GLB to OBJ converter page, already set to GLB in and OBJ out.
- Use the converter above. It reads
.glb(or.gltf) and writes.objusing three.js loaders and exporters; the standalone GLB to OBJ page works the same way. - Choose your file. Click the picker and select the
.glbfrom your device. A preview appears on the stage so you can confirm the model read correctly before converting. - Check the preview. Rotate, zoom and pan to make sure the geometry looks right. Because animation is not played, the model appears in its stored pose.
- Press convert. The exporter walks the scene and writes positions, normals and UVs per object into OBJ text.
- Download the
.obj. Save it next to whatever else your pipeline expects, then import it in your target tool.
If the file is very large, the tab may pause while it is parsed and re-written; that is normal for a single-threaded in-browser export. For a quick look at a file you only want to inspect, the OBJ viewer will open it directly too, again without an upload.
Common Failure Cases and How to Read Them
- The OBJ opens grey. Expected. Materials and textures are not part of the converted file. Rebuild them in the receiving tool or keep the GLB.
- The model has no motion. Expected. Animation and skinning are dropped; OBJ is a static format.
- The OBJ file is much larger than the GLB. Expected too. OBJ is uncompressed plain text, so the same mesh usually occupies more space.
- The model is rotated or mirrored. OBJ does not standardise an axis convention the way glTF does (glTF is Y-up). Some tools import OBJ as Z-up, so rotate the object once after import.
- Colours disappeared on a scanned mesh. Vertex colours are not written, so a scan that relied on them will look plain.
- The GLB preview is empty. Confirm the extension matches the real format and that the file is not truncated. A corrupt or non-GLB file will not parse.
When OBJ Is Still the Right Target
OBJ remains the most universally readable mesh format, and for pure geometry — a single prop, a sculpt, a printable part — it is often the simplest thing to hand someone. Use it when the receiver only needs shape, when their tool has no GLB import, or when you want a human-readable file you can inspect line by line. For anything that depends on appearance or motion, keep the GLB and convert only for the specific legacy step that demands it.
FAQ
What is lost when converting GLB to OBJ?
Geometry — positions, normals and UVs — is kept. Materials, textures, vertex colours, animation, skinning and the scene hierarchy are not written to the OBJ, so they do not survive the conversion. Treat the OBJ as a mesh-only copy.
Does the GLB to OBJ converter upload my file?
No. The file is read from your device and parsed locally with JavaScript, then the OBJ is written in the same tab. Nothing is sent to a server, and the result exists only on your machine until you download it.
Can OBJ store animation?
No. OBJ has no animation channels, so any motion baked into the GLB is dropped and the exported mesh is static. If you need an animated asset, keep it in GLB, FBX or another animated format.
Why does my converted OBJ look flat grey?
Because the OBJ carries no material information. Materials in OBJ live in a separate .mtl file that this converter does not write, so the receiving application applies its default grey material. Reassign materials after import.
Is OBJ or GLB better for a game engine?
For most modern engines, GLB is the better delivery format because it keeps materials, textures and animation together in one compact file. OBJ is useful for geometry-only exchange and for tools that cannot read glTF.
Do I need to install anything to convert GLB to OBJ?
No. The conversion runs in the browser on your device using standard three.js loaders and exporters, so there is no software to install and no file to upload. Heavier models simply take longer to parse.