HighTide

A VLSI design benchmark suite that runs open-source hardware designs through the OpenROAD RTL-to-GDSII flow on academic and open-source technology nodes (ASAP7 7nm, NanGate 45nm, SkyWater 130nm).

New here? See the Quick Start Guide to build your first design in 5 minutes. For the full, up-to-date list of designs and the platforms each one closes on, see the Design Catalog.

How It Works

Each design's upstream source lives in a git submodule at designs/src/<design>/dev/repo/. A build script converts the source HDL (SystemVerilog, Chisel, LiteX, etc.) into plain Verilog, which is checked into the repo as the release RTL at designs/src/<design>/. The release RTL may include patches or modifications beyond simple conversion — for example, SRAM memories are replaced with FakeRAM black-box macros so the design can be synthesized without an SRAM compiler. This release RTL is what builds use by default — no submodule checkout or conversion tools needed.

To regenerate RTL from the upstream source (e.g., after updating the submodule to a newer commit):

bazel build --define update_rtl=true //designs/asap7/lfsr:lfsr_final

The release RTL is then run through the OpenROAD-flow-scripts RTL-to-GDSII flow: synthesis (Yosys) → floorplan → placement → clock tree synthesis → routing → GDSII output. Each design has per-platform configuration (clock constraints, utilization targets, pin placement) tuned for the target technology node.

Running a design in upstream ORFS (for OpenROAD researchers)

The Bazel (bazel-orfs) flow is HighTide's golden, supported entry point. But if you want to experiment with a custom OpenROAD build, modified flow Tcl scripts, or added/changed flow steps, plain OpenROAD-flow-scripts (a single config.mk + the standard Makefile) is the easier interface. Two tools bridge the gap.

One command: tools/bazel_to_orfs.sh

# Prepare a design as a portable, self-contained ORFS bundle (the default —
# does NOT run; prints instructions on how to):
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 this or any machine, no bazel, no HighTide
# checkout (needs an ORFS install with yosys + yosys-slang and an openroad):
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, through placement:
tools/bazel_to_orfs.sh --run --flow-home ~/OpenROAD-flow-scripts \
  designs/asap7/lfsr synth floorplan place

What it produces. For each design it materializes the RTL via bazel (fetching the hermetic http_archive sources / running any RTL genrules — but not synthesis), extracts the resolved config.mk, and copies every input into a self-contained, relocatable bundle:

<work-dir>/
  inputs/      every input — RTL, includes, SDC, LEF/LIB, tcl. config.mk
               references them via $(PREPARED_INPUTS), so the bundle resolves
               wherever it is copied.
  config.mk    the resolved ORFS design config
  run.sh       runs the full flow from RTL against an ORFS install

Copy the whole <work-dir> to any machine and run its run.sh — no bazel, no HighTide checkout. The bundle runs the whole flow from RTL (synth → finish), so the machine running it needs an OpenROAD-flow-scripts install whose tools/install has yosys + yosys-slang, plus an openroad. (For the pure-bazel full flow with zero setup, just bazel build //designs/<plat>/<design>:<design>_final.)

Design patterns. The 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 and printing a summary):

Pattern	Matches
designs/asap7/lfsr	one design
//designs/asap7/...	all asap7 designs
//designs/asap7/NVDLA/...	every NVDLA partition
//designs/... or all	every design, every platform
asap7 | nangate45 | sky130hd	all designs on that platform
designs/asap7/NVDLA	a container → its sub-designs

Grouped designs (NVDLA, bp_processor): these are containers — the top directory holds only shared SRAM filegroups, and each runnable design is a sub-package. Pass the sub-design path, not the container: designs/asap7/NVDLA/partition_a, designs/asap7/bp_processor/bp_uno, etc. (Pass the container and the script lists the available sub-designs.)

Prepare vs. run (--run): by default bazel_to_orfs.sh prepares only — it stages the portable bundle and prints how to run it, without running ORFS. Pass --run (with --flow-home <ORFS>) to also run the bundle locally after preparing. Either way the bundle runs the whole flow from RTL in a plain ORFS install, so you can swap in a custom openroad (--openroad / OPENROAD_EXE), edit flow/scripts/*.tcl in your ORFS checkout, or change the make targets.

QoR comparability: HighTide's published numbers come from the bazel-orfs build, which pins specific tool commits (bazel-orfs, OpenROAD, and the ORFS commit bazel_to_orfs.sh prints on --run). Running a bundle against a different ORFS / yosys shifts the baseline, and some extracted config.mk workaround variables (e.g. SKIP_CTS_REPAIR_TIMING, SETUP_MOVE_SEQUENCE, write_sdc async-reset edits) may be unnecessary or stale — review them against your ORFS.

Just the config.mk: tools/bazel_to_config_mk.sh

To drive ORFS yourself, extract an ORFS-compatible config.mk (with --abs, absolute paths that run from any directory):

tools/bazel_to_config_mk.sh --abs designs/asap7/lfsr /tmp/lfsr.config.mk
make -C OpenROAD-flow-scripts/flow DESIGN_CONFIG=/tmp/lfsr.config.mk

This costs no synthesis or place-and-route: it builds only each stage's <stage>.mk config output group (cheap bazel analysis, seconds), unions the export VAR?=VALUE lines, strips Bazel-internal vars, and adds the cquery-resolved VERILOG_FILES. (bazel_to_orfs.sh builds on this: it also materializes the RTL and copies every input into a self-contained bundle so the design runs off-machine.)

Alternative: a custom OpenROAD inside bazel-orfs (binary swap only)

If you only need a different OpenROAD binary and want to keep bazel's caching, override the openroad label instead of leaving bazel — per design via openroad = "//path/to:my_openroad" on the hightide_design()/orfs_flow() call, or globally in MODULE.bazel:

orfs = use_extension("@bazel-orfs//:extension.bzl", "orfs_repositories")
orfs.default(openroad = "@my_openroad//:openroad")

This cannot modify flow Tcl scripts (FLOW_HOME is pinned) — use the config.mk path above for flow-script or flow-step changes.

Documentation

• Quick Start Guide — install, build, and view results
• Design Catalog — all designs, platforms, variants, and complexity
• Architecture — build system, flow stages, RTL management, caching
• Adding Designs — how to add a new design to the suite
• Kubernetes Builds — building at scale on NRP Nautilus