RustForge is an institutional-grade AI trading terminal built in pure Rust. It combines real-time multi-exchange market data, Claude-powered AI analysis, quantitative risk management, prediction market trading, and a full TUI dashboard — all in a single binary with nanosecond-precision timestamps and sub-millisecond latency.

• Overview
• Architecture
• Quick Start
• Features
• TUI Hotkeys
• Performance
• Configuration
• Strategy Development
• API Reference
• Troubleshooting
• License and Disclaimer

34 modular crates, 110+ source files, strict dependency boundaries.

graph TD;
    subgraph "External Feeds"
        ALP(Alpaca WS) --> Ingest
        BIN(Binance WS) --> Ingest
        FH(Finnhub WS) --> Ingest
        PM(Polymarket WS) --> Ingest
        LLM(Anthropic Claude) <--> AI
    end

    subgraph "RustForge Engine"
        Ingest(Ingestion / Source Multiplexer) --> Bus(TCP Event Bus)
        Bus --> AI(AI Engine — Dexter / Mirofish)
        Bus --> Quant(Quant Features)
        Quant --> Swarm(Swarm Simulator — 100K Agents)
        Swarm --> KG(Knowledge Graph — petgraph RAG)
        KG --> AI

        AI --> Strategy(Strategy Dispatcher)
        Strategy --> Risk(Risk Gate — GARCH / VaR / Kill Switch)
        Risk --> Exec(Execution Gateway)

        Exec -.-> |Paper Mode| Mock(MockExecutor)
        Exec --> |Live Mode| AlpacaAPI(Alpaca REST)
        Exec --> |Prediction| PolyCLOB(Polymarket CLOB)
    end

    subgraph "Quantitative Models"
        Pricing(Pricing Engine) --> BSM(Black-Scholes-Merton)
        Pricing --> HESTON(Heston Stochastic Vol)
        Risk --> GARCH(GARCH 1,1 Volatility)
        Backtest(Backtest Engine) --> WF(Walk-Forward)
        Backtest --> MC(Monte Carlo)
    end

    subgraph "Persistence"
        Bus --> PG[(PostgreSQL)]
        Bus --> Redis[(Redis Hot-State)]
    end

    subgraph "Frontends"
        Bus --> TUI(Ratatui TUI Dashboard)
        Bus --> Web(REST API / Web Dashboard)
    end

common           Nanosecond timestamps, events, config, models
ingestion        Multi-source market data (Alpaca, Binance, Finnhub, Polymarket)
execution        Trait-based ExecutionGateway, AlpacaExecutor
strategy         Strategy trait, momentum, mean-reversion engines
risk             Kill switch, GARCH vol, VaR, risk interceptor chain
pricing          Black-Scholes-Merton, Heston, GARCH(1,1) models
backtest         Walk-forward, Monte Carlo, backtesting engine
ai               Dexter AI analyst, Claude integration, signal routing
swarm_sim        100,000-agent market microstructure simulator
knowledge_graph  petgraph-backed RAG knowledge engine
polymarket       Polymarket (3 APIs: Gamma, CLOB, Data) + EIP-712 signing
daemon           Hybrid intelligence pipeline, engine orchestration
event_bus        Postcard-serialized TCP event bus (daemon <-> TUI)
tui              Ratatui-powered 6-screen trading dashboard
oms              Order Management System (netting + hedging)
alerts           Rule-based alert engine
signals          Technical indicator signal generation
compliance       Pre-trade compliance, audit trail
persistence      PostgreSQL + SQLite persistence layer
metrics          Prometheus-compatible telemetry
ml               Machine learning model inference
model            Model registry and versioning
feature          Feature engineering pipeline
fix              FIX protocol adapter
cli              Command-line interface
web              REST API server
web-dashboard    Web-based dashboard
dashboard        Dashboard data models
tests            Integration test suite
benchmarks       Criterion performance benchmarks

# 1. Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# 2. Clone
git clone https://github.com/Ashutosh0x/rust-finance.git
cd rust-finance

# 3. Configure
cp .env.example .env
# Edit .env — add your API keys (see Configuration below)

# 4. Build
cargo build --release

# 5. Run (mock mode — no API keys required)
USE_MOCK=1 cargo run -p daemon --release

# 6. Run TUI (separate terminal)
cargo run -p tui --release

• Hybrid Intelligence Pipeline — Quant, Swarm, Knowledge Graph, Dexter AI, Risk Gate, Execution
• Nanosecond-precision timestamps (UnixNanos) with monotonic SequenceId ordering
• Swappable clock — RealtimeClock for live trading, DeterministicClock for backtesting
• Event-driven architecture with typed Envelope<T> wrapping every system event
• Deterministic Safety Gate — zero-AI verification layer preventing agent confirmation bias
• 30-crate workspace compiling in ~17s

• Alpaca — Real-time US equities via WebSocket (5 feeds: IEX, SIP, BOATS, Delayed, Overnight)
• Binance — Crypto streams (trades, bookTicker, depth5) via combined WS endpoint
• Finnhub — Global market data (incl. NSE/BSE) and live trades via WebSocket
• Polymarket — Prediction market data via 3 APIs:
  • Gamma API — Events, markets, tags, search, profiles (gamma-api.polymarket.com)
  • CLOB API — Orderbook, midpoint, spread, prices-history, tick-size, fee-rate (clob.polymarket.com)
  • Data API — Positions, trades, leaderboards, open interest (data-api.polymarket.com)
• Mock source — Deterministic replay for backtesting
• Auto-reconnect with exponential backoff on all sources
• Source Multiplexer — unified SelectAll stream from any combination of sources

• Dexter AI Analyst — Claude-powered market analysis with structured signal output
• 100K Agent Swarm Simulation — Rayon-parallel microstructure Monte Carlo
• Knowledge Graph — petgraph RAG with entity linking and context fusion
• Fused Context — Quant + Swarm + Graph consensus fed into Dexter prompt
• Impact Analysis Engine — AI-driven market impact estimation
• Mirofish — 5,000-agent scenario simulator (rally/sideways/dip probabilities)

• ExecutionGateway trait — plug-and-play execution backends
• Alpaca Executor — Full REST integration (25+ endpoints: orders, positions, assets, historical data)
• Polymarket CLOB — full order lifecycle (limit/market/FOK/GTC/GTD), EIP-712 signed orders
• Polymarket BTC 15-Min — Crypto prediction markets (BTC Up/Down, ETH, SOL, XRP, DOGE)
• Paper trading — MockExecutor for risk-free strategy testing
• Bracket orders — OCO/OTO stop-loss + take-profit combos
• Trailing stops — dynamic stop-loss that follows price

• Deterministic Safety Gate — zero-AI verification layer detecting agent confirmation bias (>85% agreement), concentration, drawdown, and correlation exposure
• Kill Switch — emergency circuit breaker (hotkey K in TUI)
• GARCH(1,1) Volatility — real-time volatility estimation
• Value at Risk (VaR) — parametric + historical VaR calculation
• PnL Attribution — component-level profit/loss decomposition
• Risk Interceptor Chain — composable pre-trade risk checks
• Kelly Criterion Sizing — optimal position sizing
• Max Drawdown and Daily Loss Limit trading guardrails

• Black-Scholes-Merton — options pricing with Greeks
• Heston Stochastic Volatility — smile-calibrated pricing
• GARCH(1,1) — volatility forecasting (sigma_t^2 = omega + alpha * epsilon_{t-1}^2 + beta * sigma_{t-1}^2)
• Monte Carlo Engine — path simulation for derivative pricing
• Walk-Forward Backtesting — out-of-sample validation
• Latency Queue — priority-queue latency simulation for realistic fills

• 6-screen navigation — Dashboard, Charts, Orderbook, Positions, AI, Settings
• Real-time sparkline charts with zoom, scroll, and time range cycling
• Live order book visualization — L2 depth with cumulative volume
• 13-symbol watchlist auto-updating from market data feed
• Exchange heartbeat monitor — NYSE, NASDAQ, CME, CBOE, LSE, CRYPTO, NSE, BSE
• Dexter AI panel with live analysis output and BUY/SELL/HOLD recommendation
• Mirofish simulation widget — rally/sideways/dip probability bars
• Buy/Sell order entry dialogs with quantity and price inputs
• Emergency controls — kill switch, paper/live toggle, risk adjustment

• Full audit trail — every state transition logged with AuditTick
• Pre-trade compliance — rule-based order validation
• Deterministic replay — reproduce any historical trading session

• Finnhub News API — general market news, company-specific news, sector news
• Alpaca News API — US equities breaking news, earnings, SEC filings
• NewsAPI.org — aggregates Reuters, Bloomberg, CNBC, WSJ, Financial Times, BBC Business
• Polygon.io — SEC filings, earnings reports, company reference data
• BSE/NSE RSS — Indian market news from Bombay and National Stock Exchanges
• CoinGecko — cryptocurrency market news and sentiment
• SEC EDGAR — real-time regulatory filings (10-K, 10-Q, 8-K)

Release profile: opt-level=3, lto=fat, codegen-units=1, strip=true

1. Copy the example environment file:

   cp .env.example .env

2. Edit .env and add your API keys (see table above).

3. Quick test with no API keys required:

   USE_MOCK=1 cargo run -p daemon --release

See docs/SETUP.md for step-by-step key creation instructions. See docs/CONFIGURATION.md for the full configuration reference.

Strategies are implemented in the strategy crate using the PluggableStrategy async trait:

1. Define your strategy struct and internal state
2. Implement on_market_event() to process live tick data
3. Emit TradeSignal objects with desired positions and dynamic confidences
4. Register in the daemon's strategy registry for hot-swapping

For examples, see AiGatedMomentum in crates/daemon/src/strategy_registry.rs.

• POST /v2/orders — order submission via AlpacaBroker::submit_order, rate-limited to 150 req/min
• GET /v2/positions — periodic position reconciliation into TUI

• POST /order — EIP-712 signed order placement
• DELETE /order/{id} — cancel specific order
• DELETE /cancel-all — cancel all open orders
• GET /orders — list open orders
• GET /book — order book snapshot
• GET /midpoint — midpoint price
• GET /balance-allowance — USDC balance

• Build errors on Solana crates: The legacy parser, executor, signer, and relay crates are excluded from the workspace due to a yanked solana_rbpf dependency. They are replaced by crates/ingestion and crates/execution in the v2 architecture.
• WebSocket timeout: Ensure your Finnhub/Alpaca API keys are correct. reconnect.rs will log warnings on exponential backoff attempts.
• Missing API keys: Run in mock mode with USE_MOCK=1 to test without any API keys.
• TUI not connecting: Start the daemon first (cargo run -p daemon), then the TUI (cargo run -p tui) in a separate terminal. The TUI connects via TCP to 127.0.0.1:7001.

WARNING This software is provided for educational and research purposes only. The authors are not responsible for any financial losses incurred from running autonomous code on live capital.

MIT License (c) 2026 Ashutosh0x