Run research strategies in live trading with a single engine
You can execute Python strategy logic identically in backtesting and live trading environments. Because the same code runs in both simulation and live systems without separate implementations, you can reduce discrepancies that arise during deployment. This repository is an open-source engine for multi-asset, multi-exchange trading systems.
v2 transition and current status
The project is currently in the v2 release candidate stage, with an API that differs from v1. v2 is available on PyPI as 2.0.0rcN for community testing, and the --pre flag is required until the final 2.0.0 release. v1 receives only security patches on the develop_v1 branch, and a separate migration guide to v2 is provided. While the API is stabilizing during this period, breaking changes may occur between releases, so caution is required.
Rust core and Python control plane
The engine core is written in Rust to maintain a deterministic event-driven architecture. Python serves as the control plane for strategy logic, configuration, and orchestration, connecting to the Rust runtime via PyO3 bindings. This structure preserves the performance and safety of a compiled language while retaining Python's flexibility. If critical tasks require it, you can write the entire strategy in Rust. The same strategy code runs identically in backtesting and live systems, reducing reimplementation costs.
Supported assets and exchange connections
You can integrate any exchange that provides a REST API or WebSocket feed as a modular adapter, regardless of asset class. The current support range is broad, covering crypto (CEX/DEX), traditional markets (forex, stocks, futures, options), and betting exchanges. Major exchanges and data providers such as Binance, Bybit, Coinbase, and Interactive Brokers are already connected. Each integration processes raw APIs by converting them into a unified interface and normalized domain model.
Precision modes and installation requirements
Core values such as price, quantity, and amount support a high-precision mode with 128-bit (up to 16 decimal places) and a standard precision mode with 64-bit (up to 9 decimal places). Official Python wheels are provided in high-precision mode by default, while pure Rust crates require explicitly enabling the high-precision feature flag. Installation can be done in two ways: downloading pre-built wheels from PyPI or building from source. The Rust toolchain is not required for pre-built wheel installation, but building from source requires the latest stable version of Rust and clang. Linux environments require glibc 2.35 or higher.
Pre-live trading checks
This engine is an open-source project focused on single-node backtesting and live trading. UI dashboards, distributed orchestration, and built-in AI/ML tooling are not included in the scope. Since v2 is currently in the release candidate stage, it is not recommended for live trading involving real funds. For production use, you should use the latest release version from the master branch, and development wheels or release candidates should be used only for testing purposes. Additionally, be aware that live execution may differ from backtest results due to variables such as exchange, transmission, timing, and reconciliation that simulation cannot reproduce.
