STL to GLB Converter

Why convert STL to GLB at all

STL is a print-bed format — a bag of triangles with no units, no color, and no idea it might one day be shown on a screen. GLB (binary glTF) is the format the web actually renders. It's what three.js, Babylon.js, Google's model-viewer, Windows 3D Viewer, and Android's Scene Viewer all read natively. Converting gets you:

• One file that drops straight onto a web page. GLB packs the scene graph and the geometry into a single binary — point model-viewer or a three.js GLTFLoader at it and it renders. No mesh-to-buffer wrangling.
• Real-world scale, baked in. glTF's unit is the meter. Cadre scales your millimeters to meters on the way out, so a 20 mm bracket is 0.02 in the file and shows up at true size in AR — not as a 20-meter monster (see below).
• Correct, web-ready shading. Geometry comes through indexed and de-duplicated, hard edges preserved, with a double-sided material so an open mesh doesn't render full of holes.
• The on-ramp to AR. GLB is the source format for Android Scene Viewer and converts cleanly to USDZ for iOS Quick Look — the same file embeds your part in a product page or a phone-held AR view.

The scale gotcha most converters get wrong

This is the one worth knowing about. STL stores no unit — just numbers. glTF says those numbers are meters. So the naïve conversion — copy the STL's millimeter coordinates straight into a glTF — produces a model that's 1000× too large: a 50 mm part becomes 50 meters. In a forgiving viewer that auto-frames the camera you might not notice; in AR, in a physics scene, or composited next to other models, it's badly wrong.

Cadre converts millimeters to meters as part of writing the file, so the GLB is at honest physical scale wherever scale actually matters. The converter doesn't reorient your mesh — the geometry comes through exactly as the STL stored it, so if your part was authored Z-up (as most print STLs are), it keeps that axis and you may want to rotate it in your viewer.

STL vs GLB

They store the same triangles, but GLB is built for a renderer and STL is built for a print bed.

• Structure. STL is a flat triangle list with nothing else. GLB is a binary glTF container with a scene graph, indexed vertex accessors, and a materials section — geometry plus everything a viewer needs to draw it.
• Units. STL has none; glTF is defined in metres. That mismatch is exactly the 1000× trap above, which is why the scale step matters.
• Materials and color. STL carries neither. glTF supports full PBR materials, per-vertex normals, and textures — but a converted STL arrives with a single neutral matte material, because a mesh has nothing to fill those slots with.
• Editability. Both are display meshes, not parametric models. GLB isn't something you re-dimension; it's something you show — the win is that it shows correctly on the web without a plugin.
• What's gained, what's lost. You gain a web- and AR-ready file at true scale, with clean shading; you lose nothing from the STL, since the geometry is preserved and simply repackaged for rendering.

One honest caveat

Converting an STL to GLB does not add color, materials, or textures — an STL never carried any, so there's nothing to recover. The body comes through with a neutral matte material. GLB's rich PBR material story is real, but it needs a model that has materials to begin with. If you want a colored, textured GLB, build the model with per-body colors in Cadre's editor and export GLB from there — each body keeps its color as a glTF material.

What is a GLB file?

A GLB (.glb) is the binary form of glTF, the Khronos Group's "JPEG of 3D" — a royalty-free runtime format for delivering models to renderers. It bundles the glTF JSON scene description, the binary vertex data, and any textures into one self-contained file. You'll see it wherever 3D meets the web and devices: three.js and Babylon.js scenes, Google's model-viewer, Android Scene Viewer, and (via a USDZ hop) iOS Quick Look AR.

Your file never leaves your browser

Plenty of "free online" converters upload your STL to a server, convert it there, and keep a copy. A handful run in the browser now, too, so whether it uploads isn't the interesting question — what builds the glTF is. Here's what's actually different:

• A CAD kernel writes the glTF, not a stitched-together script. The Rust kernel behind Cadre's editor, compiled to WebAssembly, indexes the mesh, scales it, and assembles the GLB binary inside this tab. Your part is read and returned as a download in one pass — there's no upstream leg where it could be copied.
• Spec-conformant glTF 2.0. The GLB is built against the Khronos glTF 2.0 specification — correct binary header, JSON and BIN chunks, accessor bounds, and PBR materials — so any conformant loader (three.js, Babylon.js, model-viewer, Blender) treats it as a standard file, not a "mostly works" approximation.
• No gate on the output. You don't create an account to run it, there's no per-day conversion limit, and the GLB downloads without a watermark object or a branded material dropped into the scene.

How it works

Cadre is a browser-based CAD editor whose Rust geometry kernel is compiled to WebAssembly and runs on your own hardware. Drop a file and that same kernel imports your mesh, welds and de-duplicates it, scales it to meters, and writes a binary glTF — almost instantly for typical part-sized models. A dense scan takes a little longer, because the indexing and scaling run on your own hardware instead of a rendering service in the cloud.

Want color or materials? Model it in Cadre

A converted STL has no material to carry, but a model built in Cadre does. Open the editor, add or import bodies, give each one a color, and export GLB from the File menu — each body keeps its color as a glTF material, ready to embed or drop into a three.js scene. For an embeddable, link-shareable model, the editor is the place to start.

FAQ

Does my file get uploaded anywhere?

No. Indexing, scaling, and packing your mesh into a GLB all run in the tab through WebAssembly — the part is read and the binary glTF is handed straight back, so your geometry never travels to a server. Handy when the model is a client render or an unannounced product.

Is it free?

Yes. Converting STL to GLB costs nothing and needs no account; run it on as many parts as you want, and the GLB downloads clean — no watermark object dropped into the scene.

Why is my model the wrong size after converting STL to GLB elsewhere?

Because STL has no units and glTF is defined in meters, most converters copy the raw millimeter numbers straight across, so a 50 mm part becomes 50 meters — a thousand times too big. Cadre scales millimeters to meters as it writes the file, so the model arrives at true physical scale, which matters for AR and for compositing with other models.

Will the GLB open in three.js, model-viewer, or Blender?

Yes. The output is built against the Khronos glTF 2.0 specification — correct binary chunks, accessor bounds, and PBR materials — so any conformant loader, including three.js, Babylon.js, model-viewer, and Blender, reads it as a standard file.

Does converting STL to GLB add color or materials?

No. An STL stores only triangles — it never had color or materials — so the converted GLB comes through with a neutral matte material. To get a colored or textured GLB you need a model that already has materials; you can build one with per-body colors in Cadre's editor and export GLB that carries them.

Can I convert OBJ to GLB too?

Yes. Drop an OBJ and the kernel reads its mesh, then indexes, scales, and packs it into a GLB the same way — same metre-scaled, web-ready result.

Related

• STL ⇆ OBJ converter — go between the two editable mesh formats desktop 3D tools expect.
• STL to 3MF converter — repackage the mesh for a slicer instead of a browser.
• STL to STEP converter — hand the same geometry to CAM as a faceted solid.
• Edit an STL online — tidy the mesh before you embed it on the web.
• Open Cadre — build a colored, embeddable model and export GLB with real glTF materials.