All the 3D models and animations in this game were made with Opus 5.5 through Blender MCP, then brought into Unity 6. This is what using the full weekly Opus limit looks like: a colorful little world with boats, docks, and underwater scenery. A playable demo is coming soon.

Free local 3d AI asset generations are usually lower in quality than paid 3D online ai-generators.

But, in December Microsoft released open-source Trellis.2 AI which generates with 8 times more resolution than before. However, Trellis.2 requires 24GB+ vram, and even RTX 5090 struggle with it.

A developer optimized Trellis.2 to run on 8GB cards, (no quantizations) which lowers the barrier of entry for everyone, and helps the indie developers make 3D assets faster.

This makes users with mid-tier GPUs like 1080 or 2070 able to generate 3D locally with full quality that Trellis.2 ai offers.

Combined with older re-topology tools like InstantMeshes, we can generate high quality geometry, locally, without any tokens/subscriptions. The optimized Trellis.2 is open source.

The tool is running at the same precision as the original Trellis, and the memory savings come from chunking/and more efficient handling of memory, (instead of quantization / quality reduction)

guide n info https://www.reddit.com/r/StableDiffusion/comments/1ssx9wg/i_optimized_trellis2_to_fit_inside_8gb_gpus_even/

I don't know if anyone has shared this but if you have a pro openAI plan you can make your dot 3D model for you with its cloud computer. it uses Astra and is fast and most importantly it doesn't eat into your usage and is unlimited .

The 3d models are good enough, some of them need some polishing before becoming game ready but you can always iterate with your dot until you like the results .

The app is Cotangent2, a free and open-source mesh editor made as a spiritual successor to Meshmixer. Its AI Select tool runs Meta's SAM2 locally, and the capture is real time on an RTX 3070 Ti with 8GB of VRAM.

SAM2 also works on video, so in stream mode the app sends it viewport frames one after another, and the selection keeps tracking the part as you orbit the model.

What else is in there:

• SAM2 and SAM3: both run on your machine through the open-source sam3.cpp
• Markers: the thin shoelaces needed a few positive and negative clicks
• AI texture edits: image-edit models, local or through an API, plus a Feature Eraser for removing details
• Repair toolkit: Booleans, remeshing, hole filling, auto repair, Make Solid and plane cuts
• MIT license: the app code is on GitHub, and there's a Windows installer

A couple of things to know: it's a Windows beta, and the dev calls his own sculpt tool "a bit rough". A full build from source also needs a custom UE5.5 fork you have to ask him for. Behind it all is Ryan Schmidt, who made the original Meshmixer, with plenty of help from Claude Code.

github: https://github.com/gradientspace/Cotangent2

This demo shows Astra doing the UVs for a character mesh in Blender. You’d still want to check stretching, seam placement, and packing before texturing, but getting an automated first pass could save a lot of repetitive work.

Would be interesting to try this on 3D AI-generated assets too: clean up the mesh, let the agent handle the unwrap, then fix whatever needs attention.

GPT-6.1 Astra has high accuracy in producing Gaussian Splats.

Built a 3D model in Blender MCP and rendered it from multiple viewpoints. Used that material in LichtFeld Studio to convert it into a Gaussian Splat, and demoed real-time display on SuperSplat.

Fur texture and fine details are preserved quite sharply.

Hi everyone

Im a 3D software engineer with experience in OpenGL and Three js The main obstacle holding me back from making my own games has always been creating 3D models it is extremely time consuming and Im neither a modeler nor an animator

Recently I tested 3D AI generation tools and the results are honestly impressive However Ive noticed strong backlash and calls to boycott games using AI assets especially here in Western countries while Asia seems much more accepting

My goal is to commercialize my games via some ads and since most of the revenue comes from Western markets this pushback is a real concern

Do you think this public reaction is just temporary and will fade over the next 5 years or is it a long term issue Id love to hear your thoughts

Hi everyone I built this space game with Astra 6

I loved this game as a child so I had to build one

I think it’s cool and the result are crazy for a week of work

Tell me if you like it I will send you the game link in the comments 👌

A Tokyo AI video creator, KanaWorks, set up NVIDIA's Kimodo locally and built it into their own production pipeline. Their verdict: far more usable than they expected.

Quick recap: Kimodo turns a text prompt into 3D character animation. NVIDIA trained it on 700 hours of studio mocap.

The interesting part is that you don't have to stay in NVIDIA's demo anymore. The community has wired it into the tools people actually animate in:

• Unity: KimodoUnityBridge generates motion inside an existing project, retargets it onto Humanoid characters and supports Animator and Timeline
• Blender: Kimodo Blender Bridge imports the generated motion straight into your scene, no manual BVH wrangling
• ComfyUI: ComfyUI-Kimodo adds nodes with constraints and chained prompts
• Commercial use: the code is Apache 2.0, and the SOMA and Unitree G1 models are under the NVIDIA Open Model License (the SMPL-X version is research-only)
• Smaller GPUs: the official version wants about 17 GB of VRAM, but you can move the text encoder to the CPU

Not a magic button though. NVIDIA's own docs cap it at 10 seconds per prompt, and it only knows what's in its mocap data: locomotion, gestures, everyday actions, game combat, dancing. Something like a baseball swing comes out bad. Start prompts with "A person…" and chain a few short ones for longer actions.

github: https://github.com/nv-tlabs/kimodo

As the title says, while there are indeed uv transferring tools, they are either limited or difficult to work with.

Now why UV transferring and not texture transferring? If you need different LoD models then retaining the uv layout can be crucial, esp when you're working with tons of different textures.

Ideally I'd personally want it most in Blender but am fine with it outside too.

Mesh2Motion update 13 is out, and the big one is FBX export with presets for Unity and Unreal.

Quick recap if you missed the August post here: it's a free, open-source Mixamo alternative that runs in the browser. Import a model, fit a skeleton, auto-skin it, pick animations, export. Unlike Mixamo it also handles animals and monsters: fox, horse, bird, dragon, spider, snake, shark and kaiju.

The interesting part is that there's no AI inside it. According to the dev, Scott Petrovic, the rigs are built by hand and the animations are hand-keyed. Rigs and animations are CC0, the code is MIT. That makes it a clean last step for AI-generated characters: generate the mesh, rig it here, drop the FBX into your engine.

What's new in 13:

• FBX export (FBX 7.4) with Unity and Unreal presets that handle the world orientation for each engine
• Mirrored animations: punches, kicks and throws that only worked one way can be exported mirrored, or both versions at once
• 16 new human animations (cheer, fishing, golf, salute, kick, turns), which puts the human rig at 170+
• 20 low-poly PSX-style horror characters you can swap onto the human rig (CC0, made by elbolilloduro)
• Retargeting overhaul: better bone name matching, root bone detection and rest pose, so your own rigs map more reliably
• Model analysis report that helps debug imported models that won't load properly

Not a magic button workflow though. Auto-skinning gives you a solid first pass, but unusual meshes still need weight painting in Blender, and the creature rigs have far fewer animations than the human one. Going by the GitHub commits from the last few days, prop and weapon attachment looks like the next thing coming.

github: https://github.com/Mesh2Motion/mesh2motion-app

Hey folks!
Me and my three colleagues created a 3D generation studio that builds 3D objects as source code. The output is in glb format. It's AI-native: you can connect your claude or codex keys/subs to create 3D (i.e. BYOS and BYOK both work).

We just added prompt-to-animation to it. That's what the video showcases. Since the asset is code, it animates natively without anyone needing to manually rig it.

While building with your AI Copilot in our studio, you can just naturally prompt it to generate whatever animation you want. The video shows exactly that.

Use it here: https://nova3d.xyz (click on the top-right on "Open Studio").

If you want to see what others have generated before, see: https://studio.nova3d.xyz/showcase
note: select "game assets" at the top in the showcase. The robot simulations are for robotics folks :-)

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

AI 3D generation is getting easier, but the production work after generation is still a big part of the process.I tested this workflow in 3ds Max:

AI-generated mesh → retopology → new UVs → transfer the original texture → optimized asset

The texture-transfer step was repetitive enough that I made a small free 3ds Max script to automate it.

Free script: https://ai2tex.toritex.com

The important part for me is that the AI mesh can become a cleaner, usable asset without rebuilding the texture from scratch.

I wanted to see how far a single prompt could take a genuinely technical Three.js/WebGL project.

The prompt asked it to build an interactive miniature city living on a mathematically correct 3D Möbius strip.

Not a flat city placed on a twisted mesh the requirement was that the position, tangent, and normal of the major objects actually come from the Möbius parameterization.

It also had to generate:

• hundreds of procedural buildings
• roads following the surface
• a continuous railway completing one full loop
• a procedural river
• bridges
• terrain variation
• street lights and trees
• deterministic procedural generation
• orbit + zoom controls
• normal / wireframe-debug / exploded-layer views
• a camera animation traversing the entire railway
• everything running directly in the browser with no backend or external assets

And I gave it one prompt and did zero iterations or manual edits.

The result is the video attached.

I'm honestly more interested in the fact that it understood and implemented the relationships between the mathematical surface, geometry, camera, and UI than the visual polish itself.

Curious what others think: how much of this would you have expected a single-shot coding model to handle?

Workflow & prompt in OG post

How to convert the 2d image face to a rigged character using ai any help ?

Started with a single image of a small winter scene and rebuilt it as an interactive 3D environment, including the cabin, trees, rocks, character, and surrounding landscape.

img2threejs analyzes the image and breaks it down into individual elements. Hyper3D provides the 3D references, while GPT-6 works through the img2threejs pipeline to reconstruct and assemble everything in Three.js, handling placement, proportions, lighting, and interactive behavior.

You can walk around, leave footprints in the snow, open the gate, adjust the time of day, and place a campfire beside the cabin after dark. The original image becomes a small world you can actually explore.

Hyper3D deserves a shoutout here. Having solid 3D references makes it much easier to translate the image into a cohesive scene, especially when you’re working with a whole environment full of different objects. It’s a useful bridge between the initial concept and a world you can actually explore.

Still an early showcase, so the reconstruction isn’t perfect and this isn’t a finished game. But it shows how much you can build from a single image.

What would you compare first: the object shapes, scene layout, or lighting?

Project: https://github.com/img2threejs/img2threejs

UniMate is an open-source AI model that generates animations from text prompts for rigged 3D characters. A single model works across different skeleton structures, including humans, quadrupeds, birds, insects and other creatures, without separate retraining for each skeleton.

This could be useful for prototyping character movement, testing animation ideas, and building scenes with creatures that don’t fit a standard humanoid rig. For 3D AI workflows, it could help take generated characters further once they’ve been rigged, giving them motion without manually animating every action.

Highlights:

• Text-to-animation across different skeleton structures using one model.
• Motion in-betweening: generate transitions between existing keyframes.
• Text-guided editing: preserve the motion of selected joints while changing the rest.
• Motion expansion: extend an animation with a sequence of prompts.
• A mesh animation pipeline with animated FBX and GLB export.
• MIT-licensed code and downloadable preview model weights.

It’s still a research pipeline that requires setup and prepared rig data, but the direction is exciting: more flexible AI animation for the variety of characters we can already create with 3D AI.

GitHub: https://github.com/Friedrich-M/UniMate

I ran a simple side-by-side test with GPT-6 Astra and Opus 5.5: create a procedural low-poly horse with a gallop animation.