3 Best SketchUp Mesh Simplification Plugins — #3 Is Free

SketchUp has no built-in mesh simplification or decimation tool — this is a deliberate design decision, not an oversight. SketchUp was designed for architects drawing from scratch, not for processing meshes imported from game engines or Megascans. When you import a file from 3D Warehouse, receive an FBX from a client, or export from Revit, the model can contain millions of faces that cause severe viewport lag.

The most common misconception: Soften/Smooth Edges and Hidden Geometry do not reduce faces. They only change how edges are displayed — hiding dividing lines or blurring sharp corners so surfaces look continuous. Faces still exist in full in memory, SketchUp still computes all of them, the file is still just as heavy. The only mechanism that actually reduces polygon count is deleting entities or running a dedicated decimation algorithm.

The three SketchUp polygon reduction plugins below solve that problem — but through three completely different approaches, and choosing the wrong one will cost you time rather than save it.

Skimp

Skimp is the oldest mesh simplification plugin in the SketchUp ecosystem, predating GLB as a mainstream standard. At $229 USD it is noticeably more expensive than the alternatives — for a specific reason: Skimp licenses the commercial rights to Atangeo Balancer, a simplification algorithm researched and patented in Germany. That license cost passes directly into the sale price.

Why C++ instead of Ruby? SketchUp’s API allows plugins written in Ruby, but Ruby is an interpreted language — running decimation code on a million faces in Ruby takes several seconds per slider step. Skimp uses a C++ extension (native code) and previews via the view.draw API, drawing temporary geometry as an overlay in the viewport without committing anything to the model. Dragging the slider shows the result in real time; only clicking Apply writes the geometry to the scene.

C++ on macOS carries a hidden cost: Apple requires every distributed binary to be signed with an Apple Developer certificate (notarization), and each macOS update typically requires a re-sign or recompile. The SDK cost plus the Mac maintenance work is part of why Skimp costs more than tools built on non-native scripted languages.

Key features:

• Group & Component hierarchy preserved — multi-level nested Components and shared instances all survive. One note: Skimp replaces the original Group with a new Component — if the model has scripts or observers referencing that Group by ID, the reference breaks.
• Materials and UV intact — per-face texture projection is preserved. If the UV uses projected or box mapping rather than per-face unwrap, inspect carefully after reducing, as UV can occasionally shift.
• Import GLB / STEP / FBX — load an external file, simplify the geometry, commit it to the scene. STEP files typically contain NURBS converted to SketchUp faces with very clean topology — aggressive decimation on STEP files sometimes produces worse results than the original mesh.
• Real-time preview — see the result before writing to the model; drag the slider to see the reduction ratio update immediately.

When not to use Skimp:

• The model will go into a render engine with a displacement map — decimation destroys the topology displacement needs.
• The model needs clean quad flow for import into ZBrush or Blender — Skimp output is a triangle mesh.
• The model is already lightweight under 100k faces — decimation is not needed.

Transmutr

Transmutr by Lindalë is not fundamentally a reducer like Skimp or Decimify — it is a file conversion pipeline that runs before anything enters SketchUp. Skimp and Decimify reduce polygons on geometry that already exists inside the model. Transmutr reduces polygons, processes materials, and exports proxies in a single step before the geometry touches SketchUp, avoiding the scenario of importing a 5-million-face OBJ and then trying to reduce it — by that point SketchUp has already taken the hit.

Permanent license pricing: Artist license ~$57 USD (2-machine install, no commercial resale of output files) and Studio license ~$119 USD (floating multi-seat, commercial output allowed). No subscription — buy once, use forever, free updates. Transmutr wrote its own simplification algorithm rather than licensing one externally, which is why the price is significantly lower than Skimp.

Mesh Simplification — how it works:

Transmutr merges groups of faces touching each other. This means it works best on closed/manifold meshes — a sofa exported from 3ds Max is typically a closed mesh and simplifies very effectively. Conversely, models made up of many separate pieces (leaves, fine lattices, screw threads) simplify poorly because each piece has only 2–4 triangles, cannot reduce further, and risks disappearing entirely when the slider is pushed high.

Two important options often overlooked:

• Simplification forces triangulation — Transmutr breaks all quads and n-gons into triangles. If you need to keep quad topology for downstream use (ZBrush, Blender), do not use simplification — export straight without it.
• UV Seam Preservation — protects faces near UV seams from being simplified, preventing texture stretching. Enable by default on any model with complex UV unwraps. Disabled, the algorithm has no awareness of UV seam locations and may merge faces across seam boundaries, causing visible texture deformation.

Normal Preservation is a third option — it constrains the algorithm to keep the simplified mesh close to the original shape, at the cost of a lower face-reduction ratio. Use it on models with complex curved details (architectural molding, organic shapes) where you cannot afford the silhouette to break.

Proxy System — Transmutr’s real advantage:

This feature does not exist in Skimp or Decimify. Instead of reducing polygons to lighten SketchUp, a proxy keeps the .skp file extremely light (containing only a placeholder) while the render engine uses the full-resolution source geometry. A 10-million-face model still renders correctly; the SketchUp viewport only sees a bounding box.

Three proxy types are supported:

• V-Ray — exports a .vrmesh file; supports V-Ray 7 (from version 1.2.13)
• Thea — exports .xml + .mesh.thea (or .mod.thea with Thea v2.1+)
• Enscape — exports a separate .skp file that Enscape reads alongside the main file

All three can be exported simultaneously from a single import. The placeholder displayed in SketchUp has six modes:

• Bounding Box — wireframe or solid
• Face Skipping — random face removal for rough shape recognition
• Simplified Geometry — shares the simplification slider
• Full Geometry — full display
• Billboard — cross or face-me
• Custom SKP — a hand-designed placeholder of your own

Note: do not enable “Always face camera” on a proxy component — SketchUp rotates the component to follow the camera, but the render engine reads the transform from the scene, producing a misaligned render result.

Material Automation:

Transmutr automatically extracts diffuse, bump/normal, reflection, and opacity maps from the source file and simultaneously creates materials for SketchUp native, V-Ray, Thea, and Enscape — no manual mapping needed. One little-known detail: when the source file has bump/opacity/reflection maps but no diffuse map, Transmutr automatically adds a dummy color texture so SketchUp can save the UV coordinates — without this, UVs get dropped when the .skp is saved.

Megascans Bridge integrates natively: export from Bridge using Custom Export + Socket Port, and Transmutr receives the asset and maps scale and materials automatically.

Use Transmutr when you receive FBX/OBJ files from a client or from Megascans to reduce polygon count before import and need them inside SketchUp with materials and proxies ready in one step. Use Skimp or Decimify when the model is already inside SketchUp and you need to optimize geometry in place.

Decimify

Decimify is a free SketchUp mesh simplification plugin — the Free version caps reduction at 30% of total face count, Pro is unlimited. The low price has a clear reason: Decimify runs as a web app inside SketchUp’s built-in browser rather than as a native C++ extension like Skimp or plain Ruby (too slow for real-time preview). No per-platform build, no Apple notarization on macOS — lower development and maintenance cost, reflected directly in the price.

Options and when to adjust them:

Two common gotchas:

• Keep UV on + broken UV = slider blocked. When a mesh has malformed UV seams or faces missing UV data, the algorithm cannot merge faces without destroying the texture. Fix: turn off Keep UV to unlock deeper reduction, accepting texture loss on that area.
• Output is always a triangulated mesh. Decimify splits all faces into triangles after reduction, then automatically hides and softens coplanar edges. The output has no quads, unlike what Blender or ZBrush require.

Decimify imports GLB and STL directly — load the file, reduce the mesh, commit it to SketchUp as a new Component. The workflow is equivalent to Skimp but does not support STEP or FBX. Full installation and usage details: Decimify SketchUp.

Plugin Comparison

Which Plugin to Choose?

The decision depends on two questions: where the geometry is right now, and which render engine you use.

• File not yet in SketchUp (FBX/OBJ from a client, Megascans, 3ds Max): Use Transmutr. Processing before import prevents SketchUp from loading the full heavy geometry — and the V-Ray/Thea/Enscape proxy system is an advantage no other plugin here offers. At $57–$119 it is the best-priced option of the three.
• Model already inside SketchUp, need to preview before committing: Use Skimp. The view.draw real-time preview shows exactly what the mesh will look like at each reduction level before you click Apply.
• Model already inside SketchUp, want to try for free or only need under 30% reduction: Decimify Free is enough. For deeper reduction, Decimify Pro is significantly cheaper than Skimp.

Real-world architectural work often uses all three: Transmutr for large Megascans/FBX assets, Decimify for furniture downloaded from 3D Warehouse, Skimp for particularly complex models that need careful preview before reducing.