How To Install Arch Linux: A Clear Step‑by‑Step Overview

Installing Arch Linux is very different from installing most other desktop operating systems. There’s no “Next, Next, Finish” installer. Instead, Arch gives you a toolbox and expects you to assemble the system yourself.

That’s why people like it: you get full control over what’s installed, how it’s configured, and how it boots. But that control comes with responsibility and a learning curve.

This guide walks through the core steps of installing Arch on a typical PC, explains what each step does, and highlights where your own hardware, goals, and skill level will change the details.

What “Installing Arch” Actually Means

Arch doesn’t install a preconfigured desktop. Instead, you:

1. Boot the live environment (from USB/ISO).
2. Prepare the disk (partition, format, mount).
3. Install the base system (minimal Linux environment).
4. Configure the system (time, locale, users, bootloader).
5. Optionally install a desktop (GNOME, KDE, i3, etc.).

Everything after the base system is your choice: desktop environment, display manager, file systems, extra packages, and even whether you want a graphical interface at all.

Pre‑Install Checks: Are You Ready for Arch?

Before typing a single command, a few basics matter:

• Hardware

  • A 64‑bit CPU (most modern PCs are fine).
  • At least 2 GB of RAM for a basic system (4+ GB is more comfortable with a desktop).
  • Enough disk space: 20 GB minimum for experiments, more if you’ll install many apps.

• UEFI vs Legacy BIOS

  • Newer machines typically use UEFI and may have Secure Boot enabled.
  • Older machines may still use Legacy/CSM boot.

• Internet connection

  • Arch installs from the internet, not from a big offline image.
  • A wired connection is easiest; Wi‑Fi works but needs extra steps.

Here’s how those differences matter:

Step 1: Boot the Arch ISO

1. Download the Arch ISO from the official Arch Linux site.
2. Create a bootable USB using tools like Rufus, BalenaEtcher, or dd on Linux.
3. Boot from the USB:
   • Enter your BIOS/UEFI boot menu (often F2, F12, Esc, or Del at startup).
   • Choose the USB drive.

If all goes well, you’ll end up in a terminal-based live environment, not a graphical installer. You’ll see a shell prompt like:

root@archiso ~ # 

From here, you build the system.

Step 2: Set Keyboard and Network

Set keyboard layout (if needed)

If you’re not using a US keyboard:

ls /usr/share/kbd/keymaps/**/*.map.gz # list layouts loadkeys your_layout 

Example:

loadkeys de-latin1 

Connect to the internet

• Wired (Ethernet) often works automatically. Check with:

ping archlinux.org 

• Wi‑Fi (using iwctl on the live image):

iwctl device list # see your Wi‑Fi device station wlan0 scan # scan networks station wlan0 get-networks station wlan0 connect YOUR_SSID exit 

Then verify with another ping.

Why this matters: some setups install Arch without network (e.g., local mirrors), but the standard method expects online package downloads.

Step 3: Prepare the Disk (Partitioning and Formatting)

This is where your disk layout decisions come in.

Identify your target disk

lsblk 

You’ll see something like /dev/sda, /dev/nvme0n1, or /dev/vda. Be sure you know which one you’re installing on, especially if you have multiple drives.

Choose a partitioning scheme

For UEFI systems, a common simple layout is:

• EFI System Partition (ESP) – small FAT32 partition (~300–512 MB)
• Root partition / – the rest of the space
• Optional: Swap partition or swap file

For Legacy BIOS, you can use:

• Single root partition (and optionally swap)
• No EFI partition required

Tools commonly used:

• cfdisk (menu-based, user-friendly)
• fdisk or parted (more manual)

Example with cfdisk:

cfdisk /dev/sda 

Inside cfdisk:

1. Select GPT (for UEFI) or dos/MBR (for Legacy).
2. Create partitions:
   • EFI (if UEFI): type EFI System
   • Root: type Linux filesystem
   • Optional: Swap: type Linux swap

Format partitions

Assume:

• EFI partition: /dev/sda1
• Root partition: /dev/sda2
• Optional swap: /dev/sda3

Format them:

mkfs.fat -F32 /dev/sda1 # EFI partition (UEFI only) mkfs.ext4 /dev/sda2 # root partition mkswap /dev/sda3 # swap (optional) swapon /dev/sda3 # enable swap (optional) 

Mount the root and EFI partition

mount /dev/sda2 /mnt # mount root mkdir -p /mnt/boot/efi # prepare mount point for EFI mount /dev/sda1 /mnt/boot/efi # mount EFI (UEFI installs) 

Different users may:

• Use Btrfs, XFS, or LUKS encryption instead of plain ext4.
• Set up complex layouts (separate /home, multiple disks, RAID).

Those choices change commands and complexity, but the idea (partition → format → mount) is the same.

Step 4: Install the Base Arch System

With disks mounted and network ready, you use pacstrap to install a minimal system onto /mnt.

A typical command:

pacstrap -K /mnt base linux linux-firmware 

You can add more essential packages (like editor and tools):

pacstrap -K /mnt base linux linux-firmware nano vim networkmanager 

• base → core utilities
• linux → Linux kernel
• linux-firmware → firmware for hardware like Wi‑Fi and GPUs
• networkmanager → easier network management after install

Different users might add:

• intel-ucode or amd-ucode (CPU microcode updates)
• sudo, bash-completion, git, etc.

Step 5: Generate the File System Table (fstab)

fstab tells your system what to mount at boot.

Generate it:

genfstab -U /mnt >> /mnt/etc/fstab 

You can inspect it:

cat /mnt/etc/fstab 

Check that your root, EFI, and any swap or extra partitions are listed.

Step 6: Chroot into Your New System

Now “enter” your installed system from the live environment:

arch-chroot /mnt 

From now on, commands affect your new Arch system, not the live USB.

Step 7: Basic System Configuration

Set time zone and clock

ln -sf /usr/share/zoneinfo/Region/City /etc/localtime hwclock --systohc 

Example:

ln -sf /usr/share/zoneinfo/Europe/Berlin /etc/localtime hwclock --systohc 

Configure locales (language settings)

Edit /etc/locale.gen and uncomment your language(s), e.g.:

en_US.UTF-8 UTF-8 

Then generate:

locale-gen echo "LANG=en_US.UTF-8" > /etc/locale.conf 

Set hostname and hosts file

echo "archpc" > /etc/hostname 

Edit /etc/hosts to include:

127.0.0.1 localhost ::1 localhost 127.0.1.1 archpc.localdomain archpc 

Set root password

passwd 

You’ll be prompted to enter a secure password.

Step 8: Install and Configure a Bootloader

This depends heavily on UEFI vs Legacy and personal preference.

Using GRUB on UEFI (common setup)

Install GRUB and supporting packages:

pacman -S grub efibootmgr 

Install GRUB to the disk:

grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=Arch 

Generate the GRUB config file:

grub-mkconfig -o /boot/grub/grub.cfg 

Using GRUB on Legacy BIOS

pacman -S grub grub-install /dev/sda # no partition number grub-mkconfig -o /boot/grub/grub.cfg 

Alternatives include systemd-boot or rEFInd, which have different install steps and are often preferred by advanced users or minimalists.

Step 9: Enable Networking and Create a User

Enable NetworkManager (if you installed it)

systemctl enable NetworkManager 

This will manage wired and Wi‑Fi after boot.

Create a regular user

useradd -m -G wheel -s /bin/bash yourname passwd yourname 

Allow wheel group to use sudo (if you installed sudo):

1. Install sudo if not present:

   pacman -S sudo 

2. Run:

   EDITOR=nano visudo 

3. Uncomment the line:

   %wheel ALL=(ALL:ALL) ALL 

Now your user can run administrative commands with sudo.

Step 10: Exit, Unmount, and Reboot

Leave the chroot:

exit 

Unmount all partitions:

umount -R /mnt 

Then reboot:

reboot 

Remove the USB when the system powers down or when the firmware screen appears. If all is set up correctly, you’ll boot into your new Arch system.

At this point, you’ll likely land in a terminal login (no GUI yet) where you can log in with your user account.

After the Install: Headless, Minimal, or Full Desktop?

From a bare Arch system, there are several common paths:

• Server / headless

  • No GUI.
  • Install services like openssh, web servers, Docker, etc.

• Minimal tiling window manager

  • Lightweight setups with i3, Sway, or AwesomeWM.
  • Good for low‑resource systems or power users who like keyboard-driven workflows.

• Full desktop environment

  • GNOME, KDE Plasma, Xfce, Cinnamon, etc.
  • More familiar for users coming from Windows or other mainstream Linux distros.

Example of installing a basic GNOME desktop (on Xorg, with display manager):

sudo pacman -S xorg gnome gnome-shell-extensions gdm sudo systemctl enable gdm 

Reboot and you get a graphical login.

The exact commands and package choices vary based on:

• GPU type (Intel, AMD, NVIDIA → different drivers)
• RAM and CPU (heavy vs lightweight desktops)
• Use case (development, gaming, media, server tasks)

How Your Setup Changes the “Right” Arch Install

The core steps stay the same—boot, partition, mount, install base, configure—but different users diverge in important ways.

By hardware

• Modern laptop (UEFI, NVMe)

  • GPT partitioning with EFI, potential power‑saving tweaks, Wi‑Fi setup, touchpad drivers.

• Older desktop (Legacy BIOS, HDD)

  • MBR partitioning, simpler bootloader install, but slower disk—maybe more lightweight desktop.

• Hybrid graphics / NVIDIA GPUs

  • Extra care around proprietary drivers vs open drivers.
  • May influence your choice of display manager and desktop environment.

By skill level

• Beginner to Arch

  • Likely to choose ext4, GRUB, NetworkManager, simple single partition for /.
  • Might follow the Arch Installation Guide very closely.

• Intermediate / advanced

  • May use full disk encryption (LUKS), Btrfs with subvolumes, snapshots, systemd-boot, and custom kernel parameters.
  • Might script the install or use tools like archinstall.

By use case

• Daily desktop

  • Focus on hardware support, a stable desktop environment, fonts, multimedia codecs, and browser setup.

• Development machine

  • Extra tooling: language runtimes, containers, virtualization, editors, and database services.

• Specialized workstation

  • Audio production, 3D rendering, or machine learning may require low-latency kernels, specific GPU drivers, and extra system tuning.

Installing Arch is ultimately a framework rather than a single fixed recipe. The steps above describe the backbone that almost every installation shares, but the “right” choices at each step—file system, bootloader, partitioning style, encryption, desktop environment, and extra packages—depend entirely on your hardware, your Linux experience, and what you want this Arch system to do once it’s up and running.