Performance

Run quantitative workloads efficiently, from compiled array operations to portfolio simulation. VBT PRO combines Numba, optional Rust kernels, and custom NumPy implementations with chunking, caching, and parallel execution. You can speed up calculations in a Python research workflow, spread independent backtests across workers, or build a native Rust strategy.

See VBT process millions of backtests, run stateful strategies in Rust, and spread research across CPU cores. The examples and interactive benchmarks show the speed and memory use directly.

Find the right starting point

Performance pages

Compute backends

Run kernels with Numba, parallel Numba, Rust, or NumPy and choose the backend per call

Rust engine

Run simulations on the native Rust engine and write strategy callbacks in Rust

Parallel execution and caching

Chunk work across threads, processes, or Ray, cache results, and keep memory bounded

Benchmarks

Compare simulators on the same orders and measure each backend on your own machine

Keep your Python workflow

You can use the high-level pandas and portfolio APIs while supported numerical calculations run in compiled code. Numba handles custom numerical callbacks, and the optional Rust extension can accelerate supported built-in calls without requiring you to write Rust. Backend selection and parallel workers give you separate controls over how a calculation runs and how independent work is distributed.

For a large strategy search, combine the two: run the calculations through a suitable backend, process combinations in manageable chunks, and keep the metrics you need. If you want to write the strategy in Rust, the native simulators also support stateful callbacks and processing new bars as they arrive.

Start here

Start with the benchmark comparisons to see measured examples, or follow From Python to Rust to explore the same strategy at different execution levels.

See the Rust documentation for the native backend and the Benchmarks for measured performance examples.