betaFeedback

WorksComputer Science

SiliconGym: A Versatile Reinforcement Learning Environment for Agentic EDA

Abstract

Reinforcement learning (RL) with electronic design automation (EDA) feedback is advancing large language models for hardware design and verification. Extending these gains to hardware-engineering agents requires environments that span tasks, preserve state across tool calls, and support large hierarchies alongside parallel rollouts. We present SiliconGym, the first versatile, cross-task and cross-toolchain RL environment for hardware design and verification. By decoupling versioned workspaces, budgeted execution, and acceptance-gated scoring, SiliconGym scales from module-level RTL, testbench, and PPA tasks to multi-round repository repair and full-hierarchy SoC flows. Streaming dispatch overlaps tool checks with generation, finishing a 256-answer RL batch 21.9% faster than native ChipSeek. Using interchangeable open-source and commercial backends, we show that open-source-trained functional correctness transfers cleanly to commercial simulation, while paired netlist evaluation reveals when open-source PPA gains survive commercial synthesis.

Introduction

Large language models (LLMs) have improved register-transfer-level (RTL) generation on benchmarks such as VerilogEval and RTLLM [1, 2, 3]. Reinforcement learning (RL) drives recent gains in RTL generation, verification, and power, performance, and area (PPA) optimization using executable electronic design automation (EDA) feedback [4, 5, 6] or learned rewards derived from simulation [7]. Concurrent work also trains models to invoke EDA tools and revise module-level RTL [8]. The next step toward practical hardware engineering extends beyond standalone modules: agents must inspect tool feedback, revise multiple files, and test changes within existing design hierarchies [9], [10]. Training such agents requires environments that connect repeated tool calls and parallel rollouts to workflows ranging from module simulation to full-system implementation.

Existing task-specific EDA-RL pipelines tie workspace handling, tool invocation, and reward scripts to individual tasks and toolchains, leading to repeated integration effort when workflows change (Figure 1a). As rollout concurrency and optimization objectives expand, fragile reward evaluation corrupts the learning signal: resource interference changes

Figure 1. Task-specific harnesses with uneven state and resource controls (a) versus SiliconGym’s shared cross-toolchain environment (b). Folder, clock, and gauge icons denote workspace state, limits, and rewards. Arrows carry candidates and feedback/rewards between trainers/agents and environments. The sketch shows example workspace inheritance, budgets, and acceptance-gated rewards.

scores, and incomplete checks reward invalid designs. In a controlled stress replay of a simulation-based verifier [4], a 23-line generated RTL candidate produced a 16.4 GiB whole-container memory peak, and four identical copies scored [1, 0, 1, 1] in a shared-memory batch with out-of-memory kills. Simulation acceptance alone overstates PPA gains: 31 of 54 passing candidates with apparent area reductions above 5% failed formal, interface, or initialization checks. Beyond single-toolchain reliability, a shared cross-backend environment makes it possible to test a key question for researchers limited to open-source (OSS) tools: whether OSS-trained capabilities [4], [6] carry over to commercial EDA evaluation.

Building such an environment requires resolving three technical challenges. Stateful interaction across design scales. Single-shot submissions and iterative repository edits require different workspace lifetimes. The environment must preserve editable files and public diagnostics across revisions while protecting private tests and carrying project dependencies from individual modules to full design hierarchies. Bounded execution and valid rewards. Multi-stage EDA jobs have artifact dependencies and wide variation in runtime and memory use. Parallel rollouts need explicit resource budgets and failure outcomes, while task-specific acceptance checks must verify functional and implementation contracts without adding prohibitive overhead. Toolchain-independent task semantics. When task logic hardcodes tool invocations and report formats, changing a backend risks changing the task or reward definition as well. Studying transfer from open-source to commercial feedback therefore requires interchangeable backends and paired scoring under explicit task rules.

Addressing these challenges, we present SiliconGym, the first versatile, cross-task and cross-toolchain RL environment for hardware design and verification, with three contributions:

  • Versatile, stateful interaction across design scales. Versioned workspaces and private-oracle isolation let one protocol span five repository repairs, multi-round feedback revisions, and full-hierarchy Earlgrey and OpenTPU reference flows through global placement on OSS and commercial backends.

  • Budgeted parallel execution and reward validation. Explicit budgets preserve standalone-verifier scores in six matched stress replays, while qualification and acceptance gates reject invalid PPA gains. On a 256-answer ChipSeek replay, SiliconGym returns 245 rewards before generation finishes, reducing batch time by 21.9% relative to the native harness.

  • RL transfer from open-source to commercial tools. With interchangeable backends, we find that functional correctness transfers cleanly across simulators on VerilogEval (<0.2< 0.2 percentage-point aggregate difference). OSS PPA training yields modest commercial-scored gains; netlist analysis explains why commercial synthesis absorbs other OSS-rewarded RTL rewrites.

Background and Related Work

Learning and Agentic Search with EDA Feedback

EDA feedback guides both training and inference: for RTL generation, VeriRL trains a reward model from simulation-derived preferences to guide Reinforce++ updates [7], while CodeV-RL and ChipSeek obtain simulation and PPA rewards from tool execution [4], [6]. The concurrent RTL-Interact preprint trains tool-using policies for module-level RTL tasks and identifies repository-level training environments as future work [8]. Beyond RTL design, LLM4Cov learns testbench generation from execution-validated offline trajectories [11], and CHORUS trains complementary coverage experts with dense-reward RL before merging or distilling them [12]. At inference time, feedback drives testbench correction through functional self-validation in CorrectBench [13] and joint RTL/synthesis search with isolated execution and independent re-evaluation in RTLScout [14]. HORIZON extends the search setting to repository-level hardware evolution using executable acceptance conditions and isolated Git worktrees [10]. SiliconGym supplies a common candidate–feedback runtime for these trainers and search agents across tasks and backends.

Hardware Benchmarks and Evaluation Infrastructure

VerilogEval checks functionality through simulation [1], [2], RLLM includes design quality [3], and VeriThoughts uses formal verification [15]. Other benchmarks target financial FPGA latency [16] and RTL debugging [17]. Broader workflows require additional evaluation contexts: CVDP covers agentic and non-agentic design/verification tasks [18], HWE-Bench uses project-native regressions for repository repair [9], and EDAFlowQA tests reasoning over tool logs [19]. TuRTLe consolidates how generated RTL is scored through a common correctness, synthesis, and PPA evaluation flow [20]. SiliconGym makes benchmark-defined checks usable within budgeted parallel rollouts and stateful agent interaction.

Reusable Environments and RL Systems

Common action–observation interfaces decouple learning algorithms from environment implementations, as in Gymnasium [21]; CompilerGym [22] and ArchGym [23] adapt this pattern to compiler optimization and architecture simulation. For language models, HybridFlow distributes RL computation [24], ChipMATE trains cooperating RTL and reference-model agents [25], and OpenEnv provides isolated synchronous and asynchronous interaction [26]. An OpenEnv-based RTL environment supports multi-step, multi-file interaction and concurrent sessions for accelerator primitives using Icarus, Yosys, and optional SymbiYosys [27]. SiliconGym extends this RTL-focused setting to testbench and report tasks, with interchangeable commercial backends and configuration qualification that checks acceptance and isolation independently of the learning algorithm.

SiliconGym Architecture

SiliconGym separates candidate state, task and reward specifications, and budgeted execution so that interaction mode, design scale, and tool choice can vary independently (Figure 2).

Figure 2. SiliconGym architecture. Qualified task definitions feed direct submissions or agent-edited Records. Submitted candidates are sealed and validated before EDA tools perform simulation, synthesis, formal checks, or report analysis. Public feedback supports subsequent rounds; command and output excerpts illustrate the interaction.

Versioned Workspaces and Oracle-Isolated Interaction

Parallel trainers submit independent candidates through Direct submission; iterative agents revise workspaces through Agent editor (bash). Both paths use a Record to bind each reward to one candidate version despite their different workspace lifetimes. The task instance declares editable paths and readable public context: a generation task may accept one RTL file, whereas a repair task permits edits, additions, and deletions across a repository. An agent can edit and self-test while its Record is open. Submission invokes Seal + validate: the system freezes and hashes the candidate, checks its interface, and evaluates that snapshot. A revision creates a child Record that inherits permitted files and links to the parent’s public feedback, preserving the relationship between edits, diagnostics, and rewards across rounds. The agent can inspect task-selected waveforms, coverage reports, or counterexamples, while hidden reference tests and scoring bindings remain in the tool-side Private oracle.

Toolchain-Decoupled Task and Reward Specifications

The evaluation pipeline separates what a task rewards from which tool executes it. For an RTL-optimization candidate replacing a module in a fixed design snapshot, instance binding maps the edited file to the flow’s expected location, while an EvaluationPlan selects simulation, equivalence, and synthesis configurations. An execution adapter stages the inputs and invokes the tools under their budgets; an evidence collector translates tool-specific reports into structured observations such as mismatch counts, proof depth, and cell area (observations.tsv in Figure 2). The reward evaluator applies the task’s interface, initialization, and equivalence gates before converting an accepted area reduction into reward.

Changing toolchain therefore changes the execution configuration and report collector while preserving the candidate interface and task-level reward rule. Artifact dependencies govern multi-stage execution: placement consumes an accepted synthesis result, while independent simulation and synthesis may run concurrently. Proof depth and status let reward rules distinguish a bounded sequential pass from a complete proof.

Budgeted Execution and Configuration Qualification

Configurations budget EDA execution independently of the agent’s editing session, limiting the resources a candidate can consume during parallel rollouts. The reference container adapter uses container memory and process controls; subprocess adapters apply supported process limits and periodically check log and workspace usage. Both supervise termination and retain candidate, dependency, infrastructure, and cancellation outcomes alongside the score. Trainers can distinguish budget exhaustion, a failed test, and an unavailable tool.

Budgets alone cannot ensure that a task’s checks or visibility rules are correct. Configuration qualification exercises five facets for an exact definition and configuration: executability, reference acceptance, negative controls, oracle isolation, and agent visibility. The qualified badge in Figure 2 applies to both the tested task and tool definitions. A change to either triggers requalification.

System Evaluation

We evaluate versatility, reward fidelity, and runtime cost before studying cross-toolchain RL transfer in § 5.

RQ1: Task Versatility and Design Scale

Table I separates model training, capability demonstrations, and reference flows. The catalog contains 3,470 definitions; 3,133 Code V instances pass four qualification facets, and 24 across task families pass all five, including negative controls.

CategoryTask / workloadScale / interactionEvaluation stagesBackendsCatalog / execution scope
TrainingRTL generation / CodeVModule / parallel RLSimulationOSS, Comm.3,133 defs.; 2×2002 \times200 updates
PPA optimization / ChipSeekModule / parallel RLSim., synthesisOSS, Comm.2×2002 \times200 updates; 32 slots
CasesRepository repair / HWERepository / Bash agentBuild, regressionOSS5 repairs; 1 Record each
Feedback RTL repairModule / multi-round agentSim., waveformsOSSArbiter + 3 WaveDebug repairs
Formal RTL / VeriThoughtsModule / controls, repairBounded equivalenceOSS5 qualified; 1 two-round repair
Testbench / CorrectBenchModule / TB controlsSim. (golden/mutant)OSS5 qualified cases
Coverage testbench / CVDPModule / trainer integrationSim., coverageComm.4 qualified; 1 RL update
RTL optimization / RTLScoutModule / tool, agent trialsSynthesis, placementOSSTool trials; 1-round agent trial
PPA validity / CodeV-PPAModule / candidate replaySim., formal, synthesisOSS289 defs.; 508-candidate replay
Report QA / EDAFlowQAReports / answer controlsParsing, scoring—5 qualified; cached logs
FlowsEarlgrey / OpenTPUSoC, accelerator / referenceSim., synth., global placeOSS, Comm.Both designs, both backends

Table 1. Cross-task and cross-scale coverage. The catalog counts definitions (defs.). Execution counts cover the training runs, cases, and reference flows reported here.

RepositoryLang. / domainEdited filesBash cmdsTargeted regression
IbexSV / RISC-V817Debug-mode PMP access
CVA6SV / RISC-V18Compressed decode legality
CaliptraSV / RoT17Key-vault error retention
Rocket ChipChisel / RISC-V116JTAG asynchronous reset
XiangShanChisel / RISC-V113Virtual interrupt selection

Table 2. Five single-record repairs, each passing the named regression. Edited files count source/document changes. SV: SystemVerilog; RoT: root of trust.

a) Training and verification: Binary testbench checks, continuous coverage and PPA rewards, and report QA share one candidate–feedback schema (Table I). Task evaluators set acceptance criteria and scalar rewards, so trainers can change objectives through the same interface.

b) Stateful repair: Five model-authored repairs pass targeted regressions in complete Ibex, CVA6, Caliptra, Rocket Chip, and XiangShan repository workspaces (Table II). Each run uses multiple Bash actions within one Record; Ibex edits five RTL and three documentation files and performs five self-tests before submission. Directory-binding controls additionally exercise file additions and deletions.

Parent–child Records extend this interaction across scored revisions. In the arbiter case, the model repairs its own failed candidate using public feedback, improving its score from zero to one across two evaluations (with CLI commands relayed). Three WaveDebug cases and the VeriThoughts pagesel case repair seeded failures using inherited waveforms or a nine-step formal counterexample. Agents can edit and self-test within a turn. Sealing binds the reward to that snapshot and carries the diagnostics into the next turn.

c) Full-hierarchy execution: Reference flows for Earlgrey and OpenTPU reach global placement on open-source and commercial backends, using ASAP7 and approximate memory views under backend-specific resource configurations. Earlgrey retains 19 memory macros and passes two firmware tests; its open and commercial input-to-feedback-and-cleanup times are 13,216 and 14,048 s, respectively. OpenTPU contains 212,256 generic logic/register cells and 34 memory cells totaling 34.5 Mbit. Five workloads pass on both chains, and a Genus-netlist zero-delay check passes 1,656 cycles. A candidate can thus reach global placement with its enclosing hierarchy and memory configuration intact.

RQ2: Resource Budgets and Reward Fidelity

Timeouts alone do not protect concurrent rollouts from memory pressure. In targeted stress probes, the baseline verifier replay [4] uses a 30-second watchdog and process-tree termination, yet shared-memory pressure changes scores (Section I). In a shared-container probe, a 40 GiB trainer surrogate with elevated OOM-kill priority exits 137 alongside six cgroup OOM kills. Three isolated timeout probes each retain a defunct process and work directory after two seconds.

Under matched budgets—a 1 GiB container and 768 MiB tool address-space limit—all six Gym/native replay pairs agree on their scores. The memory-heavy candidate passes with sufficient memory but scores zero under tight limits. The Gym preserves the standalone verifier’s reward at both operating points, including when the tool runs out of memory.

Across 508 comparable simulation-passing candidates with valid PPA from the CodeV-PPA corpus, 54 appear to reduce area by over 5%. Acceptance gates reject 31 of these 54 candidates (57.4%): 24 yield formal counterexamples, five violate the ASIC initialization contract, and two mismatch port interfaces. Of the remaining candidates, 14 pass 20-step bounded equivalence, eight have complete combinational proofs, and one reaches the formal timeout. Retaining proof scope lets a trainer require stronger checks for sequential designs whose errors may emerge beyond a chosen bound, instead of treating every bounded pass as complete equivalence. Two simulation-passing candidates illustrate how these apparent gains arise. For audio (CodeV-68851), a rewrite replaces the reference’s 33-bit counters and bit-selected output with narrower counters, equality tests, and control flags. Mapped area falls by 34.9%, but the rewrite also changes the counter and reset behavior: a formal trace finds an output mismatch at step 19. For sixtycounter (CodeV-60023), a candidate narrows a 28-bit counter to 21 bits and adds an initial assignment; its measured area falls by 10.9%. The initialized state is outside the accepted ASIC implementation contract, so this candidate fails the initialization check.

RQ3: Runtime Cost and Parallel Efficiency

We compare SiliconGym with ChipSeek’s native harness on the first 256-answer training batch using Icarus and Yosys/OpenSTA. All three modes replay the same generation schedule with 32 warm workers and the same per-task tool limits. Native waits for the last answer before starting EDA. Gym dispatches each answer as it arrives. To measure what early dispatch contributes, we also run Gym with batch submission.

a) Where Gym gains time: Gym finishes in 90.0 s versus 115.3 s for native, a 21.9% reduction in generation-plus-reward time (Figure 3a). Forced-batch Gym takes 113.7 s, close to the native replay recorded under higher host load. Switching only Gym’s submission mode saves 23.7 s with identical rewards. By the time generation ends at 29.8 s, Gym has returned 245 rewards. Native returns all scores together after the last synthesis finishes. Scores match on 255 of 256 answers. On the exception, native’s float-only check drops an integer-valued PPA bonus (+3) that Gym retains.

Figure 3. ChipSeek batch 1. (a) Gym overlaps generation and EDA. The two stacks show successive batch phases. Native’s synthesis segment extends through cleanup. (b) Mean time to EDA completion over 256 answers. Bold totals appear above each stack. The top segment gives harness time for dispatch, setup, and worker bookkeeping. LLM Gen. includes waiting for generation to start. Tool stages include container invocation.

b) Where Gym pays for managed execution: Dispatch, setup, and worker bookkeeping average 1.24 s per answer in streaming Gym, 2.72 s in forced-batch Gym, and 0.79 s in native (Figure 3b). Mean compilation, simulation, and synthesis time totals 1.6–1.8 s per answer across the three modes. Only 106 answers reach synthesis. Each of the other 150 contributes zero synthesis time to the mean, even though native holds its score until the whole batch finishes. Releasing all answers together makes a Gym answer wait 6.09 s on average for bridge pickup and a worker slot. Streaming cuts that wait to 0.17 s and lets evaluation proceed while the LLM generates the remaining answers.

c) Synthesis timeouts and reward coverage: Unlike module simulation, synthesis workloads exhibit heavy-tailed runtime distributions where a few slow RTL candidates dominate batch completion. To evaluate how SiliconGym manages the trade-off between batch throughput and reward coverage under skewed EDA workload patterns, we compare the per-task limits above against tight uniform caps (5 s for compilation/simulation and 10 s for synthesis) in streaming mode. Under uniform caps, nine answers time out in synthesis and earn only the functional reward, whereas per-task limits let eight of the nine finish in 18–34 s and earn a PPA bonus. However, the ninth runs to its 75 s cap, extending the post-generation wait from 1.5 to 60.2 s. Longer budgets thus recover PPA feedback on slow designs, while tight uniform caps—adopted for our PPA training runs in Section V-B—bound tail latency from unrewarded stragglers.

Sensitivity to EDA Toolchains

Can gains learned with open-source tools carry over to commercial evaluation? We change the scoring backend while holding the model answers and task rules fixed.

Functional Correctness Across Simulators

Figure 4 follows one Icarus-trained and one Xcelium-trained model from validation to the VerilogEval test. On validation, switching the scorer gives nearly overlapping pass@1 and pass@4 curves for each model. At step 200, both models solve 34 of the 99 tasks within four attempts under either scorer. The agreement carries over to the test set, where each checkpoint generates 20 answers for each of 611 task/suite combinations and pass@1 is averaged equally over four suites. With commercial Xcelium scoring, the OSS-trained model reaches 44.08% and the Xcelium-trained model 44.24%. For each model the scorer gap is below 0.2 percentage points.

Figure 4. Both simulators score the same answers from each model. (a) Validation uses four answers per task on 99 tasks. Pass@1 is the mean sample pass rate and pass@4 is the fraction of tasks with a passing answer. (b) VerilogEval test pass@1 at step 200. Bars are grouped by training simulator. Filled marks and bars denote Icarus scoring, open marks and bars Xcelium.

Agreement in aggregate can still hide opposite verdicts on individual tasks. For always_casez (v1-human), Xcelium accepts all 20 commercial-trained answers, while Icarus rejects all 20 over break support. On review2015_fsmseq (v1-machine), Icarus’s acceptance of declarations after use reverses the direction of the gap. VerilogEval uses Icarus 12, whose declaration handling differs from Icarus 13 in training. Pinning the frontend version and language mode makes these syntax-dependent rewards reproducible.

PPA Gains Across Synthesis Flows

We train Qwen2.5-Coder-7B-Instruct for 200 CDPO updates with the ChipSeek correctness–PPA objective [6] and the cap described in Section IV-C. One run uses Icarus and Yosys/OpenSTA, the other Xcelium and Genus. Each uses two H100 GPUs and 32 EDA slots. Adaptive sampling consumes 723 and 885 generation batches, respectively. The runs share step-zero answers. Every 20 updates, each backend scores one answer per task on 200 NanGate45 tasks. From candidate and reference power (PP), area (AA), and delay (DD) measured on that backend, we compute:

relative EDAP=PPrefAArefDDref.\text{relative EDAP} = \frac{P}{P_{\mathrm{ref}}}\frac{A}{A_{\mathrm{ref}}}\frac{D}{D_{\mathrm{ref}}}.

Table III compares the initial model and both step-200 checkpoints on 24 designs that pass simulation and have positive EDAP in every model/scorer combination, after excluding two known overflow errors. OSS training yields a modest improvement under Genus (0.38 percentage points) even though its OSS-scored endpoint is nearly flat (+0.07 p.p.). Commercial training improves on the initial model under both scorers, by 1.46 p.p. under Genus and 1.70 p.p. under Yosys/OpenSTA. The commercial-scored means move only slightly because Genus reports identical EDAP for all three model outputs on 20 of the 24 designs. Four designs thus account for the commercial-scored gains.

ModelOSS (%) ↓Comm. (%) ↓ΔO−C\Delta_{O-C} (p.p.)
Initial106.04101.56+4.48
A (OSS-trained)106.11101.19+4.93
B (comm.-trained)104.34100.10+4.24
A−BA - B (p.p.)+1.78+1.09+0.69

Table III. Relative EDAP on 24 matched designs. Geometric means use each scoring backend’s reference as 100%. ΔO−C\Delta_{O-C}: OSS minus commercial; A−BA - B: model difference. All differences use unrounded values, in percentage points (p.p.).

a) Which RTL gains survive synthesis?: We compare answers from all checkpoints, including step zero, against each backend’s synthesis of the reference RTL. Across 33 designs, 178 jointly passing and measurable answers from the OSS run beat their reference under OSS synthesis. Genus preserves 34 of those gains, maps 98 answers to within ±0.1%\pm0.1\% of reference EDAP, and scores 46 worse than the reference.

On the 16-by-8-bit unsigned divider (vfc_7551), both step-200 models replace an unrolled shift-and-subtract loop with Verilog division and remainder. The OSS-trained answer passes the nonzero-divisor tests and has relative EDAP 0.93 under Yosys/OpenSTA and 0.30 under Genus. The initial answer fails simulation, so this gain falls outside Table III.

The 8-bit multiplier (vfc_7527, step 40) illustrates a reversal. Replacing shift-and-add with A∗BA * B lowers relative EDAP to 0.26 in the OSS flow. Under Genus, power rises by 8.5%, outweighing small area and delay reductions and bringing relative EDAP to 1.02.

The most frequent outcome is a tie. In two such cases, Genus maps the reference and the rewrite to the same cells. In vfc_7623 (step 100), explicit pairwise equality replaces a vector expression:

// Reference: 25 pairwise comparisons
assign out = ~({5{a}}, {5{b}}, {5{c}},
               {5{d}}, {5{e}})
              ^ {5{a,b,c,d,e}};
// OSS-trained answer (two of 25 assignments)
out[23] = a == b;
out[19] = b == a;

The configured Yosys flow maps reference/answer to 20/10 XNOR cells (relative EDAP 0.25); Genus maps both to the same 10-cell circuit (1.00). Yosys’s synth_flatten variant also produces 10/10 cells, tying this difference to the configured optimization passes.

In vfc_8053 (step 20), majority carry replaces the reference’s two half-adder construction:

// Reference: intermediate sum and carries
assign s1 = a ^ b;
assign c1 = a & b;
assign c2 = s1 & cin;
assign cout = c1 | c2;
// OSS-trained answer: majority carry
assign cout = (a & b) | (a & cin) | (b & cin);

Yosys maps both descriptions to five cells. The majority network uses two NAND gates where the reference uses a NAND and an inverter. Its 12.5% shorter delay and lower power outweigh a 4.8% area increase, giving relative EDAP 0.87 even with flattening enabled. Genus uses one FA_X1 full adder in each netlist. Only the order of its symmetric inputs changes, leaving relative EDAP at 1.00.

These PPA results cover one training run per chain and modules with a median of 16 nonblank reference lines. Cross-scoring identifies the effect of changing the synthesizer on a fixed RTL answer. Estimating how the backend changes the policy would also require independent training seeds. On larger IP blocks the same paired test could measure whether the PPA advantage of a module-level rewrite survives integration.

Conclusion

SiliconGym provides the first versatile, cross-task, and cross-toolchain EDA RL environment that replaces ad-hoc EDA evaluation scripts with reusable infrastructure for hardware design and verification. Rather than rebuilding workspace handlers, resource guards, and reward scripts for every workflow, researchers can use a single candidate–feedback protocol across high-throughput parallel rollouts, multi-round repository repairs, and full-hierarchy SoC flows. Streaming dispatch overlaps tool checks with rollout generation, while explicit memory budgets and formal/contract gates protect RL rewards from resource interference and invalid PPA shortcuts.

Beyond unifying single-chain workflows, SiliconGym’s interchangeable backends bridge open-source training and commercial sign-off. Paired cross-scoring shows that open-source simulation training preserves functional accuracy under Xcelium, while netlist comparison pinpoints which open-source PPA rewrites survive Genus and which are absorbed by commercial synthesis. Teams with limited commercial licenses can thus train at scale on open tools and swap backends on saved revisions to audit gains before system integration.

References

References

  1. [1]M. Liu, N. Pinckney, B. Khailany, and H. Ren, “VerilogEval: Evaluating Large Language Models for Verilog Code Generation,” in Proc. IEEE/ACM International Conference on Computer-Aided Design (ICCAD), 2023. [Online]. Available: https://arxiv.org/abs/2309.07544
  2. [2]N. Pinckney, C. Batten, M. Liu, H. Ren, and B. Khailany, “Revisiting VerilogEval: A Year of Improvements in Large-Language Models for Hardware Code Generation,” ACM Transactions on Design Automation of Electronic Systems, https://arxiv.org/abs/2408.11053
  3. [3]Y. Lu, S. Liu, Q. Zhang, and Z. Xie, “RTLLM: An Open-Source Benchmark for Design RTL Generation with Large Language Model,” in Proc. Asia and South Pacific Design Automation Conference (ASP-DAC), 2024. [Online]. Available: https://arxiv.org/abs/2308.05345
  4. [4]Y. Zhu, D. Huang, H. Lyu et al., “QiMeng-CodeV-R1: Reasoning-Enhanced Verilog Generation,” in Advances in Neural Information Processing Systems, 2025. [Online]. Available: https://arxiv.org/abs/2505.24183
  5. [5]Y. Zhao, Z. Wu, B. Yuan et al., “PRO-V-R1: Reasoning Enhanced Programming Agent for RTL Verification,” in Proc. 63rd ACM/IEEE Design Automation Conference (DAC), 2026, pp. 1–7. [Online]. Available: https://doi.org/10.1145/3770743.3803912
  6. [6]Z. Chen, K. Chang, Z. Li et al., “ChipSeek: Optimizing Verilog Generation via EDA-Integrated Reinforcement Learning,” in Proc. Annual Meeting of the Association for Computational Linguistics (ACL), 2026, pp. 25 180–25 201. [Online]. Available: https://aclanthology.org/2026.acl-long.1154/
  7. [7]F. Teng, M. Pan, X. Zhang et al., “VeriRL: Boosting the LLM-based Verilog Code Generation via Reinforcement Learning,” in Proc. IEEE/ACM International Conference on Computer-Aided Design (ICCAD), 2025. [Online]. Available: https://arxiv.org/abs/2508.18462
  8. [8]W. Shi, Y. Zhu, D. Huang et al., “RTL-Interact: Training EDA-Interactive Models for Multi-Task RTL Design,” arXiv preprint arXiv:2610.41225, 2026. [Online]. Available: https://arxiv.org/abs/2610.41225
  9. [9]F. Cui, H. Hou, Z. Luo, C. Yin, and Y. Liang, “HWE-Bench: Benchmarking LLM Agents on Real-World Hardware Bug Repair Tasks,” in Proc. 45th IEEE/ACM International Conference on Computer-Aided Design (ICCAD), 2026. [Online]. Available: https://arxiv.org/abs/2604.14709
  10. [10]C. Yu, C. Deng, N. Pinckney, and B. Khailany, “Agentic Hardware Design as Repository-Level Code Evolution,” arXiv preprint arXiv:2606.28279, 2026. [Online]. Available: https://arxiv.org/abs/2606.28279
  11. [11]H. Zhang, Z. Yu, C.-T. Ho, H. Ren, B. Khailany, and J. Zhao, “LLM4Cov: Execution-Aware Agentic Learning for High-Coverage Testbench Generation,” in Proc. International Conference on Machine Learning (ICML), ser. Proceedings of Machine Learning Research, vol. 306, 2026, pp. 160 153–160 168. [Online]. Available: https://proceedings.mlr.press/v306/zhang26hz.htmlarxiv.org/abs/2602.16953
  12. [12]H. Zhang, S. Lu, Z. Yu, C.-T. Ho, B. Khailany, and J. Zhao, “CHORUS: Complementary Experts for High-Coverage Testbench Stimulus Generation,” arXiv preprint arXiv:2608.10090, 2026. [Online]. Available: https://arxiv.org/abs/2608.10090
  13. [13]R. Qiu, G. L. Zhang, R. Drechsler, U. Schlichtmann, and B. Li, “CorrectBench: Automatic Testbench Generation with Functional Self-Correction using LLMs for HDL Design,” in Proc. Design, Automation & Test in Europe Conference (DATE), 2025, pp. 1–7. [Online]. Available: https://doi.org/10.23919/DATE64628.2025.10992873
  14. [14]F. Arnold, R. Amadruz, D. Tsaras, R. Andri, and L. Cavigelli, “RTLScout: Joint Agentic Code and Synthesis Optimization for Efficient Digital Circuits,” arXiv preprint arXiv:2606.06530, 2026. [Online]. Available: https://arxiv.org/abs/2606.06530
  15. [15]P. Yubeaton, A. Nakkab, W. Xiao et al., “VeriThoughts: Enabling Automated Verilog Code Generation using Reasoning and Formal Verification,” in Advances in Neural Information Processing Systems, 2025. [Online]. Available: https://arxiv.org/abs/2505.20302
  16. [16]W. Fu, H. Zhang, M. Shao et al., “FinHardBench: Can LLMs Generate Latency-Aware Hardware for Financial Computing?” in Proc. Conference on Language Modeling (COLM), 2026. [Online]. Available: https://arxiv.org/abs/2608.00909
  17. [17]Z. Yu, C. Zhou, Y. Lin et al., “ChipBench: A Next-Step Benchmark for Evaluating LLM Performance in AI-Aided Chip Design,” arXiv preprint arXiv:2601.21448, 2026. [Online]. Available: https://arxiv.org/abs/2601.21448
  18. [18]N. Pinckney, C. Deng, C.-T. Ho et al., “Comprehensive Verilog Design Problems: A Next-Generation Benchmark Dataset for Evaluating Large Language Models and Agents on RTL Design and Verification,” arXiv preprint arXiv:2506.14074, 2025. [Online]. Available: https://arxiv.org/abs/2506.14074
  19. [19]C.-T. Ho, R. Liang, C. Yu, and B. Khailany, “EDAFlowQA: Dual-Validated Q-Tree for a Multi-Stage EDA Log Reasoning Benchmark,” in Proc. ACM/IEEE International Symposium on Machine Learning for CAD (MLCAD), 2026. [Online]. Available: https://github.com/NVlabs/EDAFlowQA
  20. [20]D. Garcia-Gasulla, G. Kestor, E. Parisi et al., “TuRTL: A Unified Evaluation of LLMs for RTL Generation,” in Proc. ACM/IEEE International Symposium on Machine Learning for CAD (MLCAD), 2025. [Online]. Available: https://arxiv.org/abs/2504.01986
  21. [21]M. Towers, A. Kwiatkowski, J. Terry et al., “Gymnasium: A Standardized Interface for Reinforcement Learning Environments,” in Advances in Neural Information Processing Systems (NeurIPS), vol. 38, 2025, pp. 163 114–163 129. [Online]. Available: https://doi.org/10.5220/085713-4916
  22. [22]C. Cummings, B. Wasti, J. Guo et al., “CompilerGym: Robust, Performant Compiler Optimization Environments for AI Research,” in Proc. IEEE/ACM International Symposium on Code Generation and Optimization (CGO), 2022. [Online]. Available: https://arxiv.org/abs/2109.08267
  23. [23]S. Krishnan, A. Yazdanbakhsh, S. Prakash et al., “ArchGym: An Open-Source Gymnasium for Machine Learning Assisted Architecture Design,” in Proc. International Symposium on Computer Architecture (ISCA), 2023. [Online]. Available: https://arxiv.org/abs/2306.08888
  24. [24]G. Sheng, Z. Zhang, Z. Ye et al., “HybridFlow: A Flexible and Efficient RLHF Framework,” in Proc. European Conference on Computer Systems (EuroSys), 2025. [Online]. Available: https://arxiv.org/abs/2409.19256
  25. [25]Z. Yu, Y. Lin, C. Zhu et al., “ChipMATE: Multi-Agent Training via Reinforcement Learning for Enhanced RTL Generation,” arXiv preprint arXiv:2605.12857, 2026. [Online]. Available: https://arxiv.org/abs/2605.12857
  26. [26]OpenEnv contributors, “OpenEnv: Agentic Execution Environments,” Software repository, accessed: Nov. 15, 2026. [Online]. Available: https://github.com/openenv/OpenEnv
  27. [27]SupreethRao99 and contributors, “VeriRL: Verilog RTL Design Environment,” OpenEnv-based software repository, accessed: Nov. 17, 2026. [Online]. Available: https://github.com/SupreethRao99/veriRL

Paper details

vlnc:W_nxpmh67m
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 6

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents