Convert FBX, OBJ and More to glTF Directly in Your Browser — No Upload

If you've ever tried to put a 3D model on the web, you know the pain. The artist hands you an FBX. Your engine wants glTF. The "converter" you find online wants you to upload a 40 MB scene to a stranger's server, wait, then download the result — assuming the upload didn't fail.

WebConverter now does the whole conversion in your browser. Drop your file, get glTF or GLB back, never touch a server.

The supported inputs at launch:

• FBX and OBJ via ufbx — the small, fast native parser
• glTF / GLB via Magnum's own GltfImporter (round-trip optimisation and the GLB → glTF / glTF → GLB transcoders)
• PLY via Magnum's StanfordImporter
• STL via Magnum's StlImporter
• COLLADA (.dae), 3DS, LWO, Blender .blend, DirectX .x and other long-tail formats via Assimp — only when no native importer exists for the format
• Both glTF JSON and binary GLB output

Native first, Assimp last

3D importers vary wildly in size and quality. Assimp is the obvious choice for "load anything" but its FBX, OBJ and glTF importers are notably weaker than the dedicated libraries each format already has — and Assimp pulls in megabytes of parsing code per build. We bias hard toward the native importers and only fall back to Assimp where no native plugin covers the format.

The build produces two WebAssembly modules. SceneImporterNative.wasm bundles the lightweight native importers (Ufbx for FBX/OBJ, Magnum's GltfImporter for glTF/GLB, StanfordImporter for PLY, StlImporter for STL, OpenGexImporter for OGEX) — they share the same Magnum runtime, so packing them together is cheap. SceneImporterAssimp.wasm is the heavier catch-all, fetched only when a user uploads a long-tail format. If you only convert mainstream formats, you never pay the Assimp download.

The Worker picks the plugin per file at runtime, so a user can convert an FBX followed by a glTF without re-fetching the WASM. Adding a future format (STEP, IGES, CAD) is one new entry in the route table — no impact on existing paths.

What's inside

The pipeline is built on the Magnum graphics library:

1. The selected AbstractImporter plugin opens your file and produces Magnum's in-memory scene representation.
2. Optionally, MeshOptimizerSceneConverter re-encodes each mesh for the GPU vertex cache (vertex cache locality, overdraw reduction, vertex fetch) and/or simplifies it by a target ratio you pick.
3. GltfSceneConverter writes the result as glTF 2.0 (with embedded buffers) or binary GLB.

That same MeshOptimizer step is what powers our Optimize glTF/GLB, Simplify 3D Model, and Compress 3D Model for the Web pages — if you already have a glTF and just want it smaller and faster on the GPU, drop it there.

Privacy and offline

Because the whole pipeline runs in WebAssembly in your browser:

• Your model never leaves the tab. There is no server, so there is nothing to upload, store, log, leak, or rate-limit.
• It works on slow or metered connections — the page itself is a few hundred KB; the WASM module is fetched once per session and cached.
• It runs offline after the first load, like our PDF tools.
• It counts toward your CO₂ savings: input + output bytes that did not go over the wire.

For AI agents: WebMCP

The same conversion is also exposed as a WebMCP tool — convert_3d_to_gltf — so any in-browser AI agent can call it directly through document.modelContext. Pass base64 bytes, a filename, and (optionally) optimize / simplifyRatio / outputFormat; get base64 glTF or GLB back. All locally.

Coming next

The texture side is the next obvious win. The UI already has a placeholder toggle for KTX2 (Basis Universal) texture compression — supercompressed GPU textures that ship a fraction of the bytes. The encoder module follows in a separate release; the pipeline slot is already wired in convertScene(), so it's a drop-in.

Beyond that, the architecture is ready for STEP/CAD formats: one extra WASM module, one entry in the worker's routing table, no other code changes.

Try it: 3D Model to glTF Converter.