wanted to make a low poly environment for Unity as fast as possible, starting from just one reference image that already had most of the buildings and scene elements I wanted.

So I went into 3DAIStudio Flow, used the AI agent, and gave it a very simple prompt: take this image, identify the buildings and environment assets in it, separate them, and generate them in 3D. In about 3 minutes, it built a full node-based workflow for me, kind of like ComfyUI, and from that single image I ended up with a full asset kit.

For the generation part, I also used Tripo P1, and honestly the low poly output was one of the best parts of the workflow. The meshes came out lightweight, readable, and actually practical for building a game scene quickly instead of spending forever cleaning dense geometry.

Workflow:

• Reference: one image with the full environment
• 3D AI Studio Flow: gave the AI agent a simple prompt to detect and separate all the assets
• Node workflow: in about 3 minutes, it built a ComfyUI-like workflow automatically
• 3D generation: used Tripo P1 for the low poly assets
• Blender: exported everything, assembled the scene, adjusted placement, and made a few things manually like the fence with an Array modifier
• Unity: imported the finished environment and materials

After that, I exported the assets, assembled everything in Blender, placed the scene by hand, and did a bit of quick manual cleanup. Even the fence was easy to finish with a simple array workflow, so putting the whole environment together was pretty straightforward.

Then I brought everything into Unity, and it all worked nicely. The full environment ended up at around 100K faces total, with PBR materials/textures, and the real hands-on time for the whole scene was about 4 hours.

Pretty crazy that this started from one image and turned into a usable Unity-ready environment kit that fast.

This might be one of the craziest examples yet of LLMs being used for actual 3D generation.

There were no imported 3D models, no sculpting, and no texture files.

Instead, Claude Opus 5 generated the geometry itself through code. Every visible surface in the scene was procedurally created by the LLM.

• Zero imported 3D assets
• Zero manual sculpting
• Geometry generated entirely through code
• Around 17.7 billion triangles evaluated every frame
• 2,978 frames rendered at 4K
• 124-second continuous shot with one camera

It apparently even generated the car inside out at one point, which went unnoticed for weeks because the exterior silhouette still looked correct.

It's that an LLM was effectively acting as a procedural 3D modeler, generating complex geometry and assembling an entire scene without relying on a traditional asset pipeline.

We're starting to get surprisingly close to simply describing a 3D scene and letting an LLM build the geometry itself

source: https://x.com/aipulseda1ly/status/2089804529034481700

Tripo P2.0 Preview is finally live, so everyone can test it now.

The biggest change for me is that it can now generate native quad topology while letting you choose the target polycount.

And it doesn't feel like simply taking a dense AI mesh and decimating it afterward. The polygon distribution is much more intentional: simpler surfaces stay simple, while areas that actually need the geometry get more of it.

Another thing I really like is how logically some models are structured. Instead of everything becoming one giant welded blob, separate elements can come out as actual separate parts, which makes editing the result in Blender much less painful.

Main highlights:

• Native quad topology with much cleaner polygon flow
• Logical edge loops around important shapes and details
• Models can be logically separated into individual parts, instead of everything being fused into one mesh
• Custom polycount control, so you can choose how low-poly or detailed the result should be
• Support for both quad and triangle meshes
• Better polygon distribution, with more geometry where detail is needed and fewer polygons on simple surfaces
• The mesh generation itself takes only around 5–10 seconds

Source; https://www.reddit.com/r/Tripo_ai/comments/1vrxppz/we_just_shipped_tripo_p20_preview_it_is_a_major/

Saw this workflow and thought it was a pretty interesting example of where AI-assisted character creation is right now.

The creator went from basically nothing to a fully rigged and animated character in around 6 hours using:

• ChatGPT / GPT Image for the initial character design and reference views
• Tripo AI to generate the head and body separately
• Smart topology with around 20K polys allocated to each part
• Blender to merge and clean everything up
• Manual skinning / weight painting
• Texture painting to fix the face
• Shape keys for blink, wink, smile and mouth open
• Some basic jiggle physics

Author said roughly 80% of the work was still manual Blender work, especially rigging and weight painting.

One part that seems to have saved a lot of time here was Tripo AI P2 Smart Mesh. The generated head and body came out with a much cleaner and more usable mesh than you usually expect from AI generation, so there was less time spent fighting the geometry before moving into Blender. The topology was easy enough to edit, clean up and continue working with, which made it much faster to get from generation to an actually usable character.

There are still some obvious problems too. UVs and textures can be messy, close-up quality isn't really there yet, and generated meshes still need cleanup.

post https://x.com/Dstudio_ai/status/2089209243207680484

I wanted to see how fast I could go from a single character image to something I could actually run around with in Unity.

For the character, I used 3DAIStudio Flow. It’s basically a ComfyUI-style node workflow where I can use image generators and the major 3D AI generators in the same graph, which made this kind of multi-part workflow pretty convenient.

Instead of trying to generate the whole character as one mesh, I split the reference into separate parts:

• Hair
• Body
• Clothes
• Shoes

I generated each part separately with Rodin Gen 2.5 using Smart Low Poly, then moved everything into Substance Painter to fix and clean up the textures.

After that:

• Assembled and cleaned the character in Blender
• Rigged it with Mixamo
• Brought it into Unity
• Used the Third Person Template
• Retargeted the character to the controller animations
• Added running, jumping and basic playable movement

I also generated the environment through the same node-based workflow, although I’ll probably make a separate breakdown for that because the environment pipeline deserves its own post.

I also used an AI agent connected to Unity for some of the setup and repetitive work inside the project.

So after roughly one day, I had a small playable scene with an AI-generated character, generated environment, textures, rig, animations and basic gameplay.

Guide: https://www.youtube.com/watch?v=mmpLXA-xzrQ

I think Hunyuan PolyGen 1.5 is currently the best free AI retopology tool out there. On one custom test, it took a 1.5 million polygon model and turned it into a mesh with only around 15,000 faces — and the result still held up surprisingly well as a solid first retopo pass. That alone got my attention.

I've been testing quite a few AI retopology tools recently, and what impressed me here isn't just the polygon reduction. A lot of "AI retopology" tools can make a mesh lighter, but the result still looks like an automatic remesh that you immediately want to redo.

With PolyGen 1.5, the topology actually starts to look like a real first retopology pass.

On more complex characters with a mix of organic shapes, clothing, accessories and harder surface details, it does a surprisingly good job of:

• preserving the original silhouette
• keeping important forms instead of smoothing everything away
• creating much cleaner and more readable edge flow
• reducing unnecessary geometry without completely destroying smaller details
• producing a mesh that is much easier to continue cleaning manually in Blender or Maya

And that's probably the most important distinction for me.

I don't expect AI retopology to magically give me a perfect production-ready character with flawless deformation loops every single time. Characters still need inspection, cleanup, proper deformation testing and sometimes manual fixes around joints, the face, fingers, intersecting parts, etc.

But if the AI can take a horrible dense generated mesh and turn it into something that already feels 70–80% of the way toward a usable base, that's genuinely useful.

For static assets and simpler objects, the result can already be surprisingly close to something I'd actually use. For characters, I'd still treat it as a strong starting point rather than the finished mesh.

And considering that this is available as a free option, that's kind of ridiculous compared to where AI retopology was even a year ago.

This is also the part of AI in 3D that makes the most sense to me. I'd much rather see AI automate boring technical work like retopology than try to replace the creative part of modeling.

Right now, Hunyuan PolyGen 1.5 is my #1 free AI retopology option.

I've been experimenting with local 3D AI more lately, and I honestly think TRELLIS 2 + UltraShape 1.0 is one of the strongest free local combinations available right now.

The biggest reason is that the two models solve different parts of the problem.

TRELLIS 2 works as the main image-to-3D generator.

It can generate:

• complex 3D geometry from a single image
• thin and open surfaces
• detailed shapes with fairly complex topology
• full PBR materials
• textured GLB assets that are already easy to move into a normal 3D workflow

But another huge advantage of TRELLIS 2 is the community around it.

There are already several alternative ways to run it locally:

• the original Microsoft implementation
• community C++ / GGML implementations
• GGUF / quantized versions aimed at making local inference more accessible
• CUDA and Vulkan implementations
• multiple ComfyUI nodes and workflows

So you don't necessarily have to use the original heavy Python setup forever.

If you already use ComfyUI for image generation, upscaling, segmentation or other AI workflows, TRELLIS 2 can basically become another node in the same pipeline instead of a completely separate application.

Then you can add UltraShape 1.0 as the geometry refinement stage.

UltraShape takes a reference image together with an existing coarse mesh and focuses specifically on improving the geometry.

That means a practical pipeline can look like:

reference image → TRELLIS 2 → UltraShape geometry refinement → TRELLIS 2 / other tools for PBR

TRELLIS gives you the initial 3D structure quickly.

UltraShape then gets another chance to reconstruct the small forms and geometric details that the first generation missed.

And this is probably the part I like most about the combination: you're not asking a single AI model to somehow solve generation, geometry and materials perfectly in one pass.

You're splitting the workflow into stages and using a model that is good at each stage.

For local generation the advantages are pretty obvious:

• free generation
• no credits or subscriptions
• no API cost per model
• everything can stay on your own machine
• you can iterate as much as your GPU allows
• TRELLIS 2 already has a pretty large community ecosystem
• ComfyUI makes it possible to build much larger automated workflows around it
• UltraShape gives you a dedicated second pass for geometry instead of accepting the first mesh as final

Commercial generators are still much easier if you just want to upload an image and get something back in 30 seconds.

But if we're talking specifically about free + local + customizable 3D AI generation in 2026, TRELLIS 2 + UltraShape is probably the setup I'd start with.

UltraShape:
https://pku-yuangroup.github.io/UltraShape-1.0/

TRELLIS 2:
https://github.com/microsoft/TRELLIS.2

Found this today and thought it was worth sharing.

Someone built an open-source Unreal Engine plugin that integrates TRELLIS 2 directly into the editor, so you can basically go from an image to a generated 3D asset without constantly jumping between different tools.

It supports:

• image → 3D generation with TRELLIS 2
• local or remote generation
• 1K / 2K / 4K settings
• background removal
• seed and generation controls
• generation progress directly inside UE
• automatic download and import of the generated GLB into the scene

The local mode is probably the most interesting part to me. If you already have TRELLIS 2 running locally, this starts looking less like a separate AI toy and more like an actual part of the Unreal workflow.

Still pretty early, but integrations like this are exactly where I think 3D AI becomes genuinely useful.

GitHub: https://github.com/camenduru/TostEngine-trellis2-unrealengine-plugin

I've been experimenting with AI-generated characters lately and wanted to see how far I could push facial expressions while still keeping everything usable with native Unreal Engine tools.

I built the character as 4 separate parts instead of trying to generate everything as one mesh, which gave me much more control over the final result.

For the 3D generation I used 3DAIStudio to generate all of the character parts. What I liked here was being able to switch between different 3D AI generators in one place depending on which model handled a specific part better, rather than constantly jumping between separate platforms. I also generated the reference images directly inside 3DAIStudio, so most of the early concept-to-3D workflow stayed in the same place.

After that I brought everything into Blender, assembled the parts and did the usual manual cleanup and geometry fixes.

One thing that surprised me was baking the high-poly details onto the generated low-poly character. It worked much better than I expected, and the final result ended up at around 34k triangles while still keeping a lot of the original detail.

The facial setup was definitely the harder part.

I created 58 different facial expression references and used them as a guide for building the blendshapes. It still needed a fair amount of manual work, but generating the head with an open mouth helped a lot with preserving details around the mouth, teeth and inner geometry.

Finally, I brought the character into Unreal Engine / UEFN and used Control Rig for the animation setup, so the finished character still works inside a pretty normal Unreal workflow.

This is a pretty cool example of where AI-assisted 3D workflows are heading.

The project is called Empire Atlas, an interactive 3D website where you can explore 8 historical empires, their architecture, maps, interiors, daily life and more.

What makes it interesting to me is how much of the production pipeline was AI-assisted:

• Kimi K3 was used for most of the coding / engineering workflow
• Three.js powers the interactive 3D experience in the browser
• The 3D assets were generated with Tripo AI
• GPT Image 2.0 was used for design / visual generation
• Kimi's image tools were also used to generate dozens of historical images and supporting content
• The original ~500MB of 3D assets were automatically optimized down to around 18MB using mesh simplification, Draco compression and smaller WebP textures
• Everything runs directly in the browser as an interactive 3D experience

This is the part I find more interesting than another isolated AI-generated model.

We're starting to see AI-generated 3D assets actually being used inside complete interactive experiences, with AI also handling a large part of the engineering and optimization around them.

For education especially, I think this kind of thing has a lot of potential.

Instead of just looking at a picture of an ancient city in a textbook, you could actually walk around it, enter buildings and explore reconstructed environments interactively.

Pretty crazy how quickly the gap between “AI generated some assets” and “AI helped build an entire usable 3D product” is shrinking.

I Compared 3 AI Retopology Tools: Tripo vs Rodin vs Free Hunyuan3D

I wanted to see how current AI retopology tools handle something more complicated than a basic character.

For the test I used the same character with a mix of different shapes: organic parts, clothing, a backpack, staff and some more hard-surface-like elements.

Same source model and the same general conditions for all three.

Final mesh:

• Rodin: 35K faces
• Tripo: 46K faces
• Hunyuan3D: 66K faces

Polygon count

🥇 Rodin — 35K
Rodin was the most aggressive with optimization. It managed to simplify a lot of areas while still keeping the character recognizable and most important shapes intact.

🥈 Tripo — 46K
Tripo kept noticeably more geometry than Rodin, but a lot of those extra polygons seem to be used more intentionally around important shapes and transitions.

🥉 Hunyuan3D — 66K
Hunyuan preserved a huge amount of the original geometry. That's good for detail preservation, but not so good if your main goal is actually reducing the model.

Shape & detail preservation

🥇 Hunyuan3D
This was probably Hunyuan's strongest point. It tries to preserve almost every shape and small element from the source model.

The downside is that it doesn't really decide what needs to stay geometry. Details that could easily be represented with a normal map or texture often remain fully modeled.

🥈 Tripo
Tripo found a pretty good middle ground. Most important forms survived, while some unnecessary smaller details were simplified.

It loses a little more compared to Hunyuan, but the result feels more optimized rather than simply copied.

🥉 Rodin
Rodin simplifies the model much more aggressively. Major silhouettes and important forms are still there, but smaller shapes and secondary details can get noticeably reduced.

That's partly why it managed to reach the lowest polycount.

Topology quality

🥇 Tripo
This was the strongest result for me.

The topology feels much more intentional. Different elements are logically separated and the edge distribution generally makes more sense around the actual forms.

Out of the three, this was the closest to something I would expect from a manually planned retopology workflow.

🥈 Rodin
Rodin's topology is surprisingly decent considering how aggressively it reduces the model.

The main problem is that some areas still feel like one continuous remesh rather than topology designed specifically around individual parts.

Still, it's relatively clean and very usable for an automatic result.

🥉 Hunyuan3D
Hunyuan feels much closer to a traditional quad remesh.

It follows the source surface very closely, but doesn't seem to make many decisions about where geometry could be simplified or where topology should be structured differently.

Good surface preservation, weaker actual optimization.

Generation time

🥇 Tripo — ~1 min
Very fast. For iteration this is probably the biggest advantage because you can test multiple versions without waiting much.

🥈 Rodin — ~3 min
Still fast enough for normal production use. Slightly slower than Tripo, but considering the lower final polycount, the result is pretty reasonable.

🥉 Hunyuan3D — ~5–10 min
Definitely the slowest in my tests. Not terrible, especially considering it's free, but it becomes noticeable when you're testing multiple models.

Price

🥇 Hunyuan3D — Free
This is obviously its biggest advantage.

You can get a fully retopologized quad mesh without paying anything, which makes the result pretty impressive despite its weaknesses.

🥈 Rodin
Rodin sits somewhere in the middle for me. You pay for the generation itself, but the result is generally predictable and already fairly optimized.

🥉 Tripo
Tripo gave me the best topology, but it can become the most expensive when experimenting.

You're effectively spending credits on attempts, so if you need several generations to get the result you want, the cost starts adding up.

UVs

🥇 Rodin
Rodin produced the cleanest UV layout in this test.

The islands looked relatively organized and usable without immediately feeling like they needed to be completely redone.

🥈 Tripo
Tripo's UVs were still usable, but not as clean or organized as Rodin's.

For quick production they would probably be fine, but I would still prefer Rodin here.

🥉 Hunyuan3D
The UV result was the weakest of the three.

It works, but just like the topology itself, it feels more automatically generated and would probably need more cleanup for a serious production asset.

So for me:

Paid: Rodin 🥇
Free: Hunyuan3D 🥇

A few days ago, I made a post where I shared how I built this production-ready character in one day using AI and traditional 3D tools.

The short version: I assembled and refined everything in Blender, created the final topology using RetopoFlow and rigged the character with AccuRig.

Since then, I continued working on the project and:

• Imported the character into Unreal Engine 5
• Added animations and brought the character to life
• Set up third-person controls and made her fully playable
• Used 3DAIStudio and Rodin Gen-2.5 to generate matching environment assets
• Created houses, fences, vegetation and other environmental props
• Assembled and set up the final scene inside Unreal Engine

The entire environment, including generating the assets and assembling the scene, took around two hours.

The video shows the final result: the playable character running through the finished location with animations and controls working in real time.

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

Tripo P2 is now in beta, and this might already be one of the biggest AI 3D updates of the year.

It finally generates real quad-based low-poly meshes, and you can choose the target polycount yourself. But the crazy part is that it doesn’t simply decimate a dense model — the geometry is distributed like an artist would actually build it:

• flat surfaces use fewer polygons
• detailed areas get more density
• the mesh stays within the budget you set
• everything is split into logical, editable parts instead of one welded AI blob

Hard-surface is where the difference becomes ridiculous. Flat panels actually stay clean, edge flow follows the design, and the usual melted seams, random triangles and wasted geometry are massively reduced.

The mesh generates in around 10 seconds, with PBR texturing available in the same workflow.

This is the first time AI-generated low-poly models have started to feel intentionally modeled rather than automatically simplified. If P2 holds up across more tests, this could be a massive shift for game-ready 3D generation.

Top3D.AI — compare all major 3D AI generators side by side across high-poly, low-poly, PBR, segmentation and other modes, using the same 140+ prompts and reference images under identical conditions

NVIDIA just released MotionBricks, a generative framework for real-time character animation.

A single neural backbone handles more than 350,000 motion clips while reportedly reaching 15,000 FPS with 2 ms latency.

Instead of manually building huge animation graphs, MotionBricks uses “smart primitives” to combine locomotion, style changes and interactions directly inside Unreal Engine 5.

• Walk, run, strafe and switch styles in real time
• Pick up objects, sit, fall or jump over obstacles
• Generates approach, contact and follow-through automatically
• No manual motion blending or hand-authored transitions in the UE5 demo
• Works with both game characters and humanoid robots

The best part is that you can already start experimenting with it in your own projects today. NVIDIA has released the code and pretrained checkpoints, giving developers a new way to create more responsive, natural character movement and make games, simulations and virtual worlds feel much more alive.

The initial code, pretrained checkpoints and training tools are already available.
source; https://nvlabs.github.io/motionbricks/

Tencent’s Hunyuan3D team has introduced WorldClaw, an agentic framework that turns a single open-ended text prompt into a large, explorable and editable 3D environment.

Instead of generating the entire world as one flattened scene, WorldClaw builds it in stages:

• An agent converts the prompt into a structured plan containing regions, terrain, materials, objects and spatial relationships.
• A semantic layout and procedural height field are used to construct the global terrain.
• Individual regions are rendered and populated using image generation.
• SAM3 separates the objects, while SAM3D and Hunyuan3D reconstruct them as individual textured meshes.
• Blender-connected agents place the assets and repeatedly inspect the scene to correct scale, orientation, floating objects, terrain intersections and material issues.

The important part is that the result is not just a video or a fixed 3DGS environment. The terrain and individual objects remain explicit, independently editable 3D meshes that could potentially be exported into conventional game-engine workflows.

The team demonstrated pirate islands, tribal river canyons, desert battlefields, futuristic snowy valleys, medieval villages, volcanic environments and several other large scenes.

There are some major limitations, though. The experiments used Claude Opus 4.8, GPT-Image-2, SAM3, SAM3D, Hunyuan3D, Blender 5.1.1 and a server with four NVIDIA H20 GPUs. The process is computationally expensive, generation times were not reported, and the comparison is mainly qualitative.

The WorldClaw pipeline itself also does not appear to be publicly released yet—the current GitHub repository only contains the project website.

Project: https://tencent-hunyuan.github.io/Hunyuan3D-WorldClaw/

NVIDIA’s Kimodo is starting to look much more useful than the usual “type a prompt and get a random animation” demos.

You can describe a motion in text and generate a full-body animation, but the interesting part is that the result can also be constrained with key poses, joint positions/rotations, waypoints and motion paths. So instead of endlessly regenerating until the character happens to move correctly, you can actually give the model some animation direction.

Kimodo was trained on around 700 hours of optical motion-capture data and uses a motion diffusion system designed specifically to reduce common problems like foot sliding and unstable root movement. It can handle locomotion, gestures, dancing, stunts, object interactions and even sequences made from multiple prompts.

What makes this especially interesting for actual 3D workflows is that people are already integrating Kimodo into Houdini/KineFX and Unreal Engine, where the generated motion can be retargeted or turned into a regular animation sequence and then cleaned up manually.

So I don’t really see this replacing animation work anytime soon, but as a way to generate blocking, locomotion variations, background character motion or a first animation pass, this could become genuinely useful.

source; https://research.nvidia.com/labs/sil/projects/kimodo/

LocalAI 4.8 just added 3D generation as a native modality.

The new pipeline uses trellis2cpp, a C++/GGML implementation of Microsoft’s TRELLIS.2, to turn a single reference image into a textured GLB model with PBR materials directly on your own machine.

The release also includes:

• A dedicated 3D generation UI
• A built-in GLB viewer
• Generation history
• A REST API endpoint
• Watertight remeshing for cleaner printable results

The full textured pipeline requires around 18 GB of memory, while a smaller geometry-only version needs roughly 7 GB.

It is image-to-3D only for now, but having generation, previewing and remeshing inside one fully local open-source interface looks pretty useful.

source: https://github.com/hec-ovi/text-to-3D-skill

Hunyuan3D-Buffalo 1.0 is Tencent’s new unified AI system for 3D generation, understanding and editing.

Unlike most 3D AI tools that focus on only one task, Buffalo is designed to understand the structure of an existing model and then modify it through natural-language instructions.

The most interesting capabilities:

• Generate complete 3D assets from text prompts
• Select, remove or replace individual parts of a model
• Preserve the original geometry outside the edited area
• Extract semantic parts as separate 3D objects
• Answer questions about the shape and structure of an asset
• Perform instruction-based geometry editing without rebuilding everything from scratch
• Combine 3D understanding and generation inside one model
• Trained on approximately 87 million samples

For example, you could ask it to remove the wings, replace a weapon, change a specific armor piece or extract the helmet as a separate object while keeping the rest of the character intact.

The system combines Qwen-VL for multimodal understanding with technology based on TRELLIS and Hunyuan3D for geometry generation and editing.

This is much more interesting than another basic image-to-3D generator. Controlled part-level editing could eventually make AI-generated assets far more practical for Blender workflows, game development, asset variations and 3D printing.

source: https://tencent-hunyuan.github.io/Hunyuan3D-Buffalo1.0/

DiffGI is a new approach for generating high-fidelity thin-shell 3D models from a single image or clothing pattern.

Unlike many image-to-3D systems built around watertight volumetric geometry, DiffGI is designed to preserve thin surfaces, open boundaries and small structural details. This makes it especially interesting for clothing, furniture and other assets that standard representations often tear apart or overcomplicate.

According to the researchers, it can:

• Generate a complete 3D garment from one front-view image
• Produce compact meshes averaging around 23K vertices
• Run in roughly 1.2 seconds on an RTX 4070
• Generate results on CPU-only devices
• Preserve cleaner silhouettes and boundaries than TRELLIS, TRELLIS.2 and GarmageNet in their tests

The method works through a compact 32×32 latent representation and a differentiable surface extraction process, allowing the system to learn the final 3D geometry end-to-end.

Code is not available yet, but the project looks genuinely useful for AI-assisted clothing creation rather than just producing another dense mesh that needs immediate surgery.

Project: https://ejshim.github.io/diffgi

This is a pretty solid example of AI being used for something beyond yet another shiny character turntable.

The developer created a full interactive human anatomy app using:

• GPT Image for the original design and references
• Tripo AI to convert each image into a 3D model
• Three.js for the web-based 3D viewer
• Codex to build the interface, interactions, illustrations and hotspot system

The first version contained almost 900 MB of 3D assets and ran at around 16 FPS. After several optimization passes, the models were reduced to roughly 2–5.5 MB each, bringing the entire asset package down to only 28.6 MB, with models loaded on demand.

Users can rotate and inspect, view where they sit inside the body, open educational illustrations and interact with hotspots explaining different anatomical areas.

Not a one-click workflow, obviously, because reality continues refusing to be that convenient, but it shows how image generation, AI 3D tools and coding agents can be combined into a genuinely useful educational product.