To have all of the Arm Allinea Studio tools available to use, you must install both the Arm Compiler for Linux and Arm Forge packages.

Install Arm Compiler for Linux

Follow these instructions to install the Arm Compiler for Linux package.

Before you begin

If any of the following tools are not already installed by your Linux distribution, you must install them before installing Arm Compiler for Linux:

  • Python (version 2.7 or later)
  • C Libraries:
    • SUSE and RHEL: glibc-devel
    • Ubuntu:                 libc6-dev


  1. Extract the downloaded package:

    tar -xvf <package_name>.tar

    Replace <package_name> with the full name of the downloaded package.

  2. Change to the extracted package directory:

    cd <package_name>
  3. Install the package:

    • To install the package using the default options (requires superuser permissions), run:

      sudo ./<package_name>.sh
      The packages are installed to /opt/arm/<package_name>.

    • To install the package using a set of options, run:

      sudo ./<package_name>.sh <options>
      Note: sudo permissions are not required if you install the package to a location where you have write permissions using --install-to (see table below).

      Where <options> can be one or more of:

      -a, --accept Automatically accept the EULA
      (the EULA still displays).
      -l, --list-packages List the installer packages
      -i, --install-to <location> Install to the given directory.
      Use this option if you do not have sudo rights to install to /opt/arm or another central location.
      -s, --save-packages-to <location> Save packages to given directory.
      -f, --force Force an install attempt to a non empty directory.
      --list-available-microarchitectures List the supported microarchitectures.
      --only-install-microarchitectures=<arg>,<arg> Install the packages for a subset of the supported microarchitectures.
      Supported microarchitectures include:
      • generic: For a generic Armv8-A implementation.
      • generic-sve: For a generic, SVE-enabled Armv8-A implementation.
      • Target-specific: To see the CPU targets supported, see the supported arguments for the -mcpu= compiler option in the Arm Fortran Compiler or Arm C/C++ Compiler reference guide.

      Note: The generic implementation is always installed. native is supported for the -mcpu option, but is not a supported argument for --only-install-microarchitectures. To specify multiple microarchitectures, pass each microarchitecture as a comma-separated argument.
      -h, --help Display this table in the form of a help message in the terminal.

      Note: For the --list-available-microarchitectures and --only-install-microarchitectures=<arg> options, there is a delay between running the script and receiving a response.

      The packages are installed to <install_dir>/<package_name>, where <install_dir> defaults to /opt/arm if not explicitly provided using the --install-to option.

  4. The installer displays the EULA and prompts you to agree to the terms. To agree, type 'yes' at the prompt.

Note: Arm recommends that you rebuild your MPI implementation (Open MPI, MVAPICH, MPICH) after each installation of a new version of Arm Compiler for Linux. This ensures that the Fortran interface incorporates any changes to the armflang module format, and that the correct run-time libraries are used.

(Optional) Next Steps: Enable command line completion

Arm Compiler for Linux versions 20.2+ include a tool that allows bash terminal users to autocomplete their command line using the Tab key on their keyboard.

For compile commands, it allows bash users to complete the armflang|armclang|armclang++ commands, and for options it allows users to complete the option name, and also any arguments it supports. Where an option is already complete, and it supports arguments, users can press the Tab key to see a list of the supported arguments. For example, to list the supported arguments for -ffp-contract= with armclang, users can type the following command line into your terminal and press Tab where indicated by [TAB]:

armclang -ffp-contract=[TAB]

The arguments supported by -ffp-contract= return:

fast off on

Auto-completion relies on the support in your shell, and on the completion functions for the compiler, which make use of the  <install-dir>/share/utils/ file in the Arm Compiler for Linux package.

  • To enable bash users to use this functionality, System Administrators should ensure that the 'bash-completion' package is installed and available for all users to use. If 'bash-completion' is installed, users can load the 'arm-linux-compiler' environment module and use command line completion with the commands and options immediately.

  • To enable users of other shell types to use this functionality, System Administrators must rewrite the _clang() function defined in <install-dir>/share/utils/ using an appropriate syntax for your users' shell, then register the _clang() function with the completion system for that shell. To automatically register autocompletion scripts when the arm-linux-compiler environment module is loaded, System Administrators might also want to modify the arm-linux-compiler module.

Install Arm Forge

These steps describe the Linux text-mode install for Arm Forge, however a graphical installation is also available. For the full instructions on how to install Arm Forge on your Linux platform, see the installation instructions in the Arm Forge User Guide.


  1. Untar the Arm Forge installation package and run the script by using these commands:

    tar xf arm-forge-<version>-<distro>-<arch>.tar
    cd arm-forge-<version>-<distro>-<arch>
    Note: Replace <version>, <distro>, and <arch> with the required version, OS distribution, and architecture. For example, the tarball package for the 20.1 version, Redhat 7.4 OS, and Armv8-A (AArch64) architecture is:
  2. When you are prompted, press Return to read the license. When prompted, agree to the license terms by typing a, and pressing Enter. Next, when prompted, enter the path of the Arm Forge installation directory. The directory must be accessible on all the nodes in your cluster.
Previous Next