STL to GLB Converter

Drop an STL (or OBJ) and download a GLB — converted entirely in your browser, never uploaded to a server. GLB is the web's native 3D format: it opens in three.js, model-viewer, Babylon.js, and AR, and Cadre writes it scaled to real-world meters so it arrives at the right size instead of a thousand times too big.

Drop an STL or OBJ file here

Your file is processed in your browser — never uploaded.

Open the editor →

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 kernel is Y-up — the same axis convention glTF uses — so the model also arrives upright, no sideways surprise.

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.

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 few run locally now too, so "no upload" alone isn't the whole story. Here's what's actually different:

  • It's the real geometry kernel, not a script. The same Rust kernel that powers Cadre's modeler is compiled to WebAssembly and does the conversion inside this tab. Your file is read, converted, and handed back as a download — it never goes to a server, and there's nothing to retain.
  • 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 account, no quota, no watermark. Nothing is gated and nothing is stored, because nothing is sent.

How it works

Cadre is a browser-based CAD editor whose Rust geometry kernel runs client-side via WebAssembly. 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. Large scans take longer because everything runs on your machine, not a server farm.

Want color or materials? Model it in Cadre

A converted STL is colorless, but a model built in Cadre isn't. 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. The conversion runs locally in your browser via WebAssembly. Your STL is never uploaded, never stored, and never retained — unlike many online converters, which upload your file to a server and keep the output for a while.

Is it free?

Yes — converting STL to GLB is free, with no account, no upload, and no watermark on the output.

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 instead of an STL and you'll get a GLB back the same way.

Related