r/TopologyAI

Finally tried the newer local TRELLIS.2 setup myself, and it works surprisingly well.

What I liked most is that the whole process now feels much closer to an actual usable local 3D tool rather than a research repo you need to fight for an evening.

• Image → full 3D mesh locally
• PBR materials included
• Around 12GB VRAM in this test
• Mesh preview directly in the interface
• GLB export
• Mesh cleanup / lower-poly options
• Experimental quad remeshing and normal baking

The geometry is still not something I'd blindly throw into production, but as a free local image-to-3D generator, this is already really capable.

The interface also makes a huge difference. Drop in an image, generate, inspect the mesh and export it without building a huge workflow around it.

Pretty impressed with how usable TRELLIS.2 is becoming.

source: https://github.com/RobertBeckebans/AI_trellis2cpp/

Saw this workflow and thought it was a pretty interesting example of where AI-assisted character creation is right now.

The creator went from basically nothing to a fully rigged and animated character in around 6 hours using:

• ChatGPT / GPT Image for the initial character design and reference views
• Tripo AI to generate the head and body separately
• Smart topology with around 20K polys allocated to each part
• Blender to merge and clean everything up
• Manual skinning / weight painting
• Texture painting to fix the face
• Shape keys for blink, wink, smile and mouth open
• Some basic jiggle physics

Author said roughly 80% of the work was still manual Blender work, especially rigging and weight painting.

One part that seems to have saved a lot of time here was Tripo AI P2 Smart Mesh. The generated head and body came out with a much cleaner and more usable mesh than you usually expect from AI generation, so there was less time spent fighting the geometry before moving into Blender. The topology was easy enough to edit, clean up and continue working with, which made it much faster to get from generation to an actually usable character.

There are still some obvious problems too. UVs and textures can be messy, close-up quality isn't really there yet, and generated meshes still need cleanup.

post https://x.com/Dstudio_ai/status/2089209243207680484

wanted to make a low poly environment for Unity as fast as possible, starting from just one reference image that already had most of the buildings and scene elements I wanted.

So I went into 3DAIStudio Flow, used the AI agent, and gave it a very simple prompt: take this image, identify the buildings and environment assets in it, separate them, and generate them in 3D. In about 3 minutes, it built a full node-based workflow for me, kind of like ComfyUI, and from that single image I ended up with a full asset kit.

For the generation part, I also used Tripo P1, and honestly the low poly output was one of the best parts of the workflow. The meshes came out lightweight, readable, and actually practical for building a game scene quickly instead of spending forever cleaning dense geometry.

Workflow:

• Reference: one image with the full environment
• 3D AI Studio Flow: gave the AI agent a simple prompt to detect and separate all the assets
• Node workflow: in about 3 minutes, it built a ComfyUI-like workflow automatically
• 3D generation: used Tripo P1 for the low poly assets
• Blender: exported everything, assembled the scene, adjusted placement, and made a few things manually like the fence with an Array modifier
• Unity: imported the finished environment and materials

After that, I exported the assets, assembled everything in Blender, placed the scene by hand, and did a bit of quick manual cleanup. Even the fence was easy to finish with a simple array workflow, so putting the whole environment together was pretty straightforward.

Then I brought everything into Unity, and it all worked nicely. The full environment ended up at around 100K faces total, with PBR materials/textures, and the real hands-on time for the whole scene was about 4 hours.

Pretty crazy that this started from one image and turned into a usable Unity-ready environment kit that fast.

Hi3D V3.0 is out, and probably the most interesting part of the release is the jump to 2048³ voxel-level reconstruction.

Hi3D claims this is the first commercially available AI 3D model to reach this resolution. Previous Hi3D models topped out at 1536³, so the main improvement here isn't just higher-poly output, but preserving much smaller details directly in the geometry: engravings, wrinkles, thin parts, sharp edges and small mechanical forms.

They've also upgraded a few other areas that matter quite a bit for image-to-3D:

• 2048³ geometry reconstruction
• Better handling of hidden/back-side geometry and complex structures
• Up to 8K textures
• Improved UV completion
• PBR materials
• More focus on print-ready geometry and complex thin structures

I've been looking at some of the comparison examples against Meshy, Rodin and Tripo, and the geometry detail is probably the part I'm most interested in testing properly.

At this point AI 3D generators are already pretty good at making something that looks convincing from a distance. I'm much more interested in whether these higher-resolution models actually preserve details when you remove the textures, zoom into the raw mesh, and try to use the result for printing or further 3D work.

I'll probably run some identical inputs through V3.0 and a few other generators to see how much of the 2048³ advantage actually survives into the final mesh.

Hi3D just released V3.0, with the update mainly focused on pushing geometry, structure and texture fidelity further.

What’s new:

• 2048³ high-precision 3D representation for better preservation of wrinkles, engravings, thin parts and other small geometry details
• Better structural consistency, especially for occluded areas and complex shapes that need to be reconstructed from a single image
• Up to 8K textures with improved UV completion for cleaner hidden areas and finer surface detail
• Two generation modes: Quality — focused on highly detailed individual assets like figurines, sculptures, jewelry and ornamental designs Master — designed for more complex compositions, multi-part sculptures, miniature environments and larger scenes

And right now you can test it yourself for free. From August 19–20, Hi3D V3.0 has a 48-hour free-access period, so you can generate models, test both modes and compare the results with other 3D generators without spending credits.

Top3D.AI — you can already compare Hi3D V3.0 side by side for FREE with all major 3D AI generators across 100 prompts, with three comparison types: Classic, Low Poly, and Segmentation.

This might be one of the craziest examples yet of LLMs being used for actual 3D generation.

There were no imported 3D models, no sculpting, and no texture files.

Instead, Claude Opus 5 generated the geometry itself through code. Every visible surface in the scene was procedurally created by the LLM.

• Zero imported 3D assets
• Zero manual sculpting
• Geometry generated entirely through code
• Around 17.7 billion triangles evaluated every frame
• 2,978 frames rendered at 4K
• 124-second continuous shot with one camera

It apparently even generated the car inside out at one point, which went unnoticed for weeks because the exterior silhouette still looked correct.

It's that an LLM was effectively acting as a procedural 3D modeler, generating complex geometry and assembling an entire scene without relying on a traditional asset pipeline.

We're starting to get surprisingly close to simply describing a 3D scene and letting an LLM build the geometry itself

source: https://x.com/aipulseda1ly/status/2089804529034481700

Tripo P2.0 Preview is finally live, so everyone can test it now.

The biggest change for me is that it can now generate native quad topology while letting you choose the target polycount.

And it doesn't feel like simply taking a dense AI mesh and decimating it afterward. The polygon distribution is much more intentional: simpler surfaces stay simple, while areas that actually need the geometry get more of it.

Another thing I really like is how logically some models are structured. Instead of everything becoming one giant welded blob, separate elements can come out as actual separate parts, which makes editing the result in Blender much less painful.

Main highlights:

• Native quad topology with much cleaner polygon flow
• Logical edge loops around important shapes and details
• Models can be logically separated into individual parts, instead of everything being fused into one mesh
• Custom polycount control, so you can choose how low-poly or detailed the result should be
• Support for both quad and triangle meshes
• Better polygon distribution, with more geometry where detail is needed and fewer polygons on simple surfaces
• The mesh generation itself takes only around 5–10 seconds

Source; https://www.reddit.com/r/Tripo_ai/comments/1vrxppz/we_just_shipped_tripo_p20_preview_it_is_a_major/

Hi everyone,

We've been building LocalMesh for the past few weeks, and the beta just opened.

Short version: one photo goes in, and you get a 3D Gaussian splat (~60s on a 5090, ~2min on a 4060 laptop), then a textured mesh** (UV-unwrapped, photo reprojected, AO, normal map) exported as GLB/PLY/OBJ.

Everything runs locally. No upload, no queue, no credits. Turn off your Wi-Fi, it still works.

The mesh part is the bit we're proud of. Poisson reconstruction on gaussian centers drapes a tarp over your object: a Poisson solver has to close every surface, and can never say "I can see through here".

So instead: 60 virtual cameras on a golden-angle sphere, gsplat renders depth for each, every ray carves out the empty space it travels through, and the 60 depth maps fuse into a 768³ TSDF volume. Carving instead of guessing. (gs2mesh principle, written from scratch.)

Other things you might enjoy:

- It runs on 8 GB cards. The entire conversion (splat rendering, TSDF fusion, decimation, atlas bake) stays under 7.3 GB of VRAM, so a 4060 laptop finishes the exact same job as a 5090, just slower.

- No CUDA toolkit, no Visual Studio, no Python, no admin rights on the client. We ship a fat gsplat wheel with precompiled kernels, RTX 20 to 50.

Limits, upfront: one photo means the back of the object is invented, not measured. Windows + NVIDIA 8 GB only. No Authenticode cert yet, so SmartScreen will grumble on first launch.

7 days free, no card to start, then $39 once, no subscription, because there's no cloud to pay for: https://local-mesh.com

Break it and tell us, that's what the beta is for.

Happy to answer anything about the pipeline in the comments.

Hey everyone,

I just released v1.2.0 of anyCreature, an open-source tool designed to generate creatures natively within your workflow. You just drop the harness into your Agent and start prompting exactly what you want.

Repo link:https://github.com/Ariescar/anyCreature

A star on GitHub would be greatly appreciated! ⭐️
Feedback is welcome as I continue to optimize this harness.

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

Not quite the wizard I had in mind, but honestly… I kind of love it.

Found this pretty useful open-source project: depth-anything.cpp.

It’s a from-scratch C++/ggml port of Depth Anything 3, built around GGUF models and designed to run without Python, PyTorch or a CUDA toolkit during inference.

What makes it more interesting for 3D workflows is that it can get more than just a basic depth map from an image:

• Metric depth
• Per-pixel confidence
• Camera intrinsics + extrinsics
• 3D point cloud
• GLB / COLMAP / PLY export
• Multi-view depth + camera pose

It also supports quantized models. The smallest q4_k version is around 99 MB, and there are CPU, CUDA, Metal and Vulkan backends.

Their CPU benchmarks are especially interesting: the q8_0 build runs about 1.3× faster than the PyTorch version on their Ryzen 9 9950X3D test while using significantly less memory.

I can see this being pretty useful as a lightweight building block for image-to-3D, reconstruction, game-engine tools or local 3D AI pipelines, especially when you don’t want an entire Python environment sitting behind a simple depth estimation step.

GitHub https://github.com/localai-org/depth-anything.cpp

I think Hunyuan PolyGen 1.5 is currently the best free AI retopology tool out there. On one custom test, it took a 1.5 million polygon model and turned it into a mesh with only around 15,000 faces — and the result still held up surprisingly well as a solid first retopo pass. That alone got my attention.

I've been testing quite a few AI retopology tools recently, and what impressed me here isn't just the polygon reduction. A lot of "AI retopology" tools can make a mesh lighter, but the result still looks like an automatic remesh that you immediately want to redo.

With PolyGen 1.5, the topology actually starts to look like a real first retopology pass.

On more complex characters with a mix of organic shapes, clothing, accessories and harder surface details, it does a surprisingly good job of:

• preserving the original silhouette
• keeping important forms instead of smoothing everything away
• creating much cleaner and more readable edge flow
• reducing unnecessary geometry without completely destroying smaller details
• producing a mesh that is much easier to continue cleaning manually in Blender or Maya

And that's probably the most important distinction for me.

I don't expect AI retopology to magically give me a perfect production-ready character with flawless deformation loops every single time. Characters still need inspection, cleanup, proper deformation testing and sometimes manual fixes around joints, the face, fingers, intersecting parts, etc.

But if the AI can take a horrible dense generated mesh and turn it into something that already feels 70–80% of the way toward a usable base, that's genuinely useful.

For static assets and simpler objects, the result can already be surprisingly close to something I'd actually use. For characters, I'd still treat it as a strong starting point rather than the finished mesh.

And considering that this is available as a free option, that's kind of ridiculous compared to where AI retopology was even a year ago.

This is also the part of AI in 3D that makes the most sense to me. I'd much rather see AI automate boring technical work like retopology than try to replace the creative part of modeling.

Right now, Hunyuan PolyGen 1.5 is my #1 free AI retopology option.

I've been experimenting with local 3D AI more lately, and I honestly think TRELLIS 2 + UltraShape 1.0 is one of the strongest free local combinations available right now.

The biggest reason is that the two models solve different parts of the problem.

TRELLIS 2 works as the main image-to-3D generator.

It can generate:

• complex 3D geometry from a single image
• thin and open surfaces
• detailed shapes with fairly complex topology
• full PBR materials
• textured GLB assets that are already easy to move into a normal 3D workflow

But another huge advantage of TRELLIS 2 is the community around it.

There are already several alternative ways to run it locally:

• the original Microsoft implementation
• community C++ / GGML implementations
• GGUF / quantized versions aimed at making local inference more accessible
• CUDA and Vulkan implementations
• multiple ComfyUI nodes and workflows

So you don't necessarily have to use the original heavy Python setup forever.

If you already use ComfyUI for image generation, upscaling, segmentation or other AI workflows, TRELLIS 2 can basically become another node in the same pipeline instead of a completely separate application.

Then you can add UltraShape 1.0 as the geometry refinement stage.

UltraShape takes a reference image together with an existing coarse mesh and focuses specifically on improving the geometry.

That means a practical pipeline can look like:

reference image → TRELLIS 2 → UltraShape geometry refinement → TRELLIS 2 / other tools for PBR

TRELLIS gives you the initial 3D structure quickly.

UltraShape then gets another chance to reconstruct the small forms and geometric details that the first generation missed.

And this is probably the part I like most about the combination: you're not asking a single AI model to somehow solve generation, geometry and materials perfectly in one pass.

You're splitting the workflow into stages and using a model that is good at each stage.

For local generation the advantages are pretty obvious:

• free generation
• no credits or subscriptions
• no API cost per model
• everything can stay on your own machine
• you can iterate as much as your GPU allows
• TRELLIS 2 already has a pretty large community ecosystem
• ComfyUI makes it possible to build much larger automated workflows around it
• UltraShape gives you a dedicated second pass for geometry instead of accepting the first mesh as final

Commercial generators are still much easier if you just want to upload an image and get something back in 30 seconds.

But if we're talking specifically about free + local + customizable 3D AI generation in 2026, TRELLIS 2 + UltraShape is probably the setup I'd start with.

UltraShape:
https://pku-yuangroup.github.io/UltraShape-1.0/

TRELLIS 2:
https://github.com/microsoft/TRELLIS.2

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

language models aren’t limited to generating individual assets or small code snippets anymore. this entire photorealistic, walkable 3D street was built from scratch with Claude.

there was no Blender scene and no library of premade assets. every building, car, road, texture, cloud, light and even the audio is generated through code using Three.js and React Three Fiber.

you can actually open the result in a browser and explore it in first person. the repository also includes the five original prompts and the full source code.

the most interesting part is that this wasn’t made with a specialized text-to-3D model. it was built by a general-purpose language model that knows how to code a 3D environment. in theory, the same workflow could be reproduced with other capable coding LLMs as well.

github: https://github.com/StarKnightt/night-street

feels like we’re getting closer to a point where prompting an LLM for an entire interactive 3D world becomes a normal workflow.

Found this today and thought it was worth sharing.

Someone built an open-source Unreal Engine plugin that integrates TRELLIS 2 directly into the editor, so you can basically go from an image to a generated 3D asset without constantly jumping between different tools.

It supports:

• image → 3D generation with TRELLIS 2
• local or remote generation
• 1K / 2K / 4K settings
• background removal
• seed and generation controls
• generation progress directly inside UE
• automatic download and import of the generated GLB into the scene

The local mode is probably the most interesting part to me. If you already have TRELLIS 2 running locally, this starts looking less like a separate AI toy and more like an actual part of the Unreal workflow.

Still pretty early, but integrations like this are exactly where I think 3D AI becomes genuinely useful.

GitHub: https://github.com/camenduru/TostEngine-trellis2-unrealengine-plugin

I've been experimenting with AI-generated characters lately and wanted to see how far I could push facial expressions while still keeping everything usable with native Unreal Engine tools.

I built the character as 4 separate parts instead of trying to generate everything as one mesh, which gave me much more control over the final result.

For the 3D generation I used 3DAIStudio to generate all of the character parts. What I liked here was being able to switch between different 3D AI generators in one place depending on which model handled a specific part better, rather than constantly jumping between separate platforms. I also generated the reference images directly inside 3DAIStudio, so most of the early concept-to-3D workflow stayed in the same place.

After that I brought everything into Blender, assembled the parts and did the usual manual cleanup and geometry fixes.

One thing that surprised me was baking the high-poly details onto the generated low-poly character. It worked much better than I expected, and the final result ended up at around 34k triangles while still keeping a lot of the original detail.

The facial setup was definitely the harder part.

I created 58 different facial expression references and used them as a guide for building the blendshapes. It still needed a fair amount of manual work, but generating the head with an open mouth helped a lot with preserving details around the mouth, teeth and inner geometry.

Finally, I brought the character into Unreal Engine / UEFN and used Control Rig for the animation setup, so the finished character still works inside a pretty normal Unreal workflow.

Facial animation gets a lot more complicated once you move outside of MetaHumans, so I decided to test a few different ways of getting the same performance onto custom characters.

The interesting part is how differently they handle the same expressions:

• MetaHuman Animator — easily the richest result here. It captures a lot of subtle facial movement from regular video/webcam footage, but by default the resulting animation is designed around the much more complex MetaHuman facial rig.

• ARKit 52 — much more universal. A lot of custom characters can be set up around the standard 52 blendshapes, but you're working with a considerably smaller expression set, so some of the finer facial detail gets lost.

• MHA → ARKit Remap — probably the most interesting middle ground. It takes the MetaHuman Animator performance and converts it into the standard 52 ARKit curves, so you can use the MHA capture on characters that aren't MetaHumans.

In my opinion the remapped version gets surprisingly close considering how much facial data is being compressed into only 52 shapes.

And the nice part: ARKitRemap V3 is completely free and open source.

It runs on UE5.8's native RigMapper system and can work with any character that already has the standard ARKit 52 morph targets:

https://github.com/Dylanyz/ARKitRemap

I think this becomes particularly useful with AI-generated 3D characters.

You can generate a character, keep its original/stylized face, create the ARKit blendshapes for it with something like Faceit, and then use MetaHuman Animator for the actual facial capture instead of trying to force the whole character through a MetaHuman conversion.

This is a pretty cool example of where AI-assisted 3D workflows are heading.

The project is called Empire Atlas, an interactive 3D website where you can explore 8 historical empires, their architecture, maps, interiors, daily life and more.

What makes it interesting to me is how much of the production pipeline was AI-assisted:

• Kimi K3 was used for most of the coding / engineering workflow
• Three.js powers the interactive 3D experience in the browser
• The 3D assets were generated with Tripo AI
• GPT Image 2.0 was used for design / visual generation
• Kimi's image tools were also used to generate dozens of historical images and supporting content
• The original ~500MB of 3D assets were automatically optimized down to around 18MB using mesh simplification, Draco compression and smaller WebP textures
• Everything runs directly in the browser as an interactive 3D experience

This is the part I find more interesting than another isolated AI-generated model.

We're starting to see AI-generated 3D assets actually being used inside complete interactive experiences, with AI also handling a large part of the engineering and optimization around them.

For education especially, I think this kind of thing has a lot of potential.

Instead of just looking at a picture of an ancient city in a textbook, you could actually walk around it, enter buildings and explore reconstructed environments interactively.

Pretty crazy how quickly the gap between “AI generated some assets” and “AI helped build an entire usable 3D product” is shrinking.