# 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.

```bash
# 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:

```bash
sudo apt update && sudo apt upgrade aura
```

Uninstall:

```bash
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`:

```bash
yay -S aura-bin
```

Or manually with `makepkg`:

```bash
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.

```bash
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:

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

Upgrade:

```bash
sudo dnf upgrade aura
```

Uninstall:

```bash
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.

```bash
# 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:

```bash
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:

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

## Verification

In any shell:

```bash
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`:

```bash
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:

```bash
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:

```bash
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:

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

Inspect logs:

```bash
journalctl -u aura-mothership -f
```

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

```bash
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:

```bash
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](/connecting-to-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
# 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:

```bash
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

- [Initialize your first repository](/first-repo)
- [Write your first intent-logged commit](/first-commit-with-intent)
- [Wire Aura into Claude Code via CLAUDE.md](/claude-md-integration)
- [Troubleshooting install issues](/troubleshooting-install)

For team deployments, read the [Mothership overview](/mothership-overview) to understand what the daemon is doing, then generate a join token and onboard your first teammate.