Getting started » Downloading and building

Basic system requirements

Operating sytem

Atlas requires a POSIX compliant operating system. This includes:

  • Linux
  • MacOSX (Darwin)


Atlas requires a C++ compiler that supports the C++11 standard. The optional Atlas Fortran API requires a Fortran compiler that supports the Fortran 2008 standard.

Tested compilers include:

  • GNU 6.3, 7.3, 8.3
  • Intel 18, 19
  • PGI 17.7, 19.10
  • Cray 8.7
  • Clang C++ 7, 9 + GNU Fortran


  • Minimum required version: 3.6 or greater
  • Recommended version: 3.14 or greater

CMake is often already available on your system. If version requirements are incompatible, prebuilt CMake binary distribution may be downloaded here


Atlas is distributed as Git repository and is officially maintained at the ECMWF github space. It however relies on several dependencies to be pre-installed. Following figure illustrates how the dependencies interconnect. Below are links to each of them, with installation instructions.

Image alt text
Dependency graph of Atlas
  • Solid lines: required dependency
  • Dotted lines: optional dependency, enabling features detailed in green
  • Yellow boxes are required (fckit is required for Fortran interface)
  • The package transi (cyan colored) is currently not open-source
  • The packages on the right (white) are third party (non-ECMWF) open-sourced

Atlas aims to stay compatible with latest versions of dependencies (as of Atlas release date), and hence latest versions of dependencies are recommended. Please contact us if in doubt.

Required dependencies

For C++ API of Atlas:

  • C++ compiler: C++11 standard support required
  • CMake: Build system (meta-build system) used to compile Atlas
  • ecbuild: It implements some CMake macros that are used within the Atlas build system. For more brief information and to install, check the ecbuild installation instructions
  • eckit: It implements some useful C++ functionalities useful for Atlas. For more brief information and to install, check the eckit installation instructions

For Fortran API of Atlas, additional required dependencies:

  • Fortran compiler: Fortran 2008 standard support required.
  • fckit : It implements some useful Fortran functionalities. This is only needed when Fortran bindings are required. For more brief information and to install, check the fckit installation instructions
  • Python : Required to generate Fortran interfaces

Optional dependencies

  • MPI: Required for distributed memory parallelisation.
  • OpenMP: Required for shared memory parallelisation. For use see. As OpenMP is implemented within compilers, it is not possible to install it yourself.
  • CGAL: Required for enabling tesselation using Delaunay triangulation of unstructured grids.
  • Eigen3 : Linear algebra library that should not impact any Atlas internal performance.
  • FFTW – FFT library that improves efficiency of inverse spherical harmonics transforms (TransLocal). (Version 3.3.4 minimum required)
  • BLAS / LAPACK – Linear Algebra libraries that improve efficiency of inverse spherical harmonics transforms (TransLocal). This library is typically available on the system, and preferred implementation is available within Intels MKL library.
  • transi – For enabling IFS spherical harmonics transforms (TransIFS). This exposes an MPI parallel implementation for both direct and inverse spherical harmonics transforms. Note that transi is currently not open-source and requires a license agreement with ECMWF! For more brief information and to install, check the transi installation instructions
  • GridTools – For enabling GPU capability using CUDA in C++ or OpenACC in Fortran (compiler permitting).
  • Proj – For enabling Proj4 projections for grids. This is allows for projections that are not natively supported in Atlas.

Installation Instructions

Before building, make sure all Required dependencies are available, as well as the required Optional dependencies for the desired Optional features detailed below.

Once we have downloaded, compiled and installed required dependencies, we can now proceed to download and install.

Downloading Atlas

atlas is officially maintained and available from its ECMWF github page.

The master branch tracks the latest stable release, whereas the develop branch tracks the latest developments.

To download the project at the latest release we can type on the terminal the commands reported below:

git clone -b master

Building Atlas

The atlas build system is based on CMake which tries to automatically detect compilers and project dependencies. To avoid suprises make sure that the following environment variables are pointing to the correct compiler.

  • CC – Path to C compiler
  • CXX – Path to C++ compiler
  • Fortran – Path to Fortran compiler

Other environment variables which may help CMake (version greater than 3.12) in finding required and optional dependencies for Atlas:

  • ecbuild_ROOT – Path to ecbuild install prefix
  • eckit_ROOT – Path to eckit install prefix
  • fckit_ROOT – Path to fckit install prefix
  • transi_ROOT – Path to transi install prefix
  • GridTools_ROOT – Path to GridTools install prefix
  • CGAL_ROOT – Path to CGAL install prefix
  • FFTW_ROOT – Path to FFTW install prefix
  • PROJ4_ROOT – Path to Proj install prefix
  • Eigen3_ROOT – Path to Eigen install prefix

atlas can be configured and installed as follows, to a given path-to-install as shown below:

cd atlas
mkdir build && cd build
cmake ../ -DCMAKE_INSTALL_PREFIX=<path-to-install>
make -j8

The number 8 in the argument -j8 to make speeds up compilation by using 8 threads. This number can be tuned to maximise compilation speed.

Optional features


This feature enables the compilation of the Atlas Fortran interface and is ON by default. It requires availability of the package fckit and a python executable. If not available, this feature will be disabled automatically.


This feature enables the capability of Atlas to have parallel distributed data structures and algorithms. It requires the availability of MPI.


This feature enables the capability of OpenMP shared memory parallelism for algorithms within Atlas and is ON by default, but depends on the OpenMP implementation within the compilers.


This feature, ON by default, enables the Delaunay mesh generator, which allows to generate a mesh by tesselating an unstructured grid using Delaunay triangulation. It requires the availability of the CGAL optional dependency.


With this feature enabled, the underlying data memory storage is handled by GridTools. It therefore depends on the availability of GridTools. When GridTools is compiled with CUDA available, then the Atlas arrays are allocated both on the host (CPU) and device (GPU). It is then possible to use atlas fields within CUDA kernels, and OpenACC.


This feature allows the use of OpenACC, provided that the feature GRIDTOOLS_STORAGE is also enabled. It is ON by default, but depends on the OpenACC implementation within the compilers.


This feature, ON by default, enables the TransIFS spectral transforms capability. It allows to perform direct and inverse spectral transforms in an MPI distributed parallel context. The scope is limited only to global (Reduced) Gaussian grids! It requires the availability of the transi optional dependency, which requires private access permissions at ECMWF, as it is not open-source.


This feature, OFF by default grid projections defined by Proj, and relies on the package Proj to be available.


This feature enables the compilation of Atlas unit tests.

Testing Atlas

The Atlas tests are managed by ctest which is bundled with the CMake software. To launch the tests, navigate to the build directory and execute

ctest --output-on-failure

To run only tests matching a certain regular expression, execute

ctest --output-on-failure -R <regex>

To get output from tests that pass, execute

Installing Atlas

To install atlas, navigate to the build directory, and simply execute

make install

Inspecting the Atlas installation

Once installation of atlas is complete, an executable called atlas can be found within the Atlas install directory. Executing

export PATH=$atlas_ROOT/bin:$PATH
atlas --version
atlas --git
atlas --info
atlas version (0.20.0), git-sha1 c18afe1

    build type      : RelWithDebInfo
    timestamp       : 20200226173051
    op. system      : Linux-4.4.140-62-default (linux.64)
    processor       : x86_64
    c compiler      : GNU 7.3.0
      flags         :  -pipe -O2 -g -DNDEBUG
    c++ compiler    : GNU 7.3.0
      flags         :  -pipe -O2 -g -DNDEBUG
    fortran compiler: GNU 7.3.0
      flags         :  -O2 -g -DNDEBUG

    Fortran        : ON
    MPI            : ON
    OpenMP         : ON
    BoundsChecking : OFF
    Init_sNaN      : OFF
    Trans          : ON
    FFTW           : ON
    Eigen          : OFF
    MKL            : OFF
    Tesselation    : OFF
    ArrayDataStore : Native
    idx_t          : 32 bit integer
    gidx_t         : 64 bit integer

    eckit version (1.4.7),  git-sha1 566091e
    fckit version (0.6.6),  git-sha1 592f58b
    transi version (0.7.0), git-sha1 588e46f
    trans version (transi/contrib - CY46R1), git-sha1 588e46f

returns information respectively on:

  • the version,
  • a more detailed git-version-controlled identifier
  • a more complete view on all the features that Atlas has been compiled with, as well as compiler and compile flag information.
    Also printed is the versions of used dependencies such as eckit and transi.

Note that the output may vary in your case depending on features and versions.