# Local 3D generation

> Runtime de Local 3D generation: o trellis.cpp, uma porta C++ do Microsoft TRELLIS.2, transforma uma imagem em um modelo 3D texturizado (GLB com materiais PBR) na sua própria GPU NVIDIA ou Vulkan, sem custo por modelo. Executa os pacotes de modelo TRELLIS.2 4B e Pixal3D, que são instalados separadamente. Windows; Linux em prévia.

- Id: `aigd.trellis`
- Origem: Oficial (de primeira parte `aigd.*`)
- Categoria: 3D
- Publicador: AI Game Dev (`aigd`), verificado
- Versão mais recente: 1.0.3 (publicado em 2026-11-22)
- Licença: MIT
- Requer o app AI Game Dev: `>=0.32.0-beta.6`
- Código nativo: não
- Avaliação: ainda sem avaliações
- Página HTML: https://ai-game.dev/pt-br/packages/aigd.trellis

## Instalar

Com o CLI gamedev, na pasta do projeto:

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

No app desktop: abra a janela Packages (o ícone de pacote na barra de status), selecione **Browse**, busque `aigd.trellis` e clique em **Add to Project**. Mais: https://ai-game.dev/docs/wiki/app/packages

## Versões

| Versão | Publicado | Requer o app | Observações |
|---|---|---|---|
| 1.0.3 | 2026-11-22 | `>=0.32.0-beta.6` | mais recente |
| 1.0.2 | 2026-11-21 | `>=0.32.0-beta.6` | - |

## Descrição

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

Local 3D generation é o runtime que transforma uma imagem em um modelo 3D texturizado (GLB com materiais PBR) neste computador, na sua própria GPU, com o [trellis.cpp](https://github.com/pwilkin/trellis.cpp), uma porta C++/GGML do Microsoft TRELLIS.2. Tudo é feito no seu computador, e fazer isso não custa nada. O pacote não contém nenhum modelo em si: ele executa os pacotes de modelo 3D [TRELLIS.2 4B](https://ai-game.dev/packages/aigd.model3d-trellis2-4b) e [Pixal3D](https://ai-game.dev/packages/aigd.model3d-pixal3d). Ele é indicado para desenvolvedores com GPU NVIDIA ou Vulkan que querem assets 3D texturizados sem um serviço de nuvem.

## O que você pode criar

Com um pacote de modelo instalado:

- Props, armas, móveis, veículos e personagens texturizados e prontos para PBR a partir de uma única imagem.
- Versões 3D de concept art ou de fotos de objetos reais.
- 3D a partir de texto em duas etapas: crie a imagem com um modelo de imagem local ou em nuvem e depois transforme-a em 3D.

## Exemplos de pedidos

- "Transforme `Concepts/crate.png` em um modelo 3D texturizado."
- "Crie uma imagem de uma barraca de mercado de madeira e depois transforme-a em um modelo 3D."
- "Gere um modelo 3D a partir desta foto com o Pixal3D na resolução 1024."

## Destaques

|  |  |
|---|---|
| Runtime | trellis.cpp v0.8.1 (MIT) |
| Operação | imagem para 3D texturizado (GLB, materiais PBR) |
| Modelos | pacotes separados: TRELLIS.2 4B (cerca de 16,5 GB), Pixal3D (cerca de 14,5 GB) |
| Windows | GPU NVIDIA (CUDA 13) ou GPUs AMD / Intel / outras (Vulkan) |
| Linux | x64 com NVIDIA (CUDA 13) ou Vulkan, prévia |
| macOS | não oferecido (sem build upstream) |
| Download | 14–16 MB (Vulkan) ou 715 MB (CUDA, com o runtime NVIDIA) |
| Licença | MIT; cada pacote de modelo declara sua própria licença |

## Como funciona

Este pacote é apenas dados (`aigd-package.json`, sem código). Ele informa ao AI Game Dev qual versão do trellis.cpp baixar para o seu computador. O app baixa, verifica e executa o programa por conta própria. Sua chave **3D Gen** fica desligada até você ativá-la.

Um modelo 3D compartilha a única fila de GPU local com imagens, clipes e fala locais: apenas um modelo roda por vez, e uma tarefa 3D espera a imagem ou o clipe à sua frente (e vice-versa). Uma tarefa 3D leva minutos; você pode interrompê-la a qualquer momento.

## Os modelos são pacotes separados

Este pacote não contém nenhum modelo. Instale um pacote de modelo no navegador de Pacotes e depois baixe seus arquivos no painel Modelos. Nada é baixado sem a sua confirmação, e você vê o tamanho antes.

- `aigd.model3d-trellis2-4b` — TRELLIS.2 4B (Microsoft), cerca de 16,5 GB.
- `aigd.model3d-pixal3d` — Pixal3D (Tencent ARC), cerca de 14,5 GB; ele compartilha 3,5 GB de arquivos com o TRELLIS.2, então os dois juntos somam cerca de 27 GB.

Todo modelo é texturizado: o trellis.cpp v0.8.1 simplifica a malha apenas durante a texturização, e sua malha bruta somente geométrica (milhões de faces) ultrapassa os limites de GLB do app, então execuções somente de geometria não são oferecidas.

Texto para 3D (primeiro um modelo de imagem, depois imagem para 3D) ainda não está conectado: crie a imagem com um modelo de imagem local ou em nuvem e depois transforme-a em 3D.

## O que é baixado

Uma versão upstream, fixada por tag e verificada por sha256: `pwilkin/trellis.cpp` [`v0.8.1`](https://github.com/pwilkin/trellis.cpp/releases/tag/v0.8.1) (commit `c0bed38`). O app escolhe uma variante para o seu computador.

| Variante | Computador | Download |
|---|---|---|
| `win-x64-cuda13` | Windows, GPU NVIDIA (driver 580.88 ou mais recente, compute capability 7.5 ou superior: RTX 20 e posteriores) | 715 MB (programa + runtime NVIDIA CUDA 13) |
| `win-x64-vulkan` | Windows, GPUs AMD / Intel / outras | 14 MB |
| `linux-x64-cuda13` | Linux x64, GPU NVIDIA (driver 580.65 ou mais recente), glibc 2.34 e libstdc++ `GLIBCXX_3.4.30` ou mais recente (Ubuntu 22.04+), `libgomp.so.1` | 715 MB |
| `linux-x64-vulkan` | Linux x64 com GPU Vulkan, glibc 2.34 e libstdc++ `GLIBCXX_3.4.30` ou mais recente (Ubuntu 22.04+), `libgomp.so.1` e `libvulkan.so.1` | 16 MB |

**O Linux é uma prévia**: ainda não testado em uma GPU Linux real.

Não oferecido:

- **macOS.** O trellis.cpp roda em Apple silicon (Metal; o upstream mediu um modelo em resolução 512 em 9:21 em um M5 com 24 GB), mas o upstream não publica nenhum build para macOS. É preciso compilar a partir do código-fonte.
- Builds **ROCm** (o upstream os marca como experimentais e tem como alvo uma única APU, gfx1151) e os builds `cuda12` para GPUs Pascal/Volta (compute capability 6–7). GPUs AMD usam Vulkan.

Os builds para Windows precisam do runtime Microsoft Visual C++ 2015–2022 (`MSVCP140.dll`, `VCRUNTIME140_1.dll`), que a maioria dos PCs Windows já tem; os arquivos compactados não o incluem.

O app nunca instala drivers nem bibliotecas de sistema. Se algo estiver faltando, ele informa o que instalar.

## Licença

- trellis.cpp — MIT, © Piotr Wilkin ([licença](https://github.com/pwilkin/trellis.cpp/blob/v0.8.1/LICENSE)).
- Código de terceiros incluído, todo compilado nos binários da versão: ggml (MIT), xatlas (MIT), meshoptimizer (MIT), Fast Quadric Mesh Simplification (MIT), cpp-httplib (MIT), stb (MIT ou domínio público), libwebp ([BSD-3-Clause](https://github.com/webmproject/libwebp/blob/v1.5.0/COPYING)).
- Runtime NVIDIA CUDA (cudart, cuBLAS), apenas nas variantes CUDA — redistribuído pelo upstream sob a [NVIDIA CUDA EULA](https://docs.nvidia.com/cuda/eula/).
- Este pacote — MIT. Cada pacote de modelo declara sua própria licença.

Atribuição exigida: nenhuma para usar o programa. Os arquivos compactados da versão não trazem textos de licença; se você redistribuir os binários, inclua os avisos você mesmo: o [LICENSE](https://github.com/pwilkin/trellis.cpp/blob/v0.8.1/LICENSE) do upstream, as licenças em [`thirdparty/`](https://github.com/pwilkin/trellis.cpp/tree/v0.8.1/thirdparty), o aviso BSD do libwebp e, para as variantes CUDA, a NVIDIA CUDA EULA.

Restrições: nenhuma por parte do runtime. Os pacotes de modelo trazem as suas próprias (veja cada um).

Todos os arquivos são baixados da release do GitHub do upstream. O AI Game Dev não os hospeda.
````
