VectorBT PRO vs VectorBT

VectorBT PRO extends the familiar array-centered approach with time-aware validation, detailed portfolio simulation, resumable runs, trade and pattern analysis, portfolio continuation, and native Rust. These features preserve the same labeled results as the research grows. Community VectorBT covers focused research with labeled parameter grids, compiled portfolio simulation, core data adapters, and interactive analysis.

PRO is not just VectorBT with more functions or a faster simulator. Both products share array-centered ideas and familiar pandas-style conventions, but they are separate packages, releases, source trees, documentation surfaces, and licenses. Community code imports as vectorbt. PRO imports as vectorbtpro. Examples and API details are not interchangeable unless current documentation says so.

This guide compares community VectorBT 1.1.0 with VBT PRO 2026.9.5, both reviewed locally on September 19, 2026. It avoids static subscription prices because plans and commercial terms can change. Verify current individual or organization access terms before purchasing or deploying either product commercially.

VectorBT PRO vs VectorBT at a glance

What remains strong in community VectorBT

Community VectorBT is not a trial edition or an abandoned snapshot. It is actively maintained, supports an optional Rust engine, and contains the labeled array model that made the project distinctive.

An indicator can broadcast many parameters into labeled columns. Portfolio.from_signals() can simulate those columns together. Portfolio.from_orders() accepts explicit order instructions. Portfolio.from_order_func() executes custom Numba callbacks sequentially against cash and position state. Groups can share cash. Structured records become trades, positions, drawdowns, return accessors, statistics, and Plotly figures.

That already covers many local research needs, including signal studies, parameter surfaces, stop-based portfolios, multi-asset comparisons, custom compiled order logic, and result inspection. The community example simulates six moving-average combinations in one labeled portfolio with explicit fees and slippage.

Community VectorBT also has a useful data and indicator layer. Yahoo Finance, Binance, CCXT, Alpaca, synthetic generators, updates, alignment, IndicatorFactory, and optional technical-analysis parsers cover common workflows. The optional Rust extension can accelerate supported deterministic kernels behind the Python API.

The upgrade decision should begin with an actual missing capability, scale problem, or maintenance burden. Buying PRO is not required to make community VectorBT results valid, and community results are not automatically equivalent to a current PRO run when defaults or APIs differ.

PRO can add parameters almost anywhere

Community VectorBT broadcasts array inputs and indicator parameters very effectively. Parameter combinations often originate inside IndicatorFactory or helpers such as run_combs, then flow into portfolio columns.

VBT PRO generalizes parameters across the workflow. vbt.Param can mark function arguments, data objects, settings, or pipeline inputs as parameter dimensions. combine_params supports conditional spaces. Parameterized decorators execute arbitrary functions over combinations and merge results into labeled indexes. Random subsets, conditions, custom level names, selection, and lazy or staged construction make large spaces manageable.

This is a qualitative difference. A parameter can control a data source, feature transform, indicator, split rule, portfolio assumption, optimizer, cost scenario, or output calculation without every function implementing its own combination loop. The labels follow the result rather than living in an external experiment table.

Universal parameterization also exposes dependency. Some axes are independent and can be chunked. Others interact through shared cash, group state, or cached inputs and need a coordinated chunk or merge rule. PRO's registries describe how functions should slice, execute, and merge rather than assuming every column is independent.

For a six-combination indicator study, community VectorBT is often simpler. For a research graph with parameters at several layers, PRO prevents repeated custom orchestration.

Split large jobs and continue them later

Large array research usually fails on memory and orchestration before arithmetic. A grid can allocate expanded inputs, indicator outputs, signals, order records, portfolio values, metrics, and plots. Retaining every full array may be neither necessary nor possible.

VBT PRO's chunking system divides compatible inputs, applies registered slicing rules, and merges the required output. Chunk size can be fixed or determined automatically. The execution framework can run calls serially, in threads, in processes, or through distributed backends where supported. Intermediate results can be offloaded to disk and reloaded after a crash or restart.

This is more than multiprocessing. A correct chunk plan must know which inputs broadcast, which outputs concatenate, whether a shared-cash group may be split, and whether a stateful calculation depends on prior chunks. PRO integrates those contracts with parameterization, splitting, data, indicators, and portfolio functions.

Community VectorBT users can write loops, use job libraries, reduce outputs early, or split the grid manually. That is viable when the workflow is small and stable. PRO becomes useful when memory planning, distributed execution, resumability, and result merging begin to take up a substantial part of the work.

Performance still needs measurement. Numba and Rust compile on first use, process startup costs time, disk I/O can dominate, and some small tasks run fastest in one process. PRO supplies execution choices, not a universal acceleration factor.

Portfolio simulation and order rules in PRO

Community VectorBT's three main portfolio constructors cover a large range: signal arrays, explicit order arrays, and custom compiled order functions. It supports long and short trading, grouped cash, stop loss, trailing stop, take profit, fees, fixed fees, percentage slippage, size constraints, partial fills, and rejection probabilities.

PRO expands both high-level mechanics and low-level control. Signal simulation adds limit behavior, price deltas, time in force, expiry, stop ladders, duration-based stops, leverage modes, contract multipliers, cash deposits and earnings, additional conflict rules, and more record fields. Compiled hooks can run before or after rows, segments, signals, and orders. Flexible order functions can emit multiple orders per element.

Allocation simulators and optimizer outputs connect target weights and scheduled rebalancing to portfolio records. External fill-like records can be reconstructed into portfolios for common trade, drawdown, value, and metric analysis. This lets research, allocations, simulated execution, and imported executions use a common analysis model.

More controls do not create exchange realism automatically. A bar still cannot reveal queue priority or true intrabar order. A rejection probability is a scenario, not a calibrated venue model. A historical book would still not show counterfactual market response. Upgrade because the added assumptions are useful and testable, not because a longer argument list makes a result inherently realistic.

Validation beyond basic splits

Community VectorBT includes range and split primitives and has long supported manual walk-forward examples. A careful researcher can generate chronological ranges, slice data, run portfolios, and combine results.

PRO makes that workflow systematic. Splitter can construct rolling, expanding, anchored, grouped, and custom ranges. Purging and embargoing address label overlap. Combinatorial purged cross-validation constructs path families. Split decorators and application methods send arrays, data objects, indicators, functions, portfolios, and ML workflows through the same split definitions. Overlap analysis shows which periods are reused.

Cross-validation factories automate common parameter-based and model-based pipelines. Because split names remain coordinates, results can be grouped by train or test range, asset, parameter, or path without manually reconstructing provenance.

These tools are among the strongest reasons to upgrade, especially for predictive research. They help you test an idea, but they do not prove it works. A purge must match the information horizon, data preparation must fit only on training data, combinatorial paths are related, and every redesign after viewing results becomes part of the search. PRO makes careful validation easier, while its speed also makes multiple-testing bias easier to create.

Portfolio optimization and allocation research

Community VectorBT can consume any weight arrays a user creates, and ordinary Python packages can calculate those weights. What it lacks is PRO's integrated optimizer and allocation object model.

VBT PRO includes allocation, range, and portfolio-optimizer factories. It can schedule rebalancing, apply group and constraint logic, generate target weights, simulate those weights, and analyze the result. Integrations include Riskfolio-Lib, PyPortfolioOpt, Universal Portfolios, and custom optimization functions.

This matters when the research question is not simply when to enter one position, but how a changing opportunity set becomes a constrained portfolio. Parameterization can vary model assumptions, lookbacks, objectives, constraints, and rebalance schedules. Splitters can fit or evaluate those choices chronologically. Portfolio records then show realized turnover, exposures, costs, and drawdowns.

Optimization still depends on covariance estimates, expected returns, constraints, costs, and how often the same data was searched. Keeping the work together does not by itself make the estimates robust.

Data and several timeframes

Community VectorBT has a practical core of provider classes and local input support. Users can pull, update, align, and analyze several widely used sources. pandas and ordinary file or database libraries can supply everything else.

PRO broadens the data tools to more than 20 adapters and additional local stores, including SQL, Arrow, Parquet, and DuckDB. It adds caching, update, merge, transform, resample, and multi-timeframe operations. Data objects retain metadata and work with splits, parameters, chunks, and plots.

Multi-timeframe work is especially valuable because alignment errors are easy. PRO can compute or resample on one frequency and align results to another using explicit indexes and resampling rules. This reduces hand-written joins, although the researcher must still know when a higher-timeframe bar becomes complete and available.

Neither edition grants data rights or repairs bad inputs. Record source, observation time, revisions, symbol mappings, adjustment policy, missing intervals, universe membership, and time zones. More adapters increase convenience and therefore increase the need for governance.

Indicators, signals, labels, and custom factories

IndicatorFactory is a defining community feature. It wraps array functions with named inputs, parameters, outputs, caching, broadcasting, selection, and comparison helpers. Built-ins and optional third-party parsers use the same conventions.

PRO expands the catalog and the factory machinery. The current product catalog reports more than 500 indicators, signals, and labels. Parameters, chunking, execution engines, caching, statistics, plots, and streaming support can be attached at the factory level. Signal and label generators support research tasks beyond technical indicators.

The important difference is composition. A PRO indicator can participate in the same parameter indexes, split ranges, execution plan, cache, streaming accumulator, and downstream portfolio analysis. A custom calculation becomes a component in the broader system rather than only a function returning arrays.

Counts are orientation, not quality. Inspect formula, warm-up, missing-value, dtype, smoothing, and look-ahead behavior for every component. An indicator named the same in two libraries may not use the same convention.

Analysis beyond a score table

Community VectorBT already exposes structured order and log records, trades, positions, drawdowns, returns, portfolio metrics, mapped arrays, and interactive Plotly views. It is far more analytical than a backtester that returns only an equity curve.

PRO adds more detailed diagnostics. Trade analysis includes maximum adverse and favorable excursion, edge ratio, and path statistics. Signal and price-pattern tools can study what happens before or after events. Projection utilities examine forward behavior. Expanding and rolling metrics show when a statistic changes rather than only its final value. The catalog reports more than 200 metrics and more than 90 plot types.

Labeled coordinates make this depth especially useful. A researcher can ask which parameter region, split, asset, stop type, or allocation creates a drawdown. External fills can enter the same analysis objects, so simulation and observed execution records can be compared without pretending they originated in the same process.

More metrics also mean more opportunities to select a flattering story. Declare primary outcomes before inspecting a large diagnostic surface and distinguish explanation from confirmatory evidence.

Streaming indicators and portfolio continuation

Community VectorBT portfolio constructors consume a fixed historical array. Data objects can update, but portfolio state is normally rebuilt from the full selected history.

VBT PRO 2026.9.5 adds two related incremental paths. Accumulators implement rolling calculations and many indicators one observation at a time, with batch parity checks. Portfolio.update() continues major portfolio simulations across new chunks while preserving cash, positions, pending stops, record identifiers, and global row coordinates. Native Rust steppers can own indicator and portfolio state row by row.

The continuation example begins with two rows, adds two chunks, preserves a trailing-stop peak across their boundary, and produces the same order records as a one-shot simulation. This is the important property: continuation remembers earlier portfolio state rather than joining unrelated mini-backtests.

Continuation changes what the library can support inside a larger service. It avoids replaying a growing history for every new bar, can checkpoint state, and provides a testable bridge from batch research to incremental calculation.

It remains distinct from live trading. Neither edition supplies a complete broker execution, acknowledgement, external reconciliation, credential, monitoring, or recovery service. PRO provides calculations and portfolio state that a larger system can use, not a ready-made trading operation.

The Rust support is fundamentally different

Community vectorbt-rust is an optional PyO3 extension. It accelerates supported deterministic functions behind VectorBT's Python API. Automatic dispatch falls back to Numba for unsupported inputs, callbacks, and randomized operations. Forcing Rust raises if the function cannot use it. The crate is built for Python and requires PyO3 and NumPy.

PRO's vectorbtpro-rust is also available as a Python extension, but its defining capability is the standalone native crate. It builds an rlib, makes PyO3 and NumPy optional behind a python feature, and exposes public Rust builders, enums, records, strategies, simulators, and streaming steppers.

The crate mirrors the supported Numba compute surface across base operations, data generation, generic reductions, indicators, labels, OHLCV, portfolio simulation, records, returns, signals, and utilities. Arguments, defaults, validation, enums, and output contracts are designed to match, and parity tests compare the implementations.

This supports a direct path:

1. Express the strategy concisely in high-level VBT Python.
2. Move path-dependent rules into Numba callbacks while preserving labeled research.
3. Dispatch compatible kernels to Rust through Python where helpful.
4. Port the strategy to native Rust traits and compare orders and state.
5. Run a standalone binary with no Python interpreter, NumPy, pandas, or GIL.
6. Continue row by row with native steppers and persist state across restarts.

For Rust developers, this avoids replacing the research model with an unrelated live implementation. Typed builders, enums, traits, compiler errors, Rust documentation, release-matched references, and parity fixtures make a port easier to inspect and errors easier to locate. Review and deterministic tests remain necessary, but Python is optional rather than an unavoidable dependency.

If all work remains in Python and supported community Rust kernels cover the bottleneck, this capability alone may not justify PRO. If a native service, streaming state, or Rust-first team is part of the roadmap, it can be decisive.

Documentation and code assistance

Community VectorBT has public documentation, examples, API references, source, GitHub issues, and broad community material. Its core API is well covered by these public references.

PRO adds SearchVBT, ChatVBT, QuickSearch, CLI commands, direct documentation tools, and versioned Python and Rust documentation. They can retrieve current signatures, search by meaning, find examples, and expose specific library operations directly.

The value is reliable lookup across a large, fast-moving API. You can move from a question to a documented Python call, inspect the matching Rust API, and run a small test. This is particularly useful for less common features such as chunk registries, split decorators, callback contexts, continuation state, and native builders.

Research automation creates risks too. It can multiply unrecorded trials, leak future data, choose optimistic fills, or connect live credentials without adequate controls. Keep source review, test fixtures, trial logs, read-only defaults, and independent risk limits.

License and access

Community VectorBT is public and free to install, but its controlling license is Apache 2.0 with the Commons Clause. The added clause restricts selling a product or service whose value derives substantially from the software. It is more accurate to describe the package as source-available than ordinary permissive open source.

VBT PRO is proprietary. Individual and organization terms govern source access, commercial use, team access, deployment, updates, support, and redistribution. Verify the current agreement rather than relying on an old price or plan summary.

Total cost includes everything each edition leaves you to build. Community VectorBT may be cheaper when it already covers the work. PRO may be cheaper when it replaces custom parameter runs, cross-validation, chunking, data connections, portfolio optimizers, diagnostics, continuation, native Rust code, and documentation search.

Which edition fits?

Community VectorBT may be enough when most of these are true:

• the parameter grid fits memory and ordinary orchestration,
• IndicatorFactory, Portfolio.from_signals, from_orders, or from_order_func cover the strategy,
• community data adapters and standard pandas pipelines are sufficient,
• manual chronological splitting and experiment tracking are manageable,
• core trade, drawdown, return, and Plotly analysis answer the questions,
• Python remains the runtime and optional supported Rust kernels are enough, and
• the Commons Clause fits the intended use.

With VBT PRO, you can:

• keep parameter labels attached from data preparation through the final report,
• split parameter grids into chunks, run them in parallel or on distributed workers, save progress to disk, and resume after an interruption,
• use rolling, purged, embargoed, combinatorial, or automated validation splits,
• model limit orders, time-in-force, stop ladders, duration stops, leverage, contract sizes, and cash flows,
• combine portfolio allocation and optimization with simulation and analysis,
• work with data, multiple timeframes, indicators, signals, labels, metrics, and charts without joining separate tools,
• inspect MAE, MFE, edge ratio, projections, patterns, and portfolios reconstructed from external fills,
• continue calculations and portfolio simulations as new data arrives,
• run supported strategies directly in Rust without Python, and
• search documentation that matches the installed Python and Rust versions.

You do not need every feature on the list to benefit from PRO. The relevant question is whether the time saved by the features you use outweighs the access cost and learning curve.

A small test before you upgrade

Use one real research pipeline rather than comparing feature lists alone:

1. Reproduce the current community VectorBT result in PRO with identical data, signals, size, fees, slippage, grouping, and metric settings.
2. Reconcile orders, trades, cash, positions, drawdowns, and statistics before adding PRO behavior.
3. Turn the strategy parameters into labeled PRO dimensions and compare code, memory, runtime, and surface inspection.
4. Apply the chronological or purged validation design you actually need.
5. Add only one missing portfolio, data, optimizer, or analysis capability and measure removed custom code.
6. Chunk the production-size workload and interrupt and resume it to test failure recovery.
7. Continue a portfolio across chunks and verify equality with a one-shot reference.
8. If native deployment matters, port one dynamic rule to Rust and compare records order for order.
9. Use the versioned documentation to locate and implement one uncommon API, then verify the result with a small test.
10. Compare current license terms, team workflow, support value, and the maintenance cost of the code PRO would replace.

Choose PRO when you want parameter searches, time-based tests, data handling, portfolio updates, analysis, Rust programs, and documentation lookup to work together instead of maintaining separate code for each. The value is not that every basic statistic changes or every run becomes faster. It is that you can add more demanding tests without losing track of how the results were produced.