How To Check Linux Architecture : Determining CPU Architecture Type

by

Linux architecture is determined with `uname -m`, which outputs something like `x86_64` or `aarch64`. If you need to know How To Check Linux Architecture for installing software or troubleshooting compatibility, this guide covers every method. You will learn commands for 32-bit, 64-bit, ARM, and other systems quickly.

Knowing your Linux architecture helps you download the right packages. It also prevents errors when running binaries or compiling code. Let’s start with the fastest way to get this information.

How To Check Linux Architecture

The simplest command to check architecture is `uname -m`. Open your terminal and type:

uname -m

This prints the machine hardware name. Common outputs include:

  • x86_64 – 64-bit Intel or AMD processor
  • i686 or i386 – 32-bit Intel or AMD processor
  • aarch64 – 64-bit ARM processor
  • armv7l – 32-bit ARM processor
  • ppc64le – 64-bit PowerPC

That is all you need for most cases. But there are other commands that give more detail.

Using The Uname Command With Options

The `uname` command has several flags. `uname -a` shows all system information including kernel version and architecture. Run it like this:

uname -a

Example output:

Linux server01 5.15.0-91-generic #101-Ubuntu SMP Tue Nov 14 13:30:08 UTC 2023 x86_64 x86_64 x86_64 GNU/Linux

Notice the `x86_64` appears twice. The first one is the architecture. You can also use `uname -p` for processor type, but this sometimes returns “unknown” on some systems.

Checking Architecture With The Arch Command

Some distributions include the `arch` command. It is shorter than `uname -m` and does the same thing:

arch

Output is identical to `uname -m`. If you get “x86_64”, you are on 64-bit. If you get “i686”, it is 32-bit.

Using The Lscpu Command For Detailed Info

The `lscpu` command reads CPU information from `/proc/cpuinfo`. It shows architecture, CPU cores, and more. Type:

lscpu | grep Architecture

Full output looks like this:

Architecture:            x86_64
CPU op-mode(s):         32-bit, 64-bit
Byte Order:             Little Endian
CPU(s):                 4
...

The “CPU op-mode(s)” line tells you if your system supports 32-bit and 64-bit operations. This is useful for compatibility.

Reading The /Proc/Cpuinfo File Directly

You can also check the file directly. Use `cat` or `grep`:

cat /proc/cpuinfo | grep "model name" | head -1

For architecture specifically, run:

grep "flags" /proc/cpuinfo | head -1

Look for “lm” in the flags. “lm” stands for Long Mode, which means 64-bit support. If you see “lm”, your CPU is 64-bit capable. If not, it is 32-bit only.

Checking Architecture On Different Distributions

The commands work on Ubuntu, Debian, Fedora, CentOS, Arch Linux, and others. However, some distributions have unique tools:

  • Debian/Ubuntu: `dpkg –print-architecture` shows the package architecture (e.g., amd64, i386).
  • Red Hat/CentOS/Fedora: `rpm -q –qf “%{ARCH}”` for installed packages, but `uname -m` is simpler.
  • Arch Linux: `uname -m` works fine. Also check `/etc/pacman.conf` for multilib support.

Detecting 32-Bit Vs 64-Bit Systems

Sometimes you need to know if your system is 32-bit or 64-bit. Here are clear indicators:

  1. uname -m returns x86_64 or aarch64 – definitely 64-bit.
  2. uname -m returns i686 or i386 – 32-bit.
  3. getconf LONG_BIT – run this command. It prints 32 or 64.
getconf LONG_BIT

If it prints 64, your system is 64-bit. If 32, it is 32-bit. This is reliable because it checks the C library’s word size.

Using The File Command On Binaries

You can also check architecture by examining a binary file. For example, check the `ls` command:

file /bin/ls

Output:

/bin/ls: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=..., for GNU/Linux 2.6.32

The “64-bit” and “x86-64” confirm the architecture. This method is useful if you cannot run commands due to a broken system.

Checking Architecture For ARM Devices

ARM systems are common in Raspberry Pi, servers, and embedded devices. Use `uname -m` as usual:

  • aarch64 – 64-bit ARM (e.g., Raspberry Pi 3/4/5 with 64-bit OS).
  • armv7l – 32-bit ARM (e.g., older Raspberry Pi or 32-bit OS).

You can also check with `lscpu`:

lscpu | grep "Architecture"

For ARM, the output might show “aarch64” or “armv7l”. If you see “armv6l”, it is an older ARMv6 CPU like Raspberry Pi 1.

Why Architecture Matters For Software Installation

Installing wrong architecture packages can break your system. Here is why checking matters:

  • Binary compatibility: A 64-bit binary will not run on a 32-bit kernel without compatibility libraries.
  • Package managers: `apt` or `yum` automatically select the right architecture, but manual downloads need attention.
  • Container images: Docker images are tagged by architecture (e.g., `linux/amd64`, `linux/arm64`).
  • Compiling from source: `./configure` scripts detect architecture automatically, but you can override with `–host` flag.

Common Mistakes When Checking Architecture

People often confuse architecture with kernel version or CPU model. Here are pitfalls:

  • Using `uname -r` – this shows kernel release, not architecture.
  • Assuming 64-bit CPU means 64-bit OS – you can run a 32-bit OS on a 64-bit CPU.
  • Checking `/proc/cpuinfo` for “arch” field – there is no such field. Look for “flags” instead.
  • Using `uname -p` – it may return “unknown” on some systems.

How To Check Architecture Without Terminal

If you prefer GUI, most desktop environments show system info:

  • GNOME: Settings > About > Device Name > Architecture (e.g., “64-bit”).
  • KDE: System Settings > About This System > Architecture.
  • XFCE: Settings Manager > About > Architecture.

But the terminal method is faster and works on servers without GUI.

Checking Architecture In Scripts

You can use architecture in shell scripts for conditional logic. Example:

#!/bin/bash
ARCH=$(uname -m)
if [ "$ARCH" = "x86_64" ]; then
    echo "64-bit Intel/AMD"
elif [ "$ARCH" = "aarch64" ]; then
    echo "64-bit ARM"
else
    echo "Unknown architecture: $ARCH"
fi

This helps when automating installations or compiling software.

Using Dpkg Or Rpm To Check Package Architecture

Package managers store architecture information. For Debian-based systems:

dpkg --print-architecture

Outputs “amd64” for 64-bit or “i386” for 32-bit. For Red Hat-based systems:

rpm -q --qf "%{ARCH}" package_name

But `uname -m` is simpler for the system architecture.

Cross-Compilation And Architecture Detection

When cross-compiling, you need to specify the target architecture. Use `gcc -dumpmachine` to see the compiler’s target:

gcc -dumpmachine

Output like “x86_64-linux-gnu” indicates the architecture. For cross-compilers, it shows the target, not the host.

Checking Architecture On Containers

Inside a Docker container, `uname -m` shows the container’s architecture, which matches the host unless you use emulation. For example:

docker run --rm alpine uname -m

If you run an ARM container on x86_64 with QEMU, it shows “aarch64”.

Frequently Asked Questions

What is the difference between x86_64 and amd64?

They are the same. x86_64 is the generic name, while amd64 is used by Debian/Ubuntu for 64-bit Intel/AMD processors. Both mean 64-bit.

How do I check if my Linux is 32-bit or 64-bit?

Run `getconf LONG_BIT`. It prints 32 or 64. Alternatively, use `uname -m` and look for x86_64 (64-bit) or i686 (32-bit).

Can I run 32-bit software on a 64-bit Linux?

Yes, if you have multiarch support. On Debian/Ubuntu, enable i386 architecture with `dpkg –add-architecture i386` and install 32-bit libraries.

What does aarch64 mean?

It stands for ARM Architecture 64-bit. It is used for 64-bit ARM processors like those in Raspberry Pi 3/4/5 and many servers.

Why does uname -m show i686 on a modern CPU?

You are running a 32-bit operating system. The CPU may be 64-bit capable, but the OS is installed in 32-bit mode. Reinstall a 64-bit OS to use full capabilities.

Summary Of Commands

Here is a quick reference table for checking architecture:

Command Output Example What It Shows
uname -m x86_64 Machine hardware name
arch x86_64 Same as uname -m
lscpu | grep Architecture Architecture: x86_64 Detailed CPU info
getconf LONG_BIT 64 Word size of OS
dpkg –print-architecture amd64 Package architecture (Debian)
file /bin/ls ELF 64-bit LSB… Binary file type

Use these commands to quickly determine your system’s architecture. The most reliable is `uname -m` because it works on all distributions and environments.

Now you know multiple ways to check Linux architecture. Start with `uname -m` for a quick answer, and use `lscpu` or `getconf LONG_BIT` for more details. This knowledge helps you avoid software compatibility issues and ensures smooth system operation.