Decimate a mesh, and find out what it cost you

Point it at a .glb or .fbx, say how many triangles you want to keep, get the reduced asset back — plus the number that actually decides whether you can ship it: how far the surface moved.

Headless Blender 4.5 LTS. Outputs GLB, FBX, USD, USDC, USDA or USDZ. The source format is detected from the file's bytes, not its extension. No UI, no login, callable by agents over MCP.

Hitting a triangle target is the easy part

Every decimator does that. What none of them tell you is whether the result still looks like the thing you started with — so you end up opening each asset and eyeballing it, which is exactly what does not scale to a few thousand of them.

So every run measures the distance between the original surface and the reduced one, in both directions, and normalises it to the bounding-box diagonal so the number means the same thing on a teacup and on a cathedral:

DamagedHelmet, 15 452 → 7 725 triangles
  original → decimated   p95 0.080 %   max 0.166 %
  decimated → original   p95 0.070 %   max 0.122 %

Half the triangles, and the surface never moved more than 0.17 % of the model's own size. Ship it without looking.

Both directions matter. A reduced surface can sit perfectly on the original while whole features have quietly disappeared — only measuring original → decimated catches that.

Cross a threshold and you get told:

Fox, 576 → 288 triangles
  warning: HIGH_SILHOUETTE_DEVIATION   p95 1.21 %   max 4.14 %

That fox was already low-poly. Halving it genuinely deforms the silhouette, and the report says so instead of quietly handing you a broken asset.

UVs are verified, not assumed

A reduction that hits its triangle target and quietly wrecks the texture mapping is worse than no reduction at all, so three separate things get measured per UV layer, by layer name — losing the second set is how a lightmap or an AO bake silently disappears.

Texel density. UV area per unit of surface. If it drifts, the same texture now covers a different amount of the model and reads as stretched.

Island count. Islands are found by union-find over shared UV edges. This catches what an average cannot: a density figure can sit perfectly flat while the layout underneath has been rearranged.

Overlap. UV triangles are rasterised into a grid and cells carrying more than one face are counted. Only overlap the decimator added is flagged — mirrored and tiled UVs overlap on purpose, and a naive detector screams at them. On a test asset whose second UV set is 100 % overlapping by design, the report correctly records it as pre-existing and stays quiet.

DamagedHelmet, half the triangles
  UVMap   islands 486 → 452 (−7 %)   overlap +0 pt   density −0.4 %

MorphStressTest, half the triangles, two UV sets
  UVMap       density 5.20482 → 5.21877   drift +0.268 %
  UVMap.001   density 0.03631 → 0.03638   drift +0.200 %

A warning about planar

Planar reduction preserves the silhouette almost perfectly — 74 % of the triangles off a chess set for a geometric deviation of 0.01 %. Measure the UVs, though, and the picture reverses: it merged 56 % of the UV islands and introduced overlap.

Use planar on untextured geometry, trim-sheet assets or collision proxies. Do not use it on a uniquely-unwrapped textured asset. The report will tell you either way, which is the whole point — this limitation was found by the tool measuring itself, not by reading the manual.

What a reduction destroys, stated plainly

Vertex order does not survive. Decimation rebuilds topology, so anything keyed to vertex indices breaks: morph targets, point and vertex caches, Alembic streams, external per-vertex data, any downstream vertex ID. Skin weights are the exception — they are interpolated onto the new vertices, and the report verifies that rather than assuming it.

Meshes carrying morph targets are refused by default, because Blender cannot apply a decimate modifier to them at all: the asset would come back completely unreduced while the run reported success. You get HAS_SHAPE_KEYS, the list of blendshape names, no output and no charge. Set shapeKeyPolicy to strip to drop them deliberately — never silently.

Instanced scenes work properly

A chess set, a kitbash, a forest — production scenes share mesh data between objects, and Blender flatly refuses to apply a modifier to multi-user data. Reduce object by object and you get "Modifiers cannot be applied to multi-user data" on most of the scene.

This Actor reduces each unique mesh once and re-points the instances at the result. On a 49-object chess set that is 15 reductions instead of 49 failures, instancing survives, and it finishes in half the time:

ABeautifulGame   49 objects / 15 unique meshes
  1 497 912 → 748 944 triangles   (exactly 50 %)
  43.0 MB → 24.9 MB               (−42 %)
  deviation p95 0.0007 %

Fewer triangles does not mean a smaller file

This one surprises people, and it is worth stating plainly: on a textured asset the textures dominate, and Blender re-encodes them on export. Left on Blender's own default, halving that helmet produced a file 118 % larger than the original.

So the default here inspects the materials and picks the smallest encoding the asset can safely tolerate — JPEG when nothing is driving the shader's alpha input, Blender's AUTO when something is. Same helmet, same geometry, same deviation:

Texture setting	Output	vs source
Blender AUTO	8.23 MB	+118 %
Smart (default)	2.57 MB	−32 %
JPEG + Draco	2.36 MB	−37 %
WEBP + Draco	1.51 MB	−60 %

And when the file still grows — small, already-optimised textures where re-encoding cannot help — you get an OUTPUT_LARGER_THAN_INPUT warning rather than a silent regression.

Rigged assets keep their skinning

Vertex weights are interpolated through the reduction, and the report verifies it rather than assuming it: groups before and after, any groups lost, and how many vertices came out with no bone influence — those stay pinned at the bind pose while everything around them deforms, which reads as a torn character in motion.

Fox         24 groups → 24 groups, 0 lost, 0 unweighted vertices
Samba.fbx   Mixamo character, 2 skinned meshes, 97 vertex groups —
            all intact through fbx→fbx, fbx→glb and glb→fbx

FBX, in and out, at studio fidelity

FBX input is read without rewriting the rig: no automatic bone reorientation, no baked-in transforms, Maya pre/post rotations preserved. FBX output overrides every Blender default that loses data — smoothing groups on (FACE), tangents exported, custom properties kept, no invented leaf bones, animation curves unsimplified, textures embedded, and every animation take in the one file.

One consequence stated up front: an FBX written this way can come out larger than its source, because embedded textures and lossless curves are the point. The OUTPUT_LARGER_THAN_INPUT warning says so explicitly instead of letting you think the reduction failed — the triangle counts are where the reduction shows.

Input

Field	Type	Default
glbUrl	string	—	Public URL to a self-contained .glb or .fbx (embedded media), up to 200 MB
targetRatio	string	0.5	Fraction of triangles to keep, 0–1
targetTriangles	integer	0	Absolute budget; overrides the ratio when > 0
method	string	collapse	collapse, planar (great silhouette, damages UVs — see above), unsubdivide
preserveUvSeams	boolean	true	Stops collapses crossing UV islands
preserveBoundaries	boolean	true	Protects sharp edges and open borders
cleanupFirst	boolean	true	Weld duplicates and drop zero-area faces first
textureFormat	string	smart	smart, AUTO, JPEG, WEBP, keep
imageQuality	integer	85	For JPEG/WEBP
dracoCompression	boolean	false	Compresses geometry inside the GLB; needs a Draco-capable viewer
shapeKeyPolicy	string	reject	reject (refuse, no charge) or strip (delete morph targets)
outputFormat	string	glb	glb, fbx, usdc, usda, usd, usdz

Set preserveUvSeams off only on untextured assets. A decimator that welds across a UV seam shreds the mapping, and no triangle count is worth that.

Output

The asset lands under OUTPUT in the run's key-value store — a ZIP when the export wrote sidecar textures, the bare file otherwise, with outputKind telling you which.

The dataset record carries triangle counts before and after, the achieved ratio, the deviation block in both directions, UV integrity, skinning survival, instancing stats, file-size change and per-phase timings. The unabridged report is in the store under REPORT_FULL.

Speed

Per-phase, measured:

DamagedHelmet   15k tris            1.3 s
Fox             rigged, 3 clips     0.8 s
ABeautifulGame  1.5M tris, 49 objs  13.5 s

Quality checking is deliberately bounded — deviation is sampled at up to 4 000 points regardless of mesh size, so a two-million-triangle asset does not cost a hundred times more to verify than a twenty-thousand one.

When not to use it

• Multi-file sources. A .gltf with external .bin, or an .fbx referencing loose texture files, will not find its siblings. Use self-contained files.
• You need hand-authored LODs. This is automatic reduction; a character hero mesh usually still wants an artist.
• You want retopology. Decimation reduces existing topology, it does not rebuild clean quad flow.

Limits worth knowing

Deviation is sampled from vertices, so a reduction that moves face interiors without moving vertices is under-measured. Texel density and overlap are sampled over at most 6 000 faces, so a very localised distortion on one small island can slip past. Island counting is exact but skipped above 300 000 faces per mesh, because connectivity cannot be sampled without giving a wrong answer — the report says when it was skipped rather than guessing.

Normal maps are not re-baked: one baked against the original density stays geometrically valid but loses fidelity at aggressive reductions. unsubdivide has had less real-asset mileage than collapse. And no production character — heavy rig, many materials, UDIM tiles — has been through this yet; the verification is against Khronos reference assets.