Pith. sign in

REVIEW 3 major objections 4 minor 40 references

LACE: Large Language Model Aided Multi-Agent Framework for Agile RISC-V Instruction Extension

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

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

Pith's one-line read LACE claims that a team of LLM agents, guided by a two-level instruction IR and a graph-based RAG retriever, can turn a natural-language RISC-V instruction extension into localized RTL edits that pass formal verification, reaching an…

desk verdict The 72.8% pass@1 is an end-to-end pipeline number, not a clean test of the IR/RAG design — but the integrated workflow is real and deserves peer review. read the letter →

arxiv 2608.02915 v1 pith:2424T6HN submitted 2026-08-03 cs.AR cs.CLcs.SE

Pingqing Zheng , Jiayin Qin , Fuqi Zhang , Zishen Wan , Shang Wu , Yu Cao , Caiwen Ding , Yang Katie Zhao This is my paper · ORCID
classification cs.ARcs.CLcs.SE
keywords RISC-Vinstructionsetextensionlargelanguagemodelsmulti-agentsystemsRTLgenerationformalverificationretrieval-augmentedriscv-formal
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

LACE is a multi-agent workflow that claims to automate the slowest part of adding custom RISC-V instructions to an existing processor: turning a natural-language description of the new instruction into correct, localized edits of the processor's Register-Transfer Level (RTL) hardware code, and then proving the edit is right. The paper reports that across four embedded open-source cores and five instruction extensions, the workflow achieves an average 72.8% pass@1 rate, where a run counts as successful only if the modified core compiles with Verilator and passes riscv-formal checks for both the original instructions and the new one, while direct LLM generation succeeds only on the simplest case. The reason this matters is that ISA extensions are currently adapted per core by hand, so an automated, verification-closed pipeline could let workload experts propose instructions in plain language and get working hardware implementations across the RISC-V ecosystem.

What carries the argument

The load-bearing mechanism is the two-level IR paired with an agentic retrieval-and-edit loop. Level one, operation-level IR, expresses an instruction's semantics with predefined interface operators (read instruction, read or write register, read or write PC, read or write memory, write rd) and arithmetic operators; this keeps the specification reusable across cores. Level two, HDL task-level IR, turns those operations into repository-specific edit instructions, guided by meta-prompts that encode common integration patterns and by architecture hints such as whether the pipeline needs flushing. The agentic RAG subsystem indexes modules and always-blocks as graph nodes with hierarchy and dataflow edges, so a supervisor can dispatch searches that return file paths and line ranges for precise edits. Verification closes the loop: riscv-formal with RVFI-based assertions replaces differential testing, and stepwise checking of baseline then extended behavior lets the feedback agent catch regressions before they propagate.

What would settle it

Run the published workflow on an open-source core that has no RVFI support and do not add any instrumentation; if riscv-formal cannot check the new instruction without that manual effort, the end-to-end automation claim fails. Alternatively, rerun the four-core, five-instruction evaluation with nine runs per cell under the stated Verilator-plus-riscv-formal criterion and check whether the average pass@1 reproduces 72.8%.

Watch

Extended reading notes

Core claim

The paper's central claim is that the abstraction gap between an ISA specification and HDL implementation can be bridged by a two-level intermediate representation plus retrieval-guided editing and formal-verification feedback. LACE first translates the natural-language ISAX intent into operation-level IR, small reusable operators such as reading a register, accessing the PC, or writing back to rd, which are microarchitecture-agnostic. A second translation maps these operations into concrete HDL modification tasks using core-specific hints about pipeline depth and control paths, so the same intent can be realized in very different cores. The agents locate the relevant code through an agentic graph-based retrieval system, edit the RTL, lint with Verilator, and then run riscv-formal in two stages: first on the unmodified baseline core, then on the core with the new instruction. With this loop, LACE reports an average pass@1 of 72.8% across PicoRV32, e203 hbirdv2, ibex, and cv32e40x, versus near-zero for non-agentic generation, and comparable area and frequency overhead to an expert-designed extension framework.

Load-bearing premise

The flow's end-to-end automation assumes the target core already exposes per-instruction execution traces (RVFI) or that someone will manually add those hooks, because the formal verification that defines success cannot run without them; the paper states this assumption explicitly.

Editorial extensions

If this is right

  • A natural-language instruction description can be reused across heterogeneous cores: the operator-level IR stays the same while the HDL task translation adapts to pipeline depth and control style.
  • Formal, compiler-agnostic verification means LACE does not need a custom compiler front-end or a trusted golden model for each new instruction, removing two bottlenecks of differential testing.
  • The stepwise baseline-then-extension check turns the integration process into an iterative loop where early errors are caught before they accumulate, which the paper shows reduces verification hops for complex extensions like load mul.
  • Because area and frequency overheads stay within about 10% for most instructions and match an expert framework on PicoRV32, the automated route is not obviously paying a large hardware cost for automation.
  • The harder cases are memory-coupled and long-latency instructions (sincos and load mul), where pass@1 drops to 44-67%, indicating that multi-cycle control and cross-module coordination remain the frontier.

Reading between the lines

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

  • If the operator-level IR is as reusable as the paper suggests, it could serve as a portable front-end for ISAX proposals: one natural-language spec could feed standardization discussions and generate implementations across many cores at once, which the paper itself only gestures at.
  • The RVFI precondition means the reported automation is not end-to-end for cores without per-instruction trace hooks; a natural test is whether the same loop can be closed by automatically synthesizing RVFI instrumentation, which the paper lists as future work.
  • The same agentic RAG plus formal-checking loop could generalize beyond ISAX to other repository-scale RTL modifications, such as adding security hardening, changing memory interface timing, or migrating a core to new technology-specific primitives, though the paper only evaluates instruction extension.
  • A concrete extension would be to benchmark against human expert effort measured in wall-clock hours, not just pass rates and PPA, since the paper's value proposition is reduced manual labor but it does not directly measure that labor.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

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 manuscript presents LACE, a multi-agent LLM framework that takes natural-language RISC-V ISA extension (ISAX) descriptions, translates them into a two-level IR (operation-level and HDL task-level), performs retrieval-augmented code localization and modification on large processor repositories, and closes the loop with riscv-formal verification (assuming RVFI availability). The authors evaluate LACE on four open-source RISC-V cores (PicoRV32, e203 hbirdv2, ibex, cv32e40x) and five ISAX instructions, reporting an average pass@1 of 72.8% versus essentially zero for direct non-agentic LLM generation, together with ASIC synthesis overheads and RAG search quality metrics. The central claims are that LACE makes ISAX integration across cores significantly more automated, reliable, and efficient.

Significance. If the results hold under a fair comparison, LACE would be a valuable contribution to the emerging area of LLM-assisted hardware design, combining instruction abstraction, agentic repository navigation, and formal verification in a way that goes beyond isolated RTL generation. The paper is honest about the RVFI dependency, makes its code and evaluation setup publicly available, and provides a concrete benchmark across multiple cores and instruction types. However, the quantitative headline depends heavily on the pass@1 comparison being apples-to-apples, and on the RAG benchmark being constructed independently of the system's own design artifacts; these issues are addressable with additional experiments but are load-bearing for the stated conclusions.

major comments (3)
  1. [§VI.A and §VI.B] The pass@1 metric for LACE counts a complete agentic run that includes iterative syntax and functional checks and the Agent⑥ feedback loop (Figure 2), whereas the 'direct (non-agentic) LLM generation' baseline is described only as using 'identical target files, ISAX descriptions, 2-shot examples, and model settings,' with no mention of any repair loop. If the baseline is a single generation without feedback, the 72.8% versus near-zero gap conflates the contribution of iterative repair with that of the two-level IR and agentic RAG. To support the attribution, the authors should report the distribution of LLM calls per successful run and add a control where the non-agentic generator is also allowed to iterate against Verilator/riscv-formal failures, or explicitly justify why such a control is infeasible.
  2. [§VI.C] The RAG benchmark is constructed by 'collecting the given meta-prompts and their corresponding code segments to be modified' (50 tests). Because the meta-prompts are the authors' own design artifacts and the queries are exactly the ones LACE was built around, this evaluation partly rewards LACE's own choices and does not demonstrate superiority for unseen natural-language queries. The MRR comparison in Figure 5 should be repeated on a held-out set of ISAX descriptions or on code segments from a core not used in prompting, or the authors should discuss the inherent circularity.
  3. [§V.A and §VII] The end-to-end claim of a 'working integration and verification flow' is conditional on the stated assumption that RVFI is 'either already available or can be added with engineering effort,' with fully automatic RVFI insertion outside scope. Since riscv-formal requires RVFI, the 72.8% pass@1 results implicitly include whatever manual RVFI instrumentation was performed for the four cores. The paper should quantify or at least characterize this manual effort (e.g., person-hours or lines of instrumentation per core) so that the level of automation claimed is not overstated.
minor comments (4)
  1. [§VI.B] The average direct-baseline pass@1 is exactly 2.2% (Table III) rather than 'near-zero'; the text should state the exact number or use a precise qualifier such as 'low single digits.'
  2. [§VI.A and Abstract] The term 'pass@1' is used in a nonstandard way: it measures the fraction of nine independent multi-step agent trajectories that converge, not the probability that a single generated solution is correct. Although the definition is clear in Section VI.A, the abstract's 'pass@1 generation accuracy' may mislead readers; consider renaming it to 'run success rate' or explicitly contrasting it with one-shot pass@1.
  3. [Table III] The value for ibex sbox is shown as 88.8% while the corresponding percentage for other cores is 88.9%; please make the rounding consistent.
  4. [Figure 6] The y-axis label 'Hops Count' should be defined in the caption or text; it appears to mean the number of verification-and-repair iterations, but this is never stated explicitly.

Circularity Check

1 steps flagged · score 3.0 of 10

RAG evaluation benchmark is constructed from LACE's own meta-prompts, making that sub-claim partially self-referential; the central pass@1 comparison is not circular.

  1. self definitional [Section VI-C, 'Search Ability with Agentic RAG']
    "To comprehensively evaluate its improvement in search capability on such codes, we construct a benchmark of 50 tests by collecting the given meta-prompts and their corresponding code segments to be modified."

    The 'given meta-prompts' are the same expert-designed templates that LACE itself uses to guide Agent 2 and Agent 5 during HDL modification (Section III-C). The 50 retrieval queries are therefore not an independent sample of HDL-localization tasks; they are the system's own prompt templates paired with the code segments those templates were written to locate and edit. High MRR on this benchmark measures the system's ability to re-identify its own design artifacts, so the comparison against BM25 and CodeT5+ embeddings does not test a generalizable prediction from first principles. It partially rewards LACE's own prompt-construction choices by construction, making the search-capability evaluation self-referential rather than an external validation.

full rationale

The core pass@1 result in Table III is an empirical comparison between LACE's full agentic pipeline and direct non-agentic GPT-4o generation under matched files, ISAX descriptions, 2-shot examples, and model settings. That comparison is not circular: success is defined by an external criterion (Verilator compilation plus riscv-formal checks of the baseline core and the added instruction), and the direct baseline is a meaningful control for one-shot generation. The paper's nonstandard use of 'pass@1' — counting a complete multi-repair LACE run as one trial — is a measurement and attribution concern rather than circularity, because the repair loop is part of the tested system and the pass criterion is externally checkable. The reuse of the authors' graph-RAG framework [31] as the navigation backend is a self-citation, but the paper describes its components and evaluates retrieval empirically, so this citation is not load-bearing in a circular way. The one genuinely self-referential element is Section VI-C: the 50-query RAG benchmark is built from LACE's own meta-prompts and their corresponding target code segments, so the reported MRR improvement partly rewards the authors' design choices and cannot independently validate the navigation claim. This modest circularity in a secondary evaluation does not undermine the main pass@1 comparison, which remains an independent, falsifiable benchmark against non-agentic generation.

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

The framework introduces no new physical entities. The main free parameter is the LLM sampling temperature, and the dominant axiom is RVFI availability, which gates the formal verification step that defines success. The hand-authored meta-prompts and two-shot examples also shape results, but they are not represented as numeric parameters.

free parameters (1)
  • GPT-4o sampling temperature = 0.8
    Set for all runs and not swept; the reported pass@1 and variance could depend on this choice.
assumptions (3)
  • domain assumption RVFI is already available or can be added with engineering effort.
    Stated in Section V.A. riscv-formal verification, which defines success in the evaluation, depends on RVFI; the framework does not automate RVFI insertion.
  • domain assumption The graph-based HDL RAG backend, Ref. [31], is functional and generalizes to the evaluated cores.
    LACE reuses HDLxGraph as the code-navigation backend; the paper provides no independent validation of that component beyond the custom 50-query benchmark.
  • domain assumption The four selected cores and five ISAXes are representative of the RISC-V ecosystem.
    The paper claims cross-core generality but evaluates only small embedded cores; no out-of-order or deeply pipelined cores are tested.

how reviews work

0 comments
Cite this review

Pith. "Pith review of LACE: Large Language Model Aided Multi-Agent Framework for Agile RISC-V Instruction Extension." pith.science (2026). https://pith.science/paper/2424T6HN

@misc{pith2026260802915,
  author       = {Pith},
  title        = {Pith review of: LACE: Large Language Model Aided Multi-Agent Framework for Agile RISC-V Instruction Extension},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/2424T6HN}},
  note         = {Machine review of arXiv:2608.02915}
}
read the original abstract

Domain-specific Instruction Set Architecture eXtensions (ISAX) are widely adopted in the RISC-V ecosystem to accelerate emerging workloads, but implementing and validating ISAXes across different cores remains slow and fragmented. Existing frameworks still require per-core interface adaptation, and differential testing often breaks once either the microarchitecture or the ISAX changes. We present LACE, an LLM-aided multi-agent workflow that translates natural-language ISAX intents into a compact two-level IR (operation-level and HDL task-level), performs retrieval-guided localized RTL edits over large repositories, and closes the loop with a compiler-agnostic riscv-formal checking flow (assuming RVFI availability or instrumentation). Across four embedded RISC-V cores, LACE raises pass@1 generation accuracy from near-zero to 72.8\% within our evaluation setup, while improving code localization and reducing integration rework. The code of LACE is available at https://github.com/UMN-ZhaoLab/LACE.

Figures

Figures reproduced from arXiv: 2608.02915 by the authors.

Figure 1
Figure 1. (a) An illustration of the conventional manual process for ISAX. (b) Comparison of our proposed LACE with baseline works: one using a custom interface for updating RTL code [4] and another using a customized architecture description language (CoreDSL) for template-based RTL updates [5]. Recent advances in Large Language Models (LLMs) have demonstrated the ability to generate Hardware Description Language (HDL) code … view at source ↗
Figure 2
Figure 2. The overall LACE workflow with specification translation, agentic RAG system and riscv-formal [24] based verification. TABLE I: Predefined Interface Operators of ISAX Tasks. Operations Descriptions RdInstr() Read the instruction RdRS1/2 Read register value based on rs1/2 CreateCustReg(num) Create custom register file with ‘num‘ entries Rd/WrCustReg Read or write value from custom register Rd/WrPC Read or write curre… view at source ↗
Figure 3
Figure 3. illustrates an example of this workflow using a bit￾rotation instruction, among which the first two agents address Your task is to decompose the bitwise rotation instruction extension into a set of predefined operations Encoding - opcode [6:0] = 0110011 - rd [11:7] - funct3 [14:12] = 001 ......... Function description rol: This instruction performs a rotate left of rs1 register ....... insn = RdInstr() ...... rd_add… view at source ↗
Figures from the paper (3 more)
Figure 4
Figure 4. Figure 4: The supervisor coordinates specialized search agents to decompose, parallelize, and refine localization tasks. Query Hierarchy Searcher DFG Searcher General Searcher File Manager Search Supervisor Response Hierarchy DFG Neo4j CLI Tools GetBlock GetSignal GetCode GetFil…
Figure 5
Figure 5. Figure 5: Search Ability analysis with agentic RAG. B. ISAX Generation with LACE Accuracy improvement. We compare the pass@1 accu￾racy of ISAX generation between LACE and direct (non￾agentic) LLM generation using identical target files, ISAX descriptions, 2-shot examples, and mo…
Figure 6
Figure 6. Figure 6: Convergence efficiency with multi-hop verification with (a) 5 ISAXs on e203 hbird and (b) load mul on 4 host cores. comparable to an expert-designed ISAX integration frame￾work. Together, these results validate LACE as a reliable and efficient approach to cross-core IS…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

40 extracted references · 24 canonical work pages

  1. [31]

    Hdlxgraph: Bridging large language models and graph- based hdl representation,

    M. Zhenget al., “Hdlxgraph: Bridging large language models and graph- based hdl representation,”arXiv preprint, 2025

    work page 2025

  2. [1]

    Automating application-driven customization of asips: A survey,

    E. Hussein, B. Waschneck, and C. Mayr, “Automating application-driven customization of asips: A survey,”Journal of Systems Architecture, vol. 148, p. 103080, 2024

    work page 2024

  3. [2]

    Instruction set definition and instruction selection for asips,

    J. Van Praet, G. Goossens, D. Lanneer, and H. De Man, “Instruction set definition and instruction selection for asips,” inProceedings of 7th International Symposium on High-Level Synthesis, 1994, pp. 11–16

    work page 1994

  4. [3]

    Openasip 2.0: Co-design toolset for risc-v application-specific instruction-set processors,

    K. Hepola, J. Multanen, and P. J ¨a¨askel¨ainen, “Openasip 2.0: Co-design toolset for risc-v application-specific instruction-set processors,” in2022 IEEE 33rd International Conference on Application-specific Systems, Architectures and Processors (ASAP). IEEE, 2022, pp. 161–165

    work page 2022

  5. [4]

    Scaie-v: an open- source scalable interface for isa extensions for risc-v processors,

    M. Damian, J. Oppermann, C. Spang, and A. Koch, “Scaie-v: an open- source scalable interface for isa extensions for risc-v processors,” in Proceedings of the 59th ACM/IEEE Design Automation Conference, 2022, pp. 169–174

    work page 2022

  6. [5]

    Longnail: High-level synthesis of portable custom instruction set extensions for risc-v processors from descriptions in the open-source coredsl language,

    J. Oppermann, B. M. Damian-Kosterhon, F. Meisel, T. M ¨urmann, E. Jentzsch, and A. Koch, “Longnail: High-level synthesis of portable custom instruction set extensions for risc-v processors from descriptions in the open-source coredsl language,” inProceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Op...

    work page 2024

  7. [6]

    React: Synergizing reasoning and acting in language models,

    S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y . Cao, “React: Synergizing reasoning and acting in language models,” in International Conference on Learning Representations (ICLR), 2023

    2023

  8. [7]

    Codal: Codasip architectural language,

    Codasip Ltd., “Codal: Codasip architectural language,” https://codasip. com/glossary/codal/, 2023

    work page 2023

Show all 40 references
  1. [8]

    Andes Custom Extension™ (ACE) Enables Customers to Add Application-Specific Instructions to AndesCore™ Processors,

    Andes Technology Corporation, “Andes Custom Extension™ (ACE) Enables Customers to Add Application-Specific Instructions to AndesCore™ Processors,” https://www.andestech. com/wp-content/uploads/Andes-Custom-Extension%E2%84% A2-ACE-Enables-Customers-to-Add-Application-Specific-I...

    2015

  2. [9]

    E203 risc-v processor: External accel- erator interface (eai) specification,

    RIOS Laboratory, ICT, CAS, “E203 risc-v processor: External accel- erator interface (eai) specification,” https://github.com/riscv-mcu/e203 hbirdv2, RIOS Lab, ICT, CAS, Technical Report, 2018

    2018

  3. [10]

    Core-V eXtension Interface (XIF),

    OpenHW Group, “Core-V eXtension Interface (XIF),” https://github. com/openhwgroup/core-v-xif, 2023

    2023

  4. [11]

    An introduction to the rocket custom coprocessor interface,

    C. Yarp, “An introduction to the rocket custom coprocessor interface,” http://www-inst.eecs.berkeley.edu/∼cs250/sp16/disc/Disc02.pdf, 2019

    2019

  5. [12]

    Quentin: an ultra-low-power pulpissimo soc in 22nm fdx,

    P. D. Schiavone, D. Rossi, A. Pullini, A. Di Mauro, F. Conti, and L. Benini, “Quentin: an ultra-low-power pulpissimo soc in 22nm fdx,” in 2018 IEEE SOI-3D-Subthreshold Microelectronics Technology Unified Conference (S3S). IEEE, 2018, pp. 1–3

    2018

  6. [13]

    Chip-chat: Chal- lenges and opportunities in conversational hardware design,

    J. Blocklove, S. Garg, R. Karri, and H. Pearce, “Chip-chat: Chal- lenges and opportunities in conversational hardware design,” in2023 ACM/IEEE 5th Workshop on Machine Learning for CAD (MLCAD). IEEE, 2023, pp. 1–6

    2023

  7. [14]

    Chipgpt: How far are we from natural language hardware design,

    K. Chang, Y . Wang, H. Ren, M. Wang, S. Liang, Y . Han, H. Li, and X. Li, “Chipgpt: How far are we from natural language hardware design,”arXiv preprint arXiv:2305.14019, 2023

    2023

  8. [15]

    Rtllm: An open-source benchmark for design rtl generation with large language model,

    Y . Lu, S. Liu, Q. Zhang, and Z. Xie, “Rtllm: An open-source benchmark for design rtl generation with large language model,” in2024 29th Asia and South Pacific Design Automation Conference (ASP-DAC). IEEE, 2024, pp. 722–727

    2024

  9. [16]

    Au- tochip: Automating hdl generation using llm feedback,

    S. Thakur, J. Blocklove, H. Pearce, B. Tan, S. Garg, and R. Karri, “Au- tochip: Automating hdl generation using llm feedback,”arXiv preprint arXiv:2311.04887, 2023

    2023 arXiv

  10. [17]

    Betterv: Con- trolled verilog generation with discriminative guidance,

    Z. Pei, H.-L. Zhen, M. Yuan, Y . Huang, and B. Yu, “Betterv: Con- trolled verilog generation with discriminative guidance,”arXiv preprint arXiv:2402.03375, 2024

    2024 arXiv

  11. [18]

    Starcoder: may the source be with you!

    R. Li, L. B. Allal, Y . Zi, N. Muennighoff, D. Kocetkov, C. Mou, M. Marone, C. Akiki, J. Li, J. Chimet al., “Starcoder: may the source be with you!”arXiv preprint arXiv:2305.06161, 2023

    2023 arXiv

  12. [19]

    Agon: Automated design framework for customiz- ing processors from isa documents,

    C. Li, D. Huang, P. Jin, T. Ma, H. Han, S. Cheng, Y . Hao, Y . Zhao, G. Xu, Z. Duet al., “Agon: Automated design framework for customiz- ing processors from isa documents,”arXiv preprint arXiv:2412.20954, 2024

    2024 arXiv

  13. [20]

    Lost in the middle: How language models use long contexts,

    N. F. Liu, K. Lin, J. Hewitt, A. Paranjape, M. Bevilacqua, F. Petroni, and P. Liang, “Lost in the middle: How language models use long contexts,” 2023. [Online]. Available: https://arxiv.org/abs/2307.03172

    2023 arXiv

  14. [21]

    Qwen3 technical report,

    A. Yang, A. Li, B. Yang, B. Zhang, B. Hui, B. Zheng, B. Yu, C. Gao, C. Huang, C. Lvet al., “Qwen3 technical report,”arXiv preprint arXiv:2505.09388, 2025

    2025 arXiv

  15. [22]

    Near-threshold risc- v core with dsp extensions for scalable iot endpoint devices,

    M. Gautschi, P. D. Schiavone, A. Traber, I. Loi, A. Pullini, D. Rossi, E. Flamand, F. K. G ¨urkaynak, and L. Benini, “Near-threshold risc- v core with dsp extensions for scalable iot endpoint devices,”IEEE Transactions on Very Large Scale Integration (VLSI) Systems, vol. 25, n...

    2017

  16. [23]

    Rtlfixer: Automatically fixing rtl syntax errors with large language model,

    Y . Tsai, M. Liu, and H. Ren, “Rtlfixer: Automatically fixing rtl syntax errors with large language model,” inProceedings of the 61st ACM/IEEE Design Automation Conference, 2024, pp. 1–6

    2024

  17. [24]

    riscv-formal,

    YosysHQ, “riscv-formal,” 2016. [Online]. Available: https://github.com/ YosysHQ/riscv-formal

    2016

  18. [25]

    Llm compiler: Foundation language models for compiler optimization,

    C. Cummins, V . Seeker, D. Grubisic, B. Roziere, J. Gehring, G. Syn- naeve, and H. Leather, “Llm compiler: Foundation language models for compiler optimization,” inProceedings of the 34th ACM SIGPLAN International Conference on Compiler Construction, 2025, pp. 141–153

    2025

  19. [26]

    Qimeng-gemm: Automatically generating high-performance matrix multiplication code by exploiting large language models,

    Q. Zhou, Y . Wen, R. Chen, K. Gao, W. Xiong, L. Li, Q. Guo, Y . Wu, and Y . Chen, “Qimeng-gemm: Automatically generating high-performance matrix multiplication code by exploiting large language models,” in Proceedings of the AAAI Conference on Artificial Intelligence, vol. 39,...

    2025

  20. [27]

    Llm-driven cross-platform code generation for polyhe- dral optimized npdp codes,

    M. Palkowski, “Llm-driven cross-platform code generation for polyhe- dral optimized npdp codes,” inParallel Processing and Applied Mathe- matics, R. Wyrzykowski, J. Dongarra, E. Deelman, and K. Karczewski, Eds. Cham: Springer Nature Switzerland, 2025, pp. 162–175

    2025

  21. [28]

    Llm-aided compilation for tensor accelerators,

    C. Hong, S. Bhatia, A. Haan, S. K. Dong, D. Nikiforov, A. Cheung, and Y . S. Shao, “Llm-aided compilation for tensor accelerators,” 2024. [Online]. Available: https://arxiv.org/abs/2408.03408

    2024 arXiv

  22. [29]

    Verilator,

    W. Snyder, P. Wasson, D. Galbiet al., “Verilator,” https://github.com/ verilator/verilator, accessed: 2026-03-16

    2026

  23. [30]

    LangChain,

    H. Chase, “LangChain,” Oct. 2022. [Online]. Available: https: //github.com/langchain-ai/langchain

    2022

  24. [32]

    Moatless Tools,

    A. ¨Orwall, “Moatless Tools,” https://github.com/aorwall/moatless-tools, Jun. 2024

    2024

  25. [33]

    Openhands: An open platform for AI software developers as generalist agents,

    X. Wang, B. Li, Y . Song, F. F. Xu, X. Tang, M. Zhuge, J. Pan, Y . Song, B. Li, J. Singh, H. H. Tran, F. Li, R. Ma, M. Zheng, B. Qian, Y . Shao, N. Muennighoff, Y . Zhang, B. Hui, J. Lin, R. Brennan, H. Peng, H. Ji, and G. Neubig, “Openhands: An open platform for AI software d...

    2025

  26. [34]

    Towards Developing High Performance RISC-V Processors Using Agile Methodology,

    Y . Xu, Z. Yu, D. Tang, G. Chen, L. Chen, L. Gou, Y . Jin, Q. Li, X. Li, Z. Li, J. Lin, T. Liu, Z. Liu, J. Tan, H. Wang, H. Wang, K. Wang, C. Zhang, F. Zhang, L. Zhang, Z. Zhang, Y . Zhao, Y . Zhou, Y . Zhou, J. Zou, Y . Cai, D. Huan, Z. Li, J. Zhao, Z. Chen, W. He, Q. Quan, X...

    2022

  27. [35]

    Encore: Efficient architecture verification framework with fpga acceleration,

    K. Shi, S. Xu, Y . Diao, D. Boland, and Y . Bao, “Encore: Efficient architecture verification framework with fpga acceleration,” inProceedings of the 2023 ACM/SIGDA International Symposium on Field Programmable Gate Arrays, ser. FPGA ’23. New York, NY , USA: Association for Co...

    2023

  28. [36]

    Picorv32 – a size-optimized risc-v cpu core,

    C. Wolf, “Picorv32 – a size-optimized risc-v cpu core,” https://github. com/YosysHQ/picorv32, 2024

    2024

  29. [37]

    Hummingbirdv2 e203 core and soc,

    Nuclei System Technology, “Hummingbirdv2 e203 core and soc,” https: //doc.nucleisys.com/hbirdv2, 2024, online

    2024

  30. [38]

    Ibex: An embedded 32-bit RISC-V CPU core,

    lowRISC CIC, “Ibex: An embedded 32-bit RISC-V CPU core,” https: //github.com/lowrisc/ibex, 2025, open-source hardware project

    2025

  31. [39]

    The probabilistic relevance frame- work: Bm25 and beyond,

    S. Robertson, H. Zaragozaet al., “The probabilistic relevance frame- work: Bm25 and beyond,”Foundations and Trends® in Information Retrieval, vol. 3, no. 4, pp. 333–389, 2009

    2009

  32. [40]

    CodeT5+: Open code large language models for code understanding and generation,

    Y . Wang, H. Le, A. Gotmare, N. Bui, J. Li, and S. Hoi, “CodeT5+: Open code large language models for code understanding and generation,” in Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, H. Bouamor, J. Pino, and K. Bali, Eds., Dec. 2023

    2023

Pith tools

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