Coriolis vlsi Backend Tools

Date: March 19, 2019
Authors: Jean-Paul Chaput
Contact: <>
Version: March 19, 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

Knik Damien Dupuis

Kite, 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, 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 (



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

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


The documenation 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
  • RapidJSON
  • python2.7
  • boost
  • libxml2
  • bzip2
  • yacc & lex
  • Qt 4 or Qt 5

Building documentation prerequisites:

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

The following libraries gets directly bundled with Coriolis:

For other distributions, refer to their own packaging system.

Fixed Directory Tree

In order to simplificate 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 (noted ~/ 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 do 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

For an intermediary period, the branch under active development you must use is devel_anabatic

dummy@lepka:coriolis> git checkout devel_anabatic

Installing on RedHat or compatible distributions

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

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

Second step is to 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

The Third 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

Fourth and final step, build & install:

dummy@lepka:src> cd coriolis
dummy@lepka:coriolis> ./bootstrap/ --project=support  \
                                         --project=coriolis \
                                         --qt5              \
                                         --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 do 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 uses Qt 5 instead of Qt 4, you may add the --qt5 argument.

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

Building the Devel Branch

In the Coriolis git repository, two branches are present:

  • The master branch, which contains the latest stable version. This is the one used by default if you follow the above instructions.

  • The devel branch, which obviously contains the latest commits from the development team. To use it instead of the master one, do the following command just after the first step:

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

    Be aware that it may requires newer versions of the dependencies and may introduce incompatibilites with the stable version.

    In the (unlikely) event of a crash of cgt, as it is a Python script, the right command to run gdb on it 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 installeds :

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 libqwt-qt5-dev                       \ # Qt 4
                                   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> ./bootstrap/ --project=coriolis \
                                         --qt5              \
                                         --make="-j4 install"

Additionnal Requirement under MacOS

Coriolis make uses 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 uses 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 outaded 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/`"'