# Local 3D generation

> Local 3D generation Runtime: trellis.cpp, ein C++-Port von Microsoft TRELLIS.2, verwandelt ein Bild auf deiner eigenen NVIDIA- oder Vulkan-GPU in ein texturiertes 3D-Modell (GLB mit PBR-Materialien) – ohne Kosten pro Modell. Führt die Modellpakete TRELLIS.2 4B und Pixal3D aus, die separat installiert werden. Windows; Linux als Preview.

- Id: `aigd.trellis`
- Quelle: Offiziell (First-Party `aigd.*`)
- Kategorie: 3D
- Herausgeber: AI Game Dev (`aigd`), verifiziert
- Neueste Version: 1.0.3 (veröffentlicht am 2026-11-22)
- Lizenz: MIT
- Erfordert die AI Game Dev App: `>=0.32.0-beta.6`
- Nativer Code: nein
- Bewertung: noch nicht bewertet
- HTML-Seite: https://ai-game.dev/de/packages/aigd.trellis

## Installieren

Mit der gamedev CLI im Projektordner:

```bash
gamedev pkg add aigd.trellis
```

In der Desktop-App: Öffne das Fenster Packages (das Paket-Symbol in der Statusleiste), wähle **Browse**, suche nach `aigd.trellis` und klicke auf **Add to Project**. Mehr: https://ai-game.dev/docs/wiki/app/packages

## Versionen

| Version | Veröffentlicht | Erfordert App | Hinweise |
|---|---|---|---|
| 1.0.3 | 2026-11-22 | `>=0.32.0-beta.6` | neueste |
| 1.0.2 | 2026-11-21 | `>=0.32.0-beta.6` | - |

## Beschreibung

````markdown
# Local 3D generation (`aigd.trellis`)

Local 3D generation ist die Runtime, die mit [trellis.cpp](https://github.com/pwilkin/trellis.cpp), einem C++/GGML-Port von Microsoft TRELLIS.2, aus einem Bild ein texturiertes 3D-Modell (GLB mit PBR-Materialien) auf diesem Computer und deiner eigenen GPU erzeugt. Alles entsteht auf deinem Computer, und das kostet nichts. Das Paket enthält selbst kein Modell: Es führt die 3D-Modellpakete [TRELLIS.2 4B](https://ai-game.dev/packages/aigd.model3d-trellis2-4b) und [Pixal3D](https://ai-game.dev/packages/aigd.model3d-pixal3d) aus. Es eignet sich für Entwickler mit einer NVIDIA- oder Vulkan-GPU, die texturierte 3D-Assets ohne Cloud-Dienst wollen.

## Was du erstellen kannst

Mit einem installierten Modellpaket:

- Texturierte, PBR-fertige Props, Waffen, Möbel, Fahrzeuge und Charaktere aus einem Bild.
- 3D-Versionen von Concept Art oder Fotos realer Objekte.
- 3D aus Text in zwei Schritten: Erzeuge das Bild mit einem lokalen oder Cloud-Bildmodell und wandle es dann in 3D um.

## Beispielanfragen

- „Verwandle `Concepts/crate.png` in ein texturiertes 3D-Modell.“
- „Erstelle ein Bild von einem hölzernen Marktstand und verwandle es dann in ein 3D-Modell.“
- „Erzeuge aus diesem Foto mit Pixal3D ein 3D-Modell mit Auflösung 1024.“

## Highlights

|  |  |
|---|---|
| Runtime | trellis.cpp v0.8.1 (MIT) |
| Funktion | Bild zu texturiertem 3D (GLB, PBR-Materialien) |
| Modelle | separate Pakete: TRELLIS.2 4B (ca. 16.5 GB), Pixal3D (ca. 14.5 GB) |
| Windows | NVIDIA GPU (CUDA 13) oder AMD / Intel / andere GPUs (Vulkan) |
| Linux | x64 mit NVIDIA (CUDA 13) oder Vulkan, Preview |
| macOS | nicht angeboten (kein Upstream-Build) |
| Download | 14–16 MB (Vulkan) oder 715 MB (CUDA, mit der NVIDIA-Runtime) |
| Lizenz | MIT; jedes Modellpaket nennt seine eigene Lizenz |

## Wie es läuft

Dieses Paket enthält nur Daten (`aigd-package.json`, kein Code). Es sagt AI Game Dev, welches trellis.cpp-Release für deinen Computer heruntergeladen werden soll. Die App lädt das Programm selbst herunter, prüft es und führt es aus. Der Schalter **3D Gen** ist aus, bis du ihn einschaltest.

Ein 3D-Modell teilt sich die eine lokale GPU-Warteschlange mit lokalen Bildern, Clips und Sprache: Es läuft immer nur ein Modell gleichzeitig, und ein 3D-Job wartet auf das Bild oder den Clip vor ihm (und umgekehrt). Ein 3D-Job dauert Minuten; du kannst ihn jederzeit stoppen.

## Modelle sind separate Pakete

Dieses Paket enthält kein Modell. Installiere ein Modellpaket über den Packages-Browser und lade seine Dateien dann im Models-Panel herunter. Nichts wird ohne deine Bestätigung heruntergeladen, und du siehst vorher die Größe.

- `aigd.model3d-trellis2-4b` — TRELLIS.2 4B (Microsoft), ca. 16.5 GB.
- `aigd.model3d-pixal3d` — Pixal3D (Tencent ARC), ca. 14.5 GB; es teilt sich 3.5 GB an Dateien mit TRELLIS.2, beide zusammen sind also ca. 27 GB.

Jedes Modell ist texturiert: trellis.cpp v0.8.1 vereinfacht das Mesh nur beim Texturieren, und sein rohes Mesh mit reiner Geometrie (Millionen Flächen) sprengt die GLB-Grenzen der App, daher werden reine Geometrie-Läufe nicht angeboten.

Text zu 3D (erst ein Bildmodell, dann Bild zu 3D) ist noch nicht verdrahtet: Erzeuge das Bild mit einem lokalen oder Cloud-Bildmodell und wandle es dann in 3D um.

## Was heruntergeladen wird

Ein Upstream-Release, per Tag gepinnt und per sha256 geprüft: `pwilkin/trellis.cpp` [`v0.8.1`](https://github.com/pwilkin/trellis.cpp/releases/tag/v0.8.1) (Commit `c0bed38`). Die App wählt eine Variante für deinen Computer.

| Variante | Computer | Download |
|---|---|---|
| `win-x64-cuda13` | Windows, NVIDIA GPU (Treiber 580.88 oder neuer, Compute Capability 7.5 oder neuer: RTX 20-Serie und später) | 715 MB (Programm + NVIDIA CUDA 13 Runtime) |
| `win-x64-vulkan` | Windows, AMD / Intel / andere GPUs | 14 MB |
| `linux-x64-cuda13` | Linux x64, NVIDIA GPU (Treiber 580.65 oder neuer), glibc 2.34 und libstdc++ `GLIBCXX_3.4.30` oder neuer (Ubuntu 22.04+), `libgomp.so.1` | 715 MB |
| `linux-x64-vulkan` | Linux x64 mit einer Vulkan-GPU, glibc 2.34 und libstdc++ `GLIBCXX_3.4.30` oder neuer (Ubuntu 22.04+), `libgomp.so.1` und `libvulkan.so.1` | 16 MB |

**Linux ist eine Preview**: noch nicht auf einer echten Linux-GPU getestet.

Nicht angeboten:

- **macOS.** trellis.cpp läuft auf Apple Silicon (Metal; Upstream hat ein Modell mit Auflösung 512 auf einem M5 mit 24 GB in 9:21 gemessen), aber Upstream veröffentlicht keinen macOS-Build. Er erfordert einen Build aus dem Quellcode.
- **ROCm**-Builds (Upstream kennzeichnet sie als experimentell und zielt auf eine APU, gfx1151) und die `cuda12`-Builds für Pascal-/Volta-GPUs (Compute Capability 6–7). AMD-GPUs nutzen Vulkan.

Die Windows-Builds benötigen die Microsoft Visual C++ 2015–2022 Runtime (`MSVCP140.dll`, `VCRUNTIME140_1.dll`), die die meisten Windows-PCs bereits haben; die Archive enthalten sie nicht.

Die App installiert niemals Treiber oder Systembibliotheken. Wenn etwas fehlt, sagt sie dir, was du installieren musst.

## Lizenz

- trellis.cpp — MIT, © Piotr Wilkin ([Lizenz](https://github.com/pwilkin/trellis.cpp/blob/v0.8.1/LICENSE)).
- Mitgelieferter Third-Party-Code, vollständig in die Release-Binaries eingebaut: ggml (MIT), xatlas (MIT), meshoptimizer (MIT), Fast Quadric Mesh Simplification (MIT), cpp-httplib (MIT), stb (MIT oder Public Domain), libwebp ([BSD-3-Clause](https://github.com/webmproject/libwebp/blob/v1.5.0/COPYING)).
- NVIDIA CUDA Runtime (cudart, cuBLAS), nur in den CUDA-Varianten — von Upstream unter der [NVIDIA CUDA EULA](https://docs.nvidia.com/cuda/eula/) weiterverteilt.
- Dieses Paket — MIT. Jedes Modellpaket nennt seine eigene Lizenz.

Erforderliche Nennung: keine für die Nutzung des Programms. Die Release-Archive enthalten keine Lizenztexte; wenn du die Binaries weiterverteilst, füge die Hinweise selbst bei: die Upstream-[LICENSE](https://github.com/pwilkin/trellis.cpp/blob/v0.8.1/LICENSE), die Lizenzen unter [`thirdparty/`](https://github.com/pwilkin/trellis.cpp/tree/v0.8.1/thirdparty), den BSD-Hinweis von libwebp und bei den CUDA-Varianten die NVIDIA CUDA EULA.

Einschränkungen: keine durch die Runtime. Die Modellpakete bringen ihre eigenen mit (siehe jeweils dort).

Alle Dateien werden vom Upstream-GitHub-Release heruntergeladen. AI Game Dev hostet sie nicht.
````
