# TRELLIS.2 4B (modelo 3D)

> Image-to-3D local: TRELLIS.2 4B de Microsoft convierte una imagen en un modelo 3D texturizado (GLB con atlas UV y materiales PBR) para assets de juego, con resolución 512, 1024 o 1536. Se ejecuta con trellis.cpp en una GPU NVIDIA o Vulkan con 16 GB de memoria de vídeo. MIT, con la licencia DINOv3 de Meta para el codificador de imagen.

- Id: `aigd.model3d-trellis2-4b`
- Origen: Oficial (propio `aigd.*`)
- Categoría: 3D
- Editor: AI Game Dev (`aigd`), verificado
- Última versión: 1.0.5 (publicado el 2026-11-22)
- Licencia: SEE LICENSE IN README.md
- Requiere la app AI Game Dev: `>=0.32.0-beta.6`
- Código nativo: no
- Valoración: aún sin valoraciones
- Página HTML: https://ai-game.dev/es/packages/aigd.model3d-trellis2-4b

## Instalar

Con la CLI gamedev, en la carpeta del proyecto:

```bash
gamedev pkg add aigd.model3d-trellis2-4b
```

En la app de escritorio: abre la ventana Packages (el icono de paquete en la barra de estado), selecciona **Browse**, busca `aigd.model3d-trellis2-4b` y haz clic en **Add to Project**. Más: https://ai-game.dev/docs/wiki/app/packages

## Versiones

| Versión | Publicado | Requiere app | Notas |
|---|---|---|---|
| 1.0.5 | 2026-11-22 | `>=0.32.0-beta.6` | la más reciente |
| 1.0.4 | 2026-11-21 | `>=0.32.0-beta.6` | - |

## Descripción

````markdown
# TRELLIS.2 4B (`aigd.model3d-trellis2-4b`)

TRELLIS.2 4B es el modelo image-to-3D [TRELLIS.2](https://huggingface.co/microsoft/TRELLIS.2-4B) de Microsoft. Convierte una imagen en un modelo 3D texturizado: un GLB con atlas UV y materiales PBR (color base, metálico, rugosidad), unas 300.000 caras con resolución 1024. En AI Game Dev se ejecuta en tu GPU mediante **[Generación 3D local](https://ai-game.dev/packages/aigd.trellis)** (`aigd.trellis`, trellis.cpp), en GPU NVIDIA (CUDA) o Vulkan con 16 GB de memoria de vídeo. Está pensado para desarrolladores que quieren assets texturizados a partir de concept art sin usar un servicio en la nube.

## Qué puedes crear

- Objetos, armas, muebles, vehículos y personajes texturizados y listos para PBR a partir de una sola foto o imagen de concepto.
- Modelos a partir de fotos normales: el fondo se elimina automáticamente (BiRefNet).
- Borradores más ligeros con resolución 512, o modelos más detallados a 1536.

## Ejemplos de peticiones

- "Convierte `Concepts/potion.png` en un modelo 3D texturizado con TRELLIS.2."
- "Haz primero un GLB texturizado de esta foto de mi vieja radio con resolución 512, para poder revisarlo rápido."
- "Genera un modelo 3D del concepto del caballero a 1536."

## Aspectos destacados

|  |  |
|---|---|
| ID del modelo | `aigd.model3d-trellis2-4b.f16` |
| Operación | imagen a 3D (una imagen PNG o JPEG) |
| Salida | GLB texturizado con atlas UV y materiales PBR (texturas PNG) |
| Resoluciones | 512, 1024 (por defecto), 1536 |
| Pasos | 12 por defecto |
| Se ejecuta en | GPU NVIDIA (CUDA) o Vulkan con 16 GB de memoria de vídeo |
| Descarga | 16,5 GB, 10 archivos |
| Licencia | MIT; el codificador DINOv3 está bajo la DINOv3 License de Meta |

## TRELLIS.2 o Pixal3D

Ambos se ejecutan en [Generación 3D local](https://ai-game.dev/packages/aigd.trellis) y generan GLB texturizados.

- **TRELLIS.2 4B** (este paquete): el modelo base, también con una resolución 512 más ligera.
- **[Pixal3D](https://ai-game.dev/packages/aigd.model3d-pixal3d)**: el fine-tune de TRELLIS.2 de Tencent ARC que sigue más de cerca la silueta de la foto; solo con resoluciones 1024 y 1536. Comparte 3,5 GB de archivos con TRELLIS.2, así que ambos juntos ocupan unos 27 GB.

Para mallas sin textura en una GPU NVIDIA, consulta [TripoSG](https://ai-game.dev/packages/aigd.model3d-triposg), [Hunyuan3D-2.1 Shape](https://ai-game.dev/packages/aigd.model3d-hunyuan3d-2-1-shape) y [Step1X-3D Geometry](https://ai-game.dev/packages/aigd.model3d-step1x-3d-geometry).

## Límites y mediciones

- **Entrada:** una imagen PNG o JPEG de un solo objeto. El fondo se elimina automáticamente (BiRefNet), así que sirve una foto normal; una imagen que ya tenga transparencia la conserva.
- **Salida:** un GLB autocontenido (texturas PNG).
- **Resoluciones:** 512 (más ligera), 1024 (por defecto, una cascada 512→1024), 1536.
- **Siempre texturizado:** no se ofrece una ejecución solo de geometría. trellis.cpp v0.8.1 simplifica la malla solo durante el texturizado, así que sin texturas escribe la malla decodificada en bruto (15,67 millones de caras medidas), que supera los límites de GLB de la app. Ninguna opción de ejecución la simplifica de otro modo.
- **No es idéntico bit a bit:** la misma imagen, semilla y ajustes no dan un GLB idéntico bit a bit. Dos ejecuciones en CUDA con semilla 42 dieron ambas GLB válidos con geometría y hashes SHA-256 distintos; la semilla registrada identifica los ajustes de la petición.
- **Hardware:** una GPU NVIDIA (CUDA) o Vulkan con **16 GB** de memoria de vídeo. El proyecto original indica que la cascada de 1024 se ejecuta en una tarjeta de 16 GB, y se midieron 3:16–7:23 por modelo en una RTX 5060 Ti de 16 GB (6:09–12:39 en una iGPU Radeon 8060S), incluida la carga del modelo.
- **Descarga:** 16,5 GB, 10 archivos.

En Windows con una RTX 4090, una imagen generada con semilla 42 y 12 pasos dio estos tiempos de extremo a extremo y picos de VRAM de todo el dispositivo. El uso de VRAM inicial era de 3.676–4.819 MiB.

| Backend | Resolución | Tiempo | Pico de VRAM |
|---|---:|---:|---:|
| CUDA | 512 | 60.77 s | 7,321 MiB |
| CUDA | 1024 | 290.88 s | 10,166 MiB |
| CUDA | 1536 | 687.35 s | 14,857 MiB |
| Vulkan | 512 | 147.04 s | 7,558 MiB |
| Vulkan | 1024 | 710.54 s | 13,447 MiB |

## Qué se descarga

Todo desde [`ilintar/trellis2-gguf`](https://huggingface.co/ilintar/trellis2-gguf) en la revisión `a57397bd3d351599d9729fc144b3f87c3f87d65b` (pesos F16, normas F32), verificado con sha256:

| Archivo | Qué es | Modelo de origen | Licencia |
|---|---|---|---|
| `ss_flow`, `shape_flow_512`, `shape_flow_1024`, `tex_flow_512`, `tex_flow_1024` | los flow transformers 1.3B de las tres etapas (dos resoluciones cada una para forma y textura) | [microsoft/TRELLIS.2-4B](https://huggingface.co/microsoft/TRELLIS.2-4B) | MIT |
| `shape_dec`, `tex_dec` | decodificadores de forma y textura | microsoft/TRELLIS.2-4B | MIT |
| `ss_dec` | decodificador de estructura dispersa | [microsoft/TRELLIS-image-large](https://huggingface.co/microsoft/TRELLIS-image-large) | MIT |
| `dinov3` | codificador de imagen DINOv3 ViT-L/16 | [timm/vit_large_patch16_dinov3.lvd1689m](https://huggingface.co/timm/vit_large_patch16_dinov3.lvd1689m) (DINOv3 de Meta) | [DINOv3 License](https://ai.meta.com/resources/models-and-libraries/dinov3-license/) |
| `birefnet` | eliminación del fondo | [ZhengPeng7/BiRefNet](https://huggingface.co/ZhengPeng7/BiRefNet) | MIT |

## Licencia

TRELLIS.2 es **MIT**: se permite el uso comercial y eres dueño de lo que generas (la app te pide aceptar la licencia antes de la descarga, por las restricciones de uso del codificador DINOv3 que se indican más abajo). Un componente no es MIT:

- **Codificador de imagen DINOv3** (`dinov3.gguf`) — la [DINOv3 License](https://ai.meta.com/resources/models-and-libraries/dinov3-license/) de Meta (14 de agosto de 2025). Es una licencia gratuita, mundial y libre de regalías que permite el uso comercial, con estas condiciones:
  - Si distribuyes el codificador o un derivado de él, incluye una copia de la DINOv3 License y **muestra de forma destacada "Built with DINOv3"** en un sitio web, interfaz de usuario, entrada de blog, página «acerca de» o documentación del producto relacionada.
  - No se permite su uso en actividades sujetas a ITAR ni en usos finales prohibidos por controles comerciales: militar o bélico, industrias o aplicaciones nucleares, espionaje, o armas de fuego y armas ilegales. No debes ser objeto de sanciones comerciales.
  - No se permite la ingeniería inversa de los componentes subyacentes. Meta puede rescindir la licencia si la incumples o si demandas a Meta en relación con los materiales.
- El repositorio GGUF `ilintar/trellis2-gguf` declara la licencia «other» y remite a los modelos de origen; no añade condiciones propias.
- La página de licencia de Meta (14 de agosto de 2025, enlazada arriba) contiene la obligación "Built with DINOv3"; la copia incluida con el código de DINOv3 (19 de agosto de 2025) no la contiene. Este paquete sigue la más estricta.

Texto de atribución obligatorio:

> TRELLIS.2 © Microsoft Corporation (MIT). Built with DINOv3 (DINOv3 License, © Meta Platforms).
> BiRefNet © ZhengPeng7 (MIT).

Restricciones, en claro: la atribución de DINOv3 y su prohibición de uso militar, armamentístico y bajo controles comerciales indicada arriba. Sin límite de ingresos, sin límite territorial, sin marca de agua.

Todos los archivos se descargan de Hugging Face. AI Game Dev no los aloja. Aceptas estas licencias al descargar el modelo.
````
