# QuantForge v0.2.0

GitHub: [formaldehid/quantforge](https://github.com/formaldehid/quantforge)  
crates.io: [quantforge](https://crates.io/crates/quantforge)

> 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:

```plaintext
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:

```plaintext
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:

```plaintext
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.