How to Create a Custom Arch Linux ISO on Arch Linux

Creating a custom Arch Linux ISO is a powerful way to tailor the installation process to your specific needs. Whether you’re building a consistent setup for multiple machines, creating a recovery environment, or simply experimenting with a personalized Arch experience, customizing your own ISO provides ultimate control.

This guide walks through the process of building a custom Arch Linux ISO from scratch on an Arch-based system. We’ll use the official archiso toolset, customize packages, tweak boot options, and build the final ISO image ready for burning or booting.

Why Create a Custom Arch ISO?

Before jumping into the technical steps, here are a few reasons why you might want a custom Arch ISO:

• Automated installations: Preconfigure settings to avoid manual steps.
• Include additional packages: Tools like vim, htop, or your preferred DE/WM.
• Custom scripts: Add post-install scripts or dotfiles.
• Offline installation: Build an ISO with all necessary packages.
• Security or rescue environment: Add forensic tools, recovery scripts, or a secure setup.

Prerequisites

Make sure you’re running Arch Linux or an Arch-based distribution. Then, install the necessary tools:

sudo pacman -S --needed archiso git

You’ll also need at least 10 GB of free disk space and a decent amount of RAM (4GB+ recommended). All commands should be run as a regular user unless noted.

Step 1: Set Up the Working Directory

Start by creating a working directory for your custom ISO project:

mkdir -p ~/custom-archiso
cd ~/custom-archiso

Now copy the official Arch ISO build profile (called “releng”) into your directory:

cp -r /usr/share/archiso/configs/releng/ ./myiso
cd myiso

The releng profile is the same configuration used to build the official Arch ISO. We’ll modify it from here.

Step 2: Understand the Directory Structure

Let’s explore what the folders and files in the myiso/ directory do:

• airootfs/: This is the root filesystem of the live environment.
• packages.x86_64: A list of packages to be included in the ISO.
• pacman.conf: Optional custom pacman.conf.
• profiledef.sh: Defines how the ISO is built (label, name, etc.).
• efiboot/ and syslinux/: Bootloader configuration for UEFI and BIOS.

Step 3: Customize Packages

The default packages.x86_64 is quite minimal. Open it to add or remove packages:

nano packages.x86_64

Some packages you might want to add:

• vim, nano — editors
• htop, neofetch, btop — monitoring tools
• networkmanager or iw, wpa_supplicant — for easier networking
• git, base-devel — for development

Example:

# Essential tools
vim
htop
btrfs-progs
grub
networkmanager

Save and close the file.

Step 4: Add Custom Files or Scripts

Everything in the airootfs/ directory becomes the root (/) of your live environment.

You can:

• Place scripts in airootfs/root/ (they will appear in /root/ on boot).
• Customize dotfiles or add preconfigured settings.
• Add systemd services or enable them via symlinks.

Example: Add a post-boot welcome script.

mkdir -p airootfs/root/
echo 'echo "Welcome to Custom Arch ISO!"' > airootfs/root/.bash_profile
chmod +x airootfs/root/.bash_profile

You can also create users or change the root password via hooks or airootfs/etc/.

Step 5: Customize Boot Options (Optional)

Syslinux (BIOS)

Edit syslinux/archiso_sys.cfg to change menu entries or default boot labels:

nano syslinux/archiso_sys.cfg

You can update the menu title, default kernel parameters, or even add new entries.

EFI Bootloader

For UEFI systems, tweak efiboot/loader/entries/archiso.conf:

nano efiboot/loader/entries/archiso.conf

Change the title or kernel parameters like copytoram, quiet, or ip=dhcp.

Step 6: (Optional) Custom Pacman Configuration

You can customize pacman.conf if you want to:

• Use custom repositories
• Pre-enable multilib
• Disable signature checking for local builds

Just uncomment or modify pacman.conf in your profile directory.

Step 7: Build the ISO

Now that your customizations are ready, let’s build the ISO.

From the myiso directory:

sudo mkarchiso -v .

Note: The mkarchiso tool requires root privileges to properly build the environment. It may take several minutes to complete depending on your packages.

Once done, you’ll find the ISO in out/:

ls out/

You should see something like:

archlinux-YYYY.MM.DD-x86_64.iso

Step 8: Test Your Custom ISO

Before deploying or sharing your custom ISO, test it in a virtual machine.

Using QEMU

qemu-system-x86_64 -boot d -cdrom out/archlinux-*.iso -m 2048

Using VirtualBox or VMware

Just create a new VM and mount the ISO as the boot disk.

You should boot into your customized environment, see your added packages and customizations.

Step 9: (Optional) Automate Install with a Script

If your goal is automated installs, you can include an installer script and run it on boot.

Place a script in airootfs/root/install.sh, then call it from .bash_profile:

echo '/root/install.sh' >> airootfs/root/.bash_profile

Be sure to make it executable:

chmod +x airootfs/root/install.sh

This way, the install begins as soon as the user logs in.

Bonus: Add Custom Wallpaper and Branding

Want to go a step further and brand your live ISO?

• Place images in airootfs/usr/share/backgrounds/
• Use a preconfigured display manager (like LightDM + slick greeter)
• Add a lightdm.conf in airootfs/etc/lightdm/

Make sure to install the relevant packages (e.g., lightdm, lightdm-slick-greeter) and enable the service:

ln -s /etc/systemd/system/lightdm.service airootfs/etc/systemd/system/display-manager.service

Maintenance Tips

• Clean up airootfs/var/cache/pacman/pkg/ if the ISO gets too large.
• Test often in a VM.
• Use version control (like git) to track changes to your build profile.
• Backup your myiso/ directory if planning long-term use.

Conclusion

Creating a custom Arch Linux ISO may seem daunting at first, but once you understand the tools and structure provided by archiso, it becomes a flexible and powerful way to tailor your own environment.

Whether you’re automating a setup, building a secure ISO for emergency recovery, or just exploring the depths of Arch Linux, this process empowers you with a deeper understanding of the OS and how it boots.