Learning Artix Linux - AUR & AURIS

#Introduction

The Arch ecosystem isn't complete without the AUR — the Arch User Repository. Episode 15 covers how to use it on Artix through the yay and paru helpers, understand the contents of a PKGBUILD, use makepkg as a build sandbox, and what sets Artix apart: AURIS, the init-script repository released on April 28, 2026.

The AUR gives access to packages not in the official repos, but it requires caution: you're running scripts from the community. Knowing how to read a PKGBUILD is an essential skill for staying safe.

#The AUR and Helpers

#Why the AUR Matters

Some popular applications — for example certain proprietary browsers and specialized tools — aren't in the galaxy repo. The AUR bridges that gap: a decentralized repository where users share PKGBUILDs, not binary packages. Makepkg turns a PKGBUILD into an installable pacman package.

Helpers like yay or paru automate the AUR flow: searching, downloading, building, and installing in one command. Install one of them:

sudo pacman -S --needed base-devel git
git clone https://aur.archlinux.org/paru.git
cd paru && makepkg -si

makepkg -si builds the package from the PKGBUILD and installs it via pacman. When finished, paru is available as a helper.

#Searching and Installing from the AUR

With paru, search covers the official repos and the AUR at once:

paru -Ss app-name
paru -S app-name

paru -S app-name picks the package from the official repos or the AUR, builds it if necessary, and installs it. When asked to confirm a PKGBUILD, review it before pressing enter.

#Understanding the PKGBUILD

#Basic Structure

A PKGBUILD is a bash script with variables and functions. The most security-critical parts are source, sha256sums, and the build and package functions. A concise example:

pkgname=app-name
pkgver=1.0.0
pkgrel=1
arch=('x86_64')
depends=('glibc')
source=("$url/$pkgname-$pkgver.tar.gz")
sha256sums=('source-file-hash')
 
build() {
    cd "$srcdir/$pkgname-$pkgver"
    ./configure --prefix=/usr
    make
}
 
package() {
    cd "$srcdir/$pkgname-$pkgver"
    make DESTDIR="$pkgdir" install
}

The sha256sums variable is the security key: make sure the hash matches the original source file. If a hash changed without a clear reason, that's a danger sign.

#Checking Before Building

Before building a foreign package, get in the habit of reading it:

paru -G app-name
less app-name/PKGBUILD

paru -G downloads the PKGBUILD without building. Inspect the build and package functions to make sure there's no suspicious activity.

#makepkg as a Build Sandbox

#Building Without Root

Makepkg refuses to run as root and builds in the $srcdir directory. For stronger isolation, install the build dependencies then use makepkg flags:

cd app-name
makepkg -s
makepkg --check

makepkg -s automatically checks build dependencies. The --check option runs the test suite if the PKGBUILD provides one.

#Installing the Build Result

The build result is a .pkg.tar.zst file. Install it with pacman:

sudo pacman -U app-name-1.0.0-1-x86_64.pkg.tar.zst

pacman -U installs a local package. This means the system still uses the same package manager — only the source differs.

#AURIS: Init Scripts for the AUR

#What Is AURIS

AURIS (Artix Linux User Repository of Init Scripts) was released on April 28, 2026 to solve a classic problem: AUR applications that run as services usually only ship systemd units, which can't be used on Artix. AURIS provides official init scripts for those applications.

Enable the AURIS repo in /etc/pacman.conf. Add it after galaxy:

[auris]
Include = /etc/pacman.d/mirrorlist

After saving, synchronize the database and search for init scripts:

sudo pacman -Sy
pacman -Ss auris

pacman -Ss auris shows the available init-script packages. With AURIS, AUR applications whose services you previously had to write by hand are now just install-and-register in your init.

#Installing a Service via AURIS

As an example, install an application from the AUR, then grab its init script from AURIS:

paru -S app-name
sudo pacman -S app-name-openrc
sudo rc-update add app-name default

app-name-openrc is the AURIS subpackage naming pattern for the OpenRC init. runit, s6, and dinit versions are available with the same pattern. This is what makes service use on Artix increasingly smooth.

#AUR Package Security

#Safe Habits

Even though it's convenient, the AUR is a third-party source. Some habits that reduce risk: read the PKGBUILD every time, watch the hashes and maintainers, avoid -git packages unless needed, and never run a PKGBUILD as root. Makepkg already blocks this, but helpers like paru still ask.

#Verifying After Install

After installing an AUR package, verify its integrity like any other package:

pacman -Qi app-name
sudo pacman -Qkk app-name

pacman -Qkk app-name verifies that the installed files match the package database. If there's a warning about changed files, that's a sign something needs investigating.

#Conclusion

Episode 15 opened the door to the AUR ecosystem: the yay and paru helpers, reading PKGBUILDs safely, makepkg as a sandbox, and AURIS, which provides official init scripts for AUR applications across all four Artix inits.

Key takeaways:

• The AUR contains PKGBUILDs that makepkg turns into pacman packages.
• paru -G downloads a PKGBUILD for review before building.
• Always check sha256sums and the build/package functions.
• Makepkg refuses root and builds inside $srcdir.
• AURIS was released April 28, 2026; enable the [auris] repo in pacman.conf.
• AURIS subpackage pattern: app-name-openrc, -runit, -s6, -dinit.

In the next episode, episode 16, we'll cover backup, restore, and system update — rsync, timeshift and snapper, Btrfs snapshots, the safe pacman -Syu procedure, and rollback when the system breaks.