Install

Aura’s toolchain is the aura CLI (Rust crate aura-cli). User programs compile through a C backend and need a system C compiler at build time.

One-liner (release tarball)

The public 0.1.1-alpha.8 GitHub Release assets are available for the supported Unix targets. 0.1.0-alpha remains available as the previous public alpha.

curl -fsSL https://aura.pilotworks.dev/install.sh | bash

Versioned layout ($AURA_HOME, default ~/.aura)

$AURA_HOME/
  versions/
    0.1.1-alpha.8/
      bin/aura
      share/aura/runtime/runtime.c    # source/bootstrap fallback
      share/aura/runtime/<target>/    # prebuilt C/LLVM runtime archives
      meta/version, os, arch, installed_at
    0.2.0/
      bin/aura
      share/aura/runtime/
        runtime.c                    # source/bootstrap fallback
        llvm_exceptions.h
        darwin-arm64/
          c/dev/libaurart.a
          c/dev/none/libaurart.a
          c/release/libaurart.a
          llvm/dev/libaurart-llvm.a
          llvm/release/libaurart-llvm.a
          # every archive has a sibling .meta manifest
      …
  current -> versions/0.1.1-alpha.8     # active toolchain
  bin/
    aura -> ../current/bin/aura       # put this on PATH
    avm                               # Aura Version Manager

The installer also symlinks ~/.local/bin/aura and ~/.local/bin/avm (disable with AURA_LINK_USER_BIN=0).

Release installs support Linux amd64/arm64 and macOS arm64/amd64. Windows amd64/arm64 remain explicitly deferred release-install targets; use a source install instead.

Options

# Pin a version (tag without leading v)
curl -fsSL https://aura.pilotworks.dev/install.sh | AURA_VERSION=0.1.1-alpha.8 bash

# Custom home (multi-user or CI)
curl -fsSL https://aura.pilotworks.dev/install.sh | AURA_HOME=/opt/aura bash

# Install side-by-side without changing the active version
curl -fsSL https://aura.pilotworks.dev/install.sh | AURA_VERSION=0.2.0 AURA_SET_DEFAULT=0 bash
avm 0.2.0

Switch versions

avm --list
avm --show
avm 0.1.1-alpha.8
aura version

avm only flips the current symlink; previously installed trees under versions/ stay on disk.

The installer downloads the archive and its adjacent .sha256 file into a temporary directory, verifies the archive before publishing it, and validates the executable and version metadata before activation. A failed or interrupted download leaves the active version unchanged. Reinstalling a version also keeps the previous copy until the new copy has passed validation.

avm --list reports only installations with an executable and matching version/target metadata. avm --show reports (none) for a missing, dangling, or malformed current link. Switching refuses to replace a malformed regular file or directory and creates replacement links through temporary names.

Source of truth: scripts/install.sh + scripts/avm. Site build (site/scripts/sync-install.mjs) embeds avm into public/install.sh for the CDN.

Prerequisites

Install from source (alpha)

cargo install puts a single binary in ~/.cargo/bin (not versioned under $AURA_HOME). Prefer the one-liner for normal use.

git clone https://github.com/auraspace/aura.git
cd aura
cargo install --path crates/aura-cli

aura version
aura new hello
cd hello && aura run .

Runtime library

The C runtime (runtime/runtime.c) is embedded in the CLI and written to a cache on first build if no on-disk copy is found:

Standard library (std.io, …)

Auto-prelude and import std.* resolve packages from:

You do not need to keep the git clone after install for compiling Aura programs.

Without installing

From a clone:

cargo run -p aura-cli -- version
cargo run -p aura-cli -- run examples/notes

Release archives

Pushing a tag v* runs .github/workflows/release.yml: build tarballs (Linux amd64, macOS arm64/amd64) and attach them to a GitHub Release.

Integrity & signing (roadmap)

Alpha releases ship per-archive .sha256 files, an aggregate SHA256SUMS, and a detached minisign signature. install.sh verifies the selected archive checksum before activation; production tag workflows fail closed when signing material is missing or invalid. OS notarization and Windows Authenticode remain deferred; see RFC-013.

Maintainer flow (version dump → changelog → commit → tag → CI):

prepare-release.sh → push commit → tag v* → Actions Release → install.sh

Full steps: docs/releases/README.md.

# After the release is published:
tar xzf aura-*-<os>-<arch>.tar.gz
export PATH="$PWD/aura-*/bin:$PATH"
aura version

Or use the installer (recommended): it unpacks into $AURA_HOME/versions/<ver>/.

Local package without publishing:

TAG_VERSION=0.1.1-alpha.8 bash scripts/package-release.sh
# → dist/aura-0.1.1-alpha.8-<os>-<arch>.tar.gz

Verify install

export PATH="$HOME/.aura/bin:$HOME/.local/bin:$PATH"
aura version
avm --help
avm --show
aura new /tmp/aura-smoke && aura run /tmp/aura-smoke

Expect Hello, Aura on stdout.

Install smoke checklist (C12s)

Automated / printable checklist after a release or local package:

# Human steps only
bash scripts/install-smoke.sh --checklist

# Check the install already on PATH / $AURA_HOME (no network)
bash scripts/install-smoke.sh

# Maintainer: package this checkout into a temp $AURA_HOME and smoke
TAG_VERSION=0.1.1-alpha.8 bash scripts/package-release.sh
bash scripts/install-smoke.sh --local-pkg

# Optional: curl the published installer into a temp home (network)
# AURA_VERSION=0.1.1-alpha.8 bash scripts/install-smoke.sh --from-release

Source: scripts/install-smoke.sh.

Troubleshooting

Next

• Getting started
• CLI
• Release notes 0.1.1-alpha.8
• Historical 0.1.0-alpha release notes