Download the Arch ISO and write it to a USB, then boot into the live environment. 2. Verify UEFI mode with ls /sys/firmware/efi/efivars, connect to the internet using DHCP or iwctl for Wi-Fi, and sync the system clock with timedatectl set-ntp true. 3. Partition the disk with fdisk, creating an EFI partition (e.g., /dev/sda1) and a root partition (e.g., /dev/sda2), format them with mkfs.fat -F32 and mkfs.ext4, then mount root to /mnt and EFI to /mnt/boot. 4. Install the base system using pacstrap /mnt base linux linux-firmware and optional tools, then generate the fstab with genfstab -U /mnt >> /mnt/etc/fstab and verify it. 5. Enter the chroot environment with arch-chroot /mnt, set the timezone, generate locale settings, configure hostname and hosts file, set the root password, create a user with useradd, add to wheel group, enable sudo access by uncommenting %wheel ALL=(ALL) ALL in visudo, and set the LANG variable. 6. Install GRUB bootloader with pacman -S grub efibootmgr, run grub-install for UEFI, and generate the config via grub-mkconfig -o /boot/grub/grub.cfg, or use bootctl install for systemd-boot with a custom entry in /boot/loader/entries/arch.conf. 7. Enable essential services like NetworkManager, bluetooth.service, cups.service, or sshd.service using systemctl enable, exit chroot, unmount partitions with umount -R /mnt, and reboot. After login, connect to the network, install a desktop environment or window manager as needed, keep the system updated with sudo pacman -Syu, use the Arch Wiki for guidance, and consider automating future installations with scripts or custom package lists for reproducibility. Building Arch from scratch gives you full control and deep understanding of your system by assembling it step by step.

Building a custom Arch Linux installation gives you full control over your system — from the kernel up. Unlike other distros that come preconfigured, Arch lets you assemble your environment piece by piece. This guide walks you through the essential steps to create a minimal, tailored Arch system from scratch.

1. Prepare the Installation Environment

Start by downloading the official Arch Linux ISO from archlinux.org and write it to a USB drive:

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

Boot from the USB. Once in the live environment, verify you're in UEFI mode (if using modern systems):

ls /sys/firmware/efi/efivars

If the directory exists, you're in UEFI mode. Then connect to the internet:

• For wired connections: usually works automatically via DHCP.
• For Wi-Fi: use iwctl:

iwctl
[iwd]# device list
[iwd]# station wlan0 scan
[iwd]# station wlan0 get-networks
[iwd]# station wlan0 connect SSID

Update the system clock:

timedatectl set-ntp true

2. Partition and Format the Disk

Choose a disk (e.g., /dev/sda) and partition it. For UEFI systems, you need:

• A small EFI system partition (ESP)
• A root partition
• (Optional) a swap partition or file

Use fdisk or parted:

fdisk /dev/sda

Example layout:

• /dev/sda1 — 512MB, type EFI System
• /dev/sda2 — rest of the disk, type Linux filesystem

Format the partitions:

mkfs.fat -F32 /dev/sda1
mkfs.ext4 /dev/sda2

Mount them:

mount /dev/sda2 /mnt
mkdir /mnt/boot
mount /dev/sda1 /mnt/boot

3. Install the Base System

Use pacstrap to install essential packages:

pacstrap /mnt base linux linux-firmware

Include additional tools if needed (e.g., vim, networkmanager, sudo):

pacstrap /mnt base base-devel linux linux-firmware vim networkmanager sudo

Generate the filesystem table:

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

Verify it:

cat /mnt/etc/fstab

4. Configure the Installed System

Chroot into the new system:

arch-chroot /mnt

Set Timezone, Locale, and Hostname

Set timezone:

ln -sf /usr/share/zoneinfo/Region/City /etc/localtime
hwclock --systohc

Uncomment en_US.UTF-8 UTF-8 (or your locale) in /etc/locale.gen, then:

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

Set hostname:

echo "myarch" > /etc/hostname

Enable the lo interface and set up hosts:

cat >> /etc/hosts <<EOF
127.0.0.1   localhost
::1         localhost
127.0.1.1   myarch.localdomain myarch
EOF

Set Root Password and Create a User

passwd
useradd -m -G wheel -s /bin/bash username
passwd username

Enable sudo access:

EDITOR=vim visudo

Uncomment the line:

%wheel ALL=(ALL) ALL

5. Install and Configure the Bootloader

For UEFI systems, install grub and efibootmgr:

pacman -S grub efibootmgr

Install GRUB:

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

Generate the config:

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

Alternative bootloaders: Consider systemd-boot for a simpler UEFI setup:

bootctl install

Then create an entry in /boot/loader/entries/arch.conf.

6. Enable Essential Services

Enable NetworkManager (or another network service):

systemctl enable NetworkManager

Other common services:

• bluetooth.service
• cups.service (printing)
• sshd.service (remote access)

7. Reboot and Finish Setup

Exit chroot, unmount, and reboot:

exit
umount -R /mnt
reboot

After booting into your new system:

• Log in as your user.
• Connect to Wi-Fi: nmtui or nmcli.
• Install an X server and desktop environment (if desired):

sudo pacman -S xorg gnome
sudo systemctl enable gdm

Or go lightweight: xfce4, i3, or dwm.

Final Tips

• Keep your system updated: sudo pacman -Syu
• Use the Arch Wiki — it’s the best resource.
• Consider using pacstrap with a custom package list for repeatable builds.
• Automate future installs with scripts (e.g., bash or Ansible).

Building Arch from scratch isn’t about complexity — it’s about understanding every part of your system. Once you’ve done it once, you’ll know exactly what’s running and why.

Basically, start small, add only what you need, and enjoy the control.

The above is the detailed content of How to Build a Custom Arch Linux Installation. For more information, please follow other related articles on the PHP Chinese website!