Software Setup and Prerequisites#

Before you use NVIDIA Neural Reconstruction, set up the appropriate software and access you need on the recommended hardware setup.

Required software#

Docker installation on a supported platform (min. version 23.0.1) with the Buildx plugin, which builds the development image. Docker’s official install packages include it; confirm with docker buildx version.
NVIDIA Driver version R580 or newer, appropriate for your system. Find driver versions on the NVIDIA Driver Downloads page.
NVIDIA Container Toolkit (min. version 1.13.5) installed and configured.
Python 3.13, for any code you run against NuRec from outside the shipped container, including gRPC clients built from the NuRec protos. As of 26.08 the container and the custom wheels ship CPython 3.13.15. Releases through 26.06 shipped CPython 3.11, so client environments pinned to 3.11 must be rebuilt. You do not need a host Python installation to run NuRec itself, which executes inside the container.

Once you have the above prerequisites, confirm that your system is ready to continue.

Confirm that your container runtime supports NVIDIA GPUs. Run the following command:

docker run --rm --gpus all ubuntu nvidia-smi

Build and run from source#

Clone the repository on your host to build NuRec inside a development container. deps/docker/Dockerfile-dev.build builds it on top of the nurec_dev_deps image, which holds a set of pre-downloaded development dependencies:
```
git clone --branch release/26.10 https://github.com/NVIDIA/NuRec.git
cd NuRec
```

From the checkout root, run this setup in your host Bash terminal. NUREC_DEV_DEPS_IMAGE is the published dependency image that the build starts from; NUREC_IMAGE is the development image you build from it locally and then run everything in. NUREC_SRC is the checkout path; NUREC_OUTPUT_BASE keeps the build cache between container runs. bazelisk selects the repository’s Bazel version.

export NUREC_DEV_DEPS_IMAGE=ghcr.io/nvidia/nurec/nurec_dev_deps:26.10
export NUREC_IMAGE=nurec_dev:local
export NUREC_SRC="$PWD"
export NUREC_OUTPUT_BASE="$HOME/.cache/nurec-bazel"
export NUREC_BUILD_HOME="$NUREC_OUTPUT_BASE/build-home"
export CCACHE_DIR="$NUREC_OUTPUT_BASE/ccache"
NUREC_DOCKER_ARGS=()

docker buildx build --network=host --build-arg BASE_IMAGE="$NUREC_DEV_DEPS_IMAGE" -t "$NUREC_IMAGE" -f deps/docker/Dockerfile-dev.build --load deps/docker
mkdir -p "$NUREC_BUILD_HOME" "$CCACHE_DIR" "$NUREC_SRC/outputs"
printf 'build --action_env="HOME=%s"\n' "$NUREC_BUILD_HOME" > "$NUREC_OUTPUT_BASE/nurec.bazelrc"
printf 'build --host_action_env="HOME=%s"\n' "$NUREC_BUILD_HOME" >> "$NUREC_OUTPUT_BASE/nurec.bazelrc"
printf 'build --host_action_env="CCACHE_DIR=%s"\n' "$CCACHE_DIR" >> "$NUREC_OUTPUT_BASE/nurec.bazelrc"
printf 'test --test_env=USER\n' >> "$NUREC_OUTPUT_BASE/nurec.bazelrc"
printf 'build --sandbox_writable_path="%s"\n' "$NUREC_BUILD_HOME" "$CCACHE_DIR" >> "$NUREC_OUTPUT_BASE/nurec.bazelrc"

nurec_dev() {
  if [[ "$1" == bazelisk ]]; then
    shift
    set -- bazelisk --output_base="$NUREC_OUTPUT_BASE" \
      --bazelrc="$NUREC_OUTPUT_BASE/nurec.bazelrc" "$@"
  fi
  local tty_args=()
  if [[ -t 0 && -t 1 ]]; then tty_args=(-t); fi
  docker run --rm -i "${tty_args[@]}" --gpus all --shm-size=64g --network host \
    --user "$(id -u):$(id -g)" \
    --env HOME="$NUREC_BUILD_HOME" --env USER="$(id -un)" \
    --env CCACHE_DIR --env HF_TOKEN --env CUDA_VISIBLE_DEVICES \
    --volume "$NUREC_SRC:$NUREC_SRC" \
    --volume "$NUREC_OUTPUT_BASE:$NUREC_OUTPUT_BASE" \
    --workdir "$NUREC_SRC" \
    "${NUREC_DOCKER_ARGS[@]}" \
    "$NUREC_IMAGE" "$@"
}

Define nurec_dev once per terminal, then use it to run commands in the container from your host shell. Your source, outputs, and build cache persist between runs. The helper attaches a pseudo-TTY only when both stdin and stdout are terminals, so that commands whose output you capture — such as $(nurec_dev bazelisk info bazel-bin) — return a clean value instead of terminal line endings mixed with Bazel’s startup output.

Keep data in $NUREC_SRC/data and results in $NUREC_SRC/outputs. To use data elsewhere, mount its directory at the same path inside the container:
```
NUREC_DOCKER_ARGS+=(--volume /data/nurec:/data/nurec)
```
Build the application and tools:
```
nurec_dev bazelisk build //:run //apps:nurec_tools
```
A cold build is substantial: on one 16-core machine it took roughly 24 minutes. Treat that as an illustration rather than a target, since it scales with your core count, and expect the docker buildx build step in step 2 to add to it the first time. Later builds reuse the Bazel output base and ccache set up above, so they are much faster.

Once you’ve completed the prerequisite setup, move to the next steps to reconstruct your driving data: