Nautilus Trader - How-To Recipes
The How-To section of NautilusTrader’s docs collects goal-oriented recipes - short guides that assume you already know the core concepts and just want to accomplish a specific outcome. As of 2026-05-06 the index lists 7 recipes split across two implicit groupings: Data & Setup (loading data, catalogs, configuring the live node) and Rust Development (writing actors/strategies, running backtests, and running live trading from Rust). Two of the seven Data & Setup pages are linked from the index but currently return 404 - they’re listed below for completeness so we know what’s promised even when not yet published.
Data & Setup
Recipe: Loading External Data
Goal: Bring third-party / vendor data files (CSV, Parquet, Databento DBN, etc.)
into a Nautilus ParquetDataCatalog so it can be replayed in backtests or fed into
a live engine.
Summary: Index page promises a recipe for converting external data formats into
Nautilus-native types (QuoteTick, TradeTick, Bar, custom data) and writing
them to the catalog with the correct partition layout. Target page currently
returns HTTP 404, so summary is inferred from the index title only.
Useful for Cortana MK3 because: Direct fit - we have IBKR ticks, UW flow
snapshots, and our own scoring_events to land into a unified catalog before any
Nautilus backtest is meaningful.
URL: https://nautilustrader.io/docs/latest/how_to/loading_external_data
(404 as of 2026-05-06)
Recipe: Data Catalog with Databento
Goal: Build and curate a Nautilus ParquetDataCatalog populated from Databento
historical feeds (MBP-1, MBP-10, OHLCV, etc.).
Summary: Index page promises a Databento-specific recipe - likely walks through
schema selection, instrument mapping, and chunked download into the Parquet
catalog. Target page currently returns HTTP 404, so summary is inferred from the
index title only.
Useful for Cortana MK3 because: Not directly applicable - we’re not on
Databento today. Conceptually relevant if we ever consolidate historical SPY/SPX
options data through a third-party rather than IBKR Flex queries.
URL: https://nautilustrader.io/docs/latest/how_to/data_catalog_databento
(404 as of 2026-05-06)
Recipe: Configure a Live Trading Node
Goal: Stand up a TradingNode that connects to one or more venues for live
data and live execution, with sane operational defaults.
Summary: Walks through wiring a TradingNodeConfig - cache, message bus,
execution engine - and registering data + execution clients per venue. Covers
operational concerns that bite long-running deploys: reconciliation strategy to
align internal state with broker truth, memory management for multi-day sessions,
and platform-specific signal handling (notably Windows) for graceful shutdown.
Useful for Cortana MK3 because: Direct fit - this is the entry point for any
live IBKR-backed Nautilus deploy. The reconciliation discussion maps onto our
broker-truth-first invariant (GH #46) and the long-running-session memory advice
maps onto our launchd watchdog.
URL: https://nautilustrader.io/docs/latest/how_to/configure_live_trading
Rust Development
Recipe: Write an Actor (Rust)
Goal: Build a Rust actor that consumes market data without managing orders -
the “listen and react” building block (e.g., a spread monitor, regime detector,
or feature publisher).
Summary: Defines a SpreadMonitor struct that embeds DataActorCore and
implements the DataActor trait, overriding handler methods like on_quote. The
same actor can be registered with either a BacktestEngine or a LiveNode, so
the data-handling code is identical between backtest and live.
Useful for Cortana MK3 because: Direct fit - our V1/V2 scoring engines are
conceptually actors (data-in, score-out, no orders). This is the right
shape if we ever port them to Rust for latency.
URL: https://nautilustrader.io/docs/latest/how_to/write_rust_actor
Recipe: Write a Strategy (Rust)
Goal: Build a Rust trading strategy that consumes data AND submits / modifies
orders, extending Nautilus’s StrategyCore.
Summary: Defines a struct around StrategyCore, implements DataActor for
data subscriptions, and uses the nautilus_strategy! macro to generate the rest
of the trait surface. Order management is done through provided methods like
submit_order and modify_order against the engine’s execution path.
Useful for Cortana MK3 because: Direct fit - our entry/exit/PM logic would
become a strategy here. Macro-generated boilerplate is attractive given how much
of our current Python is glue.
URL: https://nautilustrader.io/docs/latest/how_to/write_rust_strategy
Recipe: Run a Backtest (Rust)
Goal: Run a deterministic backtest in Rust over historical data, with two
levels of control depending on dataset size.
Summary: Two paths are shown side-by-side: a low-level BacktestEngine that
gives you direct control over engine setup, venues, instruments, and strategies
(good for small datasets and tight assertions), and a high-level BacktestNode
that streams data from a ParquetDataCatalog in configurable chunks (required
for datasets that don’t fit in memory). The page covers Cargo dependencies and
provides complete runnable examples for both.
Useful for Cortana MK3 because: Direct fit - we need both. Unit-style
assertions on a single trading day fit BacktestEngine; multi-month walk-forward
needs the streaming BacktestNode so we don’t blow RAM.
URL: https://nautilustrader.io/docs/latest/how_to/run_rust_backtest
Recipe: Run Live Trading (Rust)
Goal: Spin up a LiveNode in Rust that connects to a venue and runs a
strategy until interrupted.
Summary: Uses a builder pattern on LiveNode to register venue adapters
(example uses OKX data + execution clients), attaches a strategy (the example is
a market-maker), and runs the async node until SIGINT. Same general shape as the
TradingNode recipe but Rust-native and strategy-attached out of the gate.
Useful for Cortana MK3 because: Direct fit when we’re ready to leave Python -
this is the runtime entry point for a Rust port of the engine. OKX adapter is
not us; we’d swap in IBKR.
URL: https://nautilustrader.io/docs/latest/how_to/run_rust_live_trading
Top 5 recipes most relevant for Cortana MK3
If we migrated to Nautilus, the order we’d consume these in:
- Loading External Data - nothing else matters until SPY/SPX ticks, UW flow,
and our scoring_events are in a
ParquetDataCatalog. This is the first dependency for every other recipe. - Run a Backtest (Rust) - we won’t ship a single Rust strategy without reproducing one of our existing PnL curves in a Nautilus backtest first. Backtest parity is the gating signal for migration.
- Write a Strategy (Rust) - the migration target for our entry/exit/PM surface. Macro-generated trait code reduces what we’d have to author by hand.
- Configure a Live Trading Node - covers reconciliation, memory, and signal handling, which are the three operational surfaces that have bitten us in MK2 (GH #46 broker-truth-first, watchdog plist, kill-while-open).
- Write an Actor (Rust) - the right home for V2 scoring once it stabilizes; actors are the “no-orders, just signals” shape that V2 already has.
The two Databento / external-data 404s drop out of the top 5 either because the pages don’t exist yet (Loading External Data is covered by the index title alone) or because we’re not on Databento (Data Catalog with Databento).
See also
- nautilus-concepts.md
- nautilus-tutorials.md