Module 17: Advanced TopicsSerialization, kernel lifecycle, and option Greeks for more advanced users

1. High-Performance Serialization

NautilusTrader’s performance goals extend beyond pure computation into storage and transport. The framework supports several serialization formats chosen for speed, interoperability, and operational convenience:

2. System Kernel Lifecycle

Expanding on the architecture from Module 02, we now deep-dive into the kernel.py boot sequence:

sequenceDiagram
                        participant User
                        participant Node as TradingNode
                        participant Kernel
                        participant Engines

                        User->>Node: node.run()
                        Node->>Kernel: kernel.run()
                        Kernel->>Engines: 1. Instantiate Engines (Data/Exec/Risk)
                        Kernel->>Engines: 2. Initiate Client Handshakes (Connect)
                        Kernel->>Engines: 3. Initialize Cache Persistence
                        Kernel->>Engines: 4. Re-hydrate Previous State (Load State)
                        Kernel->>Engines: 5. Promote Strategy Pods (Start)
                        Note over Kernel: ENTER ASYNC EVENT LOOP
                        User->>Node: node.stop()
                        Kernel->>Engines: 6. Flush Strategy Buffers & Stop
                        Kernel->>Engines: 7. Persist Terminal State Vectors
                        Kernel->>Engines: 8. Disconnect Client Adapters
                        Kernel->>Engines: 9. Decommission Engine Objects

3. Tick Scheme — Precision Protocols

Venues enforce rigid constraints on price and quantity increments. The TickScheme class encapsulates these regulatory boundaries:

from nautilus_trader.model.instruments import Instrument
from nautilus_trader.model.identifiers import InstrumentId
from nautilus_trader.model.objects import Price, Quantity

# Retrieving the instrument's Tick Scheme metadata
instrument: Instrument = ...
tick_scheme = instrument.tick_scheme

# 1. Price Alignment (Rounding)
raw_price = Price.from_str("100.123456")
valid_price = tick_scheme.round_price(raw_price)
# Returns 100.12 (Given a 0.01 tick size constraint)

# 2. Quantity Alignment
raw_qty = Quantity.from_str("0.001234")
valid_qty = tick_scheme.round_quantity(raw_qty)
# Returns 0.001 (Given a 0.001 step size constraint)

# 3. Validation Logic
if not tick_scheme.is_valid_price(raw_price):
    self.log.error("PRECISION BREACH: Adjusting price before submission.")

4. Option Greeks — Theoretical Pricing

NautilusTrader integrates native Black-Scholes primitives for calculating theoretical option premium and Greek sensitivities:

from nautilus_trader.model.greeks import calculate_greeks
from nautilus_trader.model.enums import OptionType

# Calculating Greek Sensitivities
greeks = calculate_greeks(
    price_underlying=100.0,
    price_strike=105.0,
    time_to_expiry=30/365,   # Annualized temporal anchor
    risk_free_rate=0.05,     # 5% RF rate
    volatility=0.20,         # 20% IV
    option_type=OptionType.CALL,
)

print(f"Delta: {greeks.delta}")  # Position sensitivity to underlying
print(f"Gamma: {greeks.gamma}")  # Delta sensitivity to underlying
print(f"Theta: {greeks.theta}")  # Temporal decay
print(f"Vega:  {greeks.vega}")   # Volatility sensitivity

5. Custom Data Types — Extending the Bus

Beyond standard OHLC Bars and Quotes, you can define proprietary telemetry (e.g., On-chain signals, Sentiment metrics):

1. Defining the Schema

from dataclasses import dataclass
from nautilus_trader.model.data import Data

@dataclass(frozen=True)
class SentimentData(Data):
    sentiment_score: float
    source: str

    @property
    def ts_event(self) -> int:
        return self._ts_event

    @property
    def ts_init(self) -> int:
        return self._ts_init

2. Strategy Integration

class AlphaSentimentStrategy(Strategy):
    def on_start(self):
        # Register for the proprietary data stream
        self.subscribe_data(
            data_type=SentimentData,
            instrument_id=self.instrument_id,
        )

    def on_data(self, data: Data):
        if isinstance(data, SentimentData):
            self.log.info(f"Signal Ingested: {data.source} Score={data.sentiment_score}")
            if data.sentiment_score > 0.8:
                self.submit_market_order(...)

6. Interactive System Probing

target_price = self.instrument.tick_scheme.round_price(raw_alpha_price)
self.order_factory.limit(..., price=target_price)

7. Synthesis of the Advanced Curriculum

Congratulations on completing the core curriculum! You now possess the specialized knowledge required to architect institutional-grade systems: