I wanted to see how fast I could go from a single character image to something I could actually run around with in Unity.

For the character, I used 3DAIStudio Flow. It’s basically a ComfyUI-style node workflow where I can use image generators and the major 3D AI generators in the same graph, which made this kind of multi-part workflow pretty convenient.

Instead of trying to generate the whole character as one mesh, I split the reference into separate parts:

• Hair
• Body
• Clothes
• Shoes

I generated each part separately with Rodin Gen 2.5 using Smart Low Poly, then moved everything into Substance Painter to fix and clean up the textures.

After that:

• Assembled and cleaned the character in Blender
• Rigged it with Mixamo
• Brought it into Unity
• Used the Third Person Template
• Retargeted the character to the controller animations
• Added running, jumping and basic playable movement

I also generated the environment through the same node-based workflow, although I’ll probably make a separate breakdown for that because the environment pipeline deserves its own post.

I also used an AI agent connected to Unity for some of the setup and repetitive work inside the project.

So after roughly one day, I had a small playable scene with an AI-generated character, generated environment, textures, rig, animations and basic gameplay.

Guide: https://www.youtube.com/watch?v=mmpLXA-xzrQ

For the 3D generation, I used 3DAIStudio with Rodin Gen 2.5. Instead of generating the whole character as one mesh, I generated the main parts separately so I had more control over the final result.

Workflow:

• Concept / References
Started by iterating on the character design with AI and generating clean references for the different parts.

• 3D Generation — 3DAIStudio + Rodin Gen 2.5
Generated the head, body, hands and accessories separately inside 3D AI Studio, using Rodin Gen 2.5.

I used its lower-poly / Smart Mesh workflow where possible to get cleaner topology while still preserving smaller details.

• Blender Cleanup
Brought everything into Blender, assembled the character and manually fixed geometry where needed.

Some shapes were adjusted in Edit Mode and Sculpt Mode rather than trying to regenerate the entire asset because one tiny thing was wrong. Revolutionary concept, apparently.

• UVs + Textures
Did a manual UV pass and cleaned up the generated textures.

For areas that were blurry or had artifacts, I used AI texture patching instead of rebuilding the whole texture manually.

• Rigging
Used Mixamo / AccuRig as a starting point, then fixed skin weights manually in Blender.

I also added spring/physics bones to things like the hair and clothing, plus colliders to reduce clipping.

• VRM + Anime Shading
Converted the finished character to VRM using the free Blender VRM add-on.

Then switched the materials to MToon, added outlines/cel shading and created facial expressions / blendshapes with FaceIt.

• AI Assistant Integration
Tested the avatar in VSeeFace, then connected the VRM character to Project Airy, which can connect the character to LLMs such as OpenAI, Claude or local models.

The final result is basically an interactive anime character that can sit as a transparent desktop overlay, talk with you and react using the finished 3D avatar.

Project AIRI (open source): https://github.com/moeru-ai/airi

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 🥇

wanted to see how far I could get without sculpting the character from scratch. I made the original reference image in ChatGPT, ran it through a 3D AI generator, then cleaned the mesh up in Blender. mostly fixed the non-manifold areas, thickened the fingers and thinner cloth parts, and adjusted the pose so it would actually print.

printed it on a Bambu Lab A1 mini with a 0.2 mm nozzle, 0.08 mm layers and marble PLA. removing the supports around the hands and clothing was a pain, and the surface still needs some cleanup, but I’m honestly surprised by how much detail survived at this size.

probably going to sand, prime and paint it next. pretty fun workflow for turning a random concept into something physical.

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.