ricequant/rqalpha
Rqalpha
RQAlpha is a Python-native quantitative trading backtesting framework and live trading execution system. It provides an event-driven engine for simulating trading strategies against historical market data, with realistic transaction costs, slippage models, and corporate action handling. The platform supports multi-asset class trading including stocks, futures, options, and REITs, with separate sub-accounts for different asset types and configurable margin requirements.
The framework distinguishes itself through a plugin-based extensible architecture that allows users to swap out core components like data sources, order matching models, and risk controls through modular mods and plugins. It includes a broker-integrated live trading execution system that routes strategy signals to real markets for order placement and trade management during market hours. The platform also offers persistent state serialization for pause-and-resume across sessions, a risk validation pipeline for pre-trade checks, and the ability to schedule recurring tasks programmatically.
Beyond backtesting and live trading, RQAlpha provides comprehensive performance analytics including alpha, beta, Sharpe ratio, and drawdown calculations, with exportable reports and equity curve visualizations. The system supports multiple time frames from daily to tick-level data, algorithmic order types like TWAP and VWAP, and can be driven from custom data sources. Users can run strategies from Python code, CLI commands, or packaged mods distributed via PyPI.
Features
- Live Trading Execution - A broker-integrated system that routes strategy signals to real markets for order placement and trade management during market hours.
- Trading Strategy Backtesters - An event-driven engine for simulating trading strategies against historical market data with realistic transaction costs and performance analytics.
- Trading Strategy Lifecycles - Defines strategies by implementing lifecycle callback functions for initialization, bars, and trading days.
- Backtesting Simulations - Simulates trading by processing market data events through a central event bus that dispatches orders, fills, and corporate actions.
- Financial Market Data - Retrieves historical and real-time data for stocks, futures, funds, and other instruments through a local API.
- Market Data APIs - Retrieves historical price bars, current snapshots, instrument details, and trading calendars through built-in data APIs.
- Market Data Sources - Connects to external data providers or local bundles to supply market and instrument data.
- Trading Broker APIs - Connects to live brokerage APIs for real order execution and account management.
- Position Managers - Queries and manages current holdings, including shares, cost basis, and available cash for each instrument.
- Historical Data Analysis - Retrieves historical bar and tick data for any instrument to inform trading decisions.
- Stock Trade Executions - Executes stock buy/sell operations and position management within backtesting and live trading simulations.
- Real-Time Market Prices - Retrieves the latest bid, ask, last price, and daily price limits for any instrument.
- Quantitative Performance Metrics - Computes returns, risk, and other indicators like alpha, beta, and Sharpe ratio from backtest results.
- Strategy Performance Analyzers - Records daily orders, trades, and portfolio states to compute risk-adjusted performance indicators.
- Multi-Asset Class Simulations - Simulates stock and futures trading with dedicated APIs for realistic multi-asset strategy backtesting.
- Financial Bar Data Retrieval - Retrieves past open, high, low, close, and volume data for any instrument at daily or minute frequency.
- Market Data Access APIs - Retrieves historical and real-time market data for Chinese equities, futures, funds, and more via a local API.
- Market Data Providers - Provides daily, minute, dividend, futures, and tick data through a replaceable data source interface.
- Trading Strategy Development Environments - A Python-native environment for writing, testing, and running algorithmic trading strategies with a unified API and CLI interface.
- Strategy Execution Interfaces - Executes strategies by passing Python files, code strings, or functions directly to the engine.
- Multi-Asset Sub-Accounts - Sets up separate sub-accounts for different asset classes with individual starting capital.
- Financial Performance Metrics - Computes alpha, beta, Sharpe ratio, and drawdown for trading strategy evaluation.
- Stock Order Placements - Provides a stock-specific order placement API supporting shares, lots, value, and percentage-based sizing.
- Unified Order Placements - Ships a unified API for programmatically placing orders across stocks, futures, and other instruments.
- Configurable Fee Models - Sets commission, tax, and slippage models to simulate realistic trading expenses.
- Extensible Plugin Architectures - A modular framework that allows custom data sources, risk controls, order matching, and event hooks through installable mods and plugins.
- Plugin Extenders - Adds or modifies features by loading modular plugins that integrate with the core framework.
- Pre-Trade Risk Validators - Validates orders against pre-trade rules such as position limits, cash sufficiency, and price bounds.
- Custom Strategy Loaders - Loads strategy code from any source and injects it with the full API environment for execution.
- Multi-Frequency Data Support - Supports running strategies on daily, minute, or tick-level data with appropriate matching logic.
- Portfolio Rebalancers - Calculates and executes a set of orders to rebalance a portfolio to a specified target allocation.
- Futures Trade Executions - Executes futures trades with margin handling and contract management in backtesting and live simulations.
- Futures Order Placements - Provides a dedicated API for placing futures orders with long/short semantics in backtesting and live trading.
- Margin Trading Managers - Supports margin trading for stocks and ETFs, including financing rates and forced liquidation for futures.
- Configurable Order Matching Models - Matches simulated orders using selectable price anchoring methods and configurable slippage models.
- Trading Order Monitors - Cancels pending orders and retrieves the list of currently unexecuted orders.
- Order Validation Rules - Checks order submission and cancellation requests against custom risk rules before they reach the broker.
- Position Limits - Enforces checks on order size, cash availability, and position concentration before execution.
- Trading Simulations - Executes a strategy in a simulated real-time environment to test its behavior before deploying real capital.
- Real-Time - Runs a strategy against a live or simulated market feed to test execution logic without risking capital.
- Real-Time Simulated Trading - Connects to a simulated market environment to test strategies in real-time without risking actual capital.
- Equity Curve Plotters - Plots the equity curve of a backtest to visualize strategy performance over time.
- Full State Serialization - Saves and restores full trading state to support incremental backtesting and live trading recovery.
- Result Serialization - Serializes the full backtest outcome into a pickle file containing portfolios, positions, trades, and summary metrics.
- Margin - Handles deposits, withdrawals, and margin requirements for different account types.
- Pluggable Market - Supplies historical and real-time market data through a replaceable data source abstraction connecting to local bundles or external providers.
- Strategy State Persistence - Saves and restores the full strategy state so execution can be paused and resumed across sessions.
- Market Snapshots - Fetches the latest bid, ask, and last price for an instrument during live or simulated trading.
- Historical Data Downloads - Downloads free daily-level stock, index, ETF, and futures data from RiceQuant for backtesting, stored as a local bundle.
- Market Data - Downloads free A-share daily market data via a single command to prepare for backtesting.
- Data Bundle Updates - Updates the local backtesting data bundle with the latest daily market data after each trading day.
- Financial Trade Cost Calculators - Computes commissions and taxes for any trade based on market and instrument-specific rules.
- Financial Transaction Cost Calculators - Calculates commissions, stamp duties, and slippage based on configurable fee models for each asset type.
- Plugin Management Interfaces - Enables or disables installed mods through CLI commands to control which extensions are active during a run.
- API Registration Hooks - Registers custom functions as new API endpoints during a mod's startup, enabling third-party formula languages or user-defined tools.
- Mod Toggles - Activates or deactivates installed third-party mods through simple CLI commands without code changes.
- Futures Trading Engines - Implements futures-specific margin, settlement, and forced liquidation logic for backtesting and live trading.
- Automatic Position Adjustments - Automatically adjusts positions and prices for dividends, splits, and other corporate events during simulation.
- Algorithmic Order Executions - Supports TWAP and VWAP algorithmic order types for executing trades in backtesting and live trading.
- Algorithmic Order Types - Supports market, limit, VWAP, and TWAP order types for stocks and futures through a single API.
- Framework Event Subscriptions - Registers custom callback functions to react to framework events like order fills or trade completions.
- Multi-Asset Trading Instruments - Extends trading and data handling capabilities to include options, REITs, and other instrument types.
- Multi-Market Instrument Handlers - Supports trading instruments from multiple markets like China A-shares and Hong Kong stocks in one strategy.
- Strategy Benchmarkers - Visualizes strategy net asset value alongside a benchmark index for comparison.
- Plugin-Based Architectures - Extends core functionality by loading modular plugins that can override data sources, accounts, order matching, and register new API endpoints.
- Strategy Performance Reports - Outputs strategy analysis results as CSV files and plots for offline review and sharing.
- Cash Management - Simulates deposits and withdrawals of cash into or out of the portfolio at specified times.
- Trading Strategy Reports - Produces detailed Excel and CSV reports containing performance summaries, equity curves, and risk metrics.
- Algorithmic Trading Engines - Extendable Python framework for backtesting and trading.
- Backtesting Engines - Open-source Python backtesting engine.
- Trading and Backtesting - Extendable algorithmic backtest and trading framework.
- Trading Frameworks - Extendable framework for backtesting and trading multiple securities.
- Trading Platforms - Extensible Python-based algorithmic trading and backtesting platform.
Star history
How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.
