Files
wickra/bindings/go
kingchenc fd9f4c8bc6 feat(bindings): expose name() on every indicator in all 10 languages (#308)
* feat(bindings): expose name() on every indicator in Node, WASM, and Python

Surface the core Indicator::name() / BarBuilder::name() accessor through the
three native bindings so every indicator reports its canonical name at runtime,
matching the existing reset/isReady/warmupPeriod surface.

- Node (napi): name(): string on all 514 classes (regenerated index.d.ts)
- WASM (wasm-bindgen): name(): string on all 514 classes
- Python (pyo3): name() -> str on all classes

* feat(bindings): expose name() across the C ABI and C/C++/Go/C#/Java/R

Regenerate the C ABI and the four generated language bindings from the updated
ScriptHelpers generators so every indicator and bar builder reports its
canonical name at runtime, completing name() coverage across all 10 languages.

- C ABI (bindings/c): wickra_<ind>_name() -> *const c_char for all 514, cached
  in a per-function OnceLock<CString> with ind.name() as the source of truth;
  cbindgen header regenerated and vendored into bindings/go/include.
- Go: Name() string; C#: string Name(); Java: String name(); R: name() S3
  generic over the wk_<ind>_name C glue (methods.R + NAMESPACE).

The Java regeneration also restores two fixes that had drifted out of the
generator (bool* arrays via boolSegment; uint8_t ctor args cast to byte) and C#
re-emits '#nullable enable'; these are no-op vs the previous committed output
apart from the new name() accessors.

* test(golden): pin canonical name() across all 10 language bindings

Add a cross-language name() consistency check: every indicator must report the
exact core Indicator::name() (which can differ from the registered class name,
e.g. ChaikinMoneyFlow -> "CMF", Donchian -> "DonchianChannels"). The 514 core
names are committed as testdata/golden/names.json (keyed by Rust canonical) and
asserted by each binding's golden replay, which already reconstructs the whole
catalogue:

- node / wasm: assert against names.json in the existing golden test
- python: new test_golden_names.py over the shared node manifest
- go / csharp / java / c+c++ / r: the golden-test generators load names.json and
  emit a name assertion per indicator (regenerated test artifacts committed)

All 10 bindings return identical names by construction (each delegates to core),
so this pins that contract and guards against a future binding breaking the
passthrough.

* docs(changelog): record name() across all 10 bindings under Unreleased

* fix(r): restore bool* flag marshalling in the regenerated C glue

The name() regeneration had reverted the cross-section bool fix: the R glue
emitted (bool *)REAL(x) for const bool* inputs, reinterpreting 8-byte doubles as
1-byte bools so every flag read as false (PercentAboveMa, NewHighsNewLows,
HighLowIndex, BullishPercentIndex returned 0 instead of the breadth value). The
wk_bool_vec() helper is restored in the generator and the glue routes bool arrays
through it again.
2026-06-15 17:19:24 +02:00
..

Wickra — Go

CI codecov Go module License: MIT OR Apache-2.0

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:

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.