---
id: 2024-11-17-archlinux-installation-and-basic-configuration
slug: archlinux-installation-and-basic-configuration
title: "Arch Linux: Installation and Basic Configuration"
excerpt: "Complete step-by-step guide to manually installing Arch Linux on modern UEFI/GPT systems: partitioning, file systems, pacstrap, chroot, and bootloader."
date: "2024-11-17T09:00:00+01:00"
updated: "2026-08-27T23:30:00+02:00"
author:
  name: "Sebastian Palencsar"
  handle: "spalencsar"
category: "arch-linux-serie"
tags: ["arch-linux", "installation", "uefi", "gpt", "pacstrap", "chroot", "grub", "systemd", "linux"]
toc: true
reading_time: 45
---

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.

<span class="nb-accent">The manual installation is the best way to truly understand Linux:</span> 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](/en/category/arch-linux-serie){.badge-link-text}. 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.

<blockquote class="infobox infobox--info">
💡 **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.
</blockquote>

## The Installation Workflow at a Glance

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

```markdown
┌─────────────────────────────────────────────────────────────┐
│ 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](https://archlinux.org/download/){.badge-link-text}

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

```bash
# 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`:

```bash
lsblk
```

<blockquote class="infobox infobox--warn">
⚠️ **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`).
</blockquote>

Write the image to the USB stick:

```bash
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`):

```bash
loadkeys de-latin1
```

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

```bash
setfont ter-128b
```

### Verify UEFI Mode

Ensure the system has actually booted in modern UEFI mode:

```bash
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`):

```bash
# Start iwctl
iwctl
```

Within the interactive `[iwd]#` console:

```text
# 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:**

```bash
ping -c 3 archlinux.org
```

### Synchronize System Clock (NTP)

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

```bash
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:

```bash
lsblk
```

Example output of a modern NVMe SSD:

```text
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:

| Partition | Device Path | Type | Recommended Size | File System | Purpose |
|-----------|-------------|------|------------------|-------------|---------|
| 1 | `/dev/nvme0n1p1` | EFI System (`EF00`) | `1024 MB` (1 GB) | `FAT32` | Bootloader, Kernel & Initramfs |
| 2 | `/dev/nvme0n1p2` | Linux Swap (`8200`) | `8192 MB` (8 GB) | `Swap` | Swap space & Zswap |
| 3 | `/dev/nvme0n1p3` | Linux Root x86-64 (`8304`) | Remaining storage | `ext4` | Operating system, Home & Data |

### Create Partitions with `cfdisk`

`cfdisk` provides a clear, menu-driven text interface:

```bash
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`**.
3. **Create Swap partition:**
   * Select free space (*Free space*) → *New* → Size: `8G` → Select *Type* → **`Linux swap`**.
4. **Create Root partition:**
   * Select remaining free space → *New* → Confirm total remaining size → Type remains **`Linux root (x86-64)`**.
5. 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:

```bash
# 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`:

```bash
# 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:

```bash
lsblk /dev/nvme0n1
```

Output:

```text
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`.

```bash
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:

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

Check the contents of the generated `fstab` for completeness:

```bash
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:

```bash
arch-chroot /mnt
```

### Timezone and Hardware Clock

Set the timezone (example for Germany/Berlin):

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

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

```bash
hwclock --systohc
```

### Localization & Language Settings

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

```bash
nano /etc/locale.gen
```

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

```text
de_DE.UTF-8 UTF-8
en_US.UTF-8 UTF-8
```

Generate the enabled locales:

```bash
locale-gen
```

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

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

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

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

### Network Configuration & Hostname

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

```bash
echo "archbox" > /etc/hostname
```

Create the local name resolution in `/etc/hosts`:

```ini
127.0.0.1   localhost
::1         localhost
127.0.1.1   archbox.localdomain archbox
```

Enable the NetworkManager service for automatic network startup after reboot:

```bash
systemctl enable NetworkManager.service
```

### Root Password and User Management

Set a secure password for the administrative root account:

```bash
passwd
```

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

```bash
# 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`:

```bash
EDITOR=nano visudo
```

Find the following line and remove the leading `#`:

```ini
%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:

```bash
# 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:

```bash
pacman -S grub efibootmgr dosfstools mtools
```

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

```bash
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:

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

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

```text
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:

```bash
exit
```

Unmount all mounted partitions cleanly:

```bash
umount -R /mnt
```

Restart the system and remove the USB stick:

```bash
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:

```bash
# 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

| Phase | Core Commands / Config Files | Purpose |
|-------|------------------------------|---------|
| **Preparation** | `loadkeys de-latin1`, `iwctl`, `timedatectl set-ntp true` | Keyboard, network, time |
| **Partitioning** | `cfdisk /dev/nvme0n1`, `mkfs.fat`, `mkfs.ext4`, `mkswap` | GPT layout & file systems |
| **Mounting** | `mount /dev/... /mnt`, `mount --mkdir /dev/... /mnt/boot` | Mount hierarchy for pacstrap |
| **Base System** | `pacstrap -K /mnt base linux linux-firmware base-devel` | OS core components |
| **Configuration** | `/etc/fstab`, `/etc/locale.gen`, `/etc/hostname`, `passwd` | Localization, user, identity |
| **Bootloader** | `intel-ucode`, `grub-install`, `grub-mkconfig` | UEFI system boot |

## Further Resources

[Arch Linux: Installing the Graphical User Interface](/en/arch-linux-serie/arch-linux-installing-the-graphical-user-interface){.badge-link-text}
[Pacman: The Comprehensive Guide](/en/arch-linux-serie/arch-linux-comprehensive-guide-package-manager-pacman){.badge-link-text}
[Arch Linux: Best Practices and Tips for System Maintenance](/en/arch-linux-serie/arch-linux-best-practices-tips){.badge-link-text}
[Arch Linux: System Hardening and Security – Best Practices](/en/arch-linux-serie/arch-linux-system-hardening-security-best-practices){.badge-link-text}
[Official Arch Linux Installation Guide (Arch Wiki)](https://wiki.archlinux.org/title/Installation_guide){.badge-link-text}

## 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.

<blockquote class="infobox infobox--info">
💡 **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.
</blockquote>

In the next article of our series, we build on this solid foundation: In [Arch Linux: Installing the Graphical User Interface](/en/arch-linux-serie/arch-linux-installing-the-graphical-user-interface){.badge-link-text} we set up hardware-accelerated graphics drivers, the modern PipeWire audio stack, and a full-featured KDE Plasma 6 desktop under Wayland.