Rust

Nautilus has a complete Rust implementation under the crates/ directory. You can write actors, strategies, run backtests, and trade live without Python. The domain model is shared across all paths, and the v2 PyO3 path runs Python strategies on the Rust engine directly.

System implementations

Nautilus has three implementations. Understanding where each stands helps you choose the right one for your use case.

• v1 legacy: Cython/Python classes under nautilus_trader/. The original implementation, fully featured but gradually being replaced.
• v2 Rust: Pure Rust under crates/. Runs without Python.
• v2 PyO3: Python strategies running on the Rust core via PyO3 bindings. Combines Python convenience with Rust engine performance.

Capability matrix

Adapters

Choosing a path

• v1 legacy is the most complete today. Use it if you need the Controller, tearsheets, Interactive Brokers, or config serialization.
• v2 Rust gives native performance without a Python runtime. All core trading functionality is available. Use it for latency-sensitive deployments or teams that prefer a compiled language.
• v2 PyO3 is the recommended path going forward. Python strategies run on the Rust core engine, getting Rust performance for data processing and execution while keeping the Python strategy authoring experience.

Project setup

The Nautilus crates are published to crates.io. Add them to your Cargo.toml:

[dependencies]
nautilus-backtest = "0.54"
nautilus-common = "0.54"
nautilus-execution = "0.54"
nautilus-model = { version = "0.54", features = ["stubs"] }
nautilus-trading = { version = "0.54", features = ["examples"] }

anyhow = "1"
log = "0.4"

For live trading, add the live crate and the adapter for your venue:

[dependencies]
nautilus-live = "0.54"
nautilus-okx = "0.54"

To track the latest development branch, point all Nautilus dependencies at the same git source to avoid type mismatches between crates.io and git versions:

[dependencies]
nautilus-backtest = { git = "https://github.com/nautechsystems/nautilus_trader.git", branch = "develop" }
nautilus-common = { git = "https://github.com/nautechsystems/nautilus_trader.git", branch = "develop" }
nautilus-execution = { git = "https://github.com/nautechsystems/nautilus_trader.git", branch = "develop" }
nautilus-model = { git = "https://github.com/nautechsystems/nautilus_trader.git", branch = "develop", features = ["stubs"] }
nautilus-trading = { git = "https://github.com/nautechsystems/nautilus_trader.git", branch = "develop", features = ["examples"] }

The minimum supported Rust version (MSRV) is 1.94.0.

Feature flags

Actors

An actor receives market data, custom data/signals, and system events but does not manage orders. Implement the DataActor trait and bind your struct to DataActorCore via Deref/DerefMut. Your struct must also implement Debug (required by the blanket Component impl). The core provides subscription methods, cache access, and clock access directly on your struct.

Handler methods

Override any handler on the DataActor trait to receive the corresponding data or event. All handlers have default no-op implementations, so you only override what you need.

For a step-by-step walkthrough, see the Write an Actor (Rust) how-to guide. For a complete example, see BookImbalanceActor.

Strategies

A strategy extends an actor with order management. Implement both DataActor (for data handling) and Strategy (for access to StrategyCore). The StrategyCore wraps DataActorCore and adds an OrderFactory, OrderManager, and portfolio integration.

Order management

The Strategy trait provides order methods through StrategyCore:

The OrderFactory (accessed via self.core.order_factory()) builds order objects: market, limit, stop_market, stop_limit, market_if_touched, limit_if_touched, and trailing_stop_market.

For a step-by-step walkthrough, see the Write a Strategy (Rust) how-to guide. For complete examples, see EmaCross and GridMarketMaker.

Backtesting

For annotated walkthroughs of both APIs, see the Run a Backtest (Rust) how-to guide.

BacktestEngine (low-level API)

Construct the engine, add venues and instruments, load data, register strategies, and run. See the full working example:

cargo run -p nautilus-backtest --features examples --example engine-ema-cross

Source: crates/backtest/examples/engine_ema_cross.rs

BacktestNode (high-level API)

Loads data from a ParquetDataCatalog and supports streaming in configurable chunk sizes. Requires the streaming feature on nautilus-backtest. See the full working example:

cargo run -p nautilus-backtest --features examples,streaming --example node-ema-cross

Source: crates/backtest/examples/node_ema_cross.rs

Live trading

For an annotated walkthrough, see the Run Live Trading (Rust) how-to guide.

The LiveNode connects to real venues through adapter clients. The builder pattern configures data and execution clients, then run() starts the async event loop. Each adapter provides its own factory and config types.

Most adapters include node_data_tester.rs and node_exec_tester.rs examples. These test data requests, streaming, and order execution against live venues.

Related guides

• Write an Actor (Rust) - Step-by-step actor walkthrough.
• Write a Strategy (Rust) - Step-by-step strategy walkthrough.
• Run a Backtest (Rust) - BacktestEngine and BacktestNode usage.
• Run Live Trading (Rust) - LiveNode setup and venue connection.
• Architecture - System design and data/execution flow.
• Actors - Actor concepts (applies to both Python and Rust).
• Strategies - Strategy concepts and handler reference.
• Events - Event types and handler dispatch.
• Backtesting - Backtest concepts and matching engine behavior.