NVIDIA DeepStream 9.1 is here, with 13 agentic skills for building video analytics pipelines.

Instead of manually building your vision AI pipeline from scratch, describe what you want in plain natural language. Use skills with a coding agent, like Claude Code or Codex, to easily handle setup, configuration, and execution.

New skills include Multi-View 3D Tracking (MV3DT) for tracking objects across multiple cameras, and AutoMagicCalib for automatically calibrating a camera network.

This release also brings NVIDIA JetPack 7.2 support for edge deployment on Jetson Orin and Thor. All open source on GitHub, check it out: https://nvda.ws/4vxQ6Yk

NVIDIA/DeepStream

Source: https://github.com/NVIDIA/DeepStream

DeepStream

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.

Overview

This repository contains the complete source code for DeepStream 9.1.

Components (src/):

• src/gst-plugins/ — DeepStream GStreamer plugin 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

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
• 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

Requirements

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.1 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.

Getting Started

# 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.1/.

Supported Platforms

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

Usage

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

cd /opt/nvidia/deepstream/deepstream-9.1/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.

Running with Triton Inference Server (Docker)

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.

# One-time NGC login (get an API key from https://ngc.nvidia.com)
docker login nvcr.io           # username: $oauthtoken,  password: <NGC API key>

# Pull the image (use 9.1-triton-arm-sbsa instead on SBSA / DGX Spark)
docker pull nvcr.io/nvidia/deepstream:9.1-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 \
    nvcr.io/nvidia/deepstream:9.1-triton-multiarch

# Inside the container, run a Triton-backed sample
cd /opt/nvidia/deepstream/deepstream-9.1/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.

Documentation

Repository Structure

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
├── 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
├── src/
│   ├── 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 (submodule)
├── 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.

Performance

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

Releases & Roadmap

• Releases / Changelog: CHANGELOG.md

DeepStream Release Assets

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

Debian packages (.deb)

Tarball archives (.tar.gz / .tbz2)

Python wheels (.whl)

Download installer(s)

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

curl

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

wget

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

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

Docker Images (NGC)

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.

Contribution Guidelines

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

Security

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

Support

• 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.

Community

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

• GitHub Issues
• GitHub Discussions
• DeepStream SDK Developer Forum

References

• 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.

License

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

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

Release Asset License

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.

Third‑Party License/Notice

Refer THIRD_PARTY_LICENSES for all 3rd Party OSS licenses and Notices