GPAW relies on the Python library atomic simulation environment (ASE), so you need to install ASE first. GPAW itself is written mostly in the Python programming language, but there are also some C-code used for:

  • performance critical parts

  • allowing Python to talk to external numerical libraries (BLAS, LibXC, MPI and ScaLAPACK)

So, in order to make GPAW work, you need to compile some C-code. You will need to build a dynamically linked library ( that the standard Python interpreter can load.

There are several ways to install GPAW:

  • Directly from PyPI: python3 -m pip install gpaw. More details here: Installation using pip.

  • Alternatively, you can download the source code and then install with a python3 -m pip install ..

  • There may be a package for your Linux distribution that you can use (named gpaw).

  • If you are a developer that need to change the code you should look at this description: Development workflow.

See also


Optional (highly recommended for increased performance):

See Release notes for version requirements.

Installation using pip

The simplest way to install GPAW is using pip and the GPAW package from the Python package index (PyPI):

$ python3 -m pip install gpaw

This will compile and install GPAW (both and all the Python files) in your ~/.local/lib/pythonX.Y/site-packages folder where Python can automatically find it. Pip will also place the command line tool gpaw in the ~/.local/bin folder, so make sure you have that in your $PATH environment variable.

Check that you have installed everything in the correct places:

$ gpaw info

Install PAW datasets

Install the datasets into the folder <dir> using this command:

$ gpaw install-data <dir>

See Installation of PAW datasets for more details.

Now you should be ready to use GPAW, but before you start, please run the tests as described below.

Run a simple test calculation

Make sure that everything works by running a simple test:

$ gpaw test

If this worked then try also a parallel calculation:

$ gpaw -P 4 test

Please report errors to the gpaw-users mailing list so that we can fix them (see Mail List).

See also

Testing GPAW for how to run the complete test suite.

Getting the source code

You can get the source from a tar-file or from Git:


You can get the source as a tar-file for the latest stable release (gpaw-24.6.0.tar.gz) or the latest development snapshot (gpaw-24.7.0b1.tar.gz).

Unpack and make a soft link:

$ tar -xf gpaw-24.6.0.tar.gz
$ ln -s gpaw-24.6.0 gpaw

Here is a list of tarballs.

Git clone:

Alternatively, you can get the source for the latest stable release from like this:

$ git clone -b 24.6.0

or if you want the development version:

$ git clone


We also have Git tags for older stable versions of GPAW. See the Release notes for which tags are available. Also the dates of older releases can be found there.

Customizing installation

The install script may need a little help finding you libraries (BLAS, FFTW, ScaLapack, libxc, libvdwxc, …). This can be done by adding a file in one of these three places:

  1. the file that $GPAW_CONFIG points at

  2. <git-root>/

  3. ~/.gpaw/

The first one found will be used. As an example, might contain the following lines:

libraries = ['myblas']
library_dirs = ['path_to_myblas']

Now, GPAW would be built with “-Lpath_to_myblas -lmyblas” linker flags. Look at the file for more possible options. Platforms and architectures provides examples of files for different platforms.

Parallel installation

By default, setup looks if mpicc is available, and if setup finds one, a parallel version is build. If the setup does not find mpicc, a user can specify one in the file.

Additionally a user may want to enable ScaLAPACK, setting in

scalapack = True

and, in this case, provide BLACS/ScaLAPACK libraries and library_dirs as described in Customizing installation.

Part of the code can be parallelized also with OpenMP. OpenMP threading can be enabled by setting in

extra_compile_args += ['-fopenmp']
extra_link_args += ['-fopenmp']

Note that a multithreaded BLAS library should be used together with OpenMP parallelization. Also, MPI library needs to support the MPI_THREAD_MULTIPLE thread support level.

Instructions for running parallel calculations can be found in the user manual.


In order to use FFTW instead of numpy.fft, add something like this to your

fftw = True
libraries += ['fftw3']

Libxc Installation

If you OS does not have a LibXC package you can use then you can download and install LibXC as described here. A few extra tips:

  • Libxc installation requires both a C compiler and a Fortran compiler.

  • We’ve tried Intel and gnu compilers and haven’t noticed much of a performance difference. Use whatever is easiest.

  • Libxc shared libraries can be built with the “–enable-shared” option to configure. This might be slightly preferred because it reduces memory footprints for executables.

  • Typically when building GPAW one has to modify in a manner similar to the following:

    library_dirs += ['/my/path/to/libxc/5.2.0/install/lib']
    include_dirs += ['/my/path/to/libxc/5.2.0/install/include']

    or if you don’t want to modify your, you can add these lines to your .bashrc:

    export C_INCLUDE_PATH=/my/path/to/libxc/5.2.0/install/include
    export LIBRARY_PATH=/my/path/to/libxc/5.2.0/install/lib
    export LD_LIBRARY_PATH=/my/path/to/libxc/5.2.0/install/lib


wget -O libxc-5.2.0.tar.gz
tar -xf libxc-5.2.0.tar.gz
cd libxc-5.2.0
./configure --enable-shared --disable-fortran --prefix=$HOME/libxc-5.2.0
make install

# add these to your .bashrc:
export C_INCLUDE_PATH=$XC/include
export LIBRARY_PATH=$XC/lib
export LD_LIBRARY_PATH=$XC/lib