GET3D by NVIDIA

Where GET3D sits

GET3D is not a product in the sense most entries in this catalog are products. It is a research artifact: the official PyTorch implementation of a NeurIPS 2022 paper from NVIDIA's Toronto AI lab, written by Jun Gao, Tianchang Shen, Zian Wang and colleagues at NVIDIA, the University of Toronto and the Vector Institute. There is no signup form, no hosted demo you can type a prompt into, and no sales team. What you get is code on GitHub, four pretrained checkpoints, a Colab notebook and a paper. In my view that matters for how you should read every claim on its project page: the images of cars, chairs, animals, motorbikes, humans and buildings are research results, not a menu of things the shipped code will make for you today.

That said, GET3D is historically important and still instructive. It was one of the first generative models to output explicit textured meshes — real geometry with real UV-mapped color that you can drop into Blender or a game engine — rather than a neural field that needs another process to become a mesh. If you are evaluating 3D generation tools in 2026 and you want to understand what the current text-to-3D services grew out of, this is the reference implementation worth an afternoon. If you need production assets next week, it is the wrong tool and I will explain exactly why below.

What GET3D actually does

The model generates 3D shapes from two latent codes: one drives geometry, the other drives texture. Internally it predicts a signed distance function plus a texture field, then uses DMTet (differentiable marching tetrahedra) to extract a triangle mesh from the SDF and queries the texture field at surface points to color it. Training is the clever part: it needs only 2D image collections as supervision. A rasterization-based differentiable renderer produces RGB images and silhouettes, two 2D discriminators judge them as real or fake, and the whole system trains end-to-end as a 3D-aware GAN. The headline claim in the paper — that GET3D produces meshes with complex topology, geometric detail and textures that render engines can consume directly — is credible and well demonstrated in the figures.

The critical clarification: GET3D generates unconditionally. You sample a random latent code and you get a shape from the category the checkpoint was trained on. It is trained from 2D images; it does not take your 2D image and reconstruct a 3D model from it, and it takes no text. I have seen this misread many times, including in directory listings, so I am stating it plainly: there is no image-to-3D and no text-to-3D path in this repo.

What NVIDIA actually released is four pretrained checkpoints: ShapeNet Car, Chair and Motorbike (trained on the standard train.txt splits) and Table (trained on the full category). The paper's more exotic results — animals, human characters, buildings — were trained on TurboSquid and other collections that were not released, so you cannot reproduce them without your own data and a training run.

My testing notes

Setup is the whole battle. Walking through the repo, the environment requirements are a 2022 time capsule: 64-bit Python 3.8, PyTorch 1.9.0, CUDA toolkit 11.1 or later, the custom CUDA extensions borrowed from the StyleGAN3 codebase, plus Nvdiffrast and Kaolin. The authors recommend Linux "for performance and compatibility reasons" and note all development was done on V100 or A100 GPUs. There is an install script (install_get3d.sh), but on a modern stack the failure points are the pinned PyTorch and the StyleGAN3 custom ops, which are the usual suspects when old GAN code meets a new CUDA driver. Budget half a day for environment archaeology if your machine is not already running a 2022-era deep learning image. This is not a code-quality complaint — the code is clean research code — it is a statement about the cost of reproducing a four-year-old CUDA stack.

Inference is a one-line command with a long tail of flags. The README spells out exact invocations for each checkpoint, and the flags matter in non-obvious ways: --data_camera_mode shapenet_car selects category-specific camera conventions, --dmtet_scale is 1.0 for cars and motorbikes but 0.8 for chairs and tables, and the R1 regularization weight --gamma jumps from 40 to 400 for chairs and tables. Each run generates a 5×5 grid of shapes from random latents. Two flags change what you get out: --inference_to_generate_textured_mesh 1 writes actual textured meshes instead of just render visualizations, and --inference_save_interpolation 1 produces latent interpolation sequences. Inference needs a single GPU with at least 16GB of memory, which is the most accessible part of the whole setup.

Repo health check. As I write this the repository shows 4,427 stars and 407 forks with 35 open issues — a healthy research repo that has stopped moving. The last substantive changelog entry is dated 2023-09-15, when FlexiCubes support was added as a drop-in replacement for DMTet. There have been no feature updates since. Issue response is community-driven; there is no support contract of any kind.

License check. The code ships under the NVIDIA Source Code License, and section 3.3 limits use of the work and any derivative works to non-commercial purposes — "for research or evaluation purposes only" — while explicitly reserving commercial use to NVIDIA and its affiliates. The README directs business inquiries to NVIDIA's research licensing form. If you were hoping to generate assets for a commercial game or a client project with these weights, read that clause first; you would need a separate license from NVIDIA.

What GET3D does not do

It does not generate from text or images. It does not run in a browser or on Windows (Linux is recommended and the CUDA ops assume it). It does not offer an API, a managed service, or a queue — you run it yourself on your own hardware. It does not cover arbitrary categories out of the box: four checkpoints is what you get, and training your own means rendering a ShapeNet-style dataset with the bundled Blender 2.90 pipeline (the render scripts note Blender 2.90.0 was the only version tested), then running a multi-GPU training job. It does not produce PBR materials in the base configuration — the paper shows unsupervised material generation, but only when combined with the separate DIBR++ work. And it does not compete with the current generation of image-to-3D and text-to-3D tools on convenience; NVIDIA's own later 3D Object Generation Blueprint, for instance, builds a prompt-to-scene workflow on Microsoft TRELLIS and SANA rather than on GET3D.

Verdict

I rate GET3D 2.7 overall, and the number is a category judgment, not a quality judgment: 40% core functionality depth — the generator itself is genuinely good at what it does, but what it does is unconditional generation of four ShapeNet categories, which is a narrow tool for a 2026 buyer; 20% value — the code is free, but the non-commercial license and the GPU requirement make "free" conditional; 20% usability — the CLI, the pinned 2022 stack and the flag archaeology put it firmly in the bring-a-grad-student tier; 10% support and ecosystem — GitHub issues and a paper, no vendor support; 10% reliability signals — stable, well-cited code that has been frozen since late 2023. As research, it is exemplary and I learned a lot from reading it. As a tool you adopt this year, it is a baseline to measure newer systems against, not a system to build on — unless you have a research or evaluation use case, a spare A100 and a tolerance for CUDA work, in which case it is still one of the cleanest 3D-aware GAN codebases you can run.

Sources

• https://research.nvidia.com/labs/toronto-ai/GET3D/
• https://github.com/nv-tlabs/GET3D
• https://github.com/nv-tlabs/GET3D/tree/master/pretrained_model
• https://github.com/nv-tlabs/GET3D/blob/master/LICENSE.txt
• https://proceedings.neurips.cc/paper_files/paper/2022/hash/cebbd24f1e50bcb63d015611fe0fe767-Abstract-Conference.html
• https://arxiv.org/html/2209.11163v1
• https://github.com/nv-tlabs/GET3D/blob/master/install_get3d.sh
• https://github.com/nv-tlabs/GET3D/blob/master/train_3d.py
• https://github.com/nv-tlabs/GET3D/tree/master/render_shapenet_data
• https://research.nvidia.com/labs/toronto-ai/flexicubes/
• https://github.com/NVIDIA-AI-Blueprints/3d-object-generation
• https://nv-tlabs.github.io/GET3D/