On November 19, NVIDIA described a high-dynamic-range electron-microscopy camera at Lawrence Berkeley National Laboratory’s Molecular Foundry, connected to GPU processing through NVIDIA’s DAQIRI data-acquisition library. The instrument can emit more than 500 gigabits per second while measuring electron energy loss, a rate the company says is over 500 times that of conventional EELS streams. FPGA readout sends data over Ethernet to a ConnectX network interface; DAQIRI moves payloads into GPU-accessible memory, where processing assembles frames, corrects the detector, reduces the spectra and visualizes the result while the experiment is still underway. NVIDIA also announced hardware packet reordering, an ibverbs backend and direct polling for low-latency control traffic. NVIDIA’s DAQIRI and microscopy report
The central change is about where computation sits. A familiar instrument pipeline captures raw data, stores it, then sends it to a workstation or computing facility for analysis. At very high rates, storage and transfer can delay feedback or force the instrument to discard or reduce information before researchers understand what matters. DAQIRI’s design brings GPU memory into the acquisition path. That could let software inspect a measurement, reduce data and potentially adjust settings before the next acquisition decision. The possibility is important, but it must be separated from what the Berkeley case actually demonstrates and from what remains a platform capability rather than an observed AI result.
The detector creates a data-path problem#
Electron energy-loss spectroscopy, or EELS, measures how much energy electrons lose when interacting with a sample. The resulting spectra help identify which elements are present and how they are bonded. Measurements contain both strong and faint signals. The conventional technique described by NVIDIA uses two acquisition processes optimized for different intensity ranges, run one after another. That requires coordination of electron optics, exposure timing and detector readout; the two outputs then need alignment and combination. A high-dynamic-range detector can capture a wider intensity range in one acquisition, simplifying the optical and timing setup while generating much more data per unit time. NVIDIA on the EELS camera workflow
At over 500 Gbps, the stream rate is more than a networking headline. Dividing bits by eight gives at least 62.5 gigabytes per second while the stream is active. If such a rate were sustained continuously, it would amount to about 225 terabytes in an hour and 5.4 petabytes in a day, before protocol overhead or any reduction. That arithmetic illustrates why “save everything and inspect later” can become impractical. It is not a claim that this microscope runs continuously at that rate for a full day. The acquisition can be episodic, and downstream processing may reduce or select the measurements worth retaining.
The microscope camera, FPGA readout, Ethernet links, network interface and software form one acquisition system. A detector’s raw output is useful only if the following stages can receive it without loss, reconstruct its frame structure and perform the calculations before the experiment moves on. If a link drops packets or buffers overflow, later GPU processing cannot restore the missing measurement. If data arrive intact but out of order, software must sort them before forming meaningful frames. If the data can be processed only after a long disk write, the resulting information may miss the decision point it was meant to inform.
This makes data movement part of experimental design. Scientists often choose exposure, scanning and region-of-interest settings before acquisition based on the expected specimen and detector behavior. Once a new high-dynamic-range camera can reveal faint and strong signals together, the instrument may expose details that were previously obscured or require separate passes. But those details matter only if the acquisition path can turn them into a usable result soon enough. The practical question is not just whether the camera collects more; it is whether the system can make that added information available while it can still change what the instrument measures next.
There is a relevant precedent at the same laboratory, though it is a different instrument and data path. Berkeley Lab described a 4D Camera operating at 87,000 frames per second and producing datasets up to 700 GB in under 15 seconds. Its existing workflow used FPGA-connected receiving servers, RAM and flash storage, then processed data locally or transferred it to NERSC for more computing resources. The lab reported that a streaming workflow improved turnaround time and enabled decisions during experiments. That experience shows the value of moving microscopy data faster, but it should not be conflated with the new 500-Gbps high-dynamic-range EELS camera or its DAQIRI pipeline. Berkeley Lab on its 4D Camera streaming workflow · DOE summary of real-time analysis for large detector data
The new system changes where additional processing can happen. Flash writes and transfer to centralized computing remain useful for preserving data and accessing larger resources. DAQIRI's path can support selected operations at the edge before or during those storage steps. This suggests a complementary architecture rather than a simple replacement for disks or HPC. A researcher may need raw archival data for later reanalysis while using a live reduction to make an immediate parameter change. The choice of what to store, reduce or discard depends on scientific reproducibility and the experiment's measurement plan.
DAQIRI moves acquisition toward the GPU#
DAQIRI stands for Data Acquisition for Integrated Real-time Instruments. NVIDIA describes it as a software-defined library that moves high-bandwidth sensor and instrument data into GPU-ready workflows. On compatible hardware, it can access the network interface from user space, bypass the Linux kernel network stack, and use GPUDirect to transfer data between a NIC and GPU without a CPU-mediated copy. Its API supports C++ and Python. DAQIRI is part of the Holoscan ecosystem, which supplies a framework for streaming sensor processing and real-time AI applications. NVIDIA DAQIRI repository and documentation · DAQIRI developer overview
“GPU-native acquisition” does not mean the GPU replaces the microscope or every part of the readout electronics. In the Berkeley example, the camera and FPGA continue to acquire and format detector data. Ethernet carries packets toward a compatible NIC. DAQIRI handles transfer, ordering and memory placement. GPU kernels then assemble frames and apply detector corrections before reducing them to EELS spectra. NVIDIA describes submicron spatial information recovered from five-micrometer sensor pixels through computation. The system is a chain of specialized components, with DAQIRI connecting the measurement side to accelerated processing.
The term “zero-copy” also needs a boundary. It describes avoiding extra copies along a supported path, such as transferring packet payloads directly into GPU-accessible memory. It does not mean data require no buffering, parsing, reordering, correction, transformation or later storage. Some pipeline stages may still copy or convert data by design, and supported transfer modes depend on whether the hardware is a discrete GPU system or a unified-memory platform. A zero-copy path can reduce CPU and memory overhead, but the end-to-end processing rate still depends on GPU kernels, detector formats, queue behavior, network traffic and software scheduling.
Hardware support is specific. DAQIRI’s repository says its high-performance raw Ethernet, RoCE and GPUDirect paths require an NVIDIA ConnectX-6 Dx or later NIC and a supported CUDA-capable GPU. The project lists NVIDIA DGX Spark, IGX and RTX Pro Servers among supported systems. A plain Linux sockets path can run on more modest hardware, but it does not provide the same peak performance profile. Packet pacing, accurate timed transmission and hardware packet reordering require ConnectX-7 or later, according to the current setup documentation. “GPU-native” is therefore an architectural option for compatible systems, not a software-only speedup available on any workstation. DAQIRI system requirements · DAQIRI hardware setup
The data path differs between discrete and integrated systems. NVIDIA’s setup guide describes IGX systems with a discrete GPU, a separate GPU BAR1 and PCIe path between NIC and GPU. DGX Spark uses a GB10 superchip with unified CPU/GPU memory and an integrated ConnectX-7; the guide uses host-pinned buffers for its GPUDirect mode. Those differences matter when interpreting a benchmark across machines. Similar labels such as “direct to GPU” can involve distinct memory topology and transfer mechanisms, affecting latency and throughput.
DAQIRI’s software choices also determine the behavior. The library supports raw Ethernet, RoCE/RDMA and Linux sockets paths, different receive engines, CPU or GPU reordering and buffer placement. A developer configures interfaces, queues, flows and memory regions. The release report’s features are not a single automatic mode that makes all data streams real time. Operators must select a transport and queue design suitable for the instrument, tune the host and network, and validate packet loss, memory pressure and the pipeline under actual load. NVIDIA’s getting-started guide itself recommends building the library, tuning the host as needed and running benchmarks on the target system. DAQIRI getting started · DAQIRI API guide
Three updates target distinct bottlenecks#
The November DAQIRI release adds hardware-assisted packet reordering for supported ConnectX-7-or-later network cards. Networks may deliver packets out of order, and conventional software handling can add CPU work, memory overhead and latency. In compatible packet formats, the NIC can parse sequence fields and place payloads into their ordered positions in memory. The application receives an ordered buffer without a separate software reorder-and-copy step. The configuration must specify where sequence numbers live and what to do when packets are missing. This is a specific queue feature, not a guarantee that packets cannot be lost or that all instruments use a supported sequence format. NVIDIA’s hardware reordering description
The second change is an ibverbs engine for high-rate raw Ethernet send and receive. NVIDIA says it reduces per-packet CPU overhead and nearly doubles per-core throughput compared with the previous DPDK backend for small packets up to 1,024 bytes at data rates above 200 Gbps. The stated benchmarks ran on DGX Spark, IGX Thor and RTX Pro server platforms. Figure 3 describes single-queue results generated on IGX Thor, with similar performance said to be expected on DGX Spark and x86 systems. For 64- and 256-byte packets, throughput nearly doubles; 8 KB packet results are similar. This is a nuanced result: the benefit depends on packet size and comparison conditions, not simply total bandwidth. NVIDIA’s ibverbs benchmark conditions
The third feature, direct polling, targets latency-sensitive control messages. A normal I/O worker can receive or submit packets separately from the application thread, which adds a handoff. Direct polling lets the application thread do both, potentially reducing that handoff delay. NVIDIA reports 2–4 microseconds for send-to-receive in a cabled loopback test with TX and RX ports on the same host. That is a local networking microbenchmark, not the delay from a camera measurement through GPU analysis to an adjusted experiment. Real feedback latency includes detector readout, packetization, scheduling, GPU computation, decision logic and control response. The microsecond result applies to one link in that chain. NVIDIA’s direct-polling test description
The features can be combined selectively. A system may use hardware reorder for high-rate measurement queues and direct polling for a smaller control queue. Batched data processing can prioritize throughput, while latency-sensitive feedback uses a different queue configuration. This split reflects two different requirements: receiving a large stream efficiently and sending a timely control message. Optimizing one may work against the other, so system builders need to measure both under realistic contention rather than treating one headline latency as the performance of the whole instrument.
The EELS case is real-time image processing, not a demonstrated AI loop#
NVIDIA’s blog frames DAQIRI as enabling real-time AI for scientific instruments and says the library supports analysis and feedback applications. The Berkeley EELS case provides an example of high-speed acquisition and GPU processing during measurement. The described GPU steps are frame assembly, detector correction, spectral reduction and visualization. The article says researchers can inspect data and adjust acquisition parameters and regions of interest in real time. It does not specify a trained AI model operating in that loop, nor report an AI accuracy or autonomous control result for this camera. NVIDIA’s Berkeley case study
That boundary matters because a GPU pipeline and an AI model are not synonymous. GPU kernels can perform deterministic corrections, transforms and reductions without inference. Holoscan and TensorRT can host streaming AI applications downstream, and DAQIRI can prepare data for such inference. NVIDIA’s platform story is that the acquisition path can make real-time AI possible. In the cited EELS workflow, the reported outcome is that data can be processed and viewed while acquisition continues. A scientific result or AI-driven experimental adjustment would require its own description and evidence.
The distinction also clarifies the role of feedback. During measurement, researchers can inspect the data and adjust parameters or regions of interest. That establishes a human-in-the-loop opportunity. An autonomous feedback loop would need to identify a condition, decide what setting to change, apply that change safely and verify the next measurement. The blog discusses feedback capabilities and time-sensitive control, but the EELS example does not report a closed-loop AI system deciding how to run the microscope. The architecture could support such development; the published case should not be written as if it already demonstrated it.
The source’s “over 500x faster than conventional EELS” comparison is also a vendor statement tied to the data streams it contrasts. The blog explains that traditional EELS separately optimizes processes for strong and faint signals and that the new camera captures both together. It does not, in the excerpted discussion, define the exact conventional instrument, detector, acquisition duration and processing boundary underlying the 500x figure. The number is useful as an indication of scale, but should be attributed to NVIDIA and not treated as an independently audited industry-wide ratio.
Independent microscopy work shows why rapid processing has mattered before this release. Berkeley Lab’s 4D Camera project generated up to 700 GB in less than 15 seconds at 87,000 frames per second. Its workflow ingested data to RAM, wrote it to flash, and then processed locally or transferred it to NERSC for stronger compute. The lab reported faster turnaround and real-time decisions. A 2025 paper on streaming microscopy data likewise describes the challenges of storing and processing large datasets and the path through FPGA receivers, memory and storage. These are not measurements of the new EELS camera or DAQIRI, but they establish that detector rates and analysis latency have been real instrument-design constraints. Berkeley Lab’s 4D Camera workflow · Streaming large-scale microscopy data
The new system changes where more processing can happen. The previous workflow’s flash writes and transfer to centralized compute remain valuable for preserving data and using larger resources. DAQIRI’s path can support selected operations at the edge before or during those storage steps. This suggests a complementary architecture rather than a simple replacement of disks or HPC. A researcher may need raw archival data for later reanalysis, while real-time reduction drives immediate parameter changes. What to store, reduce or discard depends on scientific reproducibility and the experiment’s measurement plan.
Real-time processing reshapes experimental choices#
When measurements are available during acquisition, researchers can catch problems earlier. An image with an unexpected signal, a detector issue or a poorly chosen region of interest may be visible before a long acquisition finishes. The potential value is not just faster post-processing; it is avoiding the cost of acquiring the wrong data. In experiments with scarce instrument time or sensitive samples, an early warning can affect what is measured next. This is the opportunity behind moving analysis closer to the detector.
There is a trade-off between acting early and preserving the evidence needed later. A real-time reduction may show a useful spectrum quickly, but the raw detector stream may contain details that a later algorithm can recover. If data are discarded to keep the pipeline within bandwidth, the acquisition plan must record what was reduced and why. If the raw stream is saved as well, storage and network requirements remain. “Process before disk” can lower pressure on storage for selected workflows, but it does not make data stewardship disappear.
Instrument makers may also rethink readout design when GPU-ready acquisition is available. NVIDIA suggests that a camera capable of capturing strong and faint signals together could simplify the optics and coordination that previously supported two passes. The system still requires detector electronics and FPGA readout that can sustain the data rate, plus a network and compute path with enough capacity. A high-speed link only moves the bottleneck. If GPU frame reconstruction or spectral extraction cannot keep pace, queues grow or the system must throttle acquisition.
The most important measurement for a feedback instrument is end-to-end latency under load. A 2–4 microsecond loopback result is not enough. The system should measure from detector event to validated scientific metric, then through a control decision and the instrument’s response. It should also monitor jitter and packet loss, not only average throughput. A camera may produce bursts faster than the average data rate suggests, and control timing can be sensitive to tail latency. These measurements determine whether a pipeline can safely influence acquisition rather than merely render a preview.
Scientific feedback also needs guardrails. A model or algorithm should not make a high-impact measurement change because one frame looked unusual. The application may require confidence checks, bounds on parameter changes and human confirmation. The logging system should preserve the raw measurement, derived signal, software version and chosen action. Without that provenance, faster feedback can make experiments harder to reproduce. The low-latency path is useful when it creates earlier evidence while keeping the chain of evidence inspectable.
What the performance numbers do and do not show#
The report’s throughput numbers are tied to packet sizes, queue counts, hardware and backend versions. The ibverbs result compares per-core throughput against DPDK for small packets at high rates, while large 8 KB packet throughput is reported as similar. The direct-polling delay is measured over a cabled loopback on one host. The Berkeley camera stream is a separate application case at more than 500 Gbps. These numbers answer different questions and should not be assembled into one claim that the microscope has a four-microsecond AI feedback loop at 500 Gbps.
Testing should begin on the target system. NVIDIA’s DAQIRI setup documentation lists Linux requirements, supported NIC/GPU combinations, hugepage and CUDA dependencies, and notes that the container build bundles patched DPDK and networking dependencies. Peak GPUDirect performance requires compatible hardware. A plain Linux socket path can run on more modest equipment but is not the same high-performance route. This affects who can adopt the library and what procurement or engineering work is needed. DAQIRI hardware and software requirements
The source blog recommends using DAQIRI benchmarks to evaluate throughput and communication latency on a system. A useful deployment test should include the instrument’s exact packet structure, whether packets arrive in order, acquisition burst profile, GPU kernels, storage requirements and feedback cadence. It should test overload behavior and recovery from missing packets. Hardware reorder needs a supported NIC and a correct sequence format; packet timeout policy can drop partial batches. These choices affect scientific completeness, not just speed.
A clean benchmark can compare pipeline variants: conventional receive and copy, GPU-direct transfer, software reordering, hardware reordering, batched processing and direct polling for control. It should hold the detector data and analysis constant while changing one part of the path. The result may show that a complex hardware feature has no material benefit for large packets, or that direct polling reduces control delay but consumes an application core. Such outcomes are useful; adopting every new feature by default is not the goal.
The choice between retaining raw measurements and reducing at the edge should be evaluated separately from network throughput. Some experiments may only need selected spectra for live decisions. Others require raw data for audit, recalibration or a different analysis method. A successful DAQIRI pipeline can move bytes directly to the GPU, but it cannot decide what is scientifically safe to discard. The measurement plan and downstream analysis determine that boundary.
What would make the next result convincing#
The strongest follow-up evidence would pair the new camera and DAQIRI path with a documented instrument workflow. It could report sustained and burst data rates, packet loss, GPU and storage behavior, processing latency, and how much raw data was retained. A before-and-after comparison should define the conventional EELS setup behind the “500x” statement and explain whether it compares detector output, assembled frames or full spectral results. This would make the throughput claim more interpretable to other labs.
For AI-enabled feedback, a separate evaluation should identify the model or algorithm, the measurement condition it detects, the control action permitted and the outcome against a ground-truth or human-approved procedure. The test should include missed detections, false alarms and behavior under noisy or unusual samples. It should show whether feedback improved experimental yield or reduced time without sacrificing data needed for later analysis. GPU-ready transport is an enabling component, not a substitute for validating the scientific method.
Reproducibility requires software and hardware details. A paper or benchmark should identify DAQIRI version, NIC and GPU models, driver and CUDA versions, queue configuration, packet sizes, number of repetitions, sample variation and uncertainty. It should also make clear which measurements are from NVIDIA, which from the instrument team and which are independent. The current technical post provides useful engineering specifics, especially about the feature set and measurement path; an independent result would help establish how broadly the performance generalizes.
There is a worthwhile ecosystem question too. DAQIRI is Apache-2.0 open source and offers C++ and Python interfaces, but peak performance still depends on a supported NVIDIA NIC and GPU. Teams can run a socket path on other NICs, while the zero-copy high-throughput modes are more constrained. Scientific facilities often combine legacy instruments, custom FPGAs and shared computing clusters. Integration effort, fault handling and long-term support may decide adoption as much as headline bandwidth. DAQIRI source repository and supported paths
A faster measurement path, with AI still to be demonstrated#
NVIDIA’s DAQIRI update addresses a concrete instrument problem: high-rate data can outgrow a store-first acquisition pipeline. The Berkeley EELS camera gives the announcement a specific case, and GPU-native transfers can make data processing available while measurement continues. Hardware packet reordering, ibverbs and direct polling address distinct bottlenecks in packet delivery and control communication. The published measurements are tied to their packet sizes, test setups and hardware.
The AI connection is a platform direction. DAQIRI can prepare data for GPU processing, inference and feedback, but the Berkeley workflow described in the post reports frame assembly, detector correction, spectrum reduction and visualization—not a named AI model autonomously steering the microscope. A human researcher can inspect and adjust settings during measurement. That is already useful, and it is different from a validated closed-loop AI experiment.
The result worth following is whether this acquisition path improves measurement decisions end to end. The compelling evidence will connect camera output, transport, GPU analysis and control to a reproducible scientific outcome, while accounting for raw-data retention and failure modes. Until then, DAQIRI is best understood as infrastructure that can bring analysis closer to the instrument. The data pipeline is moving toward AI; the demonstrated case is faster access to measurements.