About QuantForge
QuantForge is an open-source Rust toolkit for deterministic trading research, backtesting, controlled execution, and AI-assisted strategy development — backed by a local SQLite file you own.
This page is the why. For the hands-on path — zero to a working backtest, no exchange account needed — go to Start Here.
Why it exists
Trading tooling splits into two camps: Python research stacks that iterate fast but are hard to trust — hidden notebook state, float drift, look-ahead leaks, results you can't reproduce six months later — and closed platforms you can't audit at all. QuantForge is the missing middle: a small, open, local-first core you can read end to end and run unattended on a cheap VPS.
It also closes the gap where accounts die: in most setups, the code that produced the backtest is not the code that places orders. Here, one strategy interface runs through backtest, dry-run, and live. What you tested is what executes.
Where it's heading
Python is for research and iteration. Rust remains the core verification and execution foundation.
Rust owns everything that must not lie — data ingestion and validation, the deterministic backtest engine, risk checks, execution, and the journal of what actually happened.
Python is where strategies get born. A research bridge is planned in stages: first data exports (CSV, Parquet) so any notebook can analyze QuantForge output, later a controlled interface for defining strategies from Python — while the Rust core keeps sole authority over validation, risk, and execution.
AI proposes; it never gets authority. A planned AI workstream has a self-hosted model generate strategy candidates as strict JSON specifications — never executable code. Candidates are schema-validated, deterministically backtested against held-out data, compared to baselines, and allowed only into dry-run or testnet execution. No autonomous real-money trading, ever.
Guarded execution goes on-chain. The next major public workstream is a non-custodial Solana vault, written in Rust with Anchor: the owner deposits assets and delegates bounded, revocable trading authority to a strategy key that can execute only approved swaps under on-chain limits — time-bounded signed intents, rolling caps, cooldowns, instant pause — and can never withdraw. A devnet reference implementation to inspect and fork: no custody, no pooled funds, no profit claims.
These are one idea in three forms: a strategy never gets trust — it gets bounded, revocable, verifiable authority, checked by a deterministic referee.
Near term, the focus stays on foundations: core hardening, backtest reports (JSON, Markdown, HTML — each with a reproducibility hash so shared results can be re-run and checked), the Python bridge, and richer risk controls.
Why Rust
Rust is chosen for the layer that must be correct while unattended: compiler-enforced error handling (no unwrap() in production paths), decimal arithmetic throughout — floats never touch money — typed market concepts that fail at compile time instead of at 3 a.m., and a single installable binary with SQLite bundled in. It's also the language of Solana programs, so the on-chain work extends the same fail-closed culture.
The cost is iteration speed — which is exactly why research is planned in Python. The two languages aren't competing for the same job: Python explores; Rust verifies and executes.
Why CLI-first
There is no UI, by design. A command line is a reproducible artifact: the full configuration of any run is its invocation — copy it into an issue, diff it against yesterday's, replay it in a year. It composes for free with cron, systemd, and shell pipes, which is what future parameter sweeps and AI workflows will need. And staying CLI-only keeps the tool small enough to audit — a security property, not an aesthetic one, for software that holds exchange credentials.
Why determinism matters
A backtest you cannot reproduce is an anecdote, not evidence. The contract: timestamps are UTC epoch milliseconds, prices use decimal math, strategies see only closed bars, backtests execute on the next bar open, data is validated explicitly, and every live action is journaled to SQLite.
Two consequences. Strategies become testable like code — same candles in, same trades out, so regressions are catchable in CI. And any proposal, human or AI, can be verified by a reproducible run instead of a review meeting.
One honest limit: determinism makes results auditable, not predictive. An overfit strategy backtests deterministically too. What you conclude from the number is still on you.
Today, not yet, never
Today: Binance Spot; SQLite storage; a built-in SMA crossover plus a Rust SDK for your own strategies; closed-bar polling; dry-run by default, live only with an explicit flag and credentials.
Not yet: no Python package, nothing on-chain, no tick or websocket data, no portfolios, no derivatives, no restart reconciliation — and interfaces will still move.
Never: investment advice, profit guarantees, copy trading, a hosted trading SaaS, or a black-box bot.
Open source
QuantForge is MIT licensed — use it commercially, fork it, embed it; released versions stay MIT forever. For software that sits next to your exchange credentials, auditability is a security requirement: "read it" beats "trust me." Development happens in the open — every commit passes the full quality gate in public CI, and anything touching live execution gets human review, even when AI agents draft the change.
Join in
The roadmap is shaped by people running QuantForge and reporting where it fights them:
- ⭐ Star the repo — the simplest signal to keep going
- 💬 Join the discussion — what you'd want from the Python bridge or the vault
- 🐛 Open an issue — bugs, friction, missing docs
- 🔧 Contribute — small, reviewable changes welcome
And the best way to judge everything this page claims is to spend five minutes proving it to yourself:
→ Start Here: run QuantForge from zero
QuantForge is research tooling, not investment advice. Nothing here recommends trades or promises profitability.