quantedge-ta

A streaming technical analysis library for Rust. Correct, tested, documented.

Features

Type-safe convergence

Indicators return Option<Self::Output>. No value until there's enough data. No silent NaN, no garbage early values. The type system enforces correctness. For indicators with infinite memory (EMA), full_convergence() reports how many bars are needed for the seed's influence to decay below 1%.

Plain-struct bar input

Indicators take &Ohlcv, a Copy struct with six public fields (open, high, low, close, open_time, volume). Build one per kline with a struct literal or a From conversion from your own kline type — no trait impl required, no generic parameters on compute.

O(1) incremental updates

Indicators maintain running state and update in constant time per tick. No re-scanning the window.

WASM compatible

Works in WebAssembly environments. The library compiles for wasm32-unknown-unknown (browser) and wasm32-wasip1 (WASI runtimes). Zero dependencies, no filesystem or OS calls in the library itself. CI verifies WASM compatibility on every commit.

Live repainting

Indicators track bar boundaries using open_time. A kline with a new open_time advances the window; same open_time replaces the current value. Useful for trading terminals and real-time systems that need indicator values on forming bars.

Typed outputs

Each indicator defines its own output type via an associated type on the Indicator trait. SMA, EMA, RSI, and ATR return f64. Bollinger Bands returns BbValue { upper, middle, lower }. MACD returns MacdValue { macd, signal, histogram }. Stochastic returns StochValue { k, d }. Stochastic RSI returns StochRsiValue { k, d }. Keltner Channel returns KcValue { upper, middle, lower }. Donchian Channel returns DcValue { upper, middle, lower }. ADX returns AdxValue { adx, plus_di, minus_di }. Ichimoku Cloud returns IchimokuValue { tenkan, kijun, senkou_a, senkou_b, chikou_close }. VWAP returns VwapValue { vwap, band_1, band_2, band_3 }. Supertrend returns SupertrendValue { value, is_bullish }. Parabolic SAR returns ParabolicSarValue { sar, is_long }. Williams %R, CCI, CHOP, and OBV return f64. No downcasting, no enums, full type safety.

Usage

use quantedge_ta::{Sma, SmaConfig};
use std::num::NonZero;

let mut sma = Sma::new(SmaConfig::close(NonZero::new(20).unwrap()));

for kline in stream {
    if let Some(value) = sma.compute(&kline) {
        println!("SMA(20): {value}");
    }
    // None = not enough data yet
}

Bollinger Bands returns a struct with public fields:

use quantedge_ta::{Bb, BbConfig};
use std::num::NonZero;

let config = BbConfig::builder()
    .length(NonZero::new(20).unwrap())
    .build();
let mut bb = Bb::new(config);

for kline in stream {
    if let Some(value) = bb.compute(&kline) {
        println!("BB upper: {}, middle: {}, lower: {}",
            value.upper, value.middle, value.lower);
    }
}

Custom standard deviation multiplier:

use quantedge_ta::{BbConfig, Multiplier};
use std::num::NonZero;

let config = BbConfig::builder()
    .length(NonZero::new(20).unwrap())
    .std_dev(Multiplier::new(1.5))
    .build();

Derive a new config from an existing one with to_builder():

use quantedge_ta::{SmaConfig, PriceSource};
use std::num::NonZero;

let sma_close = SmaConfig::close(NonZero::new(20).unwrap());

// Change only the price source, keep the same length
let sma_hl2 = sma_close.to_builder().source(PriceSource::HL2).build();

Live data with repainting:

// Open kline arrives (open_time = 1000)
sma.compute(&open_kline);    // computes with current bar

// Same bar, new trade (open_time = 1000, updated close)
sma.compute(&updated_kline); // replaces current bar value

// Next bar (open_time = 2000)
sma.compute(&next_kline);    // advances the window

The caller controls bar boundaries. The library handles the rest.

Indicator Trait

Each indicator defines its output type. No downcasting needed:

trait Indicator: Sized + Clone + Display + Debug {
    type Config: IndicatorConfig<Output = Self::Output>;
    type Output: 'static + Copy + Send + Sync + Display + Debug;

    fn new(config: Self::Config) -> Self;
    fn compute(&mut self, kline: &Ohlcv) -> Option<Self::Output>;
    fn value(&self) -> Option<Self::Output>;
}

// Sma:   Output = f64
// Ema:   Output = f64
// Rsi:   Output = f64
// Bb:    Output = BbValue { upper: f64, middle: f64, lower: f64 }
// Macd:  Output = MacdValue { macd: f64, signal: Option<f64>, histogram: Option<f64> }
// Stoch: Output = StochValue { k: f64, d: Option<f64> }
// Atr:   Output = f64
// Kc:    Output = KcValue { upper: f64, middle: f64, lower: f64 }
// Dc:    Output = DcValue { upper: f64, middle: f64, lower: f64 }
// Adx:      Output = AdxValue { adx: f64, plus_di: f64, minus_di: f64 }
// Ichimoku: Output = IchimokuValue { tenkan: f64, kijun: f64, senkou_a: f64, senkou_b: f64, chikou_close: f64 }
// WillR:    Output = f64
// Cci:      Output = f64
// Chop:      Output = f64
// StochRsi:  Output = StochRsiValue { k: f64, d: Option<f64> }
// Obv:       Output = f64
// Vwap:       Output = VwapValue { vwap: f64, band_1: Option<VwapBand>, band_2: Option<VwapBand>, band_3: Option<VwapBand> }
// Supertrend:    Output = SupertrendValue { value: f64, is_bullish: bool }
// ParabolicSar:  Output = ParabolicSarValue { sar: f64, is_long: bool }

Ohlcv Struct

Ohlcv is a plain Copy struct — build one per bar and pass it by reference to compute(). Convert from your own kline type with a field-wise copy:

use quantedge_ta::Ohlcv;

struct MyKline { o: f64, h: f64, l: f64, c: f64, v: f64, t: u64 }

impl From<&MyKline> for Ohlcv {
    fn from(k: &MyKline) -> Self {
        Ohlcv {
            open: k.o,
            high: k.h,
            low: k.l,
            close: k.c,
            volume: k.v,
            open_time: k.t,
        }
    }
}

// let bar: Ohlcv = (&my_kline).into();
// indicator.compute(&bar);

Timestamp is recommended to be microseconds since Unix epoch, monotonically increasing. This is required for the VWAP indicator, which uses timestamps to detect session boundaries. volume has no implicit default: set it to a real figure for OBV and VWAP, or 0.0 when feeding indicators that ignore it.

Convergence

Every indicator config exposes convergence() — the number of bars that compute() must process before it starts returning Some. During backtesting this defines the warm-up (seeding) phase: bars where the indicator is stabilising and should not drive trading decisions.

use quantedge_ta::{SmaConfig, RsiConfig, MacdConfig};
use std::num::NonZero;

let sma = SmaConfig::close(NonZero::new(20).unwrap());
let rsi = RsiConfig::close(NonZero::new(14).unwrap());
let macd = MacdConfig::default_close(); // MACD(12, 26, 9)

// The slowest indicator determines the warm-up length
let warmup = sma.convergence()   // 20
    .max(rsi.convergence())      // 15
    .max(macd.convergence());    // 26
// → skip the first 26 bars before acting on signals

SMA and BB converge as soon as the window fills (length bars). EMA and RSI use exponential smoothing with infinite memory; the SMA seed influences all subsequent values. RSI output begins at bar length + 1. For EMA, EmaConfig provides full_convergence() — the number of bars until the seed's contribution decays below 1% (e.g. 63 for EMA(20) = 3 × (20 + 1)).

Price Sources

Each indicator is configured with a PriceSource that determines which value to extract from the Ohlcv input:

Indicators

Benchmarks

Measured with Criterion.rs on 744 BTC/USDT 1-hour bars from Binance, split into a 349-bar warm-up seed and 395 measured bars so every group times steady-state work.

Stream measures end-to-end throughput over the 395 post-warmup bars from a pre-converged seed. Tick isolates steady-state per-bar cost on a fully converged indicator. Repaint measures single-tick repaint cost (same open_time, perturbed close) on a converged indicator. Repaint Stream measures end-to-end throughput with 3 ticks per bar (open → mid → final), 1185 total observations on a pre-converged seed.

Hardware: Apple M5 Max (18 cores), 128 GB RAM, macOS 26.4.1, rustc 1.93.1, --release profile.

Stream — process 395 post-warmup bars

Tick — single compute() on a converged indicator

Repaint — single compute() repaint on a converged indicator

Repaint Stream — process 395 bars × 3 ticks post-warmup

Run locally:

cargo bench                    # all benchmarks
cargo bench -- stream          # stream only
cargo bench -- tick            # single-tick only
cargo bench -- repaint$        # single-repaint only
cargo bench -- repaint_stream  # repaint stream only

Minimum Supported Rust Version

1.93

Licence

Licensed under either of:

• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT License (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

Contributing

Contributions welcome. Please open an issue before submitting large changes.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 licence, shall be dual-licensed as above, without any additional terms or conditions.