Open-source project
The-OpenROAD-Project/OpenROAD avatar
The-OpenROAD-Project/OpenROAD

OpenROAD: one beta release tag and six hundred tapeouts

OpenROAD's unified application implementing an RTL-to-GDS Flow. Documentation at https://openroad.readthedocs.io/en/latest/

3,293 stars1,086 forksVerilogBSD-3-Clause

At a glance

What is it?
An open-source application that takes a design from RTL to GDS with no human in the loop, driven from Tcl or Python. What makes the repository interesting is the mismatch between how it is versioned and how it is actually distributed.
Who is it for?
OpenROAD is a serious choice for anyone doing open digital physical design, and the proof points are specific rather than promotional: an autonomous flow, four open PDKs, and hundreds of tapeouts on two of them. Two things to weigh before starting.
Can I use it commercially?
Yes. BSD-3-Clause is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly Verilog, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • The-OpenROAD-Project/OpenROAD3,293 ★ · +168
Star history
Repository2026-09-242026-11-15
The-OpenROAD-Project/OpenROAD3.1k3.3k

168 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The only release tag is a beta from 2020

Versioning is the first surprise. The repository lists one release, v0.9.0-beta, tagged on 2020-07-06, while the most recent push to the master branch is dated 2026-10-03 and the project is not archived. There is no contradiction in the code, only in the expectation: this is an application you build, and the flow around it is what gets versioned. Two separate things are distributed under the OpenROAD name. The application here is the engine, and OpenROAD-flow-scripts is described as a native, ready-to-use prototyping and tapeout flow built on it, with its own documentation. The project is explicit that the application is not limited to that flow, since it also enables custom flow controllers built on the underlying tools, database, and analysis engines. The licence is BSD 3-Clause, which is one of the more permissive terms in hardware tooling.

Twenty-four hours from RTL to GDS with nobody watching

The flow's defining property is autonomy. It is described as an Autonomous, No-Human-In-Loop flow with a twenty-four hour turnaround from RTL to GDSII, aimed at rapid design exploration as well as physical implementation. The flow scripts extend that idea for design space exploration and early prediction of quality of results, while still allowing manual intervention at individual stages through Tcl commands and Python APIs. That combination is the point: the automation gives a reproducible baseline, and the API lets a designer take over one stage without abandoning the rest. The application exposes flexible flow control through an API with bindings in Tcl and Python, which is why the repository carries a Tcl linting configuration alongside Python tooling and Bazel and CMake build files. The synthesis step in the documented timeline runs through Yosys and takes RTL, SDC, library, and LEF files as input.

Eight stages, and the last one is signoff

The physical implementation stages are listed in order and each one has a defined job. Floorplanning covers initialisation of the chip area and utilisation, IO pin placement for designs without pads, tap cell and well tie insertion, and power distribution network creation. Global placement handles macro placement for RAMs and embedded macros, standard cell placement, and automatic optimisation and repair for maximum slew, maximum capacitance, maximum fanout, and long wires. Detailed placement legalises the result onto the grid and adds incremental timing analysis for early estimates. Then come clock tree synthesis, which inserts buffers and resizes for high fanout nets, and setup and hold timing optimisation.

Routing is split the same way. Global routing performs antenna repair and creates routing guides; detailed routing legalises routes and produces DRC-correct routing against timing and power constraints. Chip finishing closes the flow: parasitic extraction with OpenRCX, final timing verification, final physical verification, dummy metal fill for manufacturability, and a DRC signoff step that uses KLayout or Magic on the generated GDS.

Four open PDKs, and the process nodes you want are NDA-bound

The application is described as PDK independent, with the caveat that it has been tested and validated against specific kits in the context of various flow controllers. The open set is four: GF180 at 180nm, SKY130 at 130nm, Nangate45 at 45nm, and ASAP7 as a predictive FinFET 7nm kit. The proprietary list is where a commercial project hits a wall: GF55, GF12, Intel22, Intel16, and TSMC65 are supported in the flow scripts only, they exist to test and calibrate the tool against commercial platforms, and the kits cannot be provided because of NDA restrictions. The stated workaround is that anyone with independent access to those platforms can create the platform-specific files themselves. OpenLane, a separate project, supports SkyWater 130nm and GlobalFoundries 180nm.

The dev image installs dependencies three times over

The container file is where the build requirements become concrete, and it is worth reading because the reasons are in the comments.

dockerfile
ARG fromImage=ubuntu:24.04
ARG devImage=dev

FROM $fromImage AS dev

ENV DEBIAN_FRONTEND=noninteractive
ENV TZ=America/Los_Angeles
ENV LANG=C.UTF-8
ENV LC_ALL=C.UTF-8

A single script, etc/DependencyInstaller.sh, is invoked in sequence: once for the base set, once for Bazel, and once for the common set with a saved list of dependency prefixes written to /etc/openroad_deps_prefixes.txt, which lets a later stage reuse them instead of reinstalling. The Bazel pass is not optional because the same dev image serves both build systems, and the comment records a specific breakage it fixes: on newer Ubuntu the prebuilt LLVM lld cannot load without a libxml2 compatibility symlink. On Ubuntu bases the file also strips the ABI tag section from libQt5Core.so, and skips that step otherwise. The builder stage inherits the dev image and takes a thread count argument.

Four build systems and three assistant config directories

The root listing shows a project that has grown rather than been rewritten. Build definitions come in several flavours: Bazel with a version file, an ignore list, a module lock file, and its own directory, alongside a top-level CMakeLists.txt with a graph visualisation option, a CMake directory, a Nix flake with a lock file, and a Jenkinsfile with a matching jenkins directory. Documentation has its own tooling in a Doxyfile and a Read the Docs configuration, while formatting and linting are split across a .clang-format, a .clang-tidy, a .scalafmt configuration, a tclint configuration, a yamlfix pair, and a Python configuration.

toml
[tool.black]
extend-exclude = '''
^/third-party/
'''
force-exclude = '''
^/third-party/
'''

That Python file exists only to keep the formatter out of vendored code, and the fact that a Scala formatter is configured at all hints at components written in more than one language. Three directories hold assistant configuration, alongside a script named claude.sh and an AGENTS.md, which is a recent addition to an otherwise conventional C and Verilog codebase.

Six hundred tapeouts, mostly on the two open kits

The adoption claim is specific rather than rhetorical. The flow has been used in over six hundred silicon-ready tapeouts for technologies up to 12nm, and the tapeout section narrows that: over six hundred tapeouts in SKY130 and GF180 through the Google-sponsored Efabless multi-project wafer shuttle, which also runs GlobalFoundries shuttles, design contests, and design workshops. A separate set of users is named, and it is a list of projects rather than vague praise: OpenROAD-flow-scripts, OpenLane from Efabless, Silicon Compiler from Zero ASIC, Hammer from UC Berkeley, and OpenFASoC from IDEA-FASoC for mixed-signal flows. The stated user community spans hardware designers, software engineers, industry collaborators, students, and researchers, and the project links its education work to training content and courses at universities.

Editorial conclusion

OpenROAD is a serious choice for anyone doing open digital physical design, and the proof points are specific rather than promotional: an autonomous flow, four open PDKs, and hundreds of tapeouts on two of them. Two things to weigh before starting. Read the PDK section carefully, because the process kits people actually use at 22nm and below are only supported in the separate flow-scripts repository and cannot be redistributed. And do not look for release tags to pin, since the single tag in this repository is a beta from 2020 while development continues on master.

Frequently asked questions

What is the OpenROAD software used for?

It is an open-source application for semiconductor digital design that implements an RTL-to-GDS flow, delivering an autonomous, no-human-in-loop flow with a stated twenty-four hour turnaround. It exposes flow control through an API with Tcl and Python bindings.

Which PDKs does OpenROAD support?

Four open ones are named: GF180, SKY130, Nangate45, and ASAP7. The proprietary kits GF55, GF12, Intel22, Intel16, and TSMC65 are supported in the flow scripts only and cannot be provided because of NDA restrictions, so users with independent platform access have to create the platform-specific files themselves.

What are the main stages of the OpenROAD flow?

Floorplanning, global placement, detailed placement, clock tree synthesis, setup and hold timing optimisation, global routing, detailed routing, and chip finishing, which covers parasitic extraction with OpenRCX, final timing and physical verification, dummy metal fill, and DRC signoff using KLayout or Magic on the generated GDS.

How do I set up the dependencies to build OpenROAD?

The container build uses a dependency installer script from the etc directory and runs it three times: a base pass, a Bazel pass that adds bazelisk plus libxml2 and X11/xcb runtime libraries, and a common pass that saves the dependency prefixes for later stages. The base image defaults to ubuntu:24.04.

Official sources

  1. License: BSD-3-Clause
  2. Project website
  3. README
  4. Releases
  5. The-OpenROAD-Project/OpenROAD on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/the-openroad-project-openroad.svg)](https://hysenlabs.com/projects/the-openroad-project-openroad)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/the-openroad-project-openroad.svg)](https://hysenlabs.com/projects/the-openroad-project-openroad)

Was this useful?