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/run_orfs.sh

# Fast, zero-setup: reuse the golden synthesized netlist + bazel openroad,
# full place-and-route:
tools/run_orfs.sh designs/asap7/lfsr

# Your own OpenROAD build, only through placement:
tools/run_orfs.sh --openroad ~/OpenROAD/build/src/openroad \
                  designs/asap7/lfsr floorplan place

# Re-synthesize from RTL in your own ORFS install (its yosys + slang):
tools/run_orfs.sh --resynth --flow-home ~/OpenROAD-flow-scripts designs/asap7/lfsr

# Batch: run (or prepare) many designs with a bazel-style pattern. Stage
# every asap7 design without running, then run one later / on another
# machine — no bazel needed at run time:
tools/run_orfs.sh --prepare-only //designs/asap7/...
OPENROAD_EXE=~/OpenROAD/build/src/openroad .run_orfs/asap7/lfsr/run.sh

Design patterns. The target can be one design or a bazel-style pattern that expands to many (the flow runs once per design, 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 (--prepare-only): by default run_orfs.sh prepares and runs. With --prepare-only it stops after staging the work dir (config.mk + the seeded golden netlist) and writes a self-contained run.sh there — so you can prep a batch of designs in one loop, then run each run.sh whenever/wherever you like. run.sh needs no bazel and lets you override OPENROAD_EXE, FLOW_HOME, or the make targets at run time.

It extracts the design's resolved config.mk and runs the standard ORFS Makefile. There are two synthesis modes:

• Default (reuse synth): reuses the synthesized netlist bazel-orfs already produced (results/.../1_synth.{odb,sdc}) and runs only floorplan onward. Fast and zero-setup — no yosys/slang needed — and runs against the ORFS bazel-orfs already resolved. Best for iterating on placement, routing, or the OpenROAD binary (--openroad sets OPENROAD_EXE). The netlist already reflects your constraints/RTL if you rebuild through bazel; to re-synthesize entirely in plain ORFS, use --resynth.
• --resynth (from RTL): runs the whole flow including synthesis in your ORFS install, using its own yosys + yosys-slang. Honors changes to constraints, RTL, or the synthesis flow itself — but slower, and requires --flow-home pointing at a built OpenROAD-flow-scripts install (one whose tools/install has yosys; ORFS's slang support is built in).

To edit flow scripts or steps, point --flow-home at your own ORFS checkout and edit flow/scripts/*.tcl there.

QoR comparability: HighTide's published numbers come from the bazel-orfs build, which pins specific tool commits (bazel-orfs, OpenROAD, and the ORFS commit run_orfs.sh prints). A --resynth run 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. (run_orfs.sh's default reuse-synth mode additionally builds just the _synth stage to get the netlist; --resynth re-synthesizes in your ORFS install and needs no bazel flow build at all.)

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