Python Backtesting Tools Review: which frameworks are still alive in 2026

Picking a backtesting library is mostly a maintenance bet. The code that prices your strategy needs to still be alive when an exchange changes an API, a pandas release breaks an import, or you find a bug at 2 a.m. So this review leads with the least glamorous, most decisive signal — is the project actually maintained? — and only then gets into architecture, speed, and features.

Every GitHub number below was pulled live from the GitHub API on 2026-06-22, and the harder claims were cross-checked against primary sources (project repos, official docs) and adversarially verified. Where a figure is a vendor's self-reported best case, it's flagged.

The maintenance reality check

Here's the whole ecosystem ranked by GitHub stars, color-coded by whether it's actually being worked on:

The uncomfortable takeaway: two of the most-starred, most-blogged-about names are effectively legacy.

• Backtrader (22.1k ⭐) is the famous one everyone recommends — and its last commit to the default branch was April 2023, with zero GitHub releases ever published. It's not abandoned (issues still get occasional attention), but it's dormant. Curated catalogs label it INACTIVE.
• Zipline (19.9k ⭐), Quantopian's old engine, was abandoned in 2020 when Quantopian shut down. kernc's own alternatives list files it under "Obsolete / Unmaintained." The maintained successor is a separate fork, zipline-reloaded (1.8k ⭐), by Stefan Jansen.
• PyAlgoTrade (4.7k ⭐) is archived — officially read-only. QSTrader (3.4k ⭐) and the old crypto frameworks blankly and qtpylib are flagged unmaintained.

Meanwhile the projects shipping real releases in 2026 are Freqtrade (51.7k ⭐), NautilusTrader (24.1k ⭐), LEAN (20k ⭐), backtesting.py (8.5k ⭐), Jesse (8.1k ⭐), vectorbt (8.0k ⭐), PyBroker (3.4k ⭐), bt (2.9k ⭐), and Lumibot (1.7k ⭐). Stars measure history; commit dates measure whether anyone will fix your bug.

Two architectures: event-driven vs vectorized

The other fork that decides everything is how the engine runs your strategy.

• Event-driven engines loop bar by bar, calling your strategy on each new candle. They model order fills, slippage, and intrabar risk realistically, and — critically — the same code can run live. Backtrader, NautilusTrader, backtesting.py, Freqtrade, Lumibot, and Zipline are event-driven.
• Vectorized engines (the standout is vectorbt) skip the loop entirely: they pack thousands of strategy configurations into NumPy arrays and compute them all at once. This is staggeringly fast for parameter search, but it assumes next-bar fills and ignores intrabar slippage, partial fills, and mid-bar risk checks.

Neither wins outright. You research with the fast one and validate with the realistic one. More on that trade-off below.

The actively-maintained leaders

NautilusTrader — production-grade, event-driven, Rust core

NautilusTrader (24.1k ⭐, LGPL-3.0) describes itself as a "production-grade Rust-native trading engine with deterministic event-driven architecture" — the codebase is ~70% Rust with Python bindings. It backtests across multiple venues and instruments at nanosecond resolution using tick and order-book data, and ships ~20 live integrations (Binance, Coinbase, Kraken, OKX, Bybit, Interactive Brokers, Betfair, and more). Its headline promise: identical strategy code from research to live deployment. This is the strongest pick for a crypto+stocks audience that needs tick-level realism and a real path to production. Cost: a steeper learning curve and heavier architecture than the simple libraries.

vectorbt — vectorized research at scale

vectorbt (8.0k ⭐, Apache-2.0 + Commons Clause) is the vectorized engine. Its README: "instead of looping through bars one strategy at a time, it packs thousands of configurations into NumPy arrays, accelerates the hot path with Numba and Rust, and runs them all at once, turning hours of grid search into seconds." Testing 10,000 dual-SMA window combinations in seconds is the canonical example; third parties report ~1000× speedups over Backtrader on some workloads (vendor/third-party figures, not an independent benchmark). The parameter sweep below — 25 backtests across SMA windows — is exactly what vectorbt industrializes:

Two caveats worth knowing: the Commons Clause restricts commercial resale (relevant if you're building a product), and the polished, paid vectorbt PRO is a separate product from the open-source build. vectorbt is backtest-only — no live trading.

backtesting.py — the lightweight favorite

backtesting.py (8.5k ⭐, AGPL-3.0) is the one to reach for when you want a clean, fast, readable backtest without a framework's worth of ceremony. Define init() and next(), run, get a stats object and an interactive Bokeh plot. The AGPL-3.0 license matters: it's strong copyleft with network-use provisions, so it's awkward inside a closed-source SaaS. It's backtest-only. The equity curve on this page (cover) and the statistics below come from a real backtesting.py run — a plain SMA(20/50) crossover on a synthetic series:

Note the honest outcome: the naive crossover returned +1.6% against +46% for buy & hold, with a brutal −38% drawdown. That's the normal first result of a real backtest, and exactly why you sweep parameters and validate assumptions before believing anything.

Freqtrade — the crypto default

Freqtrade (51.7k ⭐, GPL-3.0) is the most-starred project on this list and the de-facto open-source crypto trading bot. It does backtesting, dry-run (paper) trading, and live trading on major exchanges, controlled via Telegram or a built-in web UI, and ships monthly releases. It's crypto-only — no stocks — but for crypto it's the maintained, community-backed standard.

Lumibot, bt, PyBroker, Jesse, LEAN, zipline-reloaded

• Lumibot (1.7k ⭐, GPL-3.0) — multi-asset (stocks, options, crypto, futures, forex) with the same code for backtest, paper, and live across Alpaca, Interactive Brokers, Tradier, Schwab, Tradovate, and CCXT. Beginner-friendly broker onboarding; watch for documented backtest-vs-live parity gotchas (timezones, entry timing, margin).
• bt (2.9k ⭐, MIT) — a flexible, tree-of-algos framework aimed at portfolio allocation and weight-based strategies rather than per-tick execution. Permissively licensed, actively maintained, backtest-only.
• PyBroker (3.4k ⭐) — built for machine-learning strategies, with Numba acceleration and walk-forward validation baked in. Backtest-only.
• Jesse (8.1k ⭐, MIT) — a crypto framework with a clean strategy API and live trading; permissive license.
• LEAN / QuantConnect (20k ⭐, Apache-2.0) — the heavyweight, multi-asset engine behind QuantConnect's cloud. C#/.NET core with a Python API; backtest and live. Powerful but the largest commitment here.
• zipline-reloaded (1.8k ⭐, Apache-2.0) — the actively-maintained fork of Quantopian's Zipline, popular in academia and the Machine Learning for Trading book. Backtest-only; use this, not the original quantopian/zipline.

The graveyard — avoid for new projects

These still rank in search results and old blog posts, but don't start here in 2026:

• Zipline (original, quantopian/zipline) — abandoned 2020. Use zipline-reloaded.
• PyAlgoTrade — repo archived (read-only).
• QSTrader — flagged unmaintained; last push mid-2024.
• blankly — platform shut down; qtpylib — archived since 2021.
• fastquant (1.8k ⭐) — a thin wrapper aimed at one-line backtests, but stale since 2023.

Architecture matters: the realism trade-off

The vectorized-vs-event-driven split isn't academic. vectorbt's speed comes from assuming every fill happens at the next bar's price with no slippage. For a momentum screen across 500 assets that's fine. For a strategy whose edge lives in intrabar execution — stop placement, partial fills, queue position — a vectorized backtest will quietly lie to you, and you need an event-driven engine (NautilusTrader, Backtrader) or a live dry-run (Freqtrade, Lumibot) to get an honest number. The professional workflow uses both: vectorbt to explore the parameter space, an event-driven engine to validate the survivors.

Licensing — read this before you build a product

Backtesting libraries are unusually license-heavy, and several are copyleft:

If you're building something commercial and closed-source, the MIT/Apache tools are the frictionless choices; AGPL and Commons Clause need a lawyer's read.

The comparison at a glance

Stars and statuses are 2026-06-22 snapshots and will drift; maintenance is the most volatile dimension, so re-check commit activity before you commit.

How to choose, in one breath

• Research a strategy across thousands of parameters → vectorbt.
• A quick, clean single backtest in a notebook → backtesting.py (mind the AGPL).
• Production crypto+stocks with research→live parity and tick realism → NautilusTrader.
• A maintained crypto bot with backtest/dry-run/live → Freqtrade.
• Multi-asset retail algo trading, beginner-friendly → Lumibot.
• Portfolio allocation / weighting strategies → bt.
• Machine-learning strategies with walk-forward → PyBroker.
• Academic / ML-for-Trading coursework → zipline-reloaded.
• You inherited a Backtrader codebase → fine, but know it's dormant; new projects should look elsewhere.

The one rule that survives every market regime: check the last commit date before you check the star count. A 22k-star library that hasn't shipped since 2023 is a slower path to production than an 8k-star one that released last week.

Methodology: GitHub metrics were fetched live from the GitHub API on 2026-06-22; architecture, maintenance, license, and live-trading claims were cross-checked against project repositories and official docs and adversarially verified, drawing on curated catalogs (PyTrade.org, awesome-systematic-trading) and kernc's alternatives list. The equity curve, statistics, and parameter heatmap are real output from a backtesting.py run on a reproducible synthetic price series — illustrative, not a strategy recommendation. Performance figures attributed to vendors (vectorbt's speedups, NautilusTrader's nanosecond resolution) are self-reported, not independent benchmarks.