HighTide
A diverse, actively maintained open-source VLSI benchmark suite spanning multiple design languages and technology nodes, built on the OpenROAD RTL-to-GDSII flow.
A diverse, actively maintained open-source VLSI benchmark suite spanning multiple design languages and technology nodes, built on the OpenROAD RTL-to-GDSII flow.
Recent additions to the suite, curated from the project's issues and pull requests.
Multi-tile hierarchical flows are landing next: the Occamy manycore and the quad- and octa-core BlackParrot configurations. These exercise hierarchical floorplanning and macro placement at a substantially larger scale than the current flat designs.
Every design now fetches its upstream RTL through pinned Bazel archives with declarative patches — no submodule checkouts and no vendored source trees (BlackParrot alone drops ~500K lines). Builds are fully reproducible from a clean clone. See the hermetic-sourcing pull requests.
bazel_to_orfs.sh packages any design's resolved configuration and
synthesized netlist into a standalone OpenROAD-flow-scripts bundle, so you can run
place-and-route — or a custom OpenROAD build — entirely outside Bazel.
See Get Started.
Existing benchmarks haven't kept pace with modern hardware diversity.
Evaluation of EDA tools, circuits, and systems often relies on outdated hardware benchmarks. Existing benchmark designs are predominantly RISC-V CPUs, providing limited representation of the diverse components found in modern heterogeneous SoCs—from ML accelerators and GPUs to cryptographic engines and networking cores.
The growing diversity of design languages poses an additional challenge. While designs exploiting the parameterization capabilities of Chisel, Python-based generators, and SystemVerilog are increasingly prevalent in the open-source community, the majority of benchmarks available to suites remain Verilog-only snapshots—often never updated after their initial release.
For designs actively receiving upstream updates, relying on stale static snapshots risks producing results that no longer reflect a design's true complexity and structure. Models trained on a narrow design set learn patterns specific to those designs, rather than generalizable circuit behaviors. HighTide addresses these gaps with a benchmark suite that evolves alongside the open-source hardware ecosystem.
Processors, accelerators, cryptographic engines, and networking cores—not just CPUs. Cell counts range from under 20k to over 1M.
Designs originating from Verilog, SystemVerilog, Chisel, Python (LiteX), and migen, compiled down to Verilog for physical implementation.
Pinned upstream archives track sources hermetically. Updates are summarized and applied with AI-assisted Claude Code skills.
End-to-end RTL-to-GDSII benchmarks exercising synthesis, floorplanning, placement, CTS, routing, and sign-off—not just point-tool targets.
Infrastructure designed for reproducibility, scalability, and continuous evolution.
Targets ASAP7 (7nm), NanGate45 (45nm), and SKY130HD (130nm) technology nodes, enabling cross-node design exploration and tool evaluation.
Leverages OpenROAD-flow-scripts and the OpenROAD toolchain for an open, reproducible RTL-to-GDSII flow. Bazel fetches and builds the entire toolchain (OpenROAD, Yosys, OpenSTA) from source — no manual tool installation and no Docker required.
Bazel-ORFS integration partitions the flow into separate build targets, enabling incremental re-execution and remote caching to drastically reduce runtimes for large designs.
Tagged Git releases provide stable, versioned snapshots while regularly incorporating upstream changes through pinned upstream archives for reproducible evaluation.
Diverse designs with varying structural composition—sequential-heavy, combinational-heavy, macro-dense—provide rich training data for ML-driven EDA research.
Fully open-source and designed to grow. Contribute new designs, improve existing configurations, or use the suite for your research.
Hardware blocks typically found in commercial heterogeneous SoCs.
| Design | Description | Language | Platforms |
|---|---|---|---|
| BlackParrot | RISC-V multicore processor (unicore & quad core variants) | SystemVerilog | asap7 nangate45 sky130hd |
| Gemmini | Systolic array matrix multiplication accelerator | Chisel | asap7 nangate45 sky130hd |
| SHA3 | SHA-3 cryptographic hash accelerator | Chisel | asap7 nangate45 sky130hd |
| CNN | Convolutional neural network accelerator | Python (NNgen/Veriloggen) | asap7 nangate45 sky130hd |
| Eyeriss v2 | Sparse CNN accelerator (2×2 cluster array) | Verilog | asap7 nangate45 sky130hd |
| NyuziProcessor | GPGPU-style multicore vector processor | SystemVerilog | asap7 nangate45 |
| Minimax | Minimal area RISC-V core (serially-fetched) | Verilog | asap7 nangate45 sky130hd |
| LiteDRAM | Configurable DRAM controller (SDR PHY, AXI+WB+native frontend) | Python (Migen/LiteX) | asap7 nangate45 sky130hd |
| LiteEth | Lightweight Ethernet core (UDP / Xilinx UltraScale+ GTH SGMII) | Python (Migen/LiteX) | asap7 nangate45 sky130hd |
| LitePCI | Lightweight PCIe endpoint (kcu105 / Xilinx UltraScale+ pcie_us hard-IP) | Python (Migen/LiteX) | asap7 nangate45 sky130hd |
| CoralNPU | Google Coral neural processing unit accelerator | Chisel | asap7 nangate45 sky130hd |
| NVDLA | NVIDIA Deep Learning Accelerator (5 partitions) | Verilog | asap7 nangate45 sky130hd |
| FlooNoC | PULP Platform 4x4 mesh network-on-chip | SystemVerilog | asap7 nangate45 sky130hd |
| Snitch Cluster | PULP Platform energy-efficient compute cluster | SystemVerilog | asap7 nangate45 |
| Ternip | SystemVerilog ternary matmul inference accelerator | SystemVerilog | asap7 nangate45 sky130hd |
| Vortex | Open-source RISC-V GPGPU | SystemVerilog | asap7 nangate45 sky130hd |
Placement views illustrating the structural diversity across the suite—from small combinational datapaths to large systolic arrays and macro-dense accelerators.
Each design's RTL is fetched and generated hermetically inside Bazel-ORFS, which partitions the RTL-to-GDSII flow into incremental build targets with remote caching for fast, reproducible results.
http_archive—no submodule, no vendored copy
Baseline results for all designs are cached remotely. After bumping a design's pinned upstream archive, Bazel re-executes only the stages whose inputs changed, drastically reducing rebuild times for large designs.
Claude Code skills that automate discovery, integration, optimization, and debugging of benchmark designs.
HighTide includes a set of Claude Code skills—AI-powered slash commands that automate the complex, multi-step processes involved in managing a benchmark suite. These skills handle everything from searching the open-source hardware ecosystem for new candidates, to performing full RTL-to-GDSII integration, to debugging flow failures and optimizing PPA—reducing what would take hours of manual work to a single command.
Searches the open-source hardware ecosystem for designs that would strengthen the benchmark suite, evaluates them against HighTide's selection criteria, and opens GitHub issues to propose additions.
/find-designs accelerators)Performs the full end-to-end process of adding a new open-source hardware design to the suite, from pinning the upstream source through hermetic RTL generation to flow configuration and testing.
http_archiveAudits all designs and tool dependencies for upstream updates, summarizes what changed, and applies updates while maintaining flow compatibility.
Analyzes and diagnoses failures at any stage of the RTL-to-GDSII flow, from synthesis errors to routing congestion, with visual layout analysis.
Iteratively maximizes cell utilization and clock frequency while maintaining a clean flow with zero DRC violations.
Ports an existing design from one technology platform to another, adapting constraints, SRAM macros, and flow parameters for the target node.
Get up and running in minutes with the Bazel flow.
All you need is Bazelisk on an Ubuntu machine — Bazel fetches and builds everything else (OpenROAD, Yosys, OpenSTA) from source. No Docker required.
# Install Bazelisk
sudo apt install perl
sudo wget -O /usr/local/bin/bazel \
https://github.com/bazelbuild/bazelisk/releases/latest/download/bazelisk-linux-amd64
sudo chmod +x /usr/local/bin/bazelInitialize the bazel-orfs submodule after cloning — the build won't resolve targets without it.
git clone https://github.com/VLSIDA/HighTide.git
cd HighTide
git submodule update --init bazel-orfsRun the full RTL-to-GDSII flow for any design.
# Build a single design
bazel build //designs/asap7/lfsr:lfsr_final
# Build all designs for a platform
bazel build //designs/asap7/...
# Build everything
bazel build //designs/...Check build summaries and QoR reports.
./tools/summary.shSee the latest build results for detailed QoR metrics across all designs and platforms.
OpenROAD researchers can run any design in plain OpenROAD-flow-scripts to try a custom OpenROAD build, modified flow scripts, or new flow steps — while the Bazel configuration stays the golden source of truth. bazel_to_orfs.sh materializes the RTL, extracts the resolved config.mk, and copies every input into a self-contained, relocatable bundle — inputs/ + config.mk + run.sh — that runs the whole flow from RTL with no Bazel and no HighTide checkout.
# Prepare a portable bundle (default — stages + prints how to run, no run)
./tools/bazel_to_orfs.sh designs/asap7/lfsr
# Prepare every asap7 design as portable bundles
./tools/bazel_to_orfs.sh //designs/asap7/...
# Run a prepared bundle on any machine (needs an ORFS install with Yosys + slang)
FLOW_HOME=~/OpenROAD-flow-scripts OPENROAD_EXE=~/OpenROAD/build/src/openroad .orfs_bundles/asap7/lfsr/run.sh
# Prepare + run locally against your own ORFS install
./tools/bazel_to_orfs.sh --run --flow-home ~/OpenROAD-flow-scripts designs/asap7/lfsrThe target can be one design or a Bazel-style pattern that expands to many — each is prepared (or, with --run, run) in turn, continuing past failures: //designs/asap7/... (all asap7), //designs/... or all (everything), asap7 | nangate45 | sky130hd (one platform), or a container such as designs/asap7/NVDLA (all its partitions).
By default it prepares only — a self-contained bundle you can copy anywhere and run with ./run.sh (overriding FLOW_HOME, OPENROAD_EXE, or the make targets). Because the bundle synthesizes from RTL, the machine that runs it needs an OpenROAD-flow-scripts install with Yosys + yosys-slang; pass --run to also run it locally.