Installing Arch Linux¶

Preface¶

Arch Linux uses a hands-on installation approach where you build the system step by step through commands. This design emphasizes clarity and user control. Without a guided installer or concealed automation, the entire setup remains open and deliberate, making each decision visible and easy to understand.

After spending considerable time with the Arch Wiki, I gradually refined my own approach into a set of notes focused on minimalism and privacy. This guide grew out of those notes. It is a curated sequence of commands with brief explanations and links back to the Arch Wiki for readers who want deeper detail.

Although these commands could be combined into a single installation script, doing so would hide the reasoning behind each step and impose a fixed path. That tradeoff runs against the philosophy that makes Arch appealing in the first place.

The intent here is to provide a clear baseline without closing off alternatives. I consolidate common decisions into ready-to-run commands while leaving you free to follow them exactly, pause and inspect each step, diverge where needed, or rework the process entirely.

At several points, the guide presents prepared alternatives. These cover choices such as full-disk encryption, ext4 versus Btrfs, NVIDIA driver installation, and package selection. Each option is self-contained and includes a complete set of commands you can use as-is.

Beyond installation, the guide covers practical configuration details. It shows how to align an NVMe drive to 4K sectors, enable TRIM in an encrypted setup, and create a clean partition layout with parted. It walks through configuring swap as a file, setting up systemd-boot, installing an AUR helper, and enabling SSH during installation so you can work from another machine and copy commands easily.

This document does not replace the official Installation Guide, which remains the definitive reference. Use both together to understand the tradeoffs and adapt the system to your own priorities.

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.

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 --check -

sha256sum --check <(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.

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

sudo dd if="${flash:?}" iflag=direct,count_bytes count="$(stat -c %s archlinux-x86_64.iso)" bs=4M status=progress | cmp - archlinux-x86_64.iso && echo VERIFIED || 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, especially on high-resolution displays. This sets the Terminus font with a Western European codepage and bold weight. Choose the font size that suits your needs.

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

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¶

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 is initially set to the physical root partition and 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 --capabilities "${target:?}"

nvme id-ns --human-readable "${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¶

The plan is to create a ~1 GiB EFI system partition for boot files and use the remaining space for the root partition. Swap will later be added as a regular file within the root filesystem to keep the layout flexible.

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) so that any values passed to mkpart are interpreted in this unit. Doing this first ensures partitions land on precise mebibyte boundaries, which avoids alignment problems and improves performance. Because the default parted unit is less exact, explicitly selecting MiB helps prevent unintended offsets.

unit MiB

Create the EFI system partition (ESP)

[4, 8, 16, 24, 32, 48, 96, 128, 192].map(i => 1152 / i)

Create a FAT32 partition that occupies the space from 1 MiB up to the chosen alignment point, which comes out to roughly 1.10 GiB.

mkpart efi fat32 1 1136

mkpart efi fat32 1 1152

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 1136 100%

mkpart root 1152 100%

Check partition alignment

Verify optimal alignment for partition 1.

align-check opt 1

Verify optimal alignment for partition 2.

align-check opt 2

Review and exit

Display the partition table to verify the final layout.

print

Exit parted.

quit

Configure disk encryption¶

Choose whether to encrypt the root partition with LUKS or proceed without encryption.

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 the traditional ext4 filesystem or 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 --mkdir -o noatime,flushoncommit,subvol=/@home "${root_actual:?}" /mnt/home
mount --mkdir -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 --mkdir -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¶

Select your CPU architecture below and run the corresponding code block in your shell to initialize the packages array. This array includes the kernel, firmware, boot manager tools, essential utilities, and the correct CPU microcode package.

Define the base system¶

packages=(
  amd-ucode         # CPU microcode updates for AMD processors
  base              # Minimal base system required for a functional Arch installation
  efibootmgr        # Tool for managing UEFI boot entries
  intel-ucode       # CPU microcode updates for Intel processors
  linux             # The Linux kernel
  linux-firmware    # Firmware files required by many hardware devices
  man-db            # Backend for the manual page system
  man-pages         # Official Linux manual pages
  nano              # Simple terminal-based text editor
  sudo              # Privileged command execution for non-root users
  terminus-font     # Readable monospaced console font
  )

packages=(
  base              # Minimal base system required for a functional Arch installation
  efibootmgr        # Tool for managing UEFI boot entries
  intel-ucode       # CPU microcode updates for Intel processors
  linux             # The Linux kernel
  linux-firmware    # Firmware files required by many hardware devices
  man-db            # Backend for the manual page system
  man-pages         # Official Linux manual pages
  nano              # Simple terminal-based text editor
  sudo              # Privileged command execution for non-root users
  terminus-font     # Readable monospaced console font
  )

packages=(
  amd-ucode         # CPU microcode updates for AMD processors
  base              # Minimal base system required for a functional Arch installation
  efibootmgr        # Tool for managing UEFI boot entries
  linux             # The Linux kernel
  linux-firmware    # Firmware files required by many hardware devices
  man-db            # Backend for the manual page system
  man-pages         # Official Linux manual pages
  nano              # Simple terminal-based text editor
  sudo              # Privileged command execution for non-root users
  terminus-font     # Readable monospaced console font
  )

Add optional packages¶

Append optional packages such as desktop environments, drivers, and file system utilities to the packages array as needed for your system.

packages+=(
  bluez              # Linux Bluetooth protocol stack
  bluez-utils        # Bluetooth command-line utilities
  gnome              # Full GNOME desktop environment
  gnome-terminal     # GNOME terminal emulator
  networkmanager     # Network connection management service
  pipewire           # Audio and video processing framework
  wireplumber        # PipeWire session manager
)

packages+=(
  firefox            # Graphical web browser
  noto-fonts         # Primary Unicode font family
  noto-fonts-cjk     # Chinese, Japanese, and Korean font support
  noto-fonts-emoji   # Emoji font for full emoji rendering
)

packages+=(
  nvidia-open        # Open-source NVIDIA kernel driver
)

packages+=(
  btrfs-progs        # Btrfs user-space management tools
  compsize           # Reports compression and disk usage on Btrfs
)

packages+=(
  systemd-resolvconf # resolvconf compatibility for systemd-resolved
)

Run package installation¶

After defining the base system and appending optional packages, run the following command to install all selected packages onto the mounted system.

pacstrap -K /mnt "${packages[@]:?}"

The -K flag ensures a proper pacman keyring setup in the new system.

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

Review fstab

Check the generated file to confirm the filesystem entries.

cat /mnt/etc/fstab

Edit fstab (only if necessary)

Make any required adjustments to the file based on your setup.

nano /mnt/etc/fstab

nano /mnt/etc/fstab

Configure systemd-boot¶

Install the systemd-boot boot manager. This command populates the EFI System Partition (ESP) with the necessary binaries and creates the default configuration directory structure.

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

efibootmgr --unicode

efibootmgr

efibootmgr --unicode | grep -F "$(lsblk --nodeps --noheadings --output "PARTUUID" "${efi:?}")"

efibootmgr | grep -F "$(lsblk --nodeps --noheadings --output "PARTUUID" "${efi:?}")"

efibootmgr --unicode --bootorder XXXX,XXXX 

efibootmgr --bootorder XXXX,XXXX 

efibootmgr --unicode --delete-bootnum --bootnum XXXX

efibootmgr --delete-bootnum --bootnum XXXX

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 arch.conf boot entry¶

Define the boot process for the Arch Linux kernel.

1. Get UUID

First, retrieve the UUID of the physical root partition.

root_device_uuid="$(lsblk --nodeps --noheadings --output "UUID" "${root_physical:?}")"

2. Define kernel arguments

Selecting the right kernel parameters ensures that your system can locate and mount the root filesystem during boot. The next step tailors these parameters to your encryption method.

kernel_args="rd.luks.name=${root_device_uuid}=luks-root root=/dev/mapper/luks-root"

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

Before creating the final boot entry, make sure the kernel arguments also match your filesystem type. Some filesystems require extra flags so the kernel knows exactly where your root data is stored.

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

3. Create the configuration file

The microcode files (intel-ucode.img and amd-ucode.img) must appear before the main initramfs-linux.img in the configuration file to ensure they load first. The command below uses tee to create the arch.conf loader entry that references the appropriate microcode file or files, depending on the CPU architecture you select.

Make sure the required microcode files were copied to /mnt/boot. They are installed by pacstrap during the Install essential packages step, where you select your CPU architecture from the corresponding tab.

In this step, you again choose one of the architecture tabs. Select the same architecture as before so that the correct microcode images installed earlier are used in your boot loader configuration.

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

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

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

Configure systemd-resolved¶

The /etc/resolv.conf file is bind-mounted from the host system when using arch-chroot, so it cannot be replaced from inside the chroot. To ensure DNS resolution works correctly on the installed system, you must create the symlink before entering the chroot environment.

Run the following command from outside the chroot:

ln -sf ../run/systemd/resolve/stub-resolv.conf /mnt/etc/resolv.conf

Chroot into the installed system for final configuration¶

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

Configure the system time zone by linking to the appropriate zone info file. Replace Etc/UTC with the time zone you want to use.

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

Localization¶

Define a variable for your chosen locale. This variable will be used in the following steps.

locale="en_US.UTF-8"

1. Configure /etc/locale.gen¶

Uncomment your chosen locale(s) in the /etc/locale.gen file.

sed -ri "s/^#\s*(${locale//./[.]}(\s|\$))/\1/g" /etc/locale.gen

grep -v "^#" /etc/locale.gen

nano /etc/locale.gen

2. Generate locales¶

Generate the configured locales.

locale-gen

3. Create /etc/locale.conf¶

Create /etc/locale.conf to set the system-wide LANG environment variable.

echo "LANG=${locale:?}" > /etc/locale.conf

4. Configure virtual console¶

Configure the virtual console by editing /etc/vconsole.conf. This sets the keyboard layout (KEYMAP) and console font (FONT) for the TTY/boot environment.

Example for US layout and Terminus font (Western European codepage, 28-pixel height, bold).

( echo "KEYMAP=us" && echo "FONT=ter-128b" ) > /etc/vconsole.conf

Network configuration¶

Set a unique hostname for your system.

echo myhostname > /etc/hostname

Configure systemd-resolved to use DNS over TLS¶

Enable the systemd-resolved service.

systemctl enable systemd-resolved.service

Create the configuration drop-in directory.

mkdir -p /etc/systemd/resolved.conf.d

Create a drop-in configuration file for your preferred DNS provider. Use one of the following examples or supply your own configuration. The configuration enforces encrypted DNS for all domains.

cat <<EOF > /etc/systemd/resolved.conf.d/dns_over_tls.conf
[Resolve]
DNS=1.1.1.1#cloudflare-dns.com 1.0.0.1#cloudflare-dns.com 2606:4700:4700::1111#cloudflare-dns.com 2606:4700:4700::1001#cloudflare-dns.com
DNSOverTLS=yes
Domains=~.
EOF

cat <<EOF > /etc/systemd/resolved.conf.d/dns_over_tls.conf
[Resolve]
DNS=8.8.8.8#dns.google 8.8.4.4#dns.google 2001:4860:4860::8888#dns.google 2001:4860:4860::8844#dns.google
DNSOverTLS=yes
Domains=~.
EOF

cat <<EOF > /etc/systemd/resolved.conf.d/dns_over_tls.conf
[Resolve]
DNS=1.1.1.1#cloudflare-dns.com 1.0.0.1#cloudflare-dns.com 2606:4700:4700::1111#cloudflare-dns.com 2606:4700:4700::1001#cloudflare-dns.com 8.8.8.8#dns.google 8.8.4.4#dns.google 2001:4860:4860::8888#dns.google 2001:4860:4860::8844#dns.google
DNSOverTLS=yes
Domains=~.
EOF

Enable services that you may have optionally installed¶

systemctl enable gdm.service

systemctl enable NetworkManager.service

systemctl enable bluetooth.service

Set root password and create a user¶

Set a strong password for the root account. Even if you normally use sudo for administrative tasks, the root password is required for system recovery tasks such as entering the systemd emergency shell.

passwd

Choose a username for your regular account (example: foo).

username=foo

Create the user, including a home directory, and add them to the wheel group to allow administrative access via sudo.

useradd --create-home --groups wheel "${username:?}"

Set a secure password for the new user.

passwd "${username:?}"

Enable sudo access for members of 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 --uuid 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

Enable periodic TRIM¶

systemctl enable fstrim.timer

Configure Mkinitcpio¶

The initial ramdisk environment (initramfs) must be configured correctly to ensure successful system booting, particularly when using LUKS encryption or proprietary NVIDIA drivers.

You can add drop-in configuration files or make the changes manually. If you choose manual configuration, open the primary configuration file and follow the instructions below.

nano /etc/mkinitcpio.conf

Configure boot-time initramfs settings¶

cat <<'EOF' > /etc/mkinitcpio.conf.d/10-add-luks-encryption-hook.conf
mapfile -t HOOKS < <(
  for element in "${HOOKS[@]}"; do
    echo "$element"
    if [ "$element" = "block" ]; then
      echo "sd-encrypt"
    fi
  done
)
EOF

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

cat <<'EOF' > /etc/mkinitcpio.conf.d/20-remove-kms-hook.conf
mapfile -t HOOKS < <(
  for element in "${HOOKS[@]}"; do
    if [ "$element" != "kms" ]; then
      echo "$element"
    fi
  done
)
EOF

HOOKS=(...) # Make sure "kms" is not included!

cat <<EOF > /etc/mkinitcpio.conf.d/30-add-nvidia-modules.conf
MODULES+=(nvidia nvidia_modeset nvidia_uvm nvidia_drm)
EOF

MODULES=(nvidia nvidia_modeset nvidia_uvm nvidia_drm)

cat <<EOF > /etc/mkinitcpio.conf.d/30-add-nvidia-modules.conf
MODULES+=(i915 nvidia nvidia_modeset nvidia_uvm nvidia_drm)
EOF

MODULES=(i915 nvidia nvidia_modeset nvidia_uvm nvidia_drm)

Regenerate initramfs¶

Save your changes if you edited the configuration file manually, then 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¶

Exit the chroot environment to return to the live installation shell.

exit

Remove the installation USB drive and reboot the system into your new Arch Linux installation.

reboot

Post-installation¶

Congratulations! Your Arch Linux system should now boot.

For further steps, see the General recommendations and the List of applications guides.

Install 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 -d)"
git clone https://aur.archlinux.org/yay-bin.git "${yay_temp:?}"
(cd "${yay_temp:?}" && makepkg -si)
rm -rf "${yay_temp:?}"

After installing, refer to the First Use section of yay’s documentation. Review the instructions to decide if you wish to configure yay to automatically check for updates to development (-git) packages.