# Install Aura on Windows

*Three paths: Scoop, Chocolatey, and WSL2. The last one is the one we recommend.*

Aura runs on Windows, but Windows is not its primary target. The Aura team builds and tests everything against Unix-like systems first, then ships Windows binaries from the same release pipeline. If you want the smoothest experience on a Windows machine, use WSL2 and follow the [Linux install guide](/install-linux). If you need native Windows — because your editor, Git credential manager, or corporate policy demands it — Scoop and Chocolatey are both supported.

## Prerequisites

- Windows 10 version 2004 (build 19041) or Windows 11. Older builds do not have the required WSL2 kernel and are missing several console-mode fixes Aura depends on.
- PowerShell 5.1 or PowerShell 7+. Aura's installers prefer PowerShell 7 where available.
- 200 MB of free disk space. Windows AV scanners expand Aura's tree-sitter grammars transiently, so allow a little extra headroom during install.
- Git for Windows 2.40+ if you plan to use Aura alongside an existing Git workflow. Not required for standalone mode.

## Recommended: WSL2

Windows Subsystem for Linux 2 runs a real Linux kernel on your Windows machine. Aura's native Linux build performs identically on WSL2, and all the file-watching, hook, and MCP integrations behave the way they do on Linux — because they *are* the Linux builds.

Enable WSL2 if you have not already:

```powershell
wsl --install -d Ubuntu
```

Reboot when prompted. Open the Ubuntu shell and follow the [Debian/Ubuntu apt steps](/install-linux):

```bash
curl -fsSL https://auravcs.com/apt/pubkey.gpg \
  | sudo gpg --dearmor -o /usr/share/keyrings/auravcs.gpg
echo "deb [signed-by=/usr/share/keyrings/auravcs.gpg] https://auravcs.com/apt stable main" \
  | sudo tee /etc/apt/sources.list.d/auravcs.list
sudo apt update
sudo apt install aura
```

Verify:

```bash
aura --version
aura doctor
```

**Storage note:** keep your repositories on the WSL filesystem (`~/code`, not `/mnt/c/...`). Cross-filesystem access between NTFS and WSL2 is orders of magnitude slower, and Aura's file watcher does not receive inotify events for files stored on the NTFS side. If you must work on code that lives in a Windows directory, edit it through VS Code's WSL remote mode; otherwise clone directly into WSL.

**Editor integration:** VS Code with the "WSL" extension Just Works. The Aura binary your shell runs inside WSL is the one VS Code's terminal invokes, and the MCP server exposed to Claude Code runs on the Linux side. No additional configuration needed.

## Native: Scoop

Scoop is a user-scoped package manager with a clean uninstall story, and it is the Aura team's preferred native Windows path.

```powershell
# If you do not have Scoop yet:
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
irm get.scoop.sh | iex

# Add the Aura bucket and install:
scoop bucket add aura https://github.com/Naridon-Inc/scoop-aura
scoop install aura
```

Scoop installs `aura.exe` into `%USERPROFILE%\scoop\shims\aura.exe` and places the shims directory on your user `PATH`. Open a new PowerShell window to pick up the `PATH` change, then verify:

```powershell
aura --version
aura doctor
```

Upgrade:

```powershell
scoop update aura
```

Uninstall:

```powershell
scoop uninstall aura
```

## Native: Chocolatey

Chocolatey is system-scoped and is the right pick for managed corporate laptops or shared build agents.

Install from an elevated PowerShell prompt:

```powershell
choco install aura
```

Chocolatey places `aura.exe` under `C:\ProgramData\chocolatey\bin\aura.exe` and registers it on the system `PATH`. Verify from a new shell:

```powershell
aura --version
aura doctor
```

Upgrade:

```powershell
choco upgrade aura
```

Uninstall:

```powershell
choco uninstall aura
```

## PowerShell-specific notes

### Execution policy

Aura's pre-commit hook on Windows is a batch file that shells out to `aura.exe`. It does not invoke PowerShell scripts and is unaffected by `Set-ExecutionPolicy`. If you see hook execution errors, see [troubleshooting](/troubleshooting-install).

### Long paths

Aura tracks file paths at the AST level. On Windows, the 260-character `MAX_PATH` limit will bite you in monorepos. Enable long-path support once:

```powershell
# Elevated PowerShell
New-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" `
  -Name "LongPathsEnabled" -Value 1 -PropertyType DWORD -Force
```

And ensure Git knows about it:

```powershell
git config --system core.longpaths true
```

### Line endings

Aura is line-ending-agnostic at the AST level — a function hashed on Windows matches the same function hashed on macOS, regardless of `\r\n` vs `\n`. However, your Git workflow might not be. If you collaborate with Unix users, set:

```powershell
git config --global core.autocrlf input
```

This avoids spurious text-level diffs that Aura would otherwise ignore anyway, but that Git would still record.

### PowerShell completion

Aura emits PowerShell completion scripts:

```powershell
aura completions powershell | Out-String | Invoke-Expression
```

Add that line to your PowerShell profile (`$PROFILE`) to load completions on every shell start. Completion is context-aware the same way it is on macOS and Linux.

### Windows Terminal + UTF-8

Aura's output contains box-drawing characters. Windows Terminal renders them correctly. The legacy `conhost.exe` console sometimes does not, depending on your active code page. If you see mojibake, switch to Windows Terminal or run:

```powershell
chcp 65001
```

before invoking `aura` in the current shell.

## Verification

As on other platforms, the smoke test is:

```powershell
mkdir C:\temp\aura-smoke
cd C:\temp\aura-smoke
aura init
"fn main() { println!(\"hi\"); }" | Out-File -Encoding utf8 main.rs
aura log-intent "Smoke test: added main"
aura status
```

`aura status` should show one tracked logic node and no pending impacts.

## Running Mothership on Windows

A Mothership hub technically runs on Windows — the binary supports it — but the Aura team does not test Windows as a Mothership host. Use Linux under WSL2 or a dedicated Linux box for anything beyond a single-developer experiment. If you insist, the command is the same:

```powershell
aura team serve --bind 0.0.0.0:7777
```

Open the port in Windows Defender Firewall:

```powershell
New-NetFirewallRule -DisplayName "Aura Mothership" -Direction Inbound `
  -Protocol TCP -LocalPort 7777 -Action Allow
```

Consider running the hub as a Windows service via [NSSM](https://nssm.cc/) if you go this route. The [Linux systemd instructions](/install-linux) are the preferred deployment model.

## Upgrading

- `scoop update aura`
- `choco upgrade aura`
- `aura self-update` for manual installs (rare on Windows)

`aura self-update` on Windows handles the running-binary swap with the same atomic rename trick used on Unix. If antivirus software briefly locks the binary during scan, the updater retries.

## Uninstall

- `scoop uninstall aura`
- `choco uninstall aura`
- `aura self-uninstall` if you installed via the ZIP asset directly.

User state lives in `%USERPROFILE%\.aura\`. Repo state lives in `<repo>\.aura\`. Both are untouched by uninstall. Delete them manually if you want a clean slate.

## Next steps

- [Initialize your first repository](/first-repo)
- [First commit with intent](/first-commit-with-intent)
- [Connect to a team](/connecting-to-team)
- [Troubleshooting install](/troubleshooting-install)

If you are using Claude Code on Windows and want the AI agent to respect Aura's semantic guardrails, read the [CLAUDE.md protocol](/claude-md-integration) — the MCP server Aura registers runs identically on native Windows and WSL2.