NVIDIA DeepStream SDK is a streaming analytics toolkit for AI-based video and image understanding, providing a GStreamer-based framework to build multi-stream, multi-model inference pipelines on NVIDIA GPUs (dGPU and Jetson).

DeepStream pipelines combine hardware-accelerated decoding/encoding, TensorRT inference, object tracking, and message-broker integrations to deliver real-time video analytics across dGPU and Jetson platforms.

DeepStream is published as a unified GitHub repository; sources are to be used under the project LICENSE (documentation: CC-BY-4.0; source code: Apache-2.0). GitHub Release assets specific license details can be referred at Release Asset License under DeepStream Release Assets. The project is actively maintained, but currently not accepting code contributions — refer to the Contribution Guidelines for more details.

This repository contains the complete source code for DeepStream 9.2.

Components (src/):

• src/gst-plugins/ — DeepStream GStreamer plugin sources
• src/gst-utils/ — GStreamer utility library sources
• src/utils/ — utility library sources
• src/apps/sample_apps/ — GStreamer-based sample applications
• src/apps/reference_apps/ — advanced reference applications
• src/apps/tao_apps/ — TAO-model integration apps
• src/service-maker/ — Service Maker C++/Python SDK and apps
• src/3rdparty/ — x86-only vendored sources (gst-nvunixfd, gst-v4l2, v4l2) built by build/build.sh

Tools (tools/):

• inference_builder — visual inference pipeline builder
• auto-magic-calib — camera auto-calibration tool
• yolo_deepstream — YOLO + TensorRT integration
• sam2-onnx-tensorrt — SAM2 ONNX-to-TensorRT conversion
• deepstream-host-provisioning — Ansible playbooks to provision Ubuntu hosts (x86_64 & ARM SBSA) with the full NVIDIA compute stack (driver, CUDA, cuDNN, TensorRT, Docker) and DeepStream dependencies
• deepstream-otelcol — OpenTelemetry Collector setup for streaming metrics

AI agent skills (skills/, for Claude Code & compatible coding agents):

• deepstream-dev — general DeepStream development
• deepstream-generate-pipeline — interactive gst-launch pipeline builder
• deepstream-profile-pipeline — Nsight Systems profiling & config derivation
• deepstream-sop — SOP step-sequence compliance microservice
• deepstream-import-vision-model — autonomous vision-model onboarding
• deepstream-run-mv3dt — run the MV3DT reference app on sample or custom datasets
• deepstream-setup-on-wsl — set up and verify DeepStream in Docker inside WSL2
• inference-builder — generate deployable GPU inference pipelines from declarative configs
• deepstream-eval-and-finetune — evaluate and improve object detectors for DeepStream
• amc-setup-calibration-stack — launch the AutoMagicCalib microservice and UI
• amc-run-sample-calibration — verify AMC with the bundled sample dataset
• amc-run-video-calibration — calibrate user-provided MP4 camera videos
• amc-run-rtsp-calibration — calibrate live RTSP camera streams through VIOS capture
• rtvi-cv-customize-model — swap the CV detection model in RTVI-CV
• rtvi-vlm-customize-model — swap the VLM in the VSS Alerts Blueprint
• rtvi-cv-scaffold-vss-service — scaffold a custom RTVI CV microservice that publishes to VSS via Kafka

The Brev launchable workflow is available in deploy/brev/.

Before building, ensure the following prerequisites are installed:

• NVIDIA compute stack — driver, CUDA, cuDNN, and TensorRT at the versions listed below. See the DeepStream SDK Installation Guide.

• DeepStream 9.2 proprietary runtime — the prebuilt libraries and sample data are published as GitHub Release assets. bash build/build.sh automatically downloads the packages into artifacts/ before the build process starts.

  Note: After a successful build, artifacts/ is removed automatically. Pass --keep-assets to retain them.

SBSA / DGX Spark: DeepStream bare-metal installation is not supported on SBSA. Build and validation must be done inside the NVIDIA SBSA Docker container, which ships with DeepStream pre-installed — build/build.sh is not required inside the container. If you modify an open-source component, run make && make install in that component's directory to deploy the updated binaries/libs. See build/BUILD.md.

# Install Git LFS (required for LFS-tracked sample media in reference apps)
sudo apt-get install git-lfs && git lfs install

# Clone the repo with submodules
git clone --recurse-submodules https://github.com/NVIDIA/DeepStream.git && cd DeepStream

See build/BUILD.md for full build instructions, including system package dependencies (x86, aarch64, SBSA / DGX Spark), build/build.sh usage and environment variables (CUDA_VER, NVDS_VERSION, INSTALL_METHOD), and build output locations under /opt/nvidia/deepstream/deepstream-9.2/.

See src/README.md for component-specific READMEs, prerequisites, and platform limitations (on SBSA / DGX Spark only the source-available components are built), and CHANGELOG.md for the complete 9.2.0 release notes.

Supported Platforms

# Build. The script prompts for sudo only when installing to system paths.
bash build/build.sh

After bash build/build.sh, binaries are installed to /opt/nvidia/deepstream/deepstream-9.2/bin/. Run the reference deepstream-app with one of the sample configs:

cd /opt/nvidia/deepstream/deepstream-9.2/samples/configs/deepstream-app
deepstream-app -c source30_1080p_dec_infer-resnet_tiled_display.txt

# After the first install, clear the GStreamer plugin cache if needed:
rm -rf ~/.cache/gstreamer-1.0/

• More such examples: DeepStream Quickstart Guide
• Detailed API reference: DeepStream SDK Developer Guide

Each app must be run from its source directory so relative config paths resolve correctly. Refer to the README inside each app directory for app-specific run instructions and config options.

Optional. Skip this if the bare-metal build above already works for you. Use the Triton container when you need Triton-backed inference. On SBSA / DGX Spark, use the SBSA Docker container as described above — bare-metal installation is not supported.

NVIDIA publishes a DeepStream Docker image bundled with Triton Inference Server.

# Pull the image (use 9.2-triton-sbsa-dgx-spark instead on SBSA / DGX Spark)
docker pull ghcr.io/nvidia/deepstream:9.2-triton-multiarch

# Launch with display (use 'fakesink' in your pipeline for headless)
export DISPLAY=:0 && xhost +
docker run -it --rm --gpus all --network=host \
    -e DISPLAY=$DISPLAY -v /tmp/.X11-unix/:/tmp/.X11-unix \
    ghcr.io/nvidia/deepstream:9.2-triton-multiarch

# Inside the container, run a Triton-backed sample
cd /opt/nvidia/deepstream/deepstream-9.2/samples/configs/deepstream-app-triton
deepstream-app -c source30_1080p_dec_infer-resnet_tiled_display.txt

Prerequisites: Docker (docker-ce), the NVIDIA Container Toolkit, NVIDIA driver 595+, and an NGC API key. Triton sample model repos ship under /opt/nvidia/deepstream/deepstream/samples/triton_model_repo/. For gRPC-backed Triton, use samples/configs/deepstream-app-triton-grpc/ instead.

Prepare Triton dependencies and sample models on Jetson.

Building gst-nvinferserver standalone? bash build/build.sh sets up the Triton client SDK under /opt/tritonclient automatically. If you instead build the plugin standalone (bypassing build/build.sh) — including rebuilding it from the sources/ tree shipped inside a build/package.sh-produced .deb/tarball, which does not bundle the Triton client SDK — set up the Triton client SDK yourself first. See the "Other dependencies" section in src/gst-plugins/gst-nvinferserver/README.

# Run from the cloned repository root after the DeepStream build has completed.

# Installs the Jetson-compatible Triton server libraries and backends.
sudo ./scripts/triton_backend_setup.sh

# Clear the plugin cache after the Triton libraries are installed.
rm -rf ~/.cache/gstreamer-1.0/

# Generate TensorRT engines and prepare the Triton model repository.
./scripts/prepare_ds_triton_model_repo.sh

# Run the local nvinferserver sample.
cd /opt/nvidia/deepstream/deepstream-9.2/samples/configs/deepstream-app-triton
deepstream-app -c source30_1080p_dec_infer-resnet_tiled_display.txt

Jetson only. triton_backend_setup.sh downloads and installs the Jetson-compatible Triton components under /opt. For remote Triton inference over gRPC, use samples/configs/deepstream-app-triton-grpc/ and start tritonserver separately.

DeepStream/
├── .claude/                                 # Claude Code project-local config (settings, commands)
├── .github/                                 # GitHub workflows, issue templates, CODEOWNERS
├── build/
│   ├── BUILD.md                             # build instructions
│   └── build.sh                             # top-level build driver
├── example_prompts/                         # example prompts for AI coding agents
├── deploy/brev/                              # Brev launchable workflow for DeepStream Code Agent
├── includes/                                # shared public headers (ds3d, nvdsinferserver, …)
├── scripts/
│   ├── install_artifacts.sh                 # installs proprietary libs + sample data to /opt
│   ├── install_opensource_deps.sh           # builds open-source deps (OpenTelemetry, civetweb, …)
│   ├── install.sh                           # system integration (update-alternatives, pyservicemaker)
│   ├── uninstall.sh                         # removes a DeepStream installation from /opt
│   ├── triton_backend_setup.sh              # sets up Triton inference server backends
│   ├── prepare_ds_triton_model_repo.sh      # prepares the Triton model repository
│   ├── prepare_ds_triton_tao_model_repo.sh  # prepares the Triton model repository for TAO models
│   ├── prepare_classification_test_video.sh # generates a classification test video
│   ├── rtpmanager/update_rtpmanager.sh      # rtpjitterbuffer/rtsp EOS-hang fix script + patch files
│   └── print_env.sh                         # env diagnostic helper for bug reports
├── skills/
│   ├── amc-run-sample-calibration/          # AMC sample-dataset calibration skill
│   ├── amc-run-video-calibration/           # AMC custom-video calibration skill
│   ├── amc-run-rtsp-calibration/            # AMC RTSP-stream calibration skill
│   ├── amc-setup-calibration-stack/         # AMC microservice + UI launch skill
│   ├── deepstream-dev/                      # general DS development skill
│   ├── deepstream-generate-pipeline/        # interactive gst-launch pipeline builder
│   ├── deepstream-profile-pipeline/         # Nsight Systems profiling & config derivation
│   ├── deepstream-sop/                      # SOP step-sequence compliance microservice
│   ├── deepstream-import-vision-model/      # autonomous vision-model onboarding skill
│   └── deepstream-run-mv3dt/                # MV3DT reference-app operations skill
│   ├── rtvi-cv-customize-model/              # RTVI-CV model customization skill
│   ├── rtvi-vlm-customize-model/             # RTVI VLM model customization skill
│   └── rtvi-cv-scaffold-vss-service/         # RTVI CV VSS-service scaffolding skill
├── src/
│   ├── 3rdparty/                            # x86-only vendored gst-nvunixfd, gst-v4l2, v4l2
│   ├── apps/                                # sample, reference, and TAO sample applications
│   ├── gst-plugins/                         # GStreamer plugin sources (per-plugin subdirs)
│   ├── gst-utils/                           # GStreamer utility library sources
│   ├── service-maker/                       # Service Maker C++/Python SDK and apps
│   └── utils/                               # utility library sources (per-library subdirs)
├── deepstream_libraries/                    # DeepStream utility and helper libraries
├── deepstream_dockers/                      # DeepStream dockers
└── tools/
    ├── auto-magic-calib/                    # camera auto-calibration tool
    ├── deepstream-otelcol/                  # OpenTelemetry Collector setup for streaming metrics
    ├── inference_builder/                   # visual inference pipeline builder
    ├── deepstream-host-provisioning/        # Ansible playbooks for host provisioning (x86_64 & ARM SBSA)
    ├── sam2-onnx-tensorrt/                  # SAM2 ONNX-to-TensorRT conversion
    └── yolo_deepstream/                     # YOLO + TensorRT integration

NOTE: DeepStream-specific repositories previously hosted under the NVIDIA-AI-IOT GitHub organization are now consolidated into this repository.

The table below maps the existing NVIDIA-AI-IOT GitHub repository sources to their location in this repository.

Summary of benchmarks; for detailed performance numbers and hardware used, refer to the DeepStream Performance Guide.

• Releases / Changelog: CHANGELOG.md

The following .deb and .tar artifacts are published as GitHub Release assets. build/build.sh downloads them automatically into artifacts/ before installation:

Release assets can be downloaded via curl or wget from the command line.

curl

curl -LO 'https://github.com/NVIDIA/DeepStream/releases/download/v9.2.0/deepstream-9.2_9.2.0-1_amd64.deb'

wget

wget --content-disposition 'https://github.com/NVIDIA/DeepStream/releases/download/v9.2.0/deepstream-9.2_9.2.0-1_amd64.deb'

NOTE: Replace deepstream-9.2_9.2.0-1_amd64.deb with the name of the asset you want to download.

DeepStream Docker images are released through NGC. Browse and pull the images from the DeepStream NGC container catalog.

NOTE: For docker login and docker pull command details, along with the full list of available image tags, refer to the DeepStream NGC container catalog.

This project is currently not accepting contributions. The product roadmap is managed internally by NVIDIA.

• Vulnerability disclosure: File an issue at Issues.
• Do not file public issues for security reports.

• Level: Maintained
• How to get help: Issues / DeepStream SDK Developer Forum
• Filing a bug? Use the bug report template and include: platform (x86 / Jetson / SBSA), DeepStream version, install method (Debian / Docker / source), and the output of scripts/print_env.sh.

Join the DeepStream community to ask questions, share feedback, and report issues.

• GitHub Issues
• GitHub Discussions
• DeepStream SDK Developer Forum

• DeepStream NGC container — prebuilt runtime image (also bundles Triton).
• NVIDIA TAO Toolkit — model training/optimization, source of the TAO sample apps.
• GStreamer documentation — underlying framework.

This project is licensed under CC-BY-4.0 AND Apache-2.0.

• SPDX-License-Identifier: CC-BY-4.0 AND Apache-2.0

The CC-BY-4.0 AND Apache-2.0 project license is not applicable to src/3rdparty/. Those vendored sources keep their own licenses as listed below.

All GitHub Release assets (.deb packages and .tar.gz tarballs under the deepstream-binaries-* and deepstream-sample-data_* names) are governed by the Software License Agreement For NVIDIA Software Development Kits, refer the "LicenseAgreement" included within all GitHub Release Assets packages.

Refer THIRD_PARTY_LICENSES for all 3rd Party OSS licenses and Notices

Vendored sources under src/3rdparty/ (x86 only) keep their upstream licenses:

A few component subdirectories retain their own vendored/upstream LICENSE file (in addition to being covered by THIRD_PARTY_LICENSES.txt and/or the root LICENSE); these are kept in place for build/CI tooling that expects a local license file at that path: