* feat(data-layer): TickAggregator in Node, WASM, Python + C ABI hub First data-layer feature (F2): roll trade ticks up into fixed-timeframe OHLCV candles, exposed natively and over the C ABI. - wickra-data wired as a binding dependency (workspace dep; its wickra-core dep is default-features=false so it never forces rayon into the rayon-free WASM build — native bindings re-enable parallel through their own dependency). - Node `TickAggregator(bucket, gapFill?)` -> `push(price, size, ts): Candle[]`; WASM the same (array of objects); Python `push(...) -> list[tuple]`. - C ABI: `WickraCandle` struct + `wickra_tick_aggregator_new/push/free` (push writes candles into a caller buffer and returns the count), generated via the capi generator's new DATA_LAYER section; cbindgen now parses wickra-data so `TickAggregator` is a forward-declared opaque; header vendored to bindings/go. Verified bit-identical across Node/WASM/Python/C/C++ (o=100 h=101 l=100 c=101 v=3 ts=0 for the shared 3-tick probe). WIP: Go/C#/Java/R generated bindings and the cross-language golden are still pending. * feat(data-layer): TickAggregator in Go, C#, Java, R (lossless push/drain) Complete F2 across all 10 languages: the C-ABI tick aggregator now uses a two-step push/drain so gap-fill candles are never lost, and the four generated bindings expose it idiomatically. - C ABI redesigned: opaque TickAggregator handle (inner aggregator + pending buffer); push consumes a tick and returns the closed-candle count, drain copies them into a count-sized caller buffer. - Go: NewTickAggregator + Push(price,size,ts) []Candle; C#: TickAggregator + Candle[] Push(...); Java: TickAggregator + Candle[] push(...); R: TickAggregator constructor + push() S3 generic returning an (n x 6) numeric matrix. - Candle output record generated per language from WickraCandle. Verified bit-identical to the native bindings (o=100 h=101 l=100 c=101 v=3 ts=0) in Go, C#, Java, and R at runtime; R passes R CMD check (pre-existing doc warnings only). WIP: cross-language data-layer golden + CHANGELOG still pending. * test(data-layer): cross-language golden for the tick aggregator + CHANGELOG gen_golden emits a deterministic tick stream (testdata/golden/data_ticks.csv) and the reference candle streams with and without gap filling (data_candles.csv, data_candles_gap.csv). Every binding replays the shared ticks through its TickAggregator and checks the candles bit-for-bit (fp tolerance) against the Rust reference: - Node / WASM / Python / Go / C# / Java / R: a dedicated parity test each. - C / C++: data_layer_test.c (compiled as both, run as ctest). The gap-fill fixture closes several candles from a single push, exercising the lossless push/drain path. Records the feature under CHANGELOG [Unreleased]. * fix(examples): rename the CSV-loader candle to WickraBar The example CSV helper (wickra_csv.h) defined its own struct WickraCandle, which now collides with the public C ABI WickraCandle (the tick aggregator output) in any example that includes both headers (backtest, multi_timeframe, the strategy examples). The public type owns the name; rename the example loader's bar to WickraBar. The generated golden_test.c is untouched (its only match was the unrelated WickraCandleVolumeOutput).
Wickra — Go
Streaming-first technical indicators for Go, over the Wickra C ABI hub via cgo.
Wickra is a multi-language technical-analysis library with a Rust core and bindings for Python, Node.js and WASM, plus a C ABI for C, C++, C#, Go, Java, R and any other C-capable language. Every indicator is an O(1) streaming state machine, so live trading bots and historical backtests share the exact same implementation. This package is the Go binding; it consumes the C ABI hub through cgo and exposes all 514 streaming-first indicators as idiomatic types.
Install
Use the published wickra-go module, which bundles the prebuilt C ABI
library for every platform, so go get + go build works with no extra steps
(a C compiler is still required, as the binding uses cgo):
go get github.com/wickra-lib/wickra-go
import wickra "github.com/wickra-lib/wickra-go"
wickra-go is generated from this directory by the release pipeline: it mirrors
the Go sources, the vendored C ABI header (include/wickra.h) and the prebuilt
libraries under lib/<goos>_<goarch>/. On Linux/macOS the library path is baked
in via rpath; on Windows the DLL must be discoverable at run time (next to the
executable or on PATH).
Building from this repository (contributors)
This bindings/go directory is the development source. To build it directly,
compile the C ABI and stage the library into the per-platform directory cgo
links against:
cargo build -p wickra-c --release
mkdir -p bindings/go/lib/linux_amd64 # match your GOOS_GOARCH
cp target/release/libwickra.so bindings/go/lib/linux_amd64/ # Linux
cp target/release/libwickra.dylib bindings/go/lib/darwin_arm64/ # macOS (arm64)
cp target/release/wickra.dll bindings/go/lib/windows_amd64/ # Windows
Quick start
package main
import (
"fmt"
wickra "github.com/wickra-lib/wickra/bindings/go"
)
func main() {
// Batch: run an indicator over a whole series (NaN at warmup positions).
prices := make([]float64, 1000)
for i := range prices {
prices[i] = 100.0 + float64(i)*0.1
}
sma, _ := wickra.NewSma(20)
defer sma.Close()
values := sma.Batch(prices)
// Streaming: the same indicator, fed tick by tick in O(1).
rsi, _ := wickra.NewRsi(14)
defer rsi.Close()
for _, price := range prices {
value := rsi.Update(price) // NaN during warmup, no recomputation
if value > 70 {
fmt.Println("overbought")
}
}
_ = values
}
Batch(prices) and feeding the same prices through Update() produce identical
values — the equivalence is enforced by the test suite. Multi-output indicators
(MACD, Bollinger, ADX, …) return (Output, bool), with false while warming up.
Every indicator owns a native handle freed by Close(); a finalizer is wired as
a backstop, but call Close() (e.g. with defer) to release memory promptly.
Benchmark
benchmarks/throughput.go reports streaming and batch updates-per-second for
SMA, ATR and MACD. It measures this binding's FFI overhead, not a
cross-library ratio (the same Rust core runs under every binding) — see the
repository BENCHMARKS.md §3.
cd benchmarks && go run .
Documentation
The full indicator catalogue, guides, quickstarts, and API reference live in the main repository and documentation site:
- Repository & full indicator list: https://github.com/wickra-lib/wickra
- Docs (quickstarts, cookbook, TA-Lib migration): https://docs.wickra.org
- Runnable examples:
examples/go/
Wickra ships native bindings for Python, Node.js, WASM and Rust, plus a
C ABI hub that any C-capable language (C, C++, C#, Go, Java, R) links against —
all exposing the same indicators from the shared, unsafe-forbidden Rust core.
Security
Found a security issue? Please don't open a public issue. Report it privately
via the affected repository's Security tab ("Report a vulnerability") or email
support@wickra.org with a subject line starting [wickra security]. Full
policy: https://github.com/wickra-lib/wickra/blob/main/SECURITY.md.
Disclaimer
Wickra is an indicator toolkit, not a trading system. The values it computes are deterministic transforms of the input data — they are not financial advice and do not predict the market. Any use in a live trading context is at your own risk. The library is provided as is, without warranty of any kind.
License
Licensed under either of Apache-2.0 or MIT at your option.