Freqtrade alternative for fast, realistic backtesting

Two backtesting engines, built differently

Freqtrade’s strategy interface computes indicators vectorized over the whole dataframe with pandas and TA-Lib, same as most Python backtesters. But the trade simulation itself steps candle by candle in Python, because it has to reproduce exactly what the live bot would do: the same entry/exit signals, stoploss, and ROI logic. That fidelity to the live bot is also why it is the slower half of the loop, especially once you multiply it across hundreds of hyperopt epochs.

Manifold-BT uses the same two-stage shape, vectorized signals, then a sequential pass for fills, but in Rust: evaluate signals over the full series at once, then walk the series once for stops, partial fills, and PnL. Same idea as Freqtrade’s event-driven loop, native speed instead of a Python one.

What Freqtrade’s backtester assumes

Freqtrade’s own documentation is upfront about this: by default, an order fills at the requested price with no slippage and no market impact, as long as that price falls within the candle’s high/low range. OHLC data alone cannot tell you the order in which prices moved within a candle, so the path between the high and the low inside a bar is unknown. Freqtrade’s fix is opt-in: pass --timeframe-detail to re-simulate against a lower timeframe for closer intra-candle accuracy. There is also no built-in walk-forward split; folds are hand-rolled by slicing timeranges yourself.

Manifold-BT models market-impact slippage, funding on perps, partial fills, and signal delay by default, and ships walk-forward folds as a first-class feature, not a manual timerange split.

Side by side

The same sweep, both engines

Same SMA crossover, same grid. In Manifold-BT the whole sweep is one native call that fans out across every core (or the GPU) and evaluates every combination. Freqtrade has no exhaustive-sweep API: the way you search a space is hyperopt, which uses Optuna to start with about 30 random trials, then sample intelligently instead of testing every combination. Each trial still reruns the full Python backtest, and Freqtrade’s own docs are blunt about the cost: it will “burn all your CPU cores” and, with the hundreds of epochs typically recommended, “still take a long time.”

Different trade-off, then: the sweep does more evaluations but gives you the full map, heatmaps included, so you can see the stable plateau around your parameters rather than trusting a single optimum a sampler landed on. Same crossover, same idea, different search:

import manifoldbt as mbt
from manifoldbt.indicators import close, sma

# SMA crossover, the two periods declared as swept parameters
fast, slow = sma(close, mbt.param("fast")), sma(close, mbt.param("slow"))
strategy = (
    mbt.Strategy.create("sma_cross")
    .signal("fast", fast)
    .signal("slow", slow)
    .size(mbt.when(fast > slow, 1.0, 0.0))
)

# One native call: the whole grid fans out across every core.
# (config + store are set up once, elsewhere.)
sweep = mbt.run_sweep(
    strategy,
    param_grid={"fast": range(5, 100), "slow": range(10, 300)},
    config=config, store=store,
)
best = sweep.best("sharpe")

from freqtrade.strategy import IStrategy, IntParameter
import talib.abstract as ta

class SmaCross(IStrategy):
    # Same SMA crossover; hyperopt searches this space, each trial a full backtest.
    buy_fast = IntParameter(5, 100, default=20, space="buy")
    buy_slow = IntParameter(10, 300, default=50, space="buy")

    def populate_indicators(self, dataframe, metadata):
        dataframe["fast"] = ta.SMA(dataframe, timeperiod=self.buy_fast.value)
        dataframe["slow"] = ta.SMA(dataframe, timeperiod=self.buy_slow.value)
        return dataframe

    def populate_entry_trend(self, dataframe, metadata):
        dataframe.loc[dataframe["fast"] > dataframe["slow"], "enter_long"] = 1
        return dataframe

# Optuna proposes ~30 random trials, then searches the space (not an
# exhaustive grid). Each trial is one full Python backtest; hundreds of
# epochs are typical.
# freqtrade hyperopt --strategy SmaCross --spaces buy --epochs 500

That difference in shape is a difference in wall time. A single backtest is already milliseconds in Manifold-BT against a Python candle-by-candle pass in Freqtrade. The gap then compounds on the search, where the whole grid stays in native code across every core or the GPU instead of rerunning a Python backtest per trial: a study that lands in seconds on Manifold-BT is the “long time” the Freqtrade docs warn about, minutes to hours. On a full parameter search that is the difference between an interactive map and a batch job, with Manifold-BT coming out hundreds, often thousands, of times faster.

When to pick which

Choose Freqtrade if you want one open-source stack that backtests and then trades live on an exchange, and you are comfortable with candle-level fills (no slippage or market impact unless you opt into --timeframe-detail) and an Optuna-driven search over your parameter space. Choose Manifold-BT when the backtest itself is the priority: realistic execution modeled by default, an exhaustive parameter map instead of a directed search, built-in walk-forward, and Rust/GPU speed, then deploy the strategy you actually trust wherever you trade live.