Updated GNU Toolchain install

pareenaverma · pareenaverma · commit 2a8d694da324 · 2026-04-09T12:55:36.000-04:00
diff --git a/content/install-guides/gcc/arm-gnu.md b/content/install-guides/gcc/arm-gnu.md
@@ -19,9 +19,11 @@ weight: 4
 
 ## Before you begin
 
-Arm GNU Toolchain is a community-supported, pre-built GNU compiler toolchain for Arm-based CPUs.
+Arm GNU Toolchain is a community-supported, pre-built GNU compiler toolchain for Arm-based CPUs. This guide covers installing the toolchain directly from the [Arm GNU Toolchain downloads page](https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads), which is the recommended approach for bare-metal and embedded targets such as `arm-none-eabi`.
 
-There are many versions of the [Arm GNU Toolchain](https://developer.arm.com/Tools%20and%20Software/GNU%20Toolchain) available. In general, the latest version is recommended for use, as this will contain the latest optimization improvements, as well as support for the latest Arm IP.
+If you need a cross-compiler targeting Arm Linux (for example `aarch64-linux-gnu` or `arm-linux-gnueabihf`), see the [Cross-compiler](../cross) install guide instead, which installs those toolchains via the Linux package manager.
+
+There are many versions of the [Arm GNU Toolchain](https://developer.arm.com/Tools%20and%20Software/GNU%20Toolchain) available. In general, the latest version is recommended, as this will contain the latest optimization improvements and support for the latest Arm IP.
 
 However there are reasons you may wish to use earlier compiler versions, so older versions are also available.
 
@@ -45,18 +47,6 @@ Download the correct toolchain variant for your development needs from the [Arm
 
 ## How do I install the Arm GNU Toolchain on Linux?
 
-### Use package installer
-
-Many Linux distributions make the toolchain available with their package installers. However they may not be the latest versions or desired variant.
-```command
-sudo apt update
-sudo apt install gcc-arm-none-eabi
-```
-
-If the installed version does not meet your needs, you can install another Arm GNU Toolchain version.
-
-### Manual install {#manual}
-
 Unpack the downloaded file to the install directory. The exact file name will depend on the flavor selected.
 
 ```console
@@ -148,7 +138,7 @@ Double-click on the installer, such as  `arm-gnu-toolchain-15.2.rel1-mingw-w64-i
 To install silently from the command line, use similar to the following:
 
 ```console
- msiexec /i arm-gnu-toolchain-<version>--mingw-w64-i686-arm-none-eabi.msi EULA=1 /quiet
+ msiexec /i arm-gnu-toolchain-<version>-mingw-w64-i686-arm-none-eabi.msi EULA=1 /quiet
 ```
 
 The zip package is a backup to Windows installer for those who cannot run the installer. You can unzip the package and then run the tools directly.
@@ -161,12 +151,12 @@ To use the Arm GNU Toolchain in conjunction with [Arm Development Studio](https:
 
 ## Get started
 
-To verify the installation is correct enter:
+To verify the installation is correct, enter:
 ```console
 arm-none-eabi-gcc -v
 ```
 
-Additional examples are included in the toolchain installation at:
+Additional examples are included in the toolchain installation. If you installed to `$HOME` using the example above, you can find them at:
 ```console
-${install_dir}/share/gcc-arm-none-eabi/samples
+$HOME/arm-gnu-toolchain-15.2.rel1-aarch64-arm-none-eabi/share/doc/gcc-arm-none-eabi/examples
 ```
diff --git a/content/install-guides/gcc/cross.md b/content/install-guides/gcc/cross.md
@@ -18,78 +18,46 @@ weight: 3
 ---
 GCC is available on all Linux distributions and can be installed using the package manager.
 
-This covers `gcc` and `g++` for compiling C and C++ as a cross-compiler targeting the Arm architecture.
+This covers `gcc` and `g++` for compiling C and C++ as a cross-compiler targeting the Arm Linux architecture. For bare-metal and embedded targets such as `arm-none-eabi`, see the [Arm GNU Toolchain](../arm-gnu) install guide.
 
 ## Before you begin
 
-GCC is often used to cross-compile software for Arm microcontrollers and embedded devices which have firmware and other low-level software. The executables are `arm-none-eabi-gcc` and `arm-none-eabi-g++`.
-
-GCC is also used to cross compile Linux applications. Applications can be compiled for 32-bit or 64-bit Linux systems.
+GCC is used to cross-compile Linux applications targeting Arm. Applications can be compiled for 32-bit or 64-bit Arm Linux systems.
 
 The executables for 32-bit are `arm-linux-gnueabihf-gcc` and `arm-linux-gnueabihf-g++`.
 
 The executables for 64-bit are `aarch64-linux-gnu-gcc` and `aarch64-linux-gnu-g++`.
 
-Software can be compiled on an `x86` or `Arm` host machine.
+Software can be compiled on an `x86_64` or `Arm` host machine.
 
 ## How do I download a GCC cross compiler targeting Arm?
 
-For the Linux cross-compilers targeting 32-bit and 64-bit Linux applications (`arm-linux-gnueabihf` and `aarch64-linux-gnu`), the Linux package manager downloads the required files.
-
-For the bare-metal cross-compiler (`arm-none-eabi`), Arm no longer publishes new releases through Debian or Ubuntu package repositories. To get the latest version, download it directly from the [Arm GNU Toolchain downloads page](https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads).
+The Linux package manager downloads the required files. No manual download is needed.
 
 ## How do I install a GCC cross compiler on Linux?
 
 You can install a GCC cross compiler with Arm as a target architecture using Linux package managers.
 
 ### Installing on Debian based distributions such as Ubuntu
 
-Use the `apt` command to install the cross-compilers for 32-bit and 64-bit Linux targets.
+Use the `apt` command to install the cross-compilers for 32-bit and 64-bit Arm Linux targets.
 
 ```bash { target="ubuntu:latest" }
 sudo apt update
 sudo apt install gcc-arm-linux-gnueabihf -y
 sudo apt install gcc-aarch64-linux-gnu -y
 ```
 
-These packages are maintained by Canonical and the GCC version you receive is tied to your Ubuntu release (for example, GCC 13 on Ubuntu 24.04 LTS, GCC 15 on Ubuntu 25.10). 
-
-For the bare-metal cross-compiler (`arm-none-eabi`), Arm no longer publishes new releases to Debian or Ubuntu package repositories. The version available through `apt` is older and may not include support for recent Arm cores or architecture features.
-
-To install the latest `arm-none-eabi` toolchain (15.2.Rel1), download the pre-built tarball for your host architecture from the [Arm GNU Toolchain downloads page](https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads). Extract the archive and add the `bin` directory to your `PATH`.
-
-On an `aarch64` host:
-
-```bash
-wget https://developer.arm.com/-/media/Files/downloads/gnu/15.2.rel1/binrel/arm-gnu-toolchain-15.2.rel1-aarch64-arm-none-eabi.tar.xz
-tar -xJf arm-gnu-toolchain-15.2.rel1-aarch64-arm-none-eabi.tar.xz
-export PATH="$HOME/arm-gnu-toolchain-15.2.rel1-aarch64-arm-none-eabi/bin:$PATH"
-```
-
-On an `x86_64` host:
-
-```bash
-wget https://developer.arm.com/-/media/Files/downloads/gnu/15.2.rel1/binrel/arm-gnu-toolchain-15.2.rel1-x86_64-arm-none-eabi.tar.xz
-tar -xJf arm-gnu-toolchain-15.2.rel1-x86_64-arm-none-eabi.tar.xz
-export PATH="$HOME/arm-gnu-toolchain-15.2.rel1-x86_64-arm-none-eabi/bin:$PATH"
-```
-
-The commands above extract the toolchain into the current directory. Move the folder to a permanent location such as `$HOME` first if you'd like a stable install path.
-
-To make the change permanent, add the `export` line to your shell profile such as `~/.bashrc` or `~/.profile`.
+The GCC version installed is tied to your Ubuntu release. For example, Ubuntu 24.04 LTS provides GCC 13 and Ubuntu 25.10 provides GCC 15. This is normal Ubuntu packaging behaviour.
 
 ### Installing on Fedora
 
-Fedora uses the `dnf` package manager. The `arm-none-eabi-gcc-cs` package in current Fedora releases (42 and later) tracks the latest GCC release closely.
-
-If you're on RHEL, CentOS, or another EPEL-based distribution, the available version may be older. In that case, download the latest toolchain directly from the [Arm GNU Toolchain downloads page](https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads) and follow the manual extraction steps described in the Ubuntu section above.
+Fedora uses the `dnf` package manager.
 
 - If the machine has `sudo` you can use it:
 
   ```bash { target="fedora:latest" }
   sudo dnf update -y
-  sudo dnf install arm-none-eabi-gcc-cs -y
-  sudo dnf install arm-none-eabi-newlib -y
   sudo dnf install gcc-aarch64-linux-gnu -y
   sudo dnf install gcc-arm-linux-gnu -y
   ```
@@ -98,37 +66,28 @@ If you're on RHEL, CentOS, or another EPEL-based distribution, the available ver
 
   ```console
   dnf update -y
-  dnf install arm-none-eabi-gcc-cs -y
-  dnf install arm-none-eabi-newlib -y
   dnf install gcc-aarch64-linux-gnu -y
   dnf install gcc-arm-linux-gnu -y
   ```
 
-## How do I install a GCC cross compiler on macOS?
-
-You can install a GCC cross compiler with Arm as a target architecture using Homebrew, a package manager for macOS (and Linux). The Homebrew formula tracks the latest GCC release and provides pre-built bottles for Apple Silicon.
-
-```console
-brew install arm-none-eabi-gcc
-```
-
-Alternatively, Arm provides an official `.pkg` installer for macOS on Apple Silicon. Download the latest version from the [Arm GNU Toolchain downloads page](https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads) and run it to install the toolchain to `/Applications/ArmGNUToolchain/`.
+On Fedora, only building kernels is currently supported. Support for cross-building user space programs is not currently provided, as that would massively multiply the number of packages.
 
 ## Setting up product license {#license}
 
 GCC is open source and freely available for use.
 
 ## Get started {#start}
 
-To confirm the installation is successful, enter:
+To confirm the installations are successful, enter:
 
-```bash
-arm-none-eabi-gcc --version
+```bash { target="ubuntu:latest" }
+aarch64-linux-gnu-gcc --version
+arm-linux-gnueabihf-gcc --version
 ```
 
-To compile an example program, create a text file named `hello-world-embedded.c` with the contents below.
+To cross-compile an example program, create a text file named `hello-world.c` with the contents below.
 
-```C { file_name="hello-world-embedded.c" }
+```C { file_name="hello-world.c" }
 #include <stdio.h>
 
 int main()
@@ -138,20 +97,14 @@ int main()
 }
 ```
 
-To compile hello-world as a bare-metal application:
-
-```bash { target="ubuntu:latest" }
-arm-none-eabi-gcc --specs=rdimon.specs hello-world-embedded.c -o hello-world.elf
-```
-
-To cross-compile hello-world as a 32-bit Linux application. On Fedora, only building kernels is currently supported. Support for cross-building user space programs is not currently provided as that would massively multiply the number of packages.
+To cross-compile for a 64-bit Arm Linux target. On Fedora, only building kernels is currently supported, so these examples apply to Ubuntu.
 
 ```bash { target="ubuntu:latest" }
-arm-linux-gnueabihf-gcc  hello-world-embedded.c -o hello-world.elf
+aarch64-linux-gnu-gcc hello-world.c -o hello-world-aarch64.elf
 ```
 
-To cross-compile hello-world as a 64-bit Linux application. On Fedora, only building kernels is currently supported. Support for cross-building user space programs is not currently provided as that would massively multiply the number of packages.
+To cross-compile for a 32-bit Arm Linux target:
 
 ```bash { target="ubuntu:latest" }
-aarch64-linux-gnu-gcc hello-world-embedded.c -o hello-world.elf
+arm-linux-gnueabihf-gcc hello-world.c -o hello-world-arm.elf
 ```
