Convert glTF to STL

The two formats were built for opposite jobs and it shows in everything they carry. A glTF holds a scene graph, materials, textures, UV coordinates, normals, animation channels and cameras, because its purpose is to arrive at a renderer and look right. An STL holds a list of triangles with a normal each, because its purpose is to arrive at a slicer and be sliced.

The conversion keeps the intersection, which is the triangles. Everything else is discarded, and that is the correct outcome rather than a shortcoming — a slicer has nowhere to put a base colour texture, and a printer has no way to reproduce one. What matters is knowing that the STL is the shape of the model and nothing about its appearance, so a model whose interest was in its surface arrives as a plain grey solid.

A `.gltf` is JSON, and the specification lets it keep its vertex data either inside the file as a base64 data URI or beside it in a `.bin`. Exporters overwhelmingly choose the second, so the usual shape of a downloaded glTF is a folder: `scene.gltf`, `scene.bin`, and a `textures` directory. Open the `.gltf` in an editor and the `buffers` array names the file.

A conversion here takes one file and produces one file, so a glTF whose geometry lives next door has no geometry to read. The message says so rather than producing an empty model: "This glTF keeps its geometry in a separate .bin file. Convert the .glb version instead, which has everything in one file." That is the fix. Re-export as GLB from Blender or run `gltf-transform` to pack the buffer, and the same model converts without further argument.

This catches nearly everybody once. glTF declares no unit but the specification and every toolchain around it treat one unit as one metre, so a chess piece is roughly 0.08 units tall. STL declares no unit either, and every slicer ever written treats one unit as one millimetre. The number is carried through faithfully and its meaning changes underneath it.

The result is a model that arrives on the build plate as an all-but-invisible fleck, and the fix is to scale by 1000 on import. Do it against a dimension you know rather than by eye: measure something in the source — the width of a base, the height of a known feature — and check the slicer agrees after scaling. An assumed factor of 1000 is right for a glTF exported from a standards-following tool and wrong for one exported from a CAD package that was already working in millimetres, and the difference between the two is exactly one wasted print.

A glTF scene routinely places one mesh several times with different matrices — the standard example is four wheels referencing one wheel mesh. The converter walks the scene graph from the default scene, multiplies each node’s matrix by its parent’s, and applies the resulting world matrix to the vertices before writing them.

The shape you see is therefore correct and the structure is gone. Four wheels arrive as four sets of triangles in four places rather than as one mesh instanced four times, and the file is four times the size it would have been. Nodes given as separate translation, rotation and scale properties are composed into a matrix first, in the order the specification defines, so a model built that way lands where one built with an explicit matrix does.

An STL has no concept of an object, a group or a name — it is one list of triangles from beginning to end. All the meshes found while walking the scene are written into that single list in the order they were visited, so a model made of a body, a lid and a handle becomes one file containing three separate closed shells.

Slicers handle that well and usually offer to split it: PrusaSlicer and Cura both detect disconnected shells and can separate them into individual objects on the plate. What is lost is the naming — the parts come back as "Part 1", "Part 2" and "Part 3" rather than as whatever the glTF called them. If the names matter, convert to 3MF or OBJ instead, both of which keep them.

Three refusals, each with its own message. Draco-compressed geometry stops with a named error, because `KHR_draco_mesh_compression` stores vertices in a stream that needs its own decoder and that decoder is not shipped here. A glTF whose buffer sits in a `.bin` stops for the reason above. A file containing no triangle geometry at all reports that nothing was found.

One thing is skipped rather than refused: primitives that are not triangle lists. glTF mode 4 is triangles; modes 0 to 3 are points, lines, line loops and line strips, and modes 5 and 6 are triangle strips and fans. Strips and fans are legitimate surface geometry and they are passed over, so a model exported by a tool that emits them will convert to fewer triangles than it has, or to none. If the triangle count in the STL is well below what the source reported, that is the reason to check.

An STL is fifty bytes per triangle plus an eighty-four byte header, exactly and always: twelve bytes of normal, thirty-six of vertex coordinates and two spare. There is no vertex sharing in the format, so a corner used by six triangles is written six times.

A glTF stores each vertex once and refers to it by index, which is typically three to four times more compact for the same surface. Expect the STL to be several times the size of the geometry portion of the source — a 400,000-triangle model lands at almost exactly 20 MB whatever it came from. The free ceiling here is 100 MB, which is around two million triangles, and a model that large is beyond what most slicers are comfortable with anyway.

Converting the file is the easy half. Assets built for rendering are routinely made of surfaces rather than solids: a cape with no thickness, a window that is a single plane, a character whose arms intersect the body rather than joining it. A renderer draws all of that happily. A slicer has to decide what is inside and what is outside, and a surface with no thickness has no inside.

Expect to repair. PrusaSlicer and Cura both flag non-manifold geometry on load and offer a repair; 3D Builder used to close simple holes on Windows and is no longer obtainable, having been deprecated in July 2024 and pulled from the Store; Blender’s 3D-Print Toolbox reports non-manifold edges, zero-area faces and intersecting geometry with a count and a jump-to button. Do that before you scale, not after — a repair tool given a two-millimetre model makes different decisions from one given a two-hundred-millimetre one.

If the model is going back onto a screen, keep the glTF. Converting to STL and back loses the materials permanently, and there is no route that recovers them. If the model is going to be modified rather than printed, OBJ keeps the part names and 3MF keeps the units, and both are better landing places than a bag of triangles.

And if the model was bought or commissioned, check the terms before printing rather than after. Asset marketplace licences frequently cover use in a rendered scene and say nothing about physical reproduction, which is a different right. That has nothing to do with the conversion and everything to do with what happens next.

In this browser tab, by plain JavaScript. No WebAssembly module is fetched, no request carries the model, there is no account and no daily allowance, and the network tab during a conversion is the way to confirm that.

It is worth more than the usual privacy line here. Commissioned and licensed 3D assets arrive under terms that often forbid uploading them to third-party services at all, and a model of an unreleased product is a disclosure risk before it is a licensing one. Nothing leaves the machine, so neither question arises.