When setting up a modern RTL-to-GDSII flow, the standard advice is usually: “Just use Docker.” But what happens when Docker isn’t an option? Whether you are dealing with CPU Instruction Set Architecture (ISA) compatibility issues, or you simply want the raw, unthrottled performance of your machine’s RAM and CPU, building your EDA tools natively is the ultimate solution.

At LogIC SoC, we needed a robust physical design environment on a standard Windows laptop (Intel i5-10210U). We bypassed Docker completely, encountered the classic “dependency hell” of compiling massive open-source tools, and solved every C++ error along the way.

Here is your ultimate guide to compiling the OpenROAD stack from scratch, including fixes for the notorious <span and std::bit_cast fatal errors.

Phase 1: The Foundation – Ubuntu WSL2 on Windows

Before we compile Linux tools, we need a Linux environment. The Windows Subsystem for Linux (WSL2) is perfect for this because it provides a near-native Linux kernel without the overhead of a virtual machine. Make sure your system has at least 16GB of RAM and plenty of free space.

Open PowerShell as an Administrator and run:

PowerShell

wsl --install

Restart your computer, launch Ubuntu from the Start Menu, and create your UNIX credentials.

Phase 2: Fetching the OpenROAD Engine & Dependencies

OpenROAD is the heart of the modern open-source Place and Route flow. First, clone the massive repository with all its submodules directly from the official OpenROAD GitHub repository.

Bash

git clone --recursive https://github.com/The-OpenROAD-Project/OpenROAD.git
cd OpenROAD

Solving the Dependency Installer Trap

If you run the standard ./etc/DependencyInstaller.sh, you will likely get an error stating: [ERROR] You must use one of: -all, -base, or -common.

Because we are building a complete design house setup, we need the whole stack—including libraries for timing analysis (OpenSTA) and logic optimization (ABC). You must pass the -all flag.

Bash

sudo ./etc/DependencyInstaller.sh -all

Phase 3: The Build Process & Fixing CMake Errors

Once dependencies are installed, create a build directory and use CMake to generate the blueprints.

Bash

mkdir build &amp;&amp; cd build

Error 1: CMake Boost Version Mismatch

When running cmake .., you might encounter a red error: Could not find a configuration file for package "boost_iostreams" that exactly matches requested version "1.87.0".

This happens because OR-Tools is hardcoded to look for Boost 1.87.0, but your system likely downloaded a newer version (like 1.89.0). We have to force CMake to ignore strict version checking.

**

Bash

rm -rf *
cmake .. -DBoost_NO_BOOST_CMAKE=ON -DBOOST_ROOT=/usr/local

Phase 4: Fixing C++20 Fatal Errors (<span and std::bit_cast)

With CMake configured, start the compilation using your CPU cores (e.g., make -j4). This is where the real engineering starts.

Error 2: fatal error: span: No such file or directory

Around 51%, the build may crash with a missing <span header. The OpenROAD project moves fast, and its code requires a modern compiler. The default compiler in Ubuntu 20.04 (GCC 9) is simply too old to understand C++20 vocabulary.

Error 3: error: ‘bit_cast’ is not a member of ‘std’

Even if you upgrade to GCC 10, you will hit another wall around 7% when building the OpenSTA timing engine. std::bit_cast is an advanced memory feature requiring strict C++20 support. We need the gold standard: GCC 11, and we must explicitly force CMake to use the C++20 standard.

The Ultimate Compiler Fix

To solve both of these modern C++ errors, run this exact sequence to upgrade your compiler to GCC 11 and force the build configuration:

Bash

# 1. Upgrade to GCC 11
sudo apt update
sudo apt install -y gcc-11 g++-11
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 110 --slave /usr/bin/g++ g++ /usr/bin/g++-11

# 2. Re-configure CMake with explicit compiler paths and C++20 standard
rm -rf *
cmake .. \
  -DCMAKE_C_COMPILER=gcc-11 \
  -DCMAKE_CXX_COMPILER=g++-11 \
  -DCMAKE_CXX_STANDARD=20 \
  -DBoost_NO_BOOST_CMAKE=ON \
  -DBOOST_ROOT=/usr/local

# 3. Compile!
make -j4

(Note: At 99%, the compiler will seemingly “freeze” for a few minutes. This is the Linking phase where it glues all the modules together. Do not cancel it! Once it hits 100%, run sudo make install).

Phase 5: Completing the VLSI Stack (The Eyes and Judges)

A complete physical design lab needs layout viewers and verification tools. You can install these globally in a separate terminal tab while OpenROAD is compiling:

Bash

sudo apt update &amp;&amp; sudo apt install -y magic klayout netgen iverilog gtkwave
  • Magic & KLayout: The “Eyes” for viewing physical GDSII silicon layers.
  • Netgen: The LVS “Judge” to ensure your layout matches your schematic.
  • Iverilog & GTKWave: For digital logic simulation before synthesis.

Phase 6: Launching the Graphical Interface (The Ultimate Test)

Once you successfully compile OpenROAD natively and run the sudo make install command, it is time to prove that your new physical design lab is fully operational. Because WSL2 natively supports Linux GUI apps (via WSLg), you can project the OpenROAD canvas directly onto your Windows desktop.

In your terminal, simply type:

Bash

openroad -gui

If your build was successful, a separate graphical window will launch, presenting you with the OpenROAD layout canvas, layer controls, and the Tcl scripting console. You now have a fully-featured, native physical design environment running at bare-metal speeds, ready to ingest Verilog and standard cell libraries!

Conclusion

By understanding the relationship between compiler versions (GCC 11), C++ standards (C++20), and build systems (CMake), you aren’t just installing software—you are engineering your environment. You have now successfully bypassed Docker and compiled one of the world’s most advanced open-source EDA engines directly onto your hardware.

Welcome to native physical design at LogIC SoC.

Watch the Video Demo

Want to see this entire process in action? Watch the YouTube video below for a complete, step-by-step demonstration of setting up this OpenROAD physical design lab natively on Windows. Be sure to subscribe to the LogIC SoC YouTube Channel for more advanced VLSI tutorials.

(Video coming soon!)