Browse by type
Samples for CUDA Developers which demonstrates features in CUDA Toolkit. This version supports CUDA Toolkit 13.5.
This section describes the release notes for the CUDA Samples on GitHub only.
Download and install the CUDA Toolkit for your corresponding platform. For system requirements and installation instructions of cuda toolkit, please refer to the Linux Installation Guide, and the Windows Installation Guide.
Using git clone the repository of CUDA Samples using the command below.
git clone https://github.com/NVIDIA/cuda-samples.git
Without using git the easiest way to use these samples is to download the zip file containing the current version by clicking the "Download ZIP" button on the repo page. You can then unzip the entire archive and use the samples.
The CUDA Samples are built using CMake. Follow the instructions below for building on Linux, Windows, natively on Tegra, and for cross-compilation to Automotive Linux and QNX.
Ensure that CMake (version 3.20 or later) is installed. Install it using your package manager if necessary:
e.g.
sudo apt install cmake
Navigate to the root of the cloned repository and create a build directory:
mkdir build && cd build
Configure the project with CMake:
cmake ..
Build the samples:
make -j$(nproc)
By default, samples are compiled for all GPU architectures supported by this release. If you only need to target a specific GPU, you can override this to build for a single architecture and reduce build time considerably:
cmake -DCMAKE_CUDA_ARCHITECTURES=<arch> ..
Replace <arch> with your GPU's SM version (e.g. 90 for sm_90).
Run the samples from their respective directories in the build folder.
To build just one sample, configure CMake from within the sample's directory. You must explicitly specify a GPU architecture — standalone builds have no top-level default:
cd cpp/<category>/<sampleName>
mkdir -p build && cd build
cmake -DCMAKE_CUDA_ARCHITECTURES=<arch> ..
make
Replace <arch> with your GPU's SM version (e.g. 90 for sm_90).
Language services for CMake are available in Visual Studio 2019 version 16.5 or later, and you can directly import the CUDA samples repository from either the root level or from any subdirectory or individual sample.
To build from the command line, open the x64 Native Tools Command Prompt for VS provided with your Visual Studio installation.
Navigate to the root of the cloned repository and create a build directory:
mkdir build && cd build
Configure the project with CMake - for example:
cmake .. -G "Visual Studio 16 2019" -A x64
Open the generated solution file CUDA_Samples.sln in Visual Studio. Build the samples by selecting the desired configuration (e.g., Debug or Release) and pressing F7 (Build Solution).
Run the samples from the output directories specified in Visual Studio.
NVIDIA GPUs support on-GPU debugging through cuda-gdb. Enabling this may significantly affect application performance as certain compiler optimizations are disabled
in this configuration, hence it's not on by default. Enablement of on-device debugging is controlled via the -G switch to nvcc.
To enable cuda-gdb for samples builds, define the ENABLE_CUDA_DEBUG flag on the CMake command line. For example:
cmake -DENABLE_CUDA_DEBUG=True ...
Some CUDA samples are specific to certain platforms, and require passing flags into CMake to enable. In particular, we define the following platform-specific flags:
BUILD_TEGRA - for Tegra-specific samplesTo build these samples, set the variables either on the command line or through your CMake GUI. For example:
cmake -DBUILD_TEGRA=True ..
Build on the Tegra device itself (Jetson L4T or Drive OS Linux). Do not pass a CMake toolchain file; the compilers on the board already target aarch64 Linux. Cross compilation from x86 is covered in the Automotive Linux and QNX sections below.
Ensure that CMake (version 3.20 or later) and the CUDA toolkit are installed on the device. Then, from the repository root:
mkdir build && cd build
cmake .. -DBUILD_TEGRA=True \
-DCMAKE_CUDA_COMPILER=/usr/local/cuda/bin/nvcc \
-DCMAKE_CUDA_ARCHITECTURES=<arch>
make -j$(nproc)
Replace <arch> with the GPU SM version (87 for Orin, 110 for Thor).
On some Drive OS installs the toolkit keeps headers and libraries only under a chip-suffixed directory such as targets/aarch64-linux-thor, and nvcc's default target directory does not find them. In that case add the matching flag (use the directory name that exists under /usr/local/cuda/targets/):
cmake .. -DBUILD_TEGRA=True \
-DCMAKE_CUDA_COMPILER=/usr/local/cuda/bin/nvcc \
-DCMAKE_CUDA_ARCHITECTURES=110 \
-DCMAKE_CUDA_FLAGS="--target-directory aarch64-linux-thor"
To build CUDA samples to the target platform from the DriveOS Docker containers, use the following instructions.
Mount the target Root Filesystem (RFS) in the container so that the CUDA cmake process has the correct paths to CUDA and other system libraries required to build the samples.
Create a temporary directory, <temp> is any temporary directory of your choosing, for example, you can use /drive/temp:
$ mkdir /drive/<temp>
Mount the filesystem by running the following command:
$ mount /drive/drive-linux/filesystem/targetfs-images/dev_nsr_desktop_ubuntu-24.04_thor_rfs.img /drive/temp
Configure the project by running the following cmake command. Replace cuda-XX.X with the CUDA version on the target filesystem, and aarch64-linux-thor with the directory name that exists under targets/ (on both the host toolkit and the mounted RFS):
$ mkdir build && cd build
$ cmake .. -DBUILD_TEGRA=True \
-DCMAKE_CUDA_COMPILER=/usr/local/cuda/bin/nvcc \
-DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/toolchain-aarch64-linux.cmake \
-DTARGET_FS=/drive/temp \
-DCMAKE_CUDA_FLAGS="--target-directory aarch64-linux-thor" \
-DCMAKE_LIBRARY_PATH=/drive/temp/usr/local/cuda-XX.X/targets/aarch64-linux-thor/lib/ \
-DCMAKE_INCLUDE_PATH=/drive/temp/usr/local/cuda-XX.X/targets/aarch64-linux-thor/include/
Please note that the following libraries are not pre-installed in the DriveOS dev-nsr target filesystem: * libdrm-dev * Vulkan
This causes the cmake command to throw errors related to the missing files, and as a result, the related samples will not build in later steps. This issue will be addressed in a future DriveOS release.
To build the samples with ignore the error mentioned above, you can use --ignore-errors/--keep-going or comment out the comment out the corresponding add_subdirectory command in the CMakeLists.txt in the parent folder for the samples requiring Vulkan and libdrm_dev:
$ make -j$(nproc) --ignore-errors # or --keep-going
# In cpp/5_Domain_Specific/CMakeLists.txt
# add_subdirectory(simpleGL)
# add_subdirectory(simpleVulkan)
# add_subdirectory(simpleVulkanMMAP)
# In cpp/8_Platform_Specific/Tegra/CMakeLists.txt
# add_subdirectory(simpleGLES_EGLOutput)
Cross-compilation for QNX with CMake is supported in the CUDA 13.0 samples release and newer.
Set up the QNX SDP paths:
export QNX_HOST=/path/to/qnx/host
export QNX_TARGET=/path/to/qnx/target
Build the samples for the Tegra Thor QNX platform. Replace aarch64-qnx-thor with the directory name that exists under /usr/local/cuda/targets/:
mkdir -p build && cd build
cmake .. \
-DBUILD_TEGRA=True \
-DCMAKE_CUDA_COMPILER=/usr/local/cuda/bin/nvcc \
-DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/toolchain-aarch64-qnx.cmake \
-DTARGET_FS=/path/to/qnx/targetfs \
-DCMAKE_CUDA_FLAGS="--target-directory aarch64-qnx-thor" \
-DCMAKE_LIBRARY_PATH=/usr/local/cuda/targets/aarch64-qnx-thor/lib/stubs/ \
-DCMAKE_INCLUDE_PATH=/usr/local/cuda/targets/aarch64-qnx-thor/include/
cmake --build .
TARGET_FS is the QNX target filesystem of your board. The cudaNvSci sample needs it, because the NvSci headers and libraries ship with the target filesystem and not with the CUDA toolkit. Without TARGET_FS the build reports NvSCI not found and skips the sample.
The target filesystem is part of the NVIDIA DRIVE OS QNX SDK, which registered users download from NVONLINE. After the SDK is installed, the filesystem is in the DRIVE OS workspace: <NV_WORKSPACE>/drive-qnx for the standard SDK and <NV_WORKSPACE>/drive-qnx-safety for the safety SDK. See the DRIVE OS documentation for the installation guides.
For both QNX toolchains the build looks for nvscibuf.h in <TARGET_FS>/include, <TARGET_FS>/../include and <TARGET_FS>/usr/include, and for libnvscibuf.so in <TARGET_FS>/lib-target, <TARGET_FS>/usr/libnvidia and <TARGET_FS>/usr/lib. If your filesystem uses a different layout, set NVSCIBUF_INCLUDE_DIR, NVSCISYNC_INCLUDE_DIR, NVSCIBUF_LIBRARY and NVSCISYNC_LIBRARY on the cmake command line instead.
Cross-compilation for QNX Safety uses the CUDA Safe toolkit (for example /usr/local/cuda-XX.X-safe).
Set up the QNX SDP and Safe toolkit paths:
export QNX_HOST=/path/to/qnx/host
export QNX_TARGET=/path/to/qnx/target
export CUDA_PATH=/usr/local/cuda-XX.X-safe
export PATH=$CUDA_PATH/nvvm/bin:$PATH
Build a single sample (standalone configure from the sample directory).
mkdir -p build && cd build
cmake .. \
-DCMAKE_TOOLCHAIN_FILE=../../../cmake/toolchains/toolchain-aarch64-qnx-safe.cmake \
-DCMAKE_CUDA_COMPILER=$CUDA_PATH/bin/nvcc \
-DCMAKE_CUDA_ARCHITECTURES=110 \
-DTARGET_FS=/path/to/qnx/safety/targetfs
cmake --build .
The safe toolchain sets -safety-compat, links shared libcudart and libcuda, and uses QNX q++ as the CUDA host compiler (CMAKE_CUDA_HOST_COMPILER). Set CMAKE_CUDA_ARCHITECTURES to match your GPU (87 for Orin, 110 for Thor).
Supported QNX Safety samples: matrixMul, cudaNvSci and all samples in cpp/10_Safety directory.
TARGET_FS is only needed for cudaNvSci, which links the NvSci libraries from the safety target filesystem (<NV_WORKSPACE>/drive-qnx-safety, part of the DRIVE OS QNX Safety SDK). matrixMul and sharedCtx build without it. The NvSci search paths are the same as for the standard QNX build above.
To build samples with new CUDA Toolkit(CUDA 13.0 or later) and UMD(Version 580 or later) and old KMD(Version 550 or earlier),you need to set the CMAKE_PREFIX_PATH for using new driver library, the command might like this:
cmake -DCMAKE_PREFIX_PATH=/usr/local/cuda/lib64/stubs/ ..
The repository includes Python examples under the python/ directory. These samples are cuda.core–focused: they use CUDA Python, with cuda.core for devices, programs, launches, and memory, alongside NumPy, CuPy, or framework interop where each sample notes.
Layout (same themes as the C++ samples):
| Directory | Contents |
|---|---|
python/1_GettingStarted/ |
Introductory scripts (e.g. vectorAdd, deviceQuery, systemInfo, image blur with unified memory, NumPy vs CuPy). |
python/2_CoreConcepts/ |
Algorithms and techniques (e.g. reductions, histograms, FFT, stream overlap, memoryResources, cudaGraphs, jitLtoLinking, tmaTensorMap). |
python/3_FrameworkInterop/ |
Integration with PyTorch and TensorFlow. |
python/4_DistributedComputing/ |
Multi-GPU, peer-to-peer, and IPC patterns (ipcMemoryPool). |
python/Utilities/ |
Shared helpers imported by some samples. |
How to run: The top-level CMake build does not compile these samples. For each sample, use a Python 3.10+ environment with a matching CUDA Toolkit (the samples target CUDA 13.x and document exact package pins in requirements.txt):
cd python/<category>/<sampleName>
pip install -r requirements.txt
python <sampleScript>.py
Use each sample’s README.md for prerequisites, CLI options, and expected output.
The installation system automatically organizes samples into a structured directory layout based on:
- Target Architecture: ${CMAKE_SYSTEM_PROCESSOR}, e.g. x64, aarch64, amd64, etc.
- Target OS: linux, windows, darwin, qnx
- Build Type: release, debug, etc.
The default installation path is: build/bin/${TARGET_ARCH}/${TARGET_OS}/${BUILD_TYPE}
Examples:
- Linux x86_64 Release: build/bin/x64/linux/release
- Linux aarch64 Release: build/bin/aarch64/linux/release
- Windows amd64 Release: build/bin/amd64/windows/release
You can customize the installation location using CMake variables during the configuration step:
CMAKE_INSTALL_PREFIX: Changes the root installation directory (default: build/bin)
cmake -DCMAKE_INSTALL_PREFIX=/custom/path ..
This will install to: /custom/path/${TARGET_ARCH}/${TARGET_OS}/${BUILD_TYPE}
CUDA_SAMPLES_INSTALL_DIR: Specifies the exact final installation directory (overrides the structured path)
```
cmake -DCUDA_SAMP
$ claude mcp add cuda-samples \
-- python -m otcore.mcp_server <graph>