# Verilog

Verilog is a hardware description language used to model, simulate, and synthesize digital electronic systems.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## FormalFixer: Intent-Aligned Automated Hardware Repair via Joint Refinement of Specifications, Assertions, and RTL Implementations

DevFeed: [FormalFixer: Intent-Aligned Automated Hardware Repair via Joint Refinement of Specifications, Assertions, and RTL Implementations](<https://devfeed.tech/articles/formalfixer-intent-aligned-automated-hardware-repair-via-joint-refinement-of-specifications-assertions-and-rtl-implementations-142744.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.24037>)

Author: Changyuan Yu, Hongce Zhang

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Verilog](<https://devfeed.tech/topics/verilog.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [align](<https://devfeed.tech/tags/align.md>), [alignment](<https://devfeed.tech/tags/alignment.md>), [also](<https://devfeed.tech/tags/also.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [assertions](<https://devfeed.tech/tags/assertions.md>), [automated](<https://devfeed.tech/tags/automated.md>), [based](<https://devfeed.tech/tags/based.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [but](<https://devfeed.tech/tags/but.md>), [can](<https://devfeed.tech/tags/can.md>), [change](<https://devfeed.tech/tags/change.md>), [compromise](<https://devfeed.tech/tags/compromise.md>), [confidence](<https://devfeed.tech/tags/confidence.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ma](<https://devfeed.tech/tags/cs-ma.md>), [defect](<https://devfeed.tech/tags/defect.md>), [designs](<https://devfeed.tech/tags/designs.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [repair](<https://devfeed.tech/tags/repair.md>), [rtl](<https://devfeed.tech/tags/rtl.md>), [specifications](<https://devfeed.tech/tags/specifications.md>)

### AI overview

FormalFixer treats a failed formal property verification (FPV) assertion as a possible mismatch among specification intent, verification intent, and RTL behavior--not necessarily an RTL defect. For Verilog designs with assertions, it keeps the original specification as authoritative and appends confidence-filtered refinements to clarify implicit constraints. It then uses intent mismatch and verifier-generated counterexample cone graphs to guide iterative RTL patching, explicitly checking correspondence among the specification, assertions, and RTL. The excerpt reports results supporting intent alignment for FPV-based repair, but provides no quantitative results or workflow details.

### Source excerpt

arXiv:2611.24037v1 Announce Type: cross Abstract: Functional errors in hardware designs can compromise correctness and security, and must be fixed before tape-out. Formal property verification (FPV) provides strong guarantees by proving or refuting assertions, but a failed assertion is not always evidence of an RTL defect: the failure may also come from a buggy assertion or from a specification that is semantically correct but too ambiguous or incomplete for direct formalization. This creates a practical repair problem that existing RTL-centric methods do not directly address: the repair loop must align specification intent, verification intent, and RTL behavior before deciding which artifact to change. \textsc{FormalFixer} addresses this problem with a multi-stage, intent-aligned repair workflow for Verilog designs with assertions. It preserves the original specification as authoritative ground truth and appends confidence-filtered refinements to clarify implicit constraints. \textsc{FormalFixer} uses both intent mismatch and verifier-generated counterexample cone graphs to guide iterative RTL patching. This workflow explicitly checks specification--assertion--RTL correspondence. Results support intent alignment for FPV-based hardware repair.

## RTLReviewBench: LLM Hardware Reviewers Rarely Miss Bugs but Routinely Reject Correct RTL

DevFeed: [RTLReviewBench: LLM Hardware Reviewers Rarely Miss Bugs but Routinely Reject Correct RTL](<https://devfeed.tech/articles/rtlreviewbench-llm-hardware-reviewers-rarely-miss-bugs-but-routinely-reject-correct-rtl-141661.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.21678>)

Author: Yasir Mahmud

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Verilog](<https://devfeed.tech/topics/verilog.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Hallucination detection](<https://devfeed.tech/topics/hallucination-detection.md>)

Tags: [benchmark](<https://devfeed.tech/tags/benchmark.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [llm](<https://devfeed.tech/tags/llm.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [release](<https://devfeed.tech/tags/release.md>), [rtl](<https://devfeed.tech/tags/rtl.md>), [simulation](<https://devfeed.tech/tags/simulation.md>)

### AI overview

RTLReviewBench evaluates 12 commercial and open-weight models on 114 matched pairs of buggy and correct Verilog modules, with labels confirmed by simulation. Models rarely accept buggy code but frequently reject correct code, making more than five false rejections per missed bug. On the same designs, they miss fewer synthetic injected bugs than real bugs. For weaker reviewers, asking for reasoning before the verdict sharply reduces false rejections; an ablation finds reasoning placement matters more than the instruction to reason, while sampling and majority voting do not help. A blinded audit finds some correct "buggy" verdicts rely on false technical claims. The authors release the benchmark, a harder split, model responses, and evaluation code.

### Source excerpt

arXiv:2611.21678v1 Announce Type: cross Abstract: Hardware teams increasingly ask large language models (LLMs) to review register-transfer level (RTL) code, yet it is unclear whether a model can tell a correct module from a buggy one without simulating it. We introduce RTLReviewBench, a benchmark of 114 matched pairs of buggy and correct Verilog modules. Each pair shares one specification, most buggy modules are real failures of LLM code generators, and every label is confirmed by simulation. Evaluating 12 commercial and open-weight models, we find a consistent asymmetry: reviewers rarely accept buggy code but often reject correct code, producing more than five false rejections for every missed bug. Synthetic mutants hide part of the problem: on the same designs, models miss far fewer injected bugs than real ones. Asking a model to reason before it commits to a verdict sharply reduces false rejections for weaker reviewers, and a controlled ablation shows that where the reasoning appears in the output matters more than the instruction to reason, whereas sampling and majority voting do not help. A blinded audit further shows that some correct "buggy" verdicts rest on false technical claims. We release the benchmark, a harder split for future models, all model responses, and the evaluation code at https://github.com/yasirmahmud/RTLReviewBench

## Silinx: An Open, Browser-Based HDL Design Platform for Teaching Digital Systems on FPGA Boards

DevFeed: [Silinx: An Open, Browser-Based HDL Design Platform for Teaching Digital Systems on FPGA Boards](<https://devfeed.tech/articles/silinx-an-open-browser-based-hdl-design-platform-for-teaching-digital-systems-on-fpga-boards-126171.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.11741>)

Author: Pedro Malo

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Verilog](<https://devfeed.tech/topics/verilog.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-coding-agents](<https://devfeed.tech/tags/ai-coding-agents.md>), [amd](<https://devfeed.tech/tags/amd.md>), [area](<https://devfeed.tech/tags/area.md>), [asm](<https://devfeed.tech/tags/asm.md>), [beginners](<https://devfeed.tech/tags/beginners.md>), [board](<https://devfeed.tech/tags/board.md>), [boolean](<https://devfeed.tech/tags/boolean.md>), [browser](<https://devfeed.tech/tags/browser.md>), [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [cs-cy](<https://devfeed.tech/tags/cs-cy.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [cs-sy](<https://devfeed.tech/tags/cs-sy.md>), [design](<https://devfeed.tech/tags/design.md>), [digital](<https://devfeed.tech/tags/digital.md>), [eess-sy](<https://devfeed.tech/tags/eess-sy.md>), [fpga](<https://devfeed.tech/tags/fpga.md>), [hdl](<https://devfeed.tech/tags/hdl.md>), [open](<https://devfeed.tech/tags/open.md>), [platform](<https://devfeed.tech/tags/platform.md>), [systems](<https://devfeed.tech/tags/systems.md>), [teaching](<https://devfeed.tech/tags/teaching.md>)

### AI overview

Silinx brings an ISE-style FPGA teaching workflow into the browser, addressing installation difficulties with discontinued ISE 14.7 on older Digilent boards. It supports VHDL, Verilog, C/C++ through Silinx HLS, and graphical design inputs that generate HDL; students can check, simulate, emulate, build, and program boards over WebUSB. Its open browser flow uses WebAssembly builds of Yosys and nextpnr, plus custom Spartan-3E and Spartan-6 device data, timing models, and bitstream writing. Lattice iCE40 boards use existing open tools; other families are planned. The abstract reports byte-identical bitstreams to ISE for the same placed-and-routed design and passing ISE design rule checks. Across 45 shared open-source designs, the flow used fewer slices and shorter critical paths than ISE at matching optimization goals: 15% and 14% respectively for area optimization, and 21% and 8% for speed optimization. The source is an abstract, so it does not provide further implementation or evaluation details.

### Source excerpt

arXiv:2611.11741v1 Announce Type: cross Abstract: Many digital systems courses teach on FPGA boards whose vendor tool is no longer maintained: the Digilent Basys2 and Nexys2 (Xilinx Spartan-3E) and Nexys3 and Atlys (Spartan-6) need Xilinx ISE 14.7, discontinued since 2013 and hard to install on the computers and tablets students use today. The author presents Silinx, a free (AGPL-3.0) HDL design platform for teaching that keeps ISE's Project Navigator workflow but runs in a web browser with nothing to install. A module can be written in VHDL or Verilog, in C or C++ through Silinx HLS, which is compatible with AMD's Vitis HLS and passes all 73 of its introductory examples, or drawn as a schematic, an ASM chart, a state diagram, a Boolean function with its Karnaugh map, or a Petri net, from which its HDL is generated. Designs are checked with explanations written for beginners, simulated, run on an emulated board, built, and programmed onto a real board over WebUSB. The implementation flow is open and runs in the browser: Yosys and nextpnr compiled to WebAssembly, with Silinx's own device data, timing model and bitstream writer for the Spartan-3E and Spartan-6, built by black-box observation of ISE's documented tools; Lattice iCE40 boards use the existing open iCE40 tools, and further families are planned. ISE is the oracle: Silinx's bitstreams are byte-identical to those ISE writes for the same placed and routed design, and pass ISE's design rule check. Against ISE at the same optimization goal, the open flow uses 15% fewer slices with 14% shorter critical paths when optimizing for area, and 21% fewer slices with 8% shorter critical paths when optimizing for speed (geometric means over 45 open-source designs built by both flows). The author also describes how the platform was developed with AI coding agents under test-first project rules.

## AutoC2V: Synthesis-Guided LLM Training for QoR-Optimized C++-to-Verilog Generation

DevFeed: [AutoC2V: Synthesis-Guided LLM Training for QoR-Optimized C++-to-Verilog Generation](<https://devfeed.tech/articles/autoc2v-synthesis-guided-llm-training-for-qor-optimized-c-to-verilog-generation-125261.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.10824>)

Author: Guanqi Lyu, Fei Zhao, Zhaojun Lu, Jiaji He, Yongqiang Lyu

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Verilog](<https://devfeed.tech/topics/verilog.md>), [grpo](<https://devfeed.tech/topics/grpo.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Fine-tuning](<https://devfeed.tech/topics/fine-tuning.md>), [LLM Techniques](<https://devfeed.tech/topics/llm-techniques.md>)

Tags: [c-c-plus-plus](<https://devfeed.tech/tags/c-c-plus-plus.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [fine-tuning](<https://devfeed.tech/tags/fine-tuning.md>), [functional](<https://devfeed.tech/tags/functional.md>), [generation](<https://devfeed.tech/tags/generation.md>), [high-level-synthesis](<https://devfeed.tech/tags/high-level-synthesis.md>), [hls](<https://devfeed.tech/tags/hls.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [latency](<https://devfeed.tech/tags/latency.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-training](<https://devfeed.tech/tags/llm-training.md>), [long-context](<https://devfeed.tech/tags/long-context.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [model](<https://devfeed.tech/tags/model.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [synthesis](<https://devfeed.tech/tags/synthesis.md>), [training](<https://devfeed.tech/tags/training.md>), [verilog](<https://devfeed.tech/tags/verilog.md>)

### AI overview

AutoC2V trains LLMs to generate Verilog from synthesizable C++ using real synthesis data and feedback. Its dataset pairs C++ kernels with Verilog, QoR metrics, and optimization objectives; training uses supervised fine-tuning and GRPO. To reduce repeated synthesis costs during GRPO, a QoR Prediction Reward Model estimates latency and resource metrics from RTL representations and supplies reward signals. The abstract reports improved RTL functional pass rates and latency and resource optimization versus the unfine-tuned base model, named HLS optimization approaches, and listed commercial models. It provides no quantitative results or experimental details.

### Source excerpt

arXiv:2611.10824v1 Announce Type: cross Abstract: High-level synthesis (HLS) can translate C/C++ kernels into register-transfer level (RTL) designs, yet generating high-quality hardware still relies heavily on manual pragma tuning and repeated synthesis evaluation. We propose AutoC2V, a C++-to-Verilog generation framework driven by real synthesis feedback that enables large language models (LLMs) to directly generate RTL with improved quality of results (QoR) from synthesizable C++ kernels. We construct training data from real synthesis results, including synthesizable C++ source code, the corresponding Verilog RTL, QoR metrics, and optimization objectives. Using this dataset, we align the model toward synthesis-aware RTL generation through Supervised Fine-Tuning (SFT) and Group Relative Policy Optimization (GRPO). To reduce the high cost of repeatedly invoking real synthesis during GRPO, we design the QoR Prediction Reward Model (QoR RM), which predicts latency and resource metrics by encoding RTL into long-context semantic representations, thereby providing low-cost and continuous QoR reward signals for policy optimization. Experimental results demonstrate that AutoC2V not only substantially improves RTL functional pass rates, but also achieves superior latency and resource optimization compared to the unfine-tuned base model, representative HLS optimization approaches (HLSPilot, LLM-DSE, and AutoDSE), and advanced general-purpose commercial models (Claude Opus 4.8, GPT-5.5, Gemini 3.1 Pro, DeepSeek v4 Pro, and GLM-5.2). These results indicate that combining real synthesis data with efficient QoR reward modeling can further improve the ability of LLMs to generate high-quality RTL.

## Causal Signal Credit Assignment for Verilog Code Generation via Counterfactual Hardware Verification

DevFeed: [Causal Signal Credit Assignment for Verilog Code Generation via Counterfactual Hardware Verification](<https://devfeed.tech/articles/causal-signal-credit-assignment-for-verilog-code-generation-via-counterfactual-hardware-verification-126192.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.11848>)

Author: Yali Du, Ming Li

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Verilog](<https://devfeed.tech/topics/verilog.md>), [dpo](<https://devfeed.tech/topics/dpo.md>), [rlhf](<https://devfeed.tech/topics/rlhf.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>)

Tags: [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [credit-assignment](<https://devfeed.tech/tags/credit-assignment.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [direct-preference-optimization](<https://devfeed.tech/tags/direct-preference-optimization.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [signal](<https://devfeed.tech/tags/signal.md>), [verification](<https://devfeed.tech/tags/verification.md>), [verilog](<https://devfeed.tech/tags/verilog.md>)

### AI overview

Causal Signal Credit Assignment (CSCA) addresses the coarse pass/fail feedback of module-level simulation by assigning continuous credit to RTL statements. It verifies sampled candidates at signal level, identifies output-driving assignments, and applies five interventions while holding the rest of the module and testbench fixed. Changes in signal-level errors and behavioral agreement determine statement credits, which are mapped to response-token weights for strict weighted direct preference optimization. The method is designed to reinforce locally supported statements without uniformly rewarding an otherwise incorrect response. Built with Icarus Verilog and a CodeV-derived corpus, it was evaluated on code-completion and specification-to-RTL tasks in VerilogEval 2.0 and RTLLM v2.0. With Qwen2.5-Coder-7B-Instruct, CSCA led the evaluated 7B-scale models and was reported as comparable to the larger GPT-5.4-mini on these benchmarks.

### Source excerpt

arXiv:2611.11848v1 Announce Type: new Abstract: Large language models have improved Verilog generation, yet functional correctness remains difficult to optimize because simulation commonly provides a coarse module-level pass/fail outcome. Such feedback discards useful evidence from partially correct RTL modules and cannot determine whether a source statement is functionally responsible for an observed output behavior. We present a new method named Causal Signal Credit Assignment (CSCA), which is a counterfactual preference-optimization framework for Verilog generation. CSCA first performs continuous signal-level behavioral verification on sampled candidate modules. It then locates output-driving assignment spans and applies five interventions while holding the remaining module and testbench fixed. The resulting changes in signal-level errors are combined with behavioral agreement to form a continuous statement credit, which is mapped to response-token weights for strict weighted direct preference optimization. This enables CSCA to learn from locally supported statements without uniformly reinforcing an otherwise incorrect response. Built on Icarus Verilog and a CodeV-derived corpus, CSCA is evaluated on VerilogEval~2.0 and RTLLM~v2.0, including both code completion and specification-to-RTL tasks. With a Qwen2.5-Coder-7B-Instruct backbone, CSCA leads the evaluated 7B-scale models and remains comparable to the much larger GPT-5.4-mini on the reported Verilog-generation benchmarks.

## Search-Guided Reasoning Trace Curation for Verilog Generation

DevFeed: [Search-Guided Reasoning Trace Curation for Verilog Generation](<https://devfeed.tech/articles/search-guided-reasoning-trace-curation-for-verilog-generation-107953.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.37706>)

Author: Matthew DeLorenzo, Kevin Tieu, Prithwish Jana, Piyush Jha, Dileep Kalathil, Vijay Ganesh, Jeyavijayan Rajendran

Published: 2026-10-30T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [monte carlo tree search](<https://devfeed.tech/topics/monte-carlo-tree-search.md>), [Verilog](<https://devfeed.tech/topics/verilog.md>), [Fine-tuning](<https://devfeed.tech/topics/fine-tuning.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>)

Tags: [chain-of-thought](<https://devfeed.tech/tags/chain-of-thought.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [curation](<https://devfeed.tech/tags/curation.md>), [fine-tuning](<https://devfeed.tech/tags/fine-tuning.md>), [generation](<https://devfeed.tech/tags/generation.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [hardware-design](<https://devfeed.tech/tags/hardware-design.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [monte-carlo-tree-search](<https://devfeed.tech/tags/monte-carlo-tree-search.md>), [planning](<https://devfeed.tech/tags/planning.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [search](<https://devfeed.tech/tags/search.md>), [supervision](<https://devfeed.tech/tags/supervision.md>), [trace](<https://devfeed.tech/tags/trace.md>), [verilog](<https://devfeed.tech/tags/verilog.md>)

### AI overview

MCTS-SFT curates Verilog-generation training traces by searching over intermediate design decisions and using functional feedback from complete RTL rollouts to guide earlier choices. Its Plan-MCTS variant searches compact plans covering interfaces, timing, state, behavior, and update rules. It yields 84.2% correct traces, versus 81.9% for one-shot structured planning and 82.0% for unguided tree exploration. Keeping the searched plan in SFT targets raises pass@10 from 52.56% to 57.7% on identical trajectories and outputs. In a separate 6,000-trace study on VerilogEval-v2, MCTS-curated supervision improves pass@10 by up to 3.7 points over full-response chain-of-thought distillation while reducing generated length by about 50%.

### Source excerpt

arXiv:2610.37706v1 Announce Type: cross Abstract: Recent advances in large language models (LLMs) have improved Verilog generation. However, most training pipelines distill natural-language reasoning traces whose intermediate design decisions are weakly structured and are primarily selected according to the correctness of the final generated RTL. We present MCTS-SFT, a verifier-guided framework for curating reasoning traces for supervised fine-tuning (SFT) of Verilog generation models. MCTS-SFT formulates trace construction as search over intermediate reasoning states and uses Monte Carlo Tree Search (MCTS) to propagate functional feedback from complete Verilog rollouts to earlier design decisions. Within this framework, we introduce Plan-MCTS, which searches over compact hardware-design plans that explicitly represent interfaces, timing, state, behavior, and update rules. We further study plan-preserving supervision, in which the searched structured state is retained as part of the downstream SFT target. Our experiments find that Plan-MCTS achieves the highest functional trace yield, with 84.2% correct traces compared with 81.9% for one-shot structured planning and 82.0% for unguided tree exploration. For identical Plan-MCTS trajectories and Verilog outputs, retaining the explicit searched plan during SFT raises pass@10 from 52.56% to 57.7%, demonstrating that the representation of intermediate design decisions materially affects downstream learning. In a separate 6,000-trace study, MCTS-curated supervision improves pass@10 over full-response chain-of-thought distillation by up to 3.7 points while reducing downstream generation length by approximately 50% on VerilogEval-v2. These results demonstrate that structured hardware planning, verifier-guided search, and explicit intermediate-state supervision provide complementary mechanisms for constructing more effective and token-efficient training data for Verilog generation.

## NVIDIA Nemotron 3 Ultra Leads Open Models on Accuracy and Efficiency in Agentic RTL Coding

DevFeed: [NVIDIA Nemotron 3 Ultra Leads Open Models on Accuracy and Efficiency in Agentic RTL Coding](<https://devfeed.tech/articles/nvidia-nemotron-3-ultra-leads-open-models-on-accuracy-and-efficiency-in-agentic-rtl-coding-6901.md>)

Original publisher: [Read original article](<https://developer.nvidia.com/blog/nvidia-nemotron-3-ultra-leads-open-models-on-accuracy-and-efficiency-in-agentic-rtl-coding/>)

Author: Nirmal Kumar Juluru

Published: 2026-07-27T00:45:00Z

Content type: article

Language: en

Sources: [NVIDIA Developer](<https://devfeed.tech/sources/nvidia-developer.md>), [NVIDIA Technical Blog](<https://devfeed.tech/sources/nvidia-technical-blog.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [Verilog](<https://devfeed.tech/topics/verilog.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Nvidia](<https://devfeed.tech/topics/nvidia.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [debugging](<https://devfeed.tech/topics/debugging.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [Code generation](<https://devfeed.tech/topics/code-generation.md>), [Hardware](<https://devfeed.tech/topics/hardware.md>), [long-context](<https://devfeed.tech/topics/long-context.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-ai-generative-ai](<https://devfeed.tech/tags/agentic-ai-generative-ai.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [automation](<https://devfeed.tech/tags/automation.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [chip-design](<https://devfeed.tech/tags/chip-design.md>), [code](<https://devfeed.tech/tags/code.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [coding](<https://devfeed.tech/tags/coding.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [developer-tools-techniques](<https://devfeed.tech/tags/developer-tools-techniques.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [featured](<https://devfeed.tech/tags/featured.md>), [hardware-semiconductor](<https://devfeed.tech/tags/hardware-semiconductor.md>), [llms](<https://devfeed.tech/tags/llms.md>), [long-context](<https://devfeed.tech/tags/long-context.md>), [models](<https://devfeed.tech/tags/models.md>), [nemotron](<https://devfeed.tech/tags/nemotron.md>), [nvidia](<https://devfeed.tech/tags/nvidia.md>), [open](<https://devfeed.tech/tags/open.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [top-stories](<https://devfeed.tech/tags/top-stories.md>), [validation](<https://devfeed.tech/tags/validation.md>)

### AI overview

NVIDIA's article presents ACE-RTL and Nemotron 3 Ultra as a combined approach to agentic RTL coding. The workflow generates Verilog, runs simulations and other EDA checks, analyzes failures, and iteratively refines designs while maintaining debugging context. The CVDP benchmark evaluates accuracy and efficiency on realistic RTL generation, modification, debugging, and verification tasks.

### Source excerpt

Modern chip design is increasingly limited by engineering time. Register transfer level (RTL) development and verification require specialized hardware...

## Growing the Hardcaml toolset

DevFeed: [Growing the Hardcaml toolset](<https://devfeed.tech/articles/growing-the-hardcaml-toolset-20172.md>)

Original publisher: [Read original article](<https://blog.janestreet.com/growing-the-hardcaml-toolset-index/>)

Author: Andrew Ray

Published: 2020-12-01T00:00:00Z

Content type: release

Language: en

Sources: [Jane Street](<https://devfeed.tech/sources/jane-street.md>)

Topics: [Library](<https://devfeed.tech/topics/library.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>), [fpga](<https://devfeed.tech/topics/fpga.md>), [Markdown](<https://devfeed.tech/topics/markdown.md>), [OCaml](<https://devfeed.tech/topics/ocaml.md>), [Software Testing](<https://devfeed.tech/topics/software-testing.md>), [Simulation](<https://devfeed.tech/topics/simulation.md>), [Verilog](<https://devfeed.tech/topics/verilog.md>)

Tags: [announce](<https://devfeed.tech/tags/announce.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [fpga](<https://devfeed.tech/tags/fpga.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [markdown](<https://devfeed.tech/tags/markdown.md>), [ocaml](<https://devfeed.tech/tags/ocaml.md>), [simulation](<https://devfeed.tech/tags/simulation.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

Jane Street announces a broad set of new Hardcaml libraries, expanded documentation, and improved testing support. The release includes circuit designs, FPGA component bindings, verification tools, simulator backends, Verilog import, and additional simulation and hardware-design utilities.

### Source excerpt

I am pleased to announce that we have recently released a slew of new Hardcaml libraries!

## A 1997 Design Contest Compared Verilog and VHDL

DevFeed: [A 1997 Design Contest Compared Verilog and VHDL](<https://devfeed.tech/articles/verilog-won-vhdl-lost-you-be-the-judge-77759.md>)

Original publisher: [Read original article](<https://danluu.com/verilog-vs-vhdl/>)

Published: 2014-08-14T00:00:00Z

Content type: comparison

Language: en

Sources: [Danluu](<https://devfeed.tech/sources/danluu.md>)

Topics: [Verilog](<https://devfeed.tech/topics/verilog.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [asic](<https://devfeed.tech/tags/asic.md>), [eda](<https://devfeed.tech/tags/eda.md>), [hdl](<https://devfeed.tech/tags/hdl.md>), [verilog](<https://devfeed.tech/tags/verilog.md>), [vhdl](<https://devfeed.tech/tags/vhdl.md>)

### AI overview

An archived account describes a 1997 contest in which engineers used Verilog or VHDL to design a synchronous counter and generate a gate-level netlist. Verilog participants completed functional designs more often within the contest time, but the results were limited by issues including incomplete test vectors, tool and workstation problems, and unequal timing allowances. The article presents the contest as an imperfect comparison rather than a definitive verdict on either language.

### Source excerpt

This is an archived USENET post from John Cooley on a competitive comparison between VHDL and Verilog that was done in 1997. I knew I hit a nerve. Usually when I publish a candid review of a particular conference or EDA product I typically see around 85 replies in my e-mail "in" box. Buried in my review of the recent Synopsys Users Group meeting, I very tersely reported that 8 out of the 9 Verilog designers managed to complete the conference's design contest yet none of the 5 VHDL designers could. I apologized for the terseness and promised to do a detailed report on the design contest at a later date. Since publishing this, my e-mail "in" box has become a veritable Verilog/VHDL Beirut filling up with 169 replies! Once word leaked that the detailed contest write-up was going to be published in the DAC issue of "Integrated System Design" (formerly "ASIC & EDA" magazine), I started getting phone calls from the chairman of VHDL International, Mahendra Jain, and from the president of Open Verilog International, Bill Fuchs. A small army of hired gun spin doctors (otherwise know as PR agents) followed with more phone calls. I went ballistic when VHDL columnist Larry Saunders had approached the Editor-in-Chief of ISD for an advanced copy of my design contest report. He felt I was "going to do a hatchet job on VHDL" and wanted to write a rebuttal that would follow my article... and all this was happening before I had even written one damned word of the article! Because I'm an independent consultant who makes his living training and working both HDL's, I'd rather not go through a VHDL Salem witch trial where I'm publically accused of being secretly in league with the Devil to promote Verilog, thank you. Instead I'm going present everything that happened at the Design Contest, warts and all, and let you judge! At the end of court evidence, I'll ask you, the jury, to write an e-mail reply which I can publish in my column in the follow-up "Integrated System Design". The Unexpec

## Writing safe Verilog

DevFeed: [Writing safe Verilog](<https://devfeed.tech/articles/writing-safe-verilog-77734.md>)

Original publisher: [Read original article](<https://danluu.com/pl-troll/>)

Published: 2013-09-15T00:00:00Z

Content type: article

Language: en

Sources: [Danluu](<https://devfeed.tech/sources/danluu.md>)

Topics: [Verilog](<https://devfeed.tech/topics/verilog.md>), [synchronization](<https://devfeed.tech/topics/synchronization.md>)

Tags: [hardware](<https://devfeed.tech/tags/hardware.md>), [linter](<https://devfeed.tech/tags/linter.md>), [verilog](<https://devfeed.tech/tags/verilog.md>)

### AI overview

The article explains how naming conventions enable lightweight static checks in Verilog for pipeline stages, clock domains, and module boundaries. These checks can catch errors before costly simulation and timing analysis. The author reports building a checker in half an hour that found seven bugs with two false positives.

### Source excerpt

Troll? That's how people write Verilog1. At my old company, we had a team of formal methods PhD's who wrote a linter that typechecked our code, based on our naming convention. For our chip (which was small for a CPU), building a model (compiling) took about five minutes, running a single short test took ten to fifteen minutes, and long tests took CPU months. The value of a linter that can run in seconds should be obvious, not even considering the fact that it can take hours of tracing through waveforms to find out why a test failed2. Lets look at some of the most commonly used naming conventions. Pipeline stage When you pipeline hardware, you end up with many versions of the same signal, one for each stage of the pipeline the signal traverses. Even without static checks, you'll want some simple way to differentiate between these, so you might name them foo_s1, foo_s2, and foo_s3, indicating that they originate in the first, second, and third stages, respectively. In any particular stage, a signal is most likely to interact with other signals in the same stage; it's often a mistake when logic from other stages is accessed. There are reasons to access signals from other stages, like bypass paths and control logic that looks at multiple stages, but logic that stays contained within a stage is common enough that it's not too tedious to either "cast" or add a comment that disables the check, when looking at signals from other stages. Clock domain Accessing a signal in a different clock domain without synchronization is like accessing a data structure from multiple threads without synchronization. Sort of. But worse. Much worse. Driving combinational logic from a metastable state (where the signal is sitting between a 0 and 1) can burn a massive amount of power3. Here, I'm not just talking about being inefficient. If you took a high-power chip from the late 90s and removed the heat sink, it would melt itself into the socket, even under normal operation. Modern chips have