NVIDIA ovstream

ovstream is a lightweight C and Python SDK for streaming application-rendered pixels, audio, messages, and input events from GPU applications to interactive clients.

Use ovstream when you have a renderer, CUDA producer, tensor producer, or pre-encoded video source and need to deliver an interactive live view to a browser, native client, RTSP client, or same-machine desktop process. Pair it with ovrtx, or any compatible CUDA-buffer producer, to ship interactive rendered content over WebRTC, RTSP, the low-latency native protocol, or local shared memory.

• Supported inputs and outputs
• Get started in Python
• Get started in C

Features

• Five transports in one library — WebRTC (browser-friendly), RTSP (industry-standard), native (low-latency StreamSDK), SHM (same-machine host-resident zero-copy), and CUDASHM (same-host GPU-resident zero-copy over CUDA IPC). Pick one at runtime, run several simultaneously, no separate builds.
• Zero-copy CUDA buffer streaming — push raw BGRA8 frames directly from CUDA memory; the SDK encodes on the GPU via NVENC.
• Pre-encoded passthrough — stream existing H.264 / H.265 / AV1 bitstreams without re-encoding, for file replay or upstream-encoded sources.
• Bidirectional messaging and input (WebRTC / native / SHM / CUDASHM) — receive keyboard, mouse, and Unicode events from connected clients; send messages back.
• Resizable streams (WebRTC / native / SHM / CUDASHM) — width / height become the maximum and per-frame dimensions set the resolution; client resize requests arrive via a typed callback, optionally seeded with the resolution each connecting client requests.
• Connection acceptance (WebRTC / native) — a callback sees each client's signaling headers and accepts or rejects the connection.
• Stream control messages (WebRTC / native) — the browser client's config handshake, clipboard sync in both directions, cursor forwarding, app-message routing, and QoS hints via typed callbacks. ovstream_utils.messaging adds the browser client's application message convention on top: event types, correlation ids, and automatic splitting and reassembly of large payloads.
• STUN / TURN for WebRTC NAT traversal — supply ICE servers via a single set_webrtc_ice_servers call before or after start; refresh time-limited TURN credentials live without dropping connected clients.
• Self-contained — no Kit, no Carbonite, no Omniverse app required. The wheel bundles its native dependencies (StreamSDK, GStreamer, the CUDA runtime, the bundled gstnvenc plugin); pip install ovstream is enough. The bundled runtimes match the ones ovrtx ships, so the two can share a process; the per-release versions are in ARCHITECTURE.md.

Supported inputs and outputs

The diagram below summarizes the current application inputs, SDK surfaces, transport backends, and consumers supported by ovstream.

For text readers, search, and AI coding agents, the same contract is summarized below:

What goes in	ovstream surface	What comes out
BGRA8 CUDA frames from a renderer or application	stream_video	WebRTC, RTSP, native, SHM, or CUDASHM video delivery
DLPack tensor frames from Warp, PyTorch, CuPy, JAX, or another producer	stream_video	Transport-selected frame stream
Pre-encoded H.264, H.265, AV1, or custom payloads	stream_video	Passthrough video stream without re-encoding
16-bit PCM audio	stream_audio	WebRTC or native audio stream
Application messages, metadata, keyboard, mouse, and Unicode input	callbacks and messaging APIs	Server-side application events and client responses

Getting Started in Python

Python 3.8 or newer is required.

Install the ovstream wheel, then fetch the example sources (they live in the public repo, not the wheel) and run the first example:

pip install ovstream
git clone https://github.com/NVIDIA-Omniverse/ovstream.git
cd ovstream/examples/python/basic_stream
python main.py

(Or download a release source archive from https://github.com/NVIDIA-Omniverse/ovstream/releases if you don't have git.)

The basic example creates a WebRTC server with signaling port 49100 (the media stream port defaults to 47998), allocates a CUDA buffer, animates a gradient fill, and pushes frames at 60 FPS. Open examples/webrtc_client/index.html in a browser and enter 127.0.0.1:49100 to view the stream.

Pass rtsp, native, shm, or cudashm as arguments to switch transport — see the examples README for the full menu.

Getting Started in C

The C/C++ examples require CMake 3.24 or newer, a development environment, and the CUDA Toolkit (nvcc) for the examples that fill CUDA frame buffers, including basic_stream below; pre_encoded_stream builds without it. On Windows the development environment is provided by Visual Studio 2019 or newer. On Linux (Ubuntu; the stock cmake package on 22.04 is 3.22, use Kitware's APT repository or pip install cmake there):

sudo apt-get install build-essential cmake

Clone the public repo for the example sources (they're not in the wheel), then build and run the first example using CMake:

git clone https://github.com/NVIDIA-Omniverse/ovstream.git
cd ovstream/examples/c/basic_stream
cmake -B build -DCMAKE_BUILD_TYPE=Release

Then, on Windows:

cmake --build build --config Release
.\build\Release\basic_stream.exe

On Linux:

cmake --build build --config Release
./build/basic_stream

CMake's ovstream_fetch() macro downloads the matching ovstream binary archive from GitHub Releases at configure time. No manual install step is required.

Examples

Further examples using both the C and Python APIs are available in the examples directory. See the individual examples for building and usage instructions.

The Python ovrtx_stream example is the minimal "composing OV libraries into an app" demo — it loads a USD scene through ovstage, renders it with ovrtx, and streams the rendered output through ovstream, end-to-end, with auto-orbiting camera and client input handling.

Releases

The Releases page of this repository contains binary builds for the official releases of the ovstream C library and the corresponding Python wheels. These binaries are provided for the supported platforms:

• Windows x86_64
• Linux x86_64
• Linux aarch64

The libraries require a compatible NVIDIA RTX-capable GPU with a compatible NVIDIA driver on the system. More detailed system requirements can be found at https://docs.omniverse.nvidia.com/dev-guide/latest/common/technical-requirements.html

On Windows, the WebRTC and native servers must run in a logged-on user's session: StreamSDK creates its video adapter context with Direct3D, which is not available to processes in session 0 (Windows services, scheduled tasks running as SYSTEM, SSH shells). ovstream_start fails there with NVST_DISCONN_SERVER_VIDEO_ADAPTER_INITIALIZE_D3D_FAILED. RTSP, SHM and CUDASHM servers have no such requirement.

Documentation

The public C API is fully documented inline in the header files (ovstream.h, ovstream_types.h, ovstream_client.h) shipped under include/ovstream/ inside every release archive — each function carries its argument types, return semantics, thread-safety rules, and lifetime contracts as Doxygen-style comments. The Python API mirrors the C API and is documented via docstrings on the wheel-installed ovstream package (run help(ovstream) after pip install ovstream).

For runnable code, see examples. For AI-coding-agent-friendly task recipes, see skills.

AI Coding Agents

The skills directory contains a series of skills to help AI coding agents understand how to use the API (and they're useful for humans too). Copy this directory to your project and point your agent at it.

Support

https://forums.developer.nvidia.com/c/omniverse/300

Roadmap

To be announced.

Contributing

At this time this project is not open to external contributions. Please use the Support channels above for questions and bug reports.

Authors and acknowledgment

NVIDIA Corporation.

License

The software and materials are governed by the NVIDIA Software License Agreement and the Product-Specific Terms for NVIDIA Omniverse.

This project will download and install additional third-party open source software projects — see THIRD_PARTY_NOTICES.md. Review the license terms of these open source projects before use.