AivexaNewsSearch
AI news for builders and product teamsChecked every hour

Run GPU-Powered Black Hole Interferometry with NVIDIA cuPhoton

Collected Nov 13, 2026

NVIDIA has published a developer walkthrough of cuPhoton.xBeam, the GPU correlation component of its cuPhoton scientific computing toolkit, aimed at radio interferometry of the kind the Event Horizon Telescope (EHT) uses to image black holes. The tool ships as part of cuPhoton v0.1.3 and is available in the public NVIDIA/cuPhoton repository alongside sample recordings and job files. NVIDIA says the work is done in collaboration with the Harvard-Smithsonian Center for Astrophysics and the MIT Haystack Observatory.

The headline number: on an NVIDIA Vera Rubin NVL72 system with 64 GPUs and GPUDirect Storage (GDS) in compatibility mode, xBeam correlated a 10 TB dataset in 70 seconds. The x86 CPU baseline for the same job took 31,992 seconds, or about 8.89 hours, making the GPU run roughly 460x faster. That figure covers total end-to-end processing time, including reading the data, preparing it and correlating it, and the reported speedup keeps rising across the tested range from 1 to 64 GPUs. Read bandwidth on the same recording scaled from 20 GB/s on 4 GPUs to 170 GB/s on 64 GPUs with GPUDirect Storage enabled.

Some background helps explain why correlation is the bottleneck. Very-long-baseline interferometry links widely separated dishes so they act as one Earth-sized telescope; the EHT combines 13 stations across Hawaii, Chile, Spain, Mexico and the South Pole, recording millimeter and submillimeter radio emission from gas swirling outside a black hole's event horizon. Each station records two polarizations at up to 64 gigabits per second, producing petabytes of data. A correlator multiplies each pair of station signals to produce complex visibilities, which sample the Fourier components of the sky brightness. Earth's rotation traces sparse tracks through the (u, v) plane, and reconstruction algorithms solve an inverse problem to turn those samples into an image. For scale, M87*'s observed ring spans just 42 microarcseconds.

xBeam is an FX correlator, the same class as DiFX, the CPU-based open-source software correlator used as the reference for validating results. It performs five steps. First, ingest: it reads VDIF frames and builds a small .vdix sidecar index recording where each frame lives by timestamp, thread and physical location, without copying data, so later reads jump straight to the needed frames and missing or invalid data stays explicitly tracked. Second, delay and fringe correction: samples are shifted by delays taken from the job file, aligning wavefronts across stations and removing phase drift from Earth's motion. Third, channelization: an FFT splits each station's voltage stream into frequency channels. Fourth, cross-multiply and accumulate: each station's spectrum is multiplied by the complex conjugate of its partner's, summed over the integration time, with invalid input masked and products normalized by validity-derived exposure weights. Fifth, output: visibilities are written in DiFX's SWIN format or xBeam's own xbeam-v1 format.

Delay handling spans the FFT. Integer-sample alignment and fringe rotation happen before channelization, and a frequency-dependent phase correction handles the remaining fractional-sample delay afterward. The total delay is a sum of a geometric term parameterized as a polynomial in time around a reference epoch, a per-station clock offset plus linear drift, and a fixed per-band clock offset. Inside one FFT, the delay can be held constant or approximated as a line or parabola via the fringe_approximation_order setting. Notably, xBeam does not compute delays from station positions; it uses whatever the job supplies, and it does not trace light paths around a black hole. Calibration and imaging happen downstream in tools such as HOPS, rPICARD and eht-imaging.

Operationally, jobs are normalized JSON files (schema version 1) or supported DiFX .input files naming stations, clocks, frequencies, VDIF datastreams, baselines and scans; the output directory must be new. A recommended first step is inspecting headers with cuphoton xbeam inspect-vdif, then building .vdix sidecars with build-vdif-sidecar, which uses cuFile by default (pass --backend posix on machines without GPUDirect Storage). Correlation runs with --backend cupy and optionally --vdif-io cufile for direct storage-to-GPU reads. A Python API exposes load_job, correlate and a CorrelationWindow, returning visibility records one at a time, though writing SWIN files is left to the command-line tool.

Scaling works by splitting the scan in time. On a single node, --devices starts one process per GPU, writes results under RUN/shards/ and merges them. Across nodes, each process takes --shard-count and --shard-index (64 GPUs means --shard-count 64 with indices 0 through 63), and merge-shards joins the partial SWIN outputs after checking that all shards share the same job, cover the full time range and agree on headers. xBeam also offers an explicit gap-handling policy, --profile interop-real-usb-buffered-window-replay-v1, which keeps consuming samples within a reader buffer under the existing time anchor; the documentation cautions that it does not recover missing samples and that a full reported weight does not mean every timestamp was recorded.

NVIDIA also sketches an agentic angle: an AI agent could parse VDIF metadata, generate JSON job specs, launch correlation across clusters and monitor runs. The company notes current benchmarks focus on GPU acceleration rather than full agentic control, so this is presented as a potential application rather than a demonstrated result. The rest of cuPhoton applies a similar GPU-first pattern elsewhere: xDataReader, xScan, xPois and xFit for optical imaging, and xRay for detector frames from X-ray laser experiments.

A likely trade-off is workflow lock-in to the job-file model: accurate delays must come from elsewhere, so teams need an existing correlator pipeline or fringe-fitting setup to feed xBeam. In practice, the 460x figure also reflects a very large multi-node system with fast storage, so single-node gains will be smaller, though the scaling data suggests read bandwidth rather than compute quickly becomes the constraint.

Why it matters: correlating raw telescope voltages is the step that gated large interferometry datasets, and moving it onto GPUs with indexed sidecars and shard-based distribution could change how quickly next-generation EHT observations are processed. Developers in radio astronomy, and HF and signal-processing engineers more broadly, get a concrete CLI and Python API to integrate into imaging pipelines. The agentic orchestration NVIDIA describes is inference on my part as much as theirs, but automated job generation and execution is a plausible near-term use for teams managing multi-telescope data.

Read at NVIDIA Developer Blog

Based on reporting from the original publisher. Visit the source for full context and later updates.

Publisher excerpt

Imaging black holes is challenging because they are distant and appear tiny in the sky—for example, M87*’s observed ring spans just 42 microarcseconds. The...