TL;DR
FPGA-GEN is an agentic workflow that uses Large Language Models (LLMs) and tool-in-the-loop feedback to transform standard C/C++ into high-performance, hardware-ready RTL. By integrating hardware-aware selection and rigorous "device admission" rules, it achieves a 97.2% success rate in converting complex designs while significantly optimizing for latency and resource usage.
What Problem Does This Paper Address?
High-Level Synthesis (HLS) is the "magic" process of turning software code (C/C++) into hardware descriptions (RTL). However, just because C code compiles doesn't mean it will make for good hardware. A design might be functionally correct but fail to fit on the target FPGA, or it might be agonizingly slow because the LLM didn't use the right hardware pragmas.
Current LLM-based approaches often focus on just getting the code to "pass the testbench." The authors argue that this isn't enough. Real-world FPGA development requires target-awareness: the workflow must understand the specific resource constraints (like LUTs, DSPs, and BRAMs) and performance goals of the destination chip.
Methods
FPGA-GEN moves away from simple "prompt-and-pray" methods toward a structured, rule-based agentic workflow.

The workflow consists of several key stages:
- Multi-level Decomposition: It breaks tasks down into workflow and function levels, processing "helper" functions first to ensure a solid foundation before top-level composition.
- Bounded Hardware-Aware Selection: Instead of picking one candidate, it generates a set. It then uses a cost objective function—balancing latency (cycles) and resource usage—to rank them. This happens before the expensive validation and repair phase.
- Tool-Guided Repair: If a design fails, the system uses diagnostics from HLS tools to guide the LLM in fixing the code within a fixed "search budget."
- Artifact-Linked Qualification: This is the "admission" phase. To be admitted, a design must pass held-out functional tests, and the exact same RTL must successfully fit on the target device via Vivado synthesis.
Datasets
The authors evaluated FPGA-GEN across several established and internal benchmarks:
- HLS-Eval: 85 tasks used to test initial generation consistency.
- HLS-LeVeri: 107 designs used for a cumulative conversion campaign.
- Rosetta: A benchmark for realistic HLS tasks, used here for repair and held-out testing.
- MachSuite & CHStone: Classic HLS benchmarks used to fill out the conversion study.
Key Insights and Ideas
- Admission vs. Passing: The paper draws a hard line between a design that passes a public testbench and one that is "device-admitted." Admission requires matching RTL hashes between simulation and synthesis, ensuring that what you tested is exactly what you're shipping to the chip.
- The Power of Ranking: By ranking candidates using a "pre-repair latency-resource proxy," the system can identify high-potential designs early. In the TensorCore study, this allowed the system to select a candidate that was vastly more efficient than the baseline.
- Conservative Fallback: The workflow maintains a "conservative reference" ($C_0$). If the fancy model-generated optimizations fail to validate, the system can rebuild the stable reference using the same verified helper functions, ensuring the workflow rarely ends in a total failure.
Key Results
FPGA-GEN demonstrates state-of-the-art performance across multiple metrics:
- High Reliability: On the HLS-Eval benchmark, it achieved a 95.8% pass rate (407/425) for public testbenches.
- Robust Conversion: In a campaign of 208 tasks, it admitted 190 designs (91.3% overall). For the HLS-LeVeri subset specifically, it hit a 97.2% admission rate.
- Significant Optimization: In a focused TensorCore screening, the selected candidate reported 73.7% fewer cycles and 14.6% fewer LUTs than the initial generated baseline, despite using 26.7% more DSPs to achieve that speedup.
- Selection Efficiency: As shown in Figure 2, the selection process frequently finds lower-cost alternatives compared to the baseline $C_0$.

Limitations and Future Work
While highly effective, the authors note several remaining hurdles:
- Oracle Coverage: The system is only as good as its test vectors. If the "oracle" (the reference behavior) is missing or incomplete, the workflow can't guarantee correctness.
- Tool Latency: Running full synthesis and co-simulation loops is time-consuming. The authors suggest that future work should focus on "direct" C-to-HLS-C conversion with fewer intermediate stages.
- Pattern Extraction: A promising direction is to have the model learn from successful "repair trajectories"—essentially building a library of hardware engineering "common sense" to reduce the need for iterative tool feedback.
Summary updated