How to Install Arch Linux from Scratch: A Complete Step-by-Step Guide

Arch Linux has a reputation for being difficult to install, and that reputation is half-deserved. There's no graphical installer, no "next, next, finish" wizard. You get a root shell on a live ISO and a wiki. But here's the thing -- if you can follow commands in a terminal, you can install Arch. The process is methodical, not mysterious. As Arch founder Judd Vinet explained in a 2007 interview, "Simplicity, flexibility, and transparency are tenets of Arch Linux. We try to stick to the KISS principle whenever we can." That philosophy is exactly why the installer is the way it is -- it puts you in control of every decision. This guide walks through every step from the moment you boot the USB drive to a fully functional system with a desktop environment, with every command explained so you understand what each one does and why.

Why Arch Linux?

Before spending an hour on a manual install, it's worth understanding what you get in return. Arch is a rolling release distribution, meaning you install once and update forever -- no version upgrades, no reinstalls. You always have the latest stable packages. As the ArchWiki describes it, "Arch is a rolling-release model backed by pacman, a lightweight, simple and fast package manager that allows for continuously upgrading the entire system with one command." The Arch User Repository (AUR) gives you access to over 80,000 community-maintained packages covering virtually every piece of software that runs on Linux, usually up to date within hours of upstream releases.

The real value, though, is understanding. By building the system yourself, you know exactly what's running, why it's there, and how to fix it when something breaks. There are no hidden layers of abstraction between you and the machine. The ArchWiki is also one of the highest quality documentation resources in the entire Linux ecosystem -- even users of other distributions frequently reference it. Installing Arch manually is what gives you the knowledge to use that documentation effectively.

Prerequisites

Before you begin, make sure you have the following ready. A USB drive (2 GB minimum) flashed with the latest Arch Linux ISO, which you can download from archlinux.org/download. Use a tool like dd, Ventoy, Rufus, or balenaEtcher to write the ISO to the drive. The official installation guide recommends verifying the ISO signature before use, especially when downloading from an HTTP mirror, to ensure the image hasn't been tampered with. You'll also need a wired or wireless internet connection -- the installer needs to pull packages from the repositories. Finally, know your hardware: whether you have an Intel or AMD CPU (this determines which microcode package to install), and whether your GPU is Intel, AMD, or NVIDIA.

Booting the Live Environment

Insert the USB drive and boot from it. You'll typically need to press F2, F12, Del, or Esc during POST to access your firmware's boot menu -- the exact key depends on your motherboard manufacturer. Select the USB device and choose the UEFI boot entry for Arch Linux.

After a few seconds, you'll land at a root shell. This is the Arch live environment. Everything from here is typed directly into this terminal.

Verify Boot Mode

First, confirm you're booted in UEFI mode. If this directory exists and contains files, you're in UEFI mode:

If the directory doesn't exist, you've booted in BIOS/CSM mode. Reboot and check your firmware settings to ensure UEFI is enabled.

Set the Keyboard Layout

The default layout is US English. If you need a different layout, list available keymaps and load one:

# List available keymaps
# localectl list-keymaps

# Load a keymap (e.g., German)
# loadkeys de-latin1

Connect to the Internet

If you're on Ethernet, DHCP should handle everything automatically. Test the connection:

For Wi-Fi, use iwctl to connect interactively:

# iwctl
# Inside the iwctl prompt:
[iwd]# device list
[iwd]# station wlan0 scan
[iwd]# station wlan0 get-networks
[iwd]# station wlan0 connect "YourNetworkName"
# Enter your passphrase when prompted, then exit
[iwd]# exit

Update the System Clock

Partitioning the Disk

This is the step that intimidates newcomers, but it's straightforward once you understand what you need. A UEFI system requires at minimum two partitions: an EFI System Partition (ESP) for the bootloader, and a root partition for the operating system. Adding a swap partition is optional but recommended, especially if you plan to use hibernation or have limited RAM.

First, identify your target disk:

You'll see something like /dev/sda for SATA drives or /dev/nvme0n1 for NVMe SSDs. This guide uses /dev/sda -- substitute your actual device name throughout.

Launch fdisk to create a GPT partition table and the required partitions:

# fdisk /dev/sda

# Create a new GPT partition table
Command: g

# Partition 1: EFI System Partition (512 MB)
Command: n
Partition number: 1
First sector: (press Enter for default)
Last sector: +512M
Command: t
Partition type: 1    # EFI System

# Partition 2: Swap (4 GB -- adjust to your RAM)
Command: n
Partition number: 2
First sector: (press Enter for default)
Last sector: +4G
Command: t
Partition number: 2
Partition type: 19   # Linux swap

# Partition 3: Root (remaining space)
Command: n
Partition number: 3
First sector: (press Enter for default)
Last sector: (press Enter for default -- uses remaining space)

# Write changes and exit
Command: w

Format the Partitions

Each partition needs a filesystem. The EFI partition must be FAT32, swap gets its own format, and the root partition can be ext4, btrfs, or xfs. We'll use ext4 here since it's reliable, well-tested, and has the broadest support:

# Format the EFI partition as FAT32
# mkfs.fat -F 32 /dev/sda1

# Initialize swap
# mkswap /dev/sda2
# swapon /dev/sda2

# Format root as ext4
# mkfs.ext4 /dev/sda3

Mount the Partitions

# Mount root
# mount /dev/sda3 /mnt

# Create and mount the EFI directory
# mount --mkdir /dev/sda1 /mnt/boot

Installing the Base System

With the partitions mounted, you can now install the base system using pacstrap. This downloads and installs packages directly into the mounted filesystem at /mnt.

# pacstrap -K /mnt base linux linux-firmware

This gives you a minimal but bootable Linux system. The base package includes core utilities, linux is the kernel itself, and linux-firmware provides firmware blobs for hardware support. However, for a properly functional system you'll want to add several more packages at this stage -- including your CPU's microcode updates, which the ArchWiki strongly recommends for "system stability and security":

# For Intel CPUs:
# pacstrap -K /mnt base linux linux-firmware \
    base-devel networkmanager vim sudo man-db man-pages intel-ucode

# For AMD CPUs:
# pacstrap -K /mnt base linux linux-firmware \
    base-devel networkmanager vim sudo man-db man-pages amd-ucode

System Configuration

Generate fstab

The fstab file tells the system how to mount partitions at boot. Generate it from the currently mounted layout:

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

# Verify it looks correct
# cat /mnt/etc/fstab

You should see entries for your root partition and EFI partition, referenced by UUID. If something looks wrong, edit the file before proceeding.

Chroot into the New System

Now you enter the installed system as if you booted into it. The arch-chroot wrapper handles setting up the necessary bind mounts:

From this point forward, every command runs inside your new Arch installation. Your prompt will change to reflect this.

Time Zone and Locale

# Set the time zone (adjust to your location)
# ln -sf /usr/share/zoneinfo/America/New_York /etc/localtime
# hwclock --systohc

# Generate locale
# vim /etc/locale.gen
# Uncomment the line: en_US.UTF-8 UTF-8
# locale-gen

# Set the system locale
# echo "LANG=en_US.UTF-8" > /etc/locale.conf

Hostname and Hosts

# Set your hostname
# echo "archbox" > /etc/hostname

# Configure the hosts file
# vim /etc/hosts

Add the following lines to /etc/hosts:

127.0.0.1    localhost
::1          localhost
127.0.1.1    archbox.localdomain    archbox

Set the Root Password

Create a Regular User

Running everything as root is dangerous. Create a normal user and add them to the wheel group for sudo access:

# Create the user with a home directory
# useradd -m -G wheel -s /bin/bash yourusername

# Set their password
# passwd yourusername

# Enable sudo for the wheel group
# EDITOR=vim visudo
# Uncomment the line: %wheel ALL=(ALL:ALL) ALL

Installing the Bootloader

Without a bootloader, your firmware has no way to find and start the kernel. We'll use GRUB here because it's the most widely documented and supports a huge range of configurations including dual-boot setups, encrypted volumes, and custom kernel parameters. Two solid alternatives exist: systemd-boot is lighter and simpler if you're running a UEFI-only single-OS setup, and rEFInd provides automatic kernel detection with a graphical menu. The ArchWiki boot process page has a full comparison table if you want to evaluate your options.

# Install GRUB and EFI boot manager
# pacman -S grub efibootmgr

# Install GRUB to the EFI partition
# grub-install --target=x86_64-efi --efi-directory=/boot --bootloader-id=GRUB

# Generate the GRUB configuration
# grub-mkconfig -o /boot/grub/grub.cfg

Enabling Essential Services

Before you reboot, enable the services that need to start automatically. At minimum, you need NetworkManager so you can get online after the first boot:

If you need SSH access to the machine, enable that too:

# pacman -S openssh
# systemctl enable sshd

The First Boot

Everything is in place. Exit the chroot, unmount the partitions, and reboot into your new system:

# Exit the chroot
# exit

# Unmount all partitions
# umount -R /mnt

# Reboot
# reboot

Remove the USB drive when prompted. If everything went well, GRUB will appear, then the system will boot to a login prompt. Log in with the user account you created.

Post-Installation Essentials

You now have a working Arch system, but it's bare -- just a TTY login. Here's how to build it up into something you'd actually want to use daily.

Connect to the Network

NetworkManager is running. For Wi-Fi, use nmtui for a text-based interface or nmcli from the command line:

# Interactive TUI for Wi-Fi
$ nmtui

# Or connect directly via CLI
$ nmcli device wifi connect "YourNetworkName" password "YourPassword"

Update the System

Install GPU Drivers

Graphics drivers are not included in the base install. Install the appropriate package for your hardware:

# Intel integrated graphics
$ sudo pacman -S mesa intel-media-driver

# AMD (Radeon)
$ sudo pacman -S mesa xf86-video-amdgpu vulkan-radeon

# NVIDIA (proprietary)
$ sudo pacman -S nvidia nvidia-utils

Install a Desktop Environment

Choose a desktop environment and display manager. Here are two common setups:

# Install GNOME desktop and GDM display manager
$ sudo pacman -S gnome gnome-tweaks
$ sudo systemctl enable gdm

# Install KDE Plasma and SDDM display manager
$ sudo pacman -S plasma-meta sddm konsole dolphin
$ sudo systemctl enable sddm

Reboot after enabling your display manager. On next boot, you'll be greeted with a graphical login screen.

Install an AUR Helper

The AUR gives you access to over 80,000 community packages not in the official repositories. An AUR helper automates the build process. yay and paru are the two leading options -- paru (written in Rust) shows you PKGBUILD diffs before building by default, which is safer, while yay (written in Go) is slightly more established:

# Install git (needed to clone the AUR repo)
$ sudo pacman -S git

# Clone and build yay
$ git clone https://aur.archlinux.org/yay.git
$ cd yay
$ makepkg -si

# Now you can install AUR packages like this:
$ yay -S librewolf-bin

Ongoing Maintenance

Arch is a rolling release, so maintenance is part of the deal. Unlike distributions like Ubuntu or Fedora where you can ignore updates for months, Arch works best when you update at least weekly. This prevents a massive backlog of changes that could require manual intervention. The key commands you'll use regularly:

# Full system update
$ sudo pacman -Syu

# Search for a package
$ pacman -Ss firefox

# Remove a package and its unused dependencies
$ sudo pacman -Rns package-name

# Clean the package cache (keep last 3 versions)
$ sudo paccache -r

# List orphaned packages
$ pacman -Qdt

# Remove all orphaned packages
$ sudo pacman -Rns $(pacman -Qdtq)

# Find and merge .pacnew config files
$ sudo pacdiff

Check the Arch Linux homepage before each update session. The news section occasionally posts manual intervention steps required for certain upgrades -- for example, when a configuration file format changes or when a package migration requires user action. Ignoring these notices is the single most common cause of broken Arch systems.

Over time, pacman's package cache at /var/cache/pacman/pkg/ will grow to many gigabytes. The paccache tool (from the pacman-contrib package) handles cleanup. Install it with sudo pacman -S pacman-contrib and consider enabling the paccache.timer systemd timer to automate weekly cache cleanup.

Similarly, when pacman upgrades a package whose configuration file you've modified, it saves the new version as a .pacnew file rather than overwriting your changes. Use pacdiff (also from pacman-contrib) to find and merge these files. Ignoring .pacnew files leaves your system running with outdated configurations that may eventually break.

Common Troubleshooting

Even careful installations hit snags. Here are the problems that come up frequently and how to resolve them.

No boot entry after reboot. Your firmware may not have detected the GRUB installation. Boot the live USB, chroot back in, and re-run grub-install. Some motherboards require the EFI binary at a specific fallback path -- copy it with mkdir -p /boot/EFI/BOOT && cp /boot/EFI/GRUB/grubx64.efi /boot/EFI/BOOT/BOOTX64.EFI.

No internet after first boot. Verify that NetworkManager is enabled and running with systemctl status NetworkManager. If you forgot to enable it during installation, boot the live USB and chroot to fix it.

Black screen after installing GPU drivers. This is common with NVIDIA. Boot with the nomodeset kernel parameter (edit the GRUB entry at boot by pressing e), then check that you installed the correct driver package for your card generation.

Keyring issues during pacman operations. If you see PGP signature errors, reinitialize the keyring. This is common after the system has been offline for an extended period, as packager keys may have been rotated:

$ sudo pacman-key --init
$ sudo pacman-key --populate archlinux
$ sudo pacman -Sy archlinux-keyring
$ sudo pacman -Su

Wireless firmware not loading. Some Wi-Fi chipsets (particularly Broadcom and certain Realtek models) require firmware not included in linux-firmware. Check which chipset you have with lspci -k and install the appropriate firmware package. For onboard audio that isn't detected, the sof-firmware package (Sound Open Firmware) is often the fix for newer laptops.

System hasn't been updated in months. If you've let updates lapse for a long time, check the Arch Linux news page for any manual intervention notices posted during your absence. Then update the keyring first before doing a full upgrade: sudo pacman -Sy archlinux-keyring && sudo pacman -Su. This avoids signature verification failures from expired keys.

Wrapping Up

You've just built a Linux system from the ground up. Every package on this machine is there because you put it there. Every service running is one you chose to enable. That's the entire point of Arch -- you understand what you're running because you assembled it yourself.

The Arch Wiki is going to become your best reference from here. It's one of the best-documented resources in the Linux ecosystem, covering everything from Bluetooth configuration to full disk encryption to Wayland troubleshooting. Bookmark it. Even users of Ubuntu, Fedora, and other distributions routinely cite the ArchWiki because of the depth and accuracy of its content.

"Arch Linux focuses on simplicity of design, meaning that the main focus involves creating an environment that is straightforward and relatively easy for the user to understand directly, rather than providing polished point-and-click style management tools." -- Wikipedia, Arch Linux

The real Arch Linux learning curve isn't the installation -- it's the first month of figuring out what you actually need on your machine. The installation just teaches you where everything lives. From here, explore the ArchWiki's General Recommendations page for guidance on system administration, appearance tuning, power management, multimedia, and networking. That page is essentially a roadmap for turning a fresh Arch install into a polished daily driver.

Welcome to Arch. You've earned the right to say "I use Arch, btw."