BTQuant: High-Frequency Trading Meets Simplicity

BTQuant is a high-frequency algorithmic trading framework that processes thousands of trades per second across multiple exchanges with zero API rate limits. It combines Python's flexibility with C++'s performance, featuring real-time market manipulation detection, ultra-low latency shared memory data pipelines, and institutional-grade backtesting capabilities.

🚀 Key Features

Real-Time Manipulation Detection: 5 advanced C++ detectors running in parallel (stop hunts, spoofing, whale frontruns, liquidity imbalances, spread arbitrage)
Ultra-Low Latency: HotSpine shared memory for sub-microsecond trade processing across exchanges
Zero API Rate Limits: Direct WebSocket feeds from Binance, OKX, Bybit, Coinbase, Kraken
Multi-Exchange Processing: Simultaneous data from 5+ exchanges with cross-exchange correlation
Complete Transparency: Every indicator calculation step visible and auditable into its bare bone
Enterprise Data Management: M$SQL Server canonical storage with full audit trails
Live Trading Ready: Production-grade execution with monitoring, alerting, and recovery
QuantStats Integration: Professional performance analytics and reporting

🚀 Quick Start

Prerequisites

Python 3.12+ and C++17
Linux (Ubuntu 20.04+, Arch, or equivalent)
8GB RAM minimum (16GB recommended)
GCC 7+ or Clang 5+ (GCC14 recommended)

Installation

# Clone repository with submodules
git clone --recurse-submodules https://github.com/ItsXactlY/BTQuant.git
cd BTQuant

# Run automated installer
# Comes with:
# - BTQuant python setup
# - CCAPI C++ Setup
# - CCAPI C++ Modules (market data collector, manipulation dectector, ...)
# - Handling Setup of Shared Memory at /dev/shm/BTQ... 
# - Cython* readyness (Work in Progress - hidden branch)
# - M$SQL - C++ Adapter Compiling for Python/Cython
#         - Drops Random generated password after Database Setup ready for dontcommit.py
#         - Pretuned to handle big data on lowest possible CPU cycles
#         - While keeping maximal burst capacities.
#
# - If want to contribute to optimize few step further:
# - https://arxiv.org/pdf/2312.00647

bash Installers/install_all.sh

Your First Backtest (CCXT Example)

from backtrader import backtest
from backtrader.strategies.Vumanchu_A import VuManchCipher_A
from backtrader.utils.ccxt_data import get_crypto_data

# Get data
data = get_crypto_data('BTC/USDT', '2024-01-01', '2024-01-31', '1h', 'binance')

# Run backtest
result = backtest(
    strategy=VuManchCipher_A,
    data=data,
    init_cash=10000,
    quantstats=True,
    plot=True
)

Real-Time Market Monitoring

# Start market data collector (C++)
cd dependencies/ccapi/example/build/src/market_data_collector
./market_data_collector

# In another terminal: Start manipulation detector
cd tests/new/build
./manipulation_monitor

📚 Documentation

Getting Started

Installation Guide - Complete setup instructions
Quick Start Guide - Your first strategy and backtest
Manipulation Detection Quick Start - Real-time market monitoring

User Guides

Strategy Development - Build and customize strategies
Indicators Reference - Complete indicator library
Data Sources - All data feed options
Backtesting - Testing and optimization

Technical Reference

Architecture Overview - System design and components
Market Data Collection - CCAPI WebSocket collectors
HotSpine - Ultra-low latency shared memory
Manipulation Detectors - C++ detection algorithms
BigBrainCentral - SQL Server data storage
API Reference - Complete API documentation
Configuration - Setup and secrets

Additional Resources

Dashboard - QuantStats performance analysis
Troubleshooting - Common issues and solutions
FAQ - Frequently asked questions

🏗️ Architecture

BTQuant implements a hybrid Python/C++ architecture for maximum performance and flexibility:

Data Collection Layer (C++)

CCAPI Collectors: Native WebSocket connections to Binance, OKX, Bybit, Coinbase, Kraken
HotSpine Writer: Sub-microsecond shared memory data ingestion
Multi-Exchange Processing: Simultaneous data from 5+ exchanges with zero rate limits
BigBrainCentral: SQL Server canonical storage with full audit trails

Detection Engine Layer (C++)

5 Parallel Detectors: Stop hunt, liquidity imbalance, whale frontrun, spread arbitrage, spoofing
HotSpine Reader: Lock-free shared memory access for ultra-low latency
Real-Time Analysis: Sub-millisecond detection across all exchanges
Plugin Architecture: Extensible detector system with dynamic configuration

Strategy Layer (Python)

BaseStrategy: Unified strategy scaffold with DCA, order management, and telemetry
Indicator Library: Complete Ehlers suite with full transparency
Strategy Catalogue: Pre-built strategies for various market conditions
HotSpine Integration: Direct access to real-time market data

Execution Layer (Python)

Live Trading: Production-ready execution with monitoring and alerting
Backtesting: High-performance historical simulation with QuantStats
Optimization: Parallel parameter optimization with Optuna
Dashboard: Web-based performance analytics and reporting

✨ Features

Real-Time Market Intelligence

5 Advanced Detectors: Stop hunt, liquidity imbalance, whale frontrun, spread arbitrage, spoofing detection
Cross-Exchange Correlation: Simultaneous analysis across Binance, OKX, Bybit, Coinbase, Kraken
Sub-Millisecond Detection: C++ algorithms processing 4,381 trades/second
Zero Rate Limits: Direct WebSocket feeds with unlimited data access

Transparency & Auditability

Complete Indicator Visibility: See exactly how every indicator calculates values
Data Pipeline Tracking: Monitor data flow from WebSocket to strategy
Calculation Auditing: Verify signal generation and risk calculations
Full Audit Trails: SQL Server storage with complete trade history

Performance & Scale

Ultra-Low Latency: Sub-microsecond trade processing with HotSpine shared memory
High Throughput: 13,970 orderbook updates/second across multiple exchanges
Enterprise Storage: SQL Server with microsecond precision timestamps
Memory Efficient: ~100MB footprint for shared memory operations

Trading Capabilities

Multi-Exchange: Spot, futures, options across 100+ venues
DeFi Integration: PancakeSwap, Web3, and DEX trading
Advanced Strategies: ML-driven, technical, and discretionary systems
Live Trading: Production-ready execution with monitoring and recovery

Development Experience

Hybrid Architecture: Python flexibility with C++ performance
Rich Ecosystem: 100+ indicators, analyzers, and utilities
Extensible Architecture: Easy to add new exchanges, indicators, and strategies
Production Ready: Monitoring, alerting, and operational tooling
QuantStats Dashboard: Professional performance analytics and reporting

🎯 Real-Time Detection

BTQuant includes a sophisticated C++ detection engine that monitors live market data for manipulation patterns:

Detection Algorithms

Stop Hunt Detector: Identifies fake wicks and stop-loss hunting across exchanges
Liquidity Imbalance Detector: Detects thin orderbooks signaling potential manipulation targets
Whale Front-Run Detector: Catches large trades before other exchanges react
Spread Arbitrage Detector: Finds profitable cross-exchange arbitrage opportunities
Spoofing Detector: Identifies fake orders designed to manipulate prices

Performance Metrics

43,814 trades processed in 10 seconds across 5 exchanges
4,381 trades/second processing rate
13,970 orderbook updates/second
Sub-millisecond detection latency
Zero API rate limits

Integration Options

Signal Output: JSON/WebSocket for trading bot integration
Alert Systems: Telegram/Discord/Slack notifications
Database Storage: SQL Server for historical analysis
Dashboard: Real-time monitoring interface

🤝 Community & Support

GitHub Issues: Report bugs and request features
Discussions: Community forum for questions and sharing
Telegram: Real-time community chat
Discord: Voice and text channels for collaboration

🤝 Contributing

We welcome contributions! Please see our GitHub repository for contribution guidelines.

Development Setup

# Fork and clone
git clone https://github.com/itsXactlY/BTQuant.git
cd BTQuant

# Set up development environment
bash Installers/install.sh --dev

# Run tests
python -m pytest

📄 License

BTQuant is licensed under the MIT License. See LICENSE for details.

🙏 Acknowledgments

Built on the excellent [Backtrader](https://

BTQuant

Install / Use

README