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.
#3dHome › 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
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.
| If you need… | Use |
|---|---|
| Fewer triangles on a model you generated in Meshy | Meshy (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 rig | Tripo (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 model | Blender's Decimate modifier, or our tested LOD script below |
| Free automatic quad retopology outside the generators | Blender's Quad remesh (QuadriFlow) or Instant Meshes |
| LODs without making them by hand | Unity Mesh LOD (Generate mesh LODs on import), Godot's automatic mesh LOD, or Unreal's Nanite for static meshes |
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 | Tripo | |
|---|---|---|
| Low-poly at generation | Smart Topology model type (API: meshy-t2, or meshy-t2.5 by default); triangles only | Smart Mesh: native quads 500–25,000 or triangles 500–50,000; API P series from 48 faces |
| Reduce an existing model | Remesh: quad-dominant or triangle, 100–300,000 faces, adaptive or fixed target | Retopology (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 model | API retopology bakes textures onto the low-poly by default (v2.0 and v3.0) |
| UVs | UV Unwrap for meshes up to 40,000 faces | Smart UV for up to 80,000 equivalent triangles; v3.0 retopology can unwrap in the same task |
| API price | Remesh 5 credits; UV Unwrap 5 | Retopology v3.0 35 credits, 40 for quads (1 credit = $0.01) |
| Free plan | 100 credits/month, CC BY 4.0 (attribution) | 200 credits/month, public models, non-commercial |
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.
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.
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'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 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.
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.
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.
Few engines publish hard numbers, so treat these as limits, not targets:
| Limit | Number | Source |
|---|---|---|
| Roblox: one mesh | 20,000 triangles | Roblox mesh specifications (avatar items have their own, lower budgets) |
| Meshy rigging input | 380,000 triangles (a quad counts as 2) | Meshy Rigging API |
| Meshy UV Unwrap input | 40,000 faces | Meshy UV Unwrap API |
| Tripo Smart UV input | 80,000 equivalent triangles | Tripo Smart UV API |
| Unreal LOD Group preset example | SmallProp: 4 LODs, 50% of triangles per step | Unreal 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.
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.
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 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.
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.
_LODn meshes for a Unity LOD Group.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.
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.
Checked November 3, 2026.
*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
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.
#3d3D 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.
#3dReach builders, vibe coders & indie game devs. Featured listings from $49/mo.
Advertise →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.
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.
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.
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.
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.
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
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.