NautilusTrader

NautilusTrader is an open-source, production-grade trading engine written in Rust with Python bindings. It targets quantitative traders and small teams who want one codebase for research, deterministic backtesting, and live execution across crypto, FX, equities, futures, options, and sports betting markets. The Rust core handles performance and safety while Python acts as the control plane for strategy logic and orchestration, so the same strategy code runs unchanged from backtest to production.

The architecture is event-driven end to end, avoiding the common split between vectorized research code and a separately built production system. Any venue with a REST API or WebSocket feed can be connected through a modular adapter that normalizes the raw API into a unified domain model. Integrations already cover major crypto CEX and DEX venues, traditional brokers, data providers, and betting exchanges.

Key features

• Fast: Rust core using the mimalloc allocator and tokio for asynchronous networking.
• Reliable: Type- and thread-safety enforced by Rust, with optional Redis-backed state persistence.
• Portable: Runs on Linux, macOS, and Windows, and can be deployed with Docker.
• Flexible: Modular adapters connect any REST or WebSocket API to a normalized domain model.
• Advanced order handling: Time-in-force options (IOC, FOK, GTC, GTD, DAY, AT_THE_OPEN, AT_THE_CLOSE), post-only, reduce-only, iceberg orders, and contingency orders (OCO, OUO, OTO).
• Customizable: Build custom components or assemble entire systems from the cache and message bus primitives.
• Backtesting: Simulate multiple venues, instruments, and strategies at once using quote tick, trade tick, bar, order book, or custom data at nanosecond resolution.
• Research-to-live parity: Identical strategy implementations run in backtest and live deployment, with no reimplementation step.
• Multi-venue: Run market-making or cross-venue strategies across several venues at the same time.
• AI training: The engine is fast enough to train reinforcement learning or evolutionary strategy agents.

Ideal use cases

This fits individual quants or small teams building systematic strategies across crypto, FX, equities, futures, options, or betting markets who need nanosecond-resolution backtests that translate directly into live trading without rewriting logic. It also suits teams that want to write performance-critical components entirely in Rust while keeping strategy configuration and orchestration in Python. Training RL or ES trading agents against a fast, deterministic simulator is another good match.

It is not built for people who want a hosted UI dashboard, point-and-click strategy builder, or distributed multi-node orchestration out of the box; the open-source project explicitly scopes those out to stay focused on the core single-node engine. If you need built-in AI/ML tooling beyond a fast simulation environment, or a no-code trading platform, look elsewhere. Because the license is LGPL-3.0, teams with strict license compliance requirements for linked code should review the terms before embedding it in a closed product.

Installation

Prebuilt wheels are published on PyPI, so no Rust toolchain is required for a standard install:

pip install nautilus_trader

Supported platforms are Linux (x86_64 and ARM64), macOS (ARM64), and Windows (x86_64), with Python 3.12 through 3.14. Nightly and develop branch builds are also published for those who want the latest changes:

pip install -U nautilus_trader --pre --index-url https://packages.nautechsystems.io/simple/

For development or working with the Rust core directly, clone the repository and build with Cargo, which requires the Rust toolchain matching the MSRV shown in the project's compatibility table (generally the latest stable Rust release):

git clone https://github.com/nautechsystems/nautilus_trader
cd nautilus_trader

Check the docs site and the v2 migration guide in the repository before upgrading from a v1 install, since Python bindings target the Rust-native v2 runtime and v1 only receives critical security backports on a separate branch.