Arch Linux: Installation and Basic Configuration

Arch Linux differs fundamentally from classic beginner distributions like Ubuntu, Debian, or Fedora. While other systems provide a graphical installer that automates partitioning and software selection, Arch relies on the do-it-yourself principle (DIY): you install and configure every component of the operating system manually via the command line.

The manual installation is the best way to truly understand Linux: You determine the partition scheme, file system, kernel, bootloader, and network setup yourself. The result is an extremely lean, custom-tailored system without unnecessary software bloat.

This guide is the fundamental entry point to our Arch Linux series. We walk you through every step with all technical details for the complete installation process of a modern system with UEFI and GPT partitioning — from preparing the boot medium through pacstrap and arch-chroot to the first successful bootloader startup.

💡 Prerequisites: A 64-bit capable computer (x86_64) with UEFI support, a USB stick with at least 2 GB of storage, a stable internet connection (Ethernet or Wi-Fi), and a basic understanding of terminal navigation.

The Installation Workflow at a Glance

The Arch Linux installation process is divided into six logical phases:

┌─────────────────────────────────────────────────────────────┐
│ ARCH LINUX INSTALLATION WORKFLOW                            │
├─────────────────────────────────────────────────────────────┤
│ 1. LIVE MEDIUM:     Boot (UEFI) | Keyboard | Network        │
│ 2. STORAGE SETUP:   GPT Partitioning (EFI, Root, Swap)      │
│ 3. FILE SYSTEMS:    Formatting & Mounting to /mnt           │
│ 4. BASE SYSTEM:     pacstrap (base, linux, firmware)        │
│ 5. SYSTEM CONFIG:   arch-chroot (Locale, Time, Host, User)  │
│ 6. BOOTLOADER:      GRUB / systemd-boot & Microcode         │
└─────────────────────────────────────────────────────────────┘

1. Preparation & Creating the Boot Medium

Before starting the installation, you need the official installation image (Archiso).

ISO Download and Signature Verification

Download the current ISO image and its corresponding signature file from the official download page:

• Download Portal: archlinux.org/download

Verify the integrity of the download on your existing Linux system:

# Verify SHA256 checksum
sha256sum archlinux-*.iso

Compare the output checksum with the hash value on the official download page.

Create a Bootable USB Stick

Under Linux, write the image directly to the USB stick using the dd command.

Identify the device name of your USB stick with lsblk:

lsblk

⚠️ Caution with drive selection: The dd command overwrites the specified target drive irreversibly! Make absolutely sure that /dev/sdX is your USB stick and not your internal system disk (nvme0n1 or sda).

Write the image to the USB stick:

sudo dd bs=4M if=archlinux-*.iso of=/dev/sdX status=progress oflag=sync

Adjust UEFI and BIOS Settings

Restart your computer and open the UEFI/BIOS setup (usually via F2, F12, Del, or Esc keys during power-on):

1. Disable Secure Boot: The default Archiso does not support proprietary Secure Boot without manual key integration.
2. Check SATA controller mode: Ensure the controller is set to AHCI (not RAID/Optane).
3. Adjust boot order: Set the UEFI USB drive to the first position in the boot priority.

2. Starting the Live System & Initialization

After booting from the USB stick, you are greeted by the Arch Linux boot menu. Select the first entry: Arch Linux install medium (x86_64, UEFI).

Once the boot process completes, you land on the Zsh command line as root.

Activate German Keyboard Layout

The default layout in the live system is US American (QWERTY). Load the German keyboard layout (QWERTZ):

loadkeys de-latin1

For a sharper, high-resolution console font (especially on HiDPI monitors):

setfont ter-128b

Verify UEFI Mode

Ensure the system has actually booted in modern UEFI mode:

ls /sys/firmware/efi/efivars

If the directory outputs numerous EFI variables, the system is running in UEFI mode. If the message No such file or directory appears, the system was started in the outdated BIOS/CSM mode — in that case, check your BIOS settings.

Establish Internet Connection

Arch Linux requires an active internet connection during installation, as all packages are loaded fresh from online repositories.

Option A – Wired connection (Ethernet): Usually configured automatically via DHCP.

Option B – Wireless connection (Wi-Fi) with iwctl: For Wi-Fi connections, the live system includes the interactive tool iwd (iwctl):

# Start iwctl
iwctl

Within the interactive [iwd]# console:

# 1. Determine Wi-Fi device name (usually wlan0)
device list

# 2. Scan for networks in range
station wlan0 scan

# 3. Display found networks
station wlan0 get-networks

# 4. Connect to desired Wi-Fi (enter passphrase)
station wlan0 connect "MyWiFiName"

# 5. Exit iwctl
exit

Connection test:

ping -c 3 archlinux.org

Synchronize System Clock (NTP)

Exact system time is essential for cryptographic certificate verification during package downloads:

timedatectl set-ntp true

3. Disk Partitioning & File Systems (UEFI / GPT)

In this step, we set up the partition table on the target disk.

Identify Target Drive

Display all available block devices and partitions:

lsblk

Example output of a modern NVMe SSD:

NAME        MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
nvme0n1     259:0    0 500.0G  0 disk 
loop0         7:0    0   1.1G  1 loop /run/archiso/bootmnt

In this guide, we use /dev/nvme0n1 as the target drive. (On SATA systems, the name is typically /dev/sda.)

Partition Scheme (GPT)

We create a standardized, future-proof partition layout:

Create Partitions with cfdisk

cfdisk provides a clear, menu-driven text interface:

cfdisk /dev/nvme0n1

1. Select label type gpt (if the disk has no partition table yet).
2. Create EFI partition:

• Select New → Size: 1G → Select Type → EFI System.

1. Create Swap partition:

• Select free space (Free space) → New → Size: 8G → Select Type → Linux swap.

1. Create Root partition:

• Select remaining free space → New → Confirm total remaining size → Type remains Linux root (x86-64).

1. Select Write, type yes to confirm, and exit the program via Quit.

Format File Systems

Format the newly created partitions with their respective file systems:

# 1. EFI System Partition (must be FAT32)
mkfs.fat -F 32 /dev/nvme0n1p1

# 2. Initialize and activate swap area
mkswap /dev/nvme0n1p2
swapon /dev/nvme0n1p2

# 3. Format root file system (ext4 with label arch_root)
mkfs.ext4 -L arch_root /dev/nvme0n1p3

Mount File Systems Under /mnt

The partitions must now be mounted in the correct hierarchy under the temporary mount point /mnt:

# 1. Mount root partition as base
mount /dev/nvme0n1p3 /mnt

# 2. Create EFI boot directory and mount EFI partition
mount --mkdir /dev/nvme0n1p1 /mnt/boot

Verify the mount structure:

lsblk /dev/nvme0n1

Output:

NAME        MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
nvme0n1     259:0    0 500.0G  0 disk 
├─nvme0n1p1 259:1    0     1G  0 part /mnt/boot
├─nvme0n1p2 259:2    0     8G  0 part [SWAP]
└─nvme0n1p3 259:3    0 491.0G  0 part /mnt

4. Install Base System (pacstrap)

With the pacstrap tool, we install the fundamental system packages directly into the mounted target directory /mnt.

pacstrap -K /mnt \
  base \
  base-devel \
  linux \
  linux-firmware \
  linux-headers \
  networkmanager \
  neovim \
  nano \
  man-db \
  man-pages \
  git \
  sudo

Explanation of the core packages:

• base: Minimal package set for a functional Arch Linux system.
• base-devel: Compiler tools (gcc, make, etc.), essential for later software builds and AUR packages.
• linux & linux-headers: The official Linux kernel and header files for kernel modules.
• linux-firmware: Hardware driver firmware for Wi-Fi, graphics, audio, and controllers.
• networkmanager: Powerful daemon for managing Ethernet, Wi-Fi, and VPNs.
• sudo: Enables unprivileged users to execute administrative commands.

Generate File System Table (fstab)

Generate the file /etc/fstab so the system knows which partitions to mount via which UUIDs at boot:

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

Check the contents of the generated fstab for completeness:

cat /mnt/etc/fstab

All three partitions (/, /boot, swap) must be listed with unique UUID= entries.

5. System Configuration in the Chroot Environment

Switch into the freshly installed system with arch-chroot. From this moment, you work directly on your hard drive:

arch-chroot /mnt

Timezone and Hardware Clock

Set the timezone (example for Germany/Berlin):

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

Synchronize your motherboard's hardware clock with the system time in UTC standard:

hwclock --systohc

Localization & Language Settings

Open /etc/locale.gen and enable the required UTF-8 language definitions:

nano /etc/locale.gen

Remove the hash symbol (#) before the following lines:

de_DE.UTF-8 UTF-8
en_US.UTF-8 UTF-8

Generate the enabled locales:

locale-gen

Set the default system language in /etc/locale.conf:

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

Set the German keyboard layout permanently for the virtual console in /etc/vconsole.conf:

echo "KEYMAP=de-latin1" > /etc/vconsole.conf

Network Configuration & Hostname

Assign a unique network name to your computer in /etc/hostname:

echo "archbox" > /etc/hostname

Create the local name resolution in /etc/hosts:

127.0.0.1   localhost
::1         localhost
127.0.1.1   archbox.localdomain archbox

Enable the NetworkManager service for automatic network startup after reboot:

systemctl enable NetworkManager.service

Root Password and User Management

Set a secure password for the administrative root account:

passwd

Create an unprivileged user for daily operations and assign them to the administrative wheel group:

# Create user 'adminuser'
useradd -m -G wheel -s /bin/bash adminuser

# Set password for the new user
passwd adminuser

Enable Sudo Rights for the wheel Group

Open the sudoers configuration via visudo:

EDITOR=nano visudo

Find the following line and remove the leading #:

%wheel ALL=(ALL:ALL) ALL

Save the file with Ctrl+O and close it with Ctrl+X.

6. Processor Microcode & Bootloader Installation

Before installing the bootloader, the CPU microcode must be installed to catch hardware errors and CPU security vulnerabilities at boot:

# For Intel processors:
pacman -S intel-ucode

# For AMD processors:
# pacman -S amd-ucode

Bootloader: Install GRUB for UEFI

Install GRUB and the EFI boot management tools:

pacman -S grub efibootmgr dosfstools mtools

Install the GRUB bootloader into the mounted EFI system partition (/boot):

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

Create the GRUB configuration file. GRUB automatically detects the installed microcode package and integrates it into the boot process:

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

The output confirms successful detection of the Linux kernel and initramfs image:

Found linux image: /boot/vmlinuz-linux
Found initrd image: /boot/intel-ucode.img /boot/initramfs-linux.img
Found fallback initrd image(s) in /boot: initramfs-linux-fallback.img
done

7. Completing the Installation & First System Boot

The basic configuration is fully complete.

Leave the chroot environment:

exit

Unmount all mounted partitions cleanly:

umount -R /mnt

Restart the system and remove the USB stick:

reboot

First Login

After the restart, the GRUB boot menu appears. Log in on the virtual console with your newly created user account (adminuser).

Verify the internet connection and your sudo privileges:

# Check network status
ping -c 3 archlinux.org

# Check sudo functionality and package status
sudo pacman -Syu

Congratulations! Your minimal, clean, and fully functional Arch Linux base system is ready for use.

Installation Phases at a Glance

Further Resources

Arch Linux: Installing the Graphical User Interface Pacman: The Comprehensive Guide Arch Linux: Best Practices and Tips for System Maintenance Arch Linux: System Hardening and Security – Best Practices Official Arch Linux Installation Guide (Arch Wiki)

Conclusion

The manual installation of Arch Linux is the best way to truly understand the inner workings of a modern Linux operating system. Instead of relying on pre-built installer routines, you have manually configured every building block of your system — from the EFI system partition layout through the initramfs to the bootloader.

You now have an extremely lean, uncompromisingly stable base system running without unnecessary background bloat. This foundation provides maximum control, as you know exactly which services are active and how your system is structured.

💡 Practical tip: Always carefully document your chosen mount options, UUIDs, and user configurations. During later maintenance work or system recovery via a live medium, exact documentation saves you valuable time.

In the next article of our series, we build on this solid foundation: In Arch Linux: Installing the Graphical User Interface we set up hardware-accelerated graphics drivers, the modern PipeWire audio stack, and a full-featured KDE Plasma 6 desktop under Wayland.