High Poly to Low Poly Converter

Take a dense ZBrush sculpt or a 3D scan and turn it into a clean, game-ready low poly mesh while baking the lost detail into normal and ambient occlusion maps.

Generate this in 3DCreate a custom low-poly model from text or an image in seconds.

Matching downloadable assets

Start with these seed models, then generate variants in the same low-poly direction.

Members unlock protected STL access

Use the free OBJ to test the shape. Subscribe for protected STL downloads now; GLB, FBX, USDZ and Unity are shown as production export targets, not direct library downloads yet.

Commercial licenseProtected STL downloads nowMonthly AI credits included
View member plans

Highlights

  • Capture the silhouette on a light mesh, then bake lost detail into a normal map
  • Use decimation for static props and LODs, manual retopo for anything that deforms
  • Hybrid flow: decimate for blockout, hand-retopo only the hero that needs deformation
  • Target 1k to 5k tris on mobile, 10k to 50k on desktop, around 20k for a hero
  • Bake tangent-space normals plus AO onto a single 512 to 2048px atlas
  • Triangulate, cage, and add ray distance before baking to avoid skewing and seams
  • Export FBX for rigged Unity and Unreal work, GLB for web, Godot, and AR
  • Optimized assets are user-owned, commercial-safe, and need no attribution

High poly to low poly is the core retopology step that makes sculpts and scans usable in real time. A multi-million-triangle sculpt looks gorgeous in a render but will crush a game engine, so the job is to build a light cage that captures the same silhouette at a fraction of the cost. The detail does not disappear, it moves: fine surface information bakes from the high mesh into a normal map applied on the low mesh, so the lightweight model still reads as if it carried every wrinkle and pore. Done well, a 5k-triangle character with a good normal bake can look nearly identical to its source in motion.

There are two paths to the low mesh, and choosing correctly saves hours. Automatic decimation, such as the Blender decimate modifier or a remesh-and-decimate pass, is fast and ideal for static props, background scatter, and rough LODs where edge flow does not matter. Manual retopology, drawing a clean quad mesh over the sculpt, costs time but pays off for anything that deforms, animates, or sits close to camera, because clean loops follow the form and bend without pinching. A common hybrid is to decimate first for blockout and LODs, then hand-retopo only the hero asset that needs deformation. Match the method to how the asset will actually be used.

Set concrete triangle targets before you start so the reduction has a goal. For mobile and WebGL, aim for a hero around 1k to 5k triangles and props at 200 to 800. For desktop and console, 10k to 50k is the working range, with a camera-facing hero around 20k. Generate LODs from the same low base so distant instances drop to a fraction of the tris and the engine swaps them by screen size. Reducing to a known budget, rather than just reducing until it looks fine, keeps your whole scene inside its performance envelope.

Baking is where the magic happens, and it rewards setup discipline. Cage the high mesh against the low, then bake a tangent-space normal map to recover surface detail, an ambient occlusion map for contact shadows, and optionally curvature or a color ID for texturing. Bake onto a single shared atlas, 512 to 1024px for props or 1024 to 2048px for a hero, with a clean non-overlapping UV layout and a little padding to avoid seams. Match the normal map orientation to your engine, add a small ray distance to catch protrusions, and triangulate before baking so the low mesh does not shift afterward. A clean cage and good UVs prevent the skewing and waviness that ruin a rushed bake.

Export to fit the engine. GLB is the self-contained binary for web, Three.js, Godot, and AR, bundling the low mesh with its baked maps. FBX preserves hierarchy, pivots, material slots, and skeletons for Unity and Unreal, which matters when the retopologized mesh will be rigged. OBJ is fine for static interchange but carries no animation. STL and 3MF target 3D printing and ignore your hard-won normal maps, so they suit only the rare case of printing the reduced form. Keep the high source archived, because future LODs or rebakes all start from it.

Licensing follows the same friendly rules as the rest of the pipeline. The optimized low poly assets are user-owned, cleared for commercial use, and require no attribution, so you can ship a baked, game-ready model straight from a sculpt without legal overhead. That makes high poly to low poly the dependable finishing move for character artists, environment artists, and scan-based pipelines that need beauty in the viewport and speed in the engine.

Continue the optimization pipeline

Frequently asked questions

Decimate or manually retopologize?

Decimate static props, scatter, and LODs for speed. Manually retopologize anything that deforms, animates, or sits near camera so clean loops bend without pinching.

What triangle count should the low mesh be?

Around 1k to 5k for mobile heroes, 200 to 800 for props, and 10k to 50k on desktop and console, with a hero near 20k. Build LODs from that base.

How do I keep the high poly detail?

Bake a tangent-space normal map from high to low to recover surface detail, plus an AO map for contact shadows, onto a clean shared UV atlas.

Why does my bake look skewed or wavy?

Usually a bad cage, overlapping UVs, or an untriangulated low mesh. Triangulate first, fix the cage and ray distance, and ensure non-overlapping UVs with padding.

Which format should I export?

FBX when the mesh will be rigged in Unity or Unreal, GLB for web, Three.js, Godot, and AR. Keep the high source archived for future rebakes.

Related

Browse all

Need a custom low-poly model?

Generate one from a text prompt or reference image, then export GLB, FBX, OBJ or STL.

Open the generator