# Arm Toolchains repository

## About this Install Guide

| Reading time: | 15 min |
|---------------|--------|
| Last updated: | 7 Aug 2026 |
| Author: | Gary Carroll |
| Official docs: | [View](https://developer.arm.com/tools-and-software) |

This guide shows you how to install and use the tool with the most common configuration. For advanced options and complete reference information, see the official documentation. Some install guides also include optional next steps to help you explore related workflows or integrations.

The [Arm Toolchains repository](https://developer.arm.com/packages/arm-toolchains/) provides a native and convenient way to install selected Arm software products on supported Linux hosts using the host operating system package manager.

The repository files are used to distribute Linux packages for Arm Toolchains, including:

- Arm Toolchain for Linux
- Arm Performance Libraries for supported compilers on Linux

Using the repository, you can install, upgrade, and manage these packages using standard Linux package-management tools such as `apt`, `dnf`, `yum`, and `zypper`.

To use the repository, you’ll need to install the repository package. Arm provides an `arm-toolchains-repository` package for each supported Linux distribution. The package installs:

- the Arm Toolchains repository definition for your Linux distribution
- the Arm Toolchains repository signing public key
- package manager configuration that associates the repository with the correct signing key

### Signing-key update

If you configured the Arm Toolchains repository before July 2026, package manager operations might report a signing-key error or ask you to trust a new key. Existing installations of Arm Toolchain for Linux and Arm Performance Libraries continue to work. See [Recognize package manager signing-key errors](#recognize-package-manager-signing-key-errors).

## Before you begin

You need root or `sudo` permissions to install system packages.

Confirm you are using an Arm Linux system by running:

```
uname -m
```

The output is similar to:

```
__output__ aarch64
```

Use the native package manager for your distribution:

- `apt` for Ubuntu LTS releases from 22.04
- `dnf` or `yum` for RHEL 8 or later and Amazon Linux 2023
- `zypper` for SLES 15 or 16

## About the signing key

Linux package managers use cryptographic signing keys to verify that repository metadata and packages are authentic and come directly from Arm.

In July 2026, Arm reviewed and strengthened the repository management and publication processes used for the Arm Toolchains repository. As part of the continuing evolution of this release channel, Arm revoked and replaced the signing key.

If you’re setting up a new system after July 2026, installing the `arm-toolchains-repository` package automatically configures the current repository signing key for you. You don’t need to install the key manually or verify fingerprints.

However, if you’re upgrading a system that configured the Arm Toolchains repository for Linux before July 2026, you need to update the repository configuration to use the new key. Otherwise, your package manager might refuse to refresh repository metadata or install packages.

Existing installed copies of Arm Toolchain for Linux and Arm Performance Libraries continue to work.

## Recognize package manager signing-key errors

You only need this section if you configured the Arm Toolchains repository before July 2026, or if a package manager reports a signing-key problem. New systems that install `arm-toolchains-repository` version `2-2` or later already use the current key.

These messages don’t mean that your installed copy of Arm Toolchain for Linux or Arm Performance Libraries is damaged. They mean that the package manager can’t verify new repository metadata or packages until you update the repository configuration.

### Ubuntu

Running `sudo apt update` might report:

```
__output__ The following signatures couldn't be verified because the public key is not available: NO_PUBKEY 8144CA1611A0BD71
```

### RHEL and Amazon Linux

`dnf` or `yum` might report:

```
__output__ The GPG keys listed for the "Arm Toolchains" repository are already installed but they are not correct for this package.
__output__ Error: GPG check FAILED
```

### SLES

Rather than reporting an error, `zypper refresh` might ask you to trust the current signing key:

```
__output__ New repository or package signing key received:
__output__ Key Fingerprint: A406 5BCE 9386 DD1E 62FD E03B 8144 CA16 11A0 BD71
__output__ Do you want to reject the key, trust temporarily, or trust always? [r/t/a/?] (r):
```

Confirm that the fingerprint matches the value shown above before entering `a` to trust the key permanently.

To update the repository configuration, [install the repository package directly](#install-the-repository-package-directly). If you can’t install the package, see [Use manual recovery](#use-manual-recovery).

## Install the repository package directly

Use one of the following commands to install the repository package [directly](https://developer.arm.com/packages/arm-toolchains/). This allows you to update the repository configuration even if your package manager can’t currently refresh the Arm Toolchains repository metadata.

```
curl -O https://developer.arm.com/packages/arm-toolchains/ubuntu/pool/arm-toolchains-repository_2-2~noble_all.deb
sudo dpkg -i arm-toolchains-repository_2-2~noble_all.deb
sudo apt update
```

```
curl -O https://developer.arm.com/packages/arm-toolchains/ubuntu/pool/arm-toolchains-repository_2-2~jammy_all.deb
sudo dpkg -i arm-toolchains-repository_2-2~jammy_all.deb
sudo apt update
```

```
sudo dnf install -y https://developer.arm.com/packages/arm-toolchains/rhel/el10/aarch64/arm-toolchains-repository-2-2.el10.noarch.rpm
sudo dnf clean all
sudo dnf makecache
```

```
sudo dnf install -y https://developer.arm.com/packages/arm-toolchains/rhel/el9/aarch64/arm-toolchains-repository-2-2.el9.noarch.rpm
sudo dnf clean all
sudo dnf makecache
```

```
sudo dnf install -y https://developer.arm.com/packages/arm-toolchains/rhel/el8/aarch64/arm-toolchains-repository-2-2.el8.noarch.rpm
sudo dnf clean all
sudo dnf makecache
```

```
sudo dnf install -y https://developer.arm.com/packages/arm-toolchains/amazonlinux/al2023/aarch64/arm-toolchains-repository-2-2.al2023.noarch.rpm
sudo dnf clean all
sudo dnf makecache
```

```
sudo zypper install -y https://developer.arm.com/packages/arm-toolchains/sles/sles15/aarch64/arm-toolchains-repository-2-2.sles15.noarch.rpm
sudo zypper clean
sudo zypper refresh
```

```
sudo zypper install -y https://developer.arm.com/packages/arm-toolchains/sles/sles16/aarch64/arm-toolchains-repository-2-2.sles16.noarch.rpm
sudo zypper clean
sudo zypper refresh
```

## Use manual recovery

The recommended method is to install `arm-toolchains-repository` version `2-2` or later directly.

Use manual recovery only if you cannot install the repository package directly.

### Ubuntu manual recovery

Remove previous Arm Linux Toolchains Repository key material if present:

```
sudo rm -f /usr/share/keyrings/arm-toolchains-archive-keyring.gpg
sudo rm -f /etc/apt/keyrings/arm-toolchains-archive-keyring.gpg
sudo rm -f /etc/apt/trusted.gpg.d/arm-toolchains.gpg
sudo rm -f /etc/apt/trusted.gpg.d/arm-toolchains.asc
```

Install the current Arm Toolchains repository signing key:

```
curl -O https://developer.arm.com/packages/arm-toolchains/arm-toolchains.gpg
sudo install -D -m 0644 arm-toolchains.gpg \
  /usr/share/keyrings/arm-toolchains-archive-keyring.gpg
```

Check the fingerprint:

```
gpg --show-keys --fingerprint /usr/share/keyrings/arm-toolchains-archive-keyring.gpg
```

The output should include:

```
__output__ A406 5BCE 9386 DD1E 62FD  E03B 8144 CA16 11A0 BD71
```

Find any existing Arm Toolchains repository entries:

```
grep -Rns "developer.arm.com/packages/arm-toolchains/ubuntu" \
  /etc/apt/sources.list /etc/apt/sources.list.d
```

If the command finds an existing entry, edit that entry so it references `/usr/share/keyrings/arm-toolchains-archive-keyring.gpg` using `signed-by`. Don’t create a second entry for the same repository because `apt` might report conflicting `Signed-By` values.

If the command doesn’t find an entry, create `/etc/apt/sources.list.d/arm-toolchains.list` using one of the following commands:

For Ubuntu 24.04, run:

```
echo "deb [signed-by=/usr/share/keyrings/arm-toolchains-archive-keyring.gpg] https://developer.arm.com/packages/arm-toolchains/ubuntu noble main" | \
  sudo tee /etc/apt/sources.list.d/arm-toolchains.list
```

For Ubuntu 22.04, run:

```
echo "deb [signed-by=/usr/share/keyrings/arm-toolchains-archive-keyring.gpg] https://developer.arm.com/packages/arm-toolchains/ubuntu jammy main" | \
  sudo tee /etc/apt/sources.list.d/arm-toolchains.list
```

After creating `arm-toolchains.list`, refresh package metadata:

```
sudo apt update
```

### RPM-based manual recovery

Remove the previous Arm Toolchains public key if present:

```
sudo rpm -e gpg-pubkey-7a05af82* || true
```

Install the current Arm Toolchains repository signing key:

```
curl -O https://developer.arm.com/packages/arm-toolchains/arm-toolchains.gpg
sudo rpm --import arm-toolchains.gpg
```

Check that the key is installed:

```
rpm -qa gpg-pubkey*
```

Refresh package metadata by running one of the following set of commands.

For RHEL, Amazon Linux, and compatible RPM-based distributions:

```
sudo dnf clean all
sudo dnf makecache
```

For SLES:

```
sudo zypper clean
sudo zypper refresh
```

## Verify the repository package version

After installing the repository package, verify the installation:

```
dpkg -l arm-toolchains-repository
```

```
rpm -q arm-toolchains-repository
```

The installed version should be `2-2` or later.

## Signing key reference

### Repository signing key fingerprints

For reference or manual verification, the fingerprints of the previous and current Arm Toolchains signing keys are as follows.

Previous fingerprint:

```
__output__ EE37 7ACD D5AD 4AB6 BD79  9B8A B83D 741E 7A05 AF82
```

Current fingerprint:

```
__output__ A406 5BCE 9386 DD1E 62FD  E03B 8144 CA16 11A0 BD71
```

### (Optional) Manually verify the signing key

If you want to manually verify the signing key, ensure the `gpg` utility (part of GnuPG) is installed on your system, then download the key file and display its fingerprint:

```
curl -O https://developer.arm.com/packages/arm-toolchains/arm-toolchains.gpg
gpg --show-keys --fingerprint arm-toolchains.gpg
```

The output should show the current fingerprint:

```
__output__ A406 5BCE 9386 DD1E 62FD  E03B 8144 CA16 11A0 BD71
```

## Previous repository locations

The current Arm Toolchains repository at [https://developer.arm.com/packages/arm-toolchains/](https://developer.arm.com/packages/arm-toolchains/) replaces the earlier repository structure that was based on repositories built using the SUSE Open Build Service.

Earlier repositories were published under the top-level package URL [https://developer.arm.com/packages/](https://developer.arm.com/packages/) and used repository prefixes such as:

```
__output__ ACfL:<distro>
__output__ arm-toolchains:<distro>
```

These earlier repositories are deprecated but will continue to work until further notice.

Don’t configure new systems to use the deprecated `ACfL:` or `arm-toolchains:` repository paths. Migrate existing systems to the current Arm Toolchains Linux repositories and install the current `arm-toolchains-repository` package.

The deprecated repositories will be removed in a future update.

## Next steps

After installing the repository package, you’re ready to install the Arm Toolchain for Linux and the Arm Performance Libraries.

For installation instructions, see the [Arm Toolchain for Linux installation instructions](https://developer.arm.com/documentation/110477/latest/Installation) and the [Arm Performance Libraries installation instructions](/install-guides/armpl/) for your distribution.