A Backtrader alternative built for speed

Two different jobs

Backtrader is a full framework: backtest, optimize, and then trade live through broker integrations, all in Python. Its flexibility, its documentation and years of examples are its strength. The cost is speed: being pure Python and event-driven, it walks every bar of every run through a Python loop, so large datasets and big parameter optimizations get slow.

Manifold-BT is a research engine, not a live trading framework. It puts a Rust core under a concise Python DSL: years of bars backtest in sub-second, sweeps and walk-forward run in parallel, and execution is modeled explicitly, market-impact slippage, funding and partial fills are settings you choose, not hidden assumptions. You validate here, then deploy live wherever you trade.

Side by side

How each one turns a signal into a fill

backtrader is event-driven. Your strategy’s next() runs once per bar, decides, and places orders; a market order then fills at the open of the following bar. Commission schemes cover percentage and fixed fees, futures margin and multipliers; slippage is a percentage or a fixed amount; a yearly interest rate can be charged on shorts; and optional volume fillers cap how much of a bar’s volume an order may take. Everything is configurable, and everything is Python called bar by bar.

Manifold-BT evaluates the signals vectorized over the whole series in Rust, then runs one sequential pass for fills and PnL. By default a signal fills on the bar that produced it; setting signal_delay=1 moves the fill to the next bar, the closer match to backtrader’s default. Costs are separate models that start at zero: maker and taker fees, fixed, spread-based or volume-impact slippage, perpetual funding applied per bar from a funding-rate column, borrow on shorts, and a cap on the share of each bar’s volume a fill may take. Limit entries, stops, take-profits and trailing stops are order settings rather than code in a callback. The execution realism page shows what each model does to one strategy’s return.

Speed on parameter sweeps

Validating a strategy means running the grid around it, then the walk-forward folds, so the sweep is where the two designs pull apart. backtrader’s optstrategy spreads combinations over Python processes, each one a complete event loop over every bar. Manifold-BT sends the whole grid to the Rust core as one call: the data is loaded once and the combinations fan out across every core, with no Python in the loop. The free Community tier runs up to 256 backtests per sweep; Pro removes the cap.

There is no published, reproducible benchmark of backtrader against other libraries, and we have not run one, so no ratio is quoted here; the figures circulating in blog posts come without hardware or method. The engines Manifold-BT has been timed against, vectorbt, RaptorBT and NautilusTrader, are on the benchmarks page, from a public CI run with every engine installed from PyPI.

Live trading: backtrader does it, Manifold-BT does not

backtrader ships live brokers for Interactive Brokers and Oanda, and the strategy you backtested is the one that trades. That is the strongest reason to stay on it. Manifold-BT is research software: it does not place orders. The intended workflow is to find and validate the strategy here, with costs modelled and the parameter surface mapped, then run it on a platform built for execution, which can be your broker’s API, NautilusTrader, or backtrader itself.

Maintenance in 2026

backtrader’s last release, 1.9.78.123, and its last commit are both dated 19 April 2023. The issue tracker is switched off and dozens of pull requests wait on the repository, including a fix for an AttributeError on Python 3.10 and later. The code still runs and does not produce wrong numbers, and its documentation remains among the most praised of any Python backtester; what is missing is anyone merging fixes. Manifold-BT ships regular releases with CI on every push. The libraries guide links the sources for each of these points.

Less boilerplate

Backtrader strategies are Python classes with __init__ and next() methods. Manifold-BT expresses the same idea as a short signal graph, no class to subclass, no event callbacks to wire up:

import manifoldbt as mbt
from manifoldbt.indicators import close, ema
from manifoldbt.helpers import time_range, Slippage, Interval

# The whole strategy: indicators, signal, sizing, no class boilerplate
fast, slow = ema(close, 50), ema(close, 200)
strategy = (
    mbt.Strategy.create("ma_crossover")
    .signal("fast", fast)
    .signal("slow", slow)
    .size(mbt.when(fast > slow, 1.0, 0.0))
)

start, end = time_range("2020-01-01", "2026-01-01")
config = mbt.BacktestConfig(
    universe={"binance": ["BTCUSDT"]},
    time_range_start=start,
    time_range_end=end,
    bar_interval=Interval.days(1),
    initial_capital=10_000,
    fees=mbt.FeeConfig.binance_perps(),
    slippage=Slippage.fixed_bps(2),
    warmup_bars=200,
)
store = mbt.ingest(provider="binance", symbol="BTCUSDT", symbol_id=1,
                   interval="1d", start="2020-01-01T00:00:00Z",
                   end="2026-01-01T00:00:00Z")
result = mbt.run(strategy, config, store)
print(result.summary())

Which should you pick?

Choose Backtrader if you want one Python framework that also runs your strategy live through Interactive Brokers or Oanda, speed is not your bottleneck, and you are comfortable maintaining 2023 code yourself. Choose Manifold-BT if research throughput and execution realism are the priority: fast iteration, large sweeps, walk-forward validation, and costs modelled one by one, so the strategy you eventually trade is one you trust.

Frequently asked questions