[ Auracle / open-source / v2.1 ]
Backtest, simulate, and analyze historical market data on hardware you control. Python CLI, JupyterLab integration, and a web UI for managing simulation runs. Open-source. Self-hosted. Research and simulation only.
[ The product ]
Auracle Open Source is a developer toolkit for quantitative research. You hand it historical market data; it gives you a vectorized backtest engine, a walk-forward cross-validation harness, statistical tooling, and three interchangeable interfaces (notebook, CLI, web UI) for driving them. Everything runs locally on Docker; nothing leaves your machine.
It's the substrate professional quants use to test hypotheses before committing them to live capital somewhere else. It is not, by itself, a trading platform.
[ Features ]
The open-source distribution ships every research-side capability the platform has — no feature gating, no per-call quotas, no usage metering.
Run a strategy against years of daily or intraday bars in seconds. Compute portfolio returns, signal/weight/position lineage, and the standard stats (Sharpe, Sortino, Calmar, max drawdown, win rate, profit factor) directly.
Rolling-window train/test splits with the same API as a single backtest. Out-of-sample stats per fold, with overfit detection signals (parameter sensitivity, OOS Sharpe degradation, regime stability).
Bundled JupyterLab with the platform pre-installed. Import
auracle.backtest and you're researching. Walk-through notebooks
included. Bring your own pandas/NumPy code — no DSL.
auracle backtest run …, auracle walkforward …,
auracle ingest …. Scriptable for batch experiments;
emits JSON for piping into your own analysis tooling.
Houston, the bundled web UI, lets you browse historical runs, compare equity curves, sort by Sharpe, and export to CSV. Useful when you'd rather click through results than load a notebook.
Bundled adapters for free public sources (yfinance) plus optional adapters for paid providers you bring keys for. Data lives in your local Postgres + TimescaleDB. Nothing is sent to a vendor.
Drawdown analysis, rolling-window stats, regime detection, factor decomposition, and the seven overfit signals from the Lopez de Prado literature — implemented as plain Python functions you can call from any notebook.
Pre-built Docker Compose stack. Pull the images, run
docker compose up, you're done. No accounts, no cloud calls,
no usage caps, no telemetry by default.
[ Workflow ]
No accounts. No keys. The default install ships with bundled example strategies and free-tier data adapters so you can run something useful within minutes.
One-line Docker install. Three minutes from curl to a running stack on your hardware.
Pull historical bars from a free provider (yfinance) or paste keys for a paid one you already have.
Open JupyterLab, write a Strategy class, run run_backtest(). See Sharpe, equity curve, fills.
Walk-forward the result. Adjust parameters. Compare equity curves in Houston. Export as CSV for further work.
Auracle # A minimal Auracle strategy — 12 lines, pure Python.
from auracle.backtest import Strategy, run_backtest
from auracle.db import get_engine
class MACrossover(Strategy):
universe = [("SPY", "NYSE")]
def prices_to_signals(self, prices):
fast = prices.rolling(20).mean()
slow = prices.rolling(60).mean()
return (fast > slow).astype(int)
result = run_backtest(get_engine(), MACrossover)
print(f"Sharpe: {result.sharpe:.2f} | MaxDD: {result.max_drawdown:.1%}")
# Sharpe: 0.65 | MaxDD: -28.9%[ Open source ]
The installer, the client SDK, and the documentation are all on GitHub. You can read every line of the install script before running it, fork it, change it, redistribute it. The runtime images ship as pre-built Docker layers so customers don't have to rebuild a 7 GB JupyterLab image, but the source generating those images is the same code in the repo.
[ Product scope ]
Auracle Open Source is a research and simulation toolkit for time-series data. The clearest framing of the scope:
[ FAQ ]
The installer, client SDK, EULA, and the documentation site are all in public repositories under SiixQuant on GitHub. The runtime container images are distributed as pre-built Docker layers under a permissive license that allows self-hosting, modification, and redistribution — see the LICENSE file in the installer repo for the exact terms.
No. This distribution is a research and simulation environment only. It reads historical data, runs backtests in memory, and writes results to a local Postgres database. It does not authenticate to brokers, generate signals for live execution, or place orders of any kind.
You install Docker, run a single curl … | bash from the installer
repo, and three minutes later you have JupyterLab, a Python CLI, and a web UI
running on your machine. From there you import historical data (free yfinance
adapter included), write or import a Strategy class, and call
run_backtest(). Everything is local.
In a Postgres + TimescaleDB container on your machine. There is no remote
sync, no cloud backup, no telemetry by default. If you delete the
~/auracle/data/ directory, the data is gone.
Comfortable with pandas DataFrames is enough. A minimal Strategy is ~12 lines (see the example above). Bundled walk-through notebooks cover common patterns: moving-average crossovers, mean reversion, momentum, regime detection.
Minimum: 4 CPU, 8 GB RAM, 50 GB SSD. Comfortable: 8 CPU, 16 GB RAM, 200 GB SSD. The JupyterLab image is the heaviest dependency at ~3.5 GB; everything else is light.
You could do that. What Auracle adds is: a tested vectorized backtest engine with consistent stats; a walk-forward harness; a TimescaleDB-backed bar store that scales past pandas' in-memory limits; a CLI for batch runs; and a web UI for browsing and comparing historical results without re-opening a notebook every time.
A separate commercial Auracle distribution exists under its own brand and compliance review. This site does not describe it; the commercial version ships under its own terms, its own pricing, and its own product positioning.