Last updated: April 14, 2026

TRELLIS 2 by Microsoft Research is an open-source AI model for generating high-quality 3D assets from text or images. This guide walks through every installation method — from a quick local setup to Docker and ComfyUI integration — so you can start generating 3D models on your own hardware.

If you'd rather skip the setup, you can use TRELLIS 2 online with no installation required.

System Requirements

Before installing TRELLIS 2, verify your system meets these requirements:

Minimum Requirements

Component	Minimum	Recommended
GPU	NVIDIA with 8GB VRAM	NVIDIA with 16GB+ VRAM
RAM	16 GB	32 GB
Storage	10 GB free	20 GB free (SSD preferred)
Python	3.10	3.11
CUDA	11.8	12.1+
OS	Linux (Ubuntu 20.04+)	Linux (Ubuntu 22.04+)

GPU Compatibility

GPU Series	Example GPUs	Max Resolution	Performance
RTX 30/40 Series	RTX 3060, 4070, 4080, 4090	1536³	Excellent
RTX 20 Series	RTX 2060, 2070, 2080	1024³	Good
GTX 16/10 Series	GTX 1660, 1080, 1080 Ti	512³	Acceptable
Server GPUs	A100, V100, H100	1536³	Excellent

Note: AMD and Apple Silicon GPUs are not officially supported. AMD users can try the ROCm build, but expect limited compatibility. Mac users should use TRELLIS 2 online instead.

Installation Methods

Choose the method that fits your setup:

Method	Difficulty	Best For	Setup Time
Linux (Native)	Intermediate	Most setups	15-30 min
Windows (Native)	Intermediate	Windows users	15-30 min
ComfyUI Integration	Intermediate	ComfyUI users	20-40 min
Docker	Advanced	Reproducible environments	10-20 min
One-Click Installer	Beginner	Windows, quick setup	5-10 min

Method 1: Linux Installation

Step 1: Install Prerequisites

# Update system packages
sudo apt update && sudo apt upgrade -y

# Install Python 3.11 and pip
sudo apt install python3.11 python3.11-venv python3-pip -y

# Install CUDA toolkit (if not already installed)
# For CUDA 12.1:
wget https://developer.download.nvidia.com/compute/cuda/12.1.0/local_installers/cuda_12.1.0_530.32.01_linux.run
sudo sh cuda_12.1.0_530.32.01_linux.run

# Verify CUDA installation
nvcc --version
nvidia-smi

Step 2: Clone the Repository

# Clone TRELLIS 2
git clone https://github.com/microsoft/TRELLIS.2.git
cd TRELLIS.2

Step 3: Create Virtual Environment

# Create and activate virtual environment
python3.11 -m venv venv
source venv/bin/activate

# Upgrade pip
pip install --upgrade pip

Step 4: Install Dependencies

# Install PyTorch with CUDA support
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121

# Install TRELLIS 2 dependencies
pip install -r requirements.txt

Step 5: Download Model Weights

# Download pre-trained weights from Hugging Face
python download_weights.py

This downloads approximately 8 GB of model weights. The weights are saved to the weights/ directory.

Step 6: Verify Installation

# Run a quick test
python infer.py --text_prompt "a red cube" --output_path test_output.glb

If the installation is successful, you'll find test_output.glb in the project directory.

Method 2: Windows Installation

Option A: One-Click Installer (Recommended for Beginners)

The community provides a one-click installer that handles most setup automatically:

Download the installer from the TRELLIS Windows installer repository
Extract the archive to a folder with no spaces in the path (e.g., C:\TRELLIS2)
Run install.bat as administrator
Wait for the installation to complete (10-15 minutes)
Run run.bat to start the web interface

Option B: Manual Installation

Step 1: Install Prerequisites

Install Python 3.11 (check "Add to PATH")
Install Git for Windows
Install CUDA Toolkit 12.1
Install Visual Studio Build Tools (select "Desktop development with C++")

Step 2: Clone and Set Up

# Clone the repository
git clone https://github.com/microsoft/TRELLIS.2.git
cd TRELLIS.2

# Create virtual environment
python -m venv venv
.\venv\Scripts\activate

# Upgrade pip
pip install --upgrade pip

Step 3: Install Dependencies

# Install PyTorch with CUDA support
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121

# Install dependencies
pip install -r requirements.txt

Step 4: Download Weights and Test

# Download model weights
python download_weights.py

# Run test
python infer.py --text_prompt "a red cube" --output_path test_output.glb

Method 3: ComfyUI Integration

TRELLIS 2 can be integrated into ComfyUI for node-based 3D generation workflows.

Step 1: Install ComfyUI

If you don't have ComfyUI installed:

git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
pip install -r requirements.txt

Step 2: Install TRELLIS 2 Custom Nodes

cd ComfyUI/custom_nodes/
git clone https://github.com/comfyui-extensions/ComfyUI-TRELLIS.2.git
cd ComfyUI-TRELLIS.2
pip install -r requirements.txt

Step 3: Download Model Weights

Place the TRELLIS 2 weights in the ComfyUI models directory:

# Create directory if it doesn't exist
mkdir -p ComfyUI/models/trellis/

# Download weights
python ComfyUI/custom_nodes/ComfyUI-TRELLIS.2/download_weights.py \
  --output_dir ComfyUI/models/trellis/

Step 4: Start ComfyUI

cd ComfyUI
python main.py

Access the ComfyUI web interface at http://localhost:8188 and search for TRELLIS nodes in the node browser.

Available Nodes

Node	Input	Output	Description
TRELLIS Image to 3D	Image	3D Model (GLB)	Convert a single image to 3D
TRELLIS Text to 3D	Text prompt	3D Model (GLB)	Generate 3D from description
TRELLIS Multi-View	Multiple images	3D Model (GLB)	Use multiple views for better quality
TRELLIS Export	3D Model	File	Export to various formats

Method 4: Docker Installation

Docker provides a reproducible environment that works across platforms.

Step 1: Install Docker

# Ubuntu
sudo apt install docker.io docker-compose -y
sudo usermod -aG docker $USER

# Start Docker
sudo systemctl start docker
sudo systemctl enable docker

Step 2: Build the Docker Image

git clone https://github.com/microsoft/TRELLIS.2.git
cd TRELLIS.2

# Build the image (includes CUDA support)
docker build -t trellis2 .

Step 3: Run the Container

# Run with GPU support
docker run --gpus all -p 7860:7860 -v ./outputs:/app/outputs trellis2

Access the web interface at http://localhost:7860.

Configuration Options

After installation, you can configure TRELLIS 2 through a config file or command-line arguments.

Config File (config.yaml)

model:
  name: "trellis2-4b"
  weights_path: "./weights/"

generation:
  default_resolution: 512
  default_sampling_steps: 12
  default_guidance_scale: 7.5

server:
  host: "0.0.0.0"
  port: 7860
  max_batch_size: 4

output

Command-Line Arguments

python infer.py \
  --image_path input.png \
  --output_path output.glb \
  --resolution 1024 \
  --sampling_steps 25 \
  --guidance_scale 10.0 \
  --seed 42

Troubleshooting Common Issues

CUDA Out of Memory

Symptom: RuntimeError: CUDA out of memory

Solutions:

Reduce resolution: --resolution 256 or --resolution 512
Reduce sampling steps: --sampling_steps 4
Close other GPU-intensive applications
Use the online platform for high-resolution generation

Python Version Issues

Symptom: ModuleNotFoundError or syntax errors

Solution: Ensure Python 3.10 or 3.11 is being used:

python --version  # Should be 3.10.x or 3.11.x

CUDA Version Mismatch

Symptom: RuntimeError: CUDA version mismatch

Solution: Reinstall PyTorch matching your CUDA version:

# For CUDA 11.8
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118

# For CUDA 12.1
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121

Model Weights Download Failure

Symptom: Download timeout or corrupted files

Solution: Download weights manually from Hugging Face:

# Using huggingface-cli
pip install huggingface-hub
huggingface-cli download microsoft/TRELLIS.2-4B --local-dir ./weights/

Slow Generation on Windows

Symptom: Generation takes much longer than expected

Solutions:

Ensure CUDA is properly installed (nvidia-smi should work)
Check that PyTorch is using GPU: python -c "import torch; print(torch.cuda.is_available())"
Disable Windows GPU scheduling: Settings → System → Display → Graphics → Change default graphics settings

Performance Benchmarks

Expected generation times by GPU (512 resolution, 12 sampling steps):

GPU	Generation Time	VRAM Usage
RTX 4090	~2.5s	~6 GB
RTX 4080	~3s	~7 GB
RTX 3090	~4s	~8 GB
RTX 3080	~5s	~8 GB
RTX 4070	~4s	~6 GB
RTX 3060	~8s	~8 GB
GTX 1080 Ti	~12s	~8 GB
A100	~2s	~6 GB

Updating TRELLIS 2

To update to the latest version:

cd TRELLIS.2

# Pull latest changes
git pull origin main

# Update dependencies
pip install -r requirements.txt

# Download new weights if available
python download_weights.py

Alternatives to Local Installation

If your hardware doesn't meet the requirements or you prefer not to install locally:

Use TRELLIS 2 Online — No GPU Required

Feature	Local	Online Platform
Setup time	15-60 min	0 min
GPU needed	Yes (NVIDIA)	No
Max resolution	GPU-dependent	Up to 1536³
Batch processing	Yes	Yes
Cost	Hardware + electricity	Free tier available
Updates	Manual	Automatic