How to Install Paru on Arch Linux

This guide demonstrates how to install paru on Arch Linux through three methods: source compilation, pre-compiled binary, or development tracking. Paru is a feature-rich AUR helper written in Rust that wraps pacman to provide seamless access to both official repositories and the Arch User Repository (AUR), handling dependency resolution, PKGBUILD review, and package building with minimal manual intervention. By the end, you will have paru installed and ready to search, install, and maintain packages from across the entire Arch ecosystem.

Beyond installation, you will learn paru’s essential commands, configuration options, and unique features like downloading PKGBUILDs directly, viewing AUR comments, and enabling syntax highlighting for package review. If you need to set up sudo access on Arch Linux, complete that first since AUR package building requires privilege escalation for installation.

What Makes Paru Different from Other AUR Helpers

The Arch User Repository (AUR) hosts thousands of community-maintained package descriptions that let you build software unavailable in official repositories. Managing AUR packages manually involves cloning repositories, inspecting build scripts, tracking dependencies, and running compilation commands for each package. AUR helpers automate this process while maintaining transparency about what gets installed.

Paru distinguishes itself from alternatives through several design choices:

• Rust implementation: Written in Rust rather than Go or Bash, offering memory safety and modern language features
• File manager integration: Review PKGBUILDs in your preferred editor or file manager instead of the terminal
• AUR comment access: View package comments directly from the command line to check for known issues
• PKGBUILD editing with persistence: Edit build scripts and have changes merged automatically when packages update
• Syntax highlighting: Optional integration with bat for colorized PKGBUILD review

AUR helpers are unofficial community tools not supported by Arch Linux. The Arch Wiki recommends learning manual AUR package installation before relying on helpers. Review PKGBUILDs before building since AUR packages are user-submitted without official vetting.

Install Prerequisites

AUR packages require compilation tools and version control software. The base-devel group provides compilers and build utilities, while git clones package repositories from the AUR.

Synchronize Package Database

Refresh the package database and upgrade installed packages first:

sudo pacman -Syu

A full system upgrade ensures dependency versions align with repository expectations, preventing build failures from mismatched libraries.

Install Build Tools

Install the development packages required for building AUR software:

sudo pacman -S --needed git base-devel

The --needed flag prevents reinstalling packages already at their current versions, saving time if these packages exist on your system.

Select an Installation Method

Paru offers three AUR packages to match different installation preferences. The functionality remains identical across all variants; the difference lies in how you obtain the binary.

Method	Channel	Version	Updates	Best For
paru (Recommended)	AUR	Latest stable	Manual via paru -Syu	Reliable installation, always compatible
paru-bin	AUR	Latest stable	Manual via paru -Syu	Quick installation when binary is current
paru-git	AUR	Git HEAD	Manual via paru -Syu	Testing new features before release

For most users, compiling from source (paru) is recommended because it guarantees compatibility with your current pacman and libalpm versions. The binary package (paru-bin) installs faster but can break temporarily after pacman updates change the libalpm ABI before a new paru release is built. Source compilation takes 1-3 minutes and installs the Rust compiler automatically as a build dependency. Choose paru-bin only if you need the fastest installation and accept that it may require reinstalling from source after major pacman updates. Use paru-git to test unreleased features from the development branch.

Option 1: Compile Paru from Source (Recommended)

Building from source compiles paru using the Rust toolchain, which gets installed automatically as a build dependency. This method guarantees compatibility with your current system libraries and takes 1-3 minutes depending on hardware.

Clone the paru Repository

Navigate to your home directory and clone the source package:

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

Review the PKGBUILD

Examine the build script before proceeding. AUR packages are community-submitted without official review, so verifying what runs during installation is a recommended security practice:

cat PKGBUILD

The paru PKGBUILD downloads the source tarball and compiles using Rust’s cargo build system. Look for unexpected URLs, suspicious commands, or scripts that execute with elevated privileges.

Build and Install

Compile and install paru:

makepkg -si

The -s flag resolves dependencies automatically (including installing Rust if needed), and -i installs the package after building. Enter your sudo password when prompted. Compilation typically takes 1-3 minutes depending on your hardware.

Expected output:

==> Making package: paru 2.1.0-1 (Sun Jan 26 10:22:18 2026)
==> Checking runtime dependencies...
==> Checking buildtime dependencies...
==> Installing missing dependencies...
:: Proceed with installation? [Y/n]
==> Retrieving sources...
  -> Downloading paru-2.1.0.tar.gz...
==> Validating source files with sha256sums...
    paru-2.1.0.tar.gz ... Passed
==> Starting build()...
   Compiling paru v2.1.0
    Finished release [optimized] target(s) in 1m 42s
==> Entering fakeroot environment...
==> Starting package()...
==> Finished making: paru 2.1.0-1

Clean Up

Remove the build directory after installation succeeds:

The following command permanently deletes the cloned paru directory. Only run this after confirming installation succeeded with paru --version.

cd ~
rm -rf paru

Option 2: Install Paru Binary

The binary package retrieves a pre-built paru release from GitHub, avoiding the need for Rust compilation. Installation completes in seconds but depends on the binary being compiled against a compatible libalpm version.

Pre-compiled binaries can fail with “libalpm.so.XX: cannot open shared object file” errors if pacman updates before a new paru-bin release is built. If you encounter this error, use Option 1 (source compilation) instead, which always builds against your current system libraries.

Clone the paru-bin Repository

Navigate to your home directory and clone the AUR package:

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

Review the PKGBUILD

Examine the build script before proceeding. AUR packages are community-submitted without official review, so verifying what runs during installation is a recommended security practice:

cat PKGBUILD

The paru-bin PKGBUILD downloads the official release archive from GitHub and installs the pre-compiled binary. Look for unexpected URLs, suspicious commands, or scripts that execute with elevated privileges.

Build and Install

Build the package and install it:

makepkg -si

The -s flag resolves dependencies automatically, and -i installs the package after building. Enter your sudo password when prompted.

Expected output:

==> Making package: paru-bin 2.1.0-1 (Sun Jan 26 10:15:42 2026)
==> Checking runtime dependencies...
==> Checking buildtime dependencies...
==> Retrieving sources...
  -> Downloading paru-v2.1.0-x86_64.tar.zst...
==> Validating source_x86_64 files with sha256sums...
    paru-v2.1.0-x86_64.tar.zst ... Passed
==> Extracting sources...
==> Entering fakeroot environment...
==> Starting package()...
==> Tidying install...
==> Creating package "paru-bin"...
==> Leaving fakeroot environment.
==> Finished making: paru-bin 2.1.0-1

Clean Up

Remove the build directory after installation succeeds:

The following command permanently deletes the cloned paru-bin directory. Only run this after confirming installation succeeded with paru --version.

cd ~
rm -rf paru-bin

Option 3: Install Paru Development Version

The paru-git package tracks the latest development commits, providing access to new features and bug fixes before official releases. This version builds directly from the GitHub repository HEAD.

Clone the paru-git Repository

Navigate to your home directory and clone the development package:

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

Build and Install

makepkg -si

The build clones the entire paru repository and compiles from the latest commit. Updates via paru -Syu will rebuild whenever the upstream repository changes.

Clean Up

The following command permanently deletes the cloned paru-git directory. Only run this after confirming installation succeeded with paru --version.

cd ~
rm -rf paru-git

Development versions may contain unstable features or incomplete changes. Use paru-git only if you want to test upcoming features or help with debugging.

Verify Installation

Confirm paru installed correctly:

paru --version

Expected output:

paru v2.1.0 - libalpm v16.0.1

The output shows paru’s version and the underlying libalpm library version that interfaces with pacman.

Essential Paru Commands

Paru uses pacman-compatible syntax, so existing pacman commands work identically. The primary advantage is that paru searches both official repositories and AUR simultaneously.

Interactive Package Search

Search for packages interactively:

paru package-name

Running paru with only a search term displays matching packages from repositories and AUR with version numbers, descriptions, and popularity metrics. Enter a number to install the corresponding package.

For a non-interactive search that only prints results:

paru -Ss package-name

Install Packages

Install a package by name:

paru -S package-name

Paru determines whether the package exists in official repositories or AUR and handles installation accordingly. For AUR packages, paru clones the PKGBUILD, shows a diff for review, resolves dependencies (including other AUR packages), builds, and installs.

System Upgrade

Upgrade all packages including AUR:

paru -Syu

This synchronizes the package database, upgrades official packages, checks for AUR updates, and rebuilds outdated AUR packages. Running paru without arguments performs the same upgrade operation.

Upgrade AUR Packages Only

Update only AUR packages without touching official repository packages:

paru -Sua

Check for AUR Updates

List available AUR updates without installing them:

paru -Qua

View Package Information

Display details about any package:

paru -Si package-name

For AUR packages, the output includes maintainer, votes, popularity score, out-of-date status, dependencies, and last modification date.

Remove Packages

Uninstall a package along with orphaned dependencies:

paru -Rns package-name

The flags perform removal (-R), delete configuration files (-n), and remove dependencies no longer required by other packages (-s).

Paru-Specific Features

Paru provides several commands not available in standard pacman or some other AUR helpers.

Download PKGBUILDs Without Installing

Fetch the PKGBUILD and related files for any package:

paru -G package-name

This clones the AUR package repository to a directory named after the package. Useful when you want to inspect, modify, or manually build a package.

Print PKGBUILD Contents

View a package’s PKGBUILD without cloning:

paru -Gp package-name

The output prints directly to the terminal, allowing quick inspection without creating local files.

View AUR Comments

Read user comments from the AUR package page:

paru -Gc package-name

AUR comments often contain important information about build issues, workarounds, or security concerns. Checking comments before installing unfamiliar packages is a useful security practice.

Build from Local Directory

Build and install a PKGBUILD from the current directory:

paru -Bi .

This command is useful after downloading a PKGBUILD with paru -G and making modifications, or when building a locally-created package.

Manage Package Caches

Paru maintains a cache directory for AUR build files separate from pacman’s package cache. Regular cleanup prevents disk space accumulation.

Remove Orphaned Packages

List and optionally remove packages installed as dependencies that are no longer required:

paru -c

Paru presents orphaned packages and prompts for removal confirmation.

Clear All Caches

Remove cached package files and build directories:

paru -Scc

This clears both the pacman package cache in /var/cache/pacman/pkg/ and paru’s AUR cache in ~/.cache/paru/. Confirm when prompted.

Configure Paru Behavior

Paru reads settings from /etc/paru.conf (system-wide) and ~/.config/paru/paru.conf (user-specific). Create the user configuration directory if it does not exist:

mkdir -p ~/.config/paru

Copy the default configuration as a starting point:

cp /etc/paru.conf ~/.config/paru/paru.conf

Enable Search Results Bottom-Up

Display search results with the most relevant matches at the bottom, closer to your cursor:

[options]
BottomUp

Add this to your paru.conf to flip the default search order.

Enable PKGBUILD Syntax Highlighting

Install bat for syntax-highlighted PKGBUILD review:

sudo pacman -S bat

Paru automatically uses bat for PKGBUILD display when installed, providing colorized output that makes reviewing build scripts easier.

Use File Manager for PKGBUILD Review

Open PKGBUILDs in a file manager or editor instead of the terminal:

[options]
FileManager = vifm

Replace vifm with your preferred file manager or editor. This setting activates during PKGBUILD review, opening the package directory for inspection.

Track Development Packages

Development packages ending in -git, -svn, or -hg track upstream version control rather than release versions. Generate the tracking database for packages paru did not originally install:

paru --gendb

Once generated, paru checks these packages against their upstream repositories during upgrades and rebuilds when new commits appear.

Skip Diff Review Prompts

Disable the PKGBUILD diff menu that appears before building:

[options]
SkipReview

Skipping PKGBUILD review reduces security. Only disable this if you understand the risks and trust the packages you install.

Update Paru

Paru updates through the normal upgrade process like any AUR package:

paru -Syu

When a new version becomes available, paru appears in the upgrade list and handles rebuilding itself during the upgrade.

Remove Paru

If you no longer need paru, remove it with pacman.

Uninstall the Package

Remove paru and orphaned dependencies:

sudo pacman -Rns paru

If you installed paru-bin or paru-git instead:

sudo pacman -Rns paru-bin

sudo pacman -Rns paru-git

Delete Configuration and Cache

Remove paru’s configuration and build cache directories:

This permanently deletes your paru configuration settings and cached AUR build files. Skip this step if you plan to reinstall paru later and want to preserve your settings.

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

Verify Removal

Confirm paru is no longer present:

pacman -Qi paru

Expected output:

error: package 'paru' was not found

Removing paru does not affect AUR packages installed through it. Those packages remain on your system and can be managed with pacman or another AUR helper.

Troubleshooting

Cannot Build as Root

If makepkg reports “Running makepkg as root is not allowed,” you are attempting to build as the root user. AUR packages must be built as a regular user for security.

Create a non-root user and switch to it:

useradd -m username
passwd username
usermod -aG wheel username
su - username

PGP Signature Verification Failed

Some AUR packages cryptographically sign their source archives to prove authenticity. If makepkg fails with “FAILED (unknown public key)”, the PKGBUILD’s validpgpkeys array lists a key your keyring does not recognize. The error message includes the required key ID.

Import the missing key from a keyserver:

gpg --recv-keys KEY_ID

Replace KEY_ID with the full fingerprint or short ID shown in the error. For example:

gpg --recv-keys 0FC3042E345AD05D

If the default keyserver fails, specify an alternative:

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

After importing the key, retry the build. If the key still cannot be found, check the package’s AUR comments or upstream documentation for the correct key source.

Build Failures

Package builds can fail due to missing dependencies, outdated PKGBUILDs, or upstream source changes. First verify your system is fully updated:

paru -Syu

Check AUR comments for the package using paru -Gc package-name to see if others report similar issues. Package maintainers often post fixes or workarounds in the comments.

If the package shows an out-of-date flag on the AUR, the maintainer may need to update the PKGBUILD for compatibility with newer dependencies or sources.

Package Conflicts

When installing a package that conflicts with an existing one, paru prompts for removal confirmation. If you accidentally decline, remove the conflict manually:

sudo pacman -Rns conflicting-package
paru -S desired-package

Color Output Missing

Paru only displays colored output when pacman has color enabled. Edit /etc/pacman.conf and uncomment the Color option:

# Misc options
Color

Paru Hangs During Operations

If paru appears to hang, it may be waiting for input that scrolled out of view. Press Enter to check for prompts. For non-interactive operations, add the --noconfirm flag:

paru -Syu --noconfirm

Using --noconfirm bypasses all prompts including PKGBUILD review. Only use this for trusted packages or scripted environments where you accept the security implications.

libalpm.so Cannot Open Shared Object File

If paru fails with an error like “libalpm.so.15: cannot open shared object file: No such file or directory”, the pre-compiled binary (paru-bin) was built against an older libalpm version than your system currently has. This happens when pacman updates its underlying library before a new paru-bin release is available.

Check your current libalpm version:

pacman -Q pacman

The solution is to reinstall paru from source, which compiles against your current system libraries:

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

Source compilation always builds against your installed libalpm version, avoiding this compatibility issue entirely. This is why source compilation is the recommended installation method.

Common Questions

Additional Resources

For more information about paru and AUR package management:

• Paru GitHub Repository: Source code, issues, and release notes
• Arch Wiki: AUR Helpers: Comparison of available AUR helpers
• Arch Wiki: Arch User Repository: Complete AUR documentation
• AUR Web Interface: Browse and search AUR packages

Paru includes comprehensive built-in documentation:

paru --help
man paru
man paru.conf

The project also maintains an IRC channel at #paru on Libera Chat for community support and discussion.

Conclusion

Paru provides comprehensive AUR package management through familiar pacman syntax with added capabilities like AUR comment viewing, PKGBUILD downloading, and syntax-highlighted review. The essential commands are paru -S package to install, paru -Syu to upgrade everything, paru -Rns package to remove, and paru -Gc package to check comments before installing unfamiliar packages. Configure paru.conf to customize behavior, enable bat for syntax highlighting, and use the file manager integration for more thorough PKGBUILD review when needed.