Pith. sign in

REVIEW 6 major objections 6 minor 37 references

An audited per-signal intermediate representation lifts LLM-based RTL generation to 94–98% correctness at a quarter of the strongest baseline's token cost.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

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

T0 review · deepseek-v4-flash

2026-08-01 15:08 UTC pith:XCDH7KRJ

load-bearing objection VeriRefine is a genuinely new ASTF-based RTL generation pipeline with impressive functional correctness and token efficiency, but its debug-loop gains rest on an unvalidated LLM failure classifier and no artifacts are released. the 6 major comments →

arxiv 2607.18519 v1 pith:XCDH7KRJ submitted 2026-07-20 cs.AR

A Progressive Approach to Synthesizable RTL Design Generation Using LLMs

Xiangfei Kong , Tasnim Tabassum , Marwan Abdelwahab , Hao Zheng This is my paper
classification cs.AR
keywords ASTFRTL generationLLM agentsspecification refinementintermediate representationfunctional verificationsynthesizabilityVerilog
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

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

VeriRefine argues that the dominant failure mode in LLM-based RTL generation is not coding but comprehension: the model silently commits a misreading of an ambiguous natural-language specification into Verilog, where only simulation can expose it. To make interpretation verifiable, the paper proposes refining the prose specification into an explicit per-signal intermediate representation, the Abstract Signal Transition Function (ASTF), which records each signal's logic style, clock domain, reset behavior, and a priority-ordered list of guarded actions, each grounded in a verbatim specification sentence. A five-layer audit checks soundness, completeness, consistency, FSM integrity, and core RTL design rules before any code is written, and simulation failures are then classified and routed back to either the ASTF or the RTL stage for targeted repair. On RTLLM v2.0 and VerilogEval-Human v2 with Claude Sonnet 4.6, this pipeline reaches 94.0% and 98.1% functional correctness, within two designs of the strongest agentic baseline while spending roughly a quarter of its tokens. A sympathetic reader would care because the result suggests that explicit, auditable intermediate representations — not larger models or more test-time compute — are the lever that closes the specification-to-RTL semantic gap.

Core claim

The paper's central claim is that specification understanding can be separated from code generation and made verifiable, and that doing so is what drives correctness. Concretely, the paper claims that for every driven signal, representing its hardware class (logic style, clock domain, reset behavior) and its behavior as a priority-ordered list of guarded actions — each guarded action carrying a verbatim quotation from the specification — before any Verilog is emitted eliminates a large class of functional and synthesizability errors. It further claims that auditing this representation across five layers and routing simulation failures back to the correct abstraction level recovers most of th

What carries the argument

The Abstract Signal Transition Function (ASTF) is the central mechanism: a schema-constrained, per-signal JSON record that serializes H(s) — the signal's logic style, clock domain, and reset behavior — and G(s), a priority-ordered list of guarded commands, each carrying a verbatim specification citation. It carries the argument by making the model's interpretation explicit and auditable before code exists: the closed schema rejects structural errors mechanically, the five-layer audit rejects semantic errors, and the Implementation Module translates the audited ASTF into Verilog in a rule-governed way. A failure analyzer then classifies each simulation failure as an ASTF issue or an RTL issue

Load-bearing premise

The load-bearing premise is that the debug module's automatic classification of every simulation failure as either an ASTF issue or an RTL issue is accurate enough to route repairs correctly; the paper reports no accuracy or ablation for this classifier (Section 3.5.2), and if it frequently misroutes, the debug-loop gains would not reproduce.

What would settle it

A concrete test: take a random sample of failed designs, have a human expert independently label each failure as ASTF-level or RTL-level, and compare with VeriRefine's failure-analyzer decision; if agreement is near chance, targeted routing, not the representation, explains the debug-loop gains. Alternatively, replace the classifier with random routing and check whether functional correctness drops.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • If the central claim holds, the binding constraint in LLM-based RTL generation is specification comprehension, not model capacity, so further gains will come from better refinement and audit, not just larger models.
  • Because the audited ASTF fixes each signal's hardware class before code, synthesizability is largely decided at the representation stage; the observed 93.8–100% synthesizability band across conditions supports this.
  • The token-efficiency result implies that under a fixed budget, a VeriRefine-style pipeline can attempt roughly four times more designs than the strongest agentic baseline, changing which problems are reachable.
  • The paper's failure analysis locates four of its six remaining unsolved designs in specification–testbench contradictions, meaning the pipeline's ceiling on those benchmarks is set by specification quality, not by the model or the representation.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The refinement stage could be extended to audit the specification itself for contradictions, underdetermined behaviors, and forced assumptions — the paper names this as future work — which would turn the framework from a spec-faithful generator into a spec-improving one.
  • Because every guarded action carries verbatim provenance, the ASTF is a reusable verification artifact: the same structure could drive testbench generation, formal property extraction, or human review, independent of the code-emission step.
  • The failure analyzer's routing decision is itself an LLM judgment with no reported accuracy; a human-labeled routing ablation would determine how much of the debug-loop gain depends on this classification.
  • The per-signal, priority-ordered guarded-action structure resembles a synchronous reactive program, so the ASTF schema may be portable to other HDLs or to formal specifications, not just Verilog.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

6 major / 6 minor

Summary. VeriRefine is an agentic LLM-based RTL generation framework that inserts a schema-constrained intermediate representation, the Abstract Signal Transition Function (ASTF), between a natural-language specification and Verilog generation. The refinement module produces per-signal ASTFs with verbatim spec citations, validates them with a closed JSON schema and a five-layer LLM-based audit, and only then generates RTL. The verification/debug module generates a specification-only internal testbench, simulates the RTL, classifies failures as ASTF issues or RTL issues with an LLM failure analyzer, and routes repairs to the corresponding stage for at most two iterations. The paper reports 94.0% functional correctness on RTLLM v2.0 and 98.1% on VerilogEval-Human v2 with Claude Sonnet 4.6, within two designs of a reproduced VerilogCoder baseline while using roughly a quarter of its token cost. An ablation separates the ASTF-only contribution from the debug-loop contribution, and a failure analysis attributes four of six remaining failures to specification/testbench defects or ambiguity.

Significance. If the reported results reproduce, VeriRefine is a meaningful advance: it demonstrates that making interpretation explicit and auditable before code generation can recover a large share of the functional-correctness gap on standard benchmarks, and it does so at substantially lower token cost than a strong agentic baseline. The use of official RTLLM v2.0 and VerilogEval-Human v2 testbenches for the final metric avoids circularity, and the schema validation and deterministic testbench assembly are concrete, machine-checkable components. The ASTF's per-signal hardware classification is a plausible mechanism for improving both correctness and synthesizability. However, the central causal claims rely on components whose accuracy is not measured — especially the debug-loop failure classifier and the LLM-based ASTF audit — and the absence of code/data release plus single-run evaluation makes the headline numbers difficult to verify. The paper is a solid empirical contribution in need of additional evidence before the stated claims can be accepted at face value.

major comments (6)
  1. [§3.5.2, §4.2, Fig. 7] The debug-loop gains — 12.0 percentage points on RTLLM v2.0 (82.0%→94.0%) and 6.4 points on VerilogEval-Human v2 (91.7%→98.1%) — are credited to a failure analyzer that classifies each simulation failure as an ASTF issue or an RTL issue. The paper reports no accuracy, no manual evaluation, and no ablation of this routing decision. Since repair iterations are capped at two, a systematically misrouting classifier could erase or reverse the reported debug gains. I ask for a human-labeled evaluation of the analyzer's decisions on the failing designs, plus ablations that replace it with an always-ASTF or always-RTL routing policy. Without this, the mechanism behind the headline numbers is untested.
  2. [§4.1, §4.2, Table 4] All experimental results are from single temperature-0 runs with no repeated seeds, and no code, data, prompts, generated ASTFs, or Verilog outputs are released. Given that LLM APIs are not bitwise deterministic in practice, and that the framework's behavior depends on many handwritten prompts and the failure analyzer, the empirical claims need either a reproducibility release or repeated-run variance estimates. At minimum, the exact prompt templates, the ASTF schema, and the simulation harness must be made available for the central numbers to be checkable.
  3. [§4.4] The failure analysis classifies six unsolved designs into benchmark defects, specification ambiguity, and capability limits, and claims that the internal testbench passes two of the official-failing designs. This classification is post hoc and unsupported by released artifacts: no specification quotes, testbench excerpts, or diffs are shown, and an internal testbench passing a design does not prove the official testbench is defective — it may instead indicate that the internal testbench is too weak. Since four of six failures are attributed to external causes, this analysis is load-bearing for the paper's boundary claim and should be substantiated with concrete evidence or softened to a hypothesis.
  4. [§4.1, Table 4] The VerilogCoder comparison rests on a reproduction whose fidelity is not demonstrated. The paper states that the released AutoGen-based implementation ships no Anthropic backend and that a native Anthropic client was written, but provides no verification that the client preserves all agent prompts, message ordering, and tool-calling semantics. Because the headline 'within two designs at a quarter of the token cost' compares against this reproduction, token cost and correctness of the baseline should be validated against the original release (e.g., reproducing the published GPT-4-turbo result with the same client), or the comparison should be labeled as approximate.
  5. [Abstract, §3.2, §4.2, Table 4] The claim that synthesizability becomes 'a structural property of the pipeline' is stronger than the evidence supports. The experiments show that 93.8–100% of functionally correct designs synthesize, but this is a correlational result; there is no controlled comparison isolating the contribution of the ASTF's H(s) fields (logic style, clock domain, reset behavior) from other pipeline effects, and the synthesizability check is only run on designs that already pass functional simulation. The claim should be downgraded to 'the pipeline produces designs that synthesize at a high rate in these benchmarks' unless direct evidence is provided that the ASTF constraints, rather than the model's general competence, are responsible.
  6. [§3.3.3, §3.3.1] The five-layer ASTF audit is itself an LLM-based component, but its precision and recall are never measured. The paper attributes 18.0% (RTLLM v2.0) and 6.4% (VerilogEval-Human v2) first-pass gains to the audited ASTF, yet no manual audit sample, no count of audit findings, and no ablation removing individual audit layers are reported. A systematic audit that rejects valid ASTFs or misses invalid ones would change both the cost and the first-pass success rate. At least a human-evaluated sample of audit decisions, or an ablation without the audit, is needed to support the claim that the audit is what makes the ASTF reliable.
minor comments (6)
  1. [§3.5.1] Typo: 'Testbench Generatioin' should be 'Testbench Generation'. Similarly, 'Verificaton & Debug Module' in §3.5 should be corrected.
  2. [§3.3] Typo: 'sunch errors' should be 'such errors'.
  3. [§3.2] Typo: 'reduceing' should be 'reducing'.
  4. [§4.2, PPA] The PPA comparison between conditions with different design coverage is carefully caveated, but the reader is still left without design-level PPA data. An appendix table listing per-design PPA products for the overlapping design sets would make the 'on par with VerilogCoder' conclusion much easier to verify.
  5. [§4.1, Models] The description of the VerilogCoder reproduction would be clearer if it reported the exact version of the released repository and any environment differences, since AutoGen version changes can alter agent behavior.
  6. [References] Several references are to arXiv preprints with 2026 dates and anonymous authorship. If the manuscript is being revised for archival publication, these should be updated with journal/conference versions or DOIs where available.

Circularity Check

0 steps flagged

No circularity: headline scores are judged by external official testbenches; ASTF is an intermediate representation, not a fitted oracle, and no load-bearing self-citations appear.

full rationale

The derivation chain is not circular. The central functional-correctness claim is measured externally: Section 4.1 defines functional correctness as passing "the benchmark testbench simulation," i.e., the official RTLLM v2.0 and VerilogEval-Human v2 testbenches, so the reported 94.0%/98.1% numbers do not reduce to the framework's own ASTF or internal testbench. The ASTF is generated from the specification and audited, then translated to RTL; no parameter is fitted to the benchmark outcomes, and no equation equates an input artifact to the claimed metric. The reference list contains no works by the present authors, so there is no self-citation chain, load-bearing or otherwise; the cited baselines and prior-work results are external. The claim that synthesizability is a "structural property" is supported empirically by Yosys runs rather than by definition, and the PPA/synthesizability numbers are likewise tool-measured. The paper's own stated limitations—notably that Section 3.5.2 reports no accuracy or ablation for the LLM failure analyzer that routes repairs—are legitimate reproducibility/robustness concerns about the debug-loop contribution, not circular reductions, because the final pass/fail oracle remains the official benchmark testbench. Using the golden reference RTL inside the VerilogEval debug harness could raise oracle-overfitting questions, but that is not a definitional equivalence between an input and the claimed prediction. The ablation separating the ASTF contribution from debug iterations is an honest decomposition, and the failure analysis openly identifies benchmark-defect and specification-ambiguity cases. No quoted step reduces to its own inputs; hence score 0.

Axiom & Free-Parameter Ledger

3 free parameters · 4 axioms · 1 invented entities

The central contribution is an empirical pipeline; no equations are derived, so the free-parameter ledger is light. The main unproven inputs are the reliability of the LLM-based audit/debug components, the fidelity of the VerilogCoder reproduction, and the validity of the official testbenches as ground truth.

free parameters (3)
  • Hand-crafted ASTF schema and prompt ingredients = 15 sub-type patterns; classification order FSM > dual-clock > sequential > combinational
    Section 3.3.1 defines these by hand; ASTF quality and downstream pass rates depend on them, and no sensitivity analysis or learned alternative is provided.
  • Internal testbench scenario lengths = 8-15 directed cycles; 80 stress cycles for combinational, 200 for sequential
    Section 3.5.1 fixes these values by hand; they affect which failures the debug loop can detect and are not swept.
  • Maximum debug iterations = 2
    Section 4.1 caps repair iterations at 2; the reported functional-correctness numbers would change if this cap changed.
axioms (4)
  • domain assumption Official RTLLM v2.0 and VerilogEval-Human v2 testbenches are valid ground truth for functional correctness.
    Section 4.1 defines functional correctness as passing the official benchmark testbench, yet Section 4.4 later classifies some official testbenches as defective; the assumption is applied selectively and is not independently verifiable.
  • domain assumption LLM outputs at temperature 0 are treated as deterministic for the reported single-run results.
    Section 4.1 sets temperature 0 and reports one run per design; API nondeterminism and prompt sampling variance are not measured.
  • ad hoc to paper The five-layer audit and the failure analyzer perform accurately enough to guide repairs.
    Sections 3.3.3 and 3.5.2 rely on LLM prompts for content auditing and failure classification, with no reported precision, recall, or ablation of these components.
  • domain assumption The VerilogCoder reproduction is faithful despite the custom Anthropic client.
    Section 4.1 states only message formats are translated and all prompts/settings are preserved, but no code, logs, or comparison runs are released to verify this.
invented entities (1)
  • ASTF (Abstract Signal Transition Functions) independent evidence
    purpose: Per-signal schema-constrained intermediate representation capturing logic style, clock domain, reset behavior, and priority-ordered guarded actions with verbatim specification provenance.
    The ASTF is a conceptual artifact rather than an unobservable physical entity; its correctness is falsifiable through RTL simulation against external official testbenches, so it does not present the graviton problem.

pith-pipeline@v1.3.0-alltime-deepseek · 18132 in / 10917 out tokens · 117554 ms · 2026-08-01T15:08:13.433077+00:00 · methodology

0 comments
read the original abstract

Large language models can generate register-transfer-level (RTL) designs directly from natural language specifications. Their failures, however, arise mostly from understanding rather than coding \cite{zhang2026understanding, qiu2025towards}. A specification is informal and ambiguous, the model's interpretation stays implicit, and every misreading is committed silently into Verilog, where only simulation can expose it. Intermediate representations make the interpretation partly explicit, yet existing works don't verify the interpretation against the specification, and repair simulation failures at the code level regardless of where the misreading originated. VeriRefine instead treats specification refinement as a verifiable stage of RTL generation. It progressively refines the prose specification into an explicit, schema-constrained account of design intent, expressed as per-signal Abstract Signal Transition Functions (ASTFs) that commit each signal's logic style, clock domain, and reset behavior before any code exists and ground every behavior in a verbatim specification sentence. The refined specification then passes a five-layer audit spanning soundness, completeness, consistency, FSM integrity, and core RTL design rules, so interpretation errors are repaired at the representation level before any Verilog is generated. Once code is generated, each simulation failure is classified as an understanding error or a coding error and routed back to the corresponding stage for targeted repair. Because every signal's hardware class is fixed during refinement, synthesizability becomes a structural property of the pipeline rather than a post-hoc check. With Claude Sonnet 4.6, VeriRefine reaches 94.0\% functional correctness on RTLLM v2.0 and 98.1\% on VerilogEval-Human v2.

Figures

Figures reproduced from arXiv: 2607.18519 by Hao Zheng, Marwan Abdelwahab, Tasnim Tabassum, Xiangfei Kong.

Figure 1
Figure 1. Figure 1: Overview of the VeriRefine framework Functions (Section 3.2), refinement module (Section 3.3), imple￾mentation module (Section 3.4) , and verification & debug module (Section 3.5). 3.1 Overview Framework Architecture VeriRefine organizes RTL generation into three sequential modules coordinated through the ASTF, as illustrated in [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: ASTF traces the pulse_detect FSM from specification (a) through the per-signal records and FSM metadata (b) to the generated RTL (c). Panel (d) simulates the specification’s own example input as evidence. Both direct-generation outputs miss the required end cycle timing and fail, while the RTL generated from the ASTF matches the expected trace and passes on the first attempt. this example input, where both… view at source ↗
Figure 3
Figure 3. Figure 3: Refinement Module catalog of fifteen patterns covering FSMs, counter and boundary be￾havior, stacks, sequential and combinational dividers, floating-point arithmetic, frequency dividers, pipelines, FIFOs, shifters, registers, edge detection, bit-level operations, table-defined combinational logic, and FSMs with timed datapaths. Sub-types are not exclu￾sive, and detecting one can activate a companion patter… view at source ↗
Figure 4
Figure 4. Figure 4: Abridged ASTF emitted by the Refinement Module [PITH_FULL_IMAGE:figures/full_fig_p007_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Prob050 (VerilogEval) example comparing direct [PITH_FULL_IMAGE:figures/full_fig_p008_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Verification & Debug Module and corner-case behavior, one LLM-generated explicit 8–15 cycle sequence, and one pseudo-random stress scenario using 80 cycles for combinational designs or 200 cycles for sequential designs. Second, the plan is converted into a SystemVerilog stimulus module, itb_stimulus, which drives DUT inputs using a synthetic testbench clock, emits optional PROBE messages, marks scenario co… view at source ↗
Figure 7
Figure 7. Figure 7: Functional correctness by repair iteration with Son [PITH_FULL_IMAGE:figures/full_fig_p012_7.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

37 extracted references · 18 linked inside Pith

  1. [1]

    Mohammadreza Akyash, Kimia Azar, and Hadi Kamali. 2025. RTL++: Graph- enhanced LLM for RTL code generation. In 2025 IEEE International Conference on LLM-Aided Design (ICLAD)

    2025

  2. [2]

    Anonymous. 2025. ChipSeek: Optimizing Verilog generation via EDA-integrated reinforcement learning. arXiv preprint arXiv:2507.04736 (2025)

    Pith/arXiv arXiv 2025

  3. [3]

    Anonymous. 2025. ComplexVCoder: An LLM-driven framework for systematic generation of complex Verilog code. arXiv preprint arXiv:2504.20653 (2025)

    Pith/arXiv arXiv 2025

  4. [4]

    Anonymous. 2025. HDLCoRe: A training-free framework for mitigating halluci- nations in LLM-generated HDL. arXiv preprint arXiv:2503.16528 (2025)

    Pith/arXiv arXiv 2025

  5. [5]

    Anonymous. 2025. Lorecast: Layout-aware performance and power forecasting from natural language. arXiv preprint arXiv:2503.11662 (2025)

    Pith/arXiv arXiv 2025

  6. [6]

    Anonymous. 2025. VeriOpt: PPA-aware high-quality Verilog generation via multi-role LLMs. arXiv preprint arXiv:2507.14776 (2025)

    Pith/arXiv arXiv 2025

  7. [7]

    Anonymous. 2026. EvolVE: Evolutionary search for LLM-based Verilog genera- tion and optimization. arXiv preprint arXiv:2601.18067 (2026)

    arXiv 2026

  8. [8]

    Anonymous. 2026. VeriGraphi: A multi-agent framework of hierarchical RTL generation for large hardware designs. arXiv preprint arXiv:2604.14550 (2026)

    Pith/arXiv arXiv 2026

  9. [9]

    Prithwish Basu Roy et al. 2025. Veritas: Deterministic Verilog code synthesis from LLM-generated conjunctive normal form. arXiv preprint arXiv:2506.00005 (2025)

    Pith/arXiv arXiv 2025

  10. [10]

    Matthew DeLorenzo, Kevin Tieu, Prithwish Jana, Piyush Jha, Dileep Kalathil, Vijay Ganesh, and Jeyavijayan Rajendran. 2025. Abstractions-of-Thought: Inter- mediate Representations for LLM Reasoning in Hardware Design. arXiv preprint arXiv:2505.15873 (2025)

    Pith/arXiv arXiv 2025

  11. [11]

    Chenhui Deng, Yun-Da Tsai, Guan-Ting Liu, Zhongming Yu, and Haoxing Ren

  12. [12]

    Wei Fu et al. 2026. From natural language to silicon: The representation bottle- neck in LLM hardware design. arXiv preprint arXiv:2604.17097 (2026)

    Pith/arXiv arXiv 2026

  13. [13]

    Chia-Tung Ho, Haoxing Ren, and Brucek Khailany. 2025. Verilogcoder: Au- tonomous verilog coding agents with graph-based planning and abstract syntax tree (ast)-based waveform tracing tool. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 39. 300–307

    2025

  14. [14]

    Ruixin Hong, Hongming Zhang, Xinyu Pan, Dong Yu, and Changshui Zhang

  15. [15]

    Ziteng Hu, Yiwen Xia, Xiang Chen, and Liang Kuang. 2025. SecFSM: Knowledge graph-guided Verilog code generation for secure finite state machines in SoC. arXiv preprint arXiv:2508.12910 (2025)

    Pith/arXiv arXiv 2025

  16. [16]

    Lei Huang et al . 2026. QiMeng-CRUX: Narrowing the gap between natural language and Verilog via core refined understanding expression for circuit design. arXiv preprint arXiv:2511.20099 (2026)

    arXiv 2026

  17. [17]

    Zahin Ibnat, Paul E Calzada, Rasin Mohammad Ihtemam, Sujan Kumar Saha, Jingbo Zhou, Farimah Farahmandi, and Mark Tehranipoor. 2025. DeepV: A model-agnostic retrieval-augmented framework for Verilog code generation with a high-quality knowledge base. arXiv preprint arXiv:2510.05327 (2025)

    arXiv 2025

  18. [18]

    Mingjie Liu, Nathaniel Pinckney, Brucek Khailany, and Haoxing Ren. 2023. Ver- ilogeval: Evaluating large language models for verilog code generation. In 2023 A Progressive Approach to Synthesizable RTL Design Generation Using LLMs IEEE/ACM International Conference on Computer Aided Design (ICCAD) . IEEE, 1–8

    2023

  19. [19]

    Mingjie Liu, Yun-Da Tsai, Wenfei Zhou, and Haoxing Ren. 2025. CraftRTL: High-quality synthetic data generation for Verilog code models with correct- by-construction non-textual representations and targeted code repair. arXiv preprint arXiv:2409.12993 (2025)

    Pith/arXiv arXiv 2025

  20. [20]

    Shang Liu, Wenji Fang, Yao Lu, Qijun Zhang, Hongce Zhang, and Zhiyao Xie

  21. [21]

    Qing Luo et al. 2025. AutoFSM: A multi-agent framework for FSM code genera- tion with intermediate representation and SystemC-based testing. arXiv preprint arXiv:2512.11398 (2025)

    arXiv 2025

  22. [22]

    Haoyuan Ping et al. 2025. VERIMOA: A mixture-of-agents framework for spec- to-HDL generation. arXiv preprint arXiv:2510.27617 (2025)

    Pith/arXiv arXiv 2025

  23. [23]

    In2024 IEEE LLM Aided Design Workshop (LAD)

    Rtlcoder: Outperforming gpt-3.5 in design rtl generation with our open- source dataset and lightweight solution. In2024 IEEE LLM Aided Design Workshop (LAD). IEEE, 1–5

  24. [24]

    Wenhao Sun, Bohan Li, Grace Li Zhang, Xunzhao Yin, Cheng Zhuo, and Ulf Schlichtmann. 2025. Paradigm-based automatic HDL code generation using large language models. arXiv preprint arXiv:2501.12702 (2025)

    Pith/arXiv arXiv 2025

  25. [25]

    Fu Teng et al. 2025. VeriRL: Boosting LLM-based Verilog code generation via reinforcement learning. arXiv preprint arXiv:2508.18462 (2025)

    Pith/arXiv arXiv 2025

  26. [26]

    Siyu Qiu, Muzhi Wang, Raheel Afsharmazayejani, Mohammad Moradi Shahmiri, Benjamin Tan, and Hammond Pearce. 2025. Towards LLM-based Root Cause Analysis of Hardware Design Failures. In 2025 IEEE International Conference on Omni-layer Intelligent Systems (COINS) . IEEE, 1–6

    2025

  27. [27]

    Ning Wang, Bingkun Yao, Jie Zhou, Yuchen Hu, Xi Wang, Nan Guan, and Zhe Jiang. 2025. Insights from verification: Training a Verilog generation LLM with reinforcement learning with testbench feedback. arXiv preprint arXiv:2504.15804 (2025)

    Pith/arXiv arXiv 2025

  28. [28]

    Nan Wang, Bingkun Yao, Jie Zhou, Yuchen Hu, Xi Wang, Nan Guan, and Zhe Jiang. 2025. VeriReason: Reinforcement learning with testbench feedback for reasoning-enhanced Verilog generation. arXiv preprint arXiv:2505.11849 (2025)

    Pith/arXiv arXiv 2025

  29. [29]

    Shailja Thakur, Baleegh Ahmad, Hammond Pearce, Benjamin Tan, Brendan Dolan-Gavitt, Ramesh Karri, and Siddharth Garg. 2024. Verigen: A large language model for verilog code generation. ACM Transactions on Design Automation of Electronic Systems 29, 3 (2024), 1–31

    2024

  30. [30]

    Zhongkai Yu, Mingjie Liu, Max Zimmer, Yi-Chun Lin, Yang Liu, and Haoxing Ren. 2025. Spec2RTL-Agent: Automated hardware code generation from complex specifications using LLM agent systems. In 2025 IEEE International Conference on LLM-Aided Design (ICLAD)

    2025

  31. [31]

    Patrick Yubeaton, Andre Nakkab, Wenjie Xiao, Luca Collini, Ramesh Karri, Chin- may Hegde, and Siddharth Garg. 2025. VeriThoughts: Enabling automated Verilog code generation using reasoning and formal verification. arXiv preprint arXiv:2505.20302 (2025)

    arXiv 2025

  32. [32]

    Yuhao Wu et al. 2026. LLM-FSM: Scaling large language models for finite-state reasoning in RTL code generation. arXiv preprint arXiv:2602.07032 (2026)

    arXiv 2026

  33. [33]

    Yang Zhao, Di Huang, Chongxiao Li, Pengwei Jin, Ziyuan Nan, Tianyun Ma, Lei Qi, Yansong Pan, Zhenxing Zhang, Rui Zhang, et al. 2025. CodeV: Empow- ering LLMs for Verilog generation through multi-level summarization. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems (2025)

    2025

  34. [34]

    Yujie Zhao, Hejia Zhang, Hanxian Huang, Zhongming Yu, and Jishen Zhao. 2025. Mage: A multi-agent engine for automated rtl code generation. In 2025 62nd ACM/IEEE Design Automation Conference (DAC). IEEE, 1–7

    2025

  35. [35]

    Jiazheng Zhang, Cheng Liu, Long Cheng, Xiaowei Li, and Huawei Li. 2026. Understanding and mitigating errors of llm-generated rtl code.IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems (2026)

    2026

  36. [2024]

    arXiv preprint arXiv:2406.12442 (2024)

    Abstraction-of-Thought makes language models better reasoners. arXiv preprint arXiv:2406.12442 (2024)

    Pith/arXiv arXiv 2024

  37. [2025]

    arXiv preprint arXiv:2506.05566 (2025)

    ScaleRTL: Scaling LLMs with reasoning data and test-time compute for accurate RTL code generation. arXiv preprint arXiv:2506.05566 (2025)

    Pith/arXiv arXiv 2025