Open engine · Commercial PRO · Enterprise / Private
Open-source backtesting with realistic execution, robust validation and reproducible research. Add PRO for managed data and advanced research workflows, or discuss Enterprise / Private for dedicated environments and team support.
FOR RESEARCHERS
Available nowStart from 50 runnable examples or your own Python logic across long/short equities, spot FX and futures. Choose weight or order mode, configure indicators, rebalancing, risk and execution costs, then inspect NAV, holdings, trades, metrics and plots on your machine. Borrow, financing, margin and futures-roll assumptions require explicit modeling where relevant.
See asset-class modeling assumptions → Start with a free example →FOR QUANT TEAMS
Coming soonMove from isolated scripts to one explicit standard for data provenance, point-in-time inputs, timing, costs, validation and reports. The engine records the declared contract; users remain responsible for the temporal correctness of custom inputs. The hosted workspace is designed to add team access, run history and shared review artifacts when collaboration matters.
Clone the full repository or add the same engine directly to your Python workflow.
Built for quants & researchers
Build DataFrame/NumPy signal and weight paths across dates and instruments.
Replay orders, fills, slippage and costs when weights are not enough.
Run Optuna trials across numeric and categorical spaces with evidence.
Use rolling and expanding walk-forward folds before trusting a tuned run.
Inspect drawdowns, crisis windows, volatility regimes and failure periods.
Export metrics, plots, artifacts and PDF tear sheets from one documented run.
Open runs locally today. PRO is commercially available with managed research data and advanced workflows. The hosted workspace is coming soon. Enterprise / Private scope is agreed with your team. Walk-forward validation and optimization are also available in the open engine.
Run the engine locally.
Apache 2.0 backtesting with deterministic sample data, realistic execution, validation and optimization on your own machine.
Available now
Get started on GitHub →Research with managed data and advanced workflows.
Managed market and fundamental data, advanced validation and optimization workflows. Data coverage, licensing and access are agreed during onboarding.
Commercially available. Hosted workspace coming soon.
Request PRO access →Dedicated research infrastructure for your team.
Dedicated data, environments, team workflows and support, scoped around your investment process.
Deployment, capabilities and timing agreed with your team.
Discuss Enterprise / Private →Accurate cash & positions, corporate actions, financing, and costs. Built for institutional-grade analysis.
Deterministic data, pinned environments, and reproducible runs you can trust and share.
Optuna-powered optimization with walk-forward validation to avoid overfitting and measure robustness.
Comprehensive metrics, attribution, exposures, and tear sheets ready for decision making.
Start with vectorized portfolio research or move to order-aware EOD simulation when execution logic matters.
Portfolio research for allocation strategies. Signals become target weights across a portfolio. Best for factor, ranking, rotation and scheduled rebalancing.
from backtester import Backtester
class SMACrossover(Backtester):
def _compute_signals(self):
close = self.instruments_data.get_feature("adj_close")
fast = close.rolling(50).mean()
slow = close.rolling(200).mean()
return (fast > slow).astype(float).fillna(0.0)
def _compute_weights(self):
signals = self.instruments_data.get_feature(
"strategies", self.strategy_name, "signals"
)
active = signals == 1
n_active = active.sum(axis=1)
return active.div(n_active, axis=0).fillna(0.0)
strategy = SMACrossover(
instruments=["AAPL", "MSFT", "GOOGL", "AMZN", "NVDA"],
backtest_period={"start": "2015-01-01", "end": "2025-01-01"},
initial_capital=100_000,
execution_mode="weights",
)EOD execution for trade-aware strategies. Use orders, sizing, stops, take-profit and brackets when execution behavior matters.
from backtester import Backtester
class BracketTrendEntry(Backtester):
def _compute_signals(self):
close = self.instruments_data.get_feature("adj_close")
sma_200 = close.rolling(200).mean()
return (close > sma_200).astype(float).fillna(0.0)
def _compute_orders(self, date, bars, current_positions, nav):
self.bracket_percent(
"AAPL",
weight=0.20,
take_profit=0.10,
stop_loss=0.05,
)
strategy = BracketTrendEntry(
instruments=["AAPL"],
backtest_period={"start": "2020-01-01", "end": "2025-01-01"},
initial_capital=100_000,
execution_mode="orders",
)These are concrete outputs from the backtester: equity curves, drawdown, seasonality, crisis summaries, parameter diagnostics and walk-forward results.
Compare strategy path, benchmark curve, cumulative return and terminal capital.
Inspect underwater periods, recovery path, max drawdown and risk-adjusted return.
Turn return history into a calendar structure for month and regime review.
Stress the strategy across crashes, macro shocks, recoveries and volatile episodes.
See which assumptions drive objective value before promoting a tuned configuration.
Separate in-sample tuning from out-of-sample behavior with fold-level evidence.
Overlay portfolio path with bull, bear and sideways market regimes.
Inspect where the strategy adds or loses value versus the benchmark.
Measure how long drawdowns persist, not only how deep they get.
Track VaR and CVaR through regimes before approving a configuration.
Check whether additional trading activity is actually buying performance.
See which instruments are driving portfolio risk in the final packet.
The same run writes an 80+ metric table across executive summary, performance, benchmark comparison, risk, market dynamics, trading analytics, execution context, reproducibility and crisis behavior.
The console table is organized for review: headline performance, benchmark-relative behavior, downside risk, trade analytics, reproducibility and crisis response.
The free catalog covers weight and order modes, market to OCO orders, risk models, intraday workflows, futures, FX and walk-forward optimization. Open a result and inspect its exact source.
Classic trend-following with a clean signal-to-weight conversion and report output.
Ranks sector ETFs by trailing return, holds the strongest names and rebalances monthly.
Buys oversold conditions with limit entries, exits with stops and reviews the blotter.
Scales exposure through time to keep the portfolio near a target volatility budget.
Uses Optuna TPE while separating parameter search, study diagnostics and out-of-sample validation.
Separates slice diagnostics from date-bounded per-fold execution with rolling or anchored folds and pre-OOS purging.
Illustrative historical backtest from one configured research run — not live or investable performance. Results depend on the selected universe, period, data and modeled execution and cost assumptions; see the full packet for details. Past performance does not predict future results.
Strategy and benchmark path from the same configured report window.
Depth and duration of losses behind the headline return.
Target exposure by instrument through the report window.
Portfolio composition from the same generated packet.
Which assets drive portfolio risk in this run.
Rolling risk-adjusted performance from the report.
Risk scale through time for the same run.
Drawdown pressure through the report period.
How long capital stayed below its prior high.
Trading activity generated by the SMA order rules.
Most tools make the first chart easy. QuantJourney Backtester focuses on the next question: can this strategy survive costs, regimes, validation and review?
Data can come from Yahoo Finance, QuantJourney Cloud API or local files. Signals, weights, positions and reports are computed on your machine.
The open-source run produces metrics, plots, report artifacts and reproducibility metadata. Hosted and private research pipelines add full cryptographic fingerprints for code, configuration, environment and input data.
Rolling and expanding walk-forward folds, purge gaps, Sharpe decay, deflated Sharpe and PBO measure how performance changes out-of-sample.
Use portfolio weights for allocation strategies or order-based fills for stops, limits, brackets, OCO, slippage and commissions.
Our focus is an institutional-style research review layer: overfit diagnostics, crisis analysis, declarative rebalancing and review-ready reporting. Other engines can support many of the same outcomes through extensions or custom workflow code.
| Feature | QJ Backtester | VectorBT | Zipline | Backtrader | QuantConnect |
|---|---|---|---|---|---|
| Local compute | Built-in | Built-in | Built-in | Built-in | Platform-integrated / LEAN local |
| Walk-forward validation | Built-in workflow | Custom workflow | Custom workflow | Custom workflow | Custom or platform workflow |
| Overfit diagnostics (Deflated Sharpe, PBO) | Built-in workflow | Available through extension | Available through extension | Available through extension | Custom workflow |
| Crisis/regime review (20 events + 6 regimes) | Built-in workflow | Custom workflow | Custom workflow | Custom workflow | Platform-integrated reporting |
| Research PDF/report packet | Built-in | External workflow | External workflow | External workflow | Platform-integrated |
| Declarative rebalancing policies | Built-in workflow | Available through core APIs | Available through core APIs | Available through core APIs | Available through core APIs |
| Weight and order research paths | Built-in workflow | Available through core APIs | Custom workflow | Order-oriented core | Algorithm/order-oriented core |
| Slippage and commission assumptions | Built-in models | Available through core APIs | Available through extension | Built-in models | Platform-integrated models |
| Multi-asset workflows | Built-in with stated assumptions | Custom by dataset/model | Custom by dataset/model | Available through core APIs | Platform-integrated |
| Open-source engine | Apache 2.0 | Open-source core | Community open source | Open source | LEAN open source; hosted services separate |
Categories describe the default research workflow, not the theoretical limits of each engine. “Custom workflow” means the outcome can be assembled with user code or third-party tooling.
Universe, dates, data source, benchmark, costs, execution mode and validation settings are captured before the run starts.
Instead of a chart screenshot, the product is a portable research packet with assumptions and evidence attached.
A signal is not exposure. A target weight is not a fill. QuantJourney separates signals, weights, orders, positions, cash and NAV so portfolio behavior is not collapsed into one misleading return stream.
Gross alpha is cheap. Net alpha is rare. Test slippage, commissions, turnover and execution assumptions before trusting the result. Borrow, financing and margin costs must currently be supplied through custom assumptions where relevant.
A strategy that works in one market can die in another. Review crisis windows, volatility regimes, drawdown recovery and benchmark-relative behavior.
Optimized parameters are not evidence. Use walk-forward folds, purge gaps, Sharpe decay, deflated Sharpe and PBO before promoting a configuration.
Research-integrity answers for the open-source library, the hosted workspace and QuantJourney data workflows.
No account or API key is required to install the package, inspect the source or run the bundled deterministic sample-data mode. Included real-data workflows request data through QJ API and require enabled data access and QJ credentials, normally an API key. Backtester PRO is commercially available with managed research data and advanced workflows. Dataset coverage, licensing and quotas depend on your subscription.
Yes. The Python library is Apache 2.0 licensed and free to use, fork, modify and commercialize. Installation, source inspection and the bundled deterministic sample-data mode do not require an account. QJ-managed market data and hosted services have separate access conditions.
The hosted workspace is coming soon. It is designed for configuring and reviewing backtests in the browser, with team access, run history and shared review artifacts. Backtester PRO is commercially available separately from this upcoming workspace.
QuantJourney enforces next-bar timing in its built-in execution paths. Fast weight targets calculated on bar t become effective for the following return period, while orders submitted after bar t can fill no earlier than the configured execution point on bar t+1. The engine cannot determine whether arbitrary user-supplied datasets, features or preprocessing pipelines contain future information.
The engine does not currently provide a first-class historical membership model with effective start and end dates. Users can supply point-in-time membership data and prevent inactive instruments from receiving signals or target weights. A current constituent list must not be treated as historical membership.
QuantJourney does not infer publication dates or reporting lags. The supplied time index is treated as the date on which an observation became available, so fundamental inputs must be aligned to their actual publication or availability timestamp before entering a strategy. A fiscal period-end date alone is not sufficient.
QuantJourney labels a result as per-fold out-of-sample execution only when each fold runs a fresh strategy instance, any parameter selection uses the training window, and the selected configuration is then frozen for the corresponding test window. slice_diagnostics results are explicitly labeled as in-sample diagnostics. Custom feature pipelines must still avoid fitting transformations on test data.
Yes. The strategy section includes guides for SMA crossover, momentum rotation, volatility targeting and Optuna optimization, and the repository ships with 50 runnable examples across weight, order and walk-forward workflows.
Yes. That is the intended workflow: run an example, understand the signal and weighting logic, then change the universe, indicators, costs, rebalance rules or validation settings for your own research.
The library is local-first. Signals, weights, positions and reports are computed locally unless you intentionally use the hosted UI or external data services. Cloud data can feed the run without moving your research logic into someone else's engine.
Keep writing strategies in Python. QuantJourney Backtester makes the path inspectable—from data and indicators through signals, weights or orders, timing, rebalancing, costs and risk—then saves the result as local metrics, CSVs, plots and an HTML report you can review and rerun.