ISO Building & Customization

Parch GNU/Linux ships as a family of live/installer ISO images, one per edition. Each edition is a self-contained archiso profile repository, a small git repo holding a package list, a root-filesystem overlay, bootloader configuration, and a build script. From those few text files, mkarchiso assembles a bootable image that runs on both BIOS and UEFI machines, boots to an autologged-in live session, and installs Parch with the Calamares installer.

This section covers the whole pipeline: how archiso works, what every file in a profile does, building your first ISO, customizing packages and the live environment, configuring the Calamares installer, testing, release automation, and a complete worked tutorial for your own edition.

The editions

All editions share the same skeleton: iso/profiledef.sh, iso/packages.x86_64, iso/pacman.conf, iso/airootfs/, and the bootloader directories. What differs between them is the package list, the display manager, and the Parch theming packages pulled from the world repository.

Repository	Edition	In one line
`parch-iso-plasma`	KDE Plasma	Flagship desktop: Plasma with SDDM autologin and the full Parch theme set.
`Parch-iso-gnome`	GNOME	GNOME Shell with GDM and the `gnome-parch` theme packages.
`parch-iso-hyprland`	Hyprland	Tiling Wayland compositor edition for keyboard-driven workflows.
`parch-iso-xfce`	Xfce	Lightweight, traditional GTK desktop.
`parch-iso-cosmic`	COSMIC	The Rust-based COSMIC desktop edition.
`parch-iso-dwm`	dwm	Minimal suckless dynamic-window-manager edition.
`parch-iso-mini`	Mini	Reduced desktop package set for small images and quick installs.
`parch-iso-lite`	Lite	Light desktop tuned for older or low-memory hardware.
`parch-iso-base`	Base	Command-line live environment with no desktop.
`parch-iso-template`	Template	Clean starting point for new editions, no desktop, fastest build.

Anatomy of a profile repository

Clone any edition and you will find the same shape. Here is parch-iso-template, annotated:

parch-iso-template repository layout

parch-iso-template/
├── build.sh                      # Root-required wrapper: deps, mkarchiso, packaging
├── README.md
└── iso/                          # The archiso profile that mkarchiso consumes
    ├── profiledef.sh             # ISO identity, buildmodes, bootmodes, compression, permissions
    ├── packages.x86_64           # Package manifest installed into the live system
    ├── bootstrap_packages.x86_64 # Packages for the bootstrap tarball buildmode
    ├── pacman.conf               # Repositories used during the build (includes [world])
    ├── airootfs/                 # File tree copied over the installed packages
    ├── efiboot/                  # systemd-boot configuration (UEFI)
    ├── grub/                     # GRUB configuration
    ├── syslinux/                 # Syslinux configuration (BIOS)
    └── public.key                # Parch repository public key material

Three moving parts decide almost everything:

packages.x86_64, what gets installed into the live system.
airootfs/, how the live system behaves: autologin, networking, sudo, the installer, live-only scripts.
profiledef.sh plus the bootloader directories, what the ISO is called and how it boots.

Everything else builds on those three. The section in reading order:

Archiso fundamentals

What archiso and mkarchiso are, how a build proceeds phase by phase, and the build and boot modes Parch uses.

Profile structure

Every file and directory in a profile repository, plus a full profiledef.sh reference.

Build your first ISO

End-to-end tutorial: prerequisites, cloning parch-iso-template, building, and booting the result in QEMU.

Package lists

How packages.x86_64 and bootstrap_packages.x86_64 work, how the world repository is wired in, and kernel flavors.

airootfs customization

The live-system overlay: autologin, systemd-networkd, sudoers, pacman hooks, and live-only scripts.

Bootloader configuration

Syslinux for BIOS, systemd-boot for UEFI, GRUB in between, and the kernel command line.

Desktop profiles

How the Plasma, GNOME, Xfce, Hyprland, and smaller editions differ, and what to change for a new desktop.

Calamares installer

The YAML configuration under /etc/calamares, Parch branding, module defaults, and debugging.

Testing an ISO

QEMU/KVM on both firmwares, a real-hardware checklist, installer testing, and debugging boot failures.

Release automation

The build.yaml CI pipeline: release-triggered builds, the test channel, 7z volumes, and checksums.

Custom edition tutorial

A complete worked example: fork parch-iso-template, rename it, curate packages, add customizations, build, and test.

Where this fits in the portal

Set up the build host first, see Set up your workstation.
ISOs only install what exists in a repository. To add your own software to an edition, package it first, see Packaging.
The world repository that ISO builds pull Parch packages from is documented alongside the repo tooling in Packaging.

Continue in ISO Building

Archiso fundamentalsWhat archiso and mkarchiso are, how a Parch ISO build proceeds phase by phase, and which build and boot modes the editions use.Profile structureComplete anatomy of a Parch ISO profile repository, with a full profiledef.sh reference and the file_permissions system.Build your first Parch ISOEnd-to-end tutorial: prepare an Arch build host, clone parch-iso-template, build the ISO, and boot it in QEMU with both BIOS and UEFI firmware.Package listsHow packages.x86_64 and bootstrap_packages.x86_64 work, how the world repository is wired into the build, and how to add or remove packages safely.airootfs customizationThe live-system overlay: how airootfs/ works, the real Parch live setup (autologin, networkd, sudoers, pacman hooks, live scripts), and how to add your own.Bootloader configurationThe syslinux, grub, and efiboot directories in a Parch profile: which bootloader runs when, splash images, boot entries, and the kernel command line.Desktop profilesHow the Plasma, GNOME, Xfce, Hyprland, and other Parch editions differ, packages, display managers, theming, and what to change when building a new desktop edition.Calamares installerHow Calamares is installed and configured in the Parch live environment: the YAML configuration under /etc/calamares, branding, module defaults, offline installs, and debugging.Testing an ISOTest a built Parch ISO in QEMU/KVM on both firmwares, on real hardware, and through a full Calamares install, plus how to debug boot failures.Release automationHow Parch ISO releases are built and shipped: the build.yaml CI pipeline, the pre-release test channel on mirror.parchlinux.com, stable 7z volumes and checksums, and the proposed path to signed ISOs.Custom edition tutorialComplete worked example: fork parch-iso-template, rename the ISO, curate the package list, add an airootfs customization, build, and test, without touching production repos.