Install Aura on Linux

Native packages for the distros you already trust, plus a hardened systemd unit for team hubs.

Aura supports Linux as a first-class target. The official release pipeline produces native packages for Debian, Ubuntu, Fedora, and Arch, plus a static x86_64 and aarch64 binary you can drop anywhere. This page covers the distro-native routes, the manual binary route, and how to run the Mothership daemon under systemd on a dedicated team-hub machine.

Prerequisites

A 64-bit Linux kernel, version 5.4 or newer. Aura uses inotify and io_uring where available.
glibc 2.31+ for the dynamically linked bottle, or use the static binary if you are on a musl-based distro like Alpine.
150 MB of free disk space for the binary, its bundled tree-sitter grammars, and any snapshots Aura takes during normal operation.
git 2.30+ is recommended but not required. Aura can run fully standalone (aura init --no-git).

Aura does not require root to run. It only needs root during package installation for /usr/bin placement, and optionally when enabling the Mothership systemd unit.

Debian and Ubuntu (apt)

Aura publishes a signed apt repository. Add the Naridon Inc. GPG key, register the repo, and install.

# Add the signing key
curl -fsSL https://auravcs.com/apt/pubkey.gpg \
  | sudo gpg --dearmor -o /usr/share/keyrings/auravcs.gpg

# Register the repository
echo "deb [signed-by=/usr/share/keyrings/auravcs.gpg] https://auravcs.com/apt stable main" \
  | sudo tee /etc/apt/sources.list.d/auravcs.list

# Install
sudo apt update
sudo apt install aura

The Debian package installs:

/usr/bin/aura — the binary.
/usr/share/bash-completion/completions/aura — bash completion.
/usr/share/zsh/vendor-completions/_aura — zsh completion.
/usr/share/fish/vendor_completions.d/aura.fish — fish completion.
/lib/systemd/system/aura-mothership.service — a template unit for the Mothership daemon, disabled by default.

Upgrading is a normal apt workflow:

sudo apt update && sudo apt upgrade aura

Uninstall:

sudo apt remove aura
# or remove configuration as well:
sudo apt purge aura

Arch Linux (AUR)

Two AUR packages are available. Pick one.

aura-bin — installs the prebuilt binary from the official release. Fastest path.
aura — builds from source, pulled from the Git tag. Slower, but matches your local toolchain.

Using an AUR helper such as yay:

yay -S aura-bin

Or manually with makepkg:

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

Upgrades flow through the AUR helper exactly like any other package.

Note: the AUR package name aura predates an unrelated package manager of the same name by many years. The package is maintained by Naridon Inc. and is the correct target. If a conflict surfaces on your system, prefer aura-bin to disambiguate.

Fedora and RHEL-family (dnf)

Aura ships an .rpm via a signed dnf repository.

sudo dnf config-manager --add-repo https://auravcs.com/rpm/auravcs.repo
sudo dnf install aura

On older RHEL-family systems without dnf config-manager, drop the repo file manually:

sudo curl -fsSL https://auravcs.com/rpm/auravcs.repo \
  -o /etc/yum.repos.d/auravcs.repo
sudo dnf install aura

Upgrade:

sudo dnf upgrade aura

Uninstall:

sudo dnf remove aura

Manual binary install

For distros not covered above — Alpine, Void, NixOS with flakes, or anywhere you want a single self-contained binary — use the static release tarball.

# Detect your architecture
uname -m
# x86_64  -> use the amd64 tarball
# aarch64 -> use the arm64 tarball

curl -fsSL -o /tmp/aura.tar.gz \
  https://auravcs.com/releases/v0.14.1/aura-linux-amd64.tar.gz

tar -xzf /tmp/aura.tar.gz -C /tmp
sudo install -m 0755 /tmp/aura /usr/local/bin/aura

Or use the curl installer, which resolves the correct architecture automatically:

curl -fsSL https://auravcs.com/install.sh | bash

The curl installer drops the binary into ~/.aura/bin/aura by default and appends ~/.aura/bin to your shell profile's PATH. You can override the prefix:

curl -fsSL https://auravcs.com/install.sh | AURA_PREFIX=/usr/local bash

Verification

In any shell:

aura --version
aura doctor

aura doctor checks that the binary is on PATH, the tree-sitter grammars load, ~/.aura/ is writable, and hooks can be installed into a test repository. On Linux it additionally reports whether inotify limits are high enough for Live Sync to watch large repos. If you hit a limit warning, raise fs.inotify.max_user_watches:

echo "fs.inotify.max_user_watches=524288" \
  | sudo tee -a /etc/sysctl.d/99-aura.conf
sudo sysctl --system

Running the Mothership daemon under systemd

The Mothership is the optional P2P hub your team connects to for real-time function-level sync, cross-branch impact alerts, and messaging. It is a single process. For personal use you can run it ad-hoc with aura team serve, but for a shared team hub on a dedicated host the systemd unit is the right shape.

The apt and rpm packages ship the unit file. For manual installs, create it yourself:

sudo tee /etc/systemd/system/aura-mothership.service > /dev/null <<'EOF'
[Unit]
Description=Aura Mothership daemon
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=aura
Group=aura
WorkingDirectory=/var/lib/aura
ExecStart=/usr/local/bin/aura team serve --bind 0.0.0.0:7777
Restart=on-failure
RestartSec=5
ProtectSystem=strict
ReadWritePaths=/var/lib/aura
NoNewPrivileges=true
PrivateTmp=true

[Install]
WantedBy=multi-user.target
EOF

Create the service user and data directory:

sudo useradd --system --home-dir /var/lib/aura --shell /usr/sbin/nologin aura
sudo mkdir -p /var/lib/aura
sudo chown -R aura:aura /var/lib/aura

Enable and start:

sudo systemctl daemon-reload
sudo systemctl enable --now aura-mothership
sudo systemctl status aura-mothership

Inspect logs:

journalctl -u aura-mothership -f

The daemon binds to port 7777 by default. Open it in your firewall for clients on your private network:

sudo ufw allow 7777/tcp
# or, firewalld
sudo firewall-cmd --add-port=7777/tcp --permanent
sudo firewall-cmd --reload

Generate a team join token on the hub:

sudo -u aura aura team invite --expires 24h

Distribute the resulting token to teammates; they run aura team join <token> on their machines to connect. See connecting to a team for the client-side steps.

Shell completion

All three distro packages install completions in standard locations that your shell picks up automatically on next login. If you installed the binary manually and want completions:

# bash
aura completions bash | sudo tee /etc/bash_completion.d/aura > /dev/null

# zsh
aura completions zsh | sudo tee /usr/local/share/zsh/site-functions/_aura > /dev/null

# fish
aura completions fish > ~/.config/fish/completions/aura.fish

As on macOS, completion is context-aware: aura rewind <TAB> lists function names from your current session, and aura team ... subcommands tab-complete against your joined Motherships.

Upgrading

Distro packages upgrade with the normal package manager. Manual installs upgrade with:

aura self-update

Or by re-running the curl installer — it is idempotent and swaps the binary in place.

Uninstall

sudo apt remove aura on Debian/Ubuntu
sudo dnf remove aura on Fedora/RHEL
yay -R aura-bin on Arch
sudo rm /usr/local/bin/aura for manual installs, or aura self-uninstall if you used the curl installer.

Per-user state in ~/.aura/ and per-repo state in each <repo>/.aura/ is preserved across uninstall. Remove explicitly if you are decommissioning.

Next steps

For team deployments, read the Mothership overview to understand what the daemon is doing, then generate a join token and onboard your first teammate.