Ever wanted to train a NeRF model of a fox in under 5 seconds? Or fly around a scene captured from photos of a factory robot? Of course you have!
Here you will find an implementation of four neural graphics primitives, being neural radiance fields (NeRF), signed distance functions (SDFs), neural images, and neural volumes.
In each case, we train and render a MLP with multiresolution hash input encoding using the tiny-cuda-nn framework.
If you have Windows and if you do not need Python bindings, you can download one of the following binary releases and then jump directly to the usage instructions. These releases are automatically regenerated whenever the code gets updated, so you can be sure that they have the latest features.
If you use Linux, or want the Python bindings, or if your GPU is not listed above (e.g. Hopper, Volta, or Maxwell generations), use the following step-by-step instructions to compile instant-ngp yourself.
Requirements
An NVIDIA GPU; tensor cores increase performance when available. All shown results come from an RTX 3090.
A C++14 capable compiler. The following choices are recommended and have been tested:
Windows: Visual Studio 2019 or 2022
Linux: GCC/G++ 8 or higher
A recent version of CUDA. The following choices are recommended and have been tested:
If compilation fails inexplicably or takes longer than an hour, you might be running out of memory. Try running the above command without -j in that case.
If this does not help, please consult this list of possible fixes before opening an issue.
If the build succeeds, you can now run the code via the build/instant-ngp executable or the scripts/run.py script described below.
If automatic GPU architecture detection fails, (as can happen if you have multiple GPUs installed), set the TCNN_CUDA_ARCHITECTURES environment variable for the GPU you would like to use. The following table lists the values for common GPUs. If your GPU is not listed, consult this exhaustive list.
H100
40X0
30X0
A100
20X0
TITAN V / V100
10X0 / TITAN Xp
9X0
K80
90
89
86
80
75
70
61
52
37
Interactive training and rendering
This codebase comes with an interactive GUI that includes many features beyond our academic publication:
Additional training features, such as extrinsics and intrinsics optimization.
Marching cubes for NeRF->Mesh and SDF->Mesh conversion.
A spline-based camera path editor to create videos.
Debug visualizations of the activations of every neuron input and output.
To reproduce the gigapixel results, download, for example, the Tokyo image and convert it to .bin using the scripts/convert_image.py script. This custom format improves compatibility and loading speed when resolution is high. Now you can run:
Here are the main keyboard controls for the instant-ngp application.
Key
Meaning
WASD
Forward / pan left / backward / pan right.
Spacebar / C
Move up / down.
= or + / - or _
Increase / decrease camera velocity.
E / Shift+E
Increase / decrease exposure.
T
Toggle training. After around two minutes training tends to settle down, so can be toggled off.
R
Reload network from file.
Shift+R
Reset camera.
O
Toggle visualization or accumulated error map.
G
Toggle visualization of the ground truth.
M
Toggle multi-view visualization of layers of the neural model. See the paper's video for a little more explanation.
, / .
Shows the previous / next visualized layer; hit M to escape.
1-8
Switches among various render modes, with 2 being the standard one. You can see the list of render mode names in the control interface.
There are many controls in the instant-ngp GUI.
First, note that this GUI can be moved and resized, as can the "Camera path" GUI (which first must be expanded to be used).
Some popular user controls in instant-ngp are:
Snapshot: use Save to save the NeRF solution generated, Load to reload. Necessary if you want to make an animation.
Rendering -> DLSS: toggling this on and setting "DLSS sharpening" below it to 1.0 can often improve rendering quality.
Rendering -> Crop size: trim back the surrounding environment to focus on the model. "Crop aabb" lets you move the center of the volume of interest and fine tune. See more about this feature in our NeRF training & dataset tips.
The "Camera path" GUI lets you set frames along a path. "Add from cam" is the main button you'll want to push, then saving out the camera keyframes using "Save" to create a base_cam.json file. There is a bit more information about the GUI in this post and in this (bit dated) video.
Python bindings
To conduct controlled experiments in an automated fashion, all features from the interactive GUI (and more!) have Python bindings that can be easily instrumented.
For an example of how the ./build/instant-ngp application can be implemented and extended from within Python, see ./scripts/run.py, which supports a superset of the command line arguments that ./build/instant-ngp does.
Here is a typical command line using scripts/run.py to generate a 5-second flythrough of the fox dataset to the (default) file video.mp4, after using the GUI to save a (default) NeRF snapshot base.msgpack and a set of camera key frames: (see this video for a guided walkthrough)
A: Yes. See this example inspired on the notebook created by user @myagues. Caveat: this codebase requires large amounts of GPU RAM and might not fit on your assigned GPU. It will also run slower on older GPUs.
Q: How can I save the trained model and load it again later?
A: Two options:
Use the GUI's "Snapshot" section.
Use the Python bindings load_snapshot / save_snapshot (see scripts/run.py for example usage).
Q: Can this codebase use multiple GPUs at the same time?
A: No. To select a specific GPU to run on, use the CUDA_VISIBLE_DEVICES environment variable. To optimize the compilation for that specific GPU use the TCNN_CUDA_ARCHITECTURES environment variable.
Q: The NeRF reconstruction of my custom dataset looks bad; what can I do?
A: There could be multiple issues:
COLMAP might have been unable to reconstruct camera poses.
There might have been movement or blur during capture. Don't treat capture as an artistic task; treat it as photogrammetry. You want *as little blur as possible* in your dataset (motion, defocus, or otherwise) and all objects must be *static* during the entire capture. Bonus points if you are using a wide-angle lens (iPhone wide angle works well), because it covers more space than narrow lenses.
The dataset parameters (in particular aabb_scale) might have been tuned suboptimally. We recommend starting with aabb_scale=16 and then increasing or decreasing it by factors of two until you get optimal quality.
Q: Why are background colors randomized during NeRF training?
A: Transparency in the training data indicates a desire for transparency in the learned model. Using a solid background color, the model can minimize its loss by simply predicting that background color, rather than transparency (zero density). By randomizing the background colors, the model is forced to learn zero density to let the randomized colors "shine through".
Q: How to mask away NeRF training pixels (e.g. for dynamic object removal)?
A: For any training image xyz.* with dynamic objects, you can provide a dynamic_mask_xyz.png in the same folder. This file must be in PNG format, where non-zero pixel values indicate masked-away regions.
Troubleshooting compile errors
Before investigating further, make sure all submodules are up-to-date and try compiling again.
If instant-ngp still fails to compile, update CUDA as well as your compiler to the latest versions you can install on your system. It is crucial that you update both, as newer CUDA versions are not always compatible with earlier compilers and vice versa.
If your problem persists, consult the following table of known issues.
*After each step, delete the build folder and let CMake regenerate it before trying again.*
Problem
Resolution
CMake error: No CUDA toolset found / CUDA_ARCHITECTURES is empty for target "cmTC_0c70f"
Windows: the Visual Studio CUDA integration was not installed correctly. Follow these instructions to fix the problem without re-installing CUDA. (#18)
Linux: Environment variables for your CUDA installation are probably incorrectly set. You may work around the issue using cmake . -B build -DCMAKE_CUDA_COMPILER=/usr/local/cuda-<your cuda version>/bin/nvcc (#28)
CMake error: No known features for CXX compiler "MSVC"
Reinstall Visual Studio & make sure you run CMake from a developer shell. Make sure you delete the build folder before building again. (#21)
Compile error: A single input file is required for a non-link phase when an outputfile is specified
Ensure there no spaces in the path to instant-ngp. Some build systems seem to have trouble with those. (#39#198)
Compile error: undefined references to "cudaGraphExecUpdate" / identifier "cublasSetWorkspace" is undefined
Update your CUDA installation (which is likely 11.0) to 11.3 or higher. (#34#41#42)
Compile error: too few arguments in function call
Update submodules with the above two git commands. (#37#52)
Python error: No module named 'pyngp'
It is likely that CMake did not detect your Python installation and therefore did not build pyngp. Check CMake logs to verify this. If pyngp was built in a different folder than instant-ngp/build, Python will be unable to detect it and you have to supply the full path to the import statement. (#43)
Many thanks to Jonathan Tremblay and Andrew Tao for testing early versions of this codebase and to Arman Toorians and Saurabh Jain for the factory robot dataset.
We also thank Andrew Webb for noticing that one of the prime numbers in the spatial hash was not actually prime; this has been fixed since.
This project makes use of a number of awesome open source libraries, including:
tiny-cuda-nn for fast CUDA networks and input encodings
