# AI retopology: decimate, remesh or regenerate an AI 3D model for games

How to make AI-generated 3D models game-ready: measured decimation, QuadriFlow and face-limit results on Tripo, Trellis and Meshy outputs, and when each is the right fix.

Author: Ravi Parikh

Canonical: https://voyager.so/blog/ai-retopology

Published: 2026-11-19T16:15:00-08:00
Updated: 2026-11-19T16:15:00-08:00

AI retopology means turning the dense, messy mesh an AI 3D generator gives you into one a game engine or an animator can use. There are three ways to do it, and they fix different problems. **Decimation** cuts the triangle count and reuses the model's existing UVs and texture maps, which hold up well until the triangles get coarse relative to the texture's detail. **Quad remeshing** (QuadriFlow, Instant Meshes, ZRemesher, Quad Remesher) rebuilds the surface as an even grid of quads, which then needs new UVs and a texture bake. **Regenerating with a face limit** asks the generator for a smaller mesh in the first place, but gives you a different model.

The short version: decimate for static props, background characters and anything that only has to look right. Quad remesh, then check and fix the edge flow by hand, when the model will be rigged, deformed or subdivided. Ask the generator for your budget before you have a model you like, not after, because a second generation is a new roll of the dice.

We decimated and quad remeshed three AI models from our own [model reference](https://voyager.so/resources/models/best-ai-3d-model-generator) in Blender 5.2.1 on 19 November 2026, and measured the triangle count, the time, how far the surface moved and whether the textures survived. For the third option we imported and rendered 50,000-triangle generations the model reference recorded on 17 and 18 November 2026. Tool prices and generator parameters below were read from the vendors' own pages on 19 November 2026.

**Key takeaways**

* Blender's Decimate took a 1.47-million-triangle Tripo H3.1 fox to 5,000 triangles in about 8 to 12 seconds, with the surface moving 0.03% of the model's size on average, and its original texture maps still lining up because the UVs are kept.
* Merge vertices before you decimate. Unmerged, a Meshy 7.1 fox was 14,199 separate pieces, and decimating it to 5,000 triangles shredded the tail and scarf.
* Blender's QuadriFlow refused all three models at first, for two different reasons: near-zero-length edges on the Tripo fox, which scaling the model up fixed, and edges shared by more than two faces on the other two, which deleting a few faces fixed. Once it ran it made clean quads in under 15 seconds, but rounded off the dripper's rim at 5,000 quads.

## What AI generators actually hand you

Generators differ by two orders of magnitude in how many triangles they return by default. These are from the default first attempts in our model reference (five objects per model unless noted):

| Model                                                          | Default triangles in our runs                                                                  | Face control it offers                           |
| -------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- | ------------------------------------------------ |
| [Tripo H3.1](https://voyager.so/resources/models/tripo-h3-1)   | 1,405,300 to 1,473,138                                                                         | `face_limit`, `smart_low_poly`, `quad`           |
| [Hunyuan3D 3](https://voyager.so/resources/models/hunyuan3d-3) | 499,752 to 500,000                                                                             | `face_count`, LowPoly mode                       |
| [Rodin 2.5](https://voyager.so/resources/models/rodin-2-5)     | 500,000 on every object                                                                        | Mesh presets and a Quad mode                     |
| [Trellis 2](https://voyager.so/resources/models/trellis-2)     | 460,795 (the dripper only: it builds from images, and the other four objects are text prompts) | `decimation_target`                              |
| [Meshy 7.1](https://voyager.so/resources/models/meshy-7-1)     | 26,707 to 31,078                                                                               | `target_polycount` and `topology` when remeshing |
| [Tripo P2](https://voyager.so/resources/models/tripo-p2)       | 4,445 to 5,474                                                                                 | `face_limit`, `quad`                             |

Meshy's figure matches its documented remesh default, a `target_polycount` of 30,000 ([Meshy Remesh API](https://docs.meshy.ai/en/api/remesh), read 19 November 2026). Tripo's own guidance for its `face_limit` is 50,000 to 100,000 for game-ready assets and 10,000 to 50,000 for web and mobile ([Tripo generation docs](https://developers.tripo3d.ai/en/docs/generation-text-to-model/standard), read 19 November 2026). So a default Tripo H3.1, Hunyuan3D 3, Rodin or Trellis mesh is roughly 5 to 30 times over Tripo's own game-ready range before you start.

Every one of these files is triangles, with no edge loops placed around the eyes, mouth or joints. That is fine for a prop. For a character that has to bend, edge flow is what you have to check, and decimation does nothing for it.

## Before anything else: merge the vertices

This was the most useful thing we found, and it costs nothing. AI GLB files store split vertices along every UV seam, and some store near-duplicates everywhere. Decimation treats each split as a hole edge and pulls the pieces apart.

What we counted on import, before any reduction:

* **Tripo H3.1 fox:** 38,846 open edges with Blender's glTF importer at its defaults; zero with **Merge Vertices** ticked in the import options.
* **Trellis 2 dripper:** 98,427 open edges unmerged; 31 after merging on import.
* **Meshy 7.1 fox:** 57,884 open edges either way. Its duplicate vertices sit a hair apart rather than on top of each other, so the importer's merge does not catch them, and the model loads as 14,199 separate pieces. **Mesh > Clean Up > Merge by Distance** at a distance of 0.000001 joined it into one piece with 99 open edges.

![Four renders. A Meshy 7.1 fox decimated to 5,000 triangles without welding has a tail and scarf broken into jagged shards; the same fox welded first is intact. A Trellis 2 coffee dripper decimated to 10,000 triangles without merging is covered in cracks and loose flakes; the merged version is smooth.](https://cdn.moda.app/voyager/blog/ai-retopology/weld-before-decimating-af20c899da3c34af.webp)

The same reduction with and without merging first. The originals have the same shape either way; only the decimated results differ. Rendered in Blender 5.2.1, 19 November 2026.

Merging keeps the UVs: Blender stores them per face corner, so a welded vertex can still sit on two sides of a UV seam. Our merged files used the same textures as the originals with nothing re-baked.

## Decimate: the fast fix that keeps your textures

Blender's Decimate modifier in Collapse mode "merges vertices together progressively, taking the shape of the mesh into account", and its Ratio is counted in triangles ([Blender 5.3 manual](https://docs.blender.org/manual/en/latest/modeling/modifiers/generate/decimate.html), read 19 November 2026). Set the ratio to your target divided by the current triangle count, then apply it.

Our results, after merging. Deviation is the distance between the decimated surface and the original, measured both ways and given as a percentage of the model's bounding-box diagonal. For the Tripo fox scaled to one metre tall, 0.03% is about 0.4 mm.

| Source                     | Target | Triangles after | Decimate time | Mean deviation | 95th percentile | Largest |
| -------------------------- | ------ | --------------- | ------------- | -------------- | --------------- | ------- |
| Tripo H3.1 fox, 1,473,138  | 50,000 | 49,998          | 8.4 to 10.5 s | 0.003%         | 0.009%          | 0.03%   |
|                            | 10,000 | 10,000          | 8.2 to 9.0 s  | 0.015%         | 0.040%          | 0.17%   |
|                            | 5,000  | 5,000           | 8.4 to 12.0 s | 0.030%         | 0.077%          | 0.33%   |
| Trellis 2 dripper, 460,793 | 50,000 | 49,999          | 1.8 s         | 0.002%         | 0.006%          | 0.03%   |
|                            | 10,000 | 9,999           | 2.0 s         | 0.013%         | 0.034%          | 0.14%   |
|                            | 5,000  | 4,999           | 1.9 s         | 0.026%         | 0.065%          | 0.17%   |
| Meshy 7.1 fox, 31,078      | 10,000 | 10,000          | under 0.1 s   | 0.035%         | 0.091%          | 0.52%   |
|                            | 5,000  | 4,999           | under 0.1 s   | 0.077%         | 0.198%          | 0.97%   |
|                            | 2,000  | 2,000           | under 0.2 s   | 0.172%         | 0.490%          | 2.03%   |

Times are for applying the modifier alone, from one or two runs on the M5 Max. The averages hide the worst spots: on the one-metre Tripo fox at 5,000 triangles the mean shift is about 0.4 mm but the largest sampled shift is about 4.7 mm. The Tripo fox's GLB went from 43.9 MB to 3.3 MB at 50,000 triangles and 2.2 MB at 5,000, exported from Blender with its three 2048-pixel textures.

![The Tripo H3.1 fox at 1,473,138, 50,000, 10,000 and 5,000 triangles, textured on top and in grey clay below. The textured row is nearly indistinguishable; in clay, the 5,000 version has flat facets on the cheeks, muzzle and tail and loses the fur tufts on the tail.](https://cdn.moda.app/voyager/blog/ai-retopology/hero-fox-decimate-8034a5283c91ec19.webp)

At full-body distance the textured fox barely changes down to 5,000 triangles: the original colour and normal maps still line up because Decimate keeps the UVs. Clay shows what the texture is hiding.

What the numbers and renders say together:

* **Textures survive decimation when the UV islands are large.** The Tripo fox's colour, roughness and normal maps kept working at every level, and its normal map is a big part of why the 5,000-triangle version still reads as furry.
* **Small UV islands are the exception.** The Meshy fox's tail is built from many thin fur strips. Its 10,000-triangle version looked like the original; at 5,000 the strips began to smear, and at 2,000 the tail and ear tips showed white streaks where collapsed triangles now stretch across texture seams.
* **Detail goes before silhouette.** At 5,000 triangles the dripper's wall stayed smooth, but its ribs faded and a small crease appeared where the cone meets the base.
* **Decimation does not add edge flow.** The wireframe below is an even scatter of triangles with no loops to bend along.

![The Meshy 7.1 fox at 31,078, 10,000, 5,000 and 2,000 triangles, textured. At 10,000 it looks the same as the original; at 5,000 the tail fur is smoother; at 2,000 the ears are sharp-edged and white streaks appear on the tail and scarf.](https://cdn.moda.app/voyager/blog/ai-retopology/meshy-decimate-texture-90509e888434a2da.webp)

Meshy's fur strips are where its texture gives out first. 10,000 triangles kept the look; 2,000 did not.

![Close-ups of the fox's head as wireframes. The 1.47-million-triangle original is so dense it renders solid black; the 10,000 and 5,000 decimated versions are irregular triangles; the QuadriFlow version is an even grid of quads that follows the ears and muzzle.](https://cdn.moda.app/voyager/blog/ai-retopology/fox-head-wireframes-e30e5298ec113d65.webp)

Decimated triangles against QuadriFlow quads on the same head. Neither has the loops around the eyes and mouth an animator would add by hand.

Use decimation for props, environment pieces, background characters, 3D printing previews and product renders. For a game, pick the target by screen size, and keep two or three decimated levels as LODs: from the same source each one takes seconds. Before you accept a level, look at it at the size it will appear on screen and check three things: the silhouette, the texture seams, and thin parts such as ears, fingers and straps.

## Quad remesh: clean quads, new UVs, a bake, and some preparation

A quad remesher throws the triangles away and lays a new grid of quads over the shape. Blender ships one, QuadriFlow: in the Object Data properties, open **Remesh**, switch the mode to **Quad** and press **QuadriFlow Remesh**. Blender's manual is candid about its limits: neither its voxel nor its quad remesher is for "final topology for a mesh that will be deformed", because "no perfect automatic tools exist for this right now" ([Blender 5.3 manual, Remeshing](https://docs.blender.org/manual/en/latest/modeling/meshes/retopology.html), read 19 November 2026).

On our files it would not start at all. Every attempt stopped with *"The mesh needs to be manifold and have face normals that point in a consistent direction"*. That message covers several conditions. Blender's [QuadriFlow check](https://github.com/blender/blender/blob/v5.2.1/source/blender/editors/object/object_remesh.cc) in 5.2.1 accepts open boundary edges, and rejects a mesh that has any of four things: an edge shared by more than two faces, faces whose winding flips against a neighbour, a loose edge with no face, or an edge whose two ends are within 0.0001 units of each other on every axis. What our three models had, measured against those rules:

* **Tripo H3.1 fox:** no open or non-manifold edges, no flipped faces and no loose edges, but 56 edges whose ends were within 0.0001 units, about 0.1 mm on this one-metre model.
* **Trellis 2 dripper:** 2 edges shared by more than two faces, and nothing else.
* **Meshy 7.1 fox:** 76 edges shared by more than two faces and 3 flipped faces.

None of our files had loose edges. Work through the causes in this order, re-trying QuadriFlow after each step:

1. **Winding.** **Mesh > Normals > Recalculate Outside** in Edit Mode. On the Meshy fox this fixed the 3 flipped faces, but not the 76 shared edges, so QuadriFlow still refused.
2. **Loose edges.** **Mesh > Clean Up > Delete Loose** removes edges and vertices with no face, which scaling does not fix.
3. **Edges shared by more than two faces.** **Select > Select All by Trait > Non Manifold** with only **Multiple Faces** ticked selects those edges; grow the selection once with **Select > More/Less > More**, then **Delete > Faces**, and recalculate normals again. Our script deleted just the faces touching those edges: 6 on the dripper and 244 on the Meshy fox. The holes this leaves are allowed. On both models this alone was enough: QuadriFlow ran on them at their original size. A voxel remesh (**Remesh > Voxel**) also works, closing everything in under a second, but it rebuilds the whole surface, so keep it for meshes with too many problems to delete by hand.
4. **Near-zero-length edges.** If it still refuses, scale the object up 100 times, apply the scale, remesh, and scale it back. On the Tripo fox this alone was enough.

For consistency, every QuadriFlow run in the table below was done at 100 times scale, including the dripper and Meshy runs where deleting faces was already sufficient; the face-deletion runs also removed loose geometry left behind by the deletion.

We asked for 5,000 quads, with symmetry, sharp-edge preservation and boundary preservation all off, and the model scaled up 100 times during the remesh:

| Source and preparation                        | Quads (triangles) | QuadriFlow time | Mean deviation | Largest | What it looked like                                                      |
| --------------------------------------------- | ----------------- | --------------- | -------------- | ------- | ------------------------------------------------------------------------ |
| Tripo H3.1 fox, scaled up                     | 4,763 (9,526)     | 14.3 s          | 0.069%         | 2.08%   | Even grid, ears and muzzle kept, fur tufts on the head and tail softened |
| Trellis 2 dripper, 6 faces deleted, scaled up | 5,109 (10,218)    | 3.2 s           | 0.068%         | 2.53%   | Wavy rim and lumpy base, plus a dark spot the bake missed                |
| Trellis 2 dripper, voxel remesh, scaled up    | 4,958 (9,916)     | 3.9 s           | 0.062%         | 1.11%   | The same wavy rim and lumpy base                                         |
| Meshy 7.1 fox, 244 faces deleted, scaled up   | 4,297 (8,594)     | 1.8 s           | 0.125%         | 3.04%   | Scarf fringe merged; 58 open edges show as small holes                   |
| Meshy 7.1 fox, voxel remesh, scaled up        | 4,018 (8,036)     | 2.5 s           | 0.166%         | 3.00%   | Scarf fringe and fingers merged into blobs; six open edges               |

The dripper came out wavy by both routes, so at this budget the rounding comes from QuadriFlow, not from the voxel pass. Compare these with decimating to 10,000 triangles: four to five times the mean deviation on both the Tripo fox and the dripper, at roughly the same triangle count. You pay that for an even quad layout. Turning on **Preserve Sharp** may help hard edges like the dripper's rim; we did not try it.

Then the textures are gone. QuadriFlow output has no UVs, so we unwrapped it with **Smart UV Project** and baked colour, roughness and a normal map from the original onto it in Cycles with **Selected to Active** (2048 pixels, 16 samples, cage extrusion 1% of the model's size). On the M5 Max's GPU each bake took under two seconds, and the whole fox script, renders included, ran in 38 seconds.

![The Tripo fox after QuadriFlow at 4,763 quads: textured with baked colour, roughness and normal maps; the same without the normal map, which looks flatter and more faceted; the quad wireframe; and the new 2048-pixel colour atlas split into many irregular islands, including the face.](https://cdn.moda.app/voyager/blog/ai-retopology/quadriflow-bake-fox-07e9f3d76fd3e95c.webp)

QuadriFlow plus a bake on the Tripo fox. The baked normal map carries most of the fur detail. Smart UV Project cuts the face into islands an artist would not choose.

![The Trellis 2 dripper at 460,793 triangles, decimated to 10,000 and 5,000, and after voxel remesh plus QuadriFlow and a bake, with wireframes below. The decimated versions keep a smooth rim and base; the QuadriFlow version has a wavy rim, a lumpy base and visible facets inside the cone.](https://cdn.moda.app/voyager/blog/ai-retopology/dripper-decimate-vs-quadriflow-9659b7837e3dfe75.webp)

On a hard-surface product made from a generated product image, decimation kept the shape better than QuadriFlow at the same budget. The QuadriFlow column is the voxel route; the face-deletion route looked the same.

The bake is the step that makes this workflow useful: you get a quad mesh with its own textures, which is easier to edit, to add loops to and to subdivide predictably than a scatter of triangles. Triangulated meshes can be skinned and subdivided too; what you are buying is edge flow you can control. But automatic quads are a starting point, not an animation mesh. Our QuadriFlow fox has quads that follow the overall shape, with no deliberate loops around the eyes, mouth or elbows, and we did not rig or deform any of these results.

## Regenerate with a face limit: right budget, different model

Most generators let you ask for a face count in the generation request. The parameters, from each vendor's documentation read on 19 November 2026:

* **Tripo:** `face_limit` up to 1,500,000 triangles on H3.1 at Standard geometry quality and 2,000,000 at Ultra, or 150,000 with `quad: true`, which forces FBX output. `smart_low_poly` asks for "hand-crafted, clean topology style" at 500 to 20,000 triangles or 500 to 10,000 quads, and Tripo warns that complex models may fail ([Tripo generation docs](https://developers.tripo3d.ai/en/docs/generation-text-to-model/standard)). Tripo also has a separate [decimate and retopology API](https://developers.tripo3d.ai/en/docs/mesh-decimate) that takes an existing model, in three tiers: v1.0 basic decimation (`face_limit` up to 2,000,000 triangles, 10 credits), v2.0 retopology (500 to 20,000 triangles, 30 credits) and v3.0 with optional UV unwrapping (500 to 20,000 triangles, 35 credits, or 40 for quads).
* **Meshy:** with remeshing turned on (`should_remesh`, which defaults to off on Meshy 7.1, so `target_polycount` alone does nothing), `target_polycount` from 100 to 300,000 and `topology` set to `triangle` or quad-dominant `quad` ([Image to 3D API](https://docs.meshy.ai/en/api/image-to-3d)). Meshy's Smart Topology models are a separate option that generates triangles at the face count directly. Its Remesh tool works on an existing model; see the tools table below for its plan conditions.
* **Rodin 2.5, Hunyuan3D 3 and Trellis 2:** a 50K Triangle mesh option and a Quad mode on Rodin, a `face_count` on Hunyuan3D 3, and a `decimation_target` on Trellis 2. The ranges are on each model page linked in the first table.

Our model reference recorded a 50,000-triangle request for five of the models on 17 and 18 November 2026, on the fox, the chair and the dripper. Trellis 2 builds from images, so it ran only the dripper, and it was sent `decimation_target: 25000` rather than 50,000. The hosted endpoint we used accepted that value; Microsoft's own demo describes `decimation_target` as the target face count for GLB export and limits its slider to 100,000 to 1,000,000, default 500,000 ([TRELLIS.2 app.py](https://github.com/microsoft/TRELLIS.2/blob/main/app.py)). What came back ([matched-budget results](https://voyager.so/resources/models/best-ai-3d-model-generator)):

| Model and request                     | Fox     | Chair   | Dripper |
| ------------------------------------- | ------- | ------- | ------- |
| Tripo H3.1, `face_limit` 50,000       | 48,786  | 45,734  | 47,538  |
| Tripo P2, `face_limit` 50,000         | 54,707  | 53,119  | 49,517  |
| Meshy 7.1, `target_polycount` 50,000  | 51,943  | 49,196  | 51,743  |
| Rodin 2.5, 50K Triangle option        | 50,000  | 50,000  | 50,000  |
| Hunyuan3D 3, `face_count` 50,000      | 33,050  | 50,006  | 49,346  |
| Trellis 2, `decimation_target` 25,000 | not run | not run | 23,814  |

So a requested count is a target, not a guarantee: Tripo P2 went up to 9% over, and Hunyuan3D 3 delivered a third fewer on the fox. If your budget is a hard ceiling, check the count and decimate the overshoot.

![Four foxes, textured and in clay. The default Tripo H3.1 fox decimated to 50,000; a different Tripo H3.1 fox generated with face\_limit 50,000, with a redder coat, a darker face and a different pose; the default decimated to 5,000; and the Tripo P2 fox, generated natively at 5,474 triangles, which is slimmer, with a different scarf and pose.](https://cdn.moda.app/voyager/blog/ai-retopology/decimate-vs-regenerate-d9e71af06811c071.webp)

Decimating keeps the fox you chose; asking for 50,000 faces gave a different fox from the same prompt. Tripo P2 builds about 5,000 triangles by default. Generations recorded on 17 and 18 November 2026, rendered for this post.

* **A face limit in the generation request means a new generation.** The 50,000-face Tripo H3.1 fox is a different character from the same prompt: redder, with a darker face and a different stance. If you already like a model, regenerating risks losing it, and costs another generation at that model's price (listed on each model page). To reduce a model you already have, decimate it yourself or use a post-processing service such as Tripo's decimate API or Meshy Remesh.
* **A low default can be the simplest route.** Tripo P2 built a complete fox at 5,474 triangles by default. It is a different, slimmer fox from the H3.1 one, so the figure shows a trade-off between two outputs rather than which method makes cleaner topology.

So set the budget in the request when you are generating fresh for a known target. Decimate when you are keeping something.

## Dedicated retopology tools

Apart from QuadriFlow, which we ran above, we did not run these. What they are, from their own pages read on 19 November 2026:

| Tool                                                                                                                | What it is                                                                                                                                 | Runs in                                                              | Price                                                                                                                                                                                                               |
| ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [QuadriFlow](https://docs.blender.org/manual/en/latest/modeling/meshes/retopology.html)                             | Quad remesher built into Blender                                                                                                           | Blender                                                              | Free                                                                                                                                                                                                                |
| [Instant Meshes](https://github.com/wjakob/instant-meshes)                                                          | Field-aligned quad remesher from a 2015 research paper; Modo's automatic retopology uses its algorithm                                     | Standalone app; prebuilt binaries for Windows, Intel macOS and Linux | Free, BSD-style licence; last commit November 2019                                                                                                                                                                  |
| [AutoRemesher](https://github.com/huxingyi/autoremesher)                                                            | Open-source automatic quad remesher                                                                                                        | Standalone app                                                       | Free (MIT); release 1.2.0 on 23 August 2026                                                                                                                                                                         |
| [ZRemesher](https://help.maxon.net/zbr/en-us/Content/html/user-guide/3d-modeling/topology/zremesher/zremesher.html) | ZBrush's automatic retopology; version 3 adds hard-surface handling, with a target polygon count and an adaptive mode                      | ZBrush                                                               | Part of a ZBrush subscription from Maxon                                                                                                                                                                            |
| [Quad Remesher](https://exoside.com/quadremesher/)                                                                  | Commercial auto-retopology plugin from Exoside                                                                                             | Blender, Maya and other host apps Exoside lists                      | $109.90 perpetual for one host app, $59.90 for a non-commercial licence, or $15.99 per three months, before VAT, with a one-month trial ([pricing](https://exoside.com/quadremesher/quadremesher-buy/))             |
| [Meshy Remesh](https://www.meshy.ai/features/ai-retopology)                                                         | Remesh an uploaded model to triangles or quads at a fixed or adaptive target; Meshy's feature page says textures carry over with no rebake | Meshy web app (FBX, OBJ, STL, glTF or GLB up to 100 MB) and API      | No credits in the web app, but only the 10K target on the free plan ([guide](https://docs.meshy.ai/en/webapp/guides/3d-model/remesh)); 5 credits per API task ([API pricing](https://docs.meshy.ai/en/api/pricing)) |

The difference that matters for characters is whether you can steer the edge flow. Instant Meshes, which is free, has brush tools for editing its orientation and position fields before it builds the mesh. ZRemesher, per Maxon's documentation, can use PolyGroups, creased edges and its Detect Edge option to guide the new topology. We did not check Quad Remesher's guide controls. QuadriFlow in Blender offers symmetry, sharp-edge preservation and a seed, but no way to draw where loops should go. None of them claims to produce finished animation topology without an artist checking it.

Voyager, the desktop app our team builds, can run Blender operations like these from a chat: its agent works in the Blender on your computer, so "merge, decimate to 10,000 and export a GLB" does not need a script of your own. We did not time that route; the figures above are for the script below, and the same operations with the same settings should give the same meshes. The setup is in [connect Blender to Voyager](/blog/connect-blender-to-voyager).

## The script we ran

The core of the decimation run, for Blender 5.2. It starts from an empty scene, so it is safe to paste into the Scripting tab of a fresh file or run headless with `blender -b -P decimate.py`; it joins every mesh in the GLB into one before reducing it.

```python
import bpy, bmesh

SRC, OUT, TARGET = "model.glb", "model_10k.glb", 10000

bpy.ops.wm.read_factory_settings(use_empty=True)  # empty scene: no default cube
bpy.ops.import_scene.gltf(filepath=SRC, merge_vertices=True)

meshes = [o for o in bpy.context.scene.objects if o.type == "MESH"]
bpy.ops.object.select_all(action="DESELECT")
for o in meshes:
    o.select_set(True)
bpy.context.view_layer.objects.active = meshes[0]
if len(meshes) > 1:
    bpy.ops.object.join()
obj = bpy.context.view_layer.objects.active
bpy.ops.object.parent_clear(type="CLEAR_KEEP_TRANSFORM")
bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)

# Weld near-duplicates the importer misses (Meshy files need this)
bm = bmesh.new(); bm.from_mesh(obj.data)
bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.000001)
bm.to_mesh(obj.data); bm.free()

tris = sum(len(p.vertices) - 2 for p in obj.data.polygons)
mod = obj.modifiers.new("Decimate", "DECIMATE")
mod.decimate_type = "COLLAPSE"
mod.ratio = min(1.0, TARGET / tris)
bpy.ops.object.modifier_apply(modifier=mod.name)

bpy.ops.object.select_all(action="DESELECT")
obj.select_set(True)
bpy.ops.export_scene.gltf(filepath=OUT, export_format="GLB", use_selection=True)
```

For QuadriFlow, work through the four checks above first. If short edges are the only problem left, scale the object up 100 times and apply the scale before `bpy.ops.object.quadriflow_remesh(target_faces=5000)`, then scale it back down. Our runs used `use_mesh_symmetry=False`, `use_preserve_sharp=False` and `use_preserve_boundary=False`.

## Which fix to use

| If the model is                                         | Do this                                                                                                       | Because                                                                               |
| ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
| A static prop, environment piece or product render      | Merge, then decimate to budget                                                                                | Seconds of work, textures kept; check silhouette, seams and thin parts at screen size |
| A background or crowd character that never deforms much | Merge, then decimate, with two or three LODs                                                                  | Same as a prop; the texture hides the faceting at distance                            |
| A hero character you will rig and animate               | Quad remesh as a base, then hand-fix loops at joints and face, then bake                                      | No automatic tool we ran or read about claims finished deformation topology           |
| A model you will sculpt on or subdivide                 | Quad remesh, fixing non-manifold edges first                                                                  | An even quad layout subdivides more predictably than scattered triangles              |
| Not generated yet, and you know the budget              | Set `face_limit` (Tripo), `target_polycount` with `should_remesh` on (Meshy 7.1) or the preset in the request | Built near size; but each attempt is a new model, and the count can miss              |
| A hard-surface object with crisp edges                  | Decimate, or remesh with sharp-edge preservation and check the rim                                            | QuadriFlow rounded and warped our dripper's rim with sharp preservation off           |

## Frequently asked questions

### Can AI do retopology?

Partly. Generators can build a mesh at a face budget or in quads (Tripo's `quad` and `smart_low_poly`, Meshy's quad `topology`, Rodin's Quad mode), and services such as Meshy Remesh and Tripo's decimate API rebuild an existing model, per their documentation read on 19 November 2026. None of them claims finished animation topology, and Blender's own manual says no automatic tool produces it yet.

### Is retopology necessary for AI-generated 3D models?

Not always. If the model will not deform, decimating to your budget is often enough: our Tripo fox went from 1.47 million to 10,000 triangles with its textures intact and an average surface shift of 0.015% of its size. For a character you will rig, or a model you will subdivide or sculpt, controlled edge flow matters, and that is what retopology gives you.

### What is the difference between decimation and retopology?

Decimation removes triangles from the existing mesh and keeps its UVs, so the existing texture maps can be reused without a bake, though fine texture detail can smear once the triangles get coarse. Retopology builds a new mesh, usually quads with loops placed where the model bends, over the old one, so the textures have to be baked onto it again.

### How do I reduce the polygon count of an AI model in Blender?

Import the GLB with Merge Vertices ticked, run Merge by Distance if the file is from Meshy, add a Decimate modifier in Collapse mode, set Ratio to target divided by current triangles, and apply it. On our files that took 0.1 to 12 seconds depending on the starting size.

### Does decimating ruin the textures?

Not on models with large UV islands: the Tripo and Trellis textures held up at every level we tried, down to 5,000 triangles. Thin UV strips are the weak spot. The Meshy fox's fur looked unchanged at 10,000 triangles, began to smear at 5,000 and streaked at 2,000.

### Why does QuadriFlow say the mesh needs to be manifold?

The message covers four checks. Open boundaries are allowed, but edges shared by more than two faces, faces with flipped winding, loose edges and edges with almost no length are not. Recalculate normals, delete loose geometry, select non-manifold edges with only Multiple Faces ticked and delete those faces, and only if it still refuses, scale the model up 100 times before remeshing.


## Voyager is a desktop AI agent for creative work

Describe what you want to make; Voyager plans it, uses your apps and tools, and keeps everything editable.

[Sign up](/sign-up)