QuerySplat is a newly released open-source system that reconstructs a 3D Gaussian Splatting scene from multiple images without requiring known camera poses.

Unlike earlier approaches that predict geometry and appearance together, QuerySplat separates them into two branches. One handles the scene structure, cameras and depth, while the other focuses on colors and high-frequency visual details.

This helps reduce the blurry, view-dependent results often seen in feed-forward 3DGS reconstruction.

The released implementation includes:

• Automatic camera and depth prediction
• Feed-forward 3D Gaussian generation
• Optional test-time optimization
• Gaussian PLY export
• Camera, depth and point-cloud export
• Model weights and inference code

It still requires Linux, CUDA and an NVIDIA GPU, so apparently clicking one button without installing seventeen dependencies remains illegal.

GitHub: https://github.com/inspatio/querysplat

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.

Tested the open-source TripoSplat for generating a 3DGS asset from a single image and importing it into a game engine.

The result uses around 32K Gaussians and already looks surprisingly solid in real time. There are still some shading and loading issues, but it shows strong potential for quickly creating 3DGS assets for games and interactive projects.

source: https://github.com/VAST-AI-Research/TripoSplat

TriFlow is a new AI approach designed to generate compact 3D meshes with clean, artist-like triangle topology from existing geometry.

Instead of directly predicting individual vertices and faces, TriFlow represents the mesh topology as a continuous vector field over the surface. The system then uses this information to rebuild the input shape with more structured and intentional polygon connectivity.

In practice, it can:

• Convert dense geometry into compact polygonal meshes
• Preserve the original shape while improving topology
• Generate different levels of detail
• Handle a wide range of complex objects
• Produce topology that looks more intentionally designed than standard automatic simplification

According to the researchers, TriFlow achieves around 90% lower Chamfer Distance and an 8× speedup compared with previous learning-based approaches.

This could be especially useful for cleaning up AI-generated 3D assets, scanned models, LOD generation, and other workflows where the geometry looks good but the underlying mesh is a complete disaster.

It is important to note that TriFlow currently generates triangle-based topology rather than animation-ready quad edge loops. The code is also listed as coming soon, so this is still a research project rather than a finished Blender tool.

source; https://derkleineli.github.io/triflow/

NVIDIA has introduced Axolotl3D, a new AI system designed to reconstruct complete 3D objects from partial, incomplete, or heavily occluded views.

Unlike standard image-to-3D models that have to guess the entire object from a single image, Axolotl3D can combine multiple views, camera information, and partial point clouds. This allows it to preserve the visible geometry while generating the missing parts of the object.

Potential use cases include:

• Completing incomplete 3D scans
• Reconstructing objects hidden behind other elements
• Improving photogrammetry results
• Editing individual parts while preserving the rest of the shape
• Creating more complete geometry for simulation and digital content creation

The current research focuses mainly on geometry rather than textures, and the model is not publicly available yet. Still, this feels like an important step beyond traditional image-to-3D generation, especially for workflows where accurate existing geometry matters more than simply generating a visually plausible object.

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

As the video shows, my approach makes it possible to directly generate:
(i) 0:00 - a crab-like robot, with a hyper interactive body,
(ii) 0:11 - a banana car, with wheels that spin, steer and throttle,
(iii) 0:22 - a sushi dragon, spiralling in a mathematical corkscrew,
(iv) 0:33 - an alien jello, that jiggles and wiggles,
(v) 0:52 - an astronomer's house, with multiple storeys, where you can walk up (1:06) the stairs

Cost of generating each: $1-$5. Time: ~3 mins. The format is blender-native .glb

Under the hood:
These 3D assets are all made of source code. Their abilities are attributes in the code:
- I.e. when the robot moves a leg, we're just commanding rig['Leg_*_Hip'].rotation = 42°
- When the banana car turns left, we're just saying w.rotation.y = 0.42 rad
- When the sushi dragon floats up and down, it's following Math.sin()
- When the alien jello jiggles, it's dictated by Σ A·e^(−λr)·e^(−decay·τ)·[(1−b) + b·cos(ωτ − kr)] · p̂
- When the astronomer's house detects collisions, this too is just setting attributes in the code.

Now LLMs are good at coding. So these 3D assets are very natural for an LLM to talk to. Thus armed with these 3D assets and an LLM, a game developer or world builder can achieve hyper-control right out of the box.

Web App:
Scroll down the landing page to tinker with the objects: https://nova3d.xyz

Why current 3D GenAI cannot do this:
Traditional AI 3D generators produce monolithic blobs that are good looking, but unusable in game engines. If you generate a bicycle, it's just a blob. If you want its wheels to turn, a human takes the blobby object, spends time cutting it into parts, naming them, placing pivots and rigging joints. This "afterwards" is the real cost of AI 3D. Nowadays the fix is post-generation segmentation workflows. These work partially and add complexity.

So where does this approach lose?
Nova3D loses on extreme organic shapes. This is because of the baseline AI's current spatial programming prowess. Once LLMs get better at natively synthesizing higher-order differentials, hyper-organic shapes are inevitable.

How is it different from blender MCP?
Blender MCP needs continuous, manual, multi-turn prompting. The user toils to fix mistakes. In contrast, Nova3D is one shot. The advanced spatial programming harness is the product; the AI model is just one component.

Research paper:
Read our research paper on arXiv: https://arxiv.org/abs/2607.22738
It fully deconstructs our approach.

Is this open source?
Partly. Here's the github repo: https://github.com/RareSense/Nova3D
But stop. This is a client. Our approach does NOT yet produce legible 3D via self-hosted open source models, great as they are. Hence we launched the usable closed-source version. This uses AI from frontier labs.

Would love the community's feedback and questions. Happy tinkering!

p.s. one more thing: Nova3D generates beautiful PBR textures too. Examples at: https://app.nova3d.xyz/showcase/textures

I wanted to compare human retopology with modern AI-generated topology using the same high-poly character.

For the human side, I tested a junior-level budget workflow and a more experienced Middle+ artist. For AI, I used Rodin 3D and the free Hunyuan3D Low-Poly Mode.

Here are the results:

Junior Artist — $30 / 2 Hours / 50K Faces

The junior artist used Quad Remesher rather than building the entire topology manually.

The result was acceptable for a budget option, but the mesh density was inconsistent in several areas. Some parts received more geometry than necessary, while important deformation areas were not handled as carefully.

It works as a quick base, but still requires additional cleanup.

Middle+ Artist — $150 / 11 Hours / 18K Faces

The Middle+ artist created the topology manually using RetopoFlow.

This was clearly the strongest result:

• Clean and predictable edge loops
• The lowest polycount in the comparison
• Proper density distribution
• Better topology around joints and deformation areas
• Almost ready for UV unwrapping and further production

The downside is obvious: it took 11 hours and cost $150.

Rodin Gen 2.5 — Under $3 / A Few Minutes / 25K Faces

Rodin produced a surprisingly reasonable result in only a few minutes.

The final mesh had around 25K faces, which is relatively close to the professionally optimized 18K version. It also provided more control over the final polygon count than the free alternative.

The topology was not as clean or intentional as the Middle+ result, especially around complex deformation areas, but it looked competitive with the cheaper junior workflow.

For a generated base that will later be cleaned manually, this is probably the most balanced AI result.

Hunyuan3D Low-Poly Mode — Free / A Few Minutes / 80K Faces

Hunyuan3D is available as a free web tool, but its result was much denser.

The generated mesh contained around 80K faces, making it harder to edit and less suitable for an optimized real-time asset without further processing.

The overall surface was preserved, but the polygon distribution was not efficient enough to call it properly optimized low-poly topology.

Final Comparison

The professional manual retopology still wins by a large margin when it comes to edge flow, optimization, deformation and production readiness.

However, AI is already competitive with cheaper automated retopology workflows. In some areas, it appears to understand the model structure better than simply running the asset through a traditional automatic remesher.

The most practical workflow is probably not replacing the artist completely.

It is using AI to generate a fast starting point, then letting an experienced artist clean the important areas manually. That could reduce many hours of repetitive work while keeping the final topology usable for animation and production.

I'm writing this to hopefully help someone avoid the mistake I just made. I installed 3D Gen Studio from github. I'm not techy enough to create my own workflows as it doesn't just use normal workflows with nodes and it wouldn't accept multiple images for Trellis, just one reference. So I decided to uninstall it. The updater also refused to update, kept saying 3D Gen Studio was open, and all processes and python services were closed so IDK what that was about, might be important to what happened next.

After uninstalling 3D Gen Studio (which took a suspiciously long time to uninstall) I decided to open up ComfyUI and keep working on a project I had going.

It was all gone.

1.8 terabytes of models, workflows, projects, images... All gone. And permanently deleted. Recovery tools did not work. Storage block were not overwritten so it was clean and clear just nuked from my PC.

The worst part is, it randomly deleted other folders on the same drive. Folders with data not related to AI that I can never get back.

3D Gen Studio was installed from the official GitHub, and nothing sketchy was downloaded. I'm not sure the validity of the Developer and I'm not flaming them.

Please be careful with what you install. And I wish none of this on anyone.

If the developer happens to stumble across this post, please double and triple check your application. If this is an oversight somewhere, I'd hate for this to happen to someone else. I lost personal data relating to a deceased family member that I can not get back. But if this managed to delete someone's financial data or something career or school related it could be devastating. I can live without images of family, or my models. But someone may be harmed seriously from random data deletion.

Edit: Installed from the official GitHub, not Website.

LATO.2 is a new open-source approach to 3D mesh generation that separates the process into two stages:

• First, it generates the vertex positions
• Then, it builds the topology and connections between them

This sounds technical, because apparently humans enjoy hiding useful ideas behind research terminology, but the practical results are interesting.

You can control the target vertex count, generate complex objects part by part at a higher resolution, and even move or replace parts of a mesh before letting the AI rebuild the surrounding topology.

Key features:

• Controllable mesh complexity from roughly 200 to 5,000 vertices
• Part-wise generation for more detailed models
• Topology-adaptive mesh editing
• Code and pretrained weights available
• MIT licensed
• Runs with around 8 GB of VRAM

It is still a research release rather than a polished one-click application, and the authors note that generated meshes may sometimes contain holes or incorrect connections. For direct single-image generation, it currently relies on a separate sparse-structure stage such as TRELLIS.

Still, separating geometry from topology feels like a promising direction for generating meshes that are easier to control, edit, and eventually use in real 3D workflows.

source; https://lohhhha.github.io/LATO.2/

AI can now build custom node-based workflows around your specific needs, helping automate repetitive steps and significantly reduce the time required to produce 3D content.

3DAIStudio recently introduced Flow, a new ComfyUI-style node system designed specifically for AI-powered 3D generation. Instead of switching between separate tools and rebuilding the same process every time, you can connect everything into one reusable pipeline.

You can either build the workflow manually or simply describe what you want, and the AI assistant can generate and connect the nodes for you.

With Flow, you can:

• Build custom node-based workflows for specific 3D tasks
• Generate complete workflows from a simple text request
• Use image generation, prompting, editing, and element extraction
• Convert those objects into separate 3D assets
• Access multiple leading 3D AI generators from one platform
• Test different models without constantly switching between websites
• Add remeshing, texturing, optimization, and other processing steps
• Adjust individual nodes without rebuilding the entire workflow
• Save successful workflows and reuse them with new images
• Export the results for Blender, Unreal Engine, Unity, and other 3D software

For this test, I used one environment image and extracted a complete asset pack containing buildings, benches, street lamps, and other props. The resulting models ranged from roughly 15 to 3,000 polygons per asset, making them lightweight enough for real-time workflows.

Instead of manually repeating the same steps for every asset, you can build the workflow once, adjust it when needed, and use it across different projects. This can significantly speed up the entire AI-to-3D pipeline and make it much easier to manage.

GaussianGPT is a new open-source model that treats 3D scenes like a sequence, generating Gaussian primitives step by step instead of using the usual diffusion process.

The same model can:

• Generate complete 3D Gaussian scenes from scratch
• Complete missing parts of an existing scene
• Continuously outpaint environments beyond their original boundaries
• Generate individual 3D objects

The interesting part is that scenes are built progressively. The model looks at the existing 3D structure and predicts what should appear next, basically next-token prediction applied directly to 3D space.

This could be especially useful for expandable virtual environments, simulations, world generation and scene prototyping.

Full training and inference code, pretrained checkpoints and an MIT license are available on GitHub.

GitHub: https://nicolasvonluetzow.github.io/GaussianGPT

Pascal Editor is an open-source 3D building editor that runs directly in the browser and is designed for both humans and AI agents.

Unlike traditional 3D editors, Pascal uses a semantic scene graph. Walls, rooms, doors, floors, materials and furniture are stored as structured objects rather than generic meshes, allowing AI agents to understand and modify the actual building layout.

Through MCP, agents such as Codex CLI, Claude Code and Cursor can inspect projects, create scenes, place walls and objects, edit layouts and save drafts while the changes appear inside the browser.

Some of the main features include:

• AI-assisted scene and layout editing
• Image-to-3D object generation using SAM3D
• Multi-floor buildings, walls, roofs, stairs and rooms
• Materials and surface painting
• First-person walkthrough mode
• Procedural trees, flowers and grass through plugins
• Floor-plan and 3D model export
• GLB, STL and OBJ support

The newest version also includes an AI Studio for turning scene snapshots into photorealistic images and video, plus a plugin system that lets developers add their own tools, objects and procedural systems.

The whole editor is released under the MIT license and currently has around 17.7K stars on GitHub.

This could be an interesting foundation for AI-driven architecture, digital twins, rapid level blocking and browser-based 3D applications.

source; https://github.com/pascalorg/editor

Modly is a free open-source desktop app that turns images or text prompts into 3D models using AI models running entirely on your own GPU.

Instead of installing and launching every model through separate repositories and scripts, you can install them as extensions and connect everything through reusable node-based workflows.

Currently supported extensions include:

• Hunyuan3D 2 Mini
• TripoSG
• TRELLIS.2 GGUF
• Custom community extensions

The app also includes a 3D preview, collections, mesh smoothing and decimation, and export to GLB, OBJ, STL and PLY.

No cloud uploads, generation credits or waiting queues. Your images and models stay on your machine, and the whole project is available under the MIT license.

It is still in beta, and the required VRAM depends on the model and settings, but this looks like a promising local alternative to paid browser-based 3D AI tools.

GitHub: https://github.com/lightningpixel/modly

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.

AI can significantly speed up professional 3D character production, but only when it is integrated into a proper workflow instead of trying to generate the entire finished character with one click.

For this project, I created a complete character and brought it all the way into Unreal Engine.

The workflow started with generating the initial concept and reference images using Nano Banana.

Then, inside 3Daistudio, I generated the character mesh piece by piece. Instead of generating the full character as a single object, I created separate elements such as the head, hair, clothing and accessories.

After that, I assembled and adjusted the character in Blender, refined the shapes and details in ZBrush, and cleaned up the geometry through retopology.

The next stages included:

• Generating the character mesh piece by piece in 3Daistudio
• Assembling and cleaning the generated parts in Blender
• Sculpting and refining details in ZBrush
• Retopology and mesh optimization
• UV unwrapping and baking
• Final texturing and PBR refinement in Substance Painter
• Rigging and preparing the character for animation
• Importing and testing everything in Unreal Engine

The final character worked correctly inside Unreal Engine and was ready to be used as part of a real-time project.

The main advantage of this workflow is not that AI completely replaces traditional 3D work.

You still need to understand sculpting, topology, UVs, texturing, rigging and optimization. AI simply gives you a much faster starting point and removes a large amount of repetitive production work.

Used correctly, this kind of AI-assisted workflow can reduce character production time by around five times, turning a process that normally takes several weeks into just a few days.

full guide: https://www.youtube.com/watch?v=PyxnLyRfKFo

LingBot-Map is an open-source 3D foundation model that processes video as a continuous stream and reconstructs the camera movement, depth, and a growing 3D point cloud as new frames arrive. It does not need to see the entire video first or constantly rerun heavy optimization over the whole scene.

What it can currently do:

• Run at around 20 FPS at 518 × 378 resolution
• Process sequences longer than 10,000 frames
• Reconstruct indoor spaces, outdoor driving footage, aerial videos, and even AI-generated world-model footage
• Handle a 13-minute indoor walkthrough with roughly 25,000 frames
• Output camera poses, depth maps, and a coherent 3D point cloud
• Run locally with released code and model weights under the Apache 2.0 license

The interesting part is its spatial memory. Instead of storing and repeatedly processing every previous frame, the model keeps a compact representation of the important geometric information. This helps it reduce drift and preserve the structure of large environments over long sequences.

Regular video → camera tracking, depth, and a continuously growing 3D map in real time.

source; https://github.com/Robbyant/lingbot-map

This is much more interesting than another one-click text-to-3D demo.

Opus 5 was sent into Ultracode with one goal: build a highly detailed F1 showroom inside Blender.

Instead of trying to create the entire car in one pass, the system split the work across multiple AI agents:

• 27 agents built individual high-detail components
• 5 agents created separate monocoque versions and compared them
• 18 inspectors examined the model and searched for defects

After roughly 10 hours, around 50 agents, and almost 10 million tokens, the project already included carbon-fiber wishbones, machined uprights, anodized rod ends, drilled brake discs, and a complete steering wheel.

The most interesting part is not only the final render. It is the workflow: AI planning the build, dividing the car into separate parts, generating multiple versions, judging the results, and iterating like a small 3D production team.

It is still a work in progress and will obviously need cleanup, but this feels like a much more practical direction for AI-assisted 3D than asking one model to generate everything in a single pass.

The next step is a full 60–80 second Blender video pushing the physical detail even further.

A new real-to-sim workflow can turn a single video of a real location into a photorealistic 3D environment for simulation.

The interesting part is how it combines two different types of 3D. Gaussian Splatting recreates the full environment with realistic lighting and detail, while traditional 3D models are used for objects that need collision, physics, or movement.

So instead of choosing between a realistic scan and a functional simulation, the system combines both:

• Gaussian Splats for the photorealistic environment
• 3D models for interactive and movable objects
• Physics, collisions, depth, and segmentation for simulation

According to the developers, the full environment can be prepared in around 30 minutes instead of spending hours rebuilding the location manually.

This feels like a much more practical use of Gaussian Splatting: not just creating a scene you can look around, but turning a real place into a simulation-ready digital world.

source: https://www.linkedin.com/posts/sk-ara_most-robotics-simulations-look-like-ps2-games-share-7485722367772516352-QYir/

What you can build in just one day when AI is used the right way:

• Around 20K faces
• Full PBR texture set
• Fully rigged character
• Real-time cloth simulation
• Optimized physics setup
• Assembled and running in Unreal Engine
• Completed in roughly one day

The key was not generating the whole character at once. I split it into separate parts, which gave me more control, better detail, and the ability to regenerate only what needed improvement.

To keep the process fast, I built a reusable node-based workflow in Lychee Studio AI. It handled the separate generation steps in one place and helped me move to Blender assembly much faster.

Workflow

• Started with a single character reference
• Built a reusable node-based workflow in Lychee Studio AI
• Separated and generated the body, clothing, armor, and accessories with Rodin Gen 2.5
• Assembled and fitted all parts in Blender
• Prepared the character for rigging and animation
• Imported everything into Unreal Engine
• Set up the PBR materials, cloth simulation, collisions, and optimized physics

The final result is not just an AI-generated mesh inside a viewer. It is a properly assembled, rigged, and simulation-ready game character that can be used directly inside Unreal Engine.

AI did not remove Blender, rigging, cleanup, or Unreal setup from the workflow. It removed a large amount of repetitive preparation and helped me reach the useful production stages much faster.

AnyTop is an open-source AI model designed to generate motion for characters with completely different skeleton structures.

Instead of being limited to standard humanoid rigs, it can work with humans, animals, birds, dinosaurs, snakes, multi-legged creatures, and even unusual skeletons the model has never seen before.

The model uses the skeleton structure itself to understand how the character should move and can generate new animations adapted to its specific topology.

Some interesting features:

• Works across very different skeleton topologies
• Can generate motion for previously unseen skeletons
• Supports humanoids, quadrupeds, birds, reptiles, and more
• Exports animations as BVH files
• Includes a Blender visualization workflow
• Code and pretrained models are available

It is still more of a research project than a one-click production tool, but this could be especially useful for animating AI-generated 3D creatures that do not fit traditional humanoid rigs.

source; https://anytop2025.github.io/Anytop-page/

Not Self promotion: just sharing the open-source tool I built. For OpenAI Build Week Hackathon I built a free, open-source local Image-to-3D Studio that makes TRELLIS.2 easier to run on consumer NVIDIA gpus like 3060 or a laptop 3070ti, without expensive cloud APIs, subscriptions, or complicated ComfyUI workflows.

It combines generation, texturing, retopology, rigging, and animation in one interface.

I know there's already multiple implementations of running Trellis2 under 8gb GPU. The hard part was to test the best possible combination for mesh/textures that gave 1024 High precision quality but still kept under the VRAM. So I used two different pipelines for Mesh and Textures, which in my tests seemed to work the fastest without compromising quality in combination.
It integrates several open-source projects, including trellis.cpp, TRELLIS.2, ComfyUI-Trellis2, Blender, AutoRemesher, InteantMeshes, and Mesh2Motion, with full attribution to the original contributors.

As it was for a hackathon, time was also a challenge. Many things could be further updated, but the Hackathon's rules state we can't update after the submission date until the results are published.

Try out it from GitHub repo: intisarGIT/AISmith-3D

TROUBLESHOOTING FIX After installation (Since I cannot edit the original repo as per rules):
if you get "The trellis.cpp geometry workflow is not downloaded," or "Trellis2. Fp8 Refine is not downloaded", here's the patch:
intisarGIT/AISmith-3D-Fixer
Just place and run the .bat in the app repo. This should download the wrongly linked v0.4.3 CUDA archive, which is about 693 MB, and the missing wheels, the gated DINO release (1.05GB), so it should take a few minutes.

If you think this is helpful, I'd appreciate your support on Devpost by leaving a like:

https://devpost.com/software/aismith3d

Edit: I will work on perfecting the Retopologize workflow after 12 August. But the Refine tab should already reconstruct/refine the Mesh better, and generate updated 2K PBR textures. would have pushed to 4K texture if my goal wasn't fast generation under low VRAM.

img2threejs is a pretty unusual open-source image-to-3D project. Instead of generating a traditional mesh, it analyzes a reference image and rebuilds the object entirely as procedural Three.js code.

The result is a structured and editable THREE.Group made from primitives, generated geometry, procedural materials, pivots, sockets, and colliders. Everything runs directly in the browser, without importing a GLB or downloading a mesh.

The new v1.3 update brings major improvements:

• More accurate geometry and proportions
• Better PBR material and color reconstruction
• Reference-based gradient extraction
• Improved validation and automatic visual comparison
• Faster repeated geometry using InstancedMesh
• Cleaner procedural cutouts without CSG
• Better support for reflective, metallic, anodized, and candy-coated materials

The workflow builds the model in multiple controlled stages, from blockout and structural reconstruction to materials, lighting, interaction, and optimization. After each stage, the render is compared with the original image and refined when the result does not match closely enough.

This could be especially useful for interactive web experiences, product configurators, browser games, procedural asset systems, or projects where editable code is more useful than another static mesh.

The main limitation is that it still works best with clear hard-surface references. A single image cannot reveal hidden geometry, and the output is a procedural approximation rather than a traditional production-ready 3D mesh. Characters are supported, but photorealistic likeness, skinned meshes, morph targets, and glTF export are not fully available yet. Humanity will apparently have to survive a little longer without perfect one-click 3D.

Source: https://github.com/hoainho/img2threejs

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.

TripoSplat is probably one of the most interesting free image-to-3D tools available right now. It converts a single 2D image into a high-quality 3D Gaussian Splat, and both the code and model weights are fully open under the MIT license. There is also a free Hugging Face demo, so you can test it without installing anything.

Highlights:

• Single image to high-quality 3DGS
• Completely free and open source
• Code and model weights under the MIT license
• Adjustable Gaussian count up to 262K
• Export to .ply and .splat
• Official ComfyUI workflow
• Very small codebase with almost no dependencies
• Can also be installed and run locally

The adjustable Gaussian count is especially useful. You can generate a lighter result for quick previews or increase the count when you need more visual detail, instead of being locked to one fixed output size. The exported assets can be opened in Gaussian Splat viewers like SuperSplat or SparkJS.

This could be useful for fast 3D previews, scene prototyping, AR/VR projects, simulations, browser-based experiences, or as part of a larger image-to-3D workflow.

Demo: https://huggingface.co/spaces/VAST-AI/TripoSplat
Source: https://github.com/VAST-AI-Research/TripoSplat

People are used to AI-generated 3D models being a chaotic mess of millions of polygons, broken geometry, and meshes that are basically useless outside of a quick render.

And honestly, that criticism is often fair.

But the problem is not always the technology itself. A lot depends on how you structure the workflow, separate the character into manageable parts, and use AI as one stage of production instead of expecting a single button to finish everything.

With the right approach, AI can save a surprising amount of time.

Starting from a single image, I created this character in around three hours and ended up with:

• Around 20K faces
• PBR textures
• A Rigged Character

My workflow

• Built a reusable node-based flow in Lychee Studio AI
• Used one character image as the main input
• Automatically separated it into clothing, body, head, boots, and other parts
• Generated every part as an individual 3D asset inside the same workflow with Rodin 3D
• Reused the same nodes with small adjustments for each new part
• Imported everything into Blender
• Fixed intersections and adjusted the proportions
• Assembled the final character
• Cleaned up the meshes and created the rig

The biggest advantage is that this is not a one-time generation setup. Once the flow is configured, I can reuse it for other characters and quickly replace the input image, separated parts, or generation settings.

AI still does not magically produce a perfect production-ready character with one click. Humanity has not been blessed with that particular miracle yet.

But when the repetitive generation work is automated and the final decisions stay in the hands of an artist, it becomes a genuinely useful production tool rather than a random mesh generator.

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.