# I got TRELLIS.2 + real 4-view fusion running in 8 GB VRAM — code is now Apache 2.0 — retained record

> Retained reddit record from reddit:ClaudeCode.

Canonical: https://highsignal.app/data/records/36c2973f5e60aa57

[← sources](https://highsignal.app/data)


source: [reddit](https://highsignal.app/data/reddit) (reddit:ClaudeCode)  published 2026-09-10 18:09 ingested 2026-09-11 02:42

[original source ↗](https://www.reddit.com/r/ClaudeCode/comments/1wcqy6l/i_got_trellis2_real_4view_fusion_running_in_8_gb/)

## retained text



```
Quick one: I've been working on LocalMesh, a desktop app that turns photos into 3D objects locally, and I've now open-sourced the generation engine under Apache 2.0.

GitHub: [https://github.com/Quentincls/localmesh-engine](https://github.com/Quentincls/localmesh-engine)  
Technical details: [https://local-mesh.com/localmesh-engine/](https://local-mesh.com/localmesh-engine/)

Give it one photo, or four views (front / right / left / back), and it outputs a textured, UV-unwrapped `.glb` that you can open directly in Blender or Unreal.

Everything runs locally on an NVIDIA GPU. No API key, no cloud processing, and the photos never leave your machine.

For transparency: the heavy lifting comes from Microsoft's TRELLIS.2. I didn't train a new foundation model.

What I mainly worked on around it:

* **Actual 4-view fusion.** The views are fused at the sparse-structure stage using Pixal3D weights from TencentARC, converted to FP8. It's not four independent generations averaged together afterward.
* **Automatic camera estimation.** Depth Anything 3 is used to estimate the relative camera/view angles, so you don't have to manually specify that a photo is, for example, the left side at exactly 90°.
* **Position-aware floater removal.** Small geometry attached to the surface is preserved while disconnected junk farther away from the object is removed.
* **Cleaner glTF materials.** Metalness is set correctly, alpha modes are handled properly, and double-sided rendering is enabled only when the mesh actually has open boundaries.
* **8 GB VRAM support.** FP8 weights, staged model loading and an adaptive token budget allow the full pipeline to run on relatively small NVIDIA cards.
* **No nvdiffrast / GPL dependency.** I rewrote the UV rasterization in plain PyTorch, so the complete engine can be used commercially under Apache 2.0-compatible terms.

On my RTX 4060 Laptop 8 GB, using four photos:

**Standard:** \~6:30–8:30  
**Detailed:** \~9–13 min

Around 60% of the total generation time is currently texturing.

A few caveats: this is the engine, not a polished one-click installer.

You'll need Python 3.12, PyTorch 2.8 + CUDA 12.8, and three CUDA extensions that need to be compiled (`o_voxel`, `cumesh`, `flex_gemm`). DINOv3 also requires manual access approval on Hugging Face.

Disk usage is roughly 10–14 GB.

Windows + Linux, NVIDIA only.

If you just want to try the workflow without setting all of that up, the LocalMesh desktop app wraps the same engine with a board, asset library and 3D viewer. It has a 14-day free trial, then it's a one-time purchase with no subscription:

[https://local-mesh.com](https://local-mesh.com)
```



document fetched 2026-09-11 00:42 · canonical https://reddit.com/r/ClaudeCode/comments/1wcqy6l/i_got_trellis2_real_4view_fusion_running_in_8_gb
