A QuantConnect alternative that runs on your own machine

A platform, and a library

QuantConnect is built around its cloud. You write a QCAlgorithm class in Python or C#, the platform feeds it minute, hourly or daily data from a library that is free to use in the cloud, and the backtest runs on a node in your organization. The same code deploys live. The engine underneath, LEAN, is open source and runs locally through Docker with the CLI, though the CLI docs tie local backtesting to a paid organization and local data downloads are metered in credits. That is a coherent product: one place from first idea to live orders, with the data problem solved for you.

Manifold-BT is a library, and everything about it follows from running on your hardware. Signals are expressions evaluated vectorized in Rust, then a sequential pass models fills with explicit costs: market-impact slippage, funding on perpetuals, partial fills, signal delay. A parameter grid is one native call that fans out across every core you have, with GPU on Pro. Data comes from free connectors (Binance, Bybit, Hyperliquid, dYdX, Deribit, Dukascopy, Yahoo Finance), from Databento or Massive on Pro, or from a CSV or DataFrame you already have. Nothing is billed per run, because nothing runs on our side. It does not trade live, and it does not ship a universe of US equities with corporate actions the way QuantConnect does: for that breadth of curated data, their library is ahead.

Side by side

QuantConnect pricing, and what a sweep costs

As of September 2026, QuantConnect has a free tier with one backtesting node, one research node, minute-and-coarser data and no live trading. The Researcher plan is $60 per month and comes with two backtesting nodes; Team is $120 per seat per month, Trading Firm $336 per seat. On top of the plan, QuantConnect Credits pay for the things a plan does not cover: a cloud optimization job runs on optimization nodes billed by the hour, roughly $0.15 to $0.60 depending on size, and is limited to three parameters in the cloud; downloading minute US equity data for local use is about five credits per symbol-day, with one dollar buying a hundred credits. For a small optimization that is well under a dollar, and their staff say so; for a big grid, it is a job you size and budget.

Manifold-BT has a free Community tier and a Pro tier at $19 per month or $290 once. The difference in kind is that there is no meter: a sweep uses your cores, and the only limits are the ones the tier sets. Community runs at one-minute resolution and coarser and caps a session at 256 parameter combinations across its sweeps; Pro removes the cap, adds walk-forward, GPU sweeps and simulation down to one second. Whether that is cheaper depends on how often you sweep. If you run a few small optimizations a month, the two are close. If the parameter map is the work, which is what research mostly is, running it where the electricity is already paid for changes the habit: you draw the map, change a threshold, and draw it again.

The same rule, both ways

A long-only rule, in the position whenever price is above its 200-day average. On QuantConnect it is a class with an event handler, run on a cloud node:

from AlgorithmImports import *

# QuantConnect: a class, an event loop, and a cloud node to run it on
class PriceAboveSma(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2025, 12, 31)
        self.set_cash(100_000)
        symbol = self.add_equity("SPY", Resolution.DAILY).symbol
        self._sma = self.sma(symbol, 200, Resolution.DAILY)
        self.warm_up_indicator(symbol, self._sma, Resolution.DAILY)

    def on_data(self, data):
        if not self._sma.is_ready:
            return
        price = self.securities["SPY"].price
        self.set_holdings("SPY", 1.0 if price > self._sma.current.value else 0.0)

On Manifold-BT it is an expression, run on your machine, and the sweep over the lookback is the last three lines rather than a separate job:

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

# Manifold-BT: the same rule as an expression, run on your own machine
trend = sma(close, mbt.param("period", default=200))
strategy = (
    mbt.Strategy.create("price_above_sma")
    .signal("trend", trend)
    .size(mbt.when(close > trend, 1.0, 0.0))
)

start, end = time_range("2020-01-01", "2026-01-01")
config = mbt.BacktestConfig(
    universe={"yahoo": ["SPY"]},
    time_range_start=start, time_range_end=end,
    bar_interval=Interval.days(1),
    initial_capital=100_000,
    trading_days_per_year=252,
    fees=mbt.FeeConfig(taker_fee_bps=0.5, maker_fee_bps=0.5),
    slippage=Slippage.fixed_bps(1),
    warmup_bars=200,
)
store = mbt.ingest(provider="yahoo", symbol="SPY", symbol_id=1,
                   interval="1d", asset_class="equity",
                   start="2019-01-01T00:00:00Z", end="2026-01-01T00:00:00Z")
result = mbt.run(strategy, config, store)

# The whole grid is one call, fanned out across every core. No node, no meter.
sweep = mbt.run_sweep(strategy, param_grid={"period": range(50, 300, 10)},
                      config=config, store=store)
print(sweep.best("sharpe"))

When QuantConnect is the right call

Two cases, clearly. You want to go live from the code you backtested, through a brokerage the platform already integrates: Manifold-BT does not place orders, on purpose. Or your research depends on a curated universe that is hard to assemble yourself, such as the full US equity market with delistings and corporate actions, or options chains across many underlyings: QuantConnect hosts that and Manifold-BT asks you to bring it. Plenty of desks use both, researching fast and locally, then implementing the survivor on the platform that will trade it.

Which should you pick?

Choose QuantConnect if you want one hosted platform from idea to live deployment, with the data library and brokerage integrations that come with it, and the per-node, per-credit pricing fits how you work. Choose Manifold-BT if the job is research: sweeps, walk-forward and Monte Carlo on your own hardware, realistic costs as explicit settings, a library you install in one line, and a price that does not move with how many times you run it.

Frequently asked questions