u/Certain_Friendship16

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/

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.

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.

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

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

Printed on a Bambu Lab A1 using matte gray PLA at 0.2 mm layer height. Really happy with how the hair, glasses and all the small details came through. 3D Generation Hitem 3D

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

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.

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.

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

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

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 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/

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

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

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/

Someone asked Claude Opus 5 to create the best game graphics it could, using a simple car-on-a-dirt-trail demo as the test.

According to the creator, the first version was generated in one shot, without providing custom textures or finished 3D assets. After a second prompt simply asking the model to improve the quality, the lighting, environment, foliage, terrain and vehicle presentation became noticeably better.

AI can now build custom node-based workflows around your specific needs, helping automate repetitive steps and significantly reduce the time required to produce 3D content.

3DAIStudio recently introduced Flow, a new ComfyUI-style node system designed specifically for AI-powered 3D generation. Instead of switching between separate tools and rebuilding the same process every time, you can connect everything into one reusable pipeline.

You can either build the workflow manually or simply describe what you want, and the AI assistant can generate and connect the nodes for you.

With Flow, you can:

• Build custom node-based workflows for specific 3D tasks
• Generate complete workflows from a simple text request
• Use image generation, prompting, editing, and element extraction
• Convert those objects into separate 3D assets
• Access multiple leading 3D AI generators from one platform
• Test different models without constantly switching between websites
• Add remeshing, texturing, optimization, and other processing steps
• Adjust individual nodes without rebuilding the entire workflow
• Save successful workflows and reuse them with new images
• Export the results for Blender, Unreal Engine, Unity, and other 3D software

For this test, I used one environment image and extracted a complete asset pack containing buildings, benches, street lamps, and other props. The resulting models ranged from roughly 15 to 3,000 polygons per asset, making them lightweight enough for real-time workflows.

Instead of manually repeating the same steps for every asset, you can build the workflow once, adjust it when needed, and use it across different projects. This can significantly speed up the entire AI-to-3D pipeline and make it much easier to manage.