FPGA Accelerates the Radio Sky: Direct Imaging for Giant Antenna Arrays ✛
Context
Modern radio astronomy is experiencing an explosion of discoveries of fast transients, from millisecond radio bursts to gamma-ray burst afterglows. To catch these phenomena, instruments need huge fields of view and instantaneous response. Aperture arrays of thousands of small antennas provide such a field, but they generate an avalanche of data. Classical correlators, which compute all pairwise correlations of signals, require O(N²) operations, which becomes prohibitive for N in the tens of thousands. Alongside this work on the archive are studies on quantum algorithms and complex quantum systems, but this paper stands apart: it solves a real-time engineering problem for ground-based radio telescopes. Direct imaging via a spatial Fourier transform promises O(N log N) scaling, and early GPU implementations have already shown two orders of magnitude speedup, but they hit memory bandwidth limits. Moving to FPGA removes this bottleneck.
Methods
The authors built a prototype on a commercial AMD Alveo V80 card with 32 GB of HBM2e memory and four 200GbE interfaces. Calibrated complex voltages from the antenna array elements are loaded onto the card. The EPIC core performs three steps: gridding (interpolating the voltages onto a regular grid with a step smaller than half a wavelength), a two-dimensional fast Fourier transform, and per-pixel squaring to obtain polarization images. For verification, they created synthetic data based on the AAVS2 station layout (a prototype for SKA-Low) at a frequency of 159 MHz: three persistent sources and one transient, each with its own randomness, without thermal noise. The voltages are digitized with 8 bits for the real and imaginary parts. Simulation in AMD Vivado confirmed the correctness of the timing and the FFT.
Results
The prototype produces 64×64 pixel frames with a cadence of 5.12 microseconds: each frame is accumulated from four intervals of 1.28 microseconds at a channel width of 780 kHz. The output images recover all sources at the correct positions, including the injected transient. Resource estimates show that one 64×64 core processes about 6 MHz of bandwidth, and eight such cores fit on a single card, giving a total of 50 MHz. Alternatively, a 512×512 core processes one coarse channel of 780 kHz. The card can serve an array of roughly 20,000 elements with two polarizations, equivalent to 20–30 stations of the SKA-Low core. Compared to the GPU implementation on LWA-Sevilleta, which produced frames every 80 ms with a bandwidth of 19.2 MHz, the new approach wins in bandwidth by several times and potentially by an order of magnitude in array size, time resolution, and image size.
Implications
This work moves the direct imaging method from graphics processors to programmable logic, where low-precision FFTs run in parallel with lower power consumption. Unlike neighboring works on quantum algorithms that explore theoretical limits, this addresses the practical scaling problem for upcoming telescopes. It is not just an acceleration but a change in architectural paradigm: instead of storing correlations, the image is computed directly, drastically reducing memory and bandwidth requirements. For SKA-Low, where a correlator and beamformer already use the same Alveo V80 cards, the proposed approach opens a path to unified processing.
Future development
The next step is to test the prototype on real data from the operating AAVS2 station at the Murchison Observatory. This will require integration with the calibration system and solving input/output issues for streaming. In the long term, the architecture could scale to images of about a megapixel and arrays of tens of thousands of elements, provided that precision and memory allocation are optimized. It may be possible to combine multiple cards to process wider bands or create mosaics from several fields of view.
Impact
The technology will directly affect radio sky surveys: SKA-Low, MWA, LOFAR, and future instruments like HIRAX will be able to continuously monitor the entire sky with millisecond time resolution. It will also speed up the search for fast radio bursts and electromagnetic counterparts of gravitational-wave events.
Next steps
The immediate task is to run the prototype on a real data stream from AAVS2 and compare its sensitivity with that of a traditional correlator. Then, precision optimization to reduce power consumption and testing on a full-scale SKA-Low station will follow.
Key open problems
For radio astronomy, the key unsolved problem is real-time processing of arrays with more than ten thousand elements without losing sensitivity. This work offers a concrete path, but questions remain about the accuracy of gridding for arbitrary antenna layouts and the impact of low precision on the dynamic range of images.
The knowledge machine's view
This section is addressed to the author of the paper and their colleagues. Neighbouring works were found by meaning-based search across our archive, not by word overlap. We do not review: we show the field around the work.
What the work does
The authors implemented the direct imaging method (EPIC) on an AMD Alveo V80 FPGA, using gridding, a two-dimensional FFT, and per-pixel squaring. The prototype processes data from a 256-element SKA-Low station, producing 64×64-pixel frames every 5.12 microseconds. Estimates indicate that a single card can serve up to 20,000 antennas, an order of magnitude more than existing GPU solutions.
Where its strength is
Porting EPIC to an FPGA removes the memory bandwidth bottleneck typical of GPUs and demonstrates scalability to large arrays with high cadence and low power consumption.
Where it could go next
- It might be interesting to see how approaches from PhySR, which combine physical models with neural networks, could complement direct imaging: for instance, using trained models to improve reconstruction quality or speed up processing.based on: PhySR: Physics Helps a Neural Network See Through the Radio Static arXiv:2607.27750v1
- Related work on GPU-based direct imaging with a 14-second synthesis time sits nearby; comparing with it could reveal ways to optimize accuracy and resources when moving to FPGAs.based on: 14 Seconds to Weave a Star: Direct Synthesis Returns arXiv:2607.24141v1
- The archive contains a study on calibrating large antenna arrays using a robot; integrating such calibration methods with the FPGA implementation of EPIC could enhance the accuracy of the produced images.based on: How a Robot Focused 5,000 Radio Eyes arXiv:2604.17448
Worth trying
- Test low-precision FFTs with block floating point to improve accuracy without significantly increasing resource usage.
- Investigate dynamic resource reallocation among cores to adapt to varying bandwidth and image sizes.
- Consider integrating machine learning methods to suppress artifacts and improve dynamic range in real time.
Why this may matter
An FPGA implementation of EPIC paves the way for cost-effective and energy-efficient data processing systems for giant antenna arrays, which is critical for future projects like SKA and for capturing fast radio transients.
Nearby works in our archive
- Light Instead of Wires: Photonic Chip Computes Fastersimilarity 0.56
- Neural Network by Ear: How to Capture a Particle's Energysimilarity 0.52
- 14 Seconds to Weave a Star: Direct Synthesis Returnssimilarity 0.51
- Digital Conductor of Gravitational Waves: Neural Network Conducts Black Hole Mergerssimilarity 0.51
- PhySR: Physics Helps a Neural Network See Through the Radio Staticsimilarity 0.51
- Antenna Grows in Volumesimilarity 0.50
- How a Robot Focused 5,000 Radio Eyessimilarity 0.49
The archive is sparse around this work: the closest review is only 0.56, against a usual 0.64. It looks like few have drilled nearby.
The AMD Alveo V80 card used in the prototype is identical to the one already installed in the SKA-Low correlator and beamformer. That is, the same accelerator can both compute correlations and directly form images.
The idea of instantaneously 'photographing' the entire sky recalls the monitoring system in Carl Sagan's novel 'Contact', where an array of radio telescopes continuously scans the sky for signals. Only here, instead of searching for extraterrestrial intelligence, it is a hunt for fast cosmic explosions.
Key numbers
- frame rate: 5.12 microseconds per frame (195,000 frames per second)
- image size: 64×64 pixels in the prototype, up to 512×512 in the extended version
- number of elements: 256 in the prototype, up to 20,000 on a single card
- processing bandwidth: 50 MHz per card for 64×64, 780 kHz for 512×512
- speedup over GPU: several times in bandwidth, up to an order of magnitude in array size