Mintforge

Turn reference photos into print-ready 3D wargaming miniatures — on your own GPU.

Local-first desktop app · NVIDIA GPU AI inference · no cloud, no per-model cost

---

Mintforge is a Windows desktop application for tabletop wargamers and modelers. Point it at reference photos of a tank, aircraft, ship, or figure, and it generates a 3D model using Microsoft TRELLIS 2 running locally on your NVIDIA GPU. Pick your resin printer and scale, add stowage and accessory parts, run pre-flight checks, and export a print.

Everything runs on your machine. After the model weights download once (~11 GB), Mintforge works fully offline. There is no subscription and no per-generation fee.

The dashboard showing an imported Tiger I mesh prepared for a 1:35 resin print. An interactive version of this layout lives at docs/dashboard-mockup.html.

How it works

┌──────────────┐   HTTP    ┌─────────────────────┐   local GPU
│ React UI     │ ───────►  │ Python sidecar      │ ───────────► TRELLIS 2
│ (Tauri shell)│ ◄───────  │ FastAPI :8765       │              (image → 3D)
└──────────────┘   GLB     └─────────────────────┘

• Tauri (Rust) shell — native window + installer, spawns and supervises the sidecar.
• React frontend — onboarding (printer → scale), a conversational edit thread, a multi-view reference grid, a live three.js 3D preview, a parts library, pre-flight checks, and a slice/export footer.
• Python sidecar — wraps TRELLIS 2 for image-to-3D, manages weight downloads, and (in later versions) handles boolean part merges and slicing.

Hardware requirements

	Minimum	Recommended
GPU	NVIDIA, 12 GB VRAM	NVIDIA RTX 5060 Ti 16 GB (the design target)
Driver / CUDA	CUDA 12.1-capable driver	latest studio driver
Disk	~15 GB free (weights + bundle)	SSD with 25 GB+
OS	Windows 10 x64	Windows 11 x64
RAM	16 GB	32 GB

A discrete NVIDIA GPU is required for generation. Without one the app still launches and the UI is fully navigable, but the Generate action is disabled and a banner explains why.

Build & run

See BUILD.md for the full toolchain setup. Quick version:

npm install                      # frontend deps
.\scripts\setup-windows.ps1      # build the GPU sidecar exe
npm run tauri dev                # run in dev (sidecar in a 2nd terminal)
# or
npm run tauri build              # produce the MSI / NSIS installer

Frontend-only preview (no Rust/Python, generation disabled):

npm run dev   # http://localhost:1420

What's tested vs. what isn't

I want to be straight about the state of this codebase, because parts of it depend on hardware and an upstream library I couldn't exercise here.

Verified working:

• The React frontend builds clean (vite build, 1500+ modules, no errors) and runs standalone. The full UI — onboarding, reference grid, three.js preview with the procedural Tiger I, parts that attach real geometry, pre-flight, footer — is interactive.
• The Python sidecar API is verified via FastAPI's test client: health degrades gracefully with no GPU, the printer→format slice mapping is correct, generation rejects empty requests (400), and unknown jobs return 404.
• All config (tauri.conf.json, Cargo.toml, package.json) is well-formed.

Not yet verified (needs a Windows + NVIDIA machine):

• The Rust/Tauri shell has not been compiled. It's written against the documented Tauri 1.5 API (Command::new_sidecar, CommandEvent, app_local_data_dir), but you'll want to run cargo check / npm run tauri dev to confirm in your environment.
• The TRELLIS inference paths are unrun. The import names, the Hugging Face repo id, the multi-image entry point, and the GLB export helper are written against the current microsoft/TRELLIS.2 repo and marked TODO:VERIFY in python-sidecar/trellis_runner.py. The upstream API is young; confirm against the version you install.
• VRAM: the spec targeted ~10 GB, but microsoft/TRELLIS.2-4B is a 4 B parameter model and is heavier than the original TRELLIS-image-large. If 16 GB is tight, see the fallback options in python-sidecar/README.md.

Stubbed for v1 (returns a sensible response, logic to be filled in):

• /edit/add-part — the boolean union of accessory parts onto a generated mesh. The frontend already attaches real part geometry to the procedural preview, so the flow is exercised end to end.
• /slice — shelling out to PrusaSlicer + UVtools for the printer-native format. The endpoint returns the correct target format per printer.

Repository layout

mintforge/
├─ src/                 React frontend (App.jsx is the whole UI)
├─ src-tauri/           Tauri (Rust) shell, config, icons, sidecar binaries
├─ python-sidecar/      FastAPI + TRELLIS wrapper
├─ scripts/             setup-windows.ps1 (builds the sidecar exe)
├─ BUILD.md             full build instructions
└─ README.md           you are here

License

MIT — see LICENSE.