Like many small teams, Odyssey Game Studios recently hit a massive bottleneck iterating on background props and mob enemies. Our art budget is tight, and our lead modeler is swamped.
We initially looked into cloud-based AI 3D generators to speed up the process, but we immediately hit two brick walls:
The Cost: Monthly API subscriptions and strict credit limits are a nightmare for a production pipeline.
The Privacy: Uploading proprietary concept art to third-party servers instantly violated our strict NDAs.
We needed a local solution. Running raw open-source models like Hunyuan3D-2 locally was the obvious alternative, but the raw Python scripts are incredibly clunky, rely on constant huggingface_hub pings, and the native outputs often lack engine-ready UVs.
So, I spent the last few months ripping apart the architecture to build a custom, fully localized C# wrapper around it. We call it Jupetar. Here is a breakdown of the tech stack and the absolute nightmare of managing local VRAM.
The Architecture & Pipeline
We needed this to be a frictionless desktop app for our artists, meaning no terminal windows and no Python environment hell.
The Core Engine: We are utilizing the Hunyuan DiT for geometry generation and the Paint VAE for texturing.
The Wrapper: A C# UI that sandboxes the PyTorch environment. I surgically killed the auto-heal scripts and cloud pings. It relies entirely on a physical 24GB local models folder. If you pull your ethernet cable out, it still generates perfectly.
Smart UVs: Raw AI geometry is notoriously messy. We integrated XAtlas for automated, engine-ready UV unwrapping directly within the pipeline.
Texture Upscaling: Because native DiT vertex colors are usually blurry, the pipeline intercepts the raw albedo, runs a VRAM-safe 4K tiled upscaler, and synthesizes a procedural PBR normal map locally before wrapping the final GLB.
Adaptive Decimation: We built in a decimation pass so the engine crunches the poly-count down to targeted limits (e.g., 25k faces for a weapon) before export, making it actually usable in Unity or Godot.
The Struggle: PyTorch VRAM Fragmentation
The absolute biggest limitation of running a local 3D pipeline is VRAM fragmentation. Loading a 4.8GB DiT model while simultaneously running a 4K upscaler and Nvdiffrast for rasterization is incredibly heavy.
We had to force PyTorch expandable segments just to prevent Out-Of-Memory crashes during the final high-res texturing phase. Realistically, benchmarking this on my own machine, it requires an RTX 3080 10GB (or any modern card with 8GB to 12GB+ of VRAM) to run smoothly without hanging.
Escaping the Subscription Trap
We built this to solve our own studio's problem, but we realize thousands of other indie devs are trapped in the exact same SaaS fatigue.
We’ve packaged the entire pipeline into a standalone desktop app and put it on Steam for a one-off, perpetual $45 license. No cloud credits, no subscriptions, and your data never leaves your local drive.
Valve is currently finalizing their review of the main build, and I've uploaded a free Demo version to the Steam page for Launch day. This demo build contains the full trial logic so you can benchmark the PyTorch architecture and test the VRAM limits on your exact hardware configuration before ever spending a dime.
Check out the Demo and the outputs here:
https://store.steampowered.com/app/4346660/Jupetar/
Top comments (0)