从 Python 到 Rust

A backtest often grows up with its strategy. It starts as a few expressive lines in a notebook, turns into a collection of typed arrays once the rules settle, and may eventually end up in a service where Python is nowhere to be seen. VBT supports each stage. Think of its abstractions as nesting dolls: open one layer and the same array contract appears inside the next one 🪆

In this tutorial, we will backtest one strategy through four interfaces:

We will keep the data, rules, execution assumptions, and metrics fixed. Changing the strategy and the interface at the same time would tell us very little. We want to see where each layer begins, what it adds, and what it costs.

Idea

Most introductory backtests use a moving-average crossover. It is a fine first example, but it hides many details that matter in practice: several indicators must agree, signals become known only after a bar has closed, orders compete for shared cash, and stops must make assumptions about the unknown path inside an OHLC candle.

Here we will build a volatility-squeeze breakout strategy over liquid NASDAQ stocks:

1. Pull hourly OHLCV data for NVDA, TSLA, AAPL, and AMZN from TradingView.
2. Measure compression with Bollinger Band width.
3. Require trend activity with ADX.
4. Require participation with volume above its rolling mean.
5. Enter when price breaks out of the Bollinger envelope after a squeeze.
6. Exit on a middle-band cross or on ATR-based stop-loss / take-profit levels.
7. Simulate all symbols in one cash-sharing group.
8. Compare return, drawdown, risk-adjusted return, trade quality, and order counts.

This is still an educational strategy, but it has enough moving parts to expose meaningful differences among the interfaces.

Data

Let's pull hourly candles for four NASDAQ heavyweights using VBT's vectorbtpro.data.custom.tv.TVData class and its inherited vectorbtpro.data.base.Data.pull method. TradingView serves the most recent history for each symbol and timeframe, so we cannot pin an exact date range. Instead, we let VBT cache the first pull: every later run reads the same candles from disk, which is exactly the frozen input a cross-implementation comparison needs.

from vectorbtpro import *

SYMBOLS = [
    "NASDAQ:NVDA",
    "NASDAQ:TSLA",
    "NASDAQ:AAPL",
    "NASDAQ:AMZN"
]
TIMEFRAME = "1h"

data = vbt.TVData.pull(
    SYMBOLS,
    timeframe=TIMEFRAME,
    silence_warnings=True,
    cache=True,  # (1)!
    cache_kwargs=dict(cache_dir="temp")
)

data.close

symbol                     NASDAQ:NVDA  NASDAQ:TSLA  NASDAQ:AAPL  NASDAQ:AMZN
datetime
2020-01-02 14:30:00+00:00      5.94375    28.264638      74.3675      93.4400
2020-01-02 15:30:00+00:00      5.94375    28.417305      74.5275      93.4960
2020-01-02 16:30:00+00:00      5.95675    28.431305      74.5775      93.7385
...                                ...          ...          ...          ...
2026-07-14 17:30:00+00:00    211.75000   396.385000     315.2100     247.4000
2026-07-14 18:30:00+00:00    211.26000   396.610000     315.7100     247.8300
2026-07-14 19:30:00+00:00    211.82000   396.080000     314.9900     247.5000

[11452 rows x 4 columns]

1. Cache the result in VBT's local LMDB cache, here placed in the temp directory. The same symbols requested again with the same pull arguments are loaded from disk instead of TradingView.

TradingView returned roughly six and a half years of hourly candles per symbol. VBT aligned them on a common timezone-aware index of 11452 rows, which is plenty of history for a strategy that trades only a few times per month and symbol.

Rules

We keep the rules in one small configuration block. This block becomes the contract between all four implementations: