Good geometry still needs good textures. UltraTex is a new AI texturing framework that uses a reference image to generate detailed textures for an existing 3D model, working across six views at 2048×2048 resolution.

The focus is on preserving small surface details that tend to get lost in lower-resolution texturing pipelines, while keeping the generated appearance aligned with the geometry.

A few highlights:

• 2K multi-view generation for sharper texture details.
• Image-guided texturing, using a reference to guide the model’s appearance.
• Albedo generation, plus a separate metallic–roughness prediction branch with the FLUX.2 version.
• Training and inference code released, with downloadable weights.
• A dedicated inference script for AI-generated meshes.

The efficiency trick is pretty straightforward: stop spending so much compute on empty background. UltraTex removes background tokens and reduces unnecessary attention calculations between the remaining tokens.

The authors report 22.3–74.6× faster inference than their dense baseline on tested samples. Those benchmarks use an NVIDIA H200, so they don’t tell us how fast it will run on a regular desktop GPU.

For anyone working with AI-generated assets, this is a project worth testing for the texturing stage.

GitHub: https://github.com/yiboz2001/UltraTex

Take a static 3D character, generate its skeleton and skinning weights, then describe how it should move. Hyper3D has previewed ACT, a SIGGRAPH 2026 research framework that brings these tasks into one pipeline.

The demos cover humanoids, quadrupeds, mechanical objects and arthropods, with support for different skeletal structures.

Here’s what it can do:

• Generate a rig and skinning weights: predict the skeleton and how its bones influence the mesh.
• Edit the rig with text: instructions like “add hair bones” or “add skirt bones” update the skeletal structure, with new joint positions and corresponding skinning weights.
• Generate motion from a description: the examples include a snake moving with its head raised and a T. rex walking forward while opening its mouth.
• Adapt a skeleton template to different body shapes: fit the same skeletal structure to characters with different proportions.

Under the hood, ACT learns skeletal structure and motion together. A vision-language model provides semantic guidance about the character’s structure, while a diffusion transformer models the rig and movement in a shared representation.

For AI-generated 3D assets, this could make the jump from a static mesh to an animated character much easier, especially for creatures with unusual anatomy. Being able to request extra bones and have the skinning updated alongside them is a particularly useful part of the workflow.

Hyper3D says it’s coming to the platform soon. This is a research preview, with the release date and pricing still to be confirmed.

Hyper3D new Agentic Mode, powered by GPT-6.1 Sol, lets you “talk” to your 3D assets and keep refining them after generation.

• Parametric controls: adjust dimensions and proportions, from a building’s roof height to a forklift’s fork length.
• Custom sliders: ask for additional controls in plain language, then use them to fine-tune the model.
• Animation through prompts: describe a movement or gesture, like asking a mechanical hand to hold up three fingers.
• Targeted material edits: request a different material for a specific part, such as walnut wood for the upper kitchen cabinets.
• Multiple references: use images or a design sheet to guide generation, then continue refining the result through text.
• Editable geometry: Hyper3D demonstrates N-gon models aimed at further editing, including buildings and mechanical assets.

Still in beta, but the demos show a useful workflow: generate an asset, ask for changes, adjust its controls, and add movement.

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 always wanted to print a full table for our D&D campaign. The table is 148 x 238 cm, that's a lot of surface to fill. The classic way is months of foam, glue and paint, so I'm running it like a game production instead, with GPT-6 Astra driving.

1. Astra blocked out the whole town in primitives first. Boxes standing in for houses, roads, open squares. We also made a small mood reference so we both knew what the town should feel like. Everything is cheap to move around while it's still a box.

2. Buildings I generate in 3DAIStudio. Image reference for each house first, then the 3D model from it. Getting the picture first matters: a house I don't like dies in seconds instead of after the model is done. I kept switching generators inside it, some houses came out better in Tripo 3.1, some in Hi3D 3.0, it's all in one box there. It also plugs into your agent over MCP. And Meshy 7.1 is landing there soon, promising 4k resolution, will see.

3. We drop the finished models back into the blockout and keep filling until it reads like a town instead of a pile of props. Street widths, where the open space goes, what's tall, what's low.

4. Now the part I'm starting today: cutting every house into floors. Ground floor, upper floor, roof, stacked so they lift off. Roof comes off, you play the top floor. A house that doesn't open is scenery, and I want the party to go inside. The generator only gives me the outside, so every floor gets a floor plate, walls with printable thickness, doorways wide enough for a base, stairs where they make sense.

First batch goes on the printer as I finish cutting. 148 x 238 cm is going to keep that printer running for weeks and I'm fine with that

To be continued...

One prompt, Blender only, all procedural. Render the 10-second shot, and record your own build timelapse.

Opus 5.5: 35 min, 199.6k output tokens, about $13.3 in API terms.
GPT-6 Astra: 28 min, 56.6k output tokens, about $14.5 in API terms.

Feels like a worthy rival, and honestly I am glad about that. From what I watched, Opus juggles way more at once and is faster overall. Astra is still good imo.

3D AI generation has reached a point where it’s becoming genuinely useful, not just something you test for fun.

From modeling an original character to getting a finished dance video for Shorts, the whole process took about two days, which is kind of insane.

The combination of Blender + Tripo AI + GPT-6 Astra makes this workflow even faster and saves a ridiculous amount of manual work. But the important part is knowing what each tool is actually good at instead of expecting one AI to magically do everything.

The workflow was roughly this:

• Separate the head, hair, and body into different parts.
• Also separate anything you plan to give jiggle physics later.
• Use Tripo P2 for the 3D generation. The biggest advantage here is getting relatively clean low-poly geometry, which means much less time spent fixing the mesh afterward.
• Merge and clean up the parts in Blender.
• Rig the character using VRM 1.0. You can also use GPT-6 Astra to help with parts of the rigging and setup.
• Astra then helped build a proper toon shader directly inside Blender using nodes.
• It also helped with the character animation and other smaller technical tasks.

The main takeaway for me is that you need to understand what each tool can and can’t do.

Don’t throw the entire character at one AI and expect a finished result. Split the process into smaller tasks and give each tool the part it handles best.

That’s when these tools actually start saving serious time.

At this point, generating a humanoid character, rigging it and throwing some animations on top isn't really that surprising anymore.

So I wanted to try something less straightforward.

I made this eight-legged spider creature for my game and pushed the workflow all the way from a single concept to a game-ready animated character with proper locomotion.

The workflow was roughly:

• generated the initial creature concept in Lychee Studio AI
• separated it into individual parts instead of trying to generate the whole thing as one mesh
• generated several additional parts with Tripo P2
• assembled and cleaned everything up in Blender
• retopologized and baked the heavier meshes
• created a custom rig for all eight legs
• built the locomotion and procedural leg movement so the feet react properly to the ground

Lychee Studio AI has probably been the most useful tool for this kind of workflow so far. It’s node-based, so I can handle image generation, 3D generation, texturing, cleanup and the rest of the pipeline in one place instead of constantly jumping between different tools. Image generation is especially convenient there because it’s quick to iterate, and having multiple 3D generators in the same workflow makes the whole process much easier to manage.

And surprisingly, it does.

There is still plenty of manual work involved, especially around rigging, weights and locomotion, but this feels much closer to an actual game-production workflow than just generating a static 3D model.

In 3 days I built a complete playable Souls-like arena with a player character, boss, environment, animations, cloth physics, combat and lighting.

My workflow was roughly:

• Prompting + image ideation — generate prompts and supporting images in 3DAIStudio to speed up concept exploration.
• 3D generation: create characters, armor, props and environment pieces with Tripo P2.
• Optimization: decimate / retopologize the generated meshes, clean topology in Blender and bake the high-poly detail down to lighter meshes.
• Textures: generate and modify additional tileable materials, alphas and clothing textures with AI, then manually adjust everything where needed.
• World building: build the arena modularly in Blender instead of generating one giant environment mesh. Arrays, curves and reusable pieces made iteration much faster.
• Characters: assemble generated parts manually, sculpt problematic areas, rig the characters and fix skin weights.
• UE5: set up materials, weapons, animations, collisions, cloth physics, lighting, fog and the actual boss encounter.
• Coding / setup: AI coding tools helped with repetitive Unreal tasks and logic, while the actual design decisions, debugging and integration were still done manually.

One thing that became very obvious during this project is that AI is much more useful as a production accelerator than as a replacement for the workflow itself.

Tripo AI didn't magically give me a finished game-ready character. What it did was remove a huge chunk of the slow initial modeling work. Instead of starting from an empty Blender scene, I could immediately start making decisions about topology, proportions, materials, rigging and how the asset actually fits into the game.

For ideation and asset prep, I used 3DAIStudio, which helped a lot for generating prompts, reference images, and quickly iterating on visual directions. Its node-based workflow made things much faster, and having access to multiple major 3D generators in one place was genuinely useful during production.

And when you repeat that across dozens of assets, the time savings become pretty ridiculous.

There's still a lot of manual 3D work here: assembling, sculpting, retopo, baking, UVs, rigging, weight painting, optimization, level design, shaders, physics and Unreal setup.

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

Wild workflow combining GPT-6 Astra with Marvelous Designer.

It was given a character reference and then used Marvelous Designer’s Python API + computer control to build the outfit directly inside MD.

The interesting part is that it didn’t just generate something that looks like clothing:

• created the 2D sewing patterns
• assembled the garment inside Marvelous Designer
• handled the layer relationships
• ran the actual cloth simulation
• reproduced details like the cardigan structure and knit pattern

The creator says the clothing was made from essentially one character reference, with no manual cleanup to the garment itself apart from some minor accessory issues.

Going from a character image to an actually simulated, editable MD garment feels like a much more useful direction for AI-assisted 3D workflows than simply generating another mesh.

Another pretty interesting example of AI agents moving deeper into actual 3D workflows.

Hirokazu Yokohara tested GPT-6 Astra with a Marvelous Designer MCP, asking it to create a maid outfit using a pattern-based workflow.

The result is surprisingly solid. Astra was able to work through the garment construction process inside Marvelous Designer and get pretty close to a usable outfit.

It still wasn’t a one-click process. The author says the maid outfit was difficult and required quite a few correction prompts, but the interesting part is that he wasn’t manually doing most of the actual work inside the software.

This feels like a much more useful direction for AI in 3D: not replacing the entire pipeline with a generated mesh, but actually operating professional tools and handling repetitive production tasks.

AI agents inside Blender, Marvelous Designer, UE5, etc. are getting interesting very fast.

GPT-6 Astra connected to the 3DAIStudio MCP + Tripo AI.

The workflow is what makes it interesting:

• Astra decides it needs a specific asset
• generates a reference image for it
• sends it through 3DAIStudio
• Tripo P2 turns it into a game-ready 3D model
• Astra imports it back and keeps building the scene

In the example, it was used to build a Rocket League-style environment, and the wild part is that it wasn’t just giving suggestions — it was actually moving through the workflow and creating the assets it needed.

It also generated supporting things like textures and images through the MCP, so the whole process feels much closer to an actual agentic 3D workflow than a normal chatbot experience.

We’re getting to the point where AI is not just helping with isolated 3D tasks, but actually chaining them together into a usable pipeline.

If this keeps improving, it could become a very big deal for fast prototyping, game environments, and general 3D content creation.

I started with a single face reference, removed the hair, and generated the head with Hi3D 3.0v using its High Fidelity mode and 8K textures.

The result was a surprisingly strong starting point. The facial proportions were already very close to the reference, the geometry held up well, and the texture had enough detail that I could reuse parts of it later instead of rebuilding the skin from scratch.

That ended up saving a lot of time once I moved into the MetaHuman stage.

Workflow

• Find or generate a good front-facing face reference
• Remove the hair and clean up the image
• Generate the head with Hi3D 3.0
• Bring the mesh into Blender
• Adjust the proportions to fit the MetaHuman template
• Wrap/transfer the face onto MetaHuman topology
• Do some quick sculpt and shape cleanup
• Reuse and rebake parts of the 8K Hi3D texture
• Refine the skin maps and details
• Add the groom
• Finish the character in Unreal Engine 5.8

The part I liked most was how much useful information survived from the original reference. The geometry gave me a solid facial structure to work from, while the generated texture was actually useful later in the pipeline instead of just being temporary preview material.

I’d put the final likeness at around 80–90% compared to the original image.

For this kind of workflow, 3D AI feels much more useful as a starting point for a production pipeline than as a one-click final result. Getting decent proportions, geometry, and high-resolution texture from one image cuts out a pretty painful chunk of the early character work.

A test of GPT-6 Astra controlling Houdini to create a procedural 3D model.

The user only provided instructions, including the lighting and video setup, while Astra handled the actual work. It still needed several correction prompts, but the final quality is pretty impressive, especially considering multiple models could potentially be generated in parallel.

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.

Made this dog model with Tripo and then animated it using Blender MCP + GPT-6 Astra.

Nothing crazy just a small idle animation, but I think it’s a nice example of what you can get when you stop expecting perfect one shot prompts. You can actually push these workflows pretty far and get surprisingly good results by iterating.

The mouth opening/closing you see in the video isn’t part of the idle animation it’s controlled separately with a Blender Custom Propertie so I can open or close the dog’s mouth manually.

A pretty funny benchmark for ChatGPT-6 Astra working directly in Blender: recreate the Never Gonna Give You Up video as a 3D animation.

Still very early, but this is exactly the kind of benchmark I want to see for 3D agents.

I’ve been testing ChatGPT-6 Astra inside Blender with Hitem3D, and quadruped animation felt like a much better stress test than another basic humanoid rig.

The horse mesh was generated from a single image with Hi3D 3.0, which gave me a surprisingly detailed and anatomically solid starting point. It did a really good job preserving the body proportions and smaller forms, which matters a lot more once you start rigging something with four legs.

I reduced it to around 100K polygons, and the mesh still held up really well visually, so I had a pretty strong base before handing the Blender side of the workflow over to Astra.

Astra:

• created the skeleton
• set up the rig
• analyzed a real horse-running reference video
• reproduced the motion as a run animation in Blender

The animation definitely isn’t perfect, especially if you look closely at the gait, but the fact that an AI agent can go from a static quadruped mesh + reference video to an actual working animation inside Blender is pretty wild.

What feels more important here is that this isn’t just ChatGPT explaining how to rig something. It’s actually working through the task inside the 3D software.

And honestly, having a detailed base mesh from Hi3D 3.0 made the whole experiment much more practical. Instead of spending most of the time fixing the generated model first, I could move pretty quickly into rigging and animation.

Quadrupeds are still one of those things that normally need much more manual cleanup than humanoids, so this feels like a pretty interesting glimpse of where creative agents are heading.

Low-poly geometry, facial expressions, a working rig, secondary motion, and a dance demo. This character came together using Tripo AI P2, GPT-6 Astra, and Blender, with the process reportedly taking less than half a day and much of the setup running unattended.

Here’s the workflow:

• Generate the head, hair, and body separately in Tripo P2. The body includes the clothing. Splitting generation into these three parts helped get cleaner results before bringing everything together.
• Have Astra assemble the character in Blender. It joined the parts and made small adjustments around the eyes. Most of the original Tripo geometry and topology stayed intact, without a separate retopology pass.
• Generate expression variants in Tripo. Astra then built the switching setup in Blender: the active expression stays visible, while the unused meshes shrink down inside the head. Everything stays within one object. It’s an unusual workaround, and the expressions switch discretely rather than blending smoothly.
• Let Astra handle rigging and secondary motion. A custom rigging helper app supported this step. Astra set up the rig and secondary motion, with the resulting character demonstrated in a dance animation.

That’s a lot of detail for a low-poly character, especially in the hair and outfit. The Tripo P2 meshes needed very little cleanup, so most of the work in Blender went into assembly, expressions, and rigging. Getting to a dancing character in under half a day makes a lot more sense when you can keep that much of the generated model.

This combination opens up a lot of possibilities. Astra handles the tools and technical setup, while Tripo P2 supplies detailed geometry that’s already usable as a starting point. Character prototypes, short animations, avatar experiments, testing different outfits—you can see how the same approach could save time across all of them.

You still need to understand 3D to make this work well. Choosing the approach, spotting problems, and knowing when a workaround is good enough still require judgment. With that knowledge, though, this starts to feel like the workflow of the future: going from an idea to something usable and moving, with much less manual setup along the way.

This creator used Claude Fable 5.1, Tripo AI 3D and Blender to take a fantasy creature from concept to a textured, rigged model with walk, idle and roar animations. Their role was giving instructions, reviewing renders and pointing out things to fix.

Here’s the workflow:

• Concept: The agent chose the creature design and used GPT Image to generate a concept sheet and four reference views.
• 3D generation: Tripo generated the base mesh from those views, then Tripo P2 Smart Mesh handled quad remeshing and texture baking.
• Rigging: The agent analyzed the creature’s geometry, built a custom 37-bone skeleton in Blender and checked deformation across 12 poses.
• Animation: Walk, idle and roar were scripted in Python with IK. No existing animation clips. When the creator pointed out problems with the feet, the agent inspected close-up renders and corrected their ground contact.
• Export: Rigged FBX/GLB files with baked 4K PBR textures, plus renders and animation previews.

Tripo P2 deserves some real credit here. Having quad remeshing and texture baking built into the pipeline gives the agent a much better foundation for the Blender work that follows. After cleanup and further work, the final creature had roughly 9.6K vertices and 81% quads. Getting a generated design this far into an editable, animated asset is a pretty compelling use of P2.

The result still needs anatomy and motion polish, but the agent also left behind reusable scripts for the next creature. That makes this experiment even more interesting.