How to Install Paru on Arch Linux

Paru gives Arch Linux users pacman-style commands for official repository packages and AUR packages from one terminal workflow. It still keeps the Arch User Repository boundary visible: Paru downloads PKGBUILDs, shows review prompts, builds packages as a regular user, and installs the finished packages through pacman.

To install Paru on Arch Linux for the first time, bootstrap the AUR package with git, base-devel, and makepkg. After installation, the same setup can handle routine Paru commands, PKGBUILD review tools, cache cleanup, configuration, updates, removal, and common build errors.

Install Paru on Arch Linux

Do not use sudo pacman -S paru for the first install. Current Arch repository metadata does not provide a paru package in the official repositories; the maintained packages are in the AUR as paru, paru-bin, and paru-git.

These commands target Arch Linux. Arch-derived distributions such as CachyOS, Manjaro, or Artix can ship different helper defaults or repositories, so check their own package guidance before copying the Arch AUR bootstrap workflow.

AUR packages are community-maintained and are not official Arch Linux packages. Review PKGBUILDs before building, especially when a package pulls source archives, binaries, install scripts, or development snapshots.

Update Arch Linux Before Building Paru

Synchronize the package database and apply any pending Arch updates before building an AUR helper:

sudo pacman -Syu

These commands use sudo for tasks that need root privileges. If your user is not in the sudoers file yet, run the commands as root or follow the guide on how to add and manage sudo users on Arch Linux.

Install Paru Build Prerequisites

Install Git and the Arch package-build toolchain:

sudo pacman -S --needed git base-devel

The base-devel package includes tools such as makepkg, fakeroot, debugedit, make, and compiler utilities used by many AUR builds. The recommended paru package also needs a Cargo provider; if makepkg asks you to choose between rust and rustup, select rust unless you intentionally manage Rust toolchains with rustup.

Choose a Paru Package

All three AUR packages install the paru command, but they differ in source, build behavior, architecture coverage, and update risk.

Package	Build Source	Best For	Notes
paru	Stable upstream source archive	Most users	Builds against the current local pacman and libalpm libraries.
paru-bin	Prebuilt GitHub release archive	Fast installs on supported architectures	Check the AUR page first; binary packages can lag behind pacman/libalpm changes.
paru-git	Latest upstream Git commit	Testing development changes	Provides paru and conflicts with the stable packages.

The source package is the safest default because it compiles against the libraries currently installed on your system. Use paru-bin only when you want the quickest install and have checked that the AUR package is current. Use paru-git only when you specifically want unreleased development changes.

Install the Recommended Paru Source Package

Clone the stable AUR package into your home directory:

cd ~
git clone https://aur.archlinux.org/paru.git
cd paru

Review the PKGBUILD before building the package:

cat PKGBUILD

The current stable package downloads a source archive from the upstream Paru GitHub project, depends on git, pacman, and libalpm.so, and uses Cargo as a build dependency. Look for unexpected source URLs, install scripts, or commands that do not match the AUR page before continuing.

Build and install Paru with makepkg:

makepkg -si

Relevant output includes:

==> Making package: paru 2.x.x-...
==> Checking runtime dependencies...
==> Checking buildtime dependencies...
==> Validating source files with sha256sums...
    paru-2.x.x.tar.gz ... Passed
==> Starting build()...
==> Starting package()...
==> Finished making: paru 2.x.x-...
==> Installing package paru with pacman -U...

Remove the cloned build directory after the install succeeds and you no longer need the local PKGBUILD copy:

This permanently deletes the cloned ~/paru directory, not the installed package. Run the verification commands in the next section first if you are unsure whether the install completed.

cd ~
rm -rf paru

Install Paru Binary Package

The paru-bin package downloads a prebuilt release archive instead of compiling Paru locally. Review its AUR page before using it, especially after pacman upgrades, because prebuilt binaries depend on compatible libalpm libraries.

cd ~
git clone https://aur.archlinux.org/paru-bin.git
cd paru-bin
cat PKGBUILD
makepkg -si

Relevant output includes:

==> Making package: paru-bin 2.x.x-...
==> Validating source_x86_64 files with sha256sums...
    paru-v2.x.x-x86_64.tar.zst ... Passed
==> Creating package "paru-bin"...
==> Finished making: paru-bin 2.x.x-...

Clean up the cloned binary package directory after verification:

cd ~
rm -rf paru-bin

Install Paru Development Package

The paru-git package tracks upstream Git commits and rebuilds when the development branch changes. This package provides the same paru command but conflicts with paru and paru-bin, so keep only one variant installed.

cd ~
git clone https://aur.archlinux.org/paru-git.git
cd paru-git
cat PKGBUILD
makepkg -si

Clean up the cloned development package directory after verification:

cd ~
rm -rf paru-git

Verify Paru Installation

Confirm the active binary path, package owner, Paru version, and installed package variant:

command -v paru
pacman -Qo /usr/bin/paru
paru --version
pacman -Q paru paru-bin paru-git 2>/dev/null

Relevant output includes:

/usr/bin/paru
/usr/bin/paru is owned by paru 2.x.x-...
paru v2.x.x - libalpm v16.x.x
paru 2.x.x-...

If you installed paru-bin or paru-git, the package-owner and pacman -Q lines will show that package name instead.

Compare Paru with Pacman and Yay

Pacman remains the official Arch package manager. Paru delegates official repository installs and upgrades to pacman, then adds AUR searching, PKGBUILD review, dependency resolution, and local package builds for community packages.

AUR packages installed by Paru still enter the pacman database as local packages. Use this command to list foreign packages installed outside the official repositories:

pacman -Qm

Paru and Yay solve the same broad problem. Paru is written in Rust and was created by the original Yay developer, while Yay remains a widely used Go-based helper. If you want to compare helpers or install Yay instead, use the same-distro guide to install Yay on Arch Linux.

Paru does not manage Flatpak, Snap, AppImage, or distro-independent package formats. Use the tool that owns those package sources, such as flatpak for Flathub apps or snap for Snap packages.

Use Essential Paru Commands

Search Packages with Paru

Run Paru with a search term for an interactive package picker:

paru package-name

Use -Ss when you only want to print matching repository and AUR results:

paru -Ss package-name

Install Packages with Paru

Install a package by name:

paru -S package-name

Paru checks official repositories and the AUR. For AUR packages, it downloads the PKGBUILD, shows review prompts, builds as your user, and calls pacman for the final package installation.

Update Arch and AUR Packages

Upgrade official repository packages and AUR packages together:

paru -Syu

Check or update only AUR packages when you intentionally want to leave official repository upgrades for a separate pacman run:

paru -Qua
paru -Sua

Avoid long-term partial upgrades on Arch Linux. If repository packages are pending, run a normal full upgrade before troubleshooting AUR build failures.

Inspect AUR Packages

Show package metadata, including dependencies, maintainer, votes, popularity, and out-of-date status for AUR packages:

paru -Si package-name

Read AUR comments before installing unfamiliar packages or troubleshooting a failed build:

paru -Gc package-name

Remove Packages with Paru

Remove a package and dependencies that are no longer required by anything else:

paru -Rns package-name

The flags mirror pacman behavior: -R removes the package, -n removes saved configuration backups, and -s removes orphaned dependencies when pacman confirms they are no longer needed.

Review and Rebuild PKGBUILDs with Paru

Download PKGBUILDs Without Installing

Download the PKGBUILD and related AUR files for inspection:

paru -G package-name

Paru creates a directory named after the package. This is useful when you want to read, edit, or archive the package files before building.

Print a PKGBUILD in the Terminal

Print the PKGBUILD without cloning the package directory:

paru -Gp package-name

Build from a Local PKGBUILD Directory

Build and install from the current directory after reviewing or editing a PKGBUILD:

paru -Bi .

This is useful after paru -G when you intentionally modify package files before building. Review diffs carefully because local edits change what gets compiled and installed.

Force a Paru Rebuild or Redownload

Force Paru to rebuild or redownload a package when the cached build tree is stale:

paru -S --rebuild package-name
paru -S --redownload package-name

If you are used to Yay’s --cleanbuild wording, use Paru’s rebuild, redownload, or cache cleanup options instead.

Install a Specific Package Version with Paru

Paru does not use a normal paru -S package=version workflow for arbitrary AUR downgrades. For AUR packages, inspect the package’s AUR Git history and build a known PKGBUILD commit only when you understand the dependency and security tradeoffs. For official repository packages, use pacman-managed local package files or the Arch Linux Archive workflow instead of treating Paru as a version pinning tool.

Manage Paru Cache and Orphans

Paru stores AUR build files under $XDG_CACHE_HOME/paru/, or ~/.cache/paru/ when XDG_CACHE_HOME is unset. Packages installed from the AUR still install into the system through pacman; the cache is only the downloaded build workspace.

Remove Unneeded Dependencies

Ask Paru to remove dependencies that no installed package still requires:

paru -c

Review the package list before confirming. Orphan cleanup is host-specific because each Arch installation has a different package set.

Clear Paru and Pacman Caches

Start with the normal sync-cache clean when you want Paru to clean cached AUR packages and untracked files in the build cache:

paru -Sc

Use the double-clean operation only when you intentionally want the more aggressive cache cleanup prompt:

paru -Scc

paru -Scc can remove cached packages that make downgrades or rebuilds easier. Confirm the prompts only when you are comfortable losing those local copies.

Configure Paru Behavior

Paru reads configuration from $PARU_CONF, $XDG_CONFIG_HOME/paru/paru.conf, ~/.config/paru/paru.conf, and then /etc/paru.conf. Copy the system file into your user configuration directory before editing per-user options:

mkdir -p ~/.config/paru
cp /etc/paru.conf ~/.config/paru/paru.conf

Show Search Results Bottom-Up

Add BottomUp under the [options] section to print search results from bottom to top:

[options]
BottomUp

Enable Syntax Highlighting for PKGBUILDs

Install bat, which Paru lists as an optional dependency for colored PKGBUILD printing:

sudo pacman -S bat

Open PKGBUILDs in a File Manager

File-manager review belongs in the [bin] section, not under [options]:

[bin]
FileManager = vifm

Replace vifm with the command for your preferred file manager. Changes made during review do not persist across future package updates unless you also enable change saving.

Save PKGBUILD Review Changes

Add SaveChanges if you intentionally edit PKGBUILDs during review and want Paru to keep those changes for later builds:

[options]
SaveChanges

Track Development Packages

Generate Paru’s development package database for VCS packages that Paru did not originally install:

paru --gendb

Paru uses this database to compare development package sources, such as Git repositories, during future upgrades. The state data lives under $XDG_STATE_HOME/paru/, or ~/.local/state/paru/ when XDG_STATE_HOME is unset.

Skip PKGBUILD Review Prompts

Add SkipReview only when you understand the security tradeoff:

[options]
SkipReview

Skipping review hides the PKGBUILD diff stage where you would normally catch changed sources, new install scripts, or unexpected build behavior. Keep review enabled for unfamiliar AUR packages.

Update Paru

Update Paru with the same command used for normal Arch and AUR upgrades:

paru -Syu

When a new Paru package is available, Paru appears in the upgrade list and rebuilds or reinstalls through the package variant you chose. If paru-bin fails after a pacman/libalpm update, reinstall with the source package so Paru compiles against your current libraries.

Remove Paru

Removing Paru does not remove AUR packages previously installed through it. Those packages remain in pacman’s local package database until you remove them separately.

Preview Installed Paru Packages

List installed Paru variants and debug split packages before removing anything:

pacman -Q paru paru-bin paru-git paru-debug paru-git-debug 2>/dev/null

Source builds can install a debug split package such as paru-debug depending on the current Arch packaging defaults. Include any listed debug package in cleanup if you want Paru fully removed.

Uninstall Paru

Remove whichever Paru package names are installed:

pacman -Qq paru paru-bin paru-git paru-debug paru-git-debug 2>/dev/null | xargs -r sudo pacman -Rns

Delete Paru Configuration and Cache

Remove user-specific Paru settings, cached AUR build files, and Paru’s development-package state only if you do not plan to reuse them:

This permanently deletes your user Paru configuration, cached AUR build directories, and development-package state. Skip this step if you plan to reinstall Paru and want to keep those files.

rm -rf ~/.config/paru ~/.cache/paru ~/.local/state/paru

Verify Paru Removal

Confirm no Paru package variant remains installed and no paru command is on your path:

hash -r
pacman -Qq paru paru-bin paru-git paru-debug paru-git-debug 2>/dev/null || true
command -v paru || true

No output from the package query or command lookup means the package and command are no longer present.

Troubleshoot Paru on Arch Linux

paru Command Not Found

If your shell reports paru: command not found, confirm whether the binary exists and which package owns it:

command -v paru
pacman -Qo /usr/bin/paru

If both commands fail, reinstall one Paru variant from the install section. If you recently removed Paru, start a fresh shell or clear your shell’s command cache with hash -r before retesting.

makepkg Cannot Build as Root

If makepkg reports that running as root is not allowed, leave the root shell and build as a normal user. Use sudo only when pacman installs dependencies or the finished package.

debugedit or fakeroot Is Missing

If makepkg reports that debugedit, fakeroot, or another package-build helper is missing, reinstall the Arch build toolchain and rerun the build:

sudo pacman -S --needed base-devel

PGP Signature Verification Failed

If a PKGBUILD fails with FAILED (unknown public key), read the error for the missing key ID and compare it with the PKGBUILD’s validpgpkeys field. Import the key only when the package page or upstream documentation confirms it:

gpg --recv-keys KEY_ID

If your default keyserver fails, retry with a named keyserver:

gpg --keyserver keyserver.ubuntu.com --recv-keys KEY_ID

libalpm.so Cannot Open Shared Object File

This error usually affects paru-bin after pacman updates its libalpm library before the binary package has caught up. Confirm your pacman branch, remove the binary package, and rebuild from source:

pacman -Q pacman
sudo pacman -Rns paru-bin
cd ~
git clone https://aur.archlinux.org/paru.git
cd paru
makepkg -si

Package Variant Conflicts

The paru-bin and paru-git AUR packages both provide paru and conflict with the stable package. If you switch variants, remove the old one first or accept the conflict prompt only after confirming it removes the package you intended to replace.

Paru Waits for Input During Builds

Paru may be waiting at a PKGBUILD review prompt, dependency prompt, conflict prompt, or pacman confirmation. Scroll up before assuming it is frozen. For scripted maintenance on packages you already trust, --noconfirm can bypass prompts, but it also bypasses review opportunities:

paru -Syu --noconfirm

Additional Resources

• Paru GitHub repository for source code, releases, and upstream issues
• AUR package: paru for the stable source package
• AUR package: paru-bin for the prebuilt binary package
• AUR package: paru-git for the development package
• Arch Wiki: Arch User Repository for manual AUR workflow and security expectations
• Arch Wiki: AUR helpers for helper comparison and limitations

Paru also installs local manual pages:

paru --help
man paru
man paru.conf

The upstream project lists community discussion through the Libera Chat IRC network.

Conclusion

Paru is now installed through the AUR package variant you chose, with the package owner visible through pacman and the active command available at /usr/bin/paru. Use paru -Syu for normal Arch plus AUR upgrades, paru -S package-name for installs, paru -G or paru -Gp for PKGBUILD review, and paru -Rns package-name for package removal. Keep PKGBUILD review enabled for unfamiliar packages, and prefer the source package again if a prebuilt binary ever falls behind pacman/libalpm updates.