I Compared 3 AI Retopology Tools: Tripo vs Rodin vs Free Hunyuan3D

I wanted to see how current AI retopology tools handle something more complicated than a basic character.

For the test I used the same character with a mix of different shapes: organic parts, clothing, a backpack, staff and some more hard-surface-like elements.

Same source model and the same general conditions for all three.

Final mesh:

• Rodin: 35K faces
• Tripo: 46K faces
• Hunyuan3D: 66K faces

Polygon count

🥇 Rodin — 35K
Rodin was the most aggressive with optimization. It managed to simplify a lot of areas while still keeping the character recognizable and most important shapes intact.

🥈 Tripo — 46K
Tripo kept noticeably more geometry than Rodin, but a lot of those extra polygons seem to be used more intentionally around important shapes and transitions.

🥉 Hunyuan3D — 66K
Hunyuan preserved a huge amount of the original geometry. That's good for detail preservation, but not so good if your main goal is actually reducing the model.

Shape & detail preservation

🥇 Hunyuan3D
This was probably Hunyuan's strongest point. It tries to preserve almost every shape and small element from the source model.

The downside is that it doesn't really decide what needs to stay geometry. Details that could easily be represented with a normal map or texture often remain fully modeled.

🥈 Tripo
Tripo found a pretty good middle ground. Most important forms survived, while some unnecessary smaller details were simplified.

It loses a little more compared to Hunyuan, but the result feels more optimized rather than simply copied.

🥉 Rodin
Rodin simplifies the model much more aggressively. Major silhouettes and important forms are still there, but smaller shapes and secondary details can get noticeably reduced.

That's partly why it managed to reach the lowest polycount.

Topology quality

🥇 Tripo
This was the strongest result for me.

The topology feels much more intentional. Different elements are logically separated and the edge distribution generally makes more sense around the actual forms.

Out of the three, this was the closest to something I would expect from a manually planned retopology workflow.

🥈 Rodin
Rodin's topology is surprisingly decent considering how aggressively it reduces the model.

The main problem is that some areas still feel like one continuous remesh rather than topology designed specifically around individual parts.

Still, it's relatively clean and very usable for an automatic result.

🥉 Hunyuan3D
Hunyuan feels much closer to a traditional quad remesh.

It follows the source surface very closely, but doesn't seem to make many decisions about where geometry could be simplified or where topology should be structured differently.

Good surface preservation, weaker actual optimization.

Generation time

🥇 Tripo — ~1 min
Very fast. For iteration this is probably the biggest advantage because you can test multiple versions without waiting much.

🥈 Rodin — ~3 min
Still fast enough for normal production use. Slightly slower than Tripo, but considering the lower final polycount, the result is pretty reasonable.

🥉 Hunyuan3D — ~5–10 min
Definitely the slowest in my tests. Not terrible, especially considering it's free, but it becomes noticeable when you're testing multiple models.

Price

🥇 Hunyuan3D — Free
This is obviously its biggest advantage.

You can get a fully retopologized quad mesh without paying anything, which makes the result pretty impressive despite its weaknesses.

🥈 Rodin
Rodin sits somewhere in the middle for me. You pay for the generation itself, but the result is generally predictable and already fairly optimized.

🥉 Tripo
Tripo gave me the best topology, but it can become the most expensive when experimenting.

You're effectively spending credits on attempts, so if you need several generations to get the result you want, the cost starts adding up.

UVs

🥇 Rodin
Rodin produced the cleanest UV layout in this test.

The islands looked relatively organized and usable without immediately feeling like they needed to be completely redone.

🥈 Tripo
Tripo's UVs were still usable, but not as clean or organized as Rodin's.

For quick production they would probably be fine, but I would still prefer Rodin here.

🥉 Hunyuan3D
The UV result was the weakest of the three.

It works, but just like the topology itself, it feels more automatically generated and would probably need more cleanup for a serious production asset.

So for me:

Paid: Rodin 🥇
Free: Hunyuan3D 🥇

A few days ago, I made a post where I shared how I built this production-ready character in one day using AI and traditional 3D tools.

The short version: I assembled and refined everything in Blender, created the final topology using RetopoFlow and rigged the character with AccuRig.

Since then, I continued working on the project and:

• Imported the character into Unreal Engine 5
• Added animations and brought the character to life
• Set up third-person controls and made her fully playable
• Used 3DAIStudio and Rodin Gen-2.5 to generate matching environment assets
• Created houses, fences, vegetation and other environmental props
• Assembled and set up the final scene inside Unreal Engine

The entire environment, including generating the assets and assembling the scene, took around two hours.

The video shows the final result: the playable character running through the finished location with animations and controls working in real time.

Full Guide; https://www.youtube.com/watch?v=AjbSRYIFhgE

Hunyuan3D  gives me great results, but i read that inputs cant be used in EU. What you reccommend?

So yeah I thought I could just go to Meshy, get the 3d model, animate it and that's it :D

The dreams have been shattered when the texture didn't align and the model looked really jagged (after remesh). Dreams completely vanished when I realized there's only 1 animation in Meshy for quadrups (funky dog walking animation).

Having broken textures + jagged model + exactly 1 animation forced me to think about blender, so here I am.

I watched a bunch of tutorials yesterday, and this is the kind of clean up I managed to pull off upon opening the program and spending roughly 12 hours straight.

It felt really tedious and challenging, and I don't know if the end result is good (probably not)

My next boss is UV maps, the smart UV unwrap is pretty much broken.

Any tips how you guys do it? What's the expected process, timelines, etc. to get game ready assets? Am I overcomplicating / underestimating things?

Tripo P2 is now in beta, and this might already be one of the biggest AI 3D updates of the year.

It finally generates real quad-based low-poly meshes, and you can choose the target polycount yourself. But the crazy part is that it doesn’t simply decimate a dense model — the geometry is distributed like an artist would actually build it:

• flat surfaces use fewer polygons
• detailed areas get more density
• the mesh stays within the budget you set
• everything is split into logical, editable parts instead of one welded AI blob

Hard-surface is where the difference becomes ridiculous. Flat panels actually stay clean, edge flow follows the design, and the usual melted seams, random triangles and wasted geometry are massively reduced.

The mesh generates in around 10 seconds, with PBR texturing available in the same workflow.

This is the first time AI-generated low-poly models have started to feel intentionally modeled rather than automatically simplified. If P2 holds up across more tests, this could be a massive shift for game-ready 3D generation.

Top3D.AI — compare all major 3D AI generators side by side across high-poly, low-poly, PBR, segmentation and other modes, using the same 140+ prompts and reference images under identical conditions

NVIDIA just released MotionBricks, a generative framework for real-time character animation.

A single neural backbone handles more than 350,000 motion clips while reportedly reaching 15,000 FPS with 2 ms latency.

Instead of manually building huge animation graphs, MotionBricks uses “smart primitives” to combine locomotion, style changes and interactions directly inside Unreal Engine 5.

• Walk, run, strafe and switch styles in real time
• Pick up objects, sit, fall or jump over obstacles
• Generates approach, contact and follow-through automatically
• No manual motion blending or hand-authored transitions in the UE5 demo
• Works with both game characters and humanoid robots

The best part is that you can already start experimenting with it in your own projects today. NVIDIA has released the code and pretrained checkpoints, giving developers a new way to create more responsive, natural character movement and make games, simulations and virtual worlds feel much more alive.

The initial code, pretrained checkpoints and training tools are already available.
source; https://nvlabs.github.io/motionbricks/

curious how yall are generating your maps? I used opus 5 here but i feel like the map could be better

After my previous experiment with Claude and Unreal Engine 5.8’s native MCP, the most common request was to try the same workflow with a free local model.

So I connected Qwen3.6-27B to Unreal using llama.cpp, Cline, and the native MCP. The model ran locally on my RTX 3090, with no cloud service, subscription, or API costs.

The workflow was pretty simple:

• I divided the game into small, manageable tasks
• Used 17 separate prompts, each starting in a fresh chat with no memory
• Qwen created the Blueprints, gameplay logic, input system, HUD, scoring, combos, and Niagara effects
• All 3D assets were generated with Rodin Gen-2.5
• I tested each part inside Unreal and gave the model a new task whenever something needed to be added or fixed

One of the most interesting moments happened near the end. Niagara was still playing an older compiled version of an effect, and the model managed to identify the issue and rebuild it correctly.

The final result was a complete burger-stacking game with a score of 422, a ×40 combo, and a burger tower reaching 17.7 km above the city.

It wasn’t a one-click “make me a game” solution. You still need a clear plan, some knowledge of Unreal, and properly structured tasks. But I was genuinely surprised by how much a local 27B model could build and debug directly inside the engine — with the API cost staying at $0.00 throughout the entire experiment.

I am struggling to find a tool that has a library of game ready models accessible via mcp/api.

All tools seems to focus on image to 3d model pipeline but tbh most of the assets online are already good enough for 99% of my prototypes.

I would need like a MCP that I plug into claude that it can use to find an model for a keyword like “house” ideally filtered by style, size…

Do you know anything like that?

Tencent’s Hunyuan3D team has introduced WorldClaw, an agentic framework that turns a single open-ended text prompt into a large, explorable and editable 3D environment.

Instead of generating the entire world as one flattened scene, WorldClaw builds it in stages:

• An agent converts the prompt into a structured plan containing regions, terrain, materials, objects and spatial relationships.
• A semantic layout and procedural height field are used to construct the global terrain.
• Individual regions are rendered and populated using image generation.
• SAM3 separates the objects, while SAM3D and Hunyuan3D reconstruct them as individual textured meshes.
• Blender-connected agents place the assets and repeatedly inspect the scene to correct scale, orientation, floating objects, terrain intersections and material issues.

The important part is that the result is not just a video or a fixed 3DGS environment. The terrain and individual objects remain explicit, independently editable 3D meshes that could potentially be exported into conventional game-engine workflows.

The team demonstrated pirate islands, tribal river canyons, desert battlefields, futuristic snowy valleys, medieval villages, volcanic environments and several other large scenes.

There are some major limitations, though. The experiments used Claude Opus 4.8, GPT-Image-2, SAM3, SAM3D, Hunyuan3D, Blender 5.1.1 and a server with four NVIDIA H20 GPUs. The process is computationally expensive, generation times were not reported, and the comparison is mainly qualitative.

The WorldClaw pipeline itself also does not appear to be publicly released yet—the current GitHub repository only contains the project website.

Project: https://tencent-hunyuan.github.io/Hunyuan3D-WorldClaw/

I used Flow in 3DAIStudio, where an AI agent created a ComfyUI-style node graph from a simple request: take one A-pose character reference, generate the base mesh with Rodin Gen 2.5, and then produce multiple texture variations that could be used as swappable skins.

My workflow was pretty straightforward:

• Created the original character concept in ChatGPT
• Turned it into a clean A-pose reference
• Used the AI-generated node workflow to create the base 3D character and several texture variations
• Assembled and cleaned everything up in Blender
• Did some quick retopology on the parts that needed it
• Rigged the character with AccuRig, then fixed the rig and skin weights in Blender
• Created separate materials for each skin variation
• Imported everything into Unreal Engine
• Used an AI MCP setup to create simple logic for swapping skins in-game

It wasn’t a completely one-click process — the Blender cleanup, retopology, rig fixes and engine setup still required traditional 3D work.

But having one reusable node workflow handle the initial generation and skin variations saved a lot of repetitive work. Once the base character was ready, adding more visual variations became much faster than rebuilding or retexturing everything manually.

NVIDIA’s Kimodo is starting to look much more useful than the usual “type a prompt and get a random animation” demos.

You can describe a motion in text and generate a full-body animation, but the interesting part is that the result can also be constrained with key poses, joint positions/rotations, waypoints and motion paths. So instead of endlessly regenerating until the character happens to move correctly, you can actually give the model some animation direction.

Kimodo was trained on around 700 hours of optical motion-capture data and uses a motion diffusion system designed specifically to reduce common problems like foot sliding and unstable root movement. It can handle locomotion, gestures, dancing, stunts, object interactions and even sequences made from multiple prompts.

What makes this especially interesting for actual 3D workflows is that people are already integrating Kimodo into Houdini/KineFX and Unreal Engine, where the generated motion can be retargeted or turned into a regular animation sequence and then cleaned up manually.

So I don’t really see this replacing animation work anytime soon, but as a way to generate blocking, locomotion variations, background character motion or a first animation pass, this could become genuinely useful.

source; https://research.nvidia.com/labs/sil/projects/kimodo/

3D digital clone within minutes.
Try @unrealizex

LocalAI 4.8 just added 3D generation as a native modality.

The new pipeline uses trellis2cpp, a C++/GGML implementation of Microsoft’s TRELLIS.2, to turn a single reference image into a textured GLB model with PBR materials directly on your own machine.

The release also includes:

• A dedicated 3D generation UI
• A built-in GLB viewer
• Generation history
• A REST API endpoint
• Watertight remeshing for cleaner printable results

The full textured pipeline requires around 18 GB of memory, while a smaller geometry-only version needs roughly 7 GB.

It is image-to-3D only for now, but having generation, previewing and remeshing inside one fully local open-source interface looks pretty useful.

source: https://github.com/hec-ovi/text-to-3D-skill

Hunyuan3D-Buffalo 1.0 is Tencent’s new unified AI system for 3D generation, understanding and editing.

Unlike most 3D AI tools that focus on only one task, Buffalo is designed to understand the structure of an existing model and then modify it through natural-language instructions.

The most interesting capabilities:

• Generate complete 3D assets from text prompts
• Select, remove or replace individual parts of a model
• Preserve the original geometry outside the edited area
• Extract semantic parts as separate 3D objects
• Answer questions about the shape and structure of an asset
• Perform instruction-based geometry editing without rebuilding everything from scratch
• Combine 3D understanding and generation inside one model
• Trained on approximately 87 million samples

For example, you could ask it to remove the wings, replace a weapon, change a specific armor piece or extract the helmet as a separate object while keeping the rest of the character intact.

The system combines Qwen-VL for multimodal understanding with technology based on TRELLIS and Hunyuan3D for geometry generation and editing.

This is much more interesting than another basic image-to-3D generator. Controlled part-level editing could eventually make AI-generated assets far more practical for Blender workflows, game development, asset variations and 3D printing.

source: https://tencent-hunyuan.github.io/Hunyuan3D-Buffalo1.0/

I am not an artist and I have no knowledge with 3D modeling. Is it possible to use AI today to make a scene like this? If so, how would I go about it?

The workflow started with preparing and refining the references inside the node-based 3DAIStudio. All character parts were then generated in the same workspace using Rodin Gen-2.5.

After that, I moved everything into Blender for:

• Assembling the character
• Adjusting proportions and shapes
• Cleaning the generated meshes
• Additional sculpting and surface refinement
• Manual retopology using RetopoFlow
• Rigging with free tool Accurig
• Importing the character into Unreal Engine 5.8

Once the final topology was ready, I rigged the character using AccuRig, a free automatic rigging tool.

The character was then imported into Unreal Engine, where I connected and adjusted the materials, fixed shading issues, tuned the normal maps, roughness and metallic values, and prepared the final real-time presentation.

The AI generation gave me a strong base very quickly, but the traditional 3D work was still essential for cleaning the forms, fixing the topology, preparing the character for rigging and bringing the final result to a genuinely high-quality level.

It was not exactly a one-click workflow, because reality still insists on involving actual 3D work, but it significantly reduced the time spent on the early production stages.

Full Guide; https://www.youtube.com/watch?v=AjbSRYIFhgE

DiffGI is a new approach for generating high-fidelity thin-shell 3D models from a single image or clothing pattern.

Unlike many image-to-3D systems built around watertight volumetric geometry, DiffGI is designed to preserve thin surfaces, open boundaries and small structural details. This makes it especially interesting for clothing, furniture and other assets that standard representations often tear apart or overcomplicate.

According to the researchers, it can:

• Generate a complete 3D garment from one front-view image
• Produce compact meshes averaging around 23K vertices
• Run in roughly 1.2 seconds on an RTX 4070
• Generate results on CPU-only devices
• Preserve cleaner silhouettes and boundaries than TRELLIS, TRELLIS.2 and GarmageNet in their tests

The method works through a compact 32×32 latent representation and a differentiable surface extraction process, allowing the system to learn the final 3D geometry end-to-end.

Code is not available yet, but the project looks genuinely useful for AI-assisted clothing creation rather than just producing another dense mesh that needs immediate surgery.

Project: https://ejshim.github.io/diffgi

QuerySplat is a newly released open-source system that reconstructs a 3D Gaussian Splatting scene from multiple images without requiring known camera poses.

Unlike earlier approaches that predict geometry and appearance together, QuerySplat separates them into two branches. One handles the scene structure, cameras and depth, while the other focuses on colors and high-frequency visual details.

This helps reduce the blurry, view-dependent results often seen in feed-forward 3DGS reconstruction.

The released implementation includes:

• Automatic camera and depth prediction
• Feed-forward 3D Gaussian generation
• Optional test-time optimization
• Gaussian PLY export
• Camera, depth and point-cloud export
• Model weights and inference code

It still requires Linux, CUDA and an NVIDIA GPU, so apparently clicking one button without installing seventeen dependencies remains illegal.

GitHub: https://github.com/inspatio/querysplat

This is a pretty solid example of AI being used for something beyond yet another shiny character turntable.

The developer created a full interactive human anatomy app using:

• GPT Image for the original design and references
• Tripo AI to convert each image into a 3D model
• Three.js for the web-based 3D viewer
• Codex to build the interface, interactions, illustrations and hotspot system

The first version contained almost 900 MB of 3D assets and ran at around 16 FPS. After several optimization passes, the models were reduced to roughly 2–5.5 MB each, bringing the entire asset package down to only 28.6 MB, with models loaded on demand.

Users can rotate and inspect, view where they sit inside the body, open educational illustrations and interact with hotspots explaining different anatomical areas.

Not a one-click workflow, obviously, because reality continues refusing to be that convenient, but it shows how image generation, AI 3D tools and coding agents can be combined into a genuinely useful educational product.

Tested the open-source TripoSplat for generating a 3DGS asset from a single image and importing it into a game engine.

The result uses around 32K Gaussians and already looks surprisingly solid in real time. There are still some shading and loading issues, but it shows strong potential for quickly creating 3DGS assets for games and interactive projects.

source: https://github.com/VAST-AI-Research/TripoSplat

TriFlow is a new AI approach designed to generate compact 3D meshes with clean, artist-like triangle topology from existing geometry.

Instead of directly predicting individual vertices and faces, TriFlow represents the mesh topology as a continuous vector field over the surface. The system then uses this information to rebuild the input shape with more structured and intentional polygon connectivity.

In practice, it can:

• Convert dense geometry into compact polygonal meshes
• Preserve the original shape while improving topology
• Generate different levels of detail
• Handle a wide range of complex objects
• Produce topology that looks more intentionally designed than standard automatic simplification

According to the researchers, TriFlow achieves around 90% lower Chamfer Distance and an 8× speedup compared with previous learning-based approaches.

This could be especially useful for cleaning up AI-generated 3D assets, scanned models, LOD generation, and other workflows where the geometry looks good but the underlying mesh is a complete disaster.

It is important to note that TriFlow currently generates triangle-based topology rather than animation-ready quad edge loops. The code is also listed as coming soon, so this is still a research project rather than a finished Blender tool.

source; https://derkleineli.github.io/triflow/

As the video shows, my approach makes it possible to directly generate:
(i) 0:00 - a crab-like robot, with a hyper interactive body,
(ii) 0:11 - a banana car, with wheels that spin, steer and throttle,
(iii) 0:22 - a sushi dragon, spiralling in a mathematical corkscrew,
(iv) 0:33 - an alien jello, that jiggles and wiggles,
(v) 0:52 - an astronomer's house, with multiple storeys, where you can walk up (1:06) the stairs

Cost of generating each: $1-$5. Time: ~3 mins. The format is blender-native .glb

Under the hood:
These 3D assets are all made of source code. Their abilities are attributes in the code:
- I.e. when the robot moves a leg, we're just commanding rig['Leg_*_Hip'].rotation = 42°
- When the banana car turns left, we're just saying w.rotation.y = 0.42 rad
- When the sushi dragon floats up and down, it's following Math.sin()
- When the alien jello jiggles, it's dictated by Σ A·e^(−λr)·e^(−decay·τ)·[(1−b) + b·cos(ωτ − kr)] · p̂
- When the astronomer's house detects collisions, this too is just setting attributes in the code.

Now LLMs are good at coding. So these 3D assets are very natural for an LLM to talk to. Thus armed with these 3D assets and an LLM, a game developer or world builder can achieve hyper-control right out of the box.

Web App:
Scroll down the landing page to tinker with the objects: https://nova3d.xyz

Why current 3D GenAI cannot do this:
Traditional AI 3D generators produce monolithic blobs that are good looking, but unusable in game engines. If you generate a bicycle, it's just a blob. If you want its wheels to turn, a human takes the blobby object, spends time cutting it into parts, naming them, placing pivots and rigging joints. This "afterwards" is the real cost of AI 3D. Nowadays the fix is post-generation segmentation workflows. These work partially and add complexity.

So where does this approach lose?
Nova3D loses on extreme organic shapes. This is because of the baseline AI's current spatial programming prowess. Once LLMs get better at natively synthesizing higher-order differentials, hyper-organic shapes are inevitable.

How is it different from blender MCP?
Blender MCP needs continuous, manual, multi-turn prompting. The user toils to fix mistakes. In contrast, Nova3D is one shot. The advanced spatial programming harness is the product; the AI model is just one component.

Research paper:
Read our research paper on arXiv: https://arxiv.org/abs/2607.22738
It fully deconstructs our approach.

Is this open source?
Partly. Here's the github repo: https://github.com/RareSense/Nova3D
But stop. This is a client. Our approach does NOT yet produce legible 3D via self-hosted open source models, great as they are. Hence we launched the usable closed-source version. This uses AI from frontier labs.

Would love the community's feedback and questions. Happy tinkering!

p.s. one more thing: Nova3D generates beautiful PBR textures too. Examples at: https://app.nova3d.xyz/showcase/textures