NVIDIA DAQIRI
NVIDIA DAQIRI is a software-defined data acquisition library that moves high-bandwidth instrument and sensor data into GPU-ready workflows. It helps teams replace "collect, store, analyze later" with real-time processing, automated sensor control, AI inference, filtering, inspection, and operational visibility at the edge—so they can act on live data.
The Edge Supercomputing Shift
For next-generation scientific instruments, automated manufacturing lines, and high-rate sensor networks, the traditional "store-first, analyze-later" pattern is the primary bottleneck.
When high-bandwidth data must be written to disk before it can be processed, critical insights often arrive too late to affect experiment outcomes, manufacturing yield, operational uptime, or high-consequence decisions.
NVIDIA DAQIRI turns any instrument's data acquisition node into an AI-ready edge supercomputer, streaming raw sensor and detector data directly into GPU memory for real-time processing, filtering, inference, and control.
From “store-then-analyze” to real-time discovery.
Architecture and Ecosystem Integration
DAQIRI connects high-bandwidth instruments, detectors, and industrial sensors to NVIDIA accelerated computing without requiring teams to become experts in high-speed networking, detector design, or GPU memory management.
NVIDIA DAQIRI acts as the software-defined data acquisition and GPU-ready data layer. It abstracts complex, low-level networking and hardware movement patterns, allowing developers to interact with raw stream data using standard C++ or Python workflows. If a sensor or instrument speaks Ethernet, DAQIRI can ingest its data without requiring changes to the sensor hardware or software.
DAQIRI sits upstream of downstream runtimes. It prepares raw UDP and RoCE v2 streams into NVIDIA CUDA™-accessible memory formats for high-speed use in tools like NVIDIA Holoscan for sensor processing, NVIDIA TensorRT™ for optimized AI inference, and NVIDIA Omniverse™ for digital twin visualization.
DAQIRI Quickstart Guide
Learn how to initialize streaming interfaces, allocate GPU memory buffers, and run your first DAQIRI Python pipeline.
Enable Real-Time AI for High-Speed Data Acquisition With DAQIRI
DAQIRI bridges high-bandwidth scientific instruments and sensors directly into NVIDIA CUDA-X™ libraries at line rate.
Stream Directly Into Holoscan
Build a real-time sensor-processing pipeline by connecting DAQIRI and Holoscan with this hands-on tutorial.
Zero to Tensor in Five Minutes
Walk through a hands-on tutorial on streaming UDP sensor output directly into PyTorch and TensorRT GPU memory structures.
Key Features
Real-Time Processing at the Source
Move beyond offline analysis by bringing computation directly to the instrument. Run real-time reconstruction, inference, filtering, and feedback loops while the experiment or production run is live.
Bridge to NVIDIA CUDA-X
Streamline low-level data movement. DAQIRI transforms raw UDP and RoCE v2 streams into GPU-ready tensor formats, providing a clean path into downstream frameworks like NVIDIA Holoscan, TensorRT, and Omniverse.
Reduced Storage and Network Overhead
Move insights, not raw data. Perform real-time data reduction and extraction at the edge to ease pressure on storage systems, local network infrastructure, and central cloud resources.
Path to Autonomous Instruments
Enable intelligent, software-defined control. Connect sensor readouts directly to AI models to support real-time triage, closed-loop feedback, automated inspection, and adaptive system behavior.
Get Started With NVIDIA DAQIRI
DAQIRI abstracts low-level data movement and buffer allocation across UDP, RoCE v2/RDMA, NVIDIA GPUDirect™ RDMA, and GPUDirect Storage, moving streaming data into CUDA-accessible memory with zero-copy paths where supported.
Python | C++
DAQIRI Walkthrough
Start with the top-level DAQIRI settings. This establishes the raw streaming path, assigns a CPU core to manage DAQIRI, and keeps logs concise enough for deployment.
%YAML 1.2 --- daqiri: cfg: version: 1 stream_type: "raw" # Use DAQIRI's high-speed DPDK/GPUDirect path. master_core: 3 # CPU core used to start and manage DAQIRI. log_level: "info"
Next, define the GPU memory regions DAQIRI will use. rx_packets is where raw packet buffers land through GPUDirect, while rx_tensor is the completed, reordered tensor consumed by the GPU workload. The buffer sizes also make the int4-to-fp16 expansion explicit.
memory_regions: - name: "rx_packets" kind: "device" # Raw packets land directly in GPU memory. affinity: 0 # Use GPU 0. num_bufs: 16384 buf_size: 8192 # Headers + sequence number + 8000B payload. - name: "rx_tensor" kind: "device" # Reordered output also stays on the GPU. affinity: 0 num_bufs: 128 # Number of completed tensors DAQIRI can queue. buf_size: 32768000 # 1024 packets * 8000 int4 bytes * 4 bytes after fp16 expansion.
Then bind the configuration to the physical receive interface. This names the NIC by PCIe address, enables flow isolation, and assigns a polling queue. The queue batches 1024 packets at a time but can flush after 2 ms so downstream processing is not waiting indefinitely.
interfaces: - name: "rx0" address: "0000:00:00.0" # RX NIC PCIe address from lspci. rx: flow_isolation: true # Only packets matching the flow below are accepted. queues: - name: "q0" id: 0 cpu_core: 9 # CPU core polling the NIC queue. batch_size: 1024 # Build tensors from 1024 packets. timeout_us: 2000 # Flush a partial batch after 2 ms. memory_regions: ["rx_packets"]
Additional settings, such as flows, packet reorder specs, and type conversion can be added to the config.
With those details in YAML, the application code becomes intentionally small. Initialize DAQIRI from the configuration file, then ask DAQIRI for the next completed burst. By the time the application receives the pointer, DAQIRI has already reordered the packets into a tensor in contiguous GPU memory, so the code can send it directly to a model or CUDA kernel.
// Initialize DAQIRI with a config file.
daqiri::daqiri_init("rx_reorder.yaml");
daqiri::BurstParams* burst = nullptr;
// Receive packets; DAQIRI reorders them into contiguous GPU memory.
daqiri::get_rx_burst(&burst);
// The reordered batch is now a GPU tensor ready for processing/inference.
auto* tensor = daqiri::get_packet_ptr(burst, 0);
run_model_or_kernel(tensor);
Once the GPU job is done, return the buffers to DAQIRI so they can be reused for the next burst.
Flexible Access and Deployment Options
Choose the access path that fits your development environment and software deployment pipeline.
GitHub Repository
Access open source bindings, sample C++ data ingestion wrappers, and Python workflow integration code.
Access GitHub Repository
Containerized Build
Build DAQIRI in a container that bundles the required user-space networking dependencies, including patched DPDK support for high-throughput Ethernet and GPUDirect workflows.
Build With Container
C++ API and Build Instructions
Build DAQIRI from source with CMake or use the recommended container workflow to configure high-speed UDP, RoCE, and GPUDirect data paths.
View Getting-Started GuidePerformance Benchmarks
High-throughput data ingestion benchmarks across NVIDIA edge supercomputing platforms, demonstrating line-rate packet transfers straight to GPU memory.
NVIDIA IGX Thor™ Developer Kit
(Click diagram to enlarge)
NVIDIA DGX™ Spark
(Click diagram to enlarge)
Learning Library
More Resources
Ethical AI
NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our terms of service, developers should work with their supporting model team to ensure this model meets requirements for the relevant industry and use case and addresses unforeseen product misuse.
For more detailed information on ethical considerations for this model, please see the Model Card++ Explainability, Bias, Safety & Security, and Privacy Subcards. Please report security vulnerabilities or NVIDIA AI Concerns here.
Get started with NVIDIA DAQIRI today.