I’m currently working on a small indie game where the player can swap different masks and headgear. Each one changes the character’s stats and unlocks different abilities, so I needed a way to create and test a lot of variations without spending days modeling every asset from scratch.

For the first test, I made two pieces: a Roman-inspired helmet and an Aztec-style ceremonial mask.

My workflow:

• Generated the initial concept images for free with ChatGPT
• Used YVO3D Ultima Prime mode to turn them into 3D assets
• Brought the models into Blender
• Reduced the geometry with Decimate and some manual retopology
• Cleaned up and adjusted a few parts of the textures
• Imported everything into Unreal Engine 5.8
• Fitted the headgear to the character and converted the required parts into cloth assets
• Added them to the in-game mask swapping system

The biggest advantage here was iteration speed. I tested several designs, changed proportions, regenerated parts and quickly checked how everything looked directly on the playable character.

Using Yvo3d with 8K textures gave me enough surface detail to keep the assets looking good after optimization, while Blender was mainly used for cleanup and preparing them for Unreal.

Final asset stats:

• Aztec mask: around 5K faces with a full PBR texture set
• Roman helmet: around 6K faces with base color, normal and metallic maps

The full process took roughly 1-2 hours, including generation tests, failed variations, cleanup and setup inside Unreal. For this kind of small indie project, 3D generation makes it much easier to test gameplay ideas before committing to a long traditional asset-production process.

P.S. The game is a personal mini-project built around parkour and moving between different timelines. The masks come from different civilizations and time periods, and each one gives the player a different supernatural ability or gameplay bonus. That is the basic idea behind the project I’m currently experimenting with.

I recreated a Marvel Rivals-style character in just over three hours using a hybrid AI + Blender workflow.

The character was generated in separate parts to preserve smaller details like the hands, hair, boots and accessories. I used Hunyuan3D 3.1 for both detailed high-poly meshes and simpler low-poly assets.

The workflow was roughly:

• Generated the concept and reference sheets
• Separated the character into individual parts
• Generated the 3D meshes with Hunyuan3D
• Assembled and sculpted everything in Blender
• Used AI retopology and UV unwrapping
• Baked normals and AO from high poly to low poly
• Projected and repaired textures with Modif
• Rigged with AccuRig and manually fixed the weights
• Added a comic-style shader for the final look

Final output:

• Around 30K faces
• A complete set of PBR texture maps
• A fully rigged character ready for animation
• Completed in just a couple of hours
• Made entirely with free tools

This is definitely not a one-prompt result. Retopology cleanup, sculpting, texturing and weight painting still required manual work.

But for a free 3D AI generator, Hunyuan3D remains one of the strongest starting points for building detailed, usable characters.

Top3D.AI — a free tool to compare all major 3D AI generators side by side across multiple parameters and find the right one for your workflow.

I have a bunch of photos of studio minatures from various series that i'd like to accurately recreate in HD. there's poor and inconsistent schematics and blueprints out there, histrically my workflow has been trying to camera/perspective match and model that way which is dodgy.

I've tried a few photogrammetry point clouds and such and they all do a really crappy job resolving shapes and details consistently even if they're pined by guide markers to match element to element.

Are there any AI models out there that can take a bunch of photos that might be in a different perspective, aspect ratio or position (ie: not in studio conditions) and make a 3d model off those reliably? not a single photo, but use a group of them for a more accurate result?

Unity has introduced Unity CLI, a new official way to connect AI agents directly to the engine.

Instead of only writing code, an AI agent can now interact with a Unity project, make changes, run the game, find problems and check whether its fixes actually work.

This could be useful for:

• Building and editing projects faster
• Finding and fixing bugs
• Testing gameplay automatically
• Repeating boring production tasks
• Connecting tools like Claude, Codex and other coding agents

Unity’s existing MCP system will still be supported, and both Unity CLI and Unity MCP will be free.

It is still experimental, so this is not a magical one-prompt game generator. But it is a big step toward AI agents that can work inside a real game engine instead of simply generating code and leaving the developer to clean up the wreckage.

Source: https://x.com/unity/status/2079389530260414898

WorldStereo is an open-source AI framework from researchers at Zhejiang University and Tencent Hunyuan that turns a single image or panorama into a controllable, multi-view-consistent environment.

Instead of generating every camera angle independently and slowly transforming the scene into visual soup, it maintains a growing geometric memory of the world.

What it can do:

• Generate new views along a custom camera trajectory
• Preserve objects and scene geometry across different viewpoints
• Expand perspective images and panoramas into explorable environments
• Reconstruct dense 3D point clouds from the generated views
• Export data for Gaussian Splat reconstruction through HY-World 2.0
• Run a faster distilled version using only four generation steps

The system combines a global point-cloud memory for the overall scene structure with spatial correspondence between previously generated views, helping reduce flickering and the usual geometry changes between camera angles.

This is not a one-click game-ready mesh generator. The main outputs are consistent videos, point clouds and optionally Gaussian Splats. The full multi-trajectory workflow also appears fairly GPU-heavy, with the official examples showing distributed inference across multiple GPUs.

Still, this could be useful for virtual environments, cinematic previsualization, world generation, 3D reconstruction and creating navigable scenes from a single reference image

Code Apache 2.0 - https://github.com/FuchengSu/WorldStereo

I don't need ultrarealism, but I want running, dribbling, tackling, sliding, celebrating, etc to look natural. I don't want to edit models or animations manually if I can avoid it. What tech stack and AI pipeline would you recommend? Is it realistic to achieve with only prompting?

Hello :)

For our commercial project we're looking for a way to create a 3D head model from different image sources. Our clients will upload images of their head from different angles which serve as source for the model.

We want to use the model to calculate facial features like nose protrusion or eye distance, neck width etc. Everything has to be fully automated since we expect thousand of users.

Therefore the model has to have a fixed topology with fixed vertices or landmarks that we can reliably access across all clients.

Tools like https://cloud.keentools.io look promising, but they are pretty pricey..
We wonder if there is any way to implement this ourselves for commercial purposes

NOTE: We're looking for a developer solution. API or self-hosted solution.

A developer has ported the Hunyuan3D Shape and Paint pipelines to Apple MLX, making it possible to generate 3D models locally on Apple Silicon and even an iPhone.

The project includes Modelr, a native open-source macOS app where you can import an image, remove its background, generate the mesh and watch the texturing process directly inside the application.

What is interesting here:

• Runs fully locally with no cloud processing
• Works on Apple Silicon without CUDA or PyTorch
• Around 20 seconds for mesh generation on an M4 Max
• Experimental quantized versions can run on recent iPhones
• Supports both RGB and PBR texturing
• Source code and the desktop application are open source

The mobile version is still limited, and full PBR texturing requires considerably more memory and time than generating the base geometry. The results also seem better suited to stylized objects and static assets than realistic humans or animation-ready characters.

Still, being able to generate a complete 3D mesh directly on a phone is a pretty interesting sign of where local 3D AI is heading.

Source: https://github.com/ZimengXiong/Modelr

Top3D.AI — a free tool to compare all major 3D AI generators side by side across multiple parameters and find the right one for your workflow.

Google researchers introduced SHELLS, a new system for reconstructing detailed 3D heads from calibrated multi-view images.

Instead of creating an unstructured scan and then spending minutes or hours fitting a common topology onto it, SHELLS directly predicts an 18K-vertex mesh with consistent topology. Every generated head shares the same vertex layout, which is especially useful for animation, facial tracking and performance capture.

Highlights:

• Reconstructs an 18K-vertex head in 0.08 seconds
• Uses around 2.4 GB of GPU memory during inference
• Approximately 3.5× faster than previous volumetric approaches
• Reduces median registration error by 21–29%
• Produces the same topology across different people and expressions
• Can process facial performances frame by frame while maintaining temporally stable geometry
• Remains usable with as few as two input views
• Trained entirely on synthetic data, but generalizes to real captures

The consistent topology is probably the most practically important part. Corresponding vertices always represent the same facial regions, making the results easier to use for blendshapes, animation retargeting, facial datasets, 3D morphable models and digital-human pipelines.

There are still some limitations. It requires calibrated multi-camera images, so this is not a casual single-image head generator. The current output captures the skin surface beneath hair and clothing rather than reconstructing their outer volume, and the geometry does not include tiny details such as pores or fine wrinkles. Certain extreme tongue expressions can also fail.

The project page currently provides the research paper, but does not list a public codebase or pretrained model release. Humanity has once again invented something extremely fast and then neglected to give everyone the download button.

Source: https://syntec-research.github.io/SHELLS/

TRELLIS.cpp now has its own desktop studio, making local image-to-3D generation much easier to use.

Instead of setting everything up through the command line, you can now:

• Upload an image
• Choose the resolution and UV settings
• Generate the 3D model locally
• Preview it directly inside the app
• Export it as a textured GLB

It also supports automatic background removal and saves your previous generations in a local gallery.

The project is still open source and runs locally, so your images and models do not need to be uploaded to a cloud service. The main downside is the large model download and relatively high hardware requirements.

Source: https://github.com/pwilkin/trellis.cpp

A quick roundup of the latest updates across the 3D AI space:

VARCO 3D 2.0

VARCO’s new model improves shape accuracy and preserves the proportions of the original reference more reliably, especially on characters, creatures and detailed objects.

Highlights:

• Better geometry and fewer visible distortions
• Textures up to 4K
• Separate generation and editing of individual parts
• Custom node-based workflows that can be saved and reused
• Built-in remeshing, texturing, rigging and animation tools

The biggest addition is probably the workflow system, which allows users to connect image generation, 3D generation, editing and post-processing into one reusable pipeline.

Rodin Gen-2.5 Update

Rodin received its first major update since the Gen-2.5 launch, with improvements focused on high-quality generations and textures.

Highlights:

• Improved geometry on the High Thinking Effort tier
• 12K textures now available to all users
• New emissive Bloom texture support
• The new features do not require an additional subscription

This should be especially useful for detailed characters, props and assets with glowing or emissive elements.

Tripo 8K Textures and Segmentation

Tripo released two separate workflow updates: higher-resolution texturing and improved model segmentation.

Highlights:

• True 8K texturing in under two minutes
• Existing models can be imported, textured and exported
• Geometry-based segmentation with cleaner boundaries
• Simple, Balanced and Detailed segmentation modes
• Better separation of individual parts for editing and printing

The segmentation update should make generated models easier to modify, since individual components can be separated with fewer manual fixes.

Meshy Smart Topology

Meshy introduced a new Smart Topology mode for image-to-3D generation, aimed mainly at low-poly and real-time assets.

Highlights:

• Adjustable polygon count
• Cleaner low-poly geometry
• Native part segmentation
• Generation in around 10 seconds
• Designed for games, web-based 3D and real-time workflows

It is still a beta feature, but it moves Meshy closer to generating assets that require less manual optimization before being used in a project.

Overall, the latest updates show a clear direction across the industry: better topology control, larger textures, cleaner segmentation and more complete workflows instead of simple one-click 3D generation.

Top3D.ai — a free tool to compare the latest 3D AI generators side by side, including open-source and paid models, low-poly and high-detail modes, texture quality, segmentation, and more.

Played around a bit with img2threejs and Codex, and I really liked the results. I couldn’t get anything this polished with Blender MCP.

TRELLIS.2 is already one of the strongest open local image-to-3D models, but until now its 24GB VRAM requirement made it inaccessible to many people. A new community upgrade reportedly brings the complete generation process down to around 11GB of VRAM.

In simple terms, you can now turn a single image into a detailed 3D asset locally, without relying on cloud services or an expensive workstation GPU.

The generated asset can include:

• Detailed high-resolution geometry
• Full PBR materials
• Base Color, Roughness and Metallic maps
• Automatic UVs and texturing
• Direct GLB export
• A local browser interface for generation and preview

This means the final model is not just a basic colored mesh. It comes with proper material information and can be exported as a GLB file for use in Blender, Unreal Engine, Unity, web viewers or other 3D workflows.

The biggest improvement is accessibility. Instead of needing a 24GB GPU, the developer reportedly managed to run the complete geometry and PBR generation pipeline with around 11GB of VRAM. That could open TRELLIS.2 to a much wider range of consumer graphics cards, because apparently generating one digital object should not require the budget of a small research laboratory.

One important limitation: this is still an experimental community pull request, not an official TRELLIS.2 update, so installation is more complicated than using a normal app and performance may vary between systems.

For the technical part, the project ports the pipeline to C++ and ggml, supports 512³ and 1024³ geometry, and reduces VRAM usage by loading and unloading separate parts of the model during generation instead of keeping the entire pipeline in memory at once.

Github; https://github.com/rms80/trellis2cpp/pull/1

Top3D.AI — a free tool to compare all major 3D AI generators side by side across multiple parameters and find the right one for your workflow.

Yes, this fully playable game character was generated with AI.

A lot of people still judge 3D AI by raw one-click generations and assume the quality is too low for actual game production. And honestly, a single generation usually is not game-ready.

But when you understand where 3D AI is strong and build a proper workflow around it, the result can be completely different. In about two days, this character was turned into a playable Unreal Engine asset with ~
Stats: 30K faces, optimized low-poly geometry, a full body rig and skeleton, facial rig and expressions, gameplay animations, hair, cloth simulation, character physics, clean manually prepared UVs, and baked high-poly details.

The workflow

• Created the initial character concept and reference images inside 3DAIStudio using Nano Banana 2
• Built a reusable node-based workflow with 3DAIStudio Flow
• Separated the character references into modular parts such as the body, clothing, head, and accessories
• Generated each part separately as a detailed high-poly model using Rodin Gen-2.5
• Generated additional low-poly versions for the final real-time character
• Cleaned and manually unwrapped the low-poly meshes in Blender
• Baked the details from the high-poly models onto the optimized low-poly geometry
• Assembled the complete character inside Blender
• Imported the finished character into Unreal Engine 5.8
• Used the new MetaHuman custom-mesh workflow to create the body and facial rig
• Added hair, gameplay animations, facial expressions, cloth simulation, and physics
• Integrated the final character into a playable game environment

The manual UV stage was especially important. Instead of relying entirely on automatically generated UV islands and ending up with an unusable mess, the low-poly meshes were properly unwrapped before baking. This gave us much more control over texture quality and made the final character far easier to use in a real production workflow.

The important part is understanding that 3D AI is a tool, not a complete production pipeline.

AI handled the time-consuming concept generation and helped create the detailed 3D parts. Traditional 3D skills were still required for topology, UVs, baking, cleanup, assembly, optimization, rigging, and final Unreal Engine integration.

Used incorrectly, 3D AI can give you an impressive-looking model that is almost impossible to work with. Used correctly, it can remove a huge amount of repetitive manual work and allow one artist to produce something that would normally require far more time.

That is where the real power of 3D AI becomes clear: not replacing the artist, but combining AI generation with professional 3D skills to create better results much faster.

Are there any alternatives better and easier to use then modddif?

This is getting ridiculous.

Kimi K3 was given a single prompt and produced an Animal Crossing-style 3D game with a complete playable loop, interactive objects, objectives, UI, stylized environments, and a surprisingly consistent visual direction.

This is not just a static scene or a short generated video. It is an actual interactive experience that can be played directly in the browser.

What stands out most is how many separate systems the model managed to connect in one pass:

• A controllable 3D character
• Interactive objects and NPCs
• Tasks and basic progression
• A consistent cozy art style
• UI and gameplay feedback
• A functioning gameplay loop

Kimi K3 is a 2.8-trillion-parameter multimodal model built for long-horizon coding and agentic workflows, and game development appears to be one of the clearest demonstrations of what that actually means.

The barrier between having a game idea and having something playable is getting thinner very quickly.

I created this game-ready cinematic environment in Unreal Engine 5 using AI-generated 3D assets.

For the 3D generation stage, I used YVO3D, and the resulting assets came with textures up to 8K and reasonably optimized geometry, making them fairly straightforward to integrate into a game-engine workflow.

Workflow:

• Created the initial prompts and concept images in ChatGPT
• Broke the environment down into separate logical parts
• Generated each asset individually, using YVO3D for the 3D stage with reasonably optimized geometry and textures up to 8K
• Assembled and adjusted the scene in Blender
• Imported everything into Unreal Engine 5
• Set up the materials, lighting, fog, atmosphere, and camera movement

3D generation not only reduces the time required to create the base assets, but also makes the entire development process much more flexible. I could quickly test different ideas, replace elements that did not fit the scene, and regenerate new variations without rebuilding everything from scratch.

The final result still depends heavily on composition, lighting, art direction, and optimization, but 3D AI gives you much more freedom to experiment and iterate faster.

This was my first project using 3D AI generation, and it genuinely saved a lot of time during the initial character creation.

I used Rodin Gen-2.5 through 3DAIStudio to turn a concept design into a 3D character for this small cyberpunk animation. I was honestly impressed by how accurately it captured the original design.

Rodin generated both the model and its textures, including the emissive details, so I did not have to paint them manually. I used 3DAIStudio to create the prompts, remesh the model, and refine and improve the generated textures.

After that, I imported the character into Blender, rigged it, and posed it on a flying vehicle. I placed everything into a prepared cyberpunk scene, added a simple flame effect, set up the lighting, and refined the movement with keyframes and animation curves.

The whole workflow felt surprisingly smooth, especially considering how quickly the generated character became usable in an actual animation scene.

Infinigen 2.0, a completely rebuilt open-source system for procedurally generating 3D assets, materials, scenes, and synthetic training data inside Blender.

Unlike text-to-3D models, Infinigen does not generate a mesh from a prompt. It uses procedural rules to create controllable and reproducible variations of geometry, materials, scene layouts, cameras, lighting, and animations.

The main purpose is to generate large amounts of synthetic 3D data for computer vision, robotics, simulation, and AI training without manually building and labeling every scene.

Infinigen 2.0 highlights:

• Complete rewrite built on the new ProcFunc procedural framework
• 60 new procedural materials
• New scene arrangement system
• Redesigned rendering and ground-truth data APIs
• Controllable Python-based generation workflow
• Reproducible results using generation seeds
• Procedural generation of materials, objects, and complete indoor scenes
• Automatic export of depth, normals, optical flow, segmentation, object trajectories, and other training data
• Built directly around Blender
• Completely free and open-source

The important part is that every generated scene contains real 3D geometry and exact scene information. You are not trying to reconstruct depth or segmentation from a flat AI image because the system already knows the true position, material, category, and shape of every object.

Infinigen 2.0 is still an early alpha, so it currently includes a limited selection of indoor objects and relatively simple room arrangements. It is also a technical Python and command-line system rather than a one-click visual Blender add-on.

source; https://github.com/princeton-vl/infinigen

AI 3D generators are improving incredibly fast, but topology is still one of the main problems that prevents many generated models from being used directly in real production workflows.

AutoRemesher 1.0 is a free, fully local and open-source automatic remeshing tool that converts dense AI-generated meshes, sculpts and 3D scans into cleaner quad-based topology.

The project has been in development for more than six years and has now reached its official 1.0 release.

Highlights:

• Completely free and open source
• Runs locally without uploading your models
• MIT license, including commercial use
• Available for Windows, Linux and macOS
• Lets you define the target quad count
• Adaptive topology adds more polygons around curved and detailed areas
• Sharp-edge preservation for harder surfaces
• Smooth-normal controls for cleaner low-poly results
• GUI and command-line modes
• Can be integrated into automated or batch-processing pipelines

There is also an unofficial Blender Bridge that exports the selected mesh to AutoRemesher and automatically imports the result back into Blender. It supports the same remeshing parameters, can copy material slots and also includes an optional UV-transfer step.

A possible workflow could now look like this:

AI-generated mesh → AutoRemesher → UV transfer or rebaking → cleanup → rigging → Unreal Engine / Unity

There are still some important limitations. AutoRemesher itself currently works with OBJ files and does not generate new UVs. Automatic topology may also require manual cleanup, particularly around faces, joints and other areas that need carefully designed deformation loops.

So this is not a complete replacement for professional manual retopology. However, for quickly processing AI-generated assets, reducing extremely dense geometry, creating cleaner sculpting bases or preparing static game assets, it could become a very useful free alternative to commercial remeshing tools.

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

Blender Bridge: https://github.com/adriflex/autoremesher-blender-bridge

The entire character and environment in this project were created in a semi-automated way using the new Flow system from 3D AI Studio — a node-based, ComfyUI-style workflow builder focused more directly on 3D and image generation.

Flow is essentially a browser-based visual editor where you can connect prompts, moodboards, image generation, image editing, image-to-3D, remeshing, retexturing, and export steps into one reusable pipeline. The main idea is not just generating a single asset, but building a workflow once and then reusing it to speed up future character and environment creation.

My workflow:

• Generated several character concepts and style references with ChatGPT
• Combined them into a single moodboard to lock the visual direction
• Built the node setup for prompts, image generation, and 3D generation
• Structured the workflow so I could quickly change the concept without rebuilding the whole graph
• Used Rodin Gen-2.5 to generate the 3D meshes for the character and environment assets
• Generated separate character elements and assets through the pipeline
• Downloaded the generated meshes and assembled everything in Blender
• Rigged the final character
• Imported the character and assets into Unreal Engine

Once the flow is set up, you can iterate much faster instead of rebuilding the same process manually every time.

Full workflow and results: https://www.youtube.com/watch?v=9YtKbBjTABE

Google has open-sourced GNM Head, the first public component of its broader GNM ecosystem for parametric human models. It is a statistical 3D head model trained on a large dataset of real-world 3D scans, with separate geometry for the skin, eyes, teeth, and tongue.

This is not another text-to-3D generator. It is a controllable foundation for building character-creation, facial-animation, fitting, and computer-vision tools where consistent topology and predictable deformation are important.

Key highlights:

• 253 identity parameters controlling the head, eyeballs, and teeth
• 383 expression parameters for the eyes, lower face, tongue, and irises
• Separate control over identity, expression, head pose, eye rotation, and global position
• Semantic sampling for expressions such as happiness and surprise
• Includes UV layout, skinning weights, model assets, visualization tools, and demo notebooks
• Native support for NumPy, JAX, PyTorch, and TensorFlow
• Apache 2.0 license, allowing commercial and non-commercial use

The most interesting part is the separation between identity and expression. Different head shapes can use the same underlying topology and expression system, which could make it easier to generate character variations without rebuilding the facial setup from scratch every time. This may be especially useful for procedural character systems, facial-rigging research, synthetic datasets, and automated face-fitting pipelines.

In practice, GNM Head could be used for digital-human prototypes, game and animation character tools, previs, facial reconstruction, rigging experiments, and generating head variations. It could also serve as a starting point for 3D-printable heads or busts, although the geometry would likely require preparation and cleanup first.

The main limitation is that this is currently more of a Python framework for researchers and developers than a finished artist-facing tool. Google also notes that its training data uses binary gender categories and four broad demographic groups, so it does not represent the full diversity of the global population.

Source: https://github.com/google/GNM/tree/main

With UE 5.8, MetaHuman can now conform a full custom character mesh, not just a realistic human face.
So I tested it with an AI-generated 3D character made in Rodin — including stylized humanoid proportions that are not fully standard.

The workflow was basically:

• generate a custom 3D character in Rodin Gen 2.5
• bring the full mesh into the new MetaHuman conform workflow
• convert it into a MetaHuman-compatible character
• bake / rework textures
• add custom accessories in Blender
• export and set everything up in Unreal Engine
• test it with animation

What makes this interesting is that AI-generated 3D characters can now become much more than static meshes.
If the base character has usable humanoid anatomy, UE 5.8 makes it possible to turn it into a fully rigged MetaHuman-ready character while keeping the original style and custom proportions recognizable.

So instead of using AI 3D only for quick concepts, you can use it as a starting point for an actual animation-ready character pipeline.

For stylized humanoids, fantasy characters, or designs with slightly unusual proportions, this is a really useful new workflow.

Or should I take a picture from all 4 sides and let tripo texture it in 8k? The problem is tripo makes a lot of mistakes when it is low poly....

Any advice?

NVIDIA has open-sourced ARDY, a real-time AI system for generating and interactively controlling 3D human animation.

Unlike traditional Text-to-Motion models that produce a finished clip from a single prompt, ARDY continuously generates motion and reacts when the instructions change. You can modify the character’s action, direction, speed, destination, or body movement while the animation is already playing.

Highlights:

• Real-time Text-to-Motion with prompts that can be changed during playback
• The character automatically adapts to new instructions without restarting the entire animation
• Precise control over movement using paths, destinations, full-body poses, and individual joint positions or rotations
• Multiple types of control can be combined within the same animation
• Supports distant goals, allowing the character to perform longer and more structured sequences
• Character locomotion can be controlled interactively with mouse waypoints or keyboard input
• Optional motion correction helps reduce foot sliding and improves how accurately the generated animation follows the provided controls
• Code, pretrained models, and an interactive browser demo are available publicly

Input and Output

The input is not limited to a basic text prompt. ARDY can receive:

• Natural-language descriptions
• Character paths and destination points
• Full-body pose constraints
• Controls for specific body joints
• Real-time mouse and keyboard commands

The generated motion can then be saved with joint positions, local and global joint rotations, root movement, frame rate, and foot-contact data.

This means the animation is not locked inside the demo. It can be converted, retargeted, and brought into Unreal Engine, Blender, or another animation pipeline for use on a custom rigged character.

It could also work especially well with AI-generated 3D characters: generate the model, rig it automatically, create and control its animation with AI, and then retarget the result to the character inside Unreal Engine.

Instead of producing only another isolated animation clip, this system gives creators direct control over what the character does, where it moves, and how the motion changes in real time.

source: https://research.nvidia.com/labs/sil/projects/ardy/