Arch Linux installation guide¶

This guide presents a practical approach to installing Arch Linux. It walks through disk layout, optional full-disk encryption, ext4 or Btrfs filesystems, and setup of the systemd-boot bootloader. It also includes steps for installing proprietary NVIDIA drivers.

While I typically configure my desktop environment and dotfiles separately, this guide provides a brief set of commands for installing the GNOME desktop environment for convenience.

This document is not intended to replace the official Arch Wiki Installation Guide, which remains the most comprehensive and authoritative reference. Instead, it offers a personal and opinionated workflow, a set of practical notes meant to complement the Arch Wiki. Use both together to make informed decisions and adapt the process to your system.

This guide is provided under the terms of the Apache License, Version 2.0.

Recommended setup method¶

If you have access to a second computer, the most convenient way to install Arch is to boot the target machine from a flash drive and connect to it via SSH from the other computer. This approach allows you to keep this documentation open and copy commands easily between systems. Instructions for enabling SSH on the live environment are included below.

You can also complete the installation directly on the target machine if you prefer working locally.

Safe use of shell variables¶

This guide uses parameter expansion syntax, such as ${target:?}, to prevent unintended command operation if a variable is unset or empty. This safety check is particularly useful when copying commands over SSH or when several shell tabs are open, as it reduces the chance of running a command with incomplete parameters.

For manual input, you may simplify variable references to $target. However, ensure that every variable is correctly assigned and contains the expected value before running any command.

Download the Arch ISO and write it to a USB drive¶

This section assumes you are using a Linux computer to create the bootable installation medium. If you are on Windows, macOS, or Android, refer to the USB flash installation medium article. The Arch ISO file and additional download options are available on the Arch Linux Downloads page.

Download the ISO¶

Use curl to fetch the latest installation image from a reliable mirror. Arch Linux releases a new ISO every month.

curl -O https://geo.mirror.pkgbuild.com/iso/latest/archlinux-x86_64.iso

Verify the SHA256 checksum¶

Verify the SHA256 hash to ensure the downloaded file matches the official signature and has not been tampered with.

curl -s https://archlinux.org/download/ |
  grep -m1 "SHA256" |
  grep -oE "[a-f0-9]{64}" |
  sed "s/$/  archlinux-x86_64.iso/" |
  sha256sum -c -

sha256sum -c <(echo SIGNATURE archlinux-x86_64.iso)

Write the ISO to a USB drive¶

Identify the target USB device using fdisk -l, then set the device path variable to prepare the bootable medium.

sudo fdisk -l

Set the device path variable, replacing sdX with your USB drive's actual device name (e.g., sdb or mmcblk0):

flash="/dev/sdX"

Use dd to write the ISO to the USB device. This operation is permanent and destructive.

sudo dd if=archlinux-x86_64.iso of="${flash:?}" bs=4M status=progress oflag=sync

sudo cmp -n "$(stat -c %s archlinux-x86_64.iso)" archlinux-x86_64.iso "${flash:?}" && echo OK || echo ERROR

Boot from USB flash drive¶

Access your system's firmware (BIOS/UEFI) settings to select the USB drive as the boot device.

The USB drive can be safely removed once the live environment loads to a shell prompt.

Improve console readability¶

Change the console font for better legibility, which is especially useful on high-resolution displays.

setfont ter-124b  # 24-pixel font
setfont ter-128b  # 28-pixel font
setfont ter-132b  # 32-pixel font

Network checks and optional SSH connection¶

A stable network connection is mandatory for the installation. Test connectivity to ensure the live environment can reach the internet.

ping -c 3 archlinux.org

Wired connections typically work automatically.

passwd

ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null root@archiso.local

ip addr

ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -l root IP_ADDRESS

Perform basic system checks¶

Confirm UEFI boot mode¶

Confirm the system booted in UEFI mode, which is required for systemd-boot.

cat /sys/firmware/efi/fw_platform_size

If the file exists and contains 64, the system is in 64-bit UEFI mode. If the file is absent, reboot the system and switch to UEFI mode in the firmware settings.

Check system time¶

Verify the current time and that NTP synchronization is active (handled automatically by systemd-timesyncd in the live environment).

timedatectl

The time zone set here only affects the live environment and will be configured for the installed system later.

Assign variables for disk identification and prepare for partitioning¶

Identify the target disk by listing available block devices and assign the device path and partition names to shell variables.

fdisk -l

Use the appropriate tab for your disk type.

target=/dev/nvme0n1
efi="${target:?}p1"
root_physical="${target:?}p2"
root_actual="${root_physical:?}"

target=/dev/sdb
efi="${target:?}1"
root_physical="${target:?}2"
root_actual="${root_physical:?}"

Note: The root_actual variable will be updated later if LUKS encryption is applied.

Check disk settings¶

Ensure 4K block size on NVMe drives¶

Aligning your NVMe drive to a 4K (4096 bytes) logical sector size, if supported, improves performance and durability.

First, check the current logical sector size:

fdisk -l "${target:?}"

Next, verify the supported LBA formats to determine the optimal FORMAT_ID.

smartctl -c "${target:?}"

nvme id-ns -H "${target:?}"

If a 4K format is supported but not active, reformat the drive to the optimal LBA Format ID.

nvme format --lbaf=FORMAT_ID "${target:?}"

Verify TRIM support¶

Verify TRIM support, which allows the OS to communicate unused data blocks to a Solid State Drive (SSD) to maintain performance and lifespan. Non-zero values for DISC-GRAN and DISC-MAX confirm that TRIM support is present.

lsblk --discard "${target:?}"

Create partitions¶

Launch parted for interactive partitioning:

parted "${target:?}"

Create a GPT partition table

Create a GPT (GUID Partition Table), the modern standard required for UEFI.

mklabel gpt

Set the unit to MiB for optimal alignment

Set the unit to mebibytes (MiB) to ensure partitions are aligned to mebibyte boundaries for optimal performance.

unit MiB

Create the EFI system partition (ESP)

Create a 1 GiB (1024 MiB) FAT32 partition starting at 4 MiB.

mkpart efi fat32 4 1028

Set the ESP flag

Mark the first partition as the EFI System Partition, which is necessary for UEFI bootloaders.

set 1 esp on

Create the root partition

Create the root partition using all remaining disk space, starting immediately after the ESP.

mkpart root 1028 100%

Check partition alignment

Verify optimal alignment for partitions 1 and 2, which is essential for SSD performance.

align-check opt 1
align-check opt 2

Review and exit

Review the partition table and exit parted.

print
quit

Set up LUKS encryption (optional)¶

If you choose to encrypt the root partition ($root_physical) with LUKS2, the decrypted device will become $root_actual. If you skip encryption, $root_actual will simply remain the same as $root_physical.

cryptsetup luksFormat --batch-mode --verify-passphrase --type luks2 --sector-size 4096 "${root_physical:?}"

cryptsetup --perf-no_read_workqueue --perf-no_write_workqueue --allow-discards --persistent open "${root_physical:?}" luks-root

root_actual="/dev/mapper/luks-root"

Format and mount file systems¶

Format the partitions with the chosen filesystems and mount them to the installation directory (/mnt).

Root partition¶

Choose either traditional ext4 filesystem or the Btrfs with subvolumes.

mkfs.ext4 "${root_actual:?}"
mount -o noatime,commit=30 "${root_actual:?}" /mnt

mkfs.btrfs "${root_actual:?}"

mount "${root_actual:?}" /mnt
btrfs subvolume create /mnt/@
btrfs subvolume create /mnt/@home
btrfs subvolume create /mnt/@swap
umount /mnt

mount -o noatime,flushoncommit,subvol=/@ "${root_actual:?}" /mnt
mount -m -o noatime,flushoncommit,subvol=/@home "${root_actual:?}" /mnt/home
mount -m -o noatime,flushoncommit,subvol=/@swap "${root_actual:?}" /mnt/swap

EFI system partition¶

Format the ESP as FAT32, which is required for UEFI booting.

Format the EFI partition as FAT32:

mkfs.fat -F 32 -S 4096 "${efi:?}"

Mount the EFI partition to /mnt/boot:

Mount the ESP with secure permissions (umask=0077) to protect the boot files.

mount -m -o noatime,umask=0077 "${efi:?}" /mnt/boot

Double-check mounts¶

Verify that all partitions, including subvolumes, are correctly mounted under /mnt.

mount | grep /mnt

Install essential packages¶

Install the base system and all necessary packages using pacstrap. This includes the kernel, firmware, boot manager tools, network manager, and the chosen desktop environment (GNOME) and drivers (NVIDIA).

pacstrap -K /mnt \
  base linux linux-firmware efibootmgr \
  intel-ucode \
  amd-ucode \
  nvidia-open \
  btrfs-progs compsize \
  networkmanager \
  sudo man-db man-pages micro nano \
  gnome gnome-terminal \
  firefox noto-fonts noto-fonts-cjk noto-fonts-emoji

The -K flag ensures a proper pacman keyring setup in the new system. Adjust the package list as needed (e.g., remove btrfs-progs, gnome, or nvidia-open if not required).

Patch the system in /mnt before chroot¶

Fstab (file system table)¶

Generate the fstab file, which the system uses at boot to determine which filesystems to mount. The -U option ensures partitions are identified by their UUIDs for reliable mounting.

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

Check and edit fstab

Review the generated file and update it as needed, such as removing Btrfs subvolid= entries and relying on subvol= path-based mounting for better snapshot flexibility.

cat /mnt/etc/fstab
nano /mnt/etc/fstab

Configure systemd-boot¶

Install the systemd-boot boot manager to the EFI System Partition (ESP) and create the basic configuration files.

bootctl --esp-path=/mnt/boot install

Configure loader.conf

Set arch.conf as the default boot entry in the global bootloader configuration file.

echo "default arch.conf" >>/mnt/boot/loader/loader.conf

Create boot entry arch.conf

Define the boot process for the Arch Linux kernel.

1. Get UUID

First, retrieve the UUID of the physical root partition.

root_device_uuid="$(blkid -s UUID -o value "${root_physical:?}")"

2. Define kernel arguments

Define the kernel arguments, including the decryption device (cryptdevice) if LUKS is used, or simply the root filesystem UUID otherwise.

kernel_args="cryptdevice=UUID=${root_device_uuid}:luks-root root=/dev/mapper/luks-root"

kernel_args="root=UUID=${root_device_uuid}"

kernel_args="${kernel_args:?} rootflags=subvol=/@"

3. Create the configuration file

The microcode files (intel-ucode.img and amd-ucode.img) must be listed before the main initramfs-linux.img so they are loaded first. Ensure these microcode files are copied to /mnt/boot by pacstrap (they are dependencies of the intel-ucode and amd-ucode packages).

tee /mnt/boot/loader/entries/arch.conf <<EOF
title   Arch Linux
linux   /vmlinuz-linux
initrd  /intel-ucode.img
initrd  /amd-ucode.img
initrd  /initramfs-linux.img
options ${kernel_args:?} rw
EOF

Chroot into the new system and configure¶

Change the root directory into the newly installed system to perform final, system-specific configurations.

arch-chroot /mnt

Time configuration¶

Set the system time zone and enable automatic synchronization.

List available time zones with:

timedatectl list-timezones

Set the system time zone by linking to the desired zone info file:

ln -sf /usr/share/zoneinfo/Etc/UTC /etc/localtime

Synchronize the hardware clock from the system time to generate /etc/adjtime, and enable NTP for ongoing time updates.

hwclock --systohc
systemctl enable systemd-timesyncd.service

Network configuration¶

Set a unique hostname for your system.

echo myhostname >/etc/hostname

Enable NetworkManager to manage network connections.

systemctl enable NetworkManager.service

Enable GNOME display manager (GDM) (if installed)¶

If you installed the GNOME desktop environment, enable its display manager to start the graphical environment on boot.

systemctl enable gdm.service

Set root password and create a user¶

Set a secure password for the root account. Even if you normally use sudo for administrative tasks, the root password is still required for system recovery through the systemd emergency target.

passwd

Create a regular user (example: foo) and add them to the wheel group so they can use sudo.

useradd --create-home --groups wheel foo
passwd foo

Enable sudo access for the wheel group.

echo "%wheel ALL=(ALL:ALL) ALL" > /etc/sudoers.d/allow-wheel

Swap space setup¶

Even with large amounts of RAM, swap is important because it provides a backing store for inactive program memory, allowing the kernel to better manage physical RAM and file caching.

Select the appropriate method based on your filesystem to create and enable an 8 GiB (example size) swap file:

mkdir -p /swap
mkswap -U clear --size 8G --file /swap/swapfile
echo "/swap/swapfile none swap defaults 0 0" >>/etc/fstab

btrfs filesystem mkswapfile --size 8g --uuid clear /swap/swapfile
echo "/swap/swapfile none swap defaults 0 0" >>/etc/fstab

Configure Mkinitcpio¶

The initial ramdisk environment (initramfs) requires specific configuration to ensure successful system booting, especially when using LUKS encryption or specialized hardware like NVIDIA graphics cards.

Open the primary configuration file to apply the necessary changes:

nano /etc/mkinitcpio.conf

HOOKS=(... block encrypt filesystems ...)

HOOKS=(...  # make sure kms is not included here  ...)

MODULES=(... nvidia nvidia_modeset nvidia_uvm nvidia_drm ...)

MODULES=(... i915 nvidia nvidia_modeset nvidia_uvm nvidia_drm ...)

Regenerate initramfs¶

Apply the configuration changes and regenerate all initramfs images.

mkinitcpio -P

Boot loader finalization¶

Re-run the boot installation command inside the chroot to ensure the bootloader files on the ESP match the system's installed version.

bootctl install

Enable the automatic update service for systemd-boot to ensure the bootloader files are updated whenever the systemd package is upgraded.

systemctl enable systemd-boot-update.service

Exit chroot and reboot¶

Remove the installation USB drive, exit the chroot environment, and reboot the system into your new Arch Linux installation.

exit
reboot

Post-installation¶

Congratulations! Your Arch Linux system should now boot.

For further steps refer to General recommendations and List of applications.

Install yay AUR helper (optional)¶

Install yay, a popular tool for installing and managing packages from the Arch User Repository (AUR). Run these commands as your regular user, not as root.

sudo pacman -S --needed git base-devel
yay_temp="$(mktemp --directory)"
git clone https://aur.archlinux.org/yay-bin.git "${yay_temp:?}"
(cd "${yay_temp:?}" && makepkg -si)
rm -rf "${yay_temp:?}"

After installing, follow the initial setup steps in the project’s documentation under First Use: Development packages upgrade.