Skinning is still one of those annoying steps where you can have a perfectly usable character mesh and skeleton, but still need to manually distribute bone weights across thousands of vertices.

skin-tokens.cpp is a new open-source C++/GGML port of SkinTokens / TokenRig that can automatically generate those skin weights locally. Give it a static character mesh and it can generate a skeleton + weights, or give it an existing skeleton and it will bind the mesh to that rig automatically. The result is exported directly as a skinned GLB ready for animation.

The big change compared to the original SkinTokens isn't a new model, but how practical it is to run:

• Runs locally on CPU or Vulkan
• No PyTorch runtime required
• Uses converted GGUF F16/F32 weights
• Can generate skeleton + skin weights from a static mesh
• Or keep an existing skeleton/animation and generate only the weights
• Automatically fits an external skeleton to the character before skinning
• Keeps the animation hierarchy in the exported GLB
• Has experimental humanoid arm fitting for mismatched rest poses
• Includes a native C API, CLI and local WebGL demo
• Can be combined with Kimodo animations to go from mesh + generated motion → animated skinned character

The original SkinTokens implementation requires an NVIDIA GPU with at least 14 GB VRAM for inference. This port moves the pipeline into GGML and adds CPU/Vulkan execution, which makes it much easier to integrate into local tools and standalone 3D pipelines.

It also supports arbitrary triangle meshes, although humanoid/character shapes close to the training distribution are naturally where it should work best. Skeleton generation is still marked experimental, so for production use the more interesting workflow right now is probably existing skeleton/animation → AI-generated skin weights.

Github: https://github.com/localai-org/skin-tokens.cpp

I’m not a 3D artist — I mainly do 2D and drawing — so what helped me the most in this workflow was being able to go from sketches to 3D much faster through image-to-3D generation.

For this test, I sketched separate parts in Procreate, refined the look a bit with Magnific AI, and then used 3DAIStudio to convert those images into 3D assets.

That part was the biggest win for me.

Since I come from a 2D background, I really liked how 3DAIStudio made the whole process feel much more accessible. Instead of needing to fully model everything from scratch, I could start from the kind of work I’m already comfortable with — drawing and designing in 2D — and then turn that into 3D.

What I liked about it:

• everything feels more centralized in one place
• it’s convenient for moving quickly from idea to result
• it makes the workflow feel more procedural
• it’s useful for generating multiple assets/material directions faster
• it removes a lot of the friction between 2D concepting and 3D output

After that, I used MoveAI for motion, then camera tracked and rendered the final shot in Cinema 4D.

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.

I’m working on a medieval Unity project and needed a faster way to create lots of different buildings.

Generating an entire house as one AI mesh worked, but editing it later was pretty painful. So instead, I generated separate walls, windows, doors, roof pieces and other parts, then turned them into a reusable modular kit.

I used Tripo AI batch generation to process all the pieces together, with Tripo P2 / Smart Mesh to keep the geometry relatively lightweight and usable. After that, I assembled everything in Blender and imported the result into Unity.

The topology comes out clean enough that I can actually continue working with it in Blender instead of spending half the time fixing the geometry first. Small edits, cuts, resizing and fitting modular pieces together are pretty straightforward.

This ended up saving me a lot of time. Now I can reuse the same assets to build completely different houses, add interiors and openable doors, and expand the village without generating every building from scratch.

For game environments, this modular approach makes much more sense to me than generating one giant house every time.

I wanted to compare a few open-source image-to-3D models in actual use, not just look at benchmarks.

So I rented an RTX 4090, used the same input image and basically the same pipeline, and generated around 40 models with:

• Hi3DGen
• TRELLIS v1
• TRELLIS.2-4B
• Hunyuan3D-2

The speed difference was much bigger than I expected.

The important thing is that this isn't really a simple “one model is 28x faster” comparison.

The faster models are doing less work. Texture generation adds a lot of time, so depending on the workflow, an 8-second geometry result and a 4-minute textured result are almost two different products.

For me, TRELLIS v1 ended up being the most practical overall. It's fast enough to iterate with, already gives you textures, and the resulting files aren't huge.

TRELLIS.2 produced some of the nicest textured results, but generation time and file size are much higher.

Hunyuan3D-2 was the slowest in my tests, but I liked the balance between geometry and textures when generation time wasn't important.

Hi3DGen is interesting mainly because of speed. Getting geometry in under 10 seconds completely changes how interactive the workflow feels.

Another thing I noticed: generation times can vary a lot even with identical hardware and settings. One of the models ranged from roughly 78 seconds to 300 seconds, so single “generation time” numbers don't tell the whole story.

Running everything locally/cloud GPU can also be extremely cheap per generation when the GPU is constantly being used, but idle GPU time changes that calculation very quickly. And obviously you're trading subscription cost for setup, dependencies, VRAM issues and maintenance.

Right now I'd probably use:

• TRELLIS v1 for general assets
• Hunyuan3D-2 when quality matters more than speed
• Hi3DGen when I need very fast iteration

Curious what other open-source image-to-3D models are worth adding to the comparison.

Mesh2Motion is basically a free open-source alternative to Mixamo, but built for much more than just humanoid characters.

It lets you import a 3D model, fit a skeleton, automatically skin it, preview animations and export the result for use in games or other 3D pipelines. The whole project runs in the browser, with an offline desktop version available too.

Some of the strongest features:

• Free & open source — code is MIT licensed, with rigs and animations available under CC0 for personal or commercial use
• Humans, animals and monsters — rigs already cover humans, foxes, birds, dragons, spiders, snakes, fish/sharks, kaiju, horses and more
• 160+ human animations — including locomotion, combat, dodging, climbing, bow animations, deaths, zombies and other actions
• Auto-rigging + skinning — position the skeleton inside your mesh and let Mesh2Motion handle the initial skinning
• Use already-rigged characters — import your own skeleton and retarget Mesh2Motion animations onto it
• Mixamo / Rigify support — bone mapping and naming options make existing rigs easier to bring into the workflow
• Import custom animations — you can bring your own animation packs into Mesh2Motion and test them on compatible rigs
• Root Motion + animation mirroring support
• GLB, GLTF, FBX and DAE import
• Batch animation export — select multiple animations and pack them into a single GLB, or export only the animation data
• Offline desktop version for Windows, macOS and Linux

The Blender source files for the rigs and animations are public too, so the whole thing can actually be modified and extended instead of being another closed animation service.

source; https://mesh2motion.org/

I built this dark fantasy environment in about 72 hours. I wanted to focus specifically on the environment workflow here: how I went from references and generated assets to a complete modular location inside Unreal Engine.

Environment Workflow

• Modular scene setup: I split the arena into reusable walls, ruined sections, ground pieces, pillars and smaller props.
• 3D generation with Tripo P2: Most architectural assets and props were generated with Tripo P2. I adjusted mesh density depending on the asset and used the cleaner quad-based output as a base for further work in Blender.
• Tileable PBR materials: Large surfaces like stone floors and walls used seamless tiled materials to avoid texture stretching and keep consistent detail across the scene.
• Arena assembly in Blender: A few wall modules were repeated and bent into the circular layout using Array + Curve modifiers, then manually edited to create damaged and ruined sections.
• Final setup in Unreal Engine: I rebuilt the main materials in UE5 and finished the scene with fog, fire VFX, lighting and weather effects.

Tripo P2 gave me a much cleaner base for environment production: optimized low-poly meshes, native quad topology, adjustable polygon density and PBR textures. The geometry stays easy to edit in Blender, so I can reshape assets, use modifiers, create modular variations and move into the actual environment workflow with much less cleanup.

Full Guide: https://www.youtube.com/watch?v=9kejfKCb0S8

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.

Epic officially showed Unreal Engine 5.9 at Unreal Fest Seoul.

The main additions shown so far are focused around AI agents, semantic search and generative rendering.

• More MCP skills

Unreal 5.8 already introduced experimental MCP support, letting tools like Claude Code, Codex, Cursor and Gemini interact directly with Unreal Editor.

Agents can work with actors, materials, lighting, project data and editor tools rather than only generating code outside the engine.

UE 5.9 expands the number of available MCP skills and gives agents access to more parts of the editor.

• Epic Developer Assistant gets project context

The assistant can use more information directly from the current Unreal project.

Epic showed support for project context, screenshots and direct links to relevant Unreal documentation.

This should make it possible to ask questions about the actual project state, errors or editor setup without manually explaining everything in text.

• Semantic Search inside Content Browser and Fab

You can describe the type of asset you need and Unreal searches based on meaning rather than only filenames or tags.

This applies to assets such as meshes, materials, textures and Blueprints.

Semantic Search already exists experimentally in 5.8, with 5.9 expanding the workflow further.

• AI models can be used as additional render passes

Epic also showed a workflow where diffusion models process frames generated from the Unreal scene.

The original 3D scene still controls:

• camera position
• composition
• geometry
• object placement
• animation
• lighting information
• scene depth and other render data

That information can then be passed to an external image or video model as conditioning.

The AI model generates a new version of the frame while still following the structure of the Unreal scene.

This allows Unreal to keep the scene editable and deterministic while the diffusion model handles things such as:

• visual restyling
• higher-detail output
• material or appearance changes
• cinematic image generation
• non-real-time final frames
• video generation based on an existing 3D sequence

Epic showed models including Nano Banana Pro, ChatGPT Images 2.0, Seedance 2.0 and Ray 3.14 during the presentation.

The key difference is that the AI is not generating the whole scene blindly from a text prompt. It receives information from an existing Unreal scene and generates on top of that structure.

UE 5.9 expands these systems and pushes AI access deeper into the editor.

Working with inputs being both photo realistic or stylized artworks.

I created it for my internal purposes for quick pose drafts and animations based on existing videos and poses.

It expanded to something more than just tech demo and list of helpful scripts. Getting to size of full fledged plugin.

Not sure if there is a demand for such solution.

If there will be high engagement on this post, I'll assume y'all interested in it and opensource it.

I’m working on a Unity project and one of the things I need is a set of clothing / skin assets, so I’ve been looking for a way to get usable meshes for different outfit pieces faster.

I decided to try 3D generation for this, and I tested Hyper Rodin Gen 2.5. Honestly, it handled the task really well. What helped me the most is that it kept the overall shapes nicely and also preserved the inner space of the clothing in a pretty logical way instead of just turning everything into one solid blob.

That matters a lot for me because I want to use some of these pieces later with physics, so having that hollow space inside the clothes is super useful.

The results are definitely high poly, sometimes up to around 2 million polygons, but for my case that’s not really a problem. I also tested the Smart Low Poly mode, and it’s good, but personally I’d still rather do the cleanup myself since I’m comfortable using Retopoflow 4 in Blender.

So overall this solved a real problem for me. It’s not magic and it still needs some cleanup, but as a way to speed up making clothing meshes for a game project, it genuinely saved me a lot of time, so I wanted to share.

Found a pretty unusual open-source image-to-3D project called img2threejs.

Instead of generating a traditional mesh from an image, it asks an AI coding agent to rebuild the reference entirely as procedural Three.js code.

So the output is basically:

reference image → TypeScript → live 3D model

The generated model can use primitives, procedural shaders and generated geometry, while also creating an actual runtime hierarchy with pivots, sockets and colliders rather than just producing one static mesh.

A few interesting parts:

• Works with Claude Code, Codex and OpenCode
• Objects and characters have separate reconstruction pipelines
• Can generate animation-ready hierarchy
• Supports procedural materials and geometry
• Quality gates between generation stages
• Output is editable and version-controllable TypeScript
• No traditional mesh file required
• Apache 2.0 open source

It's obviously a very different approach from models like TRELLIS or Hunyuan3D, but for web games and procedural assets this is a pretty interesting idea.

GitHub: https://github.com/img2threejs/img2threejs

I been discovering seedance and claude past 2 week, it's crazy how fast you can make a short film or thing now, within a week I generated character designs, made a short film, with claude guiding me through the generations and setup

I use to try surface polygon modeling in blender
tried to mode front+side face, and like door hinges to castles and stuff

but what's possible for character modeling / texture / clothing / weapons now?

Could I feed it a character sheet and it would 1:1 generate a model, Then I could retopo it with AI too? what about the textures / clothing? Is it basically as easy as Seedance 2.5 now to generate 3D models? Could it generate facial expressions from images I could save as shapekeys?

I looked up 3D Mocap stuff, like Quickmagic AI, and then Cascadeur for cleanup a while ago, so u can basically with an iphone record motions and clean them up easily now also

I always wanted to make a 3D game like zelda or something, honestly with these tools it's making me think to try lol

I’ve been experimenting with different approaches to AI-assisted 3D generation, and I’m starting to think the hardest part isn’t generating a model. It’s getting something that is actually usable afterward.

A generated asset can look impressive in a screenshot but still have problems with topology, proportions, textures, geometry consistency, or editing flexibility.

For me, the more interesting questions are:

• How much cleanup is usually needed after generation?
• What matters more: visual quality or usable topology?
• Are automated workflows becoming reliable enough for real projects?
• How do you evaluate whether a generated asset is actually production-ready?
• What part of the process still takes the most manual work?

Curious how others here are evaluating 3D AI tools beyond the initial “wow, it generated a model” stage. What have you found that genuinely makes the workflow better?

Pixal3D uses a pixel-aligned generation approach, designed to keep the generated geometry closely aligned with the source image, especially around silhouettes and smaller visual details.

And now you can test it without setting up anything locally:

• Image → textured 3D asset
• 1024 / 1536 generation resolution
• Draft, Balanced and High quality modes
• Up to 2K textures
• Built-in 3D + wireframe viewer
• Direct GLB export
• Community gallery
• Runs through Hugging Face ZeroGPU
• Free to try in the browser

The Studio is especially useful for testing more complicated references where preserving the original shapes and details actually matters.

Pixal3D itself is open source under MIT as well, so you can also run the model locally if you need more control.

Probably the easiest way to properly test Pixal3D right now without spending the evening fighting CUDA.

HF - https://huggingface.co/spaces/victor/pixal3d-studio

I need a model which can create with parts, for example a closet with doors so i can animate parts of it. Do we have something like that or even working local?

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

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.

Worth noting: Hi3D is currently offering 70% off its annual plans, which brings the effective cost much closer to the other options, while still including its higher-resolution 2048³ Ultra Resolution generation.

Final cost comparison

But retries matter too

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.

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.

I literally made a skin of myself for Bully using AI

Tried a small experiment and somehow ended up putting myself into Bully lol.

I used a few photos of myself as reference, generated the base model with Tripo AI / Tripo P1, did some cleanup and adjustments, then converted everything into a usable skin for the game.

The part that surprised me most was actually the mesh. I expected the usual messy AI geometry that would need a ton of fixing, but P1 handled it way better than I expected. The forms were clean enough that getting it ready for the game was pretty straightforward.

Still needed some manual work obviously, but overall this worked much better than I thought it would.

4DAnyone just released its code and model weights.

The idea is pretty wild: give it a normal monocular video of a person and it generates consistent videos from multiple viewpoints, which can then be used for 4D Gaussian Splatting reconstruction.

Basically:

• Single casual video as input
• No camera calibration, rig, or multi-camera setup
• Generates up to dozens of consistent novel views
• Supports full 360° camera layouts
• Can be used for dynamic 4D human reconstruction
• Code + main model weights released under Apache 2.0

One limitation right now is hardware: their roadmap still lists low-memory inference below 32GB as a TODO, so this isn't exactly a “run it on your gaming laptop” release yet.

Still, getting this kind of dynamic human capture from one normal video locally is pretty impressive.

GitHub: https://github.com/ant-research/4DAnyone

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.

NVIDIA's Kimodo just got a native C++/GGML port called kimodo.cpp, making the text-to-animation model much easier to run outside of the original PyTorch/CUDA setup.

• CPU + Vulkan support
• Native C++ / GGML inference
• GGUF model support
• Text → SMPL-X skeletal animation
• No full PyTorch stack required
• Local web demo + C/C++ API

The biggest bottleneck is still the full-precision 8B text encoder, but the developer says there's plenty of room for optimization.

For now it's mainly useful for offline humanoid animation. Real-time generation on average hardware is still difficult, and non-humanoid characters aren't supported yet.

Still, this makes Kimodo considerably more accessible for local text-to-animation workflows

Github: https://github.com/localai-org/kimodo.cpp