How to run external codes

This how-to walks you through the steps of setting up a (possibly remote) compute resource, setting up a code on that computer, and submitting a calculation through AiiDA (similar to the introductory tutorial, but in more detail).

To run an external code with AiiDA, you need an appropriate calculation plugin. In the following, we assume that a plugin for your code is already available from the aiida plugin registry and installed on your machine. Refer to the How to install plugins section for details on how to install an existing plugin. If a plugin for your code is not yet available, see How to write a plugin for an external code.

Throughout the process, you will be prompted for information on the computer and code. In these prompts:

  • Type ? followed by <enter> to get help on what is being asked at any prompt.

  • Press <CTRL>+C at any moment to abort the setup process. Your AiiDA database will remain unmodified.


The verdi commands use readline extensions to provide default answers, which require an advanced terminal. Use a standard terminal – terminals embedded in some text editors (such as emacs) have been known to cause problems.

How to set up a computer

A Computer in AiiDA denotes a computational resource on which you will run your calculations. It can either be:

  1. the machine where AiiDA is installed or

  2. any machine that is accessible via SSH from the machine where AiiDA is installed (possibly via a proxy server).

The second option allows managing multiple remote compute resources (including HPC clusters and cloud services) from the same AiiDA installation and moving computational jobs between them.


The second option requires access through an SSH keypair. If your compute resource demands two-factor authentication, you may need to install AiiDA directly on the compute resource instead.

Computer requirements

Each computer must satisfy the following requirements:

  • It runs a Unix-like operating system (Linux distros and MacOS should work fine)

  • It has bash installed

  • (optional) It has batch scheduler installed (see the list of supported schedulers)

If you are configuring a remote computer, start by configuring password-less SSH access to it.


AiiDA will use bash on the remote computer, regardless of the default shell. Please ensure that your remote bash configuration does not load a different shell.

Computer setup

The configuration of computers happens in two steps: setting up the public metadata associated with the Computer in AiiDA provenance graphs, and configuring private connection details.

Start by creating a new computer instance in the database:

$ verdi computer setup

At the end, the command will open your default editor on a file containing a summary of the configuration up to this point. You can add bash commands that will be executed

  • before the actual execution of the job (under ‘Pre-execution script’), and

  • after the script submission (under ‘Post execution script’).

Use these additional lines to perform any further set up of the environment on the computer, for example loading modules or exporting environment variables:

export NEWVAR=1
source some/file


Don’t specify settings here that are specific to a code or calculation: you can set further pre-execution commands at the Code and even CalcJob level.

When you are done editing, save and quit. The computer has now been created in the database but you still need to configure access to it using your credentials.


In order to avoid having to retype the setup information the next time around, you can provide some (or all) of the information via a configuration file:

$ verdi computer setup --config computer.yml

where computer.yml is a configuration file in the YAML format. This file contains the information in a series of key-value pairs:

label: "localhost"
hostname: "localhost"
transport: local
scheduler: "direct"
work_dir: "/home/max/.aiida_run"
mpirun_command: "mpirun -np {tot_num_mpiprocs}"
mpiprocs_per_machine: "2"
prepend_text: |
   module load mymodule
   export NEWVAR=1

The list of the keys for the yaml file is given by the options of the computer setup command:

  $ verdi computer setup --help

Note: remove the ``--`` prefix and replace ``-`` within the keys with an underscore ``_``.

Computer connection configuration

The second step configures private connection details using:

$ verdi computer configure TRANSPORTTYPE COMPUTERLABEL

Replace COMPUTERLABEL with the computer label chosen during the setup and replace TRANSPORTTYPE with the name of chosen transport type, i.e., local for the localhost computer and ssh for any remote computer.

After the setup and configuration have been completed, let’s check that everything is working properly:

$ verdi computer test COMPUTERNAME

This command will perform various tests to make sure that AiiDA can connect to the computer, create new files in the scratch directory, retrieve files and query the job scheduler.

Mitigating connection overloads

Some compute resources, particularly large supercomputing centers, may not tolerate submitting too many jobs at once, executing scheduler commands too frequently, or opening too many SSH connections.

  • Limit the number of jobs in the queue.

    Set a limit for the maximum number of workflows to submit, and only submit new ones once previous workflows start to complete. The supported number of jobs depends on the supercomputer configuration which may be documented as part of the center’s user documentation. The supercomputer administrators may also find the information found on this page useful.

  • Increase the time interval between polling the job queue.

    The time interval (in seconds) can be set through the Python API by loading the corresponding Computer node, e.g. in the verdi shell:

  • Increase the connection cooldown time.

    This is the minimum time (in seconds) to wait between opening a new connection. Modify it for an existing computer using:

    verdi computer configure ssh --non-interactive --safe-interval <SECONDS> <COMPUTER_NAME>


The two intervals apply per daemon worker, i.e. doubling the number of workers may end up putting twice the load on the remote computer.

Managing your computers

Fully configured computers can be listed with:

$ verdi computer list

To get detailed information on the specific computer named COMPUTERLABEL:

$ verdi computer show COMPUTERLABEL

To rename a computer or remove it from the database:

$ verdi computer delete COMPUTERLABEL


Before deleting a Computer, you will need to delete all nodes linked to it (e.g. any CalcJob and RemoteData nodes). Otherwise, AiiDA will prevent you from doing so in order to preserve provenance.

If a remote machine is under maintenance (or no longer operational), you may want to disable the corresponding Computer. Doing so will prevent AiiDA from connecting to the given computer to check the state of calculations or to submit new calculations.

$ verdi computer disable COMPUTERLABEL
$ verdi computer enable COMPUTERLABEL

How to setup a code

Once your computer is configured, you can set up codes on it.

AiiDA stores a set of metadata for each code, which is attached automatically to each calculation using it. Besides being important for reproducibility, this also makes it easy to query for all calculations that were run with a given code (for instance, if a specific version is found to contain a bug).

Setting up a code

The verdi code CLI is the access point for managing codes in AiiDA. To setup a new code, execute:

$ verdi code setup

and you will be guided through a process to setup your code.

On remote and local codes

In most cases, it is advisable to install the executables to be used by AiiDA on the target machine before submitting calculations using them in order to take advantage of the compilers and libraries present on the target machine. This setup is referred to as remote codes (Installed on target computer?: True).

Occasionally, you may need to run small, reasonably machine-independent scripts (e.g. Python or bash), and copying them manually to a number of different target computers can be tedious. For this use case, AiiDA provides local codes (Installed on target computer?: False). Local codes are stored in the AiiDA file repository and copied to the target computer for every execution.

Do not use local codes as a way of encapsulating the environment of complex executables. Containers are a much better solution to this problem, and we are working on adding native support for containers in AiiDA.

At the end of these steps, you will be prompted to edit a script, where you can include bash commands that will be executed

  • before running the submission script (after the ‘Pre execution script’ lines), and

  • after running the submission script (after the ‘Post execution script’ separator).

Use this, for instance, to load modules or set variables that are needed by the code, such as:

module load intelmpi

At the end, you receive a confirmation, with the PK and the UUID of your new code.

Using configuration files

Analogous to a computer setup, some (or all) the information described above can be provided via a configuration file:

$ verdi code setup --config code.yml

where code.yml is a configuration file in the YAML format.

This file contains the information in a series of key:value pairs:

label: "qe-6.3-pw"
description: "quantum_espresso v6.3"
input_plugin: ""
on_computer: true
remote_abs_path: "/path/to/code/pw.x"
computer: "localhost"
prepend_text: |
   module load module1
   module load module2
append_text: " "

The list of the keys for the yaml file is given by the available options of the code setup command:

$ verdi code setup --help

Note: remove the -- prefix and replace - within the keys with an underscore _.

Managing codes

You can change the label of a code by using the following command:

$ verdi code relabel <IDENTIFIER> "new-label"

where <IDENTIFIER> can be the numeric PK, the UUID or the label of the code (either label or label@computername) if the label is unique.

You can also list all available codes and their identifiers with:

$ verdi code list

which also accepts flags to filter only codes on a given computer, or only codes using a specific plugin, etc. (use the -h option).

You can get the information of a specific code with:

$ verdi code show <IDENTIFIER>

Finally, to delete a code use:

$ verdi code delete <IDENTIFIER>

(only if it wasn’t used by any calculation, otherwise an exception is raised).


Codes are a subclass of Node and, as such, you can attach extras to a code, for example:

load_code('<IDENTIFIER>').set_extra('version', '6.1')
load_code('<IDENTIFIER>').set_extra('family', 'cp2k')

These can be useful for querying, for instance in order to find all runs done with the CP2K code of version 6.1 or later.

How to submit a calculation

After setting up your computer and setting up your code, you are ready to launch your calculations!

  • Make sure the daemon is running:

    verdi daemon status
  • Figure out which inputs your CalcJob plugin needs, e.g. using:

    verdi plugin list aiida.calculations arithmetic.add
  • Write a script:

    from aiida.engine import submit
    code = load_code('add@localhost')
    builder = code.get_builder()
    builder.x = Int(4)
    builder.y = Int(5)
    builder.metadata.options.withmpi = False
    builder.metadata.options.resources = {
        'num_machines': 1,
        'num_mpiprocs_per_machine': 1,
    builder.metadata.description = "My first calculation."

    Of course, the code label and builder inputs need to be adapted to your code and calculation.

  • Submit your calculation to the AiiDA daemon:

    verdi run

After this, use verdi process list to monitor the status of the calculations.

See Launching processes and Monitoring processes for more details.

How to save compute time with caching

Over the course of a project, you may end up re-running the same calculations multiple times - be it because two workflows include the same calculation or because one needs to restart a workflow that failed due to some infrastructure problem.

Since AiiDA stores the full provenance of each calculation, it can detect whether a calculation has been run before and, instead of running it again, simply reuse its outputs, thereby saving valuable computational resources. This is what we mean by caching in AiiDA.

With caching enabled, AiiDA searches the database for a calculation of the same hash. If found, AiiDA creates a copy of the calculation node and its results, thus ensuring that the resulting provenance graph is independent of whether caching is enabled or not (see Fig. 5).


Fig. 5 When reusing the results of a calculation C for a new calculation C’, AiiDA simply makes a copy of the result nodes and links them up as usual. This diagram depicts the same input node D1 being used for both calculations, but an input node D1’ with the same hash as D1 would trigger the cache as well.

Caching happens on the calculation level (no caching at the workflow level, see Limitations and Guidelines). By default, both successful and failed calculations enter the cache (more details in Controlling Caching).

How to enable caching


Caching is not enabled by default, see the faq.

Caching is controlled on a per-profile level via the verdi config cli.

View your current caching configuration:

$ verdi config list caching
name                     source    value
-----------------------  --------  -------
caching.default_enabled  default   False
caching.disabled_for     default
caching.enabled_for      default

Enable caching for your current profile or globally (for all profiles):

$ verdi config set caching.default_enabled True
Success: 'caching.default_enabled' set to True for 'quicksetup' profile

$ verdi config set -g caching.default_enabled True
Success: 'caching.default_enabled' set to True globally

$ verdi config list caching
name                     source    value
-----------------------  --------  -------
caching.default_enabled  profile   True
caching.disabled_for     default
caching.enabled_for      default

Changed in version 1.6.0: Configuring caching via the cache_config.yml is deprecated as of AiiDA 1.6.0. Existing cache_config.yml files will be migrated to the central config.json file automatically.

From this point onwards, when you launch a new calculation, AiiDA will compare its hash (a fixed size string, unique for a calulation’s type and inputs, see How are nodes hashed) against other calculations already present in your database. If another calculation with the same hash is found, AiiDA will reuse its results without repeating the actual calculation.


In contrast to caching, hashing is enabled by default, i.e. hashes for all your calculations will already have been computed.

How to configure caching

The caching mechanism can be configured on a process class level, meaning the rules will automatically be applied to all instances of the given class, or on a per-instance level, meaning it can be controlled for individual process instances when they are launch.

Class level

Besides the on/off switch set by caching.default_enabled, caching can be controlled at the level of specific calculations using their corresponding entry point strings (see the output of verdi plugin list aiida.calculations):

$ verdi config set caching.disabled_for aiida.calculations:templatereplacer
Success: 'caching.disabled_for' set to ['aiida.calculations:templatereplacer'] for 'quicksetup' profile
$ verdi config set caching.enabled_for
Success: 'caching.enabled_for' set to [''] for 'quicksetup' profile
$ verdi config set --append caching.enabled_for aiida.calculations:other
Success: 'caching.enabled_for' set to ['', 'aiida.calculations:other'] for 'quicksetup' profile
$ verdi config list caching
name                     source    value
-----------------------  --------  -------------------------------------
caching.default_enabled  profile   True
caching.disabled_for     profile   aiida.calculations:templatereplacer
caching.enabled_for      profile

In this example, caching is enabled by default, but explicitly disabled for calculations of the TemplatereplacerCalculation class, identified by its corresponding aiida.calculations:templatereplacer entry point string. It also shows how to enable caching for particular calculations (which has no effect here due to the profile-wide default).


To set multiple entry-points at once, use a , delimiter.

For the available entry-points in your environment, you can list which are enabled/disabled using:

$ verdi config caching
$ verdi config caching --disabled

For calculations which do not have an entry point, you need to specify the fully qualified Python name instead. For example, the seekpath_structure_analysis calcfunction defined in aiida_quantumespresso.workflows.functions.seekpath_structure_analysis is labelled as aiida_quantumespresso.workflows.functions.seekpath_structure_analysis.seekpath_structure_analysis. From an existing CalculationNode, you can get the identifier string through the process_type attribute.

The caching configuration also accepts * wildcards. For example, the following configuration disables caching for all calculation entry points.

$ verdi config set caching.disabled_for 'aiida.calculations:*'
Success: 'caching.disabled_for' set to ['aiida.calculations:*'] for 'quicksetup' profile
$ verdi config caching
$ verdi config caching --disabled

Any entry with a wildcard is overridden by a more specific entry. The following configuration disables caching for all aiida.calculation entry points, except those of arithmetic:

$ verdi config set caching.enabled_for 'aiida.calculations:arithmetic.*'
Success: 'caching.enabled_for' set to ['aiida.calculations:arithmetic.*'] for 'quicksetup' profile
$ verdi config list caching
name                     source    value
-----------------------  --------  -------------------------------
caching.default_enabled  profile   True
caching.disabled_for     profile   aiida.calculations:*
caching.enabled_for      profile   aiida.calculations:arithmetic.*
$ verdi config caching
$ verdi config caching --disabled

Instance level

Caching can be enabled or disabled on a case-by-case basis by using the enable_caching or disable_caching context manager, respectively, regardless of the profile settings:

from aiida.engine import run
from aiida.manage.caching import enable_caching
with enable_caching(identifier='aiida.calculations:templatereplacer'):


This affects only the current Python interpreter and won’t change the behavior of the daemon workers. This means that this technique is only useful when using run, and not with submit.

If you suspect a node is being reused in error (e.g. during development), you can also manually prevent a specific node from being reused:

  1. Load one of the nodes you suspect to be a clone. Check that get_cache_source() returns a UUID. If it returns None, the node was not cloned.

  2. Clear the hashes of all nodes that are considered identical to this node:

    for node in node.get_all_same_nodes():
  3. Run your calculation again. The node in question should no longer be reused.