Home › AI Retopology and Low-Poly Game-Ready 3D Models (2026): Meshy, Tripo, Blender and Instant Meshes

AI Retopology and Low-Poly Game-Ready 3D Models (2026): Meshy, Tripo, Blender and Instant Meshes

AI 3D generators are great at shapes and bad at budgets: a raw model can carry hundreds of thousands of triangles with topology no animator would choose. Before it goes in your game it needs a sensible polycount, clean UVs and, for anything you see from far away, LODs. This guide covers the built-in options in Meshy and Tripo, the free tools (Blender and Instant Meshes), the budgets engines actually publish, and how Unity, Godot and Unreal handle LODs, all from each tool's own docs and pricing pages. We also wrote and tested a small Blender script that makes LOD levels for you.

Last updated:

Free download · one page + PDF · updated weekly, current edition November 16, 2026

🎁 Free: The AI Game Dev Stack 2026

The best AI tool for each job in a solo or indie game (3D, sprites and pixel art, animation, audio, NPCs), MCP setups for Unity, Unreal, Godot and Roblox, and which free plans you can actually ship with.

Yours free when you join the VibeStack Weekly: new AI game-dev tools and releases every Monday, 5-minute read. Unsubscribe anytime.

Quick picks

If you need…Use
Fewer triangles on a model you generated in MeshyMeshy (try Meshy ↗*) Remesh (presets from 3K to 100K faces, or a custom target down to 100), or generate with Smart Topology from the start
Clean quads for a character you'll rigTripo (try Tripo ↗*) Smart Mesh (native quads, 500 to 25,000) or its free online quad remesh tool for any uploaded model
A free, offline way to cut polycount on any modelBlender's Decimate modifier, or our tested LOD script below
Free automatic quad retopology outside the generatorsBlender's Quad remesh (QuadriFlow) or Instant Meshes
LODs without making them by handUnity Mesh LOD (Generate mesh LODs on import), Godot's automatic mesh LOD, or Unreal's Nanite for static meshes

Why AI models need retopology

Retopology means rebuilding a mesh's polygons: fewer of them, in a layout that deforms, unwraps and shades well. Generators optimize for how a model looks in a preview, so their defaults lean dense. Tripo's High Detail models go up to 2 million polygons, and Tripo itself pitches them at pipelines that sculpt first and retopologize later. Meshy's Remesh API defaults to a 30,000-face target and accepts up to 300,000. Neither number is a game budget.

Three things decide how far you need to go: the platform's limits (Roblox has a hard cap, below), whether the model will deform (characters need edge flow around joints, props don't), and how close the camera gets. Static props usually only need a lower triangle count and clean UVs. Rigged characters need real retopology, and Blender's own manual says there are no perfect automatic tools for deforming topology yet.

Meshy vs Tripo for game-ready topology

MeshyTripo
Low-poly at generationSmart Topology model type (API: meshy-t2, or meshy-t2.5 by default); triangles onlySmart Mesh: native quads 500–25,000 or triangles 500–50,000; API P series from 48 faces
Reduce an existing modelRemesh: quad-dominant or triangle, 100–300,000 faces, adaptive or fixed targetRetopology (API v1.0–v3.0) and a free online quad remesh tool (quads 500–10,000, triangles 500–20,000)
Keeps textures?Remesh regenerates UVs and re-applies textures, and keeps the original modelAPI retopology bakes textures onto the low-poly by default (v2.0 and v3.0)
UVsUV Unwrap for meshes up to 40,000 facesSmart UV for up to 80,000 equivalent triangles; v3.0 retopology can unwrap in the same task
API priceRemesh 5 credits; UV Unwrap 5Retopology v3.0 35 credits, 40 for quads (1 credit = $0.01)
Free plan100 credits/month, CC BY 4.0 (attribution)200 credits/month, public models, non-commercial

Meshy: Smart Topology and Remesh

Start low. In the Meshy workspace, pick Smart Topology instead of High Detail as the model type; Meshy's own guide says it gives fewer faces and cleaner topology. In the API, model_type: smart-topology uses meshy-t2 (cleaner topology and natively separated parts, 100–15,000 faces, default 4,000) or meshy-t2.5 (the default, which Meshy describes as sharper detail for game assets, 100–30,000 faces, default 15,000). Smart Topology output is triangles only. A text- or image-to-3D mesh without textures costs 5 credits on these models, against 20 on meshy-7.1 or meshy-6. If you used the older lowpoly model type, it's deprecated; Meshy's deprecation page gives both October 30 and November 30, 2026 as its retirement date, so switch now.

Remesh what you have. The Remesh button in the toolbar rebuilds a model with a new face count: presets of 3K, 10K, 30K or 100K, a custom target as low as 100 faces, or an adaptive mode. Meshy recommends quads if you'll rig or animate the model and triangles for static props. It saves the result as a new model and keeps the original, and it regenerates UVs and re-applies the textures. Through the API, Remesh takes a Meshy task or your own GLB, glTF, OBJ, FBX or STL file, with topology set to quad or triangle and a target_polycount from 100 to 300,000 (the result can differ from the target), and costs 5 credits. It exports GLB, FBX, OBJ, USDZ, BLEND, STL and 3MF.

Plan note: Meshy's pricing comparison lists Remesh on the paid plans (Pro is $20/month for 1,000 credits) and not on Free, while its low-poly page's FAQ says the free credits are enough to try Smart Topology and remesh the result. Check in the app before you count on it. Free-plan models are licensed CC BY 4.0, so you must credit Meshy.

Tripo: Smart Mesh, P series and Retopology

Smart Mesh generates native quad meshes from 500 to 25,000 polygons (or triangles from 500 to 50,000) that Tripo calls engine-ready with no retopology needed; its pricing page lists Smart Mesh access in the Pro plan's toolkit ($20/month billed annually, 3,000 credits a month). The free plan's toolkit includes Retopology, with 200 credits a month, but free models are public and non-commercial.

Quad remesh any model. Tripo's AI remesh tool turns a triangle or messy mesh into quads, and it accepts your own uploads, not just Tripo models: 500–10,000 polygons in quad mode or 500–20,000 in triangle mode, exported as FBX, GLB or OBJ. Tripo calls it a free online tool and says its P1.0 model stays available to every user.

API. The P series text- and image-to-model models are tuned for low-poly output: P1 makes 50–20,000 faces, and P2 makes 48–50,000 triangles or 48–25,000 quads. Tripo suggests starting around 150 faces for simple models and 250 for complex ones. To reduce a model you already have, the Retopology endpoint (/v3/mesh/decimate) takes GLB, glTF, FBX, OBJ or STL up to 150 MB with a face_limit and an optional quad flag; v2.0 (the default) does smart high-poly-to-low-poly, v1.0 is plain decimation, and v3.0 can also unwrap UVs in the same task. bake (on by default except on v1.0) bakes the original's textures onto the low-poly. On v3.0 a quad result costs 40 credits instead of 35, and one credit is $0.01, so about $0.35–$0.40 a model. Failed or cancelled tasks aren't charged.

Free tools: Blender and Instant Meshes

Blender Decimate (fastest, for props)

The Decimate modifier's Collapse mode keeps a ratio of the faces (computed on triangles) and shows the resulting face count right in the modifier, so you can dial in a budget. Planar merges flat areas below an angle limit and can respect material, seam, sharp or UV boundaries, which suits hard-surface props; Un-Subdivide reverses grid-like subdivision. Collapse keeps UVs and materials, so the original textures still fit, which is why it's the quickest win for static AI props.

Blender Remesh: Voxel and Quad (QuadriFlow)

Blender's Remesh (Properties > Data > Remesh) has two modes. Voxel rebuilds the surface as an even grid, which is great for fixing holes and overlaps from AI output before sculpting, but Blender's manual says it's not meant for deforming characters or for simply lowering the face count (use Decimate for that). Quad uses the QuadriFlow algorithm to make an all-quad mesh to a target ratio, edge length or face count, with options to preserve sharp edges and use symmetry; it's slower and won't clean up intersecting geometry. The Remesh modifier also outputs quads only and needs a mesh with some thickness (add Solidify first for flat parts). Plan to unwrap and bake afterwards: in our test on the helmet sample below, Quad remesh (asked for 4,000 faces, it returned 2,945) dropped the UV map entirely.

Instant Meshes

Instant Meshes is a free, BSD-licensed field-aligned quad remesher from a SIGGRAPH Asia 2015 paper, with precompiled builds for Windows, macOS and Linux (the Linux build needs zenity); its README notes that Modo has used the algorithm since version 10.2. Load a mesh, solve the orientation field and then the position field, and export; brush tools let you adjust both fields by hand where the automatic flow goes wrong. Like any remesher, it gives you new topology without your original UVs.

Manual retopology

For a hero character, the honest answer is still manual work: Blender's Remeshing page recommends its Retopology overlay, the Poly Build tool and face snapping to draw new topology over the AI mesh. Automatic quads from Tripo, QuadriFlow or Instant Meshes make a good starting point to clean up.

Make LODs in one command (tested script)

This Blender script imports a GLB, glTF, FBX or OBJ, decimates it to the triangle budgets you give it, most detailed first, and exports the levels as Name_LOD0, Name_LOD1 and so on, the suffix Unity uses to build a LOD Group automatically when you import an FBX. Give it one budget to just shrink a model to a single game-ready mesh, which is all you need for Godot or Unity's Mesh LOD since they generate the other levels. It refuses rigged models, because decimating skinned meshes needs care. Run it with blender -b -P make_lods.py -- model.glb model_lods.fbx 15000 5000 1500, or with the bpy module from PyPI as python make_lods.py ….

"""make_lods.py - decimate an AI-generated 3D model to triangle budgets and
export LOD levels named _LOD0, _LOD1, ... (the suffix Unity's LOD Group import uses).

Run with Blender (tested with 5.2.3 LTS), no add-ons needed:
  blender -b -P make_lods.py -- model.glb model_lods.fbx 15000 5000 1500
or with the bpy module from PyPI:
  python make_lods.py model.glb model_lods.fbx 15000 5000 1500

Each number is a triangle budget for one LOD level, most detailed first.
Give a single budget (e.g. 15000) to just shrink the model to one game-ready mesh.
Input: .glb/.gltf/.fbx/.obj. Output: .fbx or .glb. Static meshes only:
rigged (skinned) meshes are refused, because decimating them needs care.
https://vibestackweekly.com/ai-retopology-low-poly-game-ready-3d-models/
"""
import sys, os
import bpy

argv = sys.argv[sys.argv.index("--") + 1:] if "--" in sys.argv else sys.argv[1:]
if len(argv) < 3:
    sys.exit("usage: make_lods.py INPUT OUTPUT BUDGET [BUDGET ...]")
src, dst, budgets = argv[0], argv[1], [int(b) for b in argv[2:]]

def tris(obj):
    return sum(len(p.vertices) - 2 for p in obj.data.polygons)

bpy.ops.wm.read_factory_settings(use_empty=True)
ext = os.path.splitext(src)[1].lower()
if ext in (".glb", ".gltf"): bpy.ops.import_scene.gltf(filepath=src)
elif ext == ".fbx": bpy.ops.import_scene.fbx(filepath=src)
elif ext == ".obj": bpy.ops.wm.obj_import(filepath=src)
else: sys.exit("unsupported input: " + ext)

meshes = [o for o in bpy.context.scene.objects if o.type == "MESH"]
if not meshes: sys.exit("no meshes found")
if any(m.type == "ARMATURE" for o in meshes for m in o.modifiers) or \
   any(o.type == "ARMATURE" for o in bpy.context.scene.objects):
    sys.exit("rigged model found: this script is for static meshes")

# Bake each object's transform into a world-space copy so LODs line up.
total = sum(tris(o) for o in meshes)
print(f"input: {len(meshes)} mesh(es), {total} triangles")
deps = bpy.context.evaluated_depsgraph_get()
lods = []
for i, budget in enumerate(budgets):
    ratio = min(1.0, budget / total)
    level = 0  # triangles in this LOD level
    for o in meshes:
        mod = o.modifiers.new("LODDecimate", "DECIMATE")
        mod.decimate_type = "COLLAPSE"
        mod.ratio = ratio
        mod.use_collapse_triangulate = True
        deps.update()
        me = bpy.data.meshes.new_from_object(o.evaluated_get(deps))
        o.modifiers.remove(mod)
        me.transform(o.matrix_world)
        base = o.name if len(meshes) > 1 else os.path.splitext(os.path.basename(src))[0]
        lod = bpy.data.objects.new(f"{base}_LOD{i}", me)
        bpy.context.scene.collection.objects.link(lod)
        lods.append(lod)
        level += tris(lod)
    print(f"LOD{i}: budget {budget}, got {level} triangles (ratio {ratio:.3f})")

for o in list(bpy.context.scene.objects):
    o.select_set(o in lods)
out = os.path.splitext(dst)[1].lower()
if out == ".fbx":
    bpy.ops.export_scene.fbx(filepath=dst, use_selection=True, path_mode="COPY", embed_textures=True)
elif out == ".glb":
    bpy.ops.export_scene.gltf(filepath=dst, export_format="GLB", use_selection=True)
else: sys.exit("unsupported output: " + out)
print("wrote", dst)

What we tested (November 3, 2026, Blender 5.2.3 LTS as the bpy Python module): on Khronos' DamagedHelmet sample (15,452 triangles, five 2K textures) budgets of 30,000, 8,000 and 2,000 gave LODs of 15,452, 8,000 and 2,000 triangles that kept the UV map and material and lined up with the original's bounding box after re-importing the FBX. A 1,007,616-triangle test mesh went to 19,999, 5,000 and 1,000 triangles in about 17 seconds including import, on an 8-core box. The rigged Fox sample was refused, as intended. Two things to know: the FBX export carried 3 of the helmet's 5 textures (the glTF metal-roughness and occlusion maps didn't come through, so reconnect them in your engine or export GLB), and the GLB export grew from 3.8 MB to 8.4 MB because Blender repacked the occlusion and metal-roughness maps into a PNG. Cutting triangles doesn't shrink textures; resize those separately. We haven't run it in the full Blender app or imported the results into Unity, Godot or Unreal.

Download make_lods.py (the same script as a file, MIT license; needs Blender or the bpy module). All files: free downloads.

Polycount budgets: what's actually documented

Few engines publish hard numbers, so treat these as limits, not targets:

LimitNumberSource
Roblox: one mesh20,000 trianglesRoblox mesh specifications (avatar items have their own, lower budgets)
Meshy rigging input380,000 triangles (a quad counts as 2)Meshy Rigging API
Meshy UV Unwrap input40,000 facesMeshy UV Unwrap API
Tripo Smart UV input80,000 equivalent trianglesTripo Smart UV API
Unreal LOD Group preset exampleSmallProp: 4 LODs, 50% of triangles per stepUnreal automatic LOD generation docs

Roblox also wants meshes watertight, without n-gons (quads where possible) and with volume, and allows at most 4 bone influences per vertex. Beyond hard limits, budget by screen size: a crate seen from across a room needs far fewer triangles than a character's face in a cutscene, and LODs let you have both.

UVs and baking normals

Decimating keeps your UVs; remeshing (Voxel, QuadriFlow, Instant Meshes) doesn't. After a remesh, unwrap in Blender: Unwrap (U) for organic shapes, or Smart UV Project, which cuts seams at sharp angles and suits mechanical objects and architecture. Meshy's UV Unwrap API returns a triangle mesh with a grey placeholder material, so it's a step before baking, not a finished asset.

To keep the high-poly look on the low-poly mesh, bake a normal map in Blender with Cycles: select the high-poly, then the low-poly, set Bake Type to Normal with Selected to Active, and adjust Extrusion and Max Ray Distance (or use a cage with the same topology as the low-poly) until the rays catch all the detail. The low-poly needs a UV map and an active Image Texture node to bake into. Tangent space, the default, is the one to use for animated objects. Meshy's low-poly page also sends you to Blender or Substance for this step; Tripo's API does a texture bake for you when you retopologize.

LODs in Unity, Godot and Unreal

Unity

Unity has two systems. Mesh LOD (documented from the Unity 6.2 manual on) generates LODs on import: select the model and tick Generate mesh LODs in the Inspector. It stores the levels in the original mesh's index buffer, so it's light on memory, but it doesn't reduce materials or draw calls, it works on triangle topology only, and it ignores skin weights and blend shapes when simplifying (a skinned mesh still deforms LOD0). It isn't supported with Entities Graphics, the Particle System, VFX Graph, static batching or GPU instancing. LOD Group is more flexible but has a larger memory footprint: you make each level yourself, name the meshes with a _LOD0, _LOD1… suffix, export FBX, and Unity creates the component on import (up to 8 levels). Unity doesn't recommend combining the two. More Unity tooling is in our AI tools for Unity guide.

Godot

Godot generates mesh LODs automatically when it imports glTF, .blend, Collada or FBX scenes (OBJ only if you import it as a Scene), using meshoptimizer, so a single clean LOD0 is all you need to bring in. It switches levels by on-screen error: the Rendering > Mesh LOD > LOD Change > Threshold Pixels project setting defaults to 1 pixel, which Godot calls perceptually lossless, and each mesh instance has a LOD Bias. Godot warns that generation can occasionally cause rendering issues, especially in skinned meshes, and lets you turn it off per mesh or globally; for hand-made LODs or HLOD, use visibility ranges. See our AI tools for Godot.

Unreal Engine

Nanite is Unreal 5's virtualized geometry: it handles LOD automatically, so a dense static mesh needs no manual LODs. Tick Build Nanite when importing, enable Nanite Support in the mesh editor, or right-click several meshes in the Content Browser and choose Nanite > Enable. Epic recommends high-poly detail over baking detail into normal maps for Nanite meshes. The catches: materials must be Opaque or Masked, it needs DirectX 12 with Shader Model 6 class hardware, it doesn't support forward rendering, VR stereo rendering or MSAA, and Nanite skeletal meshes have no geometry LODs and don't support morph targets. For meshes that don't use Nanite, the Static Mesh Editor can generate LODs automatically with quadratic mesh simplification, and Epic suggests LOD Group presets such as SmallProp (4 LODs, half the triangles each step) to set it up consistently. More in our AI tools for Unreal guide.

A practical workflow for AI props and characters

  1. Generate low if you can. Meshy Smart Topology or Tripo Smart Mesh saves a cleanup pass; use high-detail models only for hero assets or a high-to-low bake.
  2. Static props: decimate (Meshy Remesh with triangles, Tripo Retopology, or Blender Decimate / our script) to the smallest count that still reads, then check the silhouette from your game's camera.
  3. Characters: get quads from Tripo Smart Mesh or quad remesh, Meshy Remesh in quad mode, QuadriFlow or Instant Meshes, then fix edge loops around joints by hand. Rig them next with our AI auto-rigging guide.
  4. UVs and bake: if you remeshed, unwrap and bake normals (and the base color) from the original onto the new mesh.
  5. LODs: let Unity Mesh LOD, Godot or Nanite generate them, or export _LODn meshes for a Unity LOD Group.
  6. Import and check: scale, pivot and materials in the engine (Unity and Godot steps are in text-to-3D for Unity and Godot), and for Roblox stay under 20,000 triangles per mesh.

Licenses and disclosure

Retopology doesn't change who owns a model. Meshy's free-plan models are CC BY 4.0 and need attribution; Tripo's free-plan models are public and non-commercial, so a commercial game needs a paid plan for the assets you ship. On Steam, AI-generated assets that ship in your game belong in the Content Survey; see Steam AI disclosure: what to write.

What we haven't tested

We tested our LOD script, not the generators: we haven't run Meshy Remesh or Smart Topology, Tripo Smart Mesh, its quad remesh tool or its Retopology API, QuadriFlow or Instant Meshes on the same model, so this page compares documented features and limits, not output quality. Tripo's pricing table also lists Smart Low Poly and part-based retopology, but we couldn't read which plans include them. The credit example on Tripo's Smart UV page isn't a published price. Plan limits change often; check each pricing page before you pay.

Sources

Checked November 3, 2026.

Get the Starter Stack ($12) Get the free weekly digest

*Some links on this page are affiliate links: if you sign up through them we may earn a commission at no extra cost to you. It never affects our picks. Disclosure

Our picks (2)

freemium

Meshy

3D Generation

Text/image to 3D models with textures, game-engine ready. Meshy N1 (Nov 3, 2026) adds native 3D texturing: 2K base colour textures with fewer projection seams, for all registered users.

#3d
freemium

Tripo

3D Generation

Fast AI 3D model generation from text or images, with texturing, retopology and auto-rigging. New: Agentic Canvas (beta, Oct 29, 2026), an AI agent that plans and runs multi-step 3D workflows on a node canvas; Max and Team first, rolling out to other accounts. Tripo CLI (npm tripo-cli, MIT) lets Claude Code, Codex or Cursor generate assets from the terminal or over MCP; it spends API credits, not Studio credits.

#3d

+ Your tool here

Reach builders, vibe coders & indie game devs. Featured listings from $49/mo.

Advertise →

Try: Meshy ↗ · Tripo ↗*

🧰 The Vibe Coder's Starter Stack: AI rules files, a prompt library and a ship-it checklist. $12.
Get the pack

FAQ

Do AI 3D models need retopology for games?

Usually some. Static props often only need fewer triangles, which Meshy Remesh, Tripo Retopology or Blender's Decimate modifier handle while keeping textures. Characters you'll rig need cleaner quad topology around joints, and Blender's manual notes there's no perfect automatic tool for deforming topology yet.

Can Meshy or Tripo make low-poly models directly?

Yes. Meshy's Smart Topology model type makes lower-poly, cleaner meshes (up to 15,000 or 30,000 faces depending on the model in its API), and Tripo's Smart Mesh makes native quad meshes from 500 to 25,000 polygons. Both can also remesh an existing model to a target face count.

What is the best free retopology tool?

For props, Blender's Decimate modifier is fastest and keeps UVs. For automatic quads, Blender's Quad remesh (QuadriFlow) and Instant Meshes are free; Tripo also offers a free online quad remesh tool for uploaded models. Remeshed models need new UVs and a normal-map bake.

How many triangles should a game model have?

There's no universal number. Roblox caps a single mesh at 20,000 triangles; most engines instead let you use LODs so detail drops with distance. Budget by how large the object appears on screen and test on your lowest-end target.

Do I need to make LODs by hand?

Often not. Unity 6.2+ can generate Mesh LODs on import, Godot generates LODs automatically for glTF, .blend and FBX imports, and Unreal's Nanite handles LOD for supported static meshes. Make them by hand (named _LOD0, _LOD1… for a Unity LOD Group) when you need control.

Does Nanite mean I don't need low-poly models in Unreal?

For opaque or masked static meshes on DirectX 12 SM6-class hardware, largely yes: Epic recommends high-poly detail over baked normal maps. But Nanite doesn't support forward rendering, VR stereo or MSAA, so mobile, VR and some stylized projects still need conventional low-poly meshes and LODs.

Free download · one page + PDF · updated weekly, current edition November 16, 2026

📬 Get the VibeStack Weekly + the free AI Game Dev Stack 2026

The best AI tool for each job in a solo or indie game (3D, sprites and pixel art, animation, audio, NPCs), MCP setups for Unity, Unreal, Godot and Roblox, and which free plans you can actually ship with.

Yours free when you join the VibeStack Weekly: new AI game-dev tools and releases every Monday, 5-minute read. Unsubscribe anytime.