How to Use AUR with Arch Linux

AUR, also known as the Arch User Repository, is a community-driven repository for Arch-based Linux distributions. It allows Arch Linux users to compile and install packages from source code using package build scripts called PKGBUILDs. The repository AUR contains thousands of community-maintained applications that are not available in the official repositories.

This guide is designed for Linux administrators, developers, and Arch users who want to expand their software options beyond the default repositories. It explains how to configure your system, install an AUR helper, perform a package search, and manually build packages from source.

The AUR is valuable because it provides access to new packages, development tools, and applications that may not yet be included in the official repositories. However, AUR packages are user-created and come with risks. While Trusted Users help maintain package quality, they cannot guarantee complete safety.

Some important facts about AUR include:

• AUR packages are built from PKGBUILDs using makepkg.
• Install base-devel to compile AUR packages from source.
• The command to build and install AUR packages manually is makepkg -si.
• AUR helpers can lead to safety risks if users do not review the PKGBUILD.
• Malicious code has been found in AUR packages.
• Trusted Users monitor AUR but cannot guarantee safety.
• Inspect PKGBUILDs and install files before building packages.
• Using an AUR helper is the preferred method for many Arch users.
• Popular AUR helpers include Yay, Yaourt, and Packer.

In this post, we will show you how to use AUR with Arch Linux.

Understanding How AUR Works

Unlike the official repositories, AUR generally does not host precompiled software packages. Instead, it provides package descriptions, metadata, PKGBUILD scripts, and install instructions that tell your system how to download source code, resolve required dependencies, and build packages.

The typical build process works as follows:

1. Perform a package search.
2. Review package descriptions and package details.
3. Download or clone the package repository using git.
4. Review PKGBUILD and other related files.
5. Install dependencies.
6. Build packages using makepkg.
7. Install the package with pacman.

This approach gives users flexibility while allowing the AUR community to contribute new software and package updates.

Step 1 – Configure Repository

Before working with AUR, it is a good idea to update your mirror configuration. Configuring a fast mirror list can improve download speeds and reduce package synchronization issues.

By default, the default repository is outdated in Arch Linux, so you will need to modify the default mirror list if you have not done so already. You can do it by editing the mirrorlist configuration file:

nano  /etc/pacman.d/mirrorlist

Remove all lines and add the following lines:

## Score: 0.7, United States
Server = http://mirror.us.leaseweb.net/archlinux/$repo/os/$arch
## Score: 0.8, United States
Server = http://lug.mtu.edu/archlinux/$repo/os/$arch
Server = http://mirror.nl.leaseweb.net/archlinux/$repo/os/$arch
## Score: 0.9, United Kingdom
Server = http://mirror.bytemark.co.uk/archlinux/$repo/os/$arch
## Score: 1.5, United Kingdom
Server = http://mirrors.manchester.m247.com/arch-linux/$repo/os/$arch
Server = http://archlinux.dcc.fc.up.pt/$repo/os/$arch
## Score: 6.6, United States
Server = http://mirror.cs.pitt.edu/archlinux/$repo/os/$arch
## Score: 6.7, United States
Server = http://mirrors.acm.wpi.edu/archlinux/$repo/os/$arch
## Score: 6.8, United States
Server = http://ftp.osuosl.org/pub/archlinux/$repo/os/$arch
## Score: 7.1, India
Server = http://mirror.cse.iitk.ac.in/archlinux/$repo/os/$arch
## Score: 10.1, United States
Server = http://mirrors.xmission.com/archlinux/$repo/os/$arch

Save and close the file, then update all package indexes with the following command:

pacman -Syu

This command synchronizes your system with the latest packages available in the official repositories.

Step 2 – Create a New User

For security reasons, it is recommended not to build AUR packages directly as root. Since package builds can execute scripts during installation, creating a regular user helps reduce risk.

You can now use the AUR package as a root user, so you will need to create a new user to use the AUR package.

First, create a new user with the following command:

useradd -m user1

Next, set a password for a user with the following command:

passwd user1

Next, edit the sudoers file:

nano /etc/sudoers

Uncomment the following line:

 %wheel ALL=(ALL:ALL) NOPASSWD: ALL

Save and close the file, then add the user to the wheel group:

usermod -aG wheel user1

Step 3 – Install AUR Helper Script

The simplest way to work with AUR is by using an AUR helper. An AUR helper automates package downloads, dependency resolution, package builds, updates, and package removal.

Popular AUR helpers include:

• Yay
• Yaourt
• Packer

However, remember this important warning:

Warning AUR packages: AUR helpers can lead to safety risks if users do not review the PKGBUILD.

Before installing software, inspect:

• PKGBUILD
• Install files
• Package descriptions
• Dependencies
• Related files
• Source URLs

This is considered a good packaging technique.

First, log in as user1 and install the necessary build tools using the following command:

su - user1
sudo pacman -S --needed base-devel git

You will be asked to choose which you’d like to install.

Select “all” option and press the Enter key. You should see the following screen:

Type Y and press the Enter key to proceed with the installation.

Next, download the YAY tool with the following command:

git clone https://aur.archlinux.org/yay.git

The git clone command downloads the package source into a local directory.

Next, navigate to the downloaded directory and build the package with the following command:

cd yay
makepkg -si

AUR packages are built from PKGBUILDs using makepkg.

The makepkg -si command performs the complete build process, installs required dependencies, creates a package, and installs it using Pacman.

Searching for Packages in AUR

Before installing software, you can perform a package search to find available packages and review package descriptions.

For example:

yay -Ss package-name

This command displays package descriptions, package details, popularity information, and other useful information.

Step 4 – How to Use YAY to Install AUR Package

The basic syntax to use YAY is shown below:

yay -S package-name

For example, to install the unzip command, run the following command:

yay -S unzip

This command downloads source files, resolves dependencies, performs package builds, and installs the package.

If you want to uninstall the package, run the following command:

yay -Rns unzip

To remove unwanted dependencies, run the following command:

yay -Yc

Yay works similarly to pacman, making package management easier for Arch Linux users.

Step 5 – Install AUR Package Manually

Although Yay is convenient, some users prefer manual installation. This method provides greater visibility into package source code and package builds.

You can install packages from the AUR entirely manually by following official guidelines.

Let’s download the Google Chrome package with the following command:

git clone https://aur.archlinux.org/google-chrome.git

Next, navigate to the downloaded package and compile it with the following command:

cd google-chrome
makepkg -si

The command above downloads source code, resolves dependencies, compiles software, creates a package, and installs it.

This approach is often preferred when auditing package contents, troubleshooting an error, creating your own package, or learning how package builds work.

AUR Security Best Practices

Before installing software from AUR, keep the following recommendations in mind:

• AUR packages are user created and come with risks.
• Malicious code has been found in AUR packages.
• Trusted Users monitor AUR but cannot guarantee safety.
• Inspect PKGBUILDs and install files before building packages.
• Review package descriptions and package details.
• Verify the software uses a compatible license.
• Review package dependencies carefully.
• Check package comments and update history.
• Use AUR packages at your own risk.
• Prioritize official repositories whenever possible.

Some organizations maintain a custom repository internally instead of relying entirely on community packages.

AUR vs Official Repositories

The official repositories start with software packages reviewed and maintained by Arch developers. AUR, on the other hand, is maintained by the community.

Official repositories provide:

• Better security
• Better testing
• Faster updates
• Greater stability

AUR provides:

• New packages
• Community software
• Development versions
• Niche applications
• Popular packages inclusion before they reach official repositories

Because of these differences, many users install software from official repositories first and use AUR only when necessary.

Conclusion

In this post, we explained how to use the Arch User Repository in Arch Linux. You learned how to configure mirrors, install development tools, use sudo pacman and Yay, perform a package search, and manually build packages using makepkg.

You also learned why AUR packages require additional attention. While the AUR community provides access to thousands of useful applications, package quality can vary. Always inspect PKGBUILDs, install files, dependencies, and package details before installation. Review source code, logs, and package information carefully to minimize security risks.

For most Arch Linux users, using an AUR helper such as Yay is the preferred method because it simplifies package management. However, understanding the manual build process is valuable when troubleshooting software, auditing package contents, creating your own package, or contributing improvements back to the community.

By following the best practices outlined in this guide, you can safely install software from the AUR while maintaining a stable and secure Arch Linux system. You can now use AUR to install additional software that is not available in the Arch Linux default repository and take advantage of the vast ecosystem maintained by the Arch community.