Pith. sign in

REVIEW 3 major objections 4 minor 37 references

HINT: Toward an Executable Hardware-Intent Representation Layer for LLM-Driven RTL Generation

T0 review · 3 major / 4 minor · reviewed 2026-08-11 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read HINT proposes an executable hardware-intent intermediate representation layer between behavioral specifications and RTL, and claims it produces contract-compliant synthesizable RTL on 7/7 operator cases with smaller area than direct…

desk verdict Solid, honest contribution: the HINT intent layer is genuinely new and the evaluation is mostly careful, but the 7/7 headline rests on a human-authored pilot and a debug-visible test gate, so treat the claims as conditional. read the letter →

arxiv 2608.07625 v1 pith:QFJVWB3P submitted 2026-08-07 cs.AR cs.MA

Tairan Cheng , Yi Liu , Dongsheng Zuo , Zhengyuan Shi , Hongji Zhang , Xiangfei Hu , Maoshuo He , Hao Yan
show 1 more author
Qiang Xu
This is my paper · ORCID
classification cs.ARcs.MA
keywords hardware-intentrepresentationLLM-drivenRTLgenerationintermediatemicroarchitectureregister-transferleveltransaction-levelverificationhigh-levelsynthesishardwaredesignautomation
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper tries to establish that inserting an executable hardware-intent layer between behavioral specifications and RTL lets LLM-driven RTL generation resolve microarchitecture explicitly, making the generation task more a constrained realization than an open-ended inference problem. The authors argue that this separation improves correctness convergence and implementation quality because high-impact structural choices are made and checked before low-level code occupies the generation budget. In a controlled study of seven operator designs, the HINT-mediated route achieves contract-compliant, synthesizable RTL on all seven cases, while Direct C2RTL and C2HLSC succeed on five and one of their five applicable cases. Under matched synthesis, HINT reduces area by 5.0% to 26.2% relative to manual RTL and by 8.9% to 86.1% relative to accepted Direct C2RTL results. Cross-scale trials on AES, SDC, and a Vortex-derived VPU indicate that the approach extends to protocol-rich, memory-rich, hierarchical designs.

What carries the argument

The central object is HINT, an executable hardware-intent intermediate representation layer defined by semantic obligations covering program and object model, types and interfaces, state and control, resource and QoR model, and RTL-lowering obligations. Its evaluated instantiation is a restricted C-like reference profile in which each unit owns its state, exposes one step entry point, and commits updates only at its boundary, so the artifact can be executed and debugged at transaction level before RTL exists. The machinery that carries the argument is the pairing of an accepted HINT artifact with a frozen verification environment: HINT is checked by transaction-level equivalence against an oracle, and the same checks gate the lowered RTL, which localizes failures to architecture defects versus lowering defects.

What would settle it

Take the accepted HINT and RTL for any operator other than Hif8_mul and run co-simulation against an independently generated exhaustive or formally derived input set for that operator, such as all operand pairs for the 8-bit multiplier or all round and key schedules for AES; any mismatch that violates the stated latency or output contract would falsify the 7/7 claim as literally stated.

Watch

Extended reading notes

Core claim

The paper's central claim is that an executable hardware-intent representation layer, HINT, can carry the architectural commitments of a design through LLM-driven RTL generation, and that doing so yields correct, synthesizable RTL more reliably and with better quality-of-results than direct RTL generation. A HINT design is a hierarchy of persistent units with typed boundary objects, owned state, bounded progress, and exactly one step entry point, expressed as $(o_t, s_{t+1}) = \mathrm{step}_H(i_t, s_t)$. These commitments become explicit RTL-lowering obligations, so the RTL realization is checked for observable behavior and transaction timing against the same frozen verification environment that accepted the HINT artifact. The paper reports 7/7 contract compliance in the operator study, superior area and ADP compared with manual RTL and Direct C2RTL under matched synthesis, and successful generation of RealBench AES, RealBench SDC, and a connected Vortex-derived non-floating-point VPU synthesizing to 561.67k$\mu\mathrm{m}^2$.

Load-bearing premise

The 7/7 contract-compliance and QoR claims rest on transaction-level co-simulation with frozen testbenches, so if those testbenches miss behaviors in the design contract, contract compliance on unseen inputs is not established.

Editorial extensions

If this is right

  • If the HINT-mediated route is correct, LLM-driven RTL generation can be decomposed so that architectural mistakes are caught before signal-level debugging, reducing the cost of fixing generated designs.
  • The reported area and ADP improvements imply that explicit resource and control commitments, rather than post-synthesis search, can be the main lever for implementation quality in LLM-generated hardware.
  • The successful AES, SDC, and VPU trials imply that the representation layer can scale beyond compact flat modules to protocol-rich, memory-rich, and hierarchical designs where direct generation remains unreliable.
  • The frozen verification environment acting as a gate for both HINT and RTL implies that a single accepted intent artifact can be lowered multiple times without re-doing architectural exploration.
  • HINT artifacts, once accepted, could serve as reusable intent specifications for a design, separating the long-lived architecture from the details of a particular RTL realization.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Editorial inference: the explicit RTL-lowering obligations in HINT could be consumed by automated schedulers or binding tools, which would let the same intent artifact be realized in multiple RTL organizations and make the quality-of-results comparison far less dependent on LLM low-level coding ability.
  • Editorial inference: a testable extension is to apply the transaction-level acceptance approach to a broader set of operators with formally specified contracts, then check whether the formal properties catch any behavior that the frozen testbenches miss, which would directly probe the coverage gap in the current verification-based claim.
  • Editorial inference: if the approach scales, designers could explore microarchitectures at the HINT level, freeze one, and regenerate RTL whenever a new LLM or technology library appears, decoupling architectural exploration from low-level code churn.
  • Editorial inference: the paper's benchmark selection suggests the benefit of an intent layer grows with design complexity, and the method is not claimed to help on compact flat modules where direct generation already succeeds.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. The paper proposes HINT, an executable hardware-intent intermediate representation layer inserted between behavioral specifications/oracles and RTL generation by LLM agents. A HINT artifact makes microarchitectural commitments (typed transaction boundaries, owned state, bounded progress, control/datapath organization, resource commitments) explicit, is checked at transaction level before RTL is written, and then acts as a set of RTL-lowering obligations. The authors evaluate HINT in a controlled operator study (seven cases) and in cross-scale studies (RealBench AES and SDC, a Vortex-derived VPU). They report 7/7 contract-compliant synthesizable RTL for the HINT-mediated route, 5/5 for Direct C2RTL on the five applicable cases, 1/5 for C2HLSC, and area reductions of 5.0%–26.2% versus five manual RTL implementations and 8.9%–86.1% versus five accepted Direct C2RTL results. The paper also reports successful synthesis of RealBench AES/SDC and a 561.67k μm² VPU.

Significance. If its claims hold, HINT is a useful contribution: it separates architecture-level decisions from low-level RTL coding in LLM-based hardware generation, enables pre-RTL transaction-level checking, and provides an explicit contract for downstream lowering. The authors deserve credit for freezing verification assets before generation, sharing the correctness budget across routes, reporting the first successful post-acceptance synthesis rather than searching over QoR, and making artifacts available. The cross-scale demonstrations, especially the connected Vortex VPU, are valuable feasibility evidence. However, the strength of the central 7/7 and area-reduction claims is limited by the verification protocol and by the composition of the case set, as detailed below. The idea is credible and the paper is publishable after the load-bearing issues are addressed.

major comments (3)
  1. [Sec. 4.1 (Stage 0/1) and Sec. 5.1] The 7/7 contract-compliance claim rests on acceptance against exactly the same frozen tests or transactions that the Codex ReAct node observes during debugging; no held-out or re-randomized test set is reported. Because the controller returns failing testbench diagnostics to the agent and the agent may iterate up to 20 revisions, the acceptance gate can be satisfied by adapting to the debug-visible test population rather than by satisfying the full design contract. This also weakens the QoR comparisons, which are computed for RTL accepted under this same gate. Please add a held-out or re-seeded acceptance step, or explicitly restrict the correctness claim to 'the frozen test set' and temper the contract-compliance language accordingly.
  2. [Sec. 5.2, Table 2] The Hif8_mul case is a pilot in which an engineer authored the HINT artifact and Codex only lowered it mechanically. Including this case in the 7/7 headline conflates human architecture authoring with the LLM-mediated route and overstates the degree to which the workflow alone resolves architectural decisions. Moreover, because Hif8_mul and Karatsuba have no Direct C2RTL baseline, the 7/7-versus-5/5 comparison is not apples-to-apples: on the five cases where both HINT and Direct C2RTL apply, both routes succeed 5/5. The paper should report the fully autonomous success count separately and should state explicitly that Direct C2RTL ties HINT on the common subset.
  3. [Sec. 4.2 and Table 2] Each reported QoR result comes from a single Codex run per route, with no measure of run-to-run variability. Given that Debug Iter. ranges from 0 to 5 across cases, different seeds or initializations could plausibly change which RTL is accepted and its area. The area-reduction claims of 5.0%–26.2% and 8.9%–86.1% would be more convincing with multiple independent runs, at least on a subset of cases, or with an explicit acknowledgment that these are single-sample pilot results rather than stable route-level expectations.
minor comments (4)
  1. [Table 2] Several HINT-route area entries appear to have an extra leading digit: '01.58k', '311.10k', '6634.18k', and '6837.25k' are likely intended as '1.58k', '11.10k', '34.18k', and '37.25k'. Please reformat the table to avoid ambiguity.
  2. [Sec. 4.1, Formal-checking scope] For Hif8_mul, Formality checks the HINT-lowered implementation against an engineer-written implementation; please clarify whether this is a check of the HINT artifact's semantics or only of the lowered RTL against a golden netlist, since the two interpretations support different claims.
  3. [Sec. 3, Canonical hardware form] Terms such as 'bounded progress' and 'architecture-relevant state' are described textually but not formalized; spelling out the conditions enforced by the HINT Lint Checker would make the representation's guarantees easier to assess and reproduce.
  4. [Sec. 5.1] The phrase 'observed convergence' is used for within-budget acceptance; this is a reasonable characterization, but the paper should avoid wording that implies a statistical comparison with pass@k, since the runs are adaptive rather than independent samples.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: HINT is an empirical evaluation measured against external baselines; the only self-citation is a non-load-bearing ADP metric definition.

full rationale

HINT is presented as a new representation and workflow, and the paper's central claims are empirical: measured acceptance rates and synthesized area/timing compared with manual RTL, Direct C2RTL, and C2HLSC baselines. There is no derivation chain from inputs to outputs that could collapse by definition. The only self-citation is CktEvo [25] for the ADP metric, which is a reporting convention, not a load-bearing premise for the central claims. The explicit verification caveats in Sec. 3 and Sec. 4.1, stating that most designs are accepted by transaction-level co-simulation rather than formal equivalence, are limitations on evidence strength rather than circular steps; similarly, the frozen-test protocol in Sec. 4.1 raises a legitimate overfitting concern, but this is an evaluation validity issue, not a reduction of the result to its own inputs. The Hif8_mul pilot (Sec. 5.2, Table 2 note) involves human-authored HINT, which weakens the LLM-driven claim for one case, but this is a scope limitation, not circularity. No fitted parameter is renamed as a prediction: QoR numbers come from actual synthesis of accepted RTL, and the HINT route is frozen at first successful synthesis with no post-synthesis QoR refinement. Therefore, the paper is self-contained as an empirical study, and no circular step can be exhibited.

Assumptions & free parameters 1 free parameters · 3 assumptions · 1 invented entities

This is an empirical systems paper; the only hand-chosen numeric inputs are the per-case latency contracts that define success. The load-bearing assumptions are the sufficiency of co-simulation as a correctness gate, the expressiveness of the reference profile, and the fairness of matched synthesis comparisons. The HINT representation itself is the central proposed entity, with observable consequences in the reported results.

free parameters (1)
  • Target latency and initiation interval per case = Reported in Table 2 as target latency (e.g., 0 for combinational, 6 for SHA256); some fixed manually before generation…
    These hand-set timing contracts define what counts as contract-compliant and constrain the synthesis optimization; the area-reduction claims are relative to these frozen targets and could differ under other latency choices.
assumptions (3)
  • domain assumption Transaction-level co-simulation with frozen testbenches is a sufficient correctness gate for HINT and RTL contract compliance.
    All designs except Hif8_mul are accepted through simulation or co-simulation only (Sec. 4.1, Formal-checking scope); the paper disclaims formal structural equivalence in Sec. 3. The 7/7 and QoR claims inherit this assumption.
  • ad hoc to paper The HINT reference-profile restrictions (static bounds, no dynamic allocation, no recursion) still capture the architecture decisions that determine RTL correctness and QoR.
    The paper defines the reference profile in Sec. 3 and evaluates only designs within it; expressiveness is asserted rather than proven.
  • domain assumption Matched synthesis constraints isolate the effect of the representation layer on QoR.
    Sec. 4.2 compares all implementations with the same library, scripts, and constraints; this assumes no uncontrolled interaction between the representation and the synthesis tool's optimization.
invented entities (1)
  • HINT layer and its reference-profile obligations independent evidence
    purpose: Intermediate executable representation between behavioral spec and RTL to make architecture explicit and checkable before RTL generation.
    The paper provides falsifiable handles: contract-compliance success rates and matched-synthesis area and timing comparisons for seven operator cases and three larger designs. Whether HINT is useful is testable outside the paper, though independent replication is not yet available.

how reviews work

0 comments
Cite this review

Pith. "Pith review of HINT: Toward an Executable Hardware-Intent Representation Layer for LLM-Driven RTL Generation." pith.science (2026). https://pith.science/paper/QFJVWB3P

@misc{pith2026260807625,
  author       = {Pith},
  title        = {Pith review of: HINT: Toward an Executable Hardware-Intent Representation Layer for LLM-Driven RTL Generation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/QFJVWB3P}},
  note         = {Machine review of arXiv:2608.07625}
}
abstract

Generating implementation-quality RTL with large language models (LLMs) remains difficult because direct generation must resolve microarchitecture while simultaneously producing and debugging low-level code. We present HINT, an executable hardware-intent intermediate representation layer between behavioral specifications or executable oracles and RTL. HINT makes RTL-relevant microarchitecture explicit, supports pre-RTL checking, and supplies explicit RTL-lowering obligations. We evaluate HINT using both a minimal single-agent flow and a full staged workflow. Across seven operator cases, the HINT-mediated route, with no post-synthesis QoR refinement, produces contract-compliant synthesizable RTL on 7/7 cases; Direct C2RTL and C2HLSC apply to five cases and succeed on 5/5 and 1/5, respectively. Under matched Design Compiler synthesis, HINT reduces area by 5.0\%--26.2\% relative to five manual RTL implementations and by 8.9\%--86.1\% relative to five accepted Direct C2RTL results. RealBench AES and SDC, together with a Vortex VPU synthesizing to 561.67k~$\mu\mathrm{m}^2$, further demonstrate specification-driven, protocol-rich, memory-rich, and hierarchical designs. In the controlled operator study, the HINT-mediated route shows better observed convergence and avoids the severe implementation-quality degradation seen in several direct-generation results.

Figures

Figures reproduced from arXiv: 2608.07625 by the authors.

Figure 1
Figure 1. Canonical reference-profile excerpt for a shared [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Full HINT-centered flow used for cross-scale generation. The controlled operator study uses the reduced sequential [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. CORDIC example comparing two functionally [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

37 extracted references · 22 canonical work pages

  1. [1]

    Meisam Abdollahi, Seyedeh Faegheh Yeganli, Mohammad (Amir) Baharloo, and Amirali Baniasadi. 2025. Hardware Design and Verification with Large Language Models: A Scoping Review, Challenges, and Open Issues.Electronics14, 1 (2025),

    work page 2025

  2. [2]

    2016.SystemC Synthesizable Subset Lan- guage Reference Manual, Version 1.4.7

    Accellera Systems Initiative. 2016.SystemC Synthesizable Subset Lan- guage Reference Manual, Version 1.4.7. Accellera Systems Initiative. https://www.accellera.org/images/downloads/standards/systemc/SystemC_ Synthesis_Subset_1_4_7.pdf

    work page 2016

  3. [3]

    Lukai Cai and Daniel Gajski. 2003. Transaction Level Modeling: An Overview. InProceedings of the First IEEE/ACM/IFIP International Conference on Hard- ware/Software Codesign and System Synthesis. 19–24. doi:10.1109/CODESS.2003. 1275250

    work page doi:10.1109/codess.2003 2003

  4. [4]

    Luca Collini, Siddharth Garg, and Ramesh Karri. 2025. C2HLSC: Leveraging Large Language Models to Bridge the Software-to-Hardware Design Gap.ACM Trans. Des. Autom. Electron. Syst.30, 6, Article 96 (Oct. 2025), 24 pages. doi:10. 1145/3734524

    work page 2025

  5. [5]

    Jason Cong, Bin Liu, Stephen Neuendorffer, Juanjo Noguera, Kees Vissers, and Zhiru Zhang. 2011. High-Level Synthesis for FPGAs: From Prototyping to De- ployment.IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems30, 4 (2011), 473–491. doi:10.1109/TCAD.2011.2110592

    work page arXiv 2011

  6. [6]

    Matthew DeLorenzo, Animesh Basak Chowdhury, Vasudev Gohil, Shailja Thakur, Ramesh Karri, Siddharth Garg, and Jeyavijayan Rajendran. 2024. Make Every Move Count: LLM-based High-Quality RTL Code Generation Using MCTS.arXiv preprint arXiv:2402.03289(2024). arXiv:2402.03289 [cs.LG]

    arXiv 2024

  7. [7]

    Adam Donlin. 2004. Transaction Level Modeling: Flows and Use Models. In Proceedings of the International Conference on Hardware/Software Codesign and System Synthesis. 75–80. doi:10.1109/CODESS.2004.240821

    work page arXiv 2004

  8. [8]

    Schuyler Eldridge, Prithayan Barua, Aliaksei Chapyzhenka, Adam Izraelevitz, Jack Koenig, Chris Lattner, Andrew Lenharth, George Leontiev, Fabian Schuiki, Ram Sunder, Andrew Young, and Richard Xia. 2021. MLIR as Hardware Compiler Infrastructure. InWorkshop on Open-Source EDA Technology (WOSET). https: //woset-workshop.github.io/PDFs/2021/a06.pdf

    work page 2021

Show all 37 references
  1. [9]

    Wenji Fang, Yao Lu, Shang Liu, Qijun Zhang, Ceyu Xu, Lisa Wu Wills, Hongce Zhang, and Zhiyao Xie. 2025. RTLCoder: Fully Open-Source and Efficient LLM- Assisted RTL Code Generation Technique.IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems44, 4 (202...

    2025

  2. [10]

    Mingzhe Gao, Jieru Zhao, Zhe Lin, Wenchao Ding, Xiaofeng Hou, Yu Feng, Chao Li, and Minyi Guo. 2024. AutoVCoder: A Systematic Framework for Automated Verilog Code Generation using LLMs. arXiv:2407.18333 [cs.AR] https://arxiv. org/abs/2407.18333

    2024 arXiv

  3. [11]

    Google and SkyWater Technology. 2026. Open Source Process Design Kit for the SkyWater SKY130 Process Node. https://github.com/google/skywater-pdk. Accessed 2026-04-10

    2026

  4. [12]

    Zhuolun He, Yuan Pu, Haoyuan Wu, Tairu Qiu, and Bei Yu. 2025. Large Language Models for EDA: Future or Mirage?ACM Trans. Des. Autom. Electron. Syst.30, 6, Article 90 (Oct. 2025), 53 pages. doi:10.1145/3736167

    2025 doi

  5. [13]

    Pengwei Jin, Di Huang, Chongxiao Li, Shuyao Cheng, Yang Zhao, Xinyao Zheng, Jiaguo Zhu, Shuyi Xing, Bohan Dou, Rui Zhang, Zidong Du, Qi Guo, and Xing Hu. 2025. RealBench: Benchmarking Verilog Generation Models with Real-World IP Designs. arXiv:2507.16200 [cs.LG] https://arxiv....

    2025 arXiv

  6. [14]

    Chris Lattner, Mehdi Amini, Uday Bondhugula, Albert Cohen, Andy Davis, Jacques Pienaar, River Riddle, Tatiana Shpeisman, Nicolas Vasilache, and Olek- sandr Zinenko. 2021. MLIR: Scaling Compiler Infrastructure for Domain Specific Computation. In2021 IEEE/ACM International Sympo...

    2021

  7. [15]

    Li, Adam Izraelevitz, and Jonathan Bachrach

    Patrick S. Li, Adam Izraelevitz, and Jonathan Bachrach. 2016.Specification for the FIRRTL Language. Technical Report UCB/EECS-2016-9. EECS Department, Uni- versity of California, Berkeley. https://www2.eecs.berkeley.edu/Pubs/TechRpts/ 2016/EECS-2016-9.pdf

    2016

  8. [16]

    Mingjie Liu, Nathaniel Pinckney, Brucek Khailany, and Haoxing Ren. 2023. In- vited Paper: VerilogEval: Evaluating Large Language Models for Verilog Code Generation. In2023 IEEE/ACM International Conference on Computer Aided Design (ICCAD). 1–8. doi:10.1109/ICCAD57390.2023.10323812

    2023

  9. [17]

    Anton Lozhkov, Raymond Li, Loubna Ben Allal, Federico Cassano, Joel Lamy- Poirier, Nouamane Tazi, Ao Tang, Dmytro Pykhtar, Jiawei Liu, Yuxiang Wei, Tianyang Liu, Max Tian, Denis Kocetkov, Arthur Zucker, Younes Belkada, Zi- jian Wang, Qian Liu, Dmitry Abulkhanov, Indraneil Paul...

    2024 arXiv

  10. [18]

    Yao Lu, Shang Liu, Qijun Zhang, and Zhiyao Xie. 2024. RTLLM: An Open-Source Benchmark for Design RTL Generation with Large Language Model. In2024 29th Asia and South Pacific Design Automation Conference (ASP-DAC). 722–727. doi:10.1109/ASP-DAC58780.2024.10473904

    2024

  11. [19]

    Yuanyong Luo, Zhongxing Zhang, Richard Wu, Hu Liu, Ying Jin, Kai Zheng, Minmin Wang, Zhanying He, Guipeng Hu, Luyao Chen, Tianchi Hu, Junsong Wang, Minqi Chen, Dmitry Mikhaylov, Vladimir Korviakov, Maxim Bobrin, Yuhao Hu, Guanfu Chen, and Zeyi Huang. 2024. Ascend HiFloat8 Form...

    2024 arXiv

  12. [20]

    Razvan Nane, Vlad-Mihai Sima, Christian Pilato, Jongsok Choi, Blair Fort, Andrew Canis, Yu Ting Chen, Hsuan Hsiao, Stephen Brown, Fabrizio Ferrandi, Jason Anderson, and Koen Bertels. 2016. A Survey and Evaluation of FPGA High- Level Synthesis Tools.IEEE Transactions on Compute...

    2016

  13. [21]

    Rachit Nigam, Samuel Thomas, Zhijing Li, and Adrian Sampson. 2021. A Com- piler Infrastructure for Accelerator Generators. InProceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS). 804–817. doi:10....

    2021

  14. [22]

    OpenAI. 2026. GPT-5.3-Codex Model. https://developers.openai.com/api/docs/ models/gpt-5.3-codex. OpenAI API documentation, accessed 2026-04-10

    2026

  15. [23]

    Jingyu Pan, Guanglei Zhou, Chen-Chia Chang, Isaac Jacobson, Jiang Hu, and Yiran Chen. 2025. A Survey of Research in Large Language Models for Electronic Design Automation.ACM Transactions on Design Automation of Electronic Systems 30, 3 (2025), 34:1–34:21. doi:10.1145/3715324

    2025 doi

  16. [24]

    Zehua Pei, Huiling Zhen, Mingxuan Yuan, Yu Huang, and Bei Yu. 2024. BetterV: Controlled Verilog Generation with Discriminative Guidance. InInternational Conference on Machine Learning. PMLR, 40145–40153

    2024

  17. [25]

    Zhengyuan Shi, Jingxin Wang, Tairan Cheng, Changran Xu, Weikang Qian, and Qiang Xu. 2026. CktEvo: Repository-Level RTL Code Benchmark for Design Evolution.arXiv preprint arXiv:2603.08718(2026)

    2026

  18. [26]

    Synopsys, Inc. 2026. Design Compiler: Timing, Area, Power, & Test Opti- mization. https://www.synopsys.com/implementation-and-signoff/rtl-synthesis- test/design-compiler.html. Accessed: 2026-04-14

    2026

  19. [27]

    Synopsys, Inc. 2026. Formality Equivalence Checking. https: //www.synopsys.com/implementation-and-signoff/signoff/formality- equivalence-checking.html. Accessed: 2026-07-16

    2026

  20. [28]

    Yan Tan, Xiangchen Meng, Zijun Jiang, and Yangdi Lyu. 2026. AutoVeriFix: Automatically Correcting Errors and Enhancing Functional Correctness in LLM- Generated Verilog Code. In2026 31st Asia and South Pacific Design Automation Conference (ASP-DAC). 526–532. doi:10.1109/ASP-DAC...

    2026

  21. [29]

    Blaise Tine, Krishna Praveen Yalamarthy, Fares Elsabbagh, and Hyesoon Kim

  22. [30]

    Anu Verma, Khyati Kiyawat, Bishnu Prasad Das, and Pramod Kumar Meher

  23. [31]

    Shuo Yin, Yihe Wang, Lancheng Zou, Xufeng Yao, Tinghuan Chen, Chen Bai, Zhengrong Wang, Tsung-Yi Ho, and Bei Yu. 2026. CPPL: A Circuit Prompt Programming Language. arXiv:2605.17892 [cs.AR] https://arxiv.org/abs/2605. 17892

    2026 arXiv

  24. [32]

    Cunxi Yu, Chenhui Deng, Nathaniel Pinckney, and Brucek Khailany. 2026. Agentic Hardware Design as Repository-Level Code Evolution. arXiv:2606.28279 [cs.AR] doi:10.48550/arXiv.2606.28279

    2026 doi arXiv

  25. [33]

    Zhongkai Yu, Chenyang Zhou, Yichen Lin, Hejia Zhang, Haotian Ye, Junxia Cui, Zaifeng Pan, Jishen Zhao, and Yufei Ding. 2026. ChipBench: A Next- Step Benchmark for Evaluating LLM Performance in AI-Aided Chip Design. arXiv:2601.21448 [cs.AI] https://arxiv.org/abs/2601.21448

    2026

  26. [34]

    Yang Zhao, Di Huang, Chongxiao Li, Pengwei Jin, Muxin Song, Yinan Xu, Ziyuan Nan, Mingju Gao, Tianyun Ma, Lei Qi, Yansong Pan, Zhenxing Zhang, Rui Zhang, Xishan Zhang, Zidong Du, Qi Guo, and Xing Hu. 2025. CodeV: Empowering LLMs with HDL Generation through Multi-Level Summariz...

    2025

  27. [120]

    doi:10.3390/electronics14010120

    doi

  28. [2021]

    InProceed- ings of the 54th Annual IEEE/ACM International Symposium on Microarchitecture ASP-DAC 2027, January 25–28, 2027, Tokyo, Japan Cheng et al

    Vortex: Extending the RISC-V ISA for GPGPU and 3D-Graphics. InProceed- ings of the 54th Annual IEEE/ACM International Symposium on Microarchitecture ASP-DAC 2027, January 25–28, 2027, Tokyo, Japan Cheng et al. (MICRO ’21). ACM, 754–766. doi:10.1145/3466752.3480128

    2027

  29. [2023]

    doi:10.1109/ TVLSI.2023.3281078

    An Efficient Scaling-Free Folded Hyperbolic CORDIC Design Using a Novel Low-Complexity Power-of-2 Taylor Series Approximation.IEEE Transactions on Very Large Scale Integration (VLSI) Systems31, 8 (2023), 1167–1177. doi:10.1109/ TVLSI.2023.3281078

    2023

Pith tools

Reviewed August 11, 2026 · model on record in the stance chip above.