Ashutosh0x/rust-finance

A high-performance, ultra low-latency trading terminal and AI-infused daemon built completely in Rust.

RustFinance Terminal (Rust‑Forge) – What It Is

RustFinance is an open‑source, Rust‑only trading platform that bundles together:

  • Real‑time market‑data ingestion from a wide range of sources – direct exchange binary feeds (Nasdaq ITCH/OUCH, NYSE XDP/Pillar), broker APIs (Alpaca), crypto WebSockets (Binance), and data providers (Finnhub, Polymarket).
  • A full‑screen terminal UI built with the Ratatui TUI library, showing live order‑book depth, price charts, risk metrics and AI‑generated commentary.
  • AI analysis powered by Anthropic’s Claude model (named Dexter in the code). The model receives market snapshots and produces natural‑language insights that are displayed in the dashboard.
  • Quantitative tools – a library of micro‑structure indicators (MLOFI, VPIN, Kyle’s Lambda, etc.), risk models (GARCH(1,1), VaR), and execution algorithms (TWAP, VWAP, Iceberg, Almgren‑Chriss optimal execution).
  • Order‑execution engine that can talk natively to exchange gateways (Nasdaq OUCH, NYSE Pillar) or via broker APIs (Alpaca, Binance). It also includes a simulated “paper‑trading” mode.
  • Infrastructure – a daemon process that runs the data‑pipeline, an event bus (Postcard‑serialised TCP) that connects the daemon to the TUI, and persistence layers using PostgreSQL and Redis.
  • Research‑grade components – a 1,400‑line LaTeX research paper, 294 unit tests for the exchange adapters, and a 100 k‑agent parallel market‑microstructure simulator.

All of this is packaged as a single binary (or a set of crates) that can be built with cargo run -p tui --release for the UI or cargo run -p daemon --release for the back‑end.

Why It Might Matter

  • Performance‑first – written entirely in Rust, it aims for nanosecond‑precision timestamps and sub‑millisecond end‑to‑end latency, which is essential for high‑frequency or algorithmic trading research.
  • Open‑source research platform – the repo includes a detailed architecture diagram, a research paper, and many benchmark tests, making it a useful reference for anyone building low‑latency trading systems.
  • AI‑augmented decision support – integrating Claude lets users experiment with large‑language‑model‑driven market commentary without leaving the terminal.
  • Modular design – 38 crates separate concerns (feeds, execution, risk, AI, persistence), so developers can replace or extend individual pieces (e.g., plug in a different ML model).

Core Components (as described in the README)

Component Role Notable Tech
Daemon Orchestrates data ingestion, AI analysis, risk checks, and execution. Tokio, Rayon, Postcard TCP bus
TUI Dashboard Interactive terminal UI with six screens (order‑book, charts, risk, AI notes, etc.). Ratatui
Exchange Core Wire‑level parsers for ITCH, OUCH, XDP, Pillar, plus exact‑fixed‑point price handling. Pure Rust, no vendor SDK
AI Engine Calls Anthropic Claude, routes signals to the strategy dispatcher. ai crate, Claude API wrapper
Quant Library Indicators, micro‑structure metrics, pricing models (Black‑Scholes, Heston). signals crate, 2026 Quant Alpha Library
Execution Engine Implements TWAP, VWAP, Iceberg, POV, and Almgren‑Chriss optimal execution. execution crate
Risk Gate GARCH volatility, VaR, kill‑switch, regime detection, toxicity gating. risk crate
Knowledge Graph RAG‑style graph of market concepts for AI reasoning. knowledge_graph (petgraph)
Persistence Stores events and state for replay and analytics. PostgreSQL, Redis
Simulator 100 k‑agent parallel market‑microstructure simulation. Rayon
Compliance Pre‑trade checks for SEBI 2026 Algo‑ID, OPS thresholds, audit trail. compliance crate

Getting Started (from the README)

  1. Run the UI locally
    cargo run -p tui --release
  2. Start the back‑end daemon (mock data for quick start)
    USE_MOCK=1 cargo run -p daemon --release
  3. Live crypto feed (no API key needed)
    USE_MOCK=0 SYMBOLS_CRYPTO=BTCUSDT,ETHUSDT cargo run -p daemon --release
    This connects to Binance’s public WebSocket and streams real‑time candlesticks through the full pipeline.
  4. Explore the demo video – a short GIF is linked in the README.
  5. Read the docs – docs/DIRECT_EXCHANGE_CONNECTIVITY.md, docs/latency.md, and the research paper (rustfinance.pdf).

Who Might Use It

  • Quant researchers looking for a Rust‑based sandbox that includes both market‑data plumbing and a library of micro‑structure indicators.
  • Developers interested in low‑latency trading infrastructure who want a reference implementation of exchange binary protocols.
  • AI/ML enthusiasts who want to experiment with LLM‑driven market commentary integrated into a live trading UI.
  • Educators who need a concrete, open‑source example of a full‑stack trading system for teaching systems programming or finance.

Caveats (as stated by the authors)

  • The project is research software, not a broker or a guaranteed production‑ready trading system.
  • Users should paper‑trade and perform independent code reviews before risking real capital.
  • Some components (e.g., direct exchange connectivity) require co‑location or privileged network access to function on live venues.

Bottom line: RustFinance is a comprehensive, Rust‑centric, AI‑enhanced trading terminal that brings together market‑data ingestion, quantitative analysis, risk management, and execution in a single open‑source codebase. It is squarely within the realm of frontier finance/AI tooling, making it a valid subject for a non‑expert but curious audience.

Related

  • Project
    rustfs/rustfs

    RustFS is an Apache‑2.0‑licensed, Rust‑based distributed object storage system with S3/Swift compatibility, targeting AI data‑lake and edge workloads. It offers high performance, bit‑rot protection, single‑node and (beta) distributed modes, Helm charts, Docker images, and built‑in observability.

  • Project
    NoFxAiOS/nofx

    NOFX is an open‑source, self‑hosted trading terminal that lets large language models generate crypto‑perpetual trades. A Go runtime enforces strict risk limits, stores every model‑generated reasoning, and supports nine exchanges. Users fund an on‑chain AI fee wallet, start “Autopilot” to let the model trade automatically, and can compare multiple traders on a public leaderboard. Installation is available via a one‑click script, Docker, Railway, or manual build.

  • Project
    lc2panda/alphastream

    Alphastream is an AI‑driven financial analysis web app. It uses DeepSeek/any OpenAI‑compatible LLM with LangGraph to run 14 specialized agents (technical, fundamental, sentiment, risk, etc.) plus four investor‑persona agents. Real‑time market data comes from dual adapters (AKShare & BaoStock) covering Chinese, US, Hong‑Kong, crypto and macro sources. The Next.js + React front‑end shows a dark glass‑morphism UI with chat, dashboards and chart cards, while the Flask backend streams agent progress via SSE. All services can be launched with a single Docker‑Compose command.

  • Project
    Darkatse/TauriTavern

    TauriTavern is a cross‑platform native client (Windows, macOS, Linux, Android, iOS) that wraps the SillyTavern AI‑chat UI inside a Rust‑based Tauri application. It replaces the original Node.js backend with Rust, offering one‑click installation, local‑only data storage, LAN/cloud sync, a built‑in extension manager, and an evolving AI‑agent framework. Distributed under AGPL‑3.0, it can be installed via package managers or direct downloads, and the source follows a clean‑architecture Cargo workspace.

  • Project
    rtk-ai/rtk

    rtk (Rust Token Killer) is a Rust‑written CLI proxy that intercepts common development commands (git, test runners, linters, Docker, AWS, etc.) and rewrites their output into a compact form before an LLM‑based coding assistant reads it. By filtering, grouping, truncating, and deduplicating output, it can reduce the amount of shell output the model sees by up to 90 %, lowering input token usage. Install via Homebrew or a curl script, then run `rtk init -g` (or a tool‑specific variant) to install an auto‑rewrite hook for agents like Claude Code, Copilot, Gemini, Cursor, and many others. The tool provides analytics (`rtk gain`) to track saved tokens, supports Windows (native binary hook), and offers optional telemetry. It’s aimed at developers who use AI pair‑programmers and want to keep token costs predictable.