Hardware engineers write circuits as code (Verilog, a register-transfer-level or "RTL" language). Whether that code yields a good chip is only known after slow downstream steps: synthesis turns the code into gates, and placement assigns every gate an (x, y) position on the silicon. Wire length, congestion and much of the final timing depend on that placement. Current learned models that read RTL predict only what synthesis reveals, such as area and gate-level delay. None of them has seen where the gates end up. We propose to teach an RTL code model about placement geometry with coordinate denoising. Coordinate denoising is a self-supervised objective from molecular modeling: jitter the positions of atoms and train a network to move them back.
The plan has two stages. First, pretrain a teacher network on placed gate-level netlists by corrupting gate coordinates and learning to restore them. Second, distill the teacher's register-level embeddings into a compact encoder that reads only the RTL's control-data-flow graph, the program graph a synthesis tool extracts from the code. At inference, the student predicts post-placement quality from code alone, with no synthesis or placement run. This follows the molecular result that a 3D denoiser can teach a 2D graph model (3D Denoisers Are Good 2D Teachers), but moves it to a setting with a different geometry, different invariances and a many-to-one correspondence problem.
Core Claim
In molecules, clean training structures sit near energy minima. Denoising them therefore estimates restoring forces without any force labels, because denoising with Gaussian noise equals score matching on the data distribution (Pre-training via Denoising for Molecular Property Prediction; Energy-Motivated Equivariant Pretraining).
An analytical placer produces something closely analogous. It returns a local minimum of an explicit energy,
$$E(X) = W(X) + \lambda D(X),$$
where $X$ holds the gate coordinates, $W$ is a smooth wirelength term, $D$ is a density or overlap penalty, and $\lambda$ weights the two. If placements are treated as samples concentrated around minima of $E$, a denoiser $f_\theta$ trained at small noise scale $\sigma$ recovers the gradient of the placer's objective:
$$\frac{f_\theta(\tilde X) - \tilde X}{\sigma^2} \approx \nabla_X \log p(\tilde X) \propto -\nabla_X E(\tilde X).$$
This is the same mixture-around-minima argument used for molecular conformers. It is an approximation, since placer outputs are optimizer endpoints rather than Boltzmann samples, and we test it directly (see Decisive Checks).
Our claim is that this learned "placement force field" carries dense, per-node information about which logic pulls on which. A single scalar label such as total wirelength cannot carry that information. Distilling it into an RTL graph encoder should improve prediction of post-placement metrics, and do so with fewer placed designs than supervised regression on those scalars needs.
Relation to Prior Work
Three RTL encoders define the current state of the art, and all stop before placement.
StructRTL supplies our student architecture. It pairs a Graph Isomorphism Network (a message-passing network over the graph) with a Transformer over the control-data-flow graph, pretrains with stratified masked-node and edge prediction, and distills from a gate-netlist teacher. Its teacher is discrete and synthesis-level. Ours is geometric and placement-level.
UniRTL jointly masks code tokens and graph nodes. It reports the best delay error on the StructRTL benchmark but uses no spatial information.
NetTAG is the closest competitor. It aligns netlist embeddings with layout data through contrastive cross-stage alignment and treats physical attributes as static metadata. We instead learn from the coordinates themselves through a generative objective. We also borrow NetTAG's register-cone decomposition, which splits a sequential circuit into the logic feeding each flip-flop, and use it as the unit of correspondence.
Chip Placement with Diffusion Models shows that coordinate denoising over netlist graphs captures real placement structure: it runs zero-shot and reduces wirelength by 50% against prior macro placers. That result motivates our teacher. The work, however, generates placements and never touches code; we use denoising as a representation-learning signal and never generate placements at inference.
The molecular denoising variants constrain our noise design. Isotropic per-atom noise produces physically invalid structures, which Fractional Denoising and Sliced Denoising address by perturbing structured degrees of freedom instead. The chip analogue is that independent per-gate jitter creates massive overlap. Denoising Distance Matching motivates writing part of the loss on pairwise distances, so that it is invariant to the arbitrary symmetries of a placement solution.
Research Program
Data. We place the roughly 13,200 StructRTL designs, already synthesized to the SkyWater 130nm library, with an open-source analytical placer. Each design gets three random seeds, so that, like molecular conformers, every design has several near-equilibrium geometries. We record half-perimeter wirelength, a congestion map summary, and post-placement worst slack. These post-placement labels are new; the file reports no prior results on them. If throughput allows, the compilable subset of the UniRTL corpus (38,888 designs) extends the pretraining pool, with labels withheld.
Teacher. The teacher is a graph network over the placed netlist, with gate coordinates as node features and I/O pins fixed as anchors. Its noise is hierarchical: a rigid random translation of each register cone, plus small per-gate Gaussian jitter. This mirrors fractional denoising, where coarse moves preserve the local cluster structure the placer created. The loss combines coordinate reconstruction with a distance-matching term on intra-cone and inter-cone pairs. The distance term matters because the absolute die orientation is fixed by the pins, but relative arrangements within cones are only defined up to symmetry.
Correspondence and distillation. RTL graph nodes do not map one-to-one to gates. Registers, however, survive synthesis under traceable names. We therefore pool teacher embeddings per register cone, pool student embeddings over the RTL subgraph that feeds each register, and distill at that level with a cosine loss. The student also receives StructRTL's masked-node pretraining. The student is then fine-tuned on post-placement labels and, separately, on the original StructRTL delay and area labels.
Downstream use. As a secondary demonstration of domain specialization, we use the student as a zero-cost reranker for multiple Verilog candidates sampled from RTLCoder. Among functionally correct candidates, we measure whether the student's choice has lower real post-placement wirelength than a random correct candidate.
Baselines
The naive reference is the StructRTL student with its own pretraining and no teacher, fine-tuned on the new post-placement labels. Every gain is measured against it with identical architecture, data splits, fine-tuning budget and three seeds.
The strongest existing methods on the established benchmark are UniRTL and StructRTL. UniRTL reports delay mean absolute error 0.3384 on the StructRTL benchmark, against 0.5414 for StructRTL and 0.7327 for a graph attention network (UniRTL). StructRTL reports delay R² 0.887 and 88.23% pairwise delay-ranking accuracy on 102 industrial modules (StructRTL). For post-placement metrics we found no reported result on Lacuna, so we retrain both systems ourselves on the new labels using their published training recipes and an equal hyperparameter-search budget.
On the original delay task, beating these methods means matching or improving UniRTL's 0.3384 mean absolute error, which shows the added geometry costs nothing. On post-placement wirelength and slack, beating them means a gain larger than the seed-to-seed spread, in both mean absolute error and pairwise ranking accuracy.
The most dangerous baseline is direct supervision. The same StructRTL student is trained multitask to regress the post-placement scalars and per-cone centroid statistics from exactly the same placements. It uses the same teacher-free compute plus the teacher's GPU-hours reallocated to longer training.
A contrastive-alignment baseline in the style of NetTAG trains the teacher with a layout-to-netlist contrastive loss instead of denoising, on the same placements. This isolates whether the generative objective matters.
Three ablations isolate the key ingredient. The first replaces the teacher with one trained on coordinates shuffled across designs, which keeps the marginal statistics but destroys the geometry. The second swaps hierarchical noise for isotropic per-gate noise. The third distills from a teacher that uses gate features only, with no coordinates, which makes it roughly StructRTL's netlist knowledge-distillation teacher.
Why not just…?
Why not just regress the post-placement numbers directly? If placements are available for training, supervised regression on their scalar outcomes is simpler. It is the real threat to this proposal. Our bet is that one placement yields thousands of coordinate constraints but only a handful of scalars, so denoising should win when placed designs are scarce. We test this with learning curves at 5%, 20% and 100% of placed designs, in the spirit of StructRTL's 20%-data result. If direct regression matches the denoising student at every data fraction, we will report that denoising adds nothing beyond its labels and drop the claim.
Why not just align to layout contrastively, as NetTAG does? Contrastive alignment asks only that matching layout and netlist embeddings be close. It never requires the model to explain the arrangement. Nothing in the file shows whether this captures per-node spatial forces. The contrastive-teacher baseline, trained on identical placements, settles the question directly.
Why not just run the placer, or the synthesis tool, when you need the number? For final signoff one should. The use case here is inner-loop exploration, where the goal is to score many RTL variants or LLM samples. Synthesis alone already costs about 14 seconds per design against 0.096 seconds for StructRTL inference (StructRTL), and placement adds more on top. We report wall-clock time per design for the student, synthesis alone, and synthesis plus placement, alongside the reranking result, so readers can judge the trade-off.
Why not just keep discrete masked modeling? StructRTL and UniRTL show that masked modeling helps. It does not, however, predict where logic goes. The no-teacher baseline is exactly masked modeling alone, so any gap over it measures what geometry contributes.
Decisive Checks
The first check tests the core mechanism. On held-out placements, we compute the placer's analytical wirelength-plus-density gradient at noised coordinates and measure its cosine similarity with the teacher's predicted restoring displacement as noise shrinks. If the similarity is low, the force-field analogy fails, and gains elsewhere would need another explanation.
The second check separates geometry from extra compute: the shuffled-coordinate teacher should erase the post-placement gains.
The third check is the data-efficiency comparison against direct regression. It decides whether denoising is worth its complexity.
The fourth check tests generalization beyond the training distribution. We evaluate post-placement ranking on large sequential modules, where StructRTL reports degradation from multi-cycle feedback, and on designs placed at a different target utilization than training. This tests whether the student learned placement structure rather than one placer configuration.
A clean positive result would show three things together: strong teacher-force alignment, a clear gap over the shuffled teacher, and a data-efficiency advantage over direct regression at 20% of the data or less. Together these would establish coordinate denoising as a transferable signal for code models, outside physical chemistry.
References
- 3D Denoisers Are Good 2D Teachers: Molecular Pretraining via Denoising and Cross-Modal Distillation
- Pre-training via Denoising for Molecular Property Prediction
- Energy-Motivated Equivariant Pretraining for 3D Molecular Graphs
- Beyond Tokens: Enhancing RTL Quality Estimation via Structural Graph Learning
- UniRTL: Unifying Code and Graph for Robust RTL Representation Learning
- NetTAG: A Multimodal RTL-and-Layout-Aligned Netlist Foundation Model via Text-Attributed Graph
- Chip Placement with Diffusion Models
- Fractional Denoising for 3D Molecular Pre-training
- Sliced Denoising: A Physics-Informed Molecular Pre-Training Method
- Molecular Geometry Pretraining with SE(3)-Invariant Denoising Distance Matching
- RTLCoder: Outperforming GPT-3.5 in Design RTL Generation with Our Open-Source Dataset and Lightweight Solution