Deploy NautilusTrader on TradingHost
Run open-source NautilusTrader strategies from GitHub on always-on TradingHost runtimes.
NautilusTrader is a high-performance algorithmic trading platform with a Rust core, a Python control plane, and identical event-driven code paths for backtesting and live execution. TradingHost gives that engine a production runtime.
- GitHub-native deployment
- Rust core, Python control plane
- Identical backtest and live code paths
- Nanosecond-precision event timing
- Crypto, FX, equities, futures, options
- Always-on runtime
- Encrypted credentials
- Region selection
- MCP-ready
Introduction
New to NautilusTrader?
NautilusTrader is an open-source, high-performance algorithmic trading platform. It is built around an event-driven core written in Rust, with a Python control plane that lets you author strategies in idiomatic Python while the hot path runs compiled.
The defining design choice is determinism. The same strategy code runs in both backtest and live, against the same event-driven message bus, with nanosecond-precision timing. There is no separate research engine and live engine to drift apart; what you backtest is what you ship.
Coverage spans many asset classes: crypto on CEX (Binance, Bybit, Coinbase, OKX, BitMEX, Kraken, Deribit) and DEX (dYdX, Hyperliquid, Polymarket), forex and multi-asset via Interactive Brokers, sports markets via Betfair, plus data providers like Databento and Tardis. NautilusTrader is LGPL-3.0 licensed and maintained by Nautech Systems.
TradingHost is where a NautilusTrader strategy runs in production. Instead of leaving your strategy on a laptop or a generic VPS, you deploy your Nautilus repo to a TradingHost cloud runtime that stays online, manages your venue credentials as encrypted secrets, and streams logs back to you.
Section 01 · At a glance
At a glance
- What NautilusTrader is
- Open-source high-performance algorithmic trading platform, LGPL-3.0 licensed
- Maintained by
- Nautech Systems Pty Ltd (nautechsystems/nautilus_trader on GitHub)
- Architecture
- Rust core, Python control plane, Cython bindings; tokio async networking
- Languages
- Author strategies in Python; the hot path runs compiled Rust
- Determinism
- Identical event-driven code paths for backtest and live; nanosecond-precision timing
- Asset classes
- Crypto (CEX and DEX), forex, equities, futures, options, sports betting
- Data providers
- Databento, Tardis, plus venue-native feeds
- Modes
- Backtest, paper, live; same strategy class
- Deployment source
- GitHub
- TradingHost role
- Runtime, deployment, logs, secrets, region selection
- Affiliation
- TradingHost is independent and is not affiliated with Nautech Systems
- Best for
- Low-latency multi-asset strategies, identical research-and-live deployment, professional teams
Section 02 · Where Nautilus fits
How NautilusTrader fits into the trading stack
NautilusTrader is a full trading engine, not a strategy framework that sits on top of someone else’s primitives. The Rust core owns the message bus, the cache, the risk engine, and the venue adapters. Your Python code interacts with that engine through Strategy and Actor classes.
You can use Nautilus two ways on TradingHost:
Path 01
Strategy class
Subclass Strategy in Python. Receive ticks, bars, and order events from the Rust core; emit orders that the engine routes to the configured venue. Same class for backtest and live.
Path 02
Actor / message bus
For more sophisticated layouts, use Actors and the message bus directly. Multiple Actors can coordinate inside one engine while sharing market data and risk state.
Either path runs the same way on TradingHost. You bring a Nautilus GitHub repo. We run it.
- You
- Your Strategy or Actor classes own the trading logic.
- Nautilus
- Runs the event-driven core, message bus, cache, and venue adapters; same path for backtest and live.
- Venue
- Your exchange, broker, or DEX wallet receives the orders.
- TradingHost
- Runs the engine process, manages secrets, streams logs.
Section 03 · Why on TradingHost
Why deploy NautilusTrader on TradingHost
NautilusTrader is a low-latency engine. It rewards a runtime with a stable network path, predictable CPU, and a region close to the venue. Running on a laptop, desktop, or generic VPS introduces operational drag, including process supervision, restarts, log scattering, and unpredictable scheduling that hurts the determinism the engine is designed to deliver.
TradingHost gives a NautilusTrader engine a production-oriented runtime designed for long-running trading processes.
What you get
- GitHub-native deployment
- Always-on container runtime tuned for low-latency processes
- Multi-strategy support inside one engine
- Encrypted credential storage for every venue
- Region selection close to your venue
- Streaming logs and basic health
- Strategy-level start, stop, restart, inspect
- Same runtime for backtest and live (the engine is identical)
- MCP-compatible AI IDE workflows
What you keep
- Full control over your Strategy and Actor classes
- Direct ownership of your venue accounts and credentials
- Your choice of asset classes: crypto, FX, equities, futures, options
Section 04 · Supported venues
Supported venues and data providers
NautilusTrader spans more asset classes than the crypto-first frameworks. Native adapters cover crypto CEX, crypto DEX, multi-asset brokers, sports markets, and first-class market-data providers.
Five popular pairings are shown below. The wider directory follows.
- NautilusTrader
- your venue
- TradingHost runtime
Nautilus also ships native adapters for the following venues and data providers:
- Crypto CEX
- BitMEX, Kraken, OKX, Deribit
- Crypto DEX
- dYdX, Polymarket
- Data providers
- Databento, Tardis
- Other markets
- Betfair, AX Exchange
Section 05 · Deployment flow
How a NautilusTrader deployment works
A NautilusTrader engine on TradingHost follows the same deployment pattern as any GitHub-based project, with one extra step for installing the Rust core and any compiled extensions.
- STEP 01
Connect or create a repo
Sign in with GitHub and connect a Nautilus repo with your Strategy and Actor classes, or create one from a TradingHost Nautilus template.
- STEP 02
Configure the engine
TradingHost reads your project’s runtime configuration to know how to install the Nautilus wheel (with the Rust core), build any custom Cython extensions, and start the engine.
- STEP 03
Add encrypted venue credentials
Add exchange API keys, IBKR credentials, or DEX wallet credentials as TradingHost secrets. They are encrypted, injected into the runtime at start, and never written to your repository.
/platform/secrets/ - STEP 04
Choose a region
Select a region close to your venue’s matching engine. Latency-sensitive setups benefit from being on the same continent as the venue and the same provider as its colo region.
/platform/regions/ - STEP 05
Deploy
TradingHost starts the Nautilus engine in a managed container. Logs stream back to the dashboard. The engine treats backtest and live as variants of the same runtime, so there is one shape to monitor.
/platform/observability/
Section 06 · Determinism
Backtest = live: deterministic event-driven core
The thing that makes NautilusTrader unusual is that backtest and live are not different products. They are different inputs to the same engine. The strategy class, the message bus, the cache, and the risk engine are identical; only the data feed and the order routing change.
Practically, that means a strategy that backtests cleanly is much more likely to live-trade as expected. Live drift is harder to introduce when there is no second codebase to drift to.
Section 07 · What we don’t do
What TradingHost does not do
- TradingHost does not act as your venue.
- TradingHost does not provide trading strategies, signals, or financial advice.
- TradingHost does not modify your Nautilus Strategy or Actor classes.
- TradingHost does not custody your venue credentials beyond encrypted runtime injection.
- TradingHost does not guarantee strategy performance, venue uptime, or market connectivity.
Section 08 · FAQ
FAQ
No. TradingHost is independent. NautilusTrader is open-source software, LGPL-3.0 licensed, maintained by Nautech Systems Pty Ltd at nautechsystems/nautilus_trader.
The Rust core handles the event-driven hot path: message bus, cache, risk engine, venue adapters, async networking via tokio. The Python control plane is where you author strategies. The result is high performance with an approachable authoring surface.
Because most "it worked in backtest, broke in live" failures come from drift between two different codebases. Nautilus has one engine, one strategy class, one message bus. A backtest result is more representative of live behaviour.
Crypto CEX include Binance, Bybit, Coinbase, BitMEX, Kraken, OKX, Deribit. Crypto DEX include dYdX, Hyperliquid, Polymarket. Multi-asset coverage via Interactive Brokers (equities, futures, options, FX). Other markets include Betfair and AX Exchange. Data providers include Databento and Tardis.
Yes, primarily through Interactive Brokers, which gives access to FX along with equities, futures, and options. Tradable instruments depend on the IBKR account permissions you supply.
Yes. NautilusTrader’s engine is designed around an actor model: many Strategy and Actor instances can run in one engine, sharing market data, the cache, and the risk engine via the message bus.
You add them to TradingHost as encrypted secrets. They are injected into the Nautilus runtime at start and are not written to your repository.
No. NautilusTrader places trades through your venue credentials. TradingHost runs the engine process and streams logs.
Backtrader is older, Python-only, more limited in venue coverage, and the original repo is essentially feature-frozen. NautilusTrader is newer, actively developed, Rust-cored, multi-asset, and designed for low-latency identical backtest-and-live behaviour.
Round-trip time to the matching engine matters more than CPU on a low-latency strategy. TradingHost lets you pick a region close to your venue. See /platform/regions/ for the full list.
Deploy your first NautilusTrader strategy
Connect GitHub, choose a NautilusTrader template or your own strategy repo, add your venue credentials, choose a region, and launch into a TradingHost runtime.