Installing an AUR Helper: yay and paru

Pacman only touches the official repos. Everything in the AUR — the Arch User Repository — has to be built from source, and by default that means cloning a repo and running makepkg by hand every single time. An AUR helper automates that: search, download, build, and install, all through one command that feels like pacman.

The two most common choices right now are yay and paru. Neither is official, and neither is magic — they’re convenience wrappers around the exact same manual process you’d do yourself.

What the AUR Actually Is

Every package in the AUR is a PKGBUILD file submitted by another user. Nobody at Arch reviews it, tests it, or signs it. When you install from the AUR, you’re trusting a stranger’s build script — and that script runs with your permissions, including the parts that need sudo.

⚠️ Important Exception: An AUR helper does not make packages safer, only faster to install. It will still run arbitrary shell commands from a PKGBUILD as part of the build, and it will still ask for your sudo password to install the result. A helper automating a bad PKGBUILD is worse, not better.

Before You Start

Both helpers build packages the same way pacman does natively — with the base-devel group and git. Install those first:

sudo pacman -S --needed base-devel git

💡 Why This Matters: base-devel isn’t installed by default on a minimal Arch system, and it’s easy to skip because nothing in a normal install prompts you for it. Without it, makepkg fails partway through the build with missing-tool errors that don’t obviously point back to this step.

Installing yay

yay is written in Go and has no extra runtime dependencies beyond what you just installed. Since yay itself isn’t in the official repos, you bootstrap it the same way you’d install any AUR package manually:

git clone https://aur.archlinux.org/yay.git
cd yay
makepkg -si

makepkg -si builds the package and installs it, prompting for your sudo password when it gets to the install step.

💡 Quick Check: Run yay --version afterward. If you get a version string back, the build and install both succeeded. If you get “command not found,” the build likely failed silently — scroll back up through the terminal output for the first red error line, since that’s almost always the real cause, not the last one.

Installing paru

paru is written in Rust, so it needs a Rust toolchain to compile — either rustup or the rust package from the official repos:

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

If you’d rather skip compiling Rust from source, paru-bin is a precompiled AUR package that installs the same binary without needing the toolchain at all — clone and makepkg -si that instead.

💡 Why This Works: Both installs work the same way for the same reason — makepkg reads the PKGBUILD, downloads sources, compiles them, and hands the result to pacman to install. yay and paru aren’t special-cased by Arch; they’re just AUR packages that happen to build a tool for managing other AUR packages.

Which One Should You Use?

They cover the same core job — search, build, install, and keep AUR packages updated alongside pacman — but differ in defaults:

• yay is more widely used, has more community documentation to fall back on, and defaults to a slightly more permissive workflow.
• paru leans more conservative out of the box — it shows you the PKGBUILD diff before building by default, and its config file gives more granular control over things like build flags and skip-review behavior.

If you’re new to the AUR, that default review prompt in paru is a genuine safety net worth having.

Basic Usage

Once installed, both helpers work as a drop-in superset of pacman — same flags, just pointed at the AUR too. The handful of commands below cover most of what you’ll do day to day (swap yay for paru, the syntax is identical):

yay <search-term>          # search both official repos and the AUR
yay -S <package-name>      # install a package (official or AUR)
yay -Syu                   # update everything, official repos and AUR alike
yay -R <package-name>      # remove a package
yay -Rns <package-name>    # remove a package and its unused dependencies + config files

Running yay with no arguments does the same thing as -Syu — it’s the shortcut most people use for their daily update.

💡 Quick Check: Run yay -Syu right after install, even if you have nothing to update. If it walks through both the official repos and the AUR without erroring, everything is wired up correctly.

Read the PKGBUILD. Every Time.

This is the part it’s tempting to skip once the helper is working smoothly. Don’t.

yay -Gp <package-name>   # print a package's PKGBUILD without installing

Before installing anything from the AUR — not just the first time — skim the PKGBUILD for what it downloads and what it runs as part of the build. Malicious or just badly-written PKGBUILDs are rare but they do happen, and an AUR helper will build and run one exactly as fast as it builds a good one. Both yay and paru let you review the PKGBUILD before confirming the install; don’t turn that prompt off just to save a few seconds.