How to Install GCC on Linux Mint 22 and 21

If you’re looking for a GCC download for Linux Mint, APT already handles the standard toolchain cleanly. To install GCC on Linux Mint, the quickest path is sudo apt install build-essential, which brings in gcc, the g++ C++ compiler, make, and the headers most common C and C++ projects expect.

Mint 22 ships GCC 13 as the default compiler and offers GCC 14 as an extra package, while Mint 21 ships GCC 11 by default and tops out at GCC 12 through APT. From there, you can stay on Mint’s packaged toolchain, pull newer patch releases from the Ubuntu Toolchain PPA, switch the active unversioned compiler with update-alternatives, or build the current upstream GCC source release when the packaged branches are not new enough.

Install GCC on Linux Mint

Start with the normal package-managed path unless you already know you need a newer upstream release or custom configure flags.

Update Linux Mint before installing GCC

Refresh the package index first so the compiler packages and dependency metadata match your current Mint release.

sudo apt update && sudo apt upgrade

These commands use sudo for tasks that need root privileges. If your account does not have sudo access yet, follow the guide on how to create and add users to sudoers on Linux Mint.

Three install paths cover the usual GCC scenarios on Linux Mint.

Method	GCC Versions	Best For	Trade-offs
Default APT packages	Mint 22.x: GCC 9 through 14; Mint 21.x: GCC 9 through 12	Most development work, distro-tested builds, versioned GCC packages	Mint 21 cannot reach GCC 13 or newer through packages
Ubuntu Toolchain PPA	Newer patch releases for the packaged GCC branches	Developers who want newer fixes without moving to a source build	Does not unlock new major GCC branches on Mint 21
Source build	Current upstream source release; examples use GCC 16.1.0 with signature verification	Mint 21 users who need GCC 13+, custom prefixes, or newer upstream features	Longer build time, manual maintenance, separate runtime library path

Use the default APT packages when you want the simplest and safest GCC install on Linux Mint.
Use the Ubuntu Toolchain PPA only when you want newer patch releases for the same GCC branches Mint already packages.
Use the source-build path when Mint 21 needs GCC 13 or newer, or when you want a custom upstream toolchain outside Mint’s package database.

Mint 22 already gives you GCC 14 through the default repositories, so the Toolchain PPA is mostly about newer patch releases there. Mint 21 stops at GCC 12 in APT, and the Toolchain PPA does not change that major-version ceiling.

Install the default GCC toolchain on Linux Mint

build-essential is the normal starting point because it installs the C compiler, the g++ C++ compiler, Make, and the standard development package set in one step. On most Linux Mint systems, that means you do not need a separate GCC or C++ compiler download unless you want a specific versioned package or a newer upstream branch.

sudo apt install build-essential

Check the installed compiler and use the which command in Linux with examples to confirm that Mint is still using the package-managed binary under /usr/bin/gcc.

gcc --version
which gcc

Linux Mint 22.x output:

gcc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0
Copyright (C) 2023 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

/usr/bin/gcc

Linux Mint 21.x output:

gcc (Ubuntu 11.4.0-1ubuntu1~22.04.3) 11.4.0
Copyright (C) 2021 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

/usr/bin/gcc

The package suffix after the version number may change with security or bug-fix updates, but the key checks stay the same: GCC runs, and the binary lives under /usr/bin/gcc.

Install versioned GCC packages on Linux Mint

Install versioned gcc-NN and g++-NN packages when one project needs a newer or older compiler than Mint’s default.

Linux Mint 22.x

sudo apt install gcc-14 g++-14
sudo apt install gcc-13 g++-13
sudo apt install gcc-12 g++-12
sudo apt install gcc-11 g++-11

Linux Mint 21.x

sudo apt install gcc-12 g++-12
sudo apt install gcc-11 g++-11
sudo apt install gcc-10 g++-10
sudo apt install gcc-9 g++-9

Verify the versioned compiler directly instead of assuming the unversioned gcc command has changed.

Linux Mint 22.x example

gcc-14 --version

gcc-14 (Ubuntu 14.2.0-4ubuntu2~24.04.1) 14.2.0

Linux Mint 21.x example

gcc-12 --version

gcc-12 (Ubuntu 12.3.0-1ubuntu1~22.04.3) 12.3.0

Add the Ubuntu Toolchain PPA for GCC patch updates

The Ubuntu Toolchain PPA is optional on Linux Mint. It does not add GCC 13 or 14 to Mint 21, but it can move the existing packaged branches to newer patch levels.

If add-apt-repository is missing on a minimal or stripped-down Mint system, install the helper first.

sudo apt install mintsources

Add the PPA, then refresh package metadata before checking the candidate versions.

sudo add-apt-repository ppa:ubuntu-toolchain-r/ppa -y
sudo apt update

On Mint 22.x, relevant output includes the Launchpad fetch lines for the new source. Mint 21 shows the same Launchpad path with jammy in place of noble.

Get:10 https://ppa.launchpadcontent.net/ubuntu-toolchain-r/ppa/ubuntu noble InRelease [24.3 kB]
Get:13 https://ppa.launchpadcontent.net/ubuntu-toolchain-r/ppa/ubuntu noble/main i386 Packages [182 kB]
Get:20 https://ppa.launchpadcontent.net/ubuntu-toolchain-r/ppa/ubuntu noble/main amd64 Packages [256 kB]

Verify what the PPA actually changed. On Mint 22, checking gcc-14 is the quickest proof. On Mint 21, check gcc-12 because GCC 13 and 14 still are not packaged there.

Linux Mint 22.x example

apt-cache policy gcc-14

Relevant output includes:

gcc-14:
  Installed: 14.2.0-4ubuntu2~24.04.1
  Candidate: 14.3.0-12ubuntu1~24~ppa1
  Version table:
     14.3.0-12ubuntu1~24~ppa1 500
        500 https://ppa.launchpadcontent.net/ubuntu-toolchain-r/ppa/ubuntu noble/main amd64 Packages

Linux Mint 21.x example

apt-cache policy gcc-12

Relevant output includes:

gcc-12:
  Installed: 12.3.0-1ubuntu1~22.04.3
  Candidate: 12.5.0-8ubuntu1~22~ppa1
  Version table:
     12.5.0-8ubuntu1~22~ppa1 500
        500 https://ppa.launchpadcontent.net/ubuntu-toolchain-r/ppa/ubuntu jammy/main amd64 Packages

If you only needed the PPA for a newer patch level, install the updated package with the same versioned commands from the earlier section. If you were hoping for GCC 13 or 14 on Mint 21, skip the PPA and move straight to the source-build method below.

Compile GCC from Source on Linux Mint

Source compilation is the practical path when Mint’s packaged branches are not new enough, especially on Mint 21 where APT stops at GCC 12. It also lets you keep a custom upstream compiler under its own prefix instead of replacing Mint’s packaged toolchain.

Use GCC 16.1.0 in the examples below unless the detection step prints a newer release. The commands install the compiler with C and C++ support under its own /usr/local prefix, so Mint’s packaged /usr/bin/gcc stays in place. Keep at least 8 to 10 GB of free space available under your home directory while the compile runs.

Install GCC source-build dependencies on Linux Mint

Install the full dependency set first so configure and download_prerequisites can finish without missing-library errors.

sudo apt install build-essential libc6-dev flex bison libgmp3-dev libmpc-dev libmpfr-dev libisl-dev texinfo curl wget xz-utils gnupg

Detect the latest GCC release on Linux Mint

Run the next blocks in the same terminal session so the version, archive, and prefix variables stay available for the download and build steps. The detection line uses the curl command in Linux to read the GNU index, grep command examples in Linux to pull the newest GCC directory name, and the sed command in Linux with examples to strip the leading gcc- text from that directory name.

GCC_VERSION=$(curl -fsSL https://ftp.gnu.org/gnu/gcc/ | grep -oE 'gcc-[0-9]+\.[0-9]+\.[0-9]+' | sort -Vu | tail -n1 | sed 's/^gcc-//')
PREFIX="/usr/local/$GCC_VERSION"
ARCHIVE="gcc-$GCC_VERSION.tar.xz"
URL="https://ftp.gnu.org/gnu/gcc/gcc-$GCC_VERSION/$ARCHIVE"
SIG_URL="$URL.sig"

printf 'Latest GCC release: %s\nInstall prefix: %s\nArchive URL: %s\nSignature URL: %s\n' "$GCC_VERSION" "$PREFIX" "$URL" "$SIG_URL"

Relevant output includes:

Latest GCC release: 16.1.0
Install prefix: /usr/local/16.1.0
Archive URL: https://ftp.gnu.org/gnu/gcc/gcc-16.1.0/gcc-16.1.0.tar.xz
Signature URL: https://ftp.gnu.org/gnu/gcc/gcc-16.1.0/gcc-16.1.0.tar.xz.sig

Download and verify the GCC source tree on Linux Mint

Download the archive and its detached signature under your home directory.

mkdir -p "$HOME/gcc-source-test"
cd "$HOME/gcc-source-test"
curl -fsSLO "$URL"
curl -fsSLO "$SIG_URL"

Verify the archive before extraction. The full fingerprint below matches the current GCC release key published on the official GCC mirror page.

GCC_KEY_FPR="D3A93CAD751C2AF4F8C7AD516C35B99309B5FA62"
gpg --keyserver hkps://keyserver.ubuntu.com --recv-keys "$GCC_KEY_FPR"
gpg --verify "$ARCHIVE.sig" "$ARCHIVE"

Relevant output includes the key ID, a good-signature line, and the same full fingerprint. GPG may still warn that the key is not certified unless you have personally trusted it in your keyring.

gpg:                using RSA key 6C35B99309B5FA62
gpg: Good signature from "Jakub Jelinek <jakub@redhat.com>" [unknown]
Primary key fingerprint: D3A9 3CAD 751C 2AF4 F8C7  AD51 6C35 B993 09B5 FA62

Extract the verified archive, then let GCC fetch the extra math libraries its build expects.

tar -xf "$ARCHIVE"
cd "gcc-$GCC_VERSION"
./contrib/download_prerequisites
mkdir -p build

Configure GCC on Linux Mint

Use an out-of-tree build directory so the unpacked source stays clean. The --disable-bootstrap flag cuts build time on smaller Mint systems by skipping GCC’s self-hosting validation pass, which is a reasonable trade-off for a local custom toolchain.

cd "$HOME/gcc-source-test/gcc-$GCC_VERSION/build"
../configure --prefix="$PREFIX" --disable-multilib --enable-languages=c,c++ --disable-bootstrap

Build and install GCC on Linux Mint

The example below uses -j2 because it behaves safely on smaller Mint VMs. Raise the job count only if you know your machine has the spare CPU and memory for a heavier compile.

cd "$HOME/gcc-source-test/gcc-$GCC_VERSION/build"
make -j2
sudo make install

Register the custom runtime library directory next so binaries built with this GCC release can find the matching libstdc++ and related libraries.

printf '%s\n' "$PREFIX/lib64" | sudo tee "/etc/ld.so.conf.d/$GCC_VERSION.conf" > /dev/null
sudo ldconfig

Verify the custom compiler by calling it through the full path instead of replacing Mint’s package-managed /usr/bin/gcc.

"$PREFIX/bin/gcc" --version
"$PREFIX/bin/g++" --version

The first line from each command should match the release stored in $GCC_VERSION.

gcc (GCC) 16.1.0
g++ (GCC) 16.1.0

Create a quick hello-world test with the custom compiler if you want to prove the new toolchain is usable before you point a real project at it.

cat <<'EOF' > hello-source.c
#include <stdio.h>

int main(void) {
    printf("hello from custom gcc\n");
    return 0;
}
EOF

"$PREFIX/bin/gcc" hello-source.c -o hello-source
./hello-source

Expected output:

hello from custom gcc

Create a GCC update script on Linux Mint

If you plan to keep tracking upstream GCC releases, save a reusable helper under /usr/local/bin/update-gcc-source instead of rebuilding from scratch from memory a few months from now.

Run this helper manually after checking the GCC release notes. Do not schedule it in cron, because source-built compiler upgrades deserve a quick review before you add a new custom prefix or point projects at a newer compiler.

This helper lives under /usr/local/bin, so the pipeline uses sudo tee because plain > redirection would not write to a root-owned path.

cat <<'EOF' | sudo tee /usr/local/bin/update-gcc-source > /dev/null
#!/bin/bash
set -e

BUILD_ROOT="$HOME/gcc-source-test"
LATEST=$(curl -fsSL https://ftp.gnu.org/gnu/gcc/ | grep -oE 'gcc-[0-9]+\.[0-9]+\.[0-9]+' | sort -Vu | tail -n1 | sed 's/^gcc-//')
PREFIX="/usr/local/$LATEST"
ARCHIVE="gcc-$LATEST.tar.xz"
URL="https://ftp.gnu.org/gnu/gcc/gcc-$LATEST/$ARCHIVE"
SIG_URL="$URL.sig"
KEY_FPR="D3A93CAD751C2AF4F8C7AD516C35B99309B5FA62"

for cmd in curl tar make gcc gpg; do
    command -v "$cmd" > /dev/null 2>&1 || {
        echo "Missing required command: $cmd"
        exit 1
    }
done

if [ -x "$PREFIX/bin/gcc" ]; then
    echo "GCC $LATEST is already installed at $PREFIX"
    exit 0
fi

echo "Building GCC $LATEST under $BUILD_ROOT"
mkdir -p "$BUILD_ROOT"
cd "$BUILD_ROOT"
rm -rf "gcc-$LATEST"
rm -f "$ARCHIVE" "$ARCHIVE.sig"
curl -fsSLO "$URL"
curl -fsSLO "$SIG_URL"
gpg --keyserver hkps://keyserver.ubuntu.com --recv-keys "$KEY_FPR"
gpg --verify "$ARCHIVE.sig" "$ARCHIVE"
tar -xf "$ARCHIVE"
cd "gcc-$LATEST"
./contrib/download_prerequisites
mkdir -p build
cd build
../configure --prefix="$PREFIX" --disable-multilib --enable-languages=c,c++ --disable-bootstrap
make -j2
sudo make install
printf '%s\n' "$PREFIX/lib64" | sudo tee "/etc/ld.so.conf.d/$LATEST.conf" > /dev/null
sudo ldconfig
echo "Installed GCC $LATEST at $PREFIX"
EOF

sudo chmod 0755 /usr/local/bin/update-gcc-source

Verify that the helper is reachable from your shell before you rely on it later.

command -v update-gcc-source

Expected output:

/usr/local/bin/update-gcc-source

If you run the helper immediately after installing the current source release, it should stop without rebuilding because the same GCC prefix already exists.

update-gcc-source

GCC 16.1.0 is already installed at /usr/local/16.1.0

Switch GCC Versions on Linux Mint

Install the versioned packages you need first, then let update-alternatives manage which unversioned gcc, g++, and gcov commands are active.

Register GCC versions with update-alternatives on Linux Mint

Keep the slave list limited to g++ and gcov. Leaving cpp out avoids conflicts with Mint’s separate preprocessor alternative.

Linux Mint 22.x

sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-14 140 --slave /usr/bin/g++ g++ /usr/bin/g++-14 --slave /usr/bin/gcov gcov /usr/bin/gcov-14
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-13 130 --slave /usr/bin/g++ g++ /usr/bin/g++-13 --slave /usr/bin/gcov gcov /usr/bin/gcov-13

Linux Mint 21.x

sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-12 120 --slave /usr/bin/g++ g++ /usr/bin/g++-12 --slave /usr/bin/gcov gcov /usr/bin/gcov-12
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 110 --slave /usr/bin/g++ g++ /usr/bin/g++-11 --slave /usr/bin/gcov gcov /usr/bin/gcov-11

Switch the default GCC version on Linux Mint

Use the interactive selector when you want to change the default compiler for the current machine.

sudo update-alternatives --config gcc

Linux Mint 22.x output:

There are 2 choices for the alternative gcc (providing /usr/bin/gcc).

  Selection    Path             Priority   Status
------------------------------------------------------------
* 0            /usr/bin/gcc-14   140       auto mode
  1            /usr/bin/gcc-13   130       manual mode
  2            /usr/bin/gcc-14   140       manual mode

Press <enter> to keep the current choice[*], or type selection number:

Confirm the active compiler afterward with a normal version check.

gcc --version

Test GCC on Linux Mint

A short compile-and-run test is still the fastest way to prove that GCC, the linker, and your shell all agree on the same toolchain.

Create a GCC test program on Linux Mint

Write a tiny C source file in the current directory.

cat <<'EOF' > hello.c
#include <stdio.h>

int main(void) {
    puts("Hello from GCC!");
    return 0;
}
EOF

Compile and run the GCC test on Linux Mint

Compile the file, run the binary, and remove the test files when you are done.

gcc hello.c -o hello
./hello
rm hello.c hello

Expected output:

Hello from GCC!

Troubleshoot GCC on Linux Mint

Most GCC issues on Linux Mint come down to package availability on Mint 21, alternative-registration mistakes, or a missing runtime library path after a source build.

Fix "Unable to locate package gcc-14" on Linux Mint 21

Mint 21 inherits Ubuntu 22.04 package availability, so GCC 13 and 14 are not packaged there through either the default repositories or the Toolchain PPA.

apt-cache search '^gcc-[0-9]+$' | sort

Relevant output on Mint 21 includes only the versioned packages from gcc-9 through gcc-12. If you need a newer major branch there, use the source-build method or move to Mint 22.

gcc-10 - GNU C compiler
gcc-11 - GNU C compiler
gcc-12 - GNU C compiler
gcc-9 - GNU C compiler

Fix GCC version switching issues on Linux Mint

If update-alternatives complains that cpp is already a master alternative, keep cpp out of the slave list and register only gcc, g++, and gcov.

update-alternatives: error: alternative cpp can't be slave of gcc: it is a master alternative

sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-14 140 --slave /usr/bin/g++ g++ /usr/bin/g++-14 --slave /usr/bin/gcov gcov /usr/bin/gcov-14

Fix GCC source build failures on Linux Mint

Recheck the dependency list and free disk space first, because most failed GCC builds on Mint break before or during configure when one of the math libraries is missing.

sudo apt install build-essential libc6-dev flex bison libgmp3-dev libmpc-dev libmpfr-dev libisl-dev texinfo curl wget xz-utils gnupg
df -h "$HOME/gcc-source-test"

Keep at least 8 to 10 GB of free space available in the build area before you start another compile. If configure or a test compile reports fatal error: stdio.h: No such file or directory, reinstall the dependency command above so the C library development headers return before you retry the build.

Fix source-built GCC runtime library errors on Linux Mint

If a binary built with the custom toolchain fails with a missing libstdc++.so.6 or similar runtime error, refresh the source-built library path and rebuild the linker cache.

GCC_VERSION=16.1.0
printf '%s\n' "/usr/local/$GCC_VERSION/lib64" | sudo tee "/etc/ld.so.conf.d/$GCC_VERSION.conf" > /dev/null
sudo ldconfig

./program: /usr/lib/x86_64-linux-gnu/libstdc++.so.6: version 'CXXABI_1.3.15' not found

Remove GCC Versions on Linux Mint

Most systems should keep Mint’s stock compiler in place. In practice, removal usually means cleaning up an extra version, removing the optional Toolchain PPA, or deleting a source-built toolchain you no longer need.

Remove extra APT-installed GCC versions on Linux Mint

Remove only the versioned packages you added manually. If you registered them with update-alternatives, remove the alternative entry first so Mint does not keep a dead path as the selected gcc target.

Linux Mint 22.x example

sudo update-alternatives --remove gcc /usr/bin/gcc-14
sudo apt remove gcc-14 g++-14

Linux Mint 21.x example

sudo update-alternatives --remove gcc /usr/bin/gcc-12
sudo apt remove gcc-12 g++-12

Review sudo apt autoremove manually after the package removal if you want to clean up orphaned dependencies. On reused development systems, an automatic autoremove can remove more packages than you intended.

Verify that the package is no longer installed while the repository candidate still exists.

Linux Mint 22.x example

apt-cache policy gcc-14

Relevant output includes:

gcc-14:
  Installed: (none)
  Candidate: 14.2.0-4ubuntu2~24.04.1
  Version table:
     14.2.0-4ubuntu2~24.04.1 500
        500 http://archive.ubuntu.com/ubuntu noble-updates/universe amd64 Packages

Linux Mint 21.x example

apt-cache policy gcc-12

Relevant output includes:

gcc-12:
  Installed: (none)
  Candidate: 12.3.0-1ubuntu1~22.04.3
  Version table:
     12.3.0-1ubuntu1~22.04.3 500
        500 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 Packages

Remove the Ubuntu Toolchain PPA on Linux Mint

Remove the PPA after you have moved back to Mint’s repository builds or decided the extra patch updates are not worth keeping.

sudo add-apt-repository --remove ppa:ubuntu-toolchain-r/ppa -y
sudo apt update

Check the versioned package that matches your release to make sure the candidate has dropped back to Mint’s normal repository version.

Linux Mint 22.x example

apt-cache policy gcc-14

Relevant output includes:

gcc-14:
  Candidate: 14.2.0-4ubuntu2~24.04.1
  Version table:
     14.2.0-4ubuntu2~24.04.1 500
        500 http://archive.ubuntu.com/ubuntu noble-updates/universe amd64 Packages

Linux Mint 21.x example

apt-cache policy gcc-12

Relevant output includes:

gcc-12:
  Candidate: 12.3.0-1ubuntu1~22.04.3
  Version table:
     12.3.0-1ubuntu1~22.04.3 500
        500 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 Packages

Remove source-built GCC on Linux Mint

Remove the source-built tree only after you confirm Mint’s packaged /usr/bin/gcc still works for the projects you care about. This cleanup deletes the custom install prefix, its linker entry, the build tree, and the optional update helper.

If your earlier source-build detection step printed a newer release, replace 16.1.0 with that value before checking or deleting paths.

GCC_VERSION=16.1.0
printf '%s\n' \
  "/usr/local/$GCC_VERSION" \
  "/etc/ld.so.conf.d/$GCC_VERSION.conf" \
  "$HOME/gcc-source-test/gcc-$GCC_VERSION" \
  "$HOME/gcc-source-test/gcc-$GCC_VERSION.tar.xz" \
  "$HOME/gcc-source-test/gcc-$GCC_VERSION.tar.xz.sig" \
  /usr/local/bin/update-gcc-source

Review those paths before deleting them. The commands should name only the source-built GCC version, its linker-cache file, the matching source archive files, and the optional helper.

GCC_VERSION=16.1.0
sudo rm -rf "/usr/local/$GCC_VERSION"
sudo rm -f "/etc/ld.so.conf.d/$GCC_VERSION.conf"
sudo ldconfig
rm -rf "$HOME/gcc-source-test/gcc-$GCC_VERSION"
rm -f "$HOME/gcc-source-test/gcc-$GCC_VERSION.tar.xz" "$HOME/gcc-source-test/gcc-$GCC_VERSION.tar.xz.sig"
sudo rm -f /usr/local/bin/update-gcc-source

Verify that the custom compiler path is gone.

GCC_VERSION=16.1.0
if [ -x "/usr/local/$GCC_VERSION/bin/gcc" ]; then echo present; else echo removed; fi

Expected output:

removed

Conclusion

GCC is ready on Linux Mint for C and C++ builds, whether you stay on Mint’s packaged toolchain or keep a separate source-built compiler for newer releases. Next, install Git on Linux Mint for version control, install VS Code on Linux Mint for editing and debugging, or install Rust on Linux Mint when you want another systems language alongside GCC.

2 thoughts on “How to Install GCC on Linux Mint 22 and 21”

Tom

Friday, November 22, 2024 at 9:48 pm

This is not working if you are on mint 21 and want g++-14 and gcc-14. There is no package.
- Joshua James
  
  Saturday, November 23, 2024 at 3:08 pm
  
  Seems only for Linux Mint 22 onwards, sorry I will make a note of this. You would need to download and compile it.