How to Install Pikaur on Arch Linux

Install Pikaur on Arch Linux when you want a Python-based AUR helper that asks its questions before the build starts, then lets long package builds continue without stopping for late prompts. Pikaur uses pacman-style commands for official repository packages and AUR packages while keeping PKGBUILD review visible.

Use the stable AUR package for normal systems, the development package when you need upstream commits, and the optional static build for recovery situations where Python or pyalpm is temporarily broken. You also get the main Pikaur commands, cache locations, configuration settings, removal steps, and troubleshooting paths.

Install Pikaur on Arch Linux

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

Update System First

Synchronize the package database and upgrade existing packages:

sudo pacman -Syu

A full system upgrade keeps pacman, Python, pyalpm, and build dependencies aligned on Arch’s rolling package set. If your user is not in the sudoers file yet, configure sudo first with the guide to add and manage sudo users on Arch Linux.

Install Build Dependencies

Install the required packages for building AUR software:

sudo pacman -S --needed base-devel git

The --needed flag skips packages already installed at their current version, avoiding unnecessary reinstallation.

Choose a Pikaur Install Method on Arch Linux

Pikaur is not in the official Arch repositories, so the normal bootstrap path is a local AUR build with makepkg. Choose the package that matches how closely you want to track upstream changes and whether you want a separate recovery binary.

Package	Source	Update Behavior	Best Fit
`pikaur`	AUR stable package from tagged GitHub releases	Rebuilds when the AUR package updates to a new tagged release	Most users who want the normal stable helper
`pikaur-git`	AUR development package tracking upstream Git	Can rebuild when upstream development commits change	Testing unreleased fixes or helping debug Pikaur
`pikaur-static`	AUR static package	Installs a separate `pikaur-static` command without a Python/pyalpm runtime dependency	Package-managed recovery helper for regular Arch systems

For most users, install pikaur. The stable package follows tagged upstream releases and currently depends on pyalpm and git, with Python build tools listed as build-time dependencies in the AUR metadata. Use pikaur-git only when you deliberately want the development branch.

Consider adding pikaur-static after the regular helper is working. The static package uses Nuitka and installs a separate command, so it can help recover from Python or pyalpm breakage without conflicting with the normal pikaur package.

Install Pikaur Stable Release on Arch Linux

The stable AUR package downloads the tagged Pikaur source archive from GitHub, verifies the checksum from the PKGBUILD, builds a Python wheel, and installs the resulting package through pacman.

Clone the Pikaur AUR Repository

Navigate to your home directory and clone the AUR package:

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

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 current pikaur PKGBUILD downloads a tagged source archive from GitHub, validates it with a b2sums entry, and builds with Python’s hatchling-based toolchain. Look for unexpected URLs, suspicious commands, or changes that would run with elevated privileges.

Build and Install

Compile and install Pikaur:

makepkg -si

The -s flag asks pacman to install missing dependencies such as pyalpm and Python build tools, and -i installs the package after building. Enter your sudo password when pacman prompts for dependency installation or final package installation.

During a successful build, makepkg should check runtime and build-time dependencies, retrieve the current source archive, validate it with b2sums, run the build and package functions, then pass the finished package to pacman for installation. Version numbers and timestamps change as the AUR package updates.

Clean Up Build Directory

Remove the cloned repository after successful installation:

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

cd ~
rm -rf pikaur

Install Pikaur Development Version on Arch Linux

The pikaur-git package uses the upstream Git repository instead of a tagged release archive. It is useful for testing an unreleased fix, but it is the less conservative package for daily systems.

Clone the pikaur-git Repository

Navigate to your home directory and clone the development package:

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

Build and Install

makepkg -si

The build pulls from Pikaur’s upstream Git repository. Later pikaur -Syu runs can rebuild it when the development package detects upstream changes.

Clean Up

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

cd ~
rm -rf pikaur-git

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

Install Pikaur Static Build on Arch Linux

The static build compiles Pikaur into a standalone command with no Python or pyalpm runtime dependency. Build it before you need it; it is a recovery tool, not a replacement for keeping regular package upgrades healthy.

Clone the pikaur-static Repository

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

Build and Install

makepkg -si

The build process uses Nuitka and currently lists nuitka, python-ordered-set, ccache, fish, python-markdown-it-py, python-pysocks, and python-defusedxml as build-time dependencies in the AUR metadata. The resulting binary installs as pikaur-static and does not conflict with the regular pikaur package.

Clean Up

cd ~
rm -rf pikaur-static

For normal systems, prefer this AUR package-managed static build over a manually downloaded binary. The GitHub release asset is better reserved for emergency recovery when regular Pikaur cannot run; that path is covered in troubleshooting.

Verify Pikaur on Arch Linux

Confirm Pikaur installed correctly:

pikaur --version

Pikaur displays a banner with the Pikaur, pacman, and pyalpm versions. Treat the exact version as moving on Arch; the important check is that the command runs from your normal user account.

Use Pikaur Commands on Arch Linux

Pikaur extends familiar pacman operations with AUR support for install, search, package information, upgrades, and cache cleanup. The primary advantage is that Pikaur searches official repositories and AUR packages from one command while prompting before builds begin.

Interactive Package Search

Search and install packages interactively:

pikaur package-name

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

For a non-interactive search:

pikaur -Ss package-name

Install Packages

Install a package by name:

pikaur -S package-name

Pikaur determines whether the package exists in official repositories or AUR and handles installation accordingly. For AUR packages, Pikaur clones the PKGBUILD, shows a diff for review, resolves dependencies (including other AUR packages), prompts for all required input, then builds and installs without further interruption.

System Upgrade

Upgrade all packages including AUR:

pikaur -Syu

This synchronizes the package database, upgrades official packages, checks for AUR updates, and rebuilds outdated AUR packages. Pikaur displays any unread Arch Linux news items before proceeding with upgrades.

Upgrade AUR Packages Only

Update only AUR packages without touching official repository packages:

pikaur -Sua

Check for AUR Updates

List available AUR updates without installing them:

pikaur -Qua

View Package Information

Display details about any package:

pikaur -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:

pikaur -Rns package-name

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

Use Pikaur-Specific Features on Arch Linux

Pikaur provides several capabilities that make it different from simpler AUR wrappers. Its batch question mode collects user input before starting builds, and it can guide common AUR problems such as untrusted GPG keys, checksum mismatches, and architecture conflicts.

Compare Pikaur with Yay and Paru

Pikaur, yay, and paru all manage AUR packages with pacman-style commands, but they make different tradeoffs. Pikaur is Python-based and emphasizes asking questions up front. Yay is Go-based and widely used for a fast, minimal helper workflow. Paru is Rust-based and includes its own review-focused defaults. If you are still choosing a helper, compare this guide with the guides to install Yay on Arch Linux and install Paru on Arch Linux.

Arch News Display

Before system upgrades, Pikaur checks for unread Arch Linux news and displays relevant items that might require manual intervention. This prevents surprises from package changes that need user action before or after upgrading.

Manual Package Selection

During upgrades, Pikaur prompts you to review packages. Press M at the confirmation prompt to open your text editor with the package list. Remove lines to skip specific upgrades, then save and close to proceed with the modified selection.

Download PKGBUILDs Without Installing

Fetch the PKGBUILD and related files for any package:

pikaur -G package-name

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

Build a Local PKGBUILD

Build a package from a PKGBUILD in the current directory:

pikaur -P

Use pikaur -Pi to build and install in one step. This handles AUR dependencies automatically, unlike running makepkg directly.

Upgrade Development Packages

Force update all development packages (-git, -svn, -hg, etc.) regardless of version numbers:

pikaur -Sua --devel --needed

The --devel flag checks development packages for upstream changes, and --needed skips packages where the local version matches upstream.

Manage Pikaur Caches on Arch Linux

Pikaur maintains cache and data directories separate from pacman’s package cache. Regular cleanup prevents old AUR package archives and cloned repositories from accumulating.

Cache Locations

Pikaur stores files in several locations:

~/.cache/pikaur/build/ – Build directory (removed after successful builds)
~/.cache/pikaur/pkg/ – Built package archives
~/.local/share/pikaur/aur_repos/ – Cloned AUR repositories for tracking diffs
~/.config/pikaur.conf – Configuration file

Remove Orphaned Packages

Review packages installed as dependencies that are no longer needed, then remove them only when the list is safe for your system:

orphans=$(pacman -Qtdq 2>/dev/null || true)
if [ -n "$orphans" ]; then
    sudo pacman -Rs $orphans
else
    printf 'No orphaned packages found.\n'
fi

Clear All Caches

Remove cached package files and build directories:

pikaur -Scc

This clears both pacman’s package cache under /var/cache/pacman/pkg/ and Pikaur’s AUR cache. Confirm only after reviewing what will be removed.

Automated Cache Cleanup

Install pacman-contrib for the paccache tool, then point it at Pikaur’s built-package cache:

sudo pacman -S --needed pacman-contrib
paccache -rk2 -c ~/.cache/pikaur/pkg

This keeps only the two most recent versions of each package in Pikaur’s cache. Pikaur also ships a cache-cleanup hook example under /usr/share/pikaur/examples/ and user service/timer units under /usr/lib/systemd/user/.

Configure Pikaur on Arch Linux

Pikaur reads settings from ~/.config/pikaur.conf in INI format. The configuration file is created automatically on first run with default values, so run Pikaur once before expecting every section to exist. Open it with your preferred editor:

nano ~/.config/pikaur.conf

Skip PKGBUILD Diff Prompts

Disable the diff review prompt that appears before building:

[review]
NoDiff = yes

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

Auto-Update Development Packages

Set development packages (-git, -svn, etc.) to automatically check for updates after a certain number of days:

[sync]
DevelPkgsExpiration = 7

Set to 0 to always check development packages, or -1 to never check automatically.

Keep Build Directories

Preserve build directories between builds for faster rebuilds:

[build]
KeepBuildDir = yes

Development packages keep their build directories by default (KeepDevBuildDir = yes) since they frequently pull from version control.

Change Search Result Sorting

Configure how AUR search results are sorted:

[ui]
AurSearchSorting = hottest

Options include hottest (the default, weighted by votes and popularity), numvotes, lastmodified, popularity, or pkgname.

Use Alternative Privilege Escalation

Switch from sudo to doas only after doas is installed and configured for your user:

[misc]
PrivilegeEscalationTool = doas

Update Pikaur on Arch Linux

Pikaur updates through the normal Arch upgrade process like any AUR package:

pikaur -Syu

When a new version becomes available, Pikaur appears in the AUR upgrade list and rebuilds itself during the upgrade. Keep updates package-managed; do not replace the pacman-owned Pikaur files with a manual copy from GitHub.

Migrate from Yay to Pikaur on Arch Linux

If you previously used Yay on Arch Linux and want to preserve AUR package tracking for diff display on updates, migrate the cache:

mkdir -p ~/.local/share/pikaur/aur_repos
if [ -d ~/.cache/yay ]; then
    find ~/.cache/yay -mindepth 1 -maxdepth 1 -type d -exec mv -t ~/.local/share/pikaur/aur_repos/ -- {} +
    find ~/.local/share/pikaur/aur_repos -mindepth 1 -maxdepth 1 -type d -exec sh -c 'cd "$1" && git rev-parse HEAD > last_installed.txt' sh {} \;
else
    printf 'No yay cache directory found.\n'
fi

This moves yay’s cloned repositories and creates tracking files so Pikaur can show meaningful diffs on future updates. Skip this migration if you want Pikaur to build a fresh AUR repository cache instead.

Remove Pikaur from Arch Linux

If you no longer need Pikaur, remove the installed package with pacman. Removing the helper does not remove AUR packages you installed through it.

Uninstall the Package

Remove the stable Pikaur package and dependencies that are no longer required by other packages:

sudo pacman -Rns pikaur

If you installed pikaur-git instead:

sudo pacman -Rns pikaur-git

If you installed pikaur-static as a recovery helper, remove it separately:

sudo pacman -Rns pikaur-static

If you installed pacman-contrib only for the optional paccache cleanup example and no other workflow needs it, remove that helper separately:

sudo pacman -Rns pacman-contrib

Delete Configuration and Cache

Remove Pikaur’s configuration and data directories:

This permanently deletes your Pikaur configuration settings, cached packages, and AUR repository tracking. Skip this step if you plan to reinstall Pikaur later and want to preserve your settings.

rm -rf ~/.config/pikaur.conf ~/.cache/pikaur ~/.local/share/pikaur

Verify Removal

Confirm the package is no longer present. Substitute pikaur-git or pikaur-static if you removed one of those variants:

pacman -Q pikaur

Expected output after removing the stable package:

error: package 'pikaur' was not found

Installed AUR packages remain on your system after removing Pikaur. Manage them with pacman for installed-state and removal tasks, or install another AUR helper for future AUR upgrades.

Troubleshoot Pikaur on Arch Linux

Cannot Build as Root

Error: Running makepkg as root is not allowed.

Cause: The AUR build is running from the root account. makepkg intentionally refuses this because PKGBUILDs execute arbitrary shell commands during the build.

Fix: Log out of root and rerun the build as your normal sudo-capable user. If you do not have one yet, create it first with the sudo setup guide linked in the prerequisites section, then return to the Pikaur build steps.

PGP Signature Verification Failed

Error: FAILED (unknown public key).

Cause: The PKGBUILD for the package being built expects a source signature key that is not in your user GnuPG keyring.

Fix: Import the full key fingerprint shown by the build error or by the PKGBUILD’s validpgpkeys entry:

gpg --recv-keys KEY_FINGERPRINT

If your default keyserver fails, specify another keyserver and retry:

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

Build Failures

Error: A Pikaur build fails after the PKGBUILD review or while compiling a package.

Cause: Common causes include a partially upgraded Arch system, an outdated AUR PKGBUILD, a missing optional build dependency, or an upstream source change.

Fix: Upgrade the system first, then retry the package build. Use pacman if Pikaur itself is the package that failed to build:

sudo pacman -Syu

If the same package still fails, check that package’s AUR comments before changing local build flags. Maintainers and other users often post temporary fixes when upstream changes break a PKGBUILD.

AUR Helper Not Found

Error: error: could not find an aur helper. please install paru/pikaur/yay to proceed.

Cause: Another tool or script expects a supported AUR helper in your PATH. Pikaur satisfies that requirement only after the install succeeds and your shell can find the pikaur command.

Fix: Confirm the command is available, then rerun the original tool:

command -v pikaur
pikaur --version

If the command is still missing after installation, open a new terminal or refresh your shell’s command cache:

hash -r

Python or Pyalpm Breaks During Upgrade

If a system upgrade breaks Python or pyalpm, regular Pikaur cannot run. Install pikaur-static before you need it:

pikaur -S pikaur-static

If you are already in a broken state and the Pikaur releases page publishes a static binary for your architecture, download that matching asset on another device, transfer it to the Arch system, and run it directly. Do not use an x86_64 release binary on a non-x86_64 system. The exact filename changes by version and architecture:

chmod +x pikaur-static-v*.linux-*.exe
./pikaur-static-v*.linux-*.exe -S python pyalpm

After the repair succeeds, delete the transferred release binary if you do not want to keep an unmanaged recovery file in that directory.

Package Conflicts

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

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

Debug Output

For detailed troubleshooting information, run Pikaur with debug mode:

pikaur --pikaur-debug -S package-name

When reporting issues on the GitHub issue tracker, include the full debug output.

Pikaur Resources for Arch Linux

Use these primary resources when you need to inspect Pikaur source code, compare AUR helpers, or review Arch’s AUR security model:

Pikaur 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

Pikaur also includes operation-specific help flags:

pikaur -Sh  # Sync operations help
pikaur -Qh  # Query operations help
pikaur -Ph  # PKGBUILD operations help
pikaur -Gh  # GetPKGBUILD operations help

Conclusion

Pikaur is ready on Arch Linux once the stable AUR package builds cleanly, pikaur --version works from your normal user account, and updates stay managed through pikaur -Syu. Keep PKGBUILD review enabled unless you have a clear reason to disable it, and add pikaur-static when you want a recovery helper for Python or pyalpm breakage.