In my previous articles, I used an RTX 5060 Ti 16GB in WSL 2 for Ollama and Open WebUI and for Codex CLI with a local model. This time, I wanted to try TRELLIS.2, Microsoft’s model for turning a single image into a textured 3D model.
Microsoft’s README says an NVIDIA GPU with at least 24GB of memory is necessary. I installed TRELLIS.2 in a new WSL 2 Ubuntu 26.04 distribution anyway and tested what fit in 16GB: the web app at 512 and 1024, and 1024 and 1536 from a script.
I wanted to use the models in a product, so I also checked the licenses. Two parts of the default pipeline are not licensed for commercial use: the RMBG-2.0 background-removal model and the nvdiffrast rasterizer used for texture baking. My fork of TRELLIS.2 adds a command-line generator that replaces both, and step 9 uses it.
1. Test environment
These results were recorded on November 4 and 5, 2026, on a distribution installed for this test.
| Component | Test configuration |
|---|---|
| Windows host | Windows 11 |
| WSL / Ubuntu | WSL 3.0.3.0 / Ubuntu 26.04.1 LTS |
| WSL memory | 32GB, swap disabled |
| GPU | NVIDIA GeForce RTX 5060 Ti 16GB, driver 617.42, later 621.14 |
| Python | 3.10.22 from Miniforge 26.9.4-1 |
| CUDA compiler | conda-forge CUDA 12.8 (nvcc 12.8.93), GCC 13.4 |
| PyTorch | 2.8.0+cu128 |
| FlashAttention | 2.8.3.post2 |
| TRELLIS.2 | maksonlee/TRELLIS.2: Microsoft’s main at 75fbf01 plus tools/ |
| Model | microsoft/TRELLIS.2-4B, revision af44b45 |
Windows browser
-> http://127.0.0.1:7860
-> TRELLIS.2 web app (app.py) in WSL Ubuntu 26.04
-> RTX 5060 Ti through the Windows NVIDIA driver
tools/generate_commercial.py in WSL Ubuntu 26.04
-> image in, textured GLB out, without RMBG-2.0 or nvdiffrastMicrosoft’s setup.sh can create an environment with PyTorch 2.6.0 and CUDA 12.4. The RTX 5060 Ti has compute capability 12.0, which needs CUDA 12.8 or later, so I left out --new-env and installed the dependencies myself.
You also need a Hugging Face account for the gated models and about 40GB of free disk space. With all models installed, my WSL virtual disk was 36 GiB.
2. Create the WSL distribution
Run in Windows PowerShell:
notepad "$env:USERPROFILE\.wslconfig"Set the memory limit and disable swap in the [wsl2] section:
[wsl2]
memory=32GB
swap=0
networkingMode=mirroredIn my tests, TRELLIS.2 used up to about 20 GiB of RAM while generating. networkingMode=mirrored was already in my file from the Codex article, and Windows reached the web app on 127.0.0.1. Keep your other WSL settings. If WSL is running, save your work in every distribution and run wsl --shutdown so the new limit applies.
Install Ubuntu 26.04 as a new distribution. --location puts its virtual disk on another drive:
wsl --install Ubuntu-26.04 --location E:\WSL\Ubuntu-26.04 --no-launch
wsl -d Ubuntu-26.04The first start asks for a Linux user name and password. Then check the memory limit, swap, and GPU in WSL Ubuntu:
grep -E '^(MemTotal|SwapTotal)' /proc/meminfo
swapon --show
nvidia-smi --query-gpu=name,memory.total,memory.used,driver_version,compute_cap --format=csvMy result was:
MemTotal: 32866164 kB
SwapTotal: 0 kB
name, memory.total [MiB], memory.used [MiB], driver_version, compute_cap
NVIDIA GeForce RTX 5060 Ti, 16311 MiB, 2513 MiB, 617.42, 12.0swapon --show printed nothing. Windows and other programs were already using 2,513 MiB of GPU memory. WSL uses the Windows NVIDIA driver; do not install a Linux NVIDIA driver, or a CUDA package that includes one, inside Ubuntu. See NVIDIA’s CUDA on WSL User Guide.
3. Install Miniforge and create the Python environment
Install Git and curl in WSL Ubuntu:
sudo apt update
sudo apt install -y --no-install-recommends git curl ca-certificatesMiniforge is a small installer for conda that uses the community conda-forge channel by default. With conda, you can create isolated environments, each with its own Python version and packages, and also install tools such as the CUDA compiler and GCC used in step 4. The trellis2 environment holds Python 3.10 and everything TRELLIS.2 needs, without touching Ubuntu’s own Python.
Download Miniforge 26.9.4-1, check its SHA-256, and install it in your home directory:
mkdir -p ~/Downloads/miniforge
cd ~/Downloads/miniforge
curl -fL -o Miniforge3-26.9.4-1-Linux-x86_64.sh \
https://github.com/conda-forge/miniforge/releases/download/26.9.4-1/Miniforge3-26.9.4-1-Linux-x86_64.sh
echo "571b410272cc434f28bc6c5c49ca8ffd4a4d1bcba9f57f1b6baccdb46446cfcc Miniforge3-26.9.4-1-Linux-x86_64.sh" \
| sha256sum -c -
bash Miniforge3-26.9.4-1-Linux-x86_64.sh -b -p ~/miniforge3The checksum line should end with OK. Create a Python 3.10 environment named trellis2:
source ~/miniforge3/etc/profile.d/conda.sh
conda create -y -n trellis2 --override-channels -c conda-forge python=3.10 pip
conda activate trellis2
python --versionI did not run conda init, so each new terminal in the steps below starts with these two lines:
source ~/miniforge3/etc/profile.d/conda.sh
conda activate trellis24. Install the CUDA 12.8 compiler and PyTorch
TRELLIS.2 compiles several CUDA extensions. Install the CUDA 12.8 compiler and GCC 13 from conda-forge into the environment. This is only the build toolchain. The driver still comes from Windows.
conda install -y -n trellis2 --override-channels -c conda-forge \
'cuda-version=12.8' cuda-compiler cuda-libraries-dev \
'gcc=13' 'gxx=13' 'sysroot_linux-64=2.28' \
cmake make pkg-configActivate the environment again so the compiler’s activation scripts run, then check the versions:
conda deactivate
conda activate trellis2
nvcc --version | tail -n 2
gcc --version | head -n 1My result included:
Cuda compilation tools, release 12.8, V12.8.93
gcc (conda-forge gcc 13.4.0-20) 13.4.0Install PyTorch 2.8.0 from the CUDA 12.8 index, then run a small GPU test:
python -m pip install torch==2.8.0 torchvision==0.23.0 \
--index-url https://download.pytorch.org/whl/cu128
python - <<'EOF'
import torch
print("Torch:", torch.__version__, "CUDA:", torch.version.cuda)
print("GPU:", torch.cuda.get_device_name(0), torch.cuda.get_device_capability(0))
x = torch.randn(64, 64, device="cuda")
print("CUDA execution OK:", torch.isfinite(x @ x.T).all().item())
EOFThe output should show 2.8.0+cu128, CUDA 12.8, the RTX 5060 Ti with compute capability (12, 0), and True.
5. Install the Python dependencies and FlashAttention
Create a pip constraints file first. With PIP_CONSTRAINT set, a later install that tries to replace PyTorch, NumPy, Pillow, or OpenCV fails instead of changing them silently. That includes the installs started by setup.sh in the next step.
mkdir -p ~/.config/trellis2
cat > ~/.config/trellis2/constraints.txt <<'EOF'
torch==2.8.0+cu128
torchvision==0.23.0+cu128
numpy==2.2.6
pillow==12.3.0
opencv-python-headless==4.12.0.88
EOF
export PIP_CONSTRAINT="$HOME/.config/trellis2/constraints.txt"Keep this terminal open through step 6; exported variables apply only to the current shell. Install the packages:
python -m pip install -c "$PIP_CONSTRAINT" \
'setuptools==80.10.2' wheel packaging ninja einops psutil \
'numpy==2.2.6' 'Pillow==12.3.0' 'opencv-python-headless==4.12.0.88' \
'transformers==4.57.3' 'huggingface-hub==0.36.2' 'gradio==6.0.1' \
imageio imageio-ffmpeg tqdm easydict trimesh \
tensorboard pandas lpips zstandard kornia timm
python -m pip install -c "$PIP_CONSTRAINT" \
'git+https://github.com/EasternJournalist/utils3d.git@9a4eb15e4021b67b12c460c7057d642626897ec8'This replaces setup.sh --basic with pinned versions, using Pillow instead of pillow-simd.
Install the official FlashAttention 2.8.3.post2 wheel for CUDA 12, PyTorch 2.8, Python 3.10, and the C++11 ABI. --no-deps keeps pip away from PyTorch:
python -m pip install --no-deps \
'https://github.com/Dao-AILab/flash-attention/releases/download/v2.8.3.post2/flash_attn-2.8.3.post2%2Bcu12torch2.8cxx11abiTRUE-cp310-cp310-linux_x86_64.whl'
python - <<'EOF'
import torch
import flash_attn
from flash_attn import flash_attn_func
q = torch.randn(1, 128, 4, 64, device="cuda", dtype=torch.float16)
out = flash_attn_func(q, q, q)
torch.cuda.synchronize()
print("flash_attn", flash_attn.__version__, "OK:", torch.isfinite(out).all().item())
EOF
python -m pip checkThis replaces setup.sh --flash-attn. pip check should report No broken requirements found.
6. Build the TRELLIS.2 extensions
Clone my fork with its submodule. It is Microsoft’s main branch at 75fbf01 plus a tools/ folder for step 9; setup.sh and the rest of the code are unchanged:
cd ~
git clone -b main https://github.com/maksonlee/TRELLIS.2.git --recursive
cd ~/TRELLIS.2
git rev-parse --short HEADThe fork was at commit 0c33787. My build ran on Microsoft’s 75fbf01, which has the same build files. Point the build at the conda toolkit, build only for the RTX 50 series, and run the official script with the extension options:
export CUDA_HOME="$CONDA_PREFIX"
export TORCH_CUDA_ARCH_LIST=12.0
export MAX_JOBS=1
export CPATH="$CUDA_HOME/targets/x86_64-linux/include${CPATH:+:$CPATH}"
export LIBRARY_PATH="$CUDA_HOME/targets/x86_64-linux/lib${LIBRARY_PATH:+:$LIBRARY_PATH}"
. ./setup.sh --nvdiffrast --nvdiffrec --cumesh --flexgemm --o-voxelThese are the README’s options without --new-env, --basic, and --flash-attn. MAX_JOBS=1 builds one file at a time, and the build took about 17 minutes.
setup.sh clones the extension sources into /tmp/extensions. On Ubuntu 26.04, /tmp is a tmpfs in memory, as in my Jenkins article, so the sources disappear when WSL stops. The installed packages are not affected.
Check that the extensions load:
python - <<'EOF'
import nvdiffrast.torch
import nvdiffrec_render
import cumesh
import flex_gemm
import o_voxel
from trellis2.pipelines import Trellis2ImageTo3DPipeline
print("Native imports: OK")
EOF7. Download the models
7.1 Request access to the gated models
TRELLIS.2 uses DINOv3 for image conditioning, a gated model on Hugging Face. Microsoft’s default configuration also uses RMBG-2.0 for background removal, which is gated and released for non-commercial use. The generator in step 9 uses BiRefNet (MIT) instead, so you need RMBG-2.0 only for the web app in step 8.
Sign in to Hugging Face, open the model pages, review the terms, and request access to DINOv3, and to RMBG-2.0 if you want to run the web app.
After access is granted, create a read token in your Hugging Face settings and log in with the hf CLI in WSL Ubuntu. Paste the token at the prompt; do not put it in a command, a script, or your shell history:
hf auth login
hf auth whoamiOn my installation, the token file was created with mode 644. Restrict it, then check access:
chmod 600 ~/.cache/huggingface/token
hf download facebook/dinov3-vitl16-pretrain-lvd1689m config.json
hf download briaai/RMBG-2.0 config.json # web app onlyWithout approved access, the download fails with a gated repository error.
7.2 Download the checkpoints
The pipeline can download missing files when it loads, but I downloaded them first so the first start would not wait on 16GB. This script reads pipeline.json and fetches the TRELLIS.2 checkpoints and DINOv3:
python - <<'EOF'
import json
from pathlib import Path
from huggingface_hub import hf_hub_download
main = "microsoft/TRELLIS.2-4B"
args = json.loads(Path(hf_hub_download(main, "pipeline.json")).read_text())["args"]
jobs = []
for stem in args["models"].values():
repo = main
if not stem.startswith("ckpts/"):
owner, project, stem = stem.split("/", 2)
repo = f"{owner}/{project}"
jobs += [(repo, stem + ".json"), (repo, stem + ".safetensors")]
jobs += [(args["image_cond_model"]["args"]["model_name"], "model.safetensors")]
for repo, name in jobs:
size = Path(hf_hub_download(repo, name)).stat().st_size
print(f"{repo} {name}: {size:,} bytes")
EOFThen download BiRefNet at the revision the generator uses, and RMBG-2.0 if you want the web app:
hf download ZhengPeng7/BiRefNet --revision e2bf8e4460fc8fa32bba5ea4d94b3233d367b0e4
hf download briaai/RMBG-2.0 model.safetensors # web app onlyThe TRELLIS.2 checkpoints and DINOv3 are 17 files, about 16.2GB, stored under ~/.cache/huggingface/hub. BiRefNet adds 0.44GB, and RMBG-2.0 0.88GB.
BiRefNet and RMBG-2.0 both run Python code from their Hugging Face repositories (trust_remote_code).
8. Start the web app
The web app uses RMBG-2.0, nvdiffrast, and nvdiffrec, so I use it only to try images and settings. The models I keep come from step 9.
Open a new terminal in WSL Ubuntu and start Microsoft’s app from the repository root:
source ~/miniforge3/etc/profile.d/conda.sh
conda activate trellis2
cd ~/TRELLIS.2
mkdir -p ~/.cache/trellis2/gradio
MALLOC_MMAP_THRESHOLD_=1048576 MALLOC_ARENA_MAX=2 \
GRADIO_TEMP_DIR="$HOME/.cache/trellis2/gradio" \
python app.pyLoading the eight models took about 80 seconds. When the log shows the local URL, open it in a Windows browser:
* Running on local URL: http://127.0.0.1:7860The two MALLOC_ variables prevent the out-of-memory kill described in 8.1. GRADIO_TEMP_DIR keeps Gradio’s uploads and results on disk instead of /tmp, which uses RAM on Ubuntu 26.04. The app listens only on 127.0.0.1; leave Gradio’s public share link off.
Resolution defaults to 1024 in this app. Select 512 for the first test, upload an image, and click Generate. When the preview appears, click Extract GLB, then Download GLB.
With Microsoft’s example image assets/example_image/T.png and the default 500,000 faces and 2048px textures, each 512 run took 38 to 64 seconds to generate and 21 to 27 seconds to extract. The GLB files were about 20MB. Press Ctrl+C in the terminal to stop the app.
8.1 Why the second generation was killed
Before I added these settings, the app generated one model and was then killed during its second generation. The kernel log showed an out-of-memory kill:
Out of memory: Killed process 2953 (python) total-vm:153968276kB, anon-rss:31973772kB, file-rss:600kB, shmem-rss:79680kB, UID:1000 pgtables:68036kB oom_score_adj:0The process had reached about 30.5 GiB of the 31.3 GiB available to WSL. This was not a CUDA error. With low_vram, the default, TRELLIS.2 moves each model between the CPU and GPU on every request, and Gradio runs requests on worker threads. glibc kept the freed CPU copies of the weights in the process instead of returning them to the system.
A test that repeated only the pipeline’s own .to() and .cpu() calls showed the effect:
| malloc settings | Process memory (RSS) |
|---|---|
| glibc defaults | 10,295 MiB at the start, 15,667 MiB after two rounds on the main thread, 20,989 MiB after one more round on a new thread |
MALLOC_MMAP_THRESHOLD_=1048576, MALLOC_ARENA_MAX=2 | 12,357–12,427 MiB after two rounds on the main thread and two on new threads |
In the default case, malloc_trim(0) returned 8,631 MiB immediately, so the memory had been freed but not released.
A fixed 1 MiB mmap threshold makes glibc return large freed blocks to the system, and MALLOC_ARENA_MAX=2 limits the per-thread arenas; both variables are described in mallopt(3). With both settings and all eight models loaded, the app used about 15 GiB while idle and up to 19 GiB during generation, with no further out-of-memory kills.
8.2 1024 in the web app
1024 worked in the web app, but not reliably. In one session, I ran 1024, 512, and 1024 again with the example image:
| Run | Resolution | Result | Generate (until preview) | Extract GLB | Peak dedicated GPU memory |
|---|---|---|---|---|---|
| 1 | 1024 | Succeeded | 167.7 s | 37.7 s | 15,955 of 16,311 MiB |
| 2 | 512 | Succeeded | 40.5 s | 21.0 s | Not recorded |
| 3 | 1024 | CUDA out of memory in the preview render | — | — | 16,029 of 16,311 MiB |
The two 1024 runs peaked about 70 MiB apart, so whether 1024 completes depends on the image, the seed, and whatever else is using GPU memory. The failure came from the 48-view preview that the app renders after each generation. The app kept running, and the next 512 run succeeded without a restart.
In a separate test with the same 1024 settings, PyTorch’s allocated memory peaked at 7,261 MiB during generation and 14,317 MiB during the preview render. The GLB does not need the preview, so for 1024 and 1536 I used a script without it.
9. Generate 1024 and 1536 models from the command line
tools/generate_commercial.py in my fork runs the same steps as Generate and Extract GLB with the app’s default sampler settings, but skips the preview and replaces the two components that are not licensed for commercial use:
- Background removal: BiRefNet (MIT) at a fixed revision instead of RMBG-2.0 (CC BY-NC 4.0).
- Texture baking: CuMesh’s cuBVH (MIT) instead of nvdiffrast, whose license allows research or evaluation use only.
The script also blocks nvdiffrast and nvdiffrec, records which libraries were loaded, and exits with code 3 if that audit is not clean. Textures are written as PNG.
Stop the web app with Ctrl+C first. Each process needed 15 to 20 GiB of RAM, so they should not run at the same time.
Generate a 1024 model with the web app’s default 500,000 faces and 2048px textures:
source ~/miniforge3/etc/profile.d/conda.sh
conda activate trellis2
cd ~/TRELLIS.2
MALLOC_MMAP_THRESHOLD_=1048576 MALLOC_ARENA_MAX=2 \
python tools/generate_commercial.py \
--input /mnt/c/Users/me/Pictures/figurine.png \
--output /mnt/c/Users/me/Pictures/figurine-1024-seed{seed}.glb \
--resolution 1024 --seeds 42 \
--result /mnt/c/Users/me/Pictures/figurine-1024.jsonReplace the paths with your own; Windows drives are under /mnt/c. The script prints a [gen] line after each stage.
The web UI allows up to 1,000,000 faces and 4096px textures. For the highest settings, use 1536. --seeds 42,7,123 would try several seeds with one model load:
MALLOC_MMAP_THRESHOLD_=1048576 MALLOC_ARENA_MAX=2 \
python tools/generate_commercial.py \
--input /mnt/c/Users/me/Pictures/figurine.png \
--output /mnt/c/Users/me/Pictures/figurine-1536-seed{seed}.glb \
--resolution 1536 --seeds 42 \
--decimation 1000000 --texture 4096 \
--result /mnt/c/Users/me/Pictures/figurine-1536.jsonMy 1536 run printed:
[gen] 74.6s models loaded (8)
[gen] 77.9s input prepared (background removed, cropped)
[gen] 190.6s seed 42: 3D generated (1536_cascade, resolution 1536, 112.6 s)
[gen] 247.0s seed 42: GLB exported (68,137,156 bytes, 56.4 s)
[gen] commercial audit: clean
[gen] result: PASSThe input was a 1024×1536 PNG of a figurine on a white background:
| Setting | Generate | Export | GLB | Peak PyTorch GPU memory |
|---|---|---|---|---|
| 1024, 500,000 faces, 2048px | 58.1 s | 18.5 s | 25.6MB, 484,921 faces | 3,188 MiB |
| 1536, 1,000,000 faces, 4096px | 112.6 s | 56.4 s | 68.1MB, 989,424 faces | 5,814 MiB |
The GPU column is PyTorch’s peak allocation in the process. 1536_cascade lowers the resolution by itself when an object needs more than 49,152 tokens, and this run stayed at 1536 with 14,718 tokens. The figurine was much simpler than Microsoft’s example image: at 1024, generation peaked at 2,847 MiB of PyTorch memory here, against 7,261 MiB for T.png. A more complex image may not fit at 1536.
To check the cuBVH baking, I rasterized the UV layouts of two earlier models with both nvdiffrast and cuBVH. 99.9% of the covered texels matched, and the few that differed were on triangle edges. The fork’s tools/README.md has the numbers.
PNG textures make the files larger, but the GLB no longer requires EXT_texture_webp, and Blender 5.2 imported the 1536 model with its textures connected. In an earlier run with three seeds, one seed shifted the colors and faced the opposite direction, so try a few seeds.
9.1 Export again with another face count
The face count and texture size are export settings. The export simplifies the generated mesh to the target, unwraps new UVs, and bakes the textures from the generated 3D data. Reducing a finished GLB in another tool is not the same. In my 1,000,000-face GLB, 175,993 of the 669,657 vertices were duplicates along UV seams, and the old textures would be reused instead of baked again.
To change these settings later without generating again, add --save-latent /mnt/c/Users/me/Pictures/figurine-1536-seed{seed}-latent.npz to the command above. It keeps the shape and texture latents, the result that the web app keeps between Generate and Extract GLB. At 1536, the file was 3.5MB. It also records the model revision, because only the same decoders give the same model.
Then export it with other settings. --from-latent loads only the two decoders, so it does not need the image, background removal, or DINOv3:
MALLOC_MMAP_THRESHOLD_=1048576 MALLOC_ARENA_MAX=2 \
python tools/generate_commercial.py \
--from-latent /mnt/c/Users/me/Pictures/figurine-1536-seed42-latent.npz \
--output /mnt/c/Users/me/Pictures/figurine-1536-seed42-100k.glb \
--decimation 100000 --texture 4096 \
--result /mnt/c/Users/me/Pictures/figurine-1536-100k.jsonMy result was:
[gen] 7.4s models loaded (2)
[gen] 14.3s latent decoded (seed 42, resolution 1536, 6.7 s)
[gen] 56.8s seed 42: GLB exported (33,496,352 bytes, 42.5 s)
[gen] commercial audit: clean
[gen] result: PASSFor a 100,000-face GLB with 4096px textures:
| Route | Time | Peak process memory (RSS) | Models loaded |
|---|---|---|---|
| Generate again from the image | 236.4 s | 20,017 MiB | 8 |
| Export from the saved latent | 56.8 s | 4,430 MiB | 2 |
The latent decoded to the same raw mesh as the generation. The remeshing step in the export is not deterministic, so four 100,000-face GLBs of this generation had 99,002 to 99,622 faces, and their mean surface distance was under 0.01% of the model size.
I wanted a lighter version of the figurine for a game. At 100,000 faces, the GLB was 33.1MB instead of 68.1MB, mostly the two 4096px PNG textures. In Blender, the textured model looked almost the same as the 1,000,000-face one, and only close-ups without textures showed softer hair grooves and ear edges.
Commercial use
This table is my reading of the license texts, not legal advice:
| Component | License | Used by |
|---|---|---|
| TRELLIS.2 code and weights | MIT | Web app and generator |
| DINOv3 | DINOv3 License: commercial use allowed, with conditions such as trade controls and prohibited military uses | Web app and generator |
| RMBG-2.0 | CC BY-NC 4.0: non-commercial use; BRIA sells a commercial license | Web app |
| nvdiffrast, nvdiffrec | NVIDIA Source Code License: research or evaluation only | Web app |
| BiRefNet | MIT | Generator |
| CuMesh (with cuBVH), FlexGEMM, o-voxel | MIT | Web app and generator |
I did not review PyTorch, the other Python packages, or the CUDA libraries. Check the current terms before you ship a model.
Troubleshooting
CUDA disappears after an NVIDIA driver update
During the test, the NVIDIA driver on Windows changed from 617.42 to 621.14 in the background while WSL was running. Afterward, nvidia-smi crashed with a segmentation fault inside WSL, and PyTorch reported:
RuntimeError: Found no NVIDIA driver on your system. Please check that you have an NVIDIA GPU and installed a driver from http://www.nvidia.com/Download/index.aspxThe running web app still answered HTTP requests, but its GPU access was gone. Stop the app. After WSL stopped and started again, the new driver worked. If you do not want to wait for WSL to stop on its own, run wsl --shutdown, which stops every running distribution.
conda activate exits in a script with set -u
The conda-forge CUDA compiler’s activation script reads NVCC_PREPEND_FLAGS without a default. In a Bash script with set -u, conda activate trellis2 stops with this error (path shortened):
.../etc/conda/activate.d/~cuda-nvcc_activate.sh: line 43: NVCC_PREPEND_FLAGS: unbound variableTurn nounset off around the activation:
set +u
source ~/miniforge3/etc/profile.d/conda.sh
conda activate trellis2
set -uConclusion
The RTX 5060 Ti 16GB could run TRELLIS.2 in WSL 2 with two changes. The web app needed the glibc settings to survive repeated generations, and 1024 or 1536 needed a route without the 48-view preview, which used almost all 16GB at 1024.
With these results, this is how I would use it:
| Work | How I would run it |
|---|---|
| Trying an image or settings | Web app at 512 |
| A model to keep | tools/generate_commercial.py at 1024 |
| Close-up detail | tools/generate_commercial.py at 1536 with 1,000,000 faces, 4096px textures, and a few seeds |
| Another face count or texture size | --from-latent on a latent saved with --save-latent |
These results come from two input images and a few seeds. A more complex object may need more GPU memory at 1024 or 1536, and Microsoft does not list 16GB as a supported configuration.