How to Install Pikaur on Arch Linux

Pikaur is a Python-based AUR helper that collects all user input upfront, then builds and installs packages without interruption. This “ask first, build later” design prevents scenarios where a multi-hour compilation pauses halfway through waiting for keyboard input you missed. By the end of this guide, you will have Pikaur installed and configured to manage packages from both official Arch repositories and the Arch User Repository (AUR) with minimal interaction during builds.

This guide covers installing Pikaur from source or tracking the development branch, plus an optional static build for recovery situations when Python breaks during system upgrades. You will also learn Pikaur’s essential commands, unique configuration options, and features like Arch news display before upgrades and manual package selection via text editor. If you need to configure sudo access on Arch Linux, complete that first since building AUR packages requires privilege escalation.

Install Prerequisites

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

Update System First

Synchronize the package database and upgrade existing packages:

sudo pacman -Syu

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

Install Build Dependencies

Install the required packages for building AUR software:

sudo pacman -S --needed git base-devel

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

Select an Installation Method

Pikaur offers several AUR packages for different use cases. The core functionality remains identical; the difference lies in version tracking and dependency handling.

Method	Channel	Version	Best For
pikaur (Recommended)	AUR	Latest stable	Most users; reliable, well-tested releases
pikaur-git	AUR	Git HEAD	Testing new features before release
pikaur-static	AUR	Latest stable	Recovery tool when Python/pyalpm breaks

For most users, pikaur (stable release) is recommended. The stable package receives updates when the maintainer tags a new release, providing tested functionality. Use pikaur-git only if you want to test unreleased features or help debug issues.

Consider installing pikaur-static alongside regular pikaur as a backup. The static build uses Nuitka to compile Python into a standalone binary that works even when Python itself is broken. This takes longer to build but provides a recovery path if a system upgrade breaks your Python installation.

Option 1: Install Pikaur from Source (Recommended)

Building from source compiles Pikaur using Python build tools. The process installs necessary Python dependencies automatically and takes under a minute on most systems.

Clone the pikaur 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 pikaur PKGBUILD downloads the source tarball from GitHub and builds using Python’s hatchling build system. Look for unexpected URLs, suspicious commands, or scripts that execute with elevated privileges.

Build and Install

Compile and install Pikaur:

makepkg -si

The -s flag resolves dependencies automatically (including pyalpm and Python build tools), and -i installs the package after building. Enter your sudo password when prompted.

Expected output:

==> Making package: pikaur 1.33.2-1 (Mon Jan 27 09:15:22 2026)
==> Checking runtime dependencies...
==> Checking buildtime dependencies...
==> Installing missing dependencies...
:: Proceed with installation? [Y/n]
==> Retrieving sources...
  -> Downloading pikaur-1.33.2.tar.gz...
==> Validating source files with sha256sums...
    pikaur-1.33.2.tar.gz ... Passed
==> Extracting sources...
==> Starting build()...
==> Entering fakeroot environment...
==> Starting package()...
==> Finished making: pikaur 1.33.2-1

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

Option 2: Install Pikaur Development Version

The pikaur-git package tracks the latest development commits, providing access to new features and bug fixes before official releases.

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 clones the entire Pikaur repository and builds from the latest commit. Updates via pikaur -Syu will rebuild whenever the upstream repository 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.

Option 3: Install Pikaur Static Build

The static build compiles Pikaur into a standalone binary with no Python runtime dependency. This takes significantly longer to build but provides a recovery tool when Python or pyalpm breaks during system upgrades.

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 to compile Python code into native binaries. This requires ccache and takes 5-15 minutes depending on hardware. The resulting binary installs as pikaur-static and does not conflict with the regular pikaur package.

Clean Up

cd ~
rm -rf pikaur-static

You can also download pre-built static binaries from the Pikaur releases page on GitHub if you encounter build issues.

Verify Installation

Confirm Pikaur installed correctly:

pikaur --version

Pikaur displays version information in an ASCII art banner showing the pikaur version, pacman version, and pyalpm version. Look for the version number in the output (e.g., Pikaur v1.33.2).

Essential Pikaur Commands

Pikaur uses pacman-compatible syntax, so existing pacman commands work identically. The primary advantage is that Pikaur searches both official repositories and AUR simultaneously while prompting for all input before starting builds.

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 configuration files (-n), and remove dependencies no longer required by other packages (-s).

Pikaur-Specific Features

Pikaur provides several unique capabilities not found in all AUR helpers. Its batch question mode collects all user input before starting builds, so multi-package installations complete without interruption. Pikaur also handles common problems automatically, prompting for untrusted GPG keys, checksum mismatches, and architecture conflicts as they arise.

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 and install 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 Package Caches

Pikaur maintains cache and data directories separate from pacman. Regular cleanup prevents disk space accumulation.

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

Remove packages installed as dependencies that are no longer needed:

pikaur -Rs $(pacman -Qtdq)

Clear All Caches

Remove cached package files and build directories:

pikaur -Scc

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

Automated Cache Cleanup

Install pacman-contrib for the paccache tool, then use it with Pikaur’s cache:

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

This keeps only the two most recent versions of each package in Pikaur’s cache. Pikaur includes example systemd timer and hook files in /usr/share/pikaur/examples/ for automated cleanup.

Configure Pikaur Behavior

Pikaur reads settings from ~/.config/pikaur.conf in INI format. The configuration file is created automatically on first run with default values. Open it in your preferred text editor to customize behavior:

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 (default, weighted by votes and popularity), numvotes, lastmodified, popularity, or pkgname.

Use Alternative Privilege Escalation

Switch from sudo to doas or another tool:

[misc]
privilegeescalationtool = doas

Update Pikaur

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

pikaur -Syu

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

Migrate from Yay

If you previously used yay and want to preserve your AUR package tracking (for diff display on updates), migrate the cache:

mv ~/.cache/yay/* ~/.local/share/pikaur/aur_repos/
find ~/.local/share/pikaur/aur_repos -mindepth 1 -maxdepth 1 -type d | xargs -r -I '{}' -- sh -c 'cd "{}" && git rev-parse HEAD > last_installed.txt'

This moves yay’s cloned repositories and creates tracking files so Pikaur shows meaningful diffs on future updates.

Remove Pikaur

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

Uninstall the Package

Remove Pikaur and orphaned dependencies:

sudo pacman -Rns pikaur

If you installed pikaur-git instead:

sudo pacman -Rns pikaur-git

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 Pikaur is no longer present:

pacman -Qi pikaur

Expected output:

error: package 'pikaur' was not found

Removing Pikaur 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. If the build fails with “FAILED (unknown public key)”, import the required key:

gpg --recv-keys KEY_ID

Replace KEY_ID with the fingerprint shown in the error. If the default keyserver fails, try an alternative:

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

Pikaur can also handle some key imports interactively during the build process if the PKGBUILD specifies the required keys.

Build Failures

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

pikaur -Syu

Check AUR comments for the package on the AUR website to see if others report similar issues. Package maintainers often post fixes in the comments.

Python or Pyalpm Breaks During Upgrade

If a system upgrade breaks Python or pyalpm, Pikaur cannot run. This is where pikaur-static becomes essential. Install it before encountering problems:

pikaur -S pikaur-static

If you are already in a broken state, download the static binary from the releases page on another device, transfer it, and run it to reinstall Python:

chmod +x pikaur-static
./pikaur-static -S python pyalpm

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.

Common Questions

Additional Resources

For more information about Pikaur and AUR package management:

• 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 includes help flags for different operation types:

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

Conclusion

Pikaur provides a Python-based approach to AUR package management that prioritizes uninterrupted builds by collecting all user input before starting compilations. The essential commands are pikaur -S package to install, pikaur -Syu to upgrade everything, pikaur -Rns package to remove, and pikaur -Ss term to search. Take advantage of the automatic Arch news display during upgrades and the manual package selection feature when you need fine-grained control over updates. Consider installing pikaur-static as a backup tool to ensure you can recover from Python-related breakages during system upgrades.