Write a Strategy (Rust)

A strategy extends an actor with order management. This guide walks through building a minimal strategy that subscribes to quotes and submits market orders. Read Write an Actor (Rust) first.

For background on strategy concepts and order management, see the Strategies and Rust concept guides.

Define the struct

A strategy stores a StrategyCore field for runtime wiring. Normal strategy logic does not use the field directly; use the facade methods on self.

use nautilus_common::actor::DataActor;
use nautilus_model::{
    data::QuoteTick,
    enums::OrderSide,
    identifiers::{InstrumentId, StrategyId},
    types::Quantity,
};
use nautilus_trading::{nautilus_strategy, strategy::{Strategy, StrategyConfig, StrategyCore}};

pub struct MyStrategy {
    core: StrategyCore,
    instrument_id: InstrumentId,
    trade_size: Quantity,
}

Implement the constructor

StrategyConfig takes a strategy_id and an order_id_tag. The tag is appended to all client order IDs from this strategy, preventing collisions when multiple strategies trade the same instrument.

impl MyStrategy {
    pub fn new(instrument_id: InstrumentId) -> Self {
        let config = StrategyConfig {
            strategy_id: Some(StrategyId::from("MY_STRAT-001")),
            order_id_tag: Some("001".to_string()),
            ..Default::default()
        };
        Self {
            core: StrategyCore::new(config),
            instrument_id,
            trade_size: Quantity::from("1.0"),
        }
    }
}

Wire up the core and implement Debug

The nautilus_strategy! macro generates the native runtime wiring used by registration and the Strategy trait impl. By default it delegates to a field named core; pass a second argument for a different field name. The macro does not make your strategy or its StrategyCore deref to runtime internals. It also adds config(), which returns the StrategyConfig passed to StrategyCore::new.

Runtime registration uses blanket Actor and Component implementations that require native wiring and Debug. The macro supplies the native wiring; implement Debug manually or derive it.

nautilus_strategy!(MyStrategy);

impl std::fmt::Debug for MyStrategy {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("MyStrategy").finish()
    }
}

Implement the DataActor trait

Data handling works the same as in an actor. Subscribe in on_start, respond in handlers.

impl DataActor for MyStrategy {
    fn on_start(&mut self) -> anyhow::Result<()> {
        self.subscribe_quotes(self.instrument_id, None, None);
        Ok(())
    }

    fn on_quote(&mut self, quote: &QuoteTick) -> anyhow::Result<()> {
        let order = self.order().market(
            self.instrument_id,
            OrderSide::Buy,
            self.trade_size,
            None, None, None, None, None, None, None,
        );
        self.submit_order(order, None, None, None)?;
        Ok(())
    }
}

self.order() builds orders and order lists. Available methods:

• market
• limit
• stop_market
• stop_limit
• market_to_limit
• market_if_touched
• limit_if_touched
• trailing_stop_market
• trailing_stop_limit
• bracket
• create_list
• generate_client_order_id
• generate_order_list_id

submit_order is available on self through the Strategy trait impl generated by the macro.

Native runtime access

Use the public facade in strategy logic:

• clock()
• cache()
• order()
• portfolio()
• strategy_id()
• The order management methods on Strategy

Normal strategy code does not import DataActorNative or StrategyNative, and does not call native handles such as:

• core()
• core_mut()
• strategy_core()
• strategy_core_mut()
• order_factory()
• order_factory_rc()
• portfolio_rc()

Those native handles expose borrowed runtime state and stay in engine, runtime, registration, PyO3, testkit, plug-in host, or explicit latency-sensitive native code. The Rust native traits section covers the native-traits applicability matrix and these method tables:

• DataActorNative methods
• StrategyNative methods

Override Strategy hooks

To override Strategy trait methods such as order or position event handlers, pass them in a block. The macro generates the internal plumbing automatically; keep DataActor handlers in the separate impl DataActor block.

nautilus_strategy!(MyStrategy, {
    fn on_order_rejected(&mut self, event: OrderRejected) {
        log::warn!("Order rejected: {}", event.reason);
    }
});

Order management methods

The Strategy trait provides these facade methods:

Full examples

• EmaCross: Dual-EMA crossover with indicator integration.
• GridMarketMaker: Grid market making with configurable levels and requoting.