Building ROOT from source

ROOT 6 uses a build system based on CMake. The build process consists of three steps:

  1. Running cmake with the desired configuration arguments in a "build directory," which is separate form the source directory
  2. Executing make to build the package
  3. Doing make install to copy the relevant subset of sources and generated binaries to the installation directory

Step 1. is the most difficult one since one has to pick appropriate configuration options, of which ROOT has many. A description of most options can be found on the relevant documentation page, but be warned that not everything is documented there and that the documentation may even be incorrect/outdated sometimes.

Let us walk through a typical build process:

  1. Make sure that your system compiler is at least gcc 4.8. It needs to support C++11 fully. If you do not have such a compiler, you should upgrade your system, unless you have a lot of patience and skill. On rpm-based Linux distributions, the gcc-c++ and libstdc++ packages need to be installed. To determine your compiler version, do
    $ g++ --version
    g++ (GCC) 4.8.5 20150623 (Red Hat 4.8.5-28)
  2. Verify that you have at least CMake version 3.4.3. On some systems, this command may be called cmake3. On RHEL7/CentOS 7, cmake3 is available from EPEL.
    $ cmake --version
    cmake version 3.11.1
  3. Download the ROOT source tarball from the download page. Always pick the latest production ("pro") version; it should work even on old platforms.
  4. Unpack the source distribution wherever you like. This will create a subdirectory named "root-<version>".
    $ tar xf root_v6.12.06.source.tar.gz
    $ ls
  5. Create and switch to the build directory, for example
    $ mkdir -p ~/Develop/BUILD/root
    $ cd ~/Develop/BUILD/root
  6. Now prepare to run cmake to configure ROOT. This step will automatically detect if required dependencies are available. The most important dependencies are bundled with ROOT and are built automatically if they are not detected on the host system. Other dependencies are optional; if not found, the corresponding feature in ROOT is automatically disabled. (Example: MySQL database support.) You will get a functional version of ROOT even without these optional dependencies, so it is not essential to provide them. Getting them installed is best done through your system's package manager. Some obscure dependencies need to be build by hand from source first, which can be very time-consuming. The default CMake configuration settings are usually sufficent, so the main item to decide on is the installation path:
    $ cmake -DCMAKE_INSTALL_PREFIX=<path-to-where-you-want-ROOT-to-be-installed> <path-to-unpacked-ROOT-source>

    This will run for a minute or two, searching for available libraries on your system.
  7. Once done, start building ROOT as follows:
    $ cmake --build . -- -jN

    where you should replace "N" with the number of CPU cores in your system. Now go have a coffee … the compilation may take anywhere from 15 minutes to several hours.
  8. Hopefully, the build process completes without error. If not, there could be many reasons why things failed. If it appears that some library was not found or not properly recognized, try turning the corresponding feature off and go back to step 6. If the error appears obscure to you, ask an expert, for example on the ROOT forum.
  9. Once you manage to build ROOT without error, congratulations. Now install it in your chosen destination directory (the CMAKE_INSTALL_PREFIX you indicated in the configuration step):
    $ cmake --build . --target install

    Then run the setup script form the installation location and test ROOT, as described in Testing the installation.

Updated by Ole Hansen about 6 years ago · 6 revisions