QuantForge is research tooling, not investment advice.

Today I’m releasing QuantForge v0.2.0.

This release moves the project from an early research/backtesting CLI into a more complete single-crate trading workflow focused on data ingestion, live bot execution, and monitoring.

The direction is still the same:

• Rust-first

• CLI only

• no UI

• code-driven strategy development

• small, incremental open-source progress

What is new in v0.2.0

QuantForge v0.2.0 now includes three major command groups:

data

The new data command feeds market data into a local SQLite database.

This makes the workflow much cleaner than pulling raw data ad hoc for every task. Data becomes a first-class local resource that can be reused for validation, research, and live bot execution.

Example:

quantforge \
  --db data/market.sqlite \
  data sync \
  --symbol BTCUSDT \
  --interval 1m

The current sync behavior is designed to be practical for ongoing usage:

• if start is omitted, syncing starts from now

• if end is omitted, syncing continues indefinitely

That makes data sync useful as a simple long-running feeder process.

trade

The new trade command runs the bot against live-updating data stored in SQLite.

For v0.2.0, the goal was not to build a huge execution framework, but to establish the first end-to-end path:

market data -> database -> strategy -> order execution -> trade lifecycle tracking

The current implementation supports:

• dry-run mode

• live mode

• strategy-driven entry and exit

• market-order execution flow

• position close support

• persisted bot run state

Example:

quantforge \
  --db data/market.sqlite \
  trade run \
  --symbol BTCUSDT \
  --interval 1m \
  --fast 20 \
  --slow 50 \
  --quote-order-qty 100 \
  --mode dry-run

This is still intentionally conservative. The project is aiming for clarity and correctness first.

monitor

The new monitor command is for observing and manually managing the trading side when needed.

This includes visibility into:

• bot status

• recent trades

• open orders

• manual order cancellation

• manual position closing

Example:

quantforge \
  --db data/market.sqlite \
  monitor status \
  --symbol BTCUSDT

This is important because I do not want the project to become a “black box bot.” Even in a CLI-only workflow, operators need visibility and manual controls.

Current shape of the project

QuantForge is still not trying to be a polished end-user platform.

It is becoming a code-first foundation for:

• market data ingestion

• backtesting

• strategy experimentation

• controlled live execution

• operational monitoring

That means the project remains best suited for developers who want a Rust-native CLI framework they can inspect, modify, and extend directly.

What is next

For the next iterations, I want to keep improving the reliability and ergonomics of the workflow:

• stronger reconciliation between local run state and exchange state

• better safety rails around live execution

• more built-in strategies and indicators

• improved testing around exchange behavior and order lifecycle

• clearer contributor workflows and release discipline

If you want to follow the project or try it locally, take a look at the repository and feel free to open issues or ideas.

More updates soon.

QuantForge is research tooling, not investment advice.

Today I'm releasing QuantForge v0.1.0, an open-source Rust project for market data ingestion, strict normalization, and reproducible backtesting.

My goal was simple: build something that feels closer to a TradingView/PineScript-style workflow, but with the guarantees and ergonomics I want as an engineer — source control, explicit interfaces, deterministic rules, and a real programming language.

This first release is intentionally small and opinionated.

What ships in v0.1.0

• Binance Spot OHLCV download over public REST endpoints
• SQLite candle storage with idempotent upserts
• validation for gaps, duplicates, ordering, and OHLC sanity
• deterministic event-driven backtesting
• a built-in SMA crossover example strategy
• a CLI with three core commands: download, validate, and backtest

There is no UI.

The CLI is the product.

Why I built it

I wanted a foundation for open-source quant research in Rust that prioritizes correctness before dashboards.

A lot of trading tools start with charts and a convenient surface area, but leave critical details vague:

• how data is normalized
• how missing or malformed candles are handled
• when a strategy is allowed to act
• when an order is assumed to fill
• what arithmetic is used for portfolio calculations

For this project, I wanted the reverse:

• normalized data first
• explicit validation
• reproducible runs
• boring, inspectable rules for fills and accounting
• code-first strategies

That’s also why the first public release is a single crate. Versioning, publishing, installation, and contributor onboarding stay simple, while the internal boundaries are still clear:

• model
• exchange
• storage
• sdk
• backtest

Determinism is a feature

QuantForge v0.1.0 follows a strict contract:

• timestamps are stored as UTC epoch milliseconds
• prices and volumes use decimal arithmetic, not floating-point math
• strategies observe a completed bar and submit intent
• the engine executes that intent at the next bar open
• data validation is explicit, not best-effort

That probably sounds conservative, and it is.

But for backtesting, conservative and explainable beats clever and ambiguous every time.

Quickstart

Install from crates.io:

cargo install quantforge --locked