Skip to content

QuantWave vs TA-Lib & pandas-ta

One-page guide for teams choosing a technical-analysis stack on Polars (or migrating from pandas).

Short answer

Stay on TA-Lib or pandas-ta if you only need classic indicators in small pandas notebooks and never care about streaming parity.
Choose QuantWave if you run Polars at scale, need Ehlers DSP / price action / regimes, or want one math core for batch research and live bars without drift.

At a glance

Dimension QuantWave TA-Lib pandas-ta
Core Rust (quantwave-core) C library Pure Python (pandas)
DataFrame API Polars-native (.ta, plugins, .bt) NumPy arrays / pandas via wrappers pandas DataFrame columns
Registered indicators 230 native + metadata ~158 functions ~130 strategies
Runtime TA dependency None — all 225 are QuantWave's own Rust C TA-Lib must be installed pandas / numpy
Ehlers DSP 30+ dedicated tools Minimal A few community ports
Price action Market Structure, flags/H&S, S/R monitor Candlestick patterns only Limited
Regime detection HMM, GMM, PELT, vol clustering No No
Batch ↔ streaming parity Guaranteed (Next<T> + proptests) N/A (batch only) No
Backtest engine Built-in (sweep, WFO, Monte Carlo) No No
Large-data speed See benchmarks Fast C for classics Slow on 1M+ rows
License MIT BSD-like MIT
Migration path quantwave.talib shim + .ta names — Re-write columns to Polars .ta

Same indicator, three stacks

RSI (14) on OHLCV

import polars as pl

df = pl.read_parquet("ohlcv.parquet")
out = (
    df.lazy()
    .with_columns(pl.col("close").ta.rsi(timeperiod=14).alias("rsi"))
    .collect()
)
import talib
import pandas as pd

df = pd.read_parquet("ohlcv.parquet")
df["rsi"] = talib.RSI(df["close"].values, timeperiod=14)
import pandas as pd
import pandas_ta as ta

df = pd.read_parquet("ohlcv.parquet")
df.ta.rsi(length=14, append=True)  # adds RSI column

Takeaway: ergonomics are similar for classics. QuantWave's advantage shows on Polars lazy pipelines, multi-indicator feature matrices, and when you need the same RSI in a live stream without re-implementing warmup logic.

SuperTrend (recursive — where speed diverges)

SuperTrend is stateful bar-by-bar math. pandas-ta and naive pandas loops pay Python interpreter cost on every row; QuantWave compiles the same Next<T> path for batch plugins and streaming.

Measured throughput comparisons are being rebuilt on a reproducible harness. Until those results publish, see benchmarks for methodology and the memory measurements that are already verified.


When QuantWave wins

  • Polars is your execution engine — you want .ta and .bt on LazyFrame, not .apply() bridges from pandas.
  • Research → production parity — batch columns must match live streaming_class() output (qw.assert_parity()).
  • Beyond TA-Lib classics — Ehlers cycle tools, MQL5-style price action, regime changepoints, fractional differentiation for ML.
  • One MIT stack — indicators + backtest + metadata discovery without gluing TA-Lib + vectorbt + custom Rust.
  • Validated correctness — gold-standard vectors in quantwave-core/tests/gold_standard/, not "looks close enough."

When TA-Lib wins

  • Minimal dependency — C library + thin Python wrapper is enough; no Polars, no Rust toolchain.
  • Interop with legacy C extensions — existing systems already pass NumPy buffers to talib.*.
  • Classic set only — ~150 functions cover your roadmap; no Ehlers, PA, or backtest needs.
  • Tiny datasets — performance gap vs Rust is irrelevant below ~50k rows.

When pandas-ta wins

  • Quick pandas prototypes — one pip install, append columns in a notebook, ship a one-off analysis.
  • No Polars migration yet — team is 100% pandas and not optimizing for scale.
  • No streaming or parity requirements — research notebook never feeds a live system.
  • Familiar pandas-ta strategy names — short-lived project where rewrite cost exceeds benefit.

Migrating to QuantWave

From TA-Lib

QuantWave ships a compatibility layer for drop-in exploration:

from quantwave import talib as ta

rsi = ta.RSI(closes, timeperiod=14)
print(ta.list_functions())  # uppercase TA-Lib names in this build

For production Polars pipelines, prefer native names and metadata:

import quantwave as qw

meta = qw.metadata("rsi")
n = qw.warmup_bars("rsi", {"period": 14})

Full Python setup: Getting Started (Python).

From pandas-ta

Typical migration steps:

  1. Move data to Polars — pl.from_pandas(df) or read Parquet directly.
  2. Map strategy names — use search or qw.indicators(); many pandas-ta names map 1:1 (rsi, macd, bbands).
  3. Replace .ta.* append calls with lazy .with_columns(pl.col(...).ta.*).
  4. Verify warmup — qw.warmup_bars() and qw.assert_parity() before trusting live signals.
  5. Re-run benchmarks on your schema — benchmarks uses 1M-row OHLCV; your cardinality may differ.
# pandas-ta habit
# df.ta.sma(length=20, append=True)

# QuantWave equivalent
df = df.lazy().with_columns(
    pl.col("close").ta.sma(period=20).alias("sma_20")
).collect()

QuantWave surfaces (after you choose)

Surface Best for
pl.col("close").ta.rsi(14) Expression-plugin hot paths
lf.ta().rsi(14) Multi-column LazyFrame research
qw.streaming_class("rsi") Live bar-by-bar
lf.bt.backtest_with_report() Strategy evaluation

See Plugin vs .ta and the backtest capability matrix.


Also compared (brief)

Library Role vs QuantWave
LuxAlgo (TradingView) Pine Script indicator suite (SMC, Order Blocks, Volume Profile, Signals) Proprietary / closed Pine Script running inside TradingView (cloud-only, 5k–20k bar limits, monthly subscription). QuantWave provides open-source (MIT), bit-identical Polars & Rust implementations of equivalent market structure, SMC, Volume Profile, and session tools that process millions of bars in milliseconds.
vectorbt Vectorized portfolio backtest Stronger if backtest-only is the product; AGPL license; bring your own indicators
polars-backtest Long-format sim on Polars Simpler sim, no indicator breadth
Other Rust TA crates Fast scalar math Rarely Polars-native; no guaranteed streaming parity or PA/regime depth

Verify claims yourself

./scripts/quantwave_verify.sh
import quantwave as qw

qw.assert_parity("rsi", {"period": 14}, your_closes)
print(len(qw.indicators()), "registered names")

Full benchmarks → · Getting started → · Indicator gallery →