Coriolis vlsi Backend Tools

Date: June 4, 2019
Authors: Jean-Paul Chaput
Contact: <>
Version: June 4, 2019 (jpc)

Coriolis is a set of tools for vlsi backend. It's main features are :

  • An analytic placer Etesian (based on Coloquinte).
  • A router Katana for digital designs. An extension toward mixed design is currently under development.
  • Python fast prototyping capabilities and layout procedural description.

Coriolis is a replacement of the Alliance place and route tools.

This page is only an excerpt form the Coriolis User's Guide focused on how to get and build the toolchain.

Credits & License

Hurricane Rémy Escassut & Christian Masson

Etesian Gabriel Gouvine

Stratus Sophie Belloeil

Katana (global) Damien Dupuis

Katana (detailed), Unicorn Jean-Paul Chaput

The Hurricane data-base is copyright© Bull 2000-2019 and is released under the terms of the lgpl license. All other tools are copyright© upmc 2008-2018, Sorbonne Université 2018-2019 and released under the gpl license.

Others important contributors to Coriolis are Christophe Alexandre, Roselyne Chotin, Hugo Clement, Marek Sroka and Wu Yifei.

The Katana router makes use of the Flute software, which is copyright© Chris C. N. Chu from the Iowa State University (

Complete Design Flow & Examples

While Coriolis can be used stand-alone, it is in fact part of a more complete design flow build upon Yosys and Alliance. In addition, a set of demos and examples are supplied in the repository alliance-check-toolkit.



As the sources are being released, the binary packaging is dropped. You may still find (very) old versions here: .

In a nutshell, building source consists in pulling the git repository then running the ccb installer.


The documentation is already generated and commited in the git tree. You may not install the additional prerequisites for the documentation. By default the documentation is not generated, just installed by ccb. If you really want to re-generate it, add the --doc flag to ccb.

Main building prerequisites:

  • cmake
  • C++11-capable compiler
  • BFD library (provided through binutils).
  • RapidJSON
  • python2.7
  • boost
  • libxml2
  • bzip2
  • yacc & lex
  • Qt 4 or Qt 5
  • PyQt 4 or PyQt 5
  • Qwt

Building documentation prerequisites:

  • doxygen
  • latex
  • python-docutils (for reStructuredText)

The following libraries get directly bundled with Coriolis:

For other distributions, refer to their own packaging system.

Fixed Directory Tree

In order to simplify the work of the ccb installer, the source, build and installation tree is fixed. To successfully compile Coriolis you must follow it exactly. The tree is relative to the home directory of the user building it (note ~/ or $HOME/). Only the source directory needs to be manually created by the user, all others will be automatically created either by ccb or the build system.

Sources root
under git
Architecture Dependant Build
Linux, SL 7, 64b
Linux, SL 6, 32b
Linux, SL 6, 64b
Linux, Fedora, 64b
Linux, Fedora, 32b
FreeBSD 8, 32b
FreeBSD 8, 64b
Windows 7, 32b
Windows 7, 64b
Windows 8.x, 32b
Windows 8.x, 64b
Architecture Dependant Install
Linux, SL 6, 32b ~/coriolis-2.x/Linux.slsoc6x/Release.Shared/install/
FHS Compliant Structure under Install
Libraries (Python)
Include by tool
Configuration files
Doc, by tool


Alternate build types: the Release.Shared means an optimized build with shared libraries. But there are also available Static instead of Shared and Debug instead of Release and any combination of them.

Static does not work because I don't know yet to mix statically linked binaries and Python modules (which must be dynamic).

Building Coriolis

The actively developed branch

The devel_anabatic branch is now closed and we go back to a more classical scheme where master is the stable version and devel the development one.

The Coriolis git repository is


Again, the devel_anabatic branch is now closed. Please revert to devel or master.


As it is now possible to mix PyQt widget with Coriolis ones, it is simpler for us to revert to qt 4 only. Our reference os being rhel 7, there is no compatible PyQt5 build compatible with their qt 5 version (we fall short of one minor, they provides qt 5.9 were we need at least qt 5.10).


Under rhel 7 or clones, they upgraded their version of qt 4 (from 4.6 to 4.8) so the diagonal line bug no longer occurs. So we can safely use the default system qt again.

Installing on RedHat or compatible distributions

  1. Install or check that the required prerequisites are installed :

    dummy@lepka:~> yum install -y git cmake bison flex gcc-c++ libstdc++-devel  \
                                  binutils-devel                                \
                                  boost-devel boost-python boost-filesystem     \
                                  boost-regex  boost-wave                       \
                                  python-devel libxml2-devel bzip2-devel        \
                                  qt-devel qwt-devel                            # Qt 4

    Note, that the Qwt packages are directly available from the standart distribution when using qt 4.

  2. Install the unpackaged prerequisites. Currently, only RapidJSON.

    dummy@lepka:~> mkdir -p ~/coriolis-2.x/src/support
    dummy@lepka:support> cd ~/coriolis-2.x/src/support
    dummy@lepka:support> git clone
  3. Create the source directory and pull the git repository:

    dummy@lepka:~> mkdir -p ~/coriolis-2.x/src
    dummy@lepka:src> cd ~/coriolis-2.x/src
    dummy@lepka:src> git clone
  4. Build & install:

    dummy@lepka:src> cd coriolis
    dummy@lepka:coriolis> git checkout devel
    dummy@lepka:coriolis> ./bootstrap/ --project=support  \
                                             --project=coriolis \
                                             --make="-j4 install"


Pre-generated documentation will get installed by the previous command. Only if you did made modifications to it you need to regenerate it with:

dummy@lepka:coriolis> ./bootstrap/ --project=support  \
                                         --project=coriolis \
                                         --doc --make="-j1 install"

We need to perform a separate installation of the documentation because it does not support to be generated with a parallel build. So we compile & install in a first stage in -j4 (or whatever) then we generate the documentation in -j1

Under rhel6 or clones, you must build using the devtoolset, the version is to be given as argument:

dummy@lepka:coriolis> ./bootstrap/ --project=coriolis \
                                         --devtoolset=8 --make="-j4 install"

If you want to use Qt 5 instead of Qt 4, modify the previous steps as follows:

  • At step 1, do not install the qt 4 related development package (qt4-devel), but instead:

    dummy@lepka:~> yum install -y qt5-qtbase-devel qt5-qtsvg-devel              # Qt 5.

    The package qwt-qt5-devel and it's dependency qwt-qt5 are not provided by any standard repository (like epel). You may download them from the LIP6 Addons Repository Then run:

    dummy@lepka:~> yum localinstall -y qwt-qt5-6.1.2-4.fc23.x86_64.rpm  \
                                       qwt-qt5-6.1.2-4.fc23.x86_64.rpm  # Qwt for Qt 5.
  • At step 4, add a --qt5 argument to the command line.

  • The Python scripts that make use of PyQt in crlcore and cumulus must be edited to import PyQt5 instead of PtQt4 (should find a way to automatically switch between the two of them).

The complete list of ccb functionalities can be accessed with the --help argument. It also may be run in graphical mode (--gui).

Building a Debug Enabled Version

The Release.Shared default version of the Coriolis is built stripped of symbols and optimized so that it makes analysing a core dump after a crash difficult. In the (unlikely) case of a crash, you may want to build, alongside the optimized version, a debug one which allows forensic examination by gdb (or valgrind or whatever).

Run again, adding the --debug argument:

dummy@lepka:coriolis> ./bootstrap/ --project=support  \
                                         --project=coriolis \
                                         --make="-j4 install" --debug

As cgt is a Python script, the right command to run gdb is:

dummy@lepka:work> gdb python core.XXXX

Installing on Debian 9, Ubuntu 18 or compatible distributions

First, install or check that the required prerequisites are installed :

dummy@lepka:~> sudo apt install -y build-essential binutils-dev                     \
                                   git cmake bison flex gcc python-dev              \
                                   libboost-all-dev libboost-python-dev             \
                                   libbz2-dev libxml2-dev rapidjson-dev libbz2-dev  \
                                   qt4-dev-tools libqwt5-qt4-dev                    \ # Qt 4
                                   qtbase5-dev libqt5svg5-dev libqwt-qt5-dev        \ # Qt 5
                                   doxygen dvipng graphviz python-sphinx            \
                                   texlive-fonts-extra texlive-lang-french

Second step is to create the source directory and pull the git repository:

dummy@lepka:~> mkdir -p ~/coriolis-2.x/src
dummy@lepka:src> cd ~/coriolis-2.x/src
dummy@lepka:src> git clone

Third and final step, build & install:

dummy@lepka:src> cd coriolis
dummy@lepka:coriolis> git checkout devel
dummy@lepka:coriolis> ./bootstrap/ --project=coriolis \
                                         --make="-j4 install"

Additionnal Requirement under MacOS

Coriolis makes use of the boost::python module, but the MacPorts boost seems unable to work with the Python bundled with MacOS. So you have to install both of them from MacPorts:

dummy@macos:~> port install boost +python27
dummy@macos:~> port select python python27
dummy@macos:-> export DYLD_FRAMEWORK_PATH=/opt/local/Library/Frameworks

The last two lines tell MacOS to use the Python from MacPorts and not from the system.

Then proceed with the generic install instructions.

Packaging Coriolis

Packager should not use ccb, instead bootstrap/Makefile.package is provided to emulate a top-level autotool makefile. Just copy it in the root of the Coriolis git repository (~/corriolis-2.x/src/coriolis/) and build.

Sligthly outdated packaging configuration files can also be found under bootstrap/:

  • bootstrap/ for rpm based distributions.
  • bootstrap/debian for Debian based distributions.

Hooking up into Alliance

Coriolis relies on Alliance for the cell libraries. So after installing or packaging, you must configure it so that it can found those libraries.

The easiest way is to setup the Alliance environment (i.e. sourcing .../etc/profile.d/alc_env.{sh,csh}) before setting up Coriolis environment (see the next section). To understand how Coriolis find/setup Alliance you may have look to the Alliance Helper.

Setting up the Environment (

To simplify the tedious task of configuring your environment, a helper is provided in the bootstrap source directory (also installed in the directory .../install/etc/coriolis2/) :


Use it like this:

dummy@lepka:~> eval `~/coriolis-2.x/src/coriolis/bootstrap/`


Do not call that script in your environement initialisation. When used under rhel6 or clones, it needs to be run in the devtoolset environement. The script then launch a new shell, which may cause an infinite loop if it's called again in, say ~/.bashrc.

Instead you may want to create an alias:

alias c2r='eval "`~/coriolis-2.x/src/coriolis/bootstrap/`"'