Facial tattoos, unusual proportions, a face that doesn't look like any preset. She started as a single AI image, and by the end of the day she was talking through an iPhone Live Link in Unreal Engine 5.8.

The workflow runs on three things: Hyper3D Rodin Gen 2.5 for high-detail generated parts, Blender for assembly and baking, and MetaHuman 5.8, which can now conform an entire body to a custom mesh instead of only a head.

Highlights:

• Parts, not one mesh: head, body and clothing are generated separately and assembled in Blender sculpt mode against a free human conform mesh from Fab, used only as a size reference
• Auto Solve: MetaHuman Creator takes the assembled GLB as a custom mesh and wraps its own topology around it, keeping the facial rig, skeleton and animation support. Fingers needed a fix only on four-fingered characters
• Baked skin: the MetaHuman's DNA mesh goes back to Blender, UDIM UVs get split into plain squares, and the generated skin color with the tattoos is baked onto it in Cycles. Eyes are set in MetaHuman itself
• Clothes without weight painting: garments are aligned in sculpt mode, remeshed, then get weights from the body mesh through a Data Transfer modifier instead of automatic weights. Earrings get 100% to the ear bone
• Free mocap check: UE 5.8's markerless mocap plugin from Fab plus iPhone Live Link for the face

Image-to-3D generation often turns logos, text, and small details into a blurry mess. The new “Pixel Match” feature in image-to-3dlab tackles this by projecting pixels from the original image back onto the model, helping preserve those details after retopology.

The example takes a robot from roughly 966K faces down to 5K while keeping the chest logo readable.

• Preserves source-image details in the texture.
• Produces low-poly models that can be rigged and animated.
• Runs locally on Mac or NVIDIA hardware.
• Free, with no API or cloud required.

A useful update for getting recognizable details onto lightweight assets without repainting everything by hand.

GIthub; https://github.com/Bingeljell/image-to-3dlab

By far the most INSANE result I've ever seen from an LLM. Almost better than actual Minecraft... But in my browser.

Prompt: Create a playable version of Minecraft in my browser. Add advanced shaders that make it look as real and beautiful as possible.

Time: 1h, 37m.
Effort: Max

How did I do it?

1. Prepare the images or videos that represent the look you want to achieve. Create a separate folder for them, for example: Game/Ref.

2. Connect Godot MCP and Blender MCP to Codex.

3. Let Astra read the files inside the Ref. folder so it can understand the overall visual direction and style you want.

4. If possible, install the Dream-loop skill. It can help the AI work more effectively and make your game visuals match the references more closely

Volumetric Motion Rigging (VMR) is a new workflow for recovering 3D character motion from video-reconstructed meshes and transferring it onto a consistent animated character.

This could be useful for game development, animation, VFX, mocap workflows, and turning real-world performances into editable 3D assets.

Some of the interesting capabilities:

• Video → animated 3D character
• Works with 3D meshes reconstructed from individual video frames
• Preserves character shape and surface details across the animation
• Handles difficult areas like hands, wrists, clothing and object contact
• Demonstrated using TRELLIS.2-generated 3D references
• Produces a playable animation directly in Blender
• Can export the full animation as FBX
• The provided FBX was successfully validated in Unity
• Their demo reconstructs a complete 52-frame baseball swing at 30 FPS

Right now the animation is stored as baked mesh poses / blend shapes rather than a standard humanoid game rig, but the idea of going from video → reconstructed 3D → animated character → Blender/Unity is pretty interesting.

paper; https://discosea.com/research/vmr3d

This dragon started from a single image. I specifically picked something with a lot of small spikes, layered surfaces, and an irregular rocky base because I wanted to see how much of that detail would actually survive all the way to a physical print.

I generated the model with Hi3D 3.0 at 2048³ voxel resolution. The interesting part for me wasn’t just that the model looked detailed in the viewer. A lot of those smaller forms were preserved as actual geometry, so they still showed up after preparing and printing the model.

The generated mesh was also surprisingly usable without much manual cleanup. After generation, I separated the model into parts, adjusted the colors, arranged everything for supports, and sent it to the printer.

There are still areas I’d clean up manually if this were going into a production pipeline, but for this kind of detailed figurine workflow, the starting point is getting pretty ridiculous.

From the original image to a prepared model ready for printing took me under 30 minutes.

Image-to-3D is starting to feel less like a rough concept generator and more like something you can actually use in a real workflow.

Both Trellis.2 and Pixal3D can now run natively inside ComfyUI.

No custom nodes, no compiled CUDA extensions, no PyTorch downgrades, and no non-commercial dependencies.

This update is bigger than just adding two new models. ComfyUI also introduced a rebuilt 3D pipeline with new Load / Preview / Save 3D nodes, mesh post-processing tools, and an expanded PBR texturing workflow.

Trellis.2

Trellis.2 is still one of the strongest open-source image-to-3D models available. It uses a 4B parameter architecture with its O-Voxel representation and can generate detailed 3D assets from a single image at effective resolutions up to 1536³.

It also supports more complex topology, including open surfaces, non-manifold geometry, and enclosed volumes, while generating PBR materials with base color, roughness, and metallic maps.

Pixal3D

Pixal3D builds on top of the Trellis.2 backbone but focuses heavily on pixel-aligned 3D generation.

Instead of loosely interpreting the reference, it tries to align the generated geometry directly with the input image, which can give much stronger reconstruction fidelity.

The biggest improvement is probably the workflow itself

Previously, getting Trellis.2 running inside ComfyUI could be pretty annoying because of specific PyTorch/CUDA versions and compiled extensions.

Now both models run as native ComfyUI nodes using the existing environment.

The update also adds native mesh tools for:

• remeshing
• decimation
• smoothing normals
• filling holes
• merging meshes
• mesh painting and rendering

There is also a more complete PBR pipeline. Alongside base color, roughness, and metallic, ComfyUI can now generate normal and ambient occlusion maps, baked from the high-poly mesh.

The closed models like Hunyuan3D, Tripo, and Rodin can still produce better raw quality in many cases, but having this entire pipeline open, local, free per generation, and commercially usable makes Trellis.2 + Pixal3D much more interesting for experimentation and real 3D workflows.

You just need ComfyUI 0.34.0+, the model weights, and one of the included workflows.

Github https://github.com/Comfy-Org/workflow_templates/blob/main/templates/3d_pixal3d_trellis2_image_to_model.json

Most AI 3D workflows are still built around humanoid characters. But things get much more interesting when you start making creatures, monsters, quadrupeds, hybrids, or characters with completely non-standard anatomy.

So I built a six-legged Arachne from a single concept image and turned it into a clean, textured, rigged and animated 3D character.

The biggest lesson was: don’t try to generate the entire creature as one mesh.

Instead, I split the reference into logical parts, generated them separately, assembled everything in Blender, retopologized the important pieces, baked the high-poly details, textured the final meshes and then combined humanoid + creature rigs.

The same approach could work for things like:

• centaurs and other hybrids
• spiders and insects
• quadrupeds
• dragons
• multi-armed characters
• monsters with completely custom anatomy

I used Lychee Studio AI for a big part of the workflow. It basically brings image segmentation, part extraction, 3D generation, retopology and texturing tools into one workspace, which makes this kind of modular character workflow surprisingly convenient.

Tripo AI for the low-poly generation, Tripo P2 was probably one of the biggest time savers. Especially for things like the head and hair, it can produce lightweight textured geometry that is already genuinely usable instead of giving you another giant mesh that needs hours of cleanup. For more complex pieces I still preferred generating high-poly first and baking the detail down later.

The creature itself ended up using a hybrid rig: a spider setup for the lower body, humanoid skeleton for the upper body, plus some manual weight painting and procedural IK for the legs.

It’s definitely not a one-click process yet, but this feels much more interesting to me than AI simply generating another static 3D model.

You can actually start designing creatures around the idea you want, rather than around whatever anatomy the AI happens to understand.

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

pretty interesting local 3D character workflow that takes you almost all the way from concept art to a rigged character inside UE5.

The cool part is that most of the pipeline can run locally through ComfyUI, and even a GPU with around 6GB VRAM can handle the lighter quantized models.

Here’s the workflow:

• Generate the character concept in an A/T-pose, then separate important parts like the head, armor, clothing, etc. for better generation quality.
• Generate the meshes with Pixal3D + Trellis 2. Pixal3D seems especially good for organic forms like faces, while Trellis 2 works really well for armor and hard-surface pieces.
• Texture everything locally. You can either use Trellis 2’s basic texturing or a multi-view projection workflow that generates several views and bakes them back onto the mesh.
• Retopologize the meshes. A completely free route is Blender + AutoRemesher. For better automatic topology, QuadRemesher or Tripo can also be used.
• Bake the high-poly textures onto the low-poly meshes, assemble all the character parts in Blender, and export the finished model.
• Auto-rig it with Skin Tokens directly inside ComfyUI. It can generate a UE5-compatible skeleton automatically.
• Import everything into Unreal Engine 5, create the Control Rig, retarget mannequin animations, and the character is basically ready to use.

What I like most here is that these tools are finally starting to connect into an actual end-to-end production workflow, rather than being isolated “image to random 3D blob” demos.

Concept → separated parts → 3D generation → retopo → textures → rig → UE5.

And a surprisingly large part of it can now be done locally and for free.

For prototyping game characters, NPCs, or quickly turning concept art into something you can actually animate, this is getting seriously useful.

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

I saw many test are about assembling scene etc, but it is much more than that. Custom armature added in blender, created control rig and two animations: walk cycle and death animation. And I hate to say that "in just one prompt"

It is not perfect, especially death animation needs much tweaks, but it is extremely impressive

3D Gaussian Splatting is great for creating photorealistic captures, but the result does not contain normal polygon surfaces. That makes it difficult to edit in Blender, use for collisions, import into a traditional game pipeline, or send to a 3D printer.

Splat2Mesh is a new Windows tool that bridges this gap. You can load a 3DGS file in PLY format, adjust the mesh generation settings, and export the reconstructed geometry as OBJ or GLB.

Main features:

• Converts 3D Gaussian Splats into polygon meshes
• Supports PLY input and OBJ/GLB export
• Runs completely locally
• Does not require a GPU
• Adjustable mesh generation parameters
• Works with object captures and large scanned environments
• Output can be edited in Blender or imported into game engines
• Makes 3DGS data usable for 3D printing and simulation

The official examples show it reconstructing complex captures with vegetation, architecture and even thin geometry such as bicycle spokes.

It is important to treat this as mesh reconstruction rather than automatic production-ready retopology. The developers do not promise clean quad topology or a fully optimized game asset, so some cleanup will probably still be required.

Splat2Mesh currently supports Windows 11 and is free for personal and non-commercial use. It is not open source, and commercial use of the software or converted assets requires a separate license.

Still, this looks like a genuinely useful bridge between photorealistic Gaussian Splat captures and traditional editable 3D workflows.

source; https://3dnchu.com/archives/splat2mesh/

Most image-to-3D models generate one object or a single merged scene. Lumera takes a different approach: it reconstructs an entire image as an engine-native 3D world with separate objects, individual meshes, editable lights and an HDR environment.

The generated scene can be loaded into Blender or Unreal Engine 5, where its components remain selectable and editable.

Key features:

• Reconstructs complete indoor and outdoor scenes from one image
• Detects individual objects and estimates their 3D position, scale and rotation
• Generates a separate mesh for each foreground object
• Reconstructs parametric lights with position, color and intensity
• Estimates an HDR environment for global illumination
• Preserves scene structure for further editing in Blender and UE5
• Uses a bounded AI agent to refine object transforms and lighting
• Includes a UE5-to-Blender adapter for transferring physical light parameters

The team also created Lumera-2K, a dataset built from 2,513 UE5 projects containing 63 million object instances, 102,600 parametric lights and 95,100 camera views.

This is closer to automatic level reconstruction than regular image-to-3D generation. You get an assembled scene that can be rearranged, relit and edited rather than a flattened mesh or baked render.

The project is currently a research release. The code and Lumera-2K dataset are marked as “coming soon.”

Project page; https://haidilao0328.github.io/Lumera/

I had a goal: build a reusable node-based workflow, similar to ComfyUI, where I can drop in a single image and get a 3D printing-ready model on output that can be printed right away.

So I went into 3DAIStudio and used its new Flow feature.

Flow is a node-based system where you can build generation pipelines, and in this case I used the AI agent to build most of the workflow for me.

I gave the agent a simple task: create a pipeline that takes one rough image of a character and turns it into a clean printable 3D model with a base, exported directly as STL.

The workflow it built ended up looking roughly like this:

• upload one input image
• clean the image
• remove unnecessary background elements
• place the subject on a white background
• center the character
• generate a base / stand
• create multiple views of the character:
  • front
  • left
  • right
  • back
• pass those views into the Image-to-3D node
• generate the final mesh with Hi3D 3.0
• export the result as STL

For the 3D generation part, I used Hi3D 3.0, which is very well suited for 3D printing workflows and gave a very clean result.

The final mesh came out with:

• 0 non-manifold edges
• 0 bad contiguous edges
• 0 intersect faces

Hi3D recently released 3.0, a new 3D generation model focused heavily on 3D printing. It supports up to 2048³ voxel resolution, which gives it extremely detailed geometry and, more importantly for this workflow, very clean printable output. That’s exactly why I chose it for this pipeline.

So this was not just a visual result. The output geometry was actually clean enough that I didn’t need to spend extra time manually fixing the mesh before printing.

What I liked most is that the workflow is reusable. Once the pipeline is built, I can just load another image into the first node and run the same process again.

So the full pipeline became:

1 image → cleanup → multi-view generation → Hi3D 3.0 → printable 3D model with base → STL output

That makes it a very practical setup for quickly turning character images into printable models without rebuilding the whole process every time.

AutoRemesher is a free and open-source automatic quad remeshing tool for turning dense meshes into cleaner quad-based topology. It’s cross-platform, MIT licensed, and has been getting some pretty solid updates lately.

What changed in 1.2.0:

• Reduced triangles and irregular vertices during quad extraction
• Added touchpad pinch and scroll zooming
• Fixed parameterization for very small models
• Fixed repeated filenames in the Windows release ZIP

The quad extraction improvement is probably the main one here, especially if you’re using it for automatic retopology rather than just mesh cleanup.

github: https://github.com/huxingyi/autoremesher/releases

I ran the same reference through Hi3D 3.0, Tripo 3.1 and Rodin Gen-2.5 to compare not just geometry, but texture quality and UV unwraps.

Test conditions:

• Hi3D 3.0: Ultra Resolution / 2048³ voxels
• Rodin Gen-2.5: Extreme High
• Tripo 3.1: maximum geometry quality
• 4K textures on all three
• Same reference for every generation

A few things I noticed:

Hi3D 3.0

• Color reproduction is very close to the original reference.
• Details stay fairly sharp even when zooming in.
• Hard-to-see areas like under the arms and lower parts of the model are textured surprisingly well, without much smearing.
• UV islands are relatively large and the seams mostly follow logical parts of the model.
• Output includes Base Color + packed ORM.

Tripo 3.1

• The UV layout uses the smallest islands out of the three.
• There are a lot of separate islands and they are scattered pretty randomly across the texture space.
• The atlas itself doesn't feel particularly organized around logical model parts.
• Output includes Base Color, Normal, Metallic/Roughness ORM.

Rodin Gen-2.5

• UV islands are fairly large, but the seams are less logical and sometimes cut through seemingly random areas.
• Base Color comes out noticeably brighter, almost like some daylight/lighting information was baked into it, even though I didn't use a daylight setup.
• At close range some texture detail starts getting softer.
• Hidden areas, especially underneath the arms and on lower surfaces, can have blurred gradients or strange patches.
• Output includes Base Color, Normal and packed Metallic/Roughness ORM.

So this wasn't really a geometry comparison. I wanted to see what actually comes out of these generators once you start looking at the 4K textures, UV seams, island structure and less visible parts of the model rather than just the front render.

Top3D.ai is a free tool where you can compare all major AI 3D generators side by side across 100+ prompts, including Classic, Low Poly and Segmentation tests.

AI 3D pricing is more confusing than it looks. “1,000 credits” or “100 models/month” doesn't really tell you how much it costs to get a usable final asset.

So I compared the current pricing of:

• Tripo 3.1 + Smart Mesh
• Meshy 7
• Rodin Gen-2.5
• Hi3D 3.0

I’m using the regular monthly plans around $20/month, without annual discounts or temporary promos. Rodin is the exception at $30/month.

Important!

This is NOT a quality ranking. I’m only comparing pricing: generation cost, credits, retries/redos and how much you can realistically generate for your subscription.

Quick overview

Generator	Plan	Credits	Concurrent	Retries / Redos
Tripo Pro	$19.90	3,000	10	Up to 5 attempts
Meshy Pro	$20	1,000	10	4 free retries
Hi3D Pro	$19.90	1,000	10	6 free retries
Rodin Creator	$30	30	3	Up to 5 variants + 20 geometry / 6 material redos

Tripo 3.1 — Best for volume

$19.90 = 3,000 credits, or about $0.0066 per credit.

A high-end Tripo 3.1 generation can cost around 65 credits = ~$0.43.

For a more production-oriented workflow:

• Smart Mesh: ~65 credits
• High-end texture: +30 credits
• Total: ~95 credits

That works out to roughly $0.63 for a Smart Mesh + textured asset.

You also get up to 5 attempts, so Tripo is extremely strong if you generate a lot.

Cost: ~$0.43–$0.63
Main advantage: huge 3,000-credit monthly pool.

Meshy 7 — Simple and predictable

$20 = 1,000 credits, so each credit costs $0.02.

Typical costs:

• Geometry: 20 credits = $0.40
• Geometry + texture: 30 credits = $0.60
• Smart Topology + texture: ~15 credits = $0.30

Meshy Pro also gives 4 free retries, meaning one paid generation can give you up to 5 attempts total.

So while a textured model costs $0.60 upfront, you have several chances to get the result you want without paying another 30 credits.

Cost: ~$0.40–$0.60
Main advantage: straightforward pricing + 4 free retries.

Rodin Gen-2.5 — Best refinement value

Rodin is a little different.

Creator costs $30/month and gives 30 credits.

Standard effort levels from Low to High cost:

0.5 credit = $0.50

But one session can generate up to 5 initial variants.

Extreme High costs:

1 credit = $1

and gives up to 3 initial variants.

The really interesting part is what happens after generation.

Creator also includes:

• 20 Geometry Redos
• 6 Material Redos
• Smart Low-Poly
• Multi-Image to 3D
• HD/custom textures
• Baked normals

So instead of constantly paying for new random generations, you can pick the best initial model and keep refining it.

That makes the standard $0.50 generation feel more like a generation + refinement session than a single model purchase.

Standard: $0.50, up to 5 variants
Extreme High: $1, up to 3 variants
Main advantage: 20 geometry + 6 material redos after generation.

Hi3D 3.0 — Most expensive at maximum quality

Hi3D Pro is $19.90 for 1,000 credits, almost exactly $0.02 per credit.

But Hi3D 3.0 uses significantly more credits than the others.

Quality

• Geometry: 90
• Texture: 10
• PBR: 5
• Total: 105 credits = ~$2.09

That gives you roughly 9 full Quality generations/month.

Master

• Geometry: 440
• Texture: 10
• PBR: 5
• Total: 455 credits = ~$9.05

So the whole $20 subscription is enough for only about 2 full Master generations.

The upside is that Hi3D Pro gives 6 free retries, or up to 7 attempts total per paid task.

Quality: ~$2.09
Master: ~$9.05
Main advantage: 6 free retries and very high-resolution generation.

Final cost comparison

Workflow	Approx. cost
Tripo 3.1 high-end	~$0.43
Tripo Smart Mesh + texture	~$0.63
Meshy 7 textured	~$0.60
Meshy Smart Topology + texture	~$0.30
Rodin Gen-2.5 Standard	$0.50
Rodin Extreme High	$1.00
Hi3D 3.0 Quality	~$2.09
Hi3D 3.0 Master	~$9.05

But retries matter too

Generator	What one paid task can give you
Tripo	Up to 5 attempts
Meshy	Initial + 4 free retries
Hi3D	Initial + 6 free retries
Rodin	Up to 5 variants + 20 geometry + 6 material redos

This is why I think “cost per generation” alone is a pretty bad metric.

What matters more is how much you spend before you actually reach a model you're happy with.

My pricing/value ranking

1. Rodin Gen-2.5 — The $30 plan costs more upfront, but $0.50 for up to 5 initial variants plus 20 geometry and 6 material redos gives you a lot of room to actually finish one asset without constantly paying again.

2. Tripo 3.1 — Probably the best option for pure volume. 3,000 credits for ~$20 and cheap Smart Mesh workflows are very hard to beat.

3. Hi3D 3.0 — Much more expensive, especially Master, but 6 free retries make the pricing less painful if you specifically need its highest-end modes.

4. Meshy 7 — Still a solid all-in-one option, but purely from a pricing/value perspective, Rodin offers more refinement, Tripo offers far more volume, and Hi3D offers a more distinct high-end option.

For pricing/value only: Rodin Gen-2.5 > Tripo 3.1 > Hi3D 3.0 > Meshy 7.

Top3D.ai — a free side-by-side comparison tool where you can compare the major AI 3D generators across overall quality, geometry/polycount, segmentation, generation cost, and generation time, tested across 100+ prompts.

Tested Rodin Smart Low Poly mode on a very dense AI-generated mesh and the result was honestly impressive.

It took a model with around 2 million polygons and reduced it to roughly 5,000 faces, while still keeping the overall shape readable and usable.

What makes it even more interesting is that this is not just about geometry reduction. You can also keep a pretty rich material setup around it:

• ~2,000,000 polygons → ~5,000 faces
• AI retopology / Smart Low Poly
• Clean, lightweight mesh
• Main silhouette and forms preserved
• PBR textures up to 12K
• Emissive maps supported too
• Much more practical for real-time / game-ready workflows

That’s the part that stands out to me most: going from an extremely heavy mesh to something lightweight is already useful, but pairing that with high-resolution PBR textures and emissives makes it feel much closer to an actually usable production asset.

Hi3D V3.0 just reached #1 on both the Textured and Geometry leaderboards in the Top3D.AI Arena, only a few days after its release.

Current results:

• Textured: 1134 ELO — 415 wins / 204 losses — 67.0% win rate
• Geometry: 1188 ELO — 404 wins / 204 losses — 66.4% win rate
• Currently ahead of Tripo 3.1, Meshy 7, Rodin Gen 2.5, Hunyuan 3D 3.1 and the other major models in the respective rankings

What makes this more interesting is how the benchmark works. The same inputs are generated through the official APIs using recommended or maximum quality settings, the first generation is used with no cherry-picking, and users vote on the results in blind head-to-head comparisons. Each vote then updates the live ELO ranking.

Quick recap of what changed in Hi3D V3.0:

• 2048³ voxel-level geometry for much finer details
• Better reconstruction of hidden areas, thin parts and complex structures
• Up to 8K textures with improved UV completion

Hi3D calls V3.0 the first commercially available AI 3D model with 2048³ voxel resolution, and so far the community benchmark results seem to back up the jump in quality.

Top3D.AI is a free tool for comparing AI 3D generators directly side by side on the same tests. You can pick two models and inspect their actual outputs next to each other, so you can compare V3.0 against the other major generators yourself.

I generated a high-detail model with Hi3D V3.0, which uses the first commercially available 2048³ voxel-level 3D generation, and decided to run the raw result through Blender’s 3D Print Toolbox before doing any manual cleanup.

The results genuinely surprised me:

• Non-manifold edges: 0
• Bad contiguous edges: 0
• Intersecting faces: 0
• Shells: 1
• Zero faces: 0
• Zero edges: 0

This is where Hi3D starts to feel less like a normal AI 3D generator and more like one of the first generators that is actually built around 3D printing. The high voxel resolution gives you real geometric detail instead of relying on textures or normal maps, and the clean output can save a lot of the usual manual repair work before printing.

There’s also a full printing workflow built into Hi3D. Split-to-Print can automatically divide larger models into printable parts and seal the cuts, connectors can be generated for assembling those parts afterward, and Smart Arrangement can prepare them for the build plate before sending the result directly into supported slicers.

So instead of:

AI model → hours of cleanup → fixing geometry → manually splitting → slicer

the workflow gets much closer to:

Generate → Split → Arrange → Slice → Print

And right now anyone can try Hi3D V3.0 completely free until 24:00 UTC on August 20, so it’s a pretty good chance to generate a few models and see how the 2048³ output actually holds up for printing.

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/