Aurora

Glass-box quantitative intelligence. Local. Open. Cited.

Aurora is the verification cortex for serious quantitative work — for humans analyzing hard data, and for AI systems that can't afford to hallucinate.

Cloud LLMs guess. Aurora computes.

⬇️ Download the desktop app · Run from source · Aurora Sentinel demos · See it in action · Aurora Copilot · Aurora Cortex (MCP + SDK) · Roadmap · FantasyLab.ai

⬇️ Download the desktop app

The easiest way to run Aurora — no Python, no terminal, no setup. Download the installer for your OS, double-click, and Aurora opens as a native app with the analysis backend bundled inside it.

→ Download the latest release

Pick the file that matches your OS (filenames carry the version, e.g. 0.2.0):

Aurora_aarch64.app.tar.gz is an auto-updater artifact, not a download — use the .dmg on macOS. There is currently no Intel-Mac (x86_64) or Linux AppImage build; Intel-Mac users can run from source.

On first launch Aurora bootstraps a small knowledge-bank seed, then runs fully offline — no API keys, no cloud, no telemetry. Drop a CSV on the window and watch it analyze. Aurora is local-first: your data never leaves your machine unless you explicitly share a single finding — see PRIVACY.md.

Heads up on the "Unknown Publisher" warning. Current releases are not yet code-signed, so Windows SmartScreen may show "Windows protected your PC" and macOS Gatekeeper may say "unidentified developer." This is expected for a young open-source project. On Windows: More info → Run anyway. On macOS: right-click the app → Open. Code-signing is on the roadmap.

Desktop app — tips & known quirks

A few things that are expected behavior, not bugs:

• First launch shows a welcome screen, not a run. That's intentional — a fresh start is clean. Drop a CSV (or click a demo card) to begin; your past runs are always available under Data → Bundles.
• Give the backend a few seconds on first launch. Aurora starts a local analysis server (127.0.0.1:8001) the first time you open it; the status dot reads "connecting…" for ~5–10 s before it goes live. If it lingers, the app is still warming up — it is not frozen.
• Big datasets take longer, and results land all at once. A large file can spend a while in "analyzing…". When it finishes you'll see "analysis complete" and the views populate. If the Overview looks momentarily empty right after completion, give it a few seconds or click another tab and back — the assembled state is still being fetched, and it will fill in.
• Re-running the same file is instant. Identical data + settings reuse a cached analysis; the banner reads "instant · cached." That's a speed win, not a skipped run.
• Knowledge Bank starts small on a fresh install. The bundled app ships with a seed bank that grows over time; the large multi-thousand-entry bank you may see in screenshots is built up on a machine that's been ingesting data for a while. Citations still work against whatever is local.

Want to build it yourself or run from source? Keep reading.

⚡ Quickstart (60 seconds)

# 1. Clone + create a virtualenv
git clone https://github.com/FantasyLab-ai/aurora.git
cd aurora
python -m venv .venv
# Windows:
.\.venv\Scripts\Activate.ps1
# macOS / Linux:
source .venv/bin/activate

# 2. Install
pip install -r requirements.txt

# 3. Run the Studio
python studio_api.py

Open http://127.0.0.1:8000. Click ▶ Try a demo for an instant smoke test, or drop your own CSV / Parquet / JSON / XLSX.

First run will download a small knowledge-bank seed (~50 MB). After that, Aurora runs fully offline — no API keys, no cloud, no telemetry.

Optional extras (only if you need them):

pip install cryptography             # Ed25519 bundle signing
pip install mcp                      # MCP server for LLM agents (Claude Desktop, Cursor, etc.)
pip install -r requirements-dev.txt  # contributor / test extras

For the optional Vite + TypeScript frontend build (developers only), see § Optional frontend build.

🖥️ The desktop app

A native, installable app — frameless window, sidebar navigation, drag-and-drop any file onto it. Built with Tauri 2, with Aurora's full analysis backend bundled inside the installer, so it runs with zero setup: no Python, no venv, no terminal.

Most people should just download it. The rest of this section is for developers who want to build it from source or hack on the UI.

What it does

Build it from source / develop

The desktop app lives in desktop/. To build the installer yourself (PyInstaller backend + Tauri shell) or run the UI in hot-reload dev mode, see desktop/README.md — it covers the prerequisites (Node, Rust), the one-command launcher (launch.ps1), the installer build (build_installer.ps1), and the Windows Smart App Control caveat. A git tag vX.Y.Z push triggers the cross-platform release CI.

🚨 Aurora Sentinel — Decision Contracts in the room

Aurora ships a complete demo rig under demos/ that turns a Decision Contract trip into something tangible — a Discord ping, a Slack alert, an OBS overlay card, a smart-plug flipping in your room. Five "I gave my local AI X and watch what it caught" videos, all built on the same scaffolding.

Quickstart for the demos (after the install above):

# Generate the synthetic datasets one time:
python -m demos.datasets.falling_ball.generate
python -m demos.datasets.server_metrics.generate

# Install the demo contracts into Aurora's contracts dir:
cp demos/contracts/*.json ~/.aurora/decision_contracts/        # macOS / Linux
copy demos\contracts\*.json $env:USERPROFILE\.aurora\decision_contracts\   # Windows

# Configure your webhooks once (copy the template + paste your URLs):
cp demos/.env.demos.example demos/.env.demos                   # macOS / Linux
copy demos\.env.demos.example demos\.env.demos                 # Windows

# Run the relay (it reads .env.demos for Discord/Slack URLs):
python -m demos.relay.app

Full step-by-step recording walkthrough with OBS setup, contract installation, and a per-demo runbook lives at demos/README.md.

See Aurora in action

A real run on an environmental air-quality dataset — captured straight from a Studio session.