release: bump 0.7.5 -> 0.7.6 (#227)

Bumps the workspace to 0.7.6 to ship the C# (.NET) binding to NuGet.

.gitattributes

@@ -1,3 +1,12 @@
 # Shell scripts must keep LF line endings so they run on Linux/macOS CI and
 # local shells regardless of the committer's platform autocrlf setting.
 *.sh text eol=lf
+
+# The cbindgen-generated C header is committed; pin it to LF so its CI drift
+# check (regenerate + `git diff`) never trips on a CRLF normalization.
+bindings/c/include/wickra.h text eol=lf
+
+# C# sources (including the generated binding) are pinned to LF so the committed
+# files stay stable regardless of the committer's autocrlf setting.
+*.cs text eol=lf
+

.github/ISSUE_TEMPLATE/bug_report.md

@@ -30,9 +30,9 @@ assignees: ""
 ## Environment
 
 - Wickra version:
-- Language / binding: <!-- Rust crate / Python / Node / WASM -->
+- Language / binding: <!-- Rust crate / Python / Node / WASM / C ABI / C# (.NET) -->
 - OS and architecture:
-- Rust / Python / Node version (If relevant):
+- Rust / Python / Node / .NET version (If relevant):
 
 ## Additional context
 

.github/ISSUE_TEMPLATE/bug_report_detailed.md

@@ -26,7 +26,7 @@ assignees: []
 | Binding version      | `e.g. python 0.4.2 / node 0.4.2`       |
 | OS / arch            | `e.g. Windows 11 x86_64, Linux glibc`  |
 | Rust toolchain       | `rustc --version` (If building from source) |
-| Python / Node version | `python --version` / `node --version` |
+| Python / Node / .NET version | `python --version` / `node --version` / `dotnet --version` |
 
 ## Minimal reproducer
 

.github/ISSUE_TEMPLATE/feature_request.md

@@ -25,6 +25,8 @@ assignees: ""
 - [ ] Should be exposed in the Python binding
 - [ ] Should be exposed in the Node binding
 - [ ] Should be exposed in the WASM binding
+- [ ] Should be exposed in the C ABI
+- [ ] Should be exposed in the C# / .NET binding
 
 ## Additional context
 

.github/ISSUE_TEMPLATE/performance_regression.md

@@ -13,7 +13,7 @@ assignees: []
 ## Affected code path
 
 - Indicator / API: `e.g. EMA.update`
-- Binding: `Rust / Python / Node / Wasm`
+- Binding: `Rust / Python / Node / Wasm / C ABI / C# (.NET)`
 - Hot loop or one-shot call?
 
 ## Versions compared

.github/ISSUE_TEMPLATE/question.md

@@ -33,4 +33,4 @@ import wickra as ta
 ## Environment (Only if relevant)
 
 - Wickra version: `e.g. 0.4.2`
-- Binding: `Rust / Python / Node / Wasm`
+- Binding: `Rust / Python / Node / Wasm / C ABI / C# (.NET)`

.github/PULL_REQUEST_TEMPLATE.md

@@ -22,7 +22,7 @@
 - [ ] `cargo clippy --workspace --all-targets -- -D warnings` is clean.
 - [ ] `cargo test --workspace` passes.
 - [ ] New behaviour has tests; bug fixes have a regression test.
-- [ ] Public API changes are mirrored in the Python / Node / WASM bindings
+- [ ] Public API changes are mirrored in the Python / Node / WASM bindings, and the C ABI + C# binding are regenerated
       and their type stubs (If applicable).
 - [ ] The relevant page on the [documentation site](https://docs.wickra.org)
       and the `README.md` are updated (If applicable). Docs edits go to a

.github/PULL_REQUEST_TEMPLATE/detailed.md

@@ -23,6 +23,8 @@ Please fill in the sections below. Delete any that don't apply.
 - [ ] Python binding (`bindings/python`)
 - [ ] Node.js binding (`bindings/node`)
 - [ ] WebAssembly binding (`bindings/wasm`)
+- [ ] C ABI (`bindings/c`)
+- [ ] C# / .NET binding (`bindings/csharp`)
 - [ ] Examples / docs
 
 ## Linked issues

.github/workflows/ci.yml

@@ -622,6 +622,111 @@ jobs:
         working-directory: bindings/node
         run: node --test __tests__/
 
+  c-abi:
+    name: C ABI on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
+
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
+
+      - name: Install cbindgen
+        uses: taiki-e/install-action@0fd46367812ee04360509b4169d9f659d6892bb2 # v2.79.15
+        timeout-minutes: 10 # fail fast on a stuck download instead of hanging the job
+        with:
+          tool: cbindgen
+
+      - name: Build the C ABI library (cdylib + staticlib)
+        run: cargo build -p wickra-c --release
+
+      - name: Rust unit tests
+        run: cargo test -p wickra-c
+
+      # The generated header is platform-independent, so checking drift on one OS
+      # is enough — and avoids a spurious CRLF/LF diff on the Windows runner.
+      - name: Check the committed header is in sync with cbindgen
+        if: runner.os == 'Linux'
+        shell: bash
+        run: |
+          cbindgen --config bindings/c/cbindgen.toml --crate wickra-c --output bindings/c/include/wickra.h
+          if ! git diff --quiet -- bindings/c/include/wickra.h; then
+            echo "::error::bindings/c/include/wickra.h is out of sync — run cbindgen and commit the result"
+            git --no-pager diff -- bindings/c/include/wickra.h
+            exit 1
+          fi
+
+      # The real cross-language test: a foreign C consumer links the generated
+      # header + the compiled library and runs. If this passes on all three OSes,
+      # every C-capable language can link the same way.
+      - name: Build and run the C smoke example (CMake + ctest)
+        shell: bash
+        run: |
+          cmake -S examples/c -B examples/c/build
+          cmake --build examples/c/build --config Release
+          ctest --test-dir examples/c/build -C Release --output-on-failure
+
+  csharp:
+    name: C# on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
+
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
+
+      # The binding links against the C ABI hub at runtime; build it first so the
+      # DllImportResolver finds target/release/wickra.{dll,so,dylib}. .NET 8 SDK is
+      # preinstalled on the GitHub runners, so no setup-dotnet step is needed.
+      - name: Build the C ABI library
+        run: cargo build -p wickra-c --release
+
+      - name: .NET info
+        run: dotnet --info
+
+      - name: Test the C# binding
+        run: dotnet test bindings/csharp/Wickra.Tests/Wickra.Tests.csproj -c Release
+
+      - name: Build the C# examples
+        shell: bash
+        run: |
+          for d in streaming backtest multi_timeframe parallel_assets \
+                   strategy_rsi_mean_reversion strategy_macd_adx strategy_bollinger_squeeze \
+                   fetch_btcusdt live_binance; do
+            dotnet build "examples/csharp/$d" -c Release
+          done
+
+      # Run only the offline examples (fetch_btcusdt / live_binance need network).
+      - name: Run the offline C# examples
+        shell: bash
+        run: |
+          for d in streaming backtest multi_timeframe parallel_assets \
+                   strategy_rsi_mean_reversion strategy_macd_adx strategy_bollinger_squeeze; do
+            dotnet run --project "examples/csharp/$d" -c Release --no-build
+          done
+
   # The cross-library benchmark has moved to a dedicated scheduled workflow
   # (.github/workflows/bench.yml) — see audit finding R10. It runs nightly
   # at 03:00 UTC and on-demand via `workflow_dispatch`, and is no longer on

.github/workflows/release.yml

@@ -569,9 +569,146 @@ jobs:
   # the old "publish, then upload provenance" order would have the provenance
   # upload rejected once immutability is enabled.
   # --------------------------------------------------------------------------
+  # --------------------------------------------------------------------------
+  # C ABI native libraries (bindings/c) — built per target on a native runner
+  # (no cross toolchain needed) and attached to the GitHub Release as the
+  # distribution channel. There is no package registry for the C ABI.
+  # --------------------------------------------------------------------------
+  c-abi-build:
+    name: C ABI library (${{ matrix.target }})
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { host: ubuntu-latest, target: x86_64-unknown-linux-gnu }
+          - { host: ubuntu-24.04-arm, target: aarch64-unknown-linux-gnu }
+          - { host: macos-latest, target: x86_64-apple-darwin }
+          - { host: macos-latest, target: aarch64-apple-darwin }
+          - { host: windows-latest, target: x86_64-pc-windows-msvc }
+          - { host: windows-11-arm, target: aarch64-pc-windows-msvc }
+    runs-on: ${{ matrix.host }}
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
+        with:
+          targets: ${{ matrix.target }}
+
+      - uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
+
+      - name: Build the C ABI library (cdylib + staticlib)
+        run: cargo build -p wickra-c --release --target ${{ matrix.target }}
+
+      - name: Package header + libraries
+        shell: bash
+        run: |
+          set -e
+          dir="wickra-c-${{ matrix.target }}"
+          mkdir -p "$dir/include" "$dir/lib"
+          cp bindings/c/include/wickra.h bindings/c/include/wickra.hpp "$dir/include/"
+          for f in libwickra.so libwickra.a libwickra.dylib wickra.dll wickra.dll.lib wickra.lib; do
+            src="target/${{ matrix.target }}/release/$f"
+            [ -f "$src" ] && cp "$src" "$dir/lib/"
+          done
+          tar -czf "$dir.tar.gz" "$dir"
+          echo "packaged $dir:"; ls -lR "$dir"
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: c-abi-${{ matrix.target }}
+          path: wickra-c-${{ matrix.target }}.tar.gz
+          if-no-files-found: error
+
+  # Pack and publish the .NET binding to NuGet. Independent of the GitHub-release
+  # job so a C# hiccup never blocks the C/C++ asset release. Authentication uses
+  # NuGet Trusted Publishing (OIDC) — no long-lived API key. The 'wickra-release'
+  # trusted-publishing policy on nuget.org (owner KingchenC, repo wickra-lib/wickra,
+  # workflow release.yml) exchanges the GitHub OIDC token for a short-lived key.
+  csharp-publish:
+    name: Publish to NuGet
+    needs: c-abi-build
+    runs-on: ubuntu-latest
+    environment: release
+    permissions:
+      contents: read
+      id-token: write # request the GitHub OIDC token for trusted publishing
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Download the C ABI native libraries
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          pattern: c-abi-*
+          path: c-abi-artifacts
+
+      - name: Stage native libraries into runtimes/<rid>/native
+        shell: bash
+        run: |
+          set -e
+          declare -A RID=(
+            [x86_64-unknown-linux-gnu]=linux-x64
+            [aarch64-unknown-linux-gnu]=linux-arm64
+            [x86_64-apple-darwin]=osx-x64
+            [aarch64-apple-darwin]=osx-arm64
+            [x86_64-pc-windows-msvc]=win-x64
+            [aarch64-pc-windows-msvc]=win-arm64
+          )
+          base=bindings/csharp/Wickra/runtimes
+          for target in "${!RID[@]}"; do
+            archive=$(find c-abi-artifacts -name "wickra-c-$target.tar.gz" | head -1)
+            if [ -z "$archive" ]; then
+              echo "::error::missing native artifact for $target"; exit 1
+            fi
+            tmp=$(mktemp -d); tar -xzf "$archive" -C "$tmp"
+            dest="$base/${RID[$target]}/native"; mkdir -p "$dest"
+            for f in libwickra.so libwickra.dylib wickra.dll; do
+              src=$(find "$tmp" -name "$f" | head -1)
+              [ -n "$src" ] && cp "$src" "$dest/"
+            done
+            echo "staged ${RID[$target]}:"; ls -l "$dest"
+          done
+
+      - name: Pack
+        shell: bash
+        run: |
+          version="${GITHUB_REF_NAME#v}"
+          dotnet pack bindings/csharp/Wickra/Wickra.csproj -c Release -p:Version="$version" -o nupkg
+
+      # Exchange the GitHub OIDC token for a short-lived (~1h) NuGet API key.
+      # 'user' is the nuget.org profile name (the package owner), not an email.
+      - name: NuGet login (OIDC -> temporary API key)
+        uses: NuGet/login@8d196754b4036150537f80ac539e15c2f1028841 # v1.2.0
+        id: nuget_login
+        with:
+          user: KingchenC
+
+      # Pass the temporary key through the environment (not string-interpolated
+      # into the script) so it cannot be parsed as shell — avoids template injection.
+      - name: Push to NuGet
+        shell: bash
+        env:
+          NUGET_API_KEY: ${{ steps.nuget_login.outputs.NUGET_API_KEY }}
+        run: |
+          dotnet nuget push "nupkg/*.nupkg" --api-key "$NUGET_API_KEY" \
+            --source https://api.nuget.org/v3/index.json --skip-duplicate
+
+      - name: Upload the NuGet package as a build artifact
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: nuget-package
+          path: nupkg/*.nupkg
+          if-no-files-found: error
+
   github-release:
     name: Attach assets to the draft GitHub Release
-    needs: [cargo-publish, python-publish, node-publish, wasm-publish]
+    needs: [cargo-publish, python-publish, node-publish, wasm-publish, c-abi-build]
     runs-on: ubuntu-latest
     permissions:
       contents: write
@@ -644,7 +781,7 @@ jobs:
           # the provenance bundle is attached (P24, immutability-ready).
           draft: true
           body: |
-            Wickra ${{ github.ref_name }} — streaming-first technical indicators across 4 language registries.
+            Wickra ${{ github.ref_name }} — streaming-first technical indicators across 4 language registries plus a C ABI.
 
             ### Install
 
@@ -665,6 +802,9 @@ jobs:
               darwin-arm64, win32-x64-msvc)
             - `wickra-*.tgz` — npm-pack tarballs (main package + per-platform subpackages + WASM)
             - `*.crate` — cargo source crates (wickra-core, wickra-data, wickra)
+            - `wickra-c-<target>.tar.gz` — C ABI: `include/wickra.h` + `wickra.hpp`
+              and the cdylib/staticlib per target (linux/macos/windows × x64/arm64),
+              the hub for C / C++ / Go / C# / Java / R
 
             ### Auto-generated changelog
 

.github/workflows/sync-about.yml

@@ -9,7 +9,7 @@ name: Sync indicator count
 #   2. GitHub repo "About" description       — synced on push to main / v* tag
 #   3. Docs site: index.md / overview.md / Indicators-Overview.md
 #      (wickra-lib/wickra-docs) — synced on push to main / v* tag*
-#   4. Marketing site count (wickra-lib/webpage: index.md /
+#   4. Marketing site count (wickra-lib/webpage: index.md / about.md /
 #      .vitepress/config.ts) — push to main / v* tag*
 #   5. org profile README count (wickra-lib/.github, profile/README.md)
 #                                            — synced on push to main / v* tag*
@@ -42,10 +42,10 @@ name: Sync indicator count
 # single source of truth for what the bindings reach.
 #
 # Design: on PRs this workflow is a READ-ONLY check. The indicator wiring
-# (ScriptHelpers/_common.py wire_readme_counter) bumps both README.md and
-# docs/README.md inside the author's code commit, so the counter is already
-# correct by the time CI runs. If it is not, the check below fails loud and
-# asks the author to re-run the wiring — it never pushes a fix-up commit.
+# bumps both README.md and docs/README.md inside the author's code commit, so
+# the counter is already correct by the time CI runs. If it is not, the check
+# below fails loud and asks the author to re-run the wiring — it never pushes a
+# fix-up commit.
 #
 # (An earlier version pushed a GITHUB_TOKEN "sync indicator count" commit to
 # the PR head. Because GITHUB_TOKEN pushes trigger no workflows, that commit
@@ -149,7 +149,7 @@ jobs:
           # actually live (Cloudflare Pages, P8.1); merging this PR is therefore
           # gated on the domain resolving, otherwise the About link would 404.
           homepage="https://docs.wickra.org"
-          desc="Streaming-first technical indicators with a Rust core and Python, Node.js, and WebAssembly bindings. ${n} indicators, O(1) per-tick updates, no system dependencies. Drop-in TA-Lib replacement."
+          desc="Streaming-first technical indicators with a Rust core and Python, Node.js, WebAssembly, C ABI, and .NET bindings. ${n} indicators, O(1) per-tick updates, no system dependencies. Drop-in TA-Lib replacement."
           # Enforce the homepage unconditionally — it is a constant, so this both
           # corrects the stale kingchenc URL and self-heals any future drift.
           # Same Administration-write permission as --description (no extra scope).
@@ -366,14 +366,14 @@ jobs:
             exit 0
           fi
           cd webpage-count
-          sed -i -E "s/[0-9]+ (streaming-first )?indicators/${n} \1indicators/g" index.md .vitepress/config.ts
+          sed -i -E "s/[0-9]+ (streaming-first )?indicators/${n} \1indicators/g" index.md about.md .vitepress/config.ts
           if git diff --quiet; then
             echo "Webpage indicator count unchanged."
             exit 0
           fi
           git config user.name "wickra-bot"
           git config user.email "wickra-bot@users.noreply.github.com"
-          git add index.md .vitepress/config.ts
+          git add index.md about.md .vitepress/config.ts
           git commit -m "chore: sync indicator count to ${n}"
           if ! git push 2>/dev/null; then
             echo "::warning::push to wickra-lib/webpage failed — ABOUT_SYNC_TOKEN likely lacks write (findings P10.0a)."

ARCHITECTURE.md

@@ -27,16 +27,27 @@ or replace lives behind a separate crate boundary.
    │   no I/O, no deps    │            │  optional features │
    └──────────────────────┘            └────────────────────┘
                 ▲
-                │ (every binding wraps the same core)
-                │
-   ┌────────────┴───────────┬─────────────────────┐
-   │                        │                     │
-┌──▼──────┐         ┌───────▼──────┐      ┌───────▼────────┐
-│ Python  │         │     Node     │      │     WASM       │
-│ (PyO3)  │         │ (napi-rs)    │      │ (wasm-bindgen) │
-└─────────┘         └──────────────┘      └────────────────┘
+                │  every binding wraps the same core
+   ┌────────────┼────────────┬────────────────┐
+   │            │            │                │
+┌──▼───────┐ ┌──▼───────┐ ┌──▼───────────┐ ┌──▼──────────────────┐
+│  Python  │ │   Node   │ │     WASM     │ │  C ABI (cbindgen)   │
+│  (PyO3)  │ │ (napi-rs)│ │(wasm-bindgen)│ │   cdylib + header   │
+└──────────┘ └──────────┘ └──────────────┘ └─────────┬───────────┘
+                                                     │  linked by
+                                          ┌──────────▼──────────┐
+                                          │  C · C++ · C# · Go  │
+                                          │     · Java · R      │
+                                          └─────────────────────┘
 ```
 
+Python, Node and WASM are *native* Rust bindings (PyO3 / napi-rs /
+wasm-bindgen). The C ABI is the *hub* every other C-capable language links
+against: it builds to a `cdylib`/`staticlib` plus a generated `wickra.h`, and
+downstream languages link that one artifact rather than each re-wrapping the
+core. C and C++ link it directly; the **C# / .NET** binding (`bindings/csharp`,
+on NuGet) is generated from `wickra.h`, with Go / Java / R planned the same way.
+
 | Crate | Path | What it owns | Public deps |
 |---|---|---|---|
 | `wickra-core` | `crates/wickra-core` | every indicator, the `Indicator` trait, `BatchExt`, `Candle`/`Tick` types, `Error` | `thiserror`, `rayon` (parallel batch) |
@@ -45,6 +56,7 @@ or replace lives behind a separate crate boundary.
 | `wickra-python` | `bindings/python` | `_wickra` PyO3 module + Python package | `pyo3`, `numpy`, depends on `wickra-core` |
 | `wickra-node` | `bindings/node` | NAPI-RS native binding | `napi`, depends on `wickra-core` |
 | `wickra-wasm` | `bindings/wasm` | WebAssembly binding | `wasm-bindgen`, depends on `wickra-core` |
+| `wickra-c` | `bindings/c` | C ABI hub — `cdylib`/`staticlib` + generated `wickra.h` (cbindgen) | depends on `wickra-core` |
 | `wickra-examples` | `examples/rust` | runnable binary examples | depends on `wickra`, `wickra-data` |
 
 The `fuzz/` directory is **excluded** from the workspace (it has its own

CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.6] - 2026-06-09
+### Added
+- **C# / .NET binding (`bindings/csharp`)** — the first language stecker on the
+  C ABI hub. Exposes all 514 indicators as idiomatic `IDisposable` classes via
+  `[LibraryImport]` source-generated P/Invoke, generated from `wickra.h`. Ships
+  on NuGet as `Wickra` with prebuilt native libraries for six target triples
+  (win/linux/osx × x64/arm64), plus a full example suite mirroring the C examples.
+
+## [0.7.5] - 2026-06-09
+### Added
+- **C ABI (`bindings/c`)** — a `cdylib` + `staticlib` plus a generated
+  `include/wickra.h` exposing all 514 indicators and 10 bar builders over an
+  opaque-handle C ABI: the hub any C-capable language (C, C++, Go, C#, Java, R)
+  links against, complementing the native Python/Node/WASM bindings. Ships a
+  full example suite (streaming, backtest, multi-timeframe, OpenMP parallel
+  fan-out, three educational strategies, and Binance fetch/live over `curl`)
+  mirroring the other bindings, plus an optional `wickra.hpp` C++ RAII wrapper.
+
+## [0.7.4] - 2026-06-08
+- **Three-Line Break** — Three-line-break bars (reversal needs N-line break) (`THREE_LINE_BREAK_BARS`).
+- **Run** — Run bars (consecutive same-direction tick runs) (`RUN_BARS`).
+- **Imbalance** — Imbalance bars (tick-rule signed imbalance threshold) (`IMBALANCE_BARS`).
+- **Dollar** — Dollar bars (fixed traded value per bar, Lopez de Prado) (`DOLLAR_BARS`).
+- **Volume** — Volume bars (fixed traded volume per bar) (`VOLUME_BARS`).
+- **Tick** — Tick bars (fixed candle count per bar) (`TICK_BARS`).
+- **Range** — Range bars (fixed price-range bricks) (`RANGE_BARS`).
+
 ## [0.7.3] - 2026-06-08
 - **M2Measure** — M2 measure (Modigliani; Sharpe expressed in benchmark return units) (`M2Measure`).
 - **UpsidePotentialRatio** — Upside Potential Ratio (upside mean over downside deviation) (`UpsidePotentialRatio`).
@@ -1407,7 +1434,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   optional Binance live feed.
 - Bindings for Python, Node.js, and WebAssembly.
 
-[Unreleased]: https://github.com/wickra-lib/wickra/compare/v0.7.3...HEAD
+[Unreleased]: https://github.com/wickra-lib/wickra/compare/v0.7.6...HEAD
+[0.7.6]: https://github.com/wickra-lib/wickra/compare/v0.7.5...v0.7.6
+[0.7.5]: https://github.com/wickra-lib/wickra/compare/v0.7.4...v0.7.5
+[0.7.4]: https://github.com/wickra-lib/wickra/compare/v0.7.3...v0.7.4
 [0.7.3]: https://github.com/wickra-lib/wickra/compare/v0.7.2...v0.7.3
 [0.7.2]: https://github.com/wickra-lib/wickra/compare/v0.7.1...v0.7.2
 [0.7.1]: https://github.com/wickra-lib/wickra/compare/v0.7.0...v0.7.1

CONTRIBUTING.md

@@ -21,6 +21,8 @@ licensed as above, without any additional terms or conditions.
 | `bindings/python` | PyO3 bindings (`wickra` on PyPI). |
 | `bindings/node` | napi-rs bindings (`wickra` on npm). |
 | `bindings/wasm` | wasm-bindgen bindings (`wickra-wasm` on npm). |
+| `bindings/c` | C ABI — `cdylib` + `staticlib` + generated `include/wickra.h`. The hub for C / C++ and any C-capable language. |
+| `bindings/csharp` | .NET binding over the C ABI (`Wickra` on NuGet) — `[LibraryImport]` P/Invoke generated from `wickra.h`. |
 | `examples/` | Runnable examples. |
 | `docs/` | Pointer to the documentation site (docs.wickra.org); the docs live in the `wickra-lib/wickra-docs` repo. |
 
@@ -102,7 +104,10 @@ installed. Dependabot also keeps the `.github/requirements` pins current.
 - **Streaming parity.** An indicator's `batch` output must equal the sequence
   of `update` calls.
 - **Bindings.** A change to a public indicator API must be mirrored across the
-  Python, Node, and WASM bindings, including their type stubs / `.d.ts`.
+  Python, Node, and WASM bindings, including their type stubs / `.d.ts`. The C ABI
+  (`bindings/c`) is generated from the core, so regenerate it from the core and
+  commit `src/lib.rs` + `include/wickra.h`. The C# binding (`bindings/csharp`) is
+  generated from `wickra.h`, so regenerate and commit its `Generated/*.g.cs` too.
 - **Docs.** Update the relevant page on the
   [documentation site](https://docs.wickra.org) and the
   `README.md` when behaviour or the public API changes. The docs live in

Cargo.lock

@@ -1944,7 +1944,7 @@ dependencies = [
 
 [[package]]
 name = "wickra"
-version = "0.7.3"
+version = "0.7.6"
 dependencies = [
  "approx",
  "criterion",
@@ -1955,7 +1955,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-bench"
-version = "0.7.3"
+version = "0.7.6"
 dependencies = [
  "criterion",
  "kand",
@@ -1965,9 +1965,16 @@ dependencies = [
  "yata",
 ]
 
+[[package]]
+name = "wickra-c"
+version = "0.7.6"
+dependencies = [
+ "wickra-core",
+]
+
 [[package]]
 name = "wickra-core"
-version = "0.7.3"
+version = "0.7.6"
 dependencies = [
  "approx",
  "proptest",
@@ -1977,7 +1984,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-data"
-version = "0.7.3"
+version = "0.7.6"
 dependencies = [
  "approx",
  "csv",
@@ -1994,7 +2001,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-examples"
-version = "0.7.3"
+version = "0.7.6"
 dependencies = [
  "serde_json",
  "tokio",
@@ -2004,7 +2011,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-node"
-version = "0.7.3"
+version = "0.7.6"
 dependencies = [
  "napi",
  "napi-build",
@@ -2014,7 +2021,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-python"
-version = "0.7.3"
+version = "0.7.6"
 dependencies = [
  "numpy",
  "pyo3",
@@ -2023,7 +2030,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-wasm"
-version = "0.7.3"
+version = "0.7.6"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

Cargo.toml

@@ -7,13 +7,14 @@ members = [
     "bindings/python",
     "bindings/wasm",
     "bindings/node",
+    "bindings/c",
     "examples/rust",
     "crates/wickra-bench",
 ]
 exclude = ["fuzz"]
 
 [workspace.package]
-version = "0.7.3"
+version = "0.7.6"
 authors = ["kingchenc <support@wickra.org>"]
 edition = "2021"
 rust-version = "1.86"
@@ -25,7 +26,7 @@ keywords = ["finance", "trading", "indicators", "technical-analysis", "ta"]
 categories = ["finance", "mathematics", "science"]
 
 [workspace.dependencies]
-wickra-core = { path = "crates/wickra-core", version = "0.7.3" }
+wickra-core = { path = "crates/wickra-core", version = "0.7.6" }
 
 thiserror = "2"
 rayon = "1.10"

README.md

@@ -1,25 +1,27 @@
 <p align="center">
-  <a href="https://wickra.org"><img src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/wickra-banner.webp?v=507" alt="Wickra — streaming-first technical indicators" width="100%"></a>
+  <a href="https://wickra.org"><img src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/wickra-banner.webp?v=514" alt="Wickra — streaming-first technical indicators" width="100%"></a>
 </p>
 
-[![CI](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
-[![CodeQL](https://github.com/wickra-lib/wickra/actions/workflows/codeql.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/codeql.yml)
-[![codecov](https://codecov.io/gh/wickra-lib/wickra/branch/main/graph/badge.svg)](https://codecov.io/gh/wickra-lib/wickra)
-[![GitHub release](https://img.shields.io/github/v/release/wickra-lib/wickra?logo=github&color=green)](https://github.com/wickra-lib/wickra/releases/latest)
-[![crates.io](https://img.shields.io/crates/v/wickra.svg?logo=rust&color=orange)](https://crates.io/crates/wickra)
-[![PyPI](https://img.shields.io/pypi/v/wickra.svg?logo=pypi&color=blue)](https://pypi.org/project/wickra/)
-[![npm](https://img.shields.io/npm/v/wickra.svg?logo=npm&color=red)](https://www.npmjs.com/package/wickra)
-[![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT_OR_Apache--2.0-blue)](#license)
-[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/wickra-lib/wickra/badge)](https://scorecard.dev/viewer/?uri=github.com/wickra-lib/wickra)
-[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/13094/badge)](https://www.bestpractices.dev/projects/13094)
-[![Build provenance](https://img.shields.io/badge/provenance-attested-brightgreen?logo=github)](https://github.com/wickra-lib/wickra/attestations)
-[![Docs](https://img.shields.io/badge/docs-docs.wickra.org-0ea5e9?logo=readthedocs&logoColor=white)](https://docs.wickra.org)
+[![CI](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/ci.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
+[![CodeQL](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/codeql.svg)](https://github.com/wickra-lib/wickra/actions/workflows/codeql.yml)
+[![codecov](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/codecov.svg)](https://codecov.io/gh/wickra-lib/wickra)
+[![GitHub release](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/release.svg)](https://github.com/wickra-lib/wickra/releases/latest)
+[![crates.io](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/crates.svg)](https://crates.io/crates/wickra)
+[![PyPI](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/pypi.svg)](https://pypi.org/project/wickra/)
+[![npm](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/npm.svg)](https://www.npmjs.com/package/wickra)
+[![NuGet](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/nuget.svg)](https://www.nuget.org/packages/Wickra)
+[![License: MIT OR Apache-2.0](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/license.svg)](#license)
+[![OpenSSF Scorecard](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/scorecard.svg)](https://scorecard.dev/viewer/?uri=github.com/wickra-lib/wickra)
+[![OpenSSF Best Practices](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/best-practices.svg)](https://www.bestpractices.dev/projects/13094)
+[![Build provenance](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/provenance.svg)](https://github.com/wickra-lib/wickra/attestations)
+[![Docs](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/docs.svg)](https://docs.wickra.org)
 
 **Streaming-first technical indicators. Install with `pip install wickra` — no system dependencies.**
 
 Wickra is a multi-language technical-analysis library with a Rust core and
-bindings for Python, Node.js, and WebAssembly. Every indicator is a state
-machine that updates in O(1) per new data point, so live trading bots and
+native bindings for Python, Node.js and WebAssembly, plus a C ABI that C, C++,
+C# / .NET and any other C-capable language links against. Every indicator is a
+state machine that updates in O(1) per new data point, so live trading bots and
 historical backtests share the exact same implementation.
 
 ```python
@@ -46,9 +48,11 @@ Full documentation lives at **[docs.wickra.org](https://docs.wickra.org)**:
 - **Quickstarts** — [Rust](https://docs.wickra.org/Quickstart-Rust),
   [Python](https://docs.wickra.org/Quickstart-Python),
   [Node](https://docs.wickra.org/Quickstart-Node),
-  [WASM](https://docs.wickra.org/Quickstart-WASM).
+  [WASM](https://docs.wickra.org/Quickstart-WASM),
+  [C](https://docs.wickra.org/Quickstart-C),
+  [C#](https://docs.wickra.org/Quickstart-CSharp).
 - **Indicators** — a per-indicator deep dive (formula, parameters, warmup) for
-  every one of the 507 indicators; start at the
+  every one of the 514 indicators; start at the
   [indicators overview](https://docs.wickra.org/Indicators-Overview).
 - **Reference** — [warmup periods](https://docs.wickra.org/Warmup-Periods),
   [streaming vs batch](https://docs.wickra.org/Streaming-vs-Batch),
@@ -66,18 +70,19 @@ an afterthought — **live, tick-by-tick data** — without giving up the breadt
 a full batch library, and without making you reimplement your indicators four
 times to get there.
 
-- **The biggest streaming-native catalogue, period.** 507 indicators across 24
+- **The biggest streaming-native catalogue, period.** 514 indicators across 24
   families — candlesticks, harmonic & chart patterns, market profile, market
   breadth, Renko/Kagi/Point&Figure bars, Ehlers DSP cycles, risk/performance
   metrics — every single one updating in **O(1) per tick**. TA-Lib ships ~150 and
   none of them stream.
-- **One Rust core, four first-class targets.** Native **Python · Node.js ·
-  WebAssembly · Rust** — identical math, identical results, zero per-language
-  reimplementation and zero GIL bottleneck.
+- **One Rust core, five first-class targets.** Native **Python · Node.js ·
+  WebAssembly · Rust** plus a **C ABI** for C / C++, C# / .NET and any other C-capable language —
+  identical math, identical results, zero per-language reimplementation and zero
+  GIL bottleneck.
 - **Correct by construction, not by hope.** Every `update` validates its input,
   runs a real warmup, and returns an `Option` so a single bad tick can't silently
   poison state. `batch == streaming` is **bit-exact, fuzzed and 100 %-line-covered
-  for all 507 indicators**.
+  for all 514 indicators**.
 - **Orders of magnitude faster where it counts.** In streaming Wickra is **11–56×**
   faster than the only other incremental peer and **thousands of times** faster
   than recompute-on-every-tick libraries. On batch it wins several rows outright
@@ -95,7 +100,8 @@ Every other library forces one of those compromises. Wickra doesn't:
 
 | Library          | Install     | Streaming   | Languages                   | Indicators | Active |
 |------------------|-------------|-------------|-----------------------------|-----------:|--------|
-| **★&nbsp;Wickra**| **clean**   | **yes, O(1)** | **Python · Node · WASM · Rust** | **507** | **yes** |
+| **★&nbsp;Wickra**| **clean**   | **yes, O(1)** | **Rust · Python · Node · WASM** | **514** | **yes** |
+|                  |             |               | **C · C#**                      |            |        |
 | kand             | clean       | yes         | Python · WASM · Rust        |       ~60  | yes    |
 | ta-rs            | clean       | yes         | Rust only                   |       ~30  | stale  |
 | yata             | clean       | partial     | Rust only                   |       ~35  | yes    |
@@ -128,7 +134,7 @@ Full tables (Rust + Python, streaming + batch) and how to reproduce them live in
 
 ## Indicators
 
-507 streaming-first indicators across twenty-four families. Every one passes the
+514 streaming-first indicators across twenty-four families. Every one passes the
 `batch == streaming` equivalence test, reference-value tests, and reset
 semantics tests. Each has a per-indicator deep dive (formula, parameters,
 warmup) at [docs.wickra.org](https://docs.wickra.org/Indicators-Overview).
@@ -148,7 +154,7 @@ warmup) at [docs.wickra.org](https://docs.wickra.org/Indicators-Overview).
 | Pivots & S/R         | Classic Pivots, Fibonacci Pivots, Camarilla, Woodie Pivots, DeMark Pivots, Williams Fractals, ZigZag, Central Pivot Range, Murrey Math Lines, Andrews Pitchfork, Volume-Weighted Support/Resistance, Pivot Reversal |
 | DeMark               | TD Setup, TD Sequential, TD DeMarker, TD REI, TD Pressure, TD Combo, TD Countdown, TD Lines, TD Range Projection, TD Differential, TD Open, TD Risk Level, TD Camouflage, TD Clop, TD Clopwin, TD Propulsion, TD Trap, TD D-Wave, TD Moving Averages |
 | Ichimoku & Charts    | Ichimoku Kinko Hyo (Tenkan, Kijun, Senkou A/B, Chikou), Heikin-Ashi, Heikin-Ashi Oscillator, Three Line Break, Smoothed Heikin-Ashi, Equivolume, CandleVolume |
-| Alt-Chart Bars       | Renko (box-size bricks), Kagi (reversal-amount lines), Point & Figure (X/O columns) |
+| Alt-Chart Bars       | Renko (box-size bricks), Kagi (reversal-amount lines), Point & Figure (X/O columns), Range, Tick, Volume, Dollar, Imbalance, Run, Three-Line Break |
 | Candlestick Patterns | Doji, Hammer, Inverted Hammer, Hanging Man, Shooting Star, Engulfing, Harami, Morning/Evening Star, Three White Soldiers/Black Crows, Piercing Line/Dark Cloud Cover, Marubozu, Tweezer, Spinning Top, Three Inside Up/Down, Three Outside Up/Down, Two Crows, Upside Gap Two Crows, Identical Three Crows, Three Line Strike, Three Stars in the South, Abandoned Baby, Advance Block, Belt-hold, Breakaway, Counterattack, Doji Star, Dragonfly Doji, Gravestone Doji, Long-Legged Doji, Rickshaw Man, Evening Doji Star, Morning Doji Star, Gap Side-by-Side White, High-Wave, Hikkake, Modified Hikkake, Homing Pigeon, On-Neck, In-Neck, Thrusting, Separating Lines, Kicking, Kicking by Length, Ladder Bottom, Mat Hold, Matching Low, Long Line, Short Line, Rising Three Methods, Falling Three Methods, Upside Gap Three Methods, Downside Gap Three Methods, Stalled Pattern, Stick Sandwich, Takuri, Closing Marubozu, Opening Marubozu, Tasuki Gap, Unique Three River, Concealing Baby Swallow, Tristar, Harami Cross, Tower Top/Bottom, Dumpling Top, New Price Lines, Frying Pan Bottom |
 | Chart Patterns       | Double Top / Bottom, Triple Top / Bottom, Head and Shoulders, Triangle (asc/desc/sym), Wedge (rising/falling), Flag / Pennant, Rectangle / Range, Cup and Handle |
 | Harmonic Patterns    | AB=CD, Gartley, Butterfly, Bat, Crab, Shark, Cypher, Three Drives |
@@ -166,8 +172,9 @@ as one column each. `Doji` is direction-less by default (`+1.0` / `0.0`);
 construct it in signed mode (`Doji::new().signed()`, `Doji(signed=True)`,
 `new Doji(true)`) for a dragonfly / gravestone `±1` reading.
 
-Adding a new indicator means implementing one trait in Rust; all four bindings
-inherit it automatically.
+Adding a new indicator means implementing one trait in Rust; every binding
+inherits it automatically (the C ABI — and the C# binding generated from it —
+regenerate from the core).
 
 ## Languages
 
@@ -177,12 +184,15 @@ inherit it automatically.
 | Node.js (napi-rs) | `npm install wickra`                          | `examples/node/backtest.js` |
 | Browser / WASM    | `npm install wickra-wasm`                     | `examples/wasm/index.html` |
 | Rust              | `cargo add wickra`                            | `examples/rust/src/bin/backtest.rs` |
+| C / C++ (C ABI)   | header + library, see [`bindings/c`](bindings/c) | `examples/c/streaming.c` |
+| C# / .NET (C ABI) | `dotnet add package Wickra`, see [`bindings/csharp`](bindings/csharp) | `examples/csharp/streaming` |
 
 Each binding ships several runnable examples (streaming, backtest, live feed);
 [`examples/README.md`](examples/README.md) is the full cross-language index.
 
-The wickra-core crate is `unsafe`-forbidden, so every binding inherits a
-memory-safe implementation.
+The wickra-core crate is `unsafe`-forbidden, so the native bindings are
+memory-safe end to end. The C ABI runs the same safe core; only its thin FFI
+boundary uses `unsafe`, and the caller owns handle lifetimes (`_new` / `_free`).
 
 ## Rust API
 
@@ -237,20 +247,24 @@ A Python live-trading example using the public `websockets` package lives at
 ```
 wickra/
 ├── crates/
-│   ├── wickra-core/         core engine + all 507 indicators
+│   ├── wickra-core/         core engine + all 514 indicators
 │   ├── wickra/              top-level facade crate (publishes on crates.io) + benches/
 │   ├── wickra-data/         CSV reader, tick aggregator, live exchange feeds
 │   └── wickra-bench/        internal cross-library benchmark harness (not published)
 ├── bindings/
 │   ├── python/              PyO3 + maturin (publishes on PyPI)
 │   ├── node/                napi-rs (publishes on npm)
-│   └── wasm/                wasm-bindgen (browsers, bundlers, Node)
+│   ├── wasm/                wasm-bindgen (browsers, bundlers, Node)
+│   ├── c/                   C ABI (cdylib + staticlib) + generated include/wickra.h
+│   └── csharp/              .NET binding over the C ABI (publishes on NuGet)
 ├── examples/                examples/README.md indexes every language
 │   ├── data/                real BTCUSDT OHLCV datasets, one per timeframe
 │   ├── rust/                Rust workspace member (`wickra-examples`)
 │   ├── python/              backtest, live trading, parallel assets, multi-tf
 │   ├── node/                streaming, backtest, live trading (load `wickra`)
-│   └── wasm/                browser demo for `wickra-wasm`
+│   ├── wasm/                browser demo for `wickra-wasm`
+│   ├── c/                   C smoke + streaming, C++ RAII wrapper
+│   └── csharp/              streaming, backtest, strategies (load `Wickra`)
 └── .github/workflows/       CI and release pipelines
 ```
 
@@ -278,6 +292,14 @@ wasm-pack build bindings/wasm --target web --release --features panic-hook
 
 # Node binding (requires @napi-rs/cli)
 cd bindings/node && npm install && npm run build && npm test
+
+# C ABI (cdylib + staticlib + generated header)
+cargo build -p wickra-c --release
+cmake -S examples/c -B examples/c/build -DWICKRA_LIB_DIR="$PWD/target/release"
+cmake --build examples/c/build && ctest --test-dir examples/c/build --output-on-failure
+
+# C# / .NET binding (requires the .NET 8 SDK; links the C ABI above)
+dotnet test bindings/csharp/Wickra.Tests/Wickra.Tests.csproj
 ```
 
 ## Testing

ROADMAP.md

@@ -21,8 +21,9 @@ minor releases; breaking changes are called out in the changelog.
   versioning stability for a 1.0 release.
 - **Performance.** Keep per-tick updates O(1) and maintain the benchmark suite;
   investigate further allocation and cache improvements.
-- **Bindings parity.** Keep the Python, Node.js and WebAssembly bindings in
-  lockstep with the Rust core, including type stubs and platform coverage.
+- **Bindings parity.** Keep the Python, Node.js and WebAssembly bindings — plus
+  the C ABI and the C# / .NET binding generated from it — in lockstep with the
+  Rust core, including type stubs and platform coverage.
 - **Documentation.** Maintain a deep-dive page per indicator on
   <https://docs.wickra.org>, plus quickstarts and cookbook material.
 - **Project health.** Maintain test coverage, static and dynamic analysis,

SECURITY.md

@@ -58,7 +58,11 @@ artifacts, and (4) a healthy dependency supply chain.
 
 - *Memory safety* — the core and all bindings are written in Rust. The crates
   forbid or minimise `unsafe`, so the compiler guarantees memory and thread
-  safety for the indicator logic.
+  safety for the indicator logic. The one exception is the C ABI
+  ([`bindings/c`](bindings/c)), whose thin FFI shim is necessarily `unsafe`
+  because it dereferences caller-supplied pointers; it adds no indicator logic,
+  validates every handle for NULL, and never lets a panic cross the boundary, so
+  the safe core's guarantees still cover all computation.
 - *Input robustness* — every indicator validates its parameters and rejects
   non-finite inputs at construction; behaviour on edge cases (flat markets,
   warmup, reset) is pinned by unit tests, and the public update paths are

SUPPORT.md

@@ -7,8 +7,8 @@ Thanks for using Wickra! Here is where to get help, depending on what you need.
 Most questions are answered in the documentation:
 
 - **Docs site:** <https://docs.wickra.org> — quickstarts for Rust, Python,
-  Node.js and WebAssembly, a per-indicator reference, warmup periods, the data
-  layer, and an FAQ.
+  Node.js, WebAssembly, C and C#, a per-indicator reference, warmup periods, the
+  data layer, and an FAQ.
 - **README:** <https://github.com/wickra-lib/wickra#readme> — installation and a
   quick overview.
 - **API docs (Rust):** <https://docs.rs/wickra>.

THREAT_MODEL.md

@@ -3,8 +3,10 @@
 This document describes Wickra's attack surface and the threats considered,
 together with their mitigations. It complements the security assurance case in
 [`SECURITY.md`](SECURITY.md). Wickra is a computational technical-analysis
-library (a Rust core with Python, Node.js and WebAssembly bindings), not a
-network service or trading system; the attack surface is correspondingly small.
+library (a Rust core with Python, Node.js and WebAssembly bindings plus a C ABI
+and the .NET binding built on it),
+not a network service or trading system; the attack surface is correspondingly
+small.
 
 ## Assets
 
@@ -31,6 +33,7 @@ network service or trading system; the attack surface is correspondingly small.
 | Threat | Mitigation |
 | --- | --- |
 | Memory-safety exploit (buffer overflow, UAF) via crafted input | Pure safe Rust; `unsafe` is forbidden/minimised, so the compiler precludes these classes. |
+| Misuse of the C ABI FFI boundary (invalid/dangling handle, undersized batch buffer) | The C ABI (`bindings/c`) is the sole `unsafe` surface. Its shim adds no logic, NULL-checks every handle (returning `NaN`/no-op), writes only into caller-sized buffers, and catches panics so none cross the boundary. A caller passing a non-NULL but dangling pointer is undefined behaviour by C's own contract — out of scope, the same as any C library. |
 | Denial of service via malformed/degenerate input (NaN, infinities, extreme magnitudes) | Indicators reject non-finite inputs and validate parameters at construction; update paths are exercised by coverage-guided fuzzing and unit tests for edge cases. |
 | Silently incorrect results | 100% line coverage on the core crate; reference-value tests against known-good sources; streaming/batch parity tests. |
 | Integer overflow / panics | `clippy::pedantic` with `-D warnings`; debug assertions and overflow checks enabled in test/fuzz builds. |

bindings/c/Cargo.toml

@@ -0,0 +1,46 @@
+[package]
+name = "wickra-c"
+description = "C ABI (cdylib + staticlib) for the Wickra streaming-first technical indicators library — the hub every C-capable language (C, C++, Go, C#, Java, R) links against."
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+readme = "README.md"
+keywords.workspace = true
+categories.workspace = true
+publish = false
+
+[lib]
+name = "wickra"
+crate-type = ["cdylib", "staticlib"]
+
+# The C ABI inherently needs `unsafe` (raw pointers across the FFI boundary,
+# `#[export_name]` symbol control). The workspace forbids `unsafe_code`, so this
+# crate cannot inherit `workspace = true`; it mirrors every workspace lint and
+# only relaxes `unsafe_code` to `allow` (parity with how the proc-macro bindings
+# emit their unsafe). The Rust core stays `unsafe`-forbidden — this is the one
+# crate where the boundary lives.
+[lints.rust]
+unsafe_code = "allow"
+missing_debug_implementations = "warn"
+unreachable_pub = "warn"
+unused_must_use = "deny"
+
+[lints.clippy]
+all = { level = "warn", priority = -1 }
+pedantic = { level = "warn", priority = -1 }
+module_name_repetitions = "allow"
+must_use_candidate = "allow"
+missing_errors_doc = "allow"
+missing_panics_doc = "allow"
+cast_precision_loss = "allow"
+cast_possible_truncation = "allow"
+cast_sign_loss = "allow"
+similar_names = "allow"
+float_cmp = "allow"
+
+[dependencies]
+wickra-core = { workspace = true }

bindings/c/README.md

@@ -0,0 +1,80 @@
+# Wickra — C / C++
+
+[![CI](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/wickra-lib/wickra/branch/main/graph/badge.svg)](https://codecov.io/gh/wickra-lib/wickra)
+[![GitHub release](https://img.shields.io/github/v/release/wickra-lib/wickra?logo=github&color=green)](https://github.com/wickra-lib/wickra/releases/latest)
+[![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT_OR_Apache--2.0-blue)](https://github.com/wickra-lib/wickra#license)
+
+**Streaming-first technical indicators for C and C++. A prebuilt shared/static
+library plus a generated `wickra.h` — no system dependencies.**
+
+Wickra is a multi-language technical-analysis library with a Rust core and
+bindings for Python, Node.js and WebAssembly, plus a C ABI for C/C++, C# 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 **C ABI hub**: it compiles the
+core to a C-compatible shared/static library plus a generated header, so any
+C-capable language (C, C++, Go, C#, Java, R) links against one artifact instead
+of re-wrapping every indicator natively.
+
+## Install
+
+Grab the prebuilt header + library for your platform from the
+[GitHub releases](https://github.com/wickra-lib/wickra/releases) — each archive
+has `wickra.h`, the optional `wickra.hpp` C++ wrapper, and the shared/static
+library — or build from source:
+
+```bash
+cargo build -p wickra-c --release
+# -> target/release/libwickra.{so,dylib} or wickra.dll (+ import lib) + a staticlib
+```
+
+Then compile against the header and link the library
+(`cc app.c -I include -L lib -lwickra -lm -o app`).
+
+## Quick start
+
+```c
+#include "wickra.h"
+
+struct Rsi *rsi = wickra_rsi_new(14);              /* NULL on invalid params */
+for (size_t i = 0; i < n; ++i) {
+    double v = wickra_rsi_update(rsi, prices[i]);  /* NaN during warmup       */
+    if (v == v && v > 70.0)                        /* v == v is the NaN check */
+        printf("overbought\n");
+}
+wickra_rsi_free(rsi);                              /* exactly once per _new   */
+```
+
+Every indicator is an opaque handle with the same five functions —
+`_new` / `_update` / `_batch` / `_reset` / `_free`. `update` is O(1); there is no
+RAII across the C boundary, so each `_new` needs exactly one `_free`, and every
+function is NULL-safe (a NULL handle yields `NaN` or a no-op, never a crash).
+Multi-output indicators (MACD, Bollinger, ADX, …) take a pointer to a `#[repr(C)]`
+struct and return a `bool`. The optional `wickra.hpp` wraps any handle in a
+move-only `wickra::Handle` for exception-safe C++ lifetimes.
+
+## 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** (C quickstart, cookbook, TA-Lib migration): <https://docs.wickra.org/Quickstart-C>
+- **Runnable examples:** [`examples/c/`](https://github.com/wickra-lib/wickra/tree/main/examples/c)
+
+Wickra ships native bindings for Python, Node.js, WebAssembly and Rust, plus this
+C ABI hub that any C-capable language (C, C++, Go, C#, Java, R) links against —
+all exposing the same indicators from the shared Rust core.
+
+## 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](https://github.com/wickra-lib/wickra/blob/main/LICENSE-APACHE)
+or [MIT](https://github.com/wickra-lib/wickra/blob/main/LICENSE-MIT) at your option.

bindings/c/cbindgen.toml

@@ -0,0 +1,20 @@
+language = "C"
+header = "/* Wickra C ABI — generated by cbindgen. Do not edit by hand. */"
+include_guard = "WICKRA_H"
+pragma_once = true
+# Wrap the declarations in `extern "C"` under __cplusplus so the header is usable
+# from C++ (the optional wickra.hpp RAII layer and any C++ consumer).
+cpp_compat = true
+tab_width = 4
+# Off: cbindgen copies the Rust struct/fn doc comments verbatim, and some core
+# indicator docs contain markdown (e.g. `**1/8**/**7/8**`) whose `*/` would close
+# the C block comment early and break the header. Usage docs live in the crate
+# README and examples; the header is a pure declaration contract.
+documentation = false
+
+[parse]
+# Parse wickra-core too so the opaque indicator handle types (Sma, Ema, …) are
+# discovered and emitted as forward-declared opaque structs. Their fields are
+# never exposed — only `T *` handles cross the boundary.
+parse_deps = true
+include = ["wickra-core"]

bindings/c/include/wickra.hpp

@@ -0,0 +1,66 @@
+// Optional C++ convenience layer over the Wickra C ABI (`wickra.h`).
+//
+// The C ABI hands out raw handles that must be released exactly once with the
+// matching `wickra_<ind>_free`. `wickra::Handle` wraps that in a move-only RAII
+// owner so the free happens automatically at scope exit:
+//
+//     #include "wickra.hpp"
+//
+//     wickra::Handle<Sma, wickra_sma_free> sma(wickra_sma_new(14));
+//     if (sma) {
+//         double v = wickra_sma_update(sma.get(), 42.0);  // NaN during warmup
+//     }
+//     // sma is freed here
+//
+// This is header-only and adds no runtime cost beyond the C calls themselves.
+
+#ifndef WICKRA_HPP
+#define WICKRA_HPP
+
+#include "wickra.h"
+
+#include <utility>
+
+namespace wickra {
+
+/// Move-only RAII owner of a Wickra handle. `T` is the opaque indicator type and
+/// `Free` its `wickra_<ind>_free` function.
+template <typename T, void (*Free)(T *)>
+class Handle {
+public:
+    explicit Handle(T *ptr) noexcept : ptr_(ptr) {}
+
+    ~Handle() {
+        if (ptr_ != nullptr) {
+            Free(ptr_);
+        }
+    }
+
+    Handle(const Handle &) = delete;
+    Handle &operator=(const Handle &) = delete;
+
+    Handle(Handle &&other) noexcept : ptr_(std::exchange(other.ptr_, nullptr)) {}
+
+    Handle &operator=(Handle &&other) noexcept {
+        if (this != &other) {
+            if (ptr_ != nullptr) {
+                Free(ptr_);
+            }
+            ptr_ = std::exchange(other.ptr_, nullptr);
+        }
+        return *this;
+    }
+
+    /// The raw handle, for passing to the `wickra_<ind>_*` functions.
+    T *get() const noexcept { return ptr_; }
+
+    /// True if the handle is non-null (construction succeeded).
+    explicit operator bool() const noexcept { return ptr_ != nullptr; }
+
+private:
+    T *ptr_;
+};
+
+}  // namespace wickra
+
+#endif  // WICKRA_HPP

bindings/csharp/.gitignore

@@ -0,0 +1,12 @@
+# .NET build output
+bin/
+obj/
+*.user
+
+# NuGet packaging output
+*.nupkg
+*.snupkg
+
+# Native libraries staged for packaging (produced by the release pipeline from
+# the wickra-c-<triple>.tar.gz assets; never committed to source).
+Wickra/runtimes/

bindings/csharp/README.md

@@ -0,0 +1,78 @@
+# Wickra — .NET
+
+[![CI](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/wickra-lib/wickra/branch/main/graph/badge.svg)](https://codecov.io/gh/wickra-lib/wickra)
+[![NuGet](https://img.shields.io/nuget/v/Wickra.svg?logo=nuget&color=blue)](https://www.nuget.org/packages/Wickra)
+[![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT_OR_Apache--2.0-blue)](https://github.com/wickra-lib/wickra#license)
+
+**Streaming-first technical indicators for .NET. `dotnet add package Wickra` —
+prebuilt native library, no system dependencies.**
+
+Wickra is a multi-language technical-analysis library with a Rust core and
+bindings for Python, Node.js and WebAssembly, plus a C ABI for C/C++, C# 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 .NET binding; it consumes the
+C ABI hub through `[LibraryImport]` P/Invoke and exposes all 514 streaming-first
+indicators as idiomatic `IDisposable` classes.
+
+## Install
+
+```bash
+dotnet add package Wickra
+```
+
+The native library ships prebuilt per platform (Linux, macOS, Windows — x64 and
+arm64) under `runtimes/<rid>/native/`, selected automatically. There is nothing
+to compile. Targets .NET 8 and later.
+
+## Quick start
+
+```csharp
+using Wickra;
+
+// Batch: run an indicator over a whole series (NaN at warmup positions).
+var prices = Enumerable.Range(0, 1000).Select(i => 100.0 + i * 0.1).ToArray();
+using var sma = new Sma(20);
+double[] values = sma.Batch(prices);
+
+// Streaming: the same indicator, fed tick by tick in O(1).
+using var rsi = new Rsi(14);
+foreach (var price in liveFeed)
+{
+    var value = rsi.Update(price); // NaN during warmup, no recomputation
+    if (double.IsFinite(value) && value > 70)
+    {
+        Console.WriteLine("overbought");
+    }
+}
+```
+
+`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 a nullable `record struct`, `null` while warming up.
+
+## 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/csharp/`](https://github.com/wickra-lib/wickra/tree/main/examples/csharp)
+
+Wickra ships native bindings for Python, Node.js, WebAssembly and Rust, plus a
+C ABI hub that any C-capable language (C, C++, Go, C#, Java, R) links against —
+all exposing the same indicators from the shared, `unsafe`-forbidden Rust core.
+
+## 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](https://github.com/wickra-lib/wickra/blob/main/LICENSE-APACHE)
+or [MIT](https://github.com/wickra-lib/wickra/blob/main/LICENSE-MIT) at your option.

bindings/csharp/Wickra.Tests/ArchetypeTests.cs

@@ -0,0 +1,144 @@
+using Wickra;
+using Xunit;
+
+namespace Wickra.Tests;
+
+/// <summary>
+/// One representative per FFI archetype, exercising every marshalling path the
+/// generator produces (scalar, candle, pairwise, multi-output, bars, profile,
+/// values-profile, array-input). Garbage marshalling surfaces as NaN, wild
+/// values, or crashes — so finite/sane assertions are the real check.
+/// </summary>
+public class ArchetypeTests
+{
+    private static (double open, double high, double low, double close, double volume, long ts) Candle(int i)
+    {
+        var close = 100.0 + 10.0 * Math.Sin(i * 0.3);
+        var open = 100.0 + 10.0 * Math.Sin((i - 1) * 0.3);
+        var high = Math.Max(open, close) + 1.0;
+        var low = Math.Min(open, close) - 1.0;
+        return (open, high, low, close, 1_000.0, i * 60_000L);
+    }
+
+    [Fact]
+    public void Scalar_Ema_IsFiniteAfterWarmup()
+    {
+        using var ema = new Ema(3);
+        double last = double.NaN;
+        for (var i = 1; i <= 10; i++)
+        {
+            last = ema.Update(i);
+        }
+
+        Assert.True(double.IsFinite(last));
+        Assert.InRange(last, 1.0, 10.0);
+    }
+
+    [Fact]
+    public void Candle_Atr_IsFinitePositive()
+    {
+        using var atr = new Atr(3);
+        double last = double.NaN;
+        for (var i = 0; i < 20; i++)
+        {
+            var (o, h, l, c, v, ts) = Candle(i);
+            last = atr.Update(o, h, l, c, v, ts);
+        }
+
+        Assert.True(double.IsFinite(last));
+        Assert.True(last > 0.0);
+    }
+
+    [Fact]
+    public void Pairwise_Beta_IsFinite()
+    {
+        using var beta = new Beta(5);
+        double last = double.NaN;
+        for (var i = 0; i < 30; i++)
+        {
+            var market = 100.0 + 10.0 * Math.Sin(i * 0.5);
+            var asset = 50.0 + 6.0 * Math.Sin(i * 0.5 + 0.2);
+            last = beta.Update(market, asset);
+        }
+
+        Assert.True(double.IsFinite(last));
+    }
+
+    [Fact]
+    public void MultiOutput_Adx_ReturnsFiniteStruct()
+    {
+        using var adx = new Adx(5);
+        AdxOutput? result = null;
+        for (var i = 0; i < 60; i++)
+        {
+            var (o, h, l, c, v, ts) = Candle(i);
+            result = adx.Update(o, h, l, c, v, ts);
+        }
+
+        Assert.NotNull(result);
+        Assert.True(double.IsFinite(result!.Value.Adx));
+        Assert.True(double.IsFinite(result.Value.PlusDi));
+        Assert.True(double.IsFinite(result.Value.MinusDi));
+    }
+
+    [Fact]
+    public void Bars_DollarBars_EmitsBars()
+    {
+        using var bars = new DollarBars(5_000.0);
+        var total = 0;
+        for (var i = 0; i < 200; i++)
+        {
+            var (o, h, l, c, v, ts) = Candle(i);
+            total += bars.Update(o, h, l, c, v, ts).Length;
+        }
+
+        Assert.True(total > 0);
+    }
+
+    [Fact]
+    public void Profile_VolumeProfile_ReturnsValues()
+    {
+        using var profile = new VolumeProfile(20, 8);
+        VolumeProfileOutputScalars? result = null;
+        for (var i = 0; i < 60; i++)
+        {
+            var (o, h, l, c, v, ts) = Candle(i);
+            result = profile.Update(o, h, l, c, v, ts);
+        }
+
+        Assert.NotNull(result);
+        Assert.NotNull(result!.Value.Values);
+        Assert.True(result.Value.PriceLow <= result.Value.PriceHigh);
+    }
+
+    [Fact]
+    public void ProfileValues_DayOfWeekProfile_NoCrash()
+    {
+        using var profile = new DayOfWeekProfile(0);
+        double[]? result = null;
+        for (var i = 0; i < 60; i++)
+        {
+            var close = 100.0 + 5.0 * Math.Sin(i * 0.2);
+            // one day apart so the day-of-week buckets fill
+            result = profile.Update(close, close + 1, close - 1, close, 1_000.0, i * 86_400_000L);
+        }
+
+        if (result is not null)
+        {
+            Assert.All(result, v => Assert.True(double.IsFinite(v)));
+        }
+    }
+
+    [Fact]
+    public void ArrayInput_DepthSlope_IsFinite()
+    {
+        using var slope = new DepthSlope();
+        ReadOnlySpan<double> bidPrice = stackalloc double[] { 99.0, 98.0, 97.0 };
+        ReadOnlySpan<double> bidSize = stackalloc double[] { 10.0, 20.0, 30.0 };
+        ReadOnlySpan<double> askPrice = stackalloc double[] { 101.0, 102.0, 103.0 };
+        ReadOnlySpan<double> askSize = stackalloc double[] { 12.0, 22.0, 32.0 };
+
+        var result = slope.Update(bidPrice, bidSize, askPrice, askSize);
+        Assert.True(double.IsFinite(result));
+    }
+}

bindings/csharp/Wickra.Tests/SmaTests.cs

@@ -0,0 +1,51 @@
+using Wickra;
+using Xunit;
+
+namespace Wickra.Tests;
+
+public class SmaTests
+{
+    [Fact]
+    public void StreamingMatchesReference()
+    {
+        using var sma = new Sma(3);
+        Assert.True(double.IsNaN(sma.Update(1)));
+        Assert.True(double.IsNaN(sma.Update(2)));
+        Assert.Equal(2.0, sma.Update(3), 9);
+        Assert.Equal(3.0, sma.Update(4), 9);
+        Assert.Equal(4.0, sma.Update(5), 9);
+    }
+
+    [Fact]
+    public void BatchMatchesStreaming()
+    {
+        using var sma = new Sma(3);
+        var output = sma.Batch(new double[] { 1, 2, 3, 4, 5 });
+
+        Assert.True(double.IsNaN(output[0]));
+        Assert.True(double.IsNaN(output[1]));
+        Assert.Equal(2.0, output[2], 9);
+        Assert.Equal(3.0, output[3], 9);
+        Assert.Equal(4.0, output[4], 9);
+    }
+
+    [Fact]
+    public void ResetClearsState()
+    {
+        using var sma = new Sma(3);
+        sma.Update(1);
+        sma.Update(2);
+        sma.Update(3);
+        sma.Reset();
+        Assert.True(double.IsNaN(sma.Update(10)));
+    }
+
+    [Fact]
+    public void ZeroPeriodThrows()
+    {
+        // Zero is rejected by the native constructor (returns NULL) -> ArgumentException;
+        // a negative period is caught earlier by the wrapper guard.
+        Assert.Throws<ArgumentException>(() => new Sma(0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Sma(-1));
+    }
+}

bindings/csharp/Wickra.Tests/Wickra.Tests.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Wickra\Wickra.csproj" />
+  </ItemGroup>
+
+</Project>

bindings/csharp/Wickra/Wickra.csproj

@@ -0,0 +1,57 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <RootNamespace>Wickra</RootNamespace>
+    <AssemblyName>Wickra</AssemblyName>
+
+    <!-- NuGet package metadata -->
+    <PackageId>Wickra</PackageId>
+    <Version>0.7.6</Version>
+    <Authors>kingchenc</Authors>
+    <Description>High-performance streaming technical-analysis indicators (514 indicators) for .NET, backed by the native Rust core via the Wickra C ABI.</Description>
+    <PackageLicenseExpression>MIT OR Apache-2.0</PackageLicenseExpression>
+    <PackageProjectUrl>https://github.com/wickra-lib/wickra</PackageProjectUrl>
+    <RepositoryUrl>https://github.com/wickra-lib/wickra</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
+    <PackageTags>technical-analysis;indicators;trading;finance;streaming;ffi;native</PackageTags>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+    <IncludeSymbols>true</IncludeSymbols>
+    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <!-- A managed package carrying per-RID native assets; not built per-RID itself. -->
+    <IncludeBuildOutput>true</IncludeBuildOutput>
+    <!-- NU5128: managed package carrying only per-RID native assets.
+         CS1591: generated members are self-descriptive; hand-written API is documented. -->
+    <NoWarn>$(NoWarn);NU5128;CS1591</NoWarn>
+  </PropertyGroup>
+
+  <!--
+    Supported native runtime identifiers. The release pipeline builds the C ABI
+    per target triple and stages the libraries under
+    Wickra/runtimes/<rid>/native/ before `dotnet pack`:
+      win-x64   win-arm64   linux-x64   linux-arm64   osx-x64   osx-arm64
+  -->
+  <PropertyGroup>
+    <WickraRuntimeIdentifiers>win-x64;win-arm64;linux-x64;linux-arm64;osx-x64;osx-arm64</WickraRuntimeIdentifiers>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="..\README.md" Pack="true" PackagePath="\" />
+  </ItemGroup>
+
+  <!--
+    Native libraries are packed under runtimes/<rid>/native/ by the release pipeline,
+    which unpacks the wickra-c-<triple>.tar.gz assets into the matching RID folders.
+    For local development and tests the natives are resolved from the cargo target dir
+    via WickraNative's DllImportResolver.
+  -->
+  <ItemGroup>
+    <None Include="runtimes/**/native/*" Pack="true" PackagePath="runtimes" Condition="Exists('runtimes')" />
+  </ItemGroup>
+
+</Project>

bindings/csharp/Wickra/WickraHandle.cs

@@ -0,0 +1,26 @@
+using Microsoft.Win32.SafeHandles;
+
+namespace Wickra;
+
+/// <summary>
+/// Owns an opaque native indicator handle and releases it via the indicator's
+/// <c>_free</c> function. One generic handle type backs every indicator; the
+/// correct free routine is captured at construction time.
+/// </summary>
+internal sealed class WickraHandle : SafeHandleZeroOrMinusOneIsInvalid
+{
+    private readonly Action<nint> _free;
+
+    internal WickraHandle(nint handle, Action<nint> free)
+        : base(ownsHandle: true)
+    {
+        _free = free;
+        SetHandle(handle);
+    }
+
+    protected override bool ReleaseHandle()
+    {
+        _free(handle);
+        return true;
+    }
+}

bindings/csharp/Wickra/WickraNative.cs

@@ -0,0 +1,87 @@
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Wickra;
+
+/// <summary>
+/// Native library resolution for the Wickra C ABI.
+/// </summary>
+/// <remarks>
+/// When consumed as a NuGet package the native library ships under
+/// <c>runtimes/&lt;rid&gt;/native/</c> and the default runtime resolver finds it
+/// automatically. For local development (project reference against a cargo build)
+/// the resolver additionally walks up the directory tree to locate
+/// <c>target/release</c> or <c>target/debug</c>. Every candidate is validated to
+/// actually export the Wickra ABI before it is accepted, so an unrelated library
+/// of the same name cannot shadow the real one.
+/// </remarks>
+internal static class WickraNative
+{
+    /// <summary>The library name passed to <c>[LibraryImport]</c>.</summary>
+    internal const string LibraryName = "wickra";
+
+    // Any exported symbol works as a fingerprint; sma_new exists in every build.
+    private const string SentinelSymbol = "wickra_sma_new";
+
+    [ModuleInitializer]
+    internal static void Register()
+    {
+        NativeLibrary.SetDllImportResolver(typeof(WickraNative).Assembly, Resolve);
+    }
+
+    private static nint Resolve(string libraryName, System.Reflection.Assembly assembly, DllImportSearchPath? searchPath)
+    {
+        if (libraryName != LibraryName)
+        {
+            return nint.Zero;
+        }
+
+        // 1. Default resolution (NuGet runtimes/ layout, app-local copies). Accept
+        //    only if it is genuinely the Wickra ABI; otherwise discard and fall through.
+        if (NativeLibrary.TryLoad(libraryName, assembly, searchPath, out var handle))
+        {
+            if (Exports(handle))
+            {
+                return handle;
+            }
+
+            NativeLibrary.Free(handle);
+        }
+
+        // 2. Development fallback: locate the cargo build output.
+        var fileName = NativeFileName();
+        var dir = AppContext.BaseDirectory;
+        for (var i = 0; i < 16 && dir is not null; i++)
+        {
+            foreach (var profile in new[] { "release", "debug" })
+            {
+                var candidate = Path.Combine(dir, "target", profile, fileName);
+                if (File.Exists(candidate) && NativeLibrary.TryLoad(candidate, out var devHandle))
+                {
+                    if (Exports(devHandle))
+                    {
+                        return devHandle;
+                    }
+
+                    NativeLibrary.Free(devHandle);
+                }
+            }
+
+            dir = Path.GetDirectoryName(dir.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar));
+        }
+
+        return nint.Zero;
+    }
+
+    private static bool Exports(nint handle) => NativeLibrary.TryGetExport(handle, SentinelSymbol, out _);
+
+    private static string NativeFileName()
+    {
+        if (OperatingSystem.IsWindows())
+        {
+            return "wickra.dll";
+        }
+
+        return OperatingSystem.IsMacOS() ? "libwickra.dylib" : "libwickra.so";
+    }
+}

bindings/node/README.md

@@ -9,7 +9,8 @@
 prebuilt native binary, no system dependencies.**
 
 Wickra is a multi-language technical-analysis library with a Rust core and
-bindings for Python, Node.js, and WebAssembly. Every indicator is an O(1)
+bindings for Python, Node.js and WebAssembly, plus a C ABI for C/C++, C# 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 Node.js binding (napi-rs);
 it exposes 200+ streaming-first indicators across sixteen families.
@@ -55,8 +56,9 @@ the main repository and documentation site:
 - **Docs** (quickstarts, cookbook, TA-Lib migration): <https://docs.wickra.org>
 - **Runnable examples:** [`examples/node/`](https://github.com/wickra-lib/wickra/tree/main/examples/node)
 
-Wickra ships four bindings — Python, Node.js, WebAssembly, and Rust — that all
-expose the same indicators from the shared, `unsafe`-forbidden Rust core.
+Wickra ships native bindings for Python, Node.js, WebAssembly and Rust, plus a
+C ABI hub that any C-capable language (C, C++, Go, C#, Java, R) links against —
+all exposing the same indicators from the shared, `unsafe`-forbidden Rust core.
 
 ## Disclaimer
 

bindings/node/__tests__/completeness.test.js

@@ -14,7 +14,18 @@ const wickra = require('..');
 // but intentionally not isReady/warmupPeriod, so they are excluded from the
 // Indicator completeness contract below (their interface is covered by the
 // dedicated bar-builder tests).
-const BAR_BUILDERS = new Set(['RenkoBars', 'KagiBars', 'PointAndFigureBars']);
+const BAR_BUILDERS = new Set([
+  'RenkoBars',
+  'KagiBars',
+  'PointAndFigureBars',
+  'RangeBars',
+  'TickBars',
+  'VolumeBars',
+  'DollarBars',
+  'ImbalanceBars',
+  'RunBars',
+  'ThreeLineBreakBars',
+]);
 
 // An "indicator class" is an exported constructor whose prototype carries the
 // streaming `update` method. This excludes `version` (a plain function), the bar

bindings/node/__tests__/indicators.test.js

@@ -1769,3 +1769,72 @@ test('PointAndFigureBars closes a column on a 3-box reversal', () => {
   assert.equal(col[0].direction, 1);
   assert.ok(Math.abs(col[0].high - 15) < 1e-9 && Math.abs(col[0].low - 10) < 1e-9);
 });
+
+test('RangeBars prints aligned bars on an up move', () => {
+  const rb = new wickra.RangeBars(1.0);
+  assert.deepEqual(rb.update(10), []); // seed
+  const up = rb.update(13);
+  assert.equal(up.length, 3);
+  assert.ok(Math.abs(up[0].open - 10) < 1e-9 && Math.abs(up[2].close - 13) < 1e-9);
+  assert.ok(up.every((b) => b.direction === 1));
+});
+
+test('TickBars groups a fixed number of candles', () => {
+  const tb = new wickra.TickBars(2);
+  assert.deepEqual(tb.update(10, 11, 9, 10.5, 100), []);
+  const out = tb.update(10.5, 12, 10, 11, 150);
+  assert.equal(out.length, 1);
+  assert.ok(Math.abs(out[0].open - 10) < 1e-9);
+  assert.ok(Math.abs(out[0].high - 12) < 1e-9);
+  assert.ok(Math.abs(out[0].low - 9) < 1e-9);
+  assert.ok(Math.abs(out[0].close - 11) < 1e-9);
+  assert.ok(Math.abs(out[0].volume - 250) < 1e-9);
+});
+
+test('VolumeBars closes when accumulated volume crosses the threshold', () => {
+  const vb = new wickra.VolumeBars(100);
+  assert.deepEqual(vb.update(10, 10, 10, 10, 60), []);
+  const out = vb.update(10.5, 10.5, 10.5, 10.5, 60);
+  assert.equal(out.length, 1);
+  assert.ok(Math.abs(out[0].volume - 120) < 1e-9);
+});
+
+test('DollarBars closes when traded value crosses the threshold', () => {
+  const db = new wickra.DollarBars(1000);
+  assert.deepEqual(db.update(10, 10, 10, 10, 60), []);
+  const out = db.update(10, 10, 10, 10, 60);
+  assert.equal(out.length, 1);
+  assert.ok(Math.abs(out[0].dollar - 1200) < 1e-9);
+  assert.ok(Math.abs(out[0].volume - 120) < 1e-9);
+});
+
+test('ImbalanceBars closes a buy bar at the threshold', () => {
+  const ib = new wickra.ImbalanceBars(3.0);
+  ib.update(10, 10, 10, 10);
+  ib.update(11, 11, 11, 11);
+  ib.update(12, 12, 12, 12);
+  const out = ib.update(13, 13, 13, 13);
+  assert.equal(out.length, 1);
+  assert.equal(out[0].direction, 1);
+  assert.ok(Math.abs(out[0].imbalance - 3) < 1e-9);
+});
+
+test('RunBars closes a buy run at the run length', () => {
+  const rb = new wickra.RunBars(3);
+  rb.update(10, 10, 10, 10);
+  rb.update(11, 11, 11, 11);
+  rb.update(12, 12, 12, 12);
+  const out = rb.update(13, 13, 13, 13);
+  assert.equal(out.length, 1);
+  assert.equal(out[0].direction, 1);
+  assert.equal(out[0].length, 3);
+});
+
+test('ThreeLineBreakBars draws a rising line', () => {
+  const tlb = new wickra.ThreeLineBreakBars(3);
+  assert.deepEqual(tlb.update(10), []); // seed
+  const out = tlb.update(11);
+  assert.equal(out.length, 1);
+  assert.equal(out[0].direction, 1);
+  assert.ok(Math.abs(out[0].open - 10) < 1e-9 && Math.abs(out[0].close - 11) < 1e-9);
+});

bindings/node/index.d.ts

@@ -468,6 +468,54 @@ export interface PnfColumnValue {
   high: number
   low: number
 }
+export interface RangeBarValue {
+  open: number
+  close: number
+  direction: number
+}
+export interface TickBarValue {
+  open: number
+  high: number
+  low: number
+  close: number
+  volume: number
+}
+export interface VolumeBarValue {
+  open: number
+  high: number
+  low: number
+  close: number
+  volume: number
+}
+export interface DollarBarValue {
+  open: number
+  high: number
+  low: number
+  close: number
+  volume: number
+  dollar: number
+}
+export interface ImbalanceBarValue {
+  open: number
+  high: number
+  low: number
+  close: number
+  imbalance: number
+  direction: number
+}
+export interface RunBarValue {
+  open: number
+  high: number
+  low: number
+  close: number
+  length: number
+  direction: number
+}
+export interface LineBreakBarValue {
+  open: number
+  close: number
+  direction: number
+}
 export interface SessionHighLowValue {
   high: number
   low: number
@@ -5028,6 +5076,62 @@ export declare class PointAndFigureBars {
   reversal(): number
   reset(): void
 }
+export type RangeBarsNode = RangeBars
+export declare class RangeBars {
+  constructor(range: number)
+  update(close: number): Array<RangeBarValue>
+  batch(close: Array<number>): Array<RangeBarValue>
+  range(): number
+  reset(): void
+}
+export type TickBarsNode = TickBars
+export declare class TickBars {
+  constructor(ticks: number)
+  update(open: number, high: number, low: number, close: number, volume: number): Array<TickBarValue>
+  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<TickBarValue>
+  ticks(): number
+  reset(): void
+}
+export type VolumeBarsNode = VolumeBars
+export declare class VolumeBars {
+  constructor(volumePerBar: number)
+  update(open: number, high: number, low: number, close: number, volume: number): Array<VolumeBarValue>
+  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<VolumeBarValue>
+  volumePerBar(): number
+  reset(): void
+}
+export type DollarBarsNode = DollarBars
+export declare class DollarBars {
+  constructor(dollarPerBar: number)
+  update(open: number, high: number, low: number, close: number, volume: number): Array<DollarBarValue>
+  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<DollarBarValue>
+  dollarPerBar(): number
+  reset(): void
+}
+export type ImbalanceBarsNode = ImbalanceBars
+export declare class ImbalanceBars {
+  constructor(threshold: number)
+  update(open: number, high: number, low: number, close: number): Array<ImbalanceBarValue>
+  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<ImbalanceBarValue>
+  threshold(): number
+  reset(): void
+}
+export type RunBarsNode = RunBars
+export declare class RunBars {
+  constructor(runLength: number)
+  update(open: number, high: number, low: number, close: number): Array<RunBarValue>
+  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<RunBarValue>
+  runLength(): number
+  reset(): void
+}
+export type ThreeLineBreakBarsNode = ThreeLineBreakBars
+export declare class ThreeLineBreakBars {
+  constructor(lines: number)
+  update(close: number): Array<LineBreakBarValue>
+  batch(close: Array<number>): Array<LineBreakBarValue>
+  lines(): number
+  reset(): void
+}
 export type AlphaNode = Alpha
 export declare class Alpha {
   constructor(period: number, riskFree: number)

bindings/node/npm/darwin-arm64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wickra-darwin-arm64",
-  "version": "0.7.3",
+  "version": "0.7.6",
   "description": "Native binding for wickra (macOS Apple Silicon). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.darwin-arm64.node",
   "files": [

bindings/node/npm/darwin-x64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wickra-darwin-x64",
-  "version": "0.7.3",
+  "version": "0.7.6",
   "description": "Native binding for wickra (macOS Intel). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.darwin-x64.node",
   "files": [

bindings/node/npm/linux-arm64-gnu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wickra-linux-arm64-gnu",
-  "version": "0.7.3",
+  "version": "0.7.6",
   "description": "Native binding for wickra (linux arm64 GNU). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.linux-arm64-gnu.node",
   "files": [

bindings/node/npm/linux-x64-gnu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wickra-linux-x64-gnu",
-  "version": "0.7.3",
+  "version": "0.7.6",
   "description": "Native binding for wickra (linux x64 GNU). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.linux-x64-gnu.node",
   "files": [

bindings/node/npm/win32-arm64-msvc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wickra-win32-arm64-msvc",
-  "version": "0.7.3",
+  "version": "0.7.6",
   "description": "Native binding for wickra (Windows arm64 MSVC). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.win32-arm64-msvc.node",
   "files": [

bindings/node/npm/win32-x64-msvc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wickra-win32-x64-msvc",
-  "version": "0.7.3",
+  "version": "0.7.6",
   "description": "Native binding for wickra (Windows x64 MSVC). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.win32-x64-msvc.node",
   "files": [

bindings/node/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "wickra",
-  "version": "0.7.3",
+  "version": "0.7.6",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "wickra",
-      "version": "0.7.3",
+      "version": "0.7.6",
       "license": "MIT OR Apache-2.0",
       "devDependencies": {
         "@napi-rs/cli": "^2.18.0"
@@ -15,12 +15,12 @@
         "node": ">= 18"
       },
       "optionalDependencies": {
-        "wickra-darwin-arm64": "0.7.3",
-        "wickra-darwin-x64": "0.7.3",
-        "wickra-linux-arm64-gnu": "0.7.3",
-        "wickra-linux-x64-gnu": "0.7.3",
-        "wickra-win32-arm64-msvc": "0.7.3",
-        "wickra-win32-x64-msvc": "0.7.3"
+        "wickra-darwin-arm64": "0.7.6",
+        "wickra-darwin-x64": "0.7.6",
+        "wickra-linux-arm64-gnu": "0.7.6",
+        "wickra-linux-x64-gnu": "0.7.6",
+        "wickra-win32-arm64-msvc": "0.7.6",
+        "wickra-win32-x64-msvc": "0.7.6"
       }
     },
     "node_modules/@napi-rs/cli": {
@@ -41,8 +41,8 @@
       }
     },
     "node_modules/wickra-darwin-arm64": {
-      "version": "0.7.3",
-      "resolved": "https://registry.npmjs.org/wickra-darwin-arm64/-/wickra-darwin-arm64-0.7.3.tgz",
+      "version": "0.7.6",
+      "resolved": "https://registry.npmjs.org/wickra-darwin-arm64/-/wickra-darwin-arm64-0.7.6.tgz",
       "integrity": "sha512-4eZiBR/yGUdr4nzhEUFy2i69XgNx64iI2ax/LPamsThgylC0KpHOZKK19QzJ2d9KbK4C8nMjME5FLuR+4GNEwQ==",
       "cpu": [
         "arm64"
@@ -57,8 +57,8 @@
       }
     },
     "node_modules/wickra-darwin-x64": {
-      "version": "0.7.3",
-      "resolved": "https://registry.npmjs.org/wickra-darwin-x64/-/wickra-darwin-x64-0.7.3.tgz",
+      "version": "0.7.6",
+      "resolved": "https://registry.npmjs.org/wickra-darwin-x64/-/wickra-darwin-x64-0.7.6.tgz",
       "integrity": "sha512-6hf8zI3QPjTFp4zCpmgUwDvNtu6jHqNUHKD5e55POo0CgA52HkpyxSPtVm8TGTIZDI7kPjlbOdBM8CJ76mmXwA==",
       "cpu": [
         "x64"
@@ -73,8 +73,8 @@
       }
     },
     "node_modules/wickra-linux-arm64-gnu": {
-      "version": "0.7.3",
-      "resolved": "https://registry.npmjs.org/wickra-linux-arm64-gnu/-/wickra-linux-arm64-gnu-0.7.3.tgz",
+      "version": "0.7.6",
+      "resolved": "https://registry.npmjs.org/wickra-linux-arm64-gnu/-/wickra-linux-arm64-gnu-0.7.6.tgz",
       "integrity": "sha512-kSe6y0xBMSiqdPLXNjwop5WZdHtvdBNKSEBCwZ4hFq33p4apW25/wrlzv9/oDuyD4kuPabJEhCCnFOplh58CUg==",
       "cpu": [
         "arm64"
@@ -89,8 +89,8 @@
       }
     },
     "node_modules/wickra-linux-x64-gnu": {
-      "version": "0.7.3",
-      "resolved": "https://registry.npmjs.org/wickra-linux-x64-gnu/-/wickra-linux-x64-gnu-0.7.3.tgz",
+      "version": "0.7.6",
+      "resolved": "https://registry.npmjs.org/wickra-linux-x64-gnu/-/wickra-linux-x64-gnu-0.7.6.tgz",
       "integrity": "sha512-tWBWS4qz7hxM4xnpFb59bhf6TaLwXq0Z3jEa/2l7r8PiHA94g8r8S53NRMiT+4yiL5hSWe/nUiC/YXdRrhEZ4g==",
       "cpu": [
         "x64"
@@ -105,8 +105,8 @@
       }
     },
     "node_modules/wickra-win32-arm64-msvc": {
-      "version": "0.7.3",
-      "resolved": "https://registry.npmjs.org/wickra-win32-arm64-msvc/-/wickra-win32-arm64-msvc-0.7.3.tgz",
+      "version": "0.7.6",
+      "resolved": "https://registry.npmjs.org/wickra-win32-arm64-msvc/-/wickra-win32-arm64-msvc-0.7.6.tgz",
       "integrity": "sha512-EXIckHxAtF75PUGDKRzXyqMe9ldP0JjSdu68WFN6iJfp+McYrGu6h40TEJlQ/oUEIoPqiZB/xhVyo/el5Lg7zw==",
       "cpu": [
         "arm64"
@@ -121,8 +121,8 @@
       }
     },
     "node_modules/wickra-win32-x64-msvc": {
-      "version": "0.7.3",
-      "resolved": "https://registry.npmjs.org/wickra-win32-x64-msvc/-/wickra-win32-x64-msvc-0.7.3.tgz",
+      "version": "0.7.6",
+      "resolved": "https://registry.npmjs.org/wickra-win32-x64-msvc/-/wickra-win32-x64-msvc-0.7.6.tgz",
       "integrity": "sha512-Yfsqq1Xwp6hdxMyLze411vNdo7BDwI6+lPSe7A9XdqyPecNDbtKwYLpsal2r8EHbNzqM+R8XnuRtUaEQS5VlUQ==",
       "cpu": [
         "x64"

bindings/node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wickra",
-  "version": "0.7.3",
+  "version": "0.7.6",
   "description": "Streaming-first technical indicators: incremental, fast, install-free. Node bindings powered by Rust.",
   "author": "kingchenc <support@wickra.org>",
   "main": "index.js",
@@ -47,12 +47,12 @@
     "node": ">= 18"
   },
   "optionalDependencies": {
-    "wickra-linux-x64-gnu": "0.7.3",
-    "wickra-linux-arm64-gnu": "0.7.3",
-    "wickra-darwin-x64": "0.7.3",
-    "wickra-darwin-arm64": "0.7.3",
-    "wickra-win32-x64-msvc": "0.7.3",
-    "wickra-win32-arm64-msvc": "0.7.3"
+    "wickra-linux-x64-gnu": "0.7.6",
+    "wickra-linux-arm64-gnu": "0.7.6",
+    "wickra-darwin-x64": "0.7.6",
+    "wickra-darwin-arm64": "0.7.6",
+    "wickra-win32-x64-msvc": "0.7.6",
+    "wickra-win32-arm64-msvc": "0.7.6"
   },
   "scripts": {
     "build": "napi build --platform --release",

bindings/node/src/lib.rs

@@ -17818,6 +17818,559 @@ impl PointAndFigureBarsNode {
     }
 }
 
+#[napi(object)]
+pub struct RangeBarValue {
+    pub open: f64,
+    pub close: f64,
+    pub direction: i32,
+}
+
+#[napi(js_name = "RangeBars")]
+pub struct RangeBarsNode {
+    inner: wc::RangeBars,
+}
+#[napi]
+impl RangeBarsNode {
+    #[napi(constructor)]
+    pub fn new(range: f64) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::RangeBars::new(range).map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(&mut self, close: f64) -> napi::Result<Vec<RangeBarValue>> {
+        let candle = wc::Candle::new(close, close, close, close, 1.0, 0).map_err(map_err)?;
+        Ok(self
+            .inner
+            .update(candle)
+            .into_iter()
+            .map(|b| RangeBarValue {
+                open: b.open,
+                close: b.close,
+                direction: i32::from(b.direction),
+            })
+            .collect())
+    }
+    #[napi]
+    pub fn batch(&mut self, close: Vec<f64>) -> napi::Result<Vec<RangeBarValue>> {
+        let mut out = Vec::new();
+        for price in close {
+            let candle = wc::Candle::new(price, price, price, price, 1.0, 0).map_err(map_err)?;
+            for b in self.inner.update(candle) {
+                out.push(RangeBarValue {
+                    open: b.open,
+                    close: b.close,
+                    direction: i32::from(b.direction),
+                });
+            }
+        }
+        Ok(out)
+    }
+    #[napi]
+    pub fn range(&self) -> f64 {
+        self.inner.range()
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
+#[napi(object)]
+pub struct TickBarValue {
+    pub open: f64,
+    pub high: f64,
+    pub low: f64,
+    pub close: f64,
+    pub volume: f64,
+}
+
+#[napi(js_name = "TickBars")]
+pub struct TickBarsNode {
+    inner: wc::TickBars,
+}
+#[napi]
+impl TickBarsNode {
+    #[napi(constructor)]
+    pub fn new(ticks: u32) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::TickBars::new(ticks as usize).map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(
+        &mut self,
+        open: f64,
+        high: f64,
+        low: f64,
+        close: f64,
+        volume: f64,
+    ) -> napi::Result<Vec<TickBarValue>> {
+        let candle = wc::Candle::new(open, high, low, close, volume, 0).map_err(map_err)?;
+        Ok(self
+            .inner
+            .update(candle)
+            .into_iter()
+            .map(|b| TickBarValue {
+                open: b.open,
+                high: b.high,
+                low: b.low,
+                close: b.close,
+                volume: b.volume,
+            })
+            .collect())
+    }
+    #[napi]
+    pub fn batch(
+        &mut self,
+        open: Vec<f64>,
+        high: Vec<f64>,
+        low: Vec<f64>,
+        close: Vec<f64>,
+        volume: Vec<f64>,
+    ) -> napi::Result<Vec<TickBarValue>> {
+        if open.len() != high.len()
+            || high.len() != low.len()
+            || low.len() != close.len()
+            || close.len() != volume.len()
+        {
+            return Err(NapiError::from_reason(
+                "open, high, low, close, volume must be equal length".to_string(),
+            ));
+        }
+        let mut out = Vec::new();
+        for i in 0..open.len() {
+            let candle = wc::Candle::new(open[i], high[i], low[i], close[i], volume[i], 0)
+                .map_err(map_err)?;
+            for b in self.inner.update(candle) {
+                out.push(TickBarValue {
+                    open: b.open,
+                    high: b.high,
+                    low: b.low,
+                    close: b.close,
+                    volume: b.volume,
+                });
+            }
+        }
+        Ok(out)
+    }
+    #[napi]
+    pub fn ticks(&self) -> u32 {
+        self.inner.ticks() as u32
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
+#[napi(object)]
+pub struct VolumeBarValue {
+    pub open: f64,
+    pub high: f64,
+    pub low: f64,
+    pub close: f64,
+    pub volume: f64,
+}
+
+#[napi(js_name = "VolumeBars")]
+pub struct VolumeBarsNode {
+    inner: wc::VolumeBars,
+}
+#[napi]
+impl VolumeBarsNode {
+    #[napi(constructor)]
+    pub fn new(volume_per_bar: f64) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::VolumeBars::new(volume_per_bar).map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(
+        &mut self,
+        open: f64,
+        high: f64,
+        low: f64,
+        close: f64,
+        volume: f64,
+    ) -> napi::Result<Vec<VolumeBarValue>> {
+        let candle = wc::Candle::new(open, high, low, close, volume, 0).map_err(map_err)?;
+        Ok(self
+            .inner
+            .update(candle)
+            .into_iter()
+            .map(|b| VolumeBarValue {
+                open: b.open,
+                high: b.high,
+                low: b.low,
+                close: b.close,
+                volume: b.volume,
+            })
+            .collect())
+    }
+    #[napi]
+    pub fn batch(
+        &mut self,
+        open: Vec<f64>,
+        high: Vec<f64>,
+        low: Vec<f64>,
+        close: Vec<f64>,
+        volume: Vec<f64>,
+    ) -> napi::Result<Vec<VolumeBarValue>> {
+        if open.len() != high.len()
+            || high.len() != low.len()
+            || low.len() != close.len()
+            || close.len() != volume.len()
+        {
+            return Err(NapiError::from_reason(
+                "open, high, low, close, volume must be equal length".to_string(),
+            ));
+        }
+        let mut out = Vec::new();
+        for i in 0..open.len() {
+            let candle = wc::Candle::new(open[i], high[i], low[i], close[i], volume[i], 0)
+                .map_err(map_err)?;
+            for b in self.inner.update(candle) {
+                out.push(VolumeBarValue {
+                    open: b.open,
+                    high: b.high,
+                    low: b.low,
+                    close: b.close,
+                    volume: b.volume,
+                });
+            }
+        }
+        Ok(out)
+    }
+    #[napi(js_name = "volumePerBar")]
+    pub fn volume_per_bar(&self) -> f64 {
+        self.inner.volume_per_bar()
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
+#[napi(object)]
+pub struct DollarBarValue {
+    pub open: f64,
+    pub high: f64,
+    pub low: f64,
+    pub close: f64,
+    pub volume: f64,
+    pub dollar: f64,
+}
+
+#[napi(js_name = "DollarBars")]
+pub struct DollarBarsNode {
+    inner: wc::DollarBars,
+}
+#[napi]
+impl DollarBarsNode {
+    #[napi(constructor)]
+    pub fn new(dollar_per_bar: f64) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::DollarBars::new(dollar_per_bar).map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(
+        &mut self,
+        open: f64,
+        high: f64,
+        low: f64,
+        close: f64,
+        volume: f64,
+    ) -> napi::Result<Vec<DollarBarValue>> {
+        let candle = wc::Candle::new(open, high, low, close, volume, 0).map_err(map_err)?;
+        Ok(self
+            .inner
+            .update(candle)
+            .into_iter()
+            .map(|b| DollarBarValue {
+                open: b.open,
+                high: b.high,
+                low: b.low,
+                close: b.close,
+                volume: b.volume,
+                dollar: b.dollar,
+            })
+            .collect())
+    }
+    #[napi]
+    pub fn batch(
+        &mut self,
+        open: Vec<f64>,
+        high: Vec<f64>,
+        low: Vec<f64>,
+        close: Vec<f64>,
+        volume: Vec<f64>,
+    ) -> napi::Result<Vec<DollarBarValue>> {
+        if open.len() != high.len()
+            || high.len() != low.len()
+            || low.len() != close.len()
+            || close.len() != volume.len()
+        {
+            return Err(NapiError::from_reason(
+                "open, high, low, close, volume must be equal length".to_string(),
+            ));
+        }
+        let mut out = Vec::new();
+        for i in 0..open.len() {
+            let candle = wc::Candle::new(open[i], high[i], low[i], close[i], volume[i], 0)
+                .map_err(map_err)?;
+            for b in self.inner.update(candle) {
+                out.push(DollarBarValue {
+                    open: b.open,
+                    high: b.high,
+                    low: b.low,
+                    close: b.close,
+                    volume: b.volume,
+                    dollar: b.dollar,
+                });
+            }
+        }
+        Ok(out)
+    }
+    #[napi(js_name = "dollarPerBar")]
+    pub fn dollar_per_bar(&self) -> f64 {
+        self.inner.dollar_per_bar()
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
+#[napi(object)]
+pub struct ImbalanceBarValue {
+    pub open: f64,
+    pub high: f64,
+    pub low: f64,
+    pub close: f64,
+    pub imbalance: f64,
+    pub direction: i32,
+}
+
+#[napi(js_name = "ImbalanceBars")]
+pub struct ImbalanceBarsNode {
+    inner: wc::ImbalanceBars,
+}
+#[napi]
+impl ImbalanceBarsNode {
+    #[napi(constructor)]
+    pub fn new(threshold: f64) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::ImbalanceBars::new(threshold).map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(
+        &mut self,
+        open: f64,
+        high: f64,
+        low: f64,
+        close: f64,
+    ) -> napi::Result<Vec<ImbalanceBarValue>> {
+        let candle = wc::Candle::new(open, high, low, close, 1.0, 0).map_err(map_err)?;
+        Ok(self
+            .inner
+            .update(candle)
+            .into_iter()
+            .map(|b| ImbalanceBarValue {
+                open: b.open,
+                high: b.high,
+                low: b.low,
+                close: b.close,
+                imbalance: b.imbalance,
+                direction: i32::from(b.direction),
+            })
+            .collect())
+    }
+    #[napi]
+    pub fn batch(
+        &mut self,
+        open: Vec<f64>,
+        high: Vec<f64>,
+        low: Vec<f64>,
+        close: Vec<f64>,
+    ) -> napi::Result<Vec<ImbalanceBarValue>> {
+        if open.len() != high.len() || high.len() != low.len() || low.len() != close.len() {
+            return Err(NapiError::from_reason(
+                "open, high, low, close must be equal length".to_string(),
+            ));
+        }
+        let mut out = Vec::new();
+        for i in 0..open.len() {
+            let candle =
+                wc::Candle::new(open[i], high[i], low[i], close[i], 1.0, 0).map_err(map_err)?;
+            for b in self.inner.update(candle) {
+                out.push(ImbalanceBarValue {
+                    open: b.open,
+                    high: b.high,
+                    low: b.low,
+                    close: b.close,
+                    imbalance: b.imbalance,
+                    direction: i32::from(b.direction),
+                });
+            }
+        }
+        Ok(out)
+    }
+    #[napi]
+    pub fn threshold(&self) -> f64 {
+        self.inner.threshold()
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
+#[napi(object)]
+pub struct RunBarValue {
+    pub open: f64,
+    pub high: f64,
+    pub low: f64,
+    pub close: f64,
+    pub length: u32,
+    pub direction: i32,
+}
+
+#[napi(js_name = "RunBars")]
+pub struct RunBarsNode {
+    inner: wc::RunBars,
+}
+#[napi]
+impl RunBarsNode {
+    #[napi(constructor)]
+    pub fn new(run_length: u32) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::RunBars::new(run_length as usize).map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(
+        &mut self,
+        open: f64,
+        high: f64,
+        low: f64,
+        close: f64,
+    ) -> napi::Result<Vec<RunBarValue>> {
+        let candle = wc::Candle::new(open, high, low, close, 1.0, 0).map_err(map_err)?;
+        Ok(self
+            .inner
+            .update(candle)
+            .into_iter()
+            .map(|b| RunBarValue {
+                open: b.open,
+                high: b.high,
+                low: b.low,
+                close: b.close,
+                length: b.length as u32,
+                direction: i32::from(b.direction),
+            })
+            .collect())
+    }
+    #[napi]
+    pub fn batch(
+        &mut self,
+        open: Vec<f64>,
+        high: Vec<f64>,
+        low: Vec<f64>,
+        close: Vec<f64>,
+    ) -> napi::Result<Vec<RunBarValue>> {
+        if open.len() != high.len() || high.len() != low.len() || low.len() != close.len() {
+            return Err(NapiError::from_reason(
+                "open, high, low, close must be equal length".to_string(),
+            ));
+        }
+        let mut out = Vec::new();
+        for i in 0..open.len() {
+            let candle =
+                wc::Candle::new(open[i], high[i], low[i], close[i], 1.0, 0).map_err(map_err)?;
+            for b in self.inner.update(candle) {
+                out.push(RunBarValue {
+                    open: b.open,
+                    high: b.high,
+                    low: b.low,
+                    close: b.close,
+                    length: b.length as u32,
+                    direction: i32::from(b.direction),
+                });
+            }
+        }
+        Ok(out)
+    }
+    #[napi(js_name = "runLength")]
+    pub fn run_length(&self) -> u32 {
+        self.inner.run_length() as u32
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
+#[napi(object)]
+pub struct LineBreakBarValue {
+    pub open: f64,
+    pub close: f64,
+    pub direction: i32,
+}
+
+#[napi(js_name = "ThreeLineBreakBars")]
+pub struct ThreeLineBreakBarsNode {
+    inner: wc::ThreeLineBreakBars,
+}
+#[napi]
+impl ThreeLineBreakBarsNode {
+    #[napi(constructor)]
+    pub fn new(lines: u32) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::ThreeLineBreakBars::new(lines as usize).map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(&mut self, close: f64) -> napi::Result<Vec<LineBreakBarValue>> {
+        let candle = wc::Candle::new(close, close, close, close, 1.0, 0).map_err(map_err)?;
+        Ok(self
+            .inner
+            .update(candle)
+            .into_iter()
+            .map(|b| LineBreakBarValue {
+                open: b.open,
+                close: b.close,
+                direction: i32::from(b.direction),
+            })
+            .collect())
+    }
+    #[napi]
+    pub fn batch(&mut self, close: Vec<f64>) -> napi::Result<Vec<LineBreakBarValue>> {
+        let mut out = Vec::new();
+        for price in close {
+            let candle = wc::Candle::new(price, price, price, price, 1.0, 0).map_err(map_err)?;
+            for b in self.inner.update(candle) {
+                out.push(LineBreakBarValue {
+                    open: b.open,
+                    close: b.close,
+                    direction: i32::from(b.direction),
+                });
+            }
+        }
+        Ok(out)
+    }
+    #[napi]
+    pub fn lines(&self) -> u32 {
+        self.inner.lines() as u32
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
 #[napi(js_name = "Alpha")]
 pub struct AlphaNode {
     inner: wc::Alpha,

bindings/python/README.md

@@ -9,7 +9,8 @@
 system dependencies, no C build tooling.**
 
 Wickra is a multi-language technical-analysis library with a Rust core and
-bindings for Python, Node.js, and WebAssembly. Every indicator is an O(1)
+bindings for Python, Node.js and WebAssembly, plus a C ABI for C/C++, C# 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 Python binding (PyO3); it
 exposes 200+ streaming-first indicators across sixteen families.
@@ -54,8 +55,9 @@ the main repository and documentation site:
 - **Docs** (quickstarts, cookbook, TA-Lib migration): <https://docs.wickra.org>
 - **Runnable examples:** [`examples/python/`](https://github.com/wickra-lib/wickra/tree/main/examples/python)
 
-Wickra ships four bindings — Python, Node.js, WebAssembly, and Rust — that all
-expose the same indicators from the shared, `unsafe`-forbidden Rust core.
+Wickra ships native bindings for Python, Node.js, WebAssembly and Rust, plus a
+C ABI hub that any C-capable language (C, C++, Go, C#, Java, R) links against —
+all exposing the same indicators from the shared, `unsafe`-forbidden Rust core.
 
 ## Disclaimer
 

bindings/python/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "wickra"
-version = "0.7.3"
+version = "0.7.6"
 description = "Streaming-first technical indicators: incremental, fast, install-free."
 readme = "README.md"
 license = "MIT OR Apache-2.0"

bindings/python/python/wickra/__init__.py

@@ -370,6 +370,13 @@ from ._wickra import (
     InitialBalance,
     OpeningRange,
     # Alt-Chart Bars
+    ThreeLineBreakBars,
+    RunBars,
+    ImbalanceBars,
+    DollarBars,
+    VolumeBars,
+    TickBars,
+    RangeBars,
     RenkoBars,
     KagiBars,
     PointAndFigureBars,
@@ -907,6 +914,13 @@ __all__ = [
     "InitialBalance",
     "OpeningRange",
     # Alt-Chart Bars
+    "ThreeLineBreakBars",
+    "RunBars",
+    "ImbalanceBars",
+    "DollarBars",
+    "VolumeBars",
+    "TickBars",
+    "RangeBars",
     "RenkoBars",
     "KagiBars",
     "PointAndFigureBars",

bindings/python/src/lib.rs

@@ -38,6 +38,67 @@ fn map_err(e: wc::Error) -> PyErr {
 /// Raised instead of panicking when a `NumPy` input is not C-contiguous.
 const NON_CONTIGUOUS: &str = "array must be C-contiguous; pass np.ascontiguousarray(arr)";
 
+/// Borrowed `(open, high, low, close)` columns for candle-driven bar builders.
+type OhlcCols<'a> = (&'a [f64], &'a [f64], &'a [f64], &'a [f64]);
+/// Borrowed `(open, high, low, close, volume)` columns for candle-driven bar builders.
+type OhlcvCols<'a> = (&'a [f64], &'a [f64], &'a [f64], &'a [f64], &'a [f64]);
+
+/// `(open, high, low, close, volume)` rows from Tick/Volume bar builders.
+type OhlcvBarRows = Vec<(f64, f64, f64, f64, f64)>;
+/// `(open, high, low, close, volume, dollar)` rows from the Dollar bar builder.
+type DollarBarRows = Vec<(f64, f64, f64, f64, f64, f64)>;
+/// `(open, high, low, close, imbalance, direction)` rows from the Imbalance bar builder.
+type ImbalanceBarRows = Vec<(f64, f64, f64, f64, f64, i64)>;
+/// `(open, high, low, close, length, direction)` rows from the Run bar builder.
+type RunBarRows = Vec<(f64, f64, f64, f64, i64, i64)>;
+
+/// Extract four equal-length OHLC slices, erroring on non-contiguous or mismatched input.
+fn ohlc_slices<'a, 'py>(
+    open: &'a PyReadonlyArray1<'py, f64>,
+    high: &'a PyReadonlyArray1<'py, f64>,
+    low: &'a PyReadonlyArray1<'py, f64>,
+    close: &'a PyReadonlyArray1<'py, f64>,
+) -> PyResult<OhlcCols<'a>> {
+    let o = open
+        .as_slice()
+        .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+    let h = high
+        .as_slice()
+        .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+    let l = low
+        .as_slice()
+        .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+    let c = close
+        .as_slice()
+        .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+    if o.len() != h.len() || h.len() != l.len() || l.len() != c.len() {
+        return Err(PyValueError::new_err(
+            "open, high, low, close must be equal length",
+        ));
+    }
+    Ok((o, h, l, c))
+}
+
+/// Extract five equal-length OHLCV slices, erroring on non-contiguous or mismatched input.
+fn ohlcv_slices<'a, 'py>(
+    open: &'a PyReadonlyArray1<'py, f64>,
+    high: &'a PyReadonlyArray1<'py, f64>,
+    low: &'a PyReadonlyArray1<'py, f64>,
+    close: &'a PyReadonlyArray1<'py, f64>,
+    volume: &'a PyReadonlyArray1<'py, f64>,
+) -> PyResult<OhlcvCols<'a>> {
+    let (o, h, l, c) = ohlc_slices(open, high, low, close)?;
+    let v = volume
+        .as_slice()
+        .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+    if v.len() != o.len() {
+        return Err(PyValueError::new_err(
+            "open, high, low, close, volume must be equal length",
+        ));
+    }
+    Ok((o, h, l, c, v))
+}
+
 /// `(pp, r1, r2, r3, s1, s2, s3)` pivot levels returned by Classic/Fibonacci pivots.
 type PivotLevels = (f64, f64, f64, f64, f64, f64, f64);
 /// The five Fibonacci-extension levels returned by `FibExtension`.
@@ -23459,6 +23520,486 @@ impl PyPointAndFigureBars {
     }
 }
 
+#[pyclass(name = "RangeBars", module = "wickra._wickra", skip_from_py_object)]
+#[derive(Clone)]
+struct PyRangeBars {
+    inner: wc::RangeBars,
+}
+
+#[pymethods]
+impl PyRangeBars {
+    #[new]
+    fn new(range: f64) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::RangeBars::new(range).map_err(map_err)?,
+        })
+    }
+    /// Feed one close; returns bars completed on it as `(open, close, direction)`.
+    fn update(&mut self, close: f64) -> PyResult<Vec<(f64, f64, i64)>> {
+        let candle = wc::Candle::new(close, close, close, close, 1.0, 0).map_err(map_err)?;
+        Ok(self
+            .inner
+            .update(candle)
+            .into_iter()
+            .map(|b| (b.open, b.close, i64::from(b.direction)))
+            .collect())
+    }
+    /// Batch over a close column. Returns shape `(k, 3)` of `[open, close, direction]`.
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        close: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray2<f64>>> {
+        let prices = close
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        let mut rows: Vec<f64> = Vec::new();
+        let mut k = 0usize;
+        for &price in prices {
+            let candle = wc::Candle::new(price, price, price, price, 1.0, 0).map_err(map_err)?;
+            for b in self.inner.update(candle) {
+                rows.push(b.open);
+                rows.push(b.close);
+                rows.push(f64::from(b.direction));
+                k += 1;
+            }
+        }
+        Ok(numpy::ndarray::Array2::from_shape_vec((k, 3), rows)
+            .expect("shape consistent")
+            .into_pyarray(py))
+    }
+    #[getter]
+    fn range(&self) -> f64 {
+        self.inner.range()
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn __repr__(&self) -> String {
+        format!("RangeBars(range={})", self.inner.range())
+    }
+}
+
+#[pyclass(name = "TickBars", module = "wickra._wickra", skip_from_py_object)]
+#[derive(Clone)]
+struct PyTickBars {
+    inner: wc::TickBars,
+}
+
+#[pymethods]
+impl PyTickBars {
+    #[new]
+    fn new(ticks: usize) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::TickBars::new(ticks).map_err(map_err)?,
+        })
+    }
+    /// Feed one candle; returns bars completed as `(open, high, low, close, volume)`.
+    #[allow(clippy::too_many_arguments)]
+    fn update(
+        &mut self,
+        open: f64,
+        high: f64,
+        low: f64,
+        close: f64,
+        volume: f64,
+    ) -> PyResult<OhlcvBarRows> {
+        let candle = wc::Candle::new(open, high, low, close, volume, 0).map_err(map_err)?;
+        Ok(self
+            .inner
+            .update(candle)
+            .into_iter()
+            .map(|b| (b.open, b.high, b.low, b.close, b.volume))
+            .collect())
+    }
+    /// Batch over OHLCV columns. Returns shape `(k, 5)` of `[open, high, low, close, volume]`.
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        open: PyReadonlyArray1<'py, f64>,
+        high: PyReadonlyArray1<'py, f64>,
+        low: PyReadonlyArray1<'py, f64>,
+        close: PyReadonlyArray1<'py, f64>,
+        volume: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray2<f64>>> {
+        let (o, h, l, c, v) = ohlcv_slices(&open, &high, &low, &close, &volume)?;
+        let mut rows: Vec<f64> = Vec::new();
+        let mut k = 0usize;
+        for i in 0..o.len() {
+            let candle = wc::Candle::new(o[i], h[i], l[i], c[i], v[i], 0).map_err(map_err)?;
+            for b in self.inner.update(candle) {
+                rows.extend_from_slice(&[b.open, b.high, b.low, b.close, b.volume]);
+                k += 1;
+            }
+        }
+        Ok(numpy::ndarray::Array2::from_shape_vec((k, 5), rows)
+            .expect("shape consistent")
+            .into_pyarray(py))
+    }
+    #[getter]
+    fn ticks(&self) -> usize {
+        self.inner.ticks()
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn __repr__(&self) -> String {
+        format!("TickBars(ticks={})", self.inner.ticks())
+    }
+}
+
+#[pyclass(name = "VolumeBars", module = "wickra._wickra", skip_from_py_object)]
+#[derive(Clone)]
+struct PyVolumeBars {
+    inner: wc::VolumeBars,
+}
+
+#[pymethods]
+impl PyVolumeBars {
+    #[new]
+    fn new(volume_per_bar: f64) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::VolumeBars::new(volume_per_bar).map_err(map_err)?,
+        })
+    }
+    /// Feed one candle; returns bars completed as `(open, high, low, close, volume)`.
+    #[allow(clippy::too_many_arguments)]
+    fn update(
+        &mut self,
+        open: f64,
+        high: f64,
+        low: f64,
+        close: f64,
+        volume: f64,
+    ) -> PyResult<OhlcvBarRows> {
+        let candle = wc::Candle::new(open, high, low, close, volume, 0).map_err(map_err)?;
+        Ok(self
+            .inner
+            .update(candle)
+            .into_iter()
+            .map(|b| (b.open, b.high, b.low, b.close, b.volume))
+            .collect())
+    }
+    /// Batch over OHLCV columns. Returns shape `(k, 5)` of `[open, high, low, close, volume]`.
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        open: PyReadonlyArray1<'py, f64>,
+        high: PyReadonlyArray1<'py, f64>,
+        low: PyReadonlyArray1<'py, f64>,
+        close: PyReadonlyArray1<'py, f64>,
+        volume: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray2<f64>>> {
+        let (o, h, l, c, v) = ohlcv_slices(&open, &high, &low, &close, &volume)?;
+        let mut rows: Vec<f64> = Vec::new();
+        let mut k = 0usize;
+        for i in 0..o.len() {
+            let candle = wc::Candle::new(o[i], h[i], l[i], c[i], v[i], 0).map_err(map_err)?;
+            for b in self.inner.update(candle) {
+                rows.extend_from_slice(&[b.open, b.high, b.low, b.close, b.volume]);
+                k += 1;
+            }
+        }
+        Ok(numpy::ndarray::Array2::from_shape_vec((k, 5), rows)
+            .expect("shape consistent")
+            .into_pyarray(py))
+    }
+    #[getter]
+    fn volume_per_bar(&self) -> f64 {
+        self.inner.volume_per_bar()
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn __repr__(&self) -> String {
+        format!("VolumeBars(volume_per_bar={})", self.inner.volume_per_bar())
+    }
+}
+
+#[pyclass(name = "DollarBars", module = "wickra._wickra", skip_from_py_object)]
+#[derive(Clone)]
+struct PyDollarBars {
+    inner: wc::DollarBars,
+}
+
+#[pymethods]
+impl PyDollarBars {
+    #[new]
+    fn new(dollar_per_bar: f64) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::DollarBars::new(dollar_per_bar).map_err(map_err)?,
+        })
+    }
+    /// Feed one candle; returns bars completed as `(open, high, low, close, volume, dollar)`.
+    #[allow(clippy::too_many_arguments)]
+    fn update(
+        &mut self,
+        open: f64,
+        high: f64,
+        low: f64,
+        close: f64,
+        volume: f64,
+    ) -> PyResult<DollarBarRows> {
+        let candle = wc::Candle::new(open, high, low, close, volume, 0).map_err(map_err)?;
+        Ok(self
+            .inner
+            .update(candle)
+            .into_iter()
+            .map(|b| (b.open, b.high, b.low, b.close, b.volume, b.dollar))
+            .collect())
+    }
+    /// Batch over OHLCV columns. Returns shape `(k, 6)` of `[open, high, low, close, volume, dollar]`.
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        open: PyReadonlyArray1<'py, f64>,
+        high: PyReadonlyArray1<'py, f64>,
+        low: PyReadonlyArray1<'py, f64>,
+        close: PyReadonlyArray1<'py, f64>,
+        volume: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray2<f64>>> {
+        let (o, h, l, c, v) = ohlcv_slices(&open, &high, &low, &close, &volume)?;
+        let mut rows: Vec<f64> = Vec::new();
+        let mut k = 0usize;
+        for i in 0..o.len() {
+            let candle = wc::Candle::new(o[i], h[i], l[i], c[i], v[i], 0).map_err(map_err)?;
+            for b in self.inner.update(candle) {
+                rows.extend_from_slice(&[b.open, b.high, b.low, b.close, b.volume, b.dollar]);
+                k += 1;
+            }
+        }
+        Ok(numpy::ndarray::Array2::from_shape_vec((k, 6), rows)
+            .expect("shape consistent")
+            .into_pyarray(py))
+    }
+    #[getter]
+    fn dollar_per_bar(&self) -> f64 {
+        self.inner.dollar_per_bar()
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn __repr__(&self) -> String {
+        format!("DollarBars(dollar_per_bar={})", self.inner.dollar_per_bar())
+    }
+}
+
+#[pyclass(name = "ImbalanceBars", module = "wickra._wickra", skip_from_py_object)]
+#[derive(Clone)]
+struct PyImbalanceBars {
+    inner: wc::ImbalanceBars,
+}
+
+#[pymethods]
+impl PyImbalanceBars {
+    #[new]
+    fn new(threshold: f64) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::ImbalanceBars::new(threshold).map_err(map_err)?,
+        })
+    }
+    /// Feed one candle; returns bars completed as `(open, high, low, close, imbalance, direction)`.
+    fn update(&mut self, open: f64, high: f64, low: f64, close: f64) -> PyResult<ImbalanceBarRows> {
+        let candle = wc::Candle::new(open, high, low, close, 1.0, 0).map_err(map_err)?;
+        Ok(self
+            .inner
+            .update(candle)
+            .into_iter()
+            .map(|b| {
+                (
+                    b.open,
+                    b.high,
+                    b.low,
+                    b.close,
+                    b.imbalance,
+                    i64::from(b.direction),
+                )
+            })
+            .collect())
+    }
+    /// Batch over OHLC columns. Returns shape `(k, 6)` of `[open, high, low, close, imbalance, direction]`.
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        open: PyReadonlyArray1<'py, f64>,
+        high: PyReadonlyArray1<'py, f64>,
+        low: PyReadonlyArray1<'py, f64>,
+        close: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray2<f64>>> {
+        let (o, h, l, c) = ohlc_slices(&open, &high, &low, &close)?;
+        let mut rows: Vec<f64> = Vec::new();
+        let mut k = 0usize;
+        for i in 0..o.len() {
+            let candle = wc::Candle::new(o[i], h[i], l[i], c[i], 1.0, 0).map_err(map_err)?;
+            for b in self.inner.update(candle) {
+                rows.extend_from_slice(&[
+                    b.open,
+                    b.high,
+                    b.low,
+                    b.close,
+                    b.imbalance,
+                    f64::from(b.direction),
+                ]);
+                k += 1;
+            }
+        }
+        Ok(numpy::ndarray::Array2::from_shape_vec((k, 6), rows)
+            .expect("shape consistent")
+            .into_pyarray(py))
+    }
+    #[getter]
+    fn threshold(&self) -> f64 {
+        self.inner.threshold()
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn __repr__(&self) -> String {
+        format!("ImbalanceBars(threshold={})", self.inner.threshold())
+    }
+}
+
+#[pyclass(name = "RunBars", module = "wickra._wickra", skip_from_py_object)]
+#[derive(Clone)]
+struct PyRunBars {
+    inner: wc::RunBars,
+}
+
+#[pymethods]
+impl PyRunBars {
+    #[new]
+    fn new(run_length: usize) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::RunBars::new(run_length).map_err(map_err)?,
+        })
+    }
+    /// Feed one candle; returns bars completed as `(open, high, low, close, length, direction)`.
+    fn update(&mut self, open: f64, high: f64, low: f64, close: f64) -> PyResult<RunBarRows> {
+        let candle = wc::Candle::new(open, high, low, close, 1.0, 0).map_err(map_err)?;
+        Ok(self
+            .inner
+            .update(candle)
+            .into_iter()
+            .map(|b| {
+                (
+                    b.open,
+                    b.high,
+                    b.low,
+                    b.close,
+                    i64::try_from(b.length).unwrap_or(i64::MAX),
+                    i64::from(b.direction),
+                )
+            })
+            .collect())
+    }
+    /// Batch over OHLC columns. Returns shape `(k, 6)` of `[open, high, low, close, length, direction]`.
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        open: PyReadonlyArray1<'py, f64>,
+        high: PyReadonlyArray1<'py, f64>,
+        low: PyReadonlyArray1<'py, f64>,
+        close: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray2<f64>>> {
+        let (o, h, l, c) = ohlc_slices(&open, &high, &low, &close)?;
+        let mut rows: Vec<f64> = Vec::new();
+        let mut k = 0usize;
+        for i in 0..o.len() {
+            let candle = wc::Candle::new(o[i], h[i], l[i], c[i], 1.0, 0).map_err(map_err)?;
+            for b in self.inner.update(candle) {
+                #[allow(clippy::cast_precision_loss)]
+                rows.extend_from_slice(&[
+                    b.open,
+                    b.high,
+                    b.low,
+                    b.close,
+                    b.length as f64,
+                    f64::from(b.direction),
+                ]);
+                k += 1;
+            }
+        }
+        Ok(numpy::ndarray::Array2::from_shape_vec((k, 6), rows)
+            .expect("shape consistent")
+            .into_pyarray(py))
+    }
+    #[getter]
+    fn run_length(&self) -> usize {
+        self.inner.run_length()
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn __repr__(&self) -> String {
+        format!("RunBars(run_length={})", self.inner.run_length())
+    }
+}
+
+#[pyclass(
+    name = "ThreeLineBreakBars",
+    module = "wickra._wickra",
+    skip_from_py_object
+)]
+#[derive(Clone)]
+struct PyThreeLineBreakBars {
+    inner: wc::ThreeLineBreakBars,
+}
+
+#[pymethods]
+impl PyThreeLineBreakBars {
+    #[new]
+    #[pyo3(signature = (lines=3))]
+    fn new(lines: usize) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::ThreeLineBreakBars::new(lines).map_err(map_err)?,
+        })
+    }
+    /// Feed one close; returns bars completed on it as `(open, close, direction)`.
+    fn update(&mut self, close: f64) -> PyResult<Vec<(f64, f64, i64)>> {
+        let candle = wc::Candle::new(close, close, close, close, 1.0, 0).map_err(map_err)?;
+        Ok(self
+            .inner
+            .update(candle)
+            .into_iter()
+            .map(|b| (b.open, b.close, i64::from(b.direction)))
+            .collect())
+    }
+    /// Batch over a close column. Returns shape `(k, 3)` of `[open, close, direction]`.
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        close: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray2<f64>>> {
+        let prices = close
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        let mut rows: Vec<f64> = Vec::new();
+        let mut k = 0usize;
+        for &price in prices {
+            let candle = wc::Candle::new(price, price, price, price, 1.0, 0).map_err(map_err)?;
+            for b in self.inner.update(candle) {
+                rows.push(b.open);
+                rows.push(b.close);
+                rows.push(f64::from(b.direction));
+                k += 1;
+            }
+        }
+        Ok(numpy::ndarray::Array2::from_shape_vec((k, 3), rows)
+            .expect("shape consistent")
+            .into_pyarray(py))
+    }
+    #[getter]
+    fn lines(&self) -> usize {
+        self.inner.lines()
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn __repr__(&self) -> String {
+        format!("ThreeLineBreakBars(lines={})", self.inner.lines())
+    }
+}
+
 // ============================== Module ==============================
 
 // ====================== Seasonality & Session (full-candle) ======================
@@ -26074,6 +26615,13 @@ fn _wickra(_py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyRenkoBars>()?;
     m.add_class::<PyKagiBars>()?;
     m.add_class::<PyPointAndFigureBars>()?;
+    m.add_class::<PyRangeBars>()?;
+    m.add_class::<PyTickBars>()?;
+    m.add_class::<PyVolumeBars>()?;
+    m.add_class::<PyDollarBars>()?;
+    m.add_class::<PyImbalanceBars>()?;
+    m.add_class::<PyRunBars>()?;
+    m.add_class::<PyThreeLineBreakBars>()?;
     m.add_class::<PyInitialBalance>()?;
     m.add_class::<PyOpeningRange>()?;
     m.add_class::<PyNakedPoc>()?;

bindings/python/tests/test_new_indicators.py

@@ -4237,3 +4237,83 @@ def test_bar_builders_reset():
     r.update(15.0)
     r.reset()
     assert r.update(50.0) == []  # re-seeds after reset
+
+
+def test_range_bars_reference():
+    rb = ta.RangeBars(1.0)
+    assert rb.update(10.0) == []  # seed
+    assert rb.update(13.0) == [(10.0, 11.0, 1), (11.0, 12.0, 1), (12.0, 13.0, 1)]
+
+
+def test_range_bars_batch_shape():
+    rb = ta.RangeBars(1.0)
+    out = rb.batch(np.array([10.0, 11.0, 12.0, 13.0]))
+    assert out.shape == (3, 3)
+    np.testing.assert_allclose(out[:, 2], [1.0, 1.0, 1.0])
+
+
+def test_tick_bars_reference():
+    tb = ta.TickBars(2)
+    assert tb.update(10.0, 11.0, 9.0, 10.5, 100.0) == []
+    out = tb.update(10.5, 12.0, 10.0, 11.0, 150.0)
+    assert len(out) == 1
+    assert out[0] == (10.0, 12.0, 9.0, 11.0, 250.0)
+
+
+def test_tick_bars_batch_shape():
+    tb = ta.TickBars(2)
+    col = np.array([10.0, 10.0, 10.0, 10.0])
+    vol = np.array([1.0, 1.0, 1.0, 1.0])
+    out = tb.batch(col, col, col, col, vol)
+    assert out.shape == (2, 5)
+
+
+def test_volume_bars_reference():
+    vb = ta.VolumeBars(100.0)
+    assert vb.update(10.0, 10.0, 10.0, 10.0, 60.0) == []
+    out = vb.update(10.5, 10.5, 10.5, 10.5, 60.0)
+    assert len(out) == 1
+    assert out[0][4] == 120.0  # accumulated volume
+
+
+def test_dollar_bars_reference():
+    db = ta.DollarBars(1000.0)
+    assert db.update(10.0, 10.0, 10.0, 10.0, 60.0) == []  # 600
+    out = db.update(10.0, 10.0, 10.0, 10.0, 60.0)  # 1200 >= 1000
+    assert len(out) == 1
+    assert out[0][4] == 120.0  # volume
+    assert out[0][5] == 1200.0  # traded value
+
+
+def test_imbalance_bars_reference():
+    ib = ta.ImbalanceBars(3.0)
+    assert ib.update(10.0, 10.0, 10.0, 10.0) == []  # seed
+    ib.update(11.0, 11.0, 11.0, 11.0)  # +1
+    ib.update(12.0, 12.0, 12.0, 12.0)  # +2
+    out = ib.update(13.0, 13.0, 13.0, 13.0)  # +3 -> close
+    assert len(out) == 1
+    assert out[0][4] == 3.0  # imbalance
+    assert out[0][5] == 1  # direction
+
+
+def test_run_bars_reference():
+    rb = ta.RunBars(3)
+    assert rb.update(10.0, 10.0, 10.0, 10.0) == []  # seed
+    rb.update(11.0, 11.0, 11.0, 11.0)  # run 1
+    rb.update(12.0, 12.0, 12.0, 12.0)  # run 2
+    out = rb.update(13.0, 13.0, 13.0, 13.0)  # run 3 -> close
+    assert len(out) == 1
+    assert out[0][4] == 3  # length
+    assert out[0][5] == 1  # direction
+
+
+def test_three_line_break_bars_reference():
+    tlb = ta.ThreeLineBreakBars(3)
+    assert tlb.update(10.0) == []  # seed
+    assert tlb.update(11.0) == [(10.0, 11.0, 1)]
+
+
+def test_three_line_break_bars_batch_shape():
+    tlb = ta.ThreeLineBreakBars(3)
+    out = tlb.batch(np.array([10.0, 11.0, 12.0, 13.0]))
+    assert out.shape[1] == 3

bindings/wasm/README.md

@@ -9,7 +9,8 @@
 wickra-wasm` — pure WebAssembly, runs anywhere a modern JS engine does.**
 
 Wickra is a multi-language technical-analysis library with a Rust core and
-bindings for Python, Node.js, and WebAssembly. Every indicator is an O(1)
+bindings for Python, Node.js and WebAssembly, plus a C ABI for C/C++, C# and any
+other C-capable language. Every indicator is an O(1)
 streaming state machine, so live trading dashboards and historical backtests
 share the exact same implementation. This package is the WebAssembly binding
 (wasm-bindgen, built for the `web` target); it exposes 200+ streaming-first
@@ -54,8 +55,9 @@ the main repository and documentation site:
 - **Docs** (quickstarts, cookbook, TA-Lib migration): <https://docs.wickra.org>
 - **Runnable browser examples:** [`examples/wasm/`](https://github.com/wickra-lib/wickra/tree/main/examples/wasm)
 
-Wickra ships four bindings — Python, Node.js, WebAssembly, and Rust — that all
-expose the same indicators from the shared, `unsafe`-forbidden Rust core.
+Wickra ships native bindings for Python, Node.js, WebAssembly and Rust, plus a
+C ABI hub that any C-capable language (C, C++, Go, C#, Java, R) links against —
+all exposing the same indicators from the shared, `unsafe`-forbidden Rust core.
 
 ## Disclaimer
 

bindings/wasm/src/lib.rs

@@ -13163,6 +13163,310 @@ impl WasmPointAndFigureBars {
     }
 }
 
+#[wasm_bindgen(js_name = RangeBars)]
+pub struct WasmRangeBars {
+    inner: wc::RangeBars,
+}
+
+#[wasm_bindgen(js_class = RangeBars)]
+impl WasmRangeBars {
+    #[wasm_bindgen(constructor)]
+    pub fn new(range: f64) -> Result<WasmRangeBars, JsError> {
+        Ok(Self {
+            inner: wc::RangeBars::new(range).map_err(map_err)?,
+        })
+    }
+    /// Returns an array of `{ open, close, direction }` bars completed on this close.
+    pub fn update(&mut self, close: f64) -> Result<Array, JsError> {
+        let candle = wc::Candle::new(close, close, close, close, 1.0, 0).map_err(map_err)?;
+        let arr = Array::new();
+        for b in self.inner.update(candle) {
+            let obj = Object::new();
+            Reflect::set(&obj, &"open".into(), &b.open.into()).ok();
+            Reflect::set(&obj, &"close".into(), &b.close.into()).ok();
+            Reflect::set(&obj, &"direction".into(), &f64::from(b.direction).into()).ok();
+            arr.push(&obj);
+        }
+        Ok(arr)
+    }
+    pub fn batch(&mut self, close: &[f64]) -> Result<Array, JsError> {
+        let arr = Array::new();
+        for &price in close {
+            let candle = wc::Candle::new(price, price, price, price, 1.0, 0).map_err(map_err)?;
+            for b in self.inner.update(candle) {
+                let obj = Object::new();
+                Reflect::set(&obj, &"open".into(), &b.open.into()).ok();
+                Reflect::set(&obj, &"close".into(), &b.close.into()).ok();
+                Reflect::set(&obj, &"direction".into(), &f64::from(b.direction).into()).ok();
+                arr.push(&obj);
+            }
+        }
+        Ok(arr)
+    }
+    pub fn range(&self) -> f64 {
+        self.inner.range()
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
+#[wasm_bindgen(js_name = TickBars)]
+pub struct WasmTickBars {
+    inner: wc::TickBars,
+}
+
+#[wasm_bindgen(js_class = TickBars)]
+impl WasmTickBars {
+    #[wasm_bindgen(constructor)]
+    pub fn new(ticks: usize) -> Result<WasmTickBars, JsError> {
+        Ok(Self {
+            inner: wc::TickBars::new(ticks).map_err(map_err)?,
+        })
+    }
+    /// Returns an array of `{ open, high, low, close, volume }` bars completed on this candle.
+    pub fn update(
+        &mut self,
+        open: f64,
+        high: f64,
+        low: f64,
+        close: f64,
+        volume: f64,
+    ) -> Result<Array, JsError> {
+        let candle = wc::Candle::new(open, high, low, close, volume, 0).map_err(map_err)?;
+        let arr = Array::new();
+        for b in self.inner.update(candle) {
+            let obj = Object::new();
+            Reflect::set(&obj, &"open".into(), &b.open.into()).ok();
+            Reflect::set(&obj, &"high".into(), &b.high.into()).ok();
+            Reflect::set(&obj, &"low".into(), &b.low.into()).ok();
+            Reflect::set(&obj, &"close".into(), &b.close.into()).ok();
+            Reflect::set(&obj, &"volume".into(), &b.volume.into()).ok();
+            arr.push(&obj);
+        }
+        Ok(arr)
+    }
+    pub fn ticks(&self) -> usize {
+        self.inner.ticks()
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
+#[wasm_bindgen(js_name = VolumeBars)]
+pub struct WasmVolumeBars {
+    inner: wc::VolumeBars,
+}
+
+#[wasm_bindgen(js_class = VolumeBars)]
+impl WasmVolumeBars {
+    #[wasm_bindgen(constructor)]
+    pub fn new(volume_per_bar: f64) -> Result<WasmVolumeBars, JsError> {
+        Ok(Self {
+            inner: wc::VolumeBars::new(volume_per_bar).map_err(map_err)?,
+        })
+    }
+    /// Returns an array of `{ open, high, low, close, volume }` bars completed on this candle.
+    pub fn update(
+        &mut self,
+        open: f64,
+        high: f64,
+        low: f64,
+        close: f64,
+        volume: f64,
+    ) -> Result<Array, JsError> {
+        let candle = wc::Candle::new(open, high, low, close, volume, 0).map_err(map_err)?;
+        let arr = Array::new();
+        for b in self.inner.update(candle) {
+            let obj = Object::new();
+            Reflect::set(&obj, &"open".into(), &b.open.into()).ok();
+            Reflect::set(&obj, &"high".into(), &b.high.into()).ok();
+            Reflect::set(&obj, &"low".into(), &b.low.into()).ok();
+            Reflect::set(&obj, &"close".into(), &b.close.into()).ok();
+            Reflect::set(&obj, &"volume".into(), &b.volume.into()).ok();
+            arr.push(&obj);
+        }
+        Ok(arr)
+    }
+    #[wasm_bindgen(js_name = volumePerBar)]
+    pub fn volume_per_bar(&self) -> f64 {
+        self.inner.volume_per_bar()
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
+#[wasm_bindgen(js_name = DollarBars)]
+pub struct WasmDollarBars {
+    inner: wc::DollarBars,
+}
+
+#[wasm_bindgen(js_class = DollarBars)]
+impl WasmDollarBars {
+    #[wasm_bindgen(constructor)]
+    pub fn new(dollar_per_bar: f64) -> Result<WasmDollarBars, JsError> {
+        Ok(Self {
+            inner: wc::DollarBars::new(dollar_per_bar).map_err(map_err)?,
+        })
+    }
+    /// Returns an array of `{ open, high, low, close, volume, dollar }` bars completed on this candle.
+    pub fn update(
+        &mut self,
+        open: f64,
+        high: f64,
+        low: f64,
+        close: f64,
+        volume: f64,
+    ) -> Result<Array, JsError> {
+        let candle = wc::Candle::new(open, high, low, close, volume, 0).map_err(map_err)?;
+        let arr = Array::new();
+        for b in self.inner.update(candle) {
+            let obj = Object::new();
+            Reflect::set(&obj, &"open".into(), &b.open.into()).ok();
+            Reflect::set(&obj, &"high".into(), &b.high.into()).ok();
+            Reflect::set(&obj, &"low".into(), &b.low.into()).ok();
+            Reflect::set(&obj, &"close".into(), &b.close.into()).ok();
+            Reflect::set(&obj, &"volume".into(), &b.volume.into()).ok();
+            Reflect::set(&obj, &"dollar".into(), &b.dollar.into()).ok();
+            arr.push(&obj);
+        }
+        Ok(arr)
+    }
+    #[wasm_bindgen(js_name = dollarPerBar)]
+    pub fn dollar_per_bar(&self) -> f64 {
+        self.inner.dollar_per_bar()
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
+#[wasm_bindgen(js_name = ImbalanceBars)]
+pub struct WasmImbalanceBars {
+    inner: wc::ImbalanceBars,
+}
+
+#[wasm_bindgen(js_class = ImbalanceBars)]
+impl WasmImbalanceBars {
+    #[wasm_bindgen(constructor)]
+    pub fn new(threshold: f64) -> Result<WasmImbalanceBars, JsError> {
+        Ok(Self {
+            inner: wc::ImbalanceBars::new(threshold).map_err(map_err)?,
+        })
+    }
+    /// Returns an array of `{ open, high, low, close, imbalance, direction }` bars completed on this candle.
+    pub fn update(&mut self, open: f64, high: f64, low: f64, close: f64) -> Result<Array, JsError> {
+        let candle = wc::Candle::new(open, high, low, close, 1.0, 0).map_err(map_err)?;
+        let arr = Array::new();
+        for b in self.inner.update(candle) {
+            let obj = Object::new();
+            Reflect::set(&obj, &"open".into(), &b.open.into()).ok();
+            Reflect::set(&obj, &"high".into(), &b.high.into()).ok();
+            Reflect::set(&obj, &"low".into(), &b.low.into()).ok();
+            Reflect::set(&obj, &"close".into(), &b.close.into()).ok();
+            Reflect::set(&obj, &"imbalance".into(), &b.imbalance.into()).ok();
+            Reflect::set(&obj, &"direction".into(), &f64::from(b.direction).into()).ok();
+            arr.push(&obj);
+        }
+        Ok(arr)
+    }
+    pub fn threshold(&self) -> f64 {
+        self.inner.threshold()
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
+#[wasm_bindgen(js_name = RunBars)]
+pub struct WasmRunBars {
+    inner: wc::RunBars,
+}
+
+#[wasm_bindgen(js_class = RunBars)]
+impl WasmRunBars {
+    #[wasm_bindgen(constructor)]
+    pub fn new(run_length: usize) -> Result<WasmRunBars, JsError> {
+        Ok(Self {
+            inner: wc::RunBars::new(run_length).map_err(map_err)?,
+        })
+    }
+    /// Returns an array of `{ open, high, low, close, length, direction }` bars completed on this candle.
+    pub fn update(&mut self, open: f64, high: f64, low: f64, close: f64) -> Result<Array, JsError> {
+        let candle = wc::Candle::new(open, high, low, close, 1.0, 0).map_err(map_err)?;
+        let arr = Array::new();
+        for b in self.inner.update(candle) {
+            let obj = Object::new();
+            Reflect::set(&obj, &"open".into(), &b.open.into()).ok();
+            Reflect::set(&obj, &"high".into(), &b.high.into()).ok();
+            Reflect::set(&obj, &"low".into(), &b.low.into()).ok();
+            Reflect::set(&obj, &"close".into(), &b.close.into()).ok();
+            #[allow(clippy::cast_precision_loss)]
+            Reflect::set(&obj, &"length".into(), &(b.length as f64).into()).ok();
+            Reflect::set(&obj, &"direction".into(), &f64::from(b.direction).into()).ok();
+            arr.push(&obj);
+        }
+        Ok(arr)
+    }
+    #[wasm_bindgen(js_name = runLength)]
+    pub fn run_length(&self) -> usize {
+        self.inner.run_length()
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
+#[wasm_bindgen(js_name = ThreeLineBreakBars)]
+pub struct WasmThreeLineBreakBars {
+    inner: wc::ThreeLineBreakBars,
+}
+
+#[wasm_bindgen(js_class = ThreeLineBreakBars)]
+impl WasmThreeLineBreakBars {
+    #[wasm_bindgen(constructor)]
+    pub fn new(lines: usize) -> Result<WasmThreeLineBreakBars, JsError> {
+        Ok(Self {
+            inner: wc::ThreeLineBreakBars::new(lines).map_err(map_err)?,
+        })
+    }
+    /// Returns an array of `{ open, close, direction }` bars completed on this close.
+    pub fn update(&mut self, close: f64) -> Result<Array, JsError> {
+        let candle = wc::Candle::new(close, close, close, close, 1.0, 0).map_err(map_err)?;
+        let arr = Array::new();
+        for b in self.inner.update(candle) {
+            let obj = Object::new();
+            Reflect::set(&obj, &"open".into(), &b.open.into()).ok();
+            Reflect::set(&obj, &"close".into(), &b.close.into()).ok();
+            Reflect::set(&obj, &"direction".into(), &f64::from(b.direction).into()).ok();
+            arr.push(&obj);
+        }
+        Ok(arr)
+    }
+    pub fn batch(&mut self, close: &[f64]) -> Result<Array, JsError> {
+        let arr = Array::new();
+        for &price in close {
+            let candle = wc::Candle::new(price, price, price, price, 1.0, 0).map_err(map_err)?;
+            for b in self.inner.update(candle) {
+                let obj = Object::new();
+                Reflect::set(&obj, &"open".into(), &b.open.into()).ok();
+                Reflect::set(&obj, &"close".into(), &b.close.into()).ok();
+                Reflect::set(&obj, &"direction".into(), &f64::from(b.direction).into()).ok();
+                arr.push(&obj);
+            }
+        }
+        Ok(arr)
+    }
+    pub fn lines(&self) -> usize {
+        self.inner.lines()
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
 #[wasm_bindgen(js_name = Alpha)]
 pub struct WasmAlpha {
     inner: wc::Alpha,

crates/wickra-core/src/indicators/dollar_bars.rs

@@ -0,0 +1,224 @@
+//! Dollar bar builder — close a bar each time accumulated traded value reaches a threshold.
+
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::BarBuilder;
+
+/// One completed dollar bar (an OHLC aggregate spanning ~`dollar_per_bar` of traded value).
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct DollarBar {
+    /// Open of the first candle in the bar.
+    pub open: f64,
+    /// Highest high across the bar.
+    pub high: f64,
+    /// Lowest low across the bar.
+    pub low: f64,
+    /// Close of the candle that closed the bar.
+    pub close: f64,
+    /// Summed volume across the bar.
+    pub volume: f64,
+    /// Accumulated traded value (`Σ close · volume`, `>= dollar_per_bar`).
+    pub dollar: f64,
+}
+
+/// Dollar bar builder — emits a bar each time accumulated traded value
+/// (`price × volume`) reaches `dollar_per_bar`.
+///
+/// Dollar bars are the most drift-robust of the information-driven bar types. Where
+/// [`VolumeBars`](crate::VolumeBars) close on a fixed *quantity* of shares/contracts,
+/// dollar bars close on a fixed *value*: each candle contributes `close × volume` to
+/// the running total. As a market's price level rises over years, a fixed share
+/// count buys ever more value and volume bars drift in meaning; dollar bars stay
+/// economically comparable across the whole history, which is why they are the
+/// preferred sampling for long backtests and machine-learning features.
+///
+/// The bar is candle-granular: at most one bar closes per candle, and the candle
+/// that crosses the threshold closes the bar with its overshoot included.
+/// [`BarBuilder::update`] returns either an empty vector or a single [`DollarBar`].
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{BarBuilder, Candle, DollarBars};
+///
+/// let c = |cl, v| Candle::new(cl, cl, cl, cl, v, 0).unwrap();
+/// let mut bars = DollarBars::new(1000.0).unwrap();
+/// assert!(bars.update(c(10.0, 60.0)).is_empty()); // 600
+/// let out = bars.update(c(10.0, 60.0)); // 1200 >= 1000 -> close
+/// assert_eq!(out.len(), 1);
+/// assert_eq!(out[0].dollar, 1200.0);
+/// ```
+#[derive(Debug, Clone)]
+pub struct DollarBars {
+    dollar_per_bar: f64,
+    count: usize,
+    open: f64,
+    high: f64,
+    low: f64,
+    close: f64,
+    volume: f64,
+    dollar: f64,
+}
+
+impl DollarBars {
+    /// Construct a dollar-bar builder with the given traded-value threshold.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::InvalidPeriod`] if `dollar_per_bar` is not finite and positive.
+    pub fn new(dollar_per_bar: f64) -> Result<Self> {
+        if !dollar_per_bar.is_finite() || dollar_per_bar <= 0.0 {
+            return Err(Error::InvalidPeriod {
+                message: "dollar_per_bar must be finite and positive",
+            });
+        }
+        Ok(Self {
+            dollar_per_bar,
+            count: 0,
+            open: 0.0,
+            high: 0.0,
+            low: 0.0,
+            close: 0.0,
+            volume: 0.0,
+            dollar: 0.0,
+        })
+    }
+
+    /// Configured traded-value threshold per bar.
+    pub const fn dollar_per_bar(&self) -> f64 {
+        self.dollar_per_bar
+    }
+
+    /// Traded value accumulated into the in-progress bar.
+    pub const fn accumulated(&self) -> f64 {
+        self.dollar
+    }
+}
+
+impl BarBuilder for DollarBars {
+    type Bar = DollarBar;
+
+    fn update(&mut self, candle: Candle) -> Vec<DollarBar> {
+        if self.count == 0 {
+            self.open = candle.open;
+            self.high = candle.high;
+            self.low = candle.low;
+            self.volume = 0.0;
+        } else {
+            self.high = self.high.max(candle.high);
+            self.low = self.low.min(candle.low);
+        }
+        self.close = candle.close;
+        self.volume += candle.volume;
+        self.dollar += candle.close * candle.volume;
+        self.count += 1;
+        if self.dollar < self.dollar_per_bar {
+            return Vec::new();
+        }
+        let bar = DollarBar {
+            open: self.open,
+            high: self.high,
+            low: self.low,
+            close: self.close,
+            volume: self.volume,
+            dollar: self.dollar,
+        };
+        self.count = 0;
+        self.dollar = 0.0;
+        vec![bar]
+    }
+
+    fn reset(&mut self) {
+        self.count = 0;
+        self.volume = 0.0;
+        self.dollar = 0.0;
+    }
+
+    fn name(&self) -> &'static str {
+        "DollarBars"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::assert_relative_eq;
+
+    fn candle(open: f64, high: f64, low: f64, close: f64, volume: f64) -> Candle {
+        Candle::new(open, high, low, close, volume, 0).unwrap()
+    }
+
+    #[test]
+    fn rejects_invalid_threshold() {
+        assert!(matches!(
+            DollarBars::new(0.0),
+            Err(Error::InvalidPeriod { .. })
+        ));
+        assert!(matches!(
+            DollarBars::new(-1000.0),
+            Err(Error::InvalidPeriod { .. })
+        ));
+        assert!(matches!(
+            DollarBars::new(f64::NAN),
+            Err(Error::InvalidPeriod { .. })
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let bars = DollarBars::new(50_000.0).unwrap();
+        assert_relative_eq!(bars.dollar_per_bar(), 50_000.0, epsilon = 1e-6);
+        assert_relative_eq!(bars.accumulated(), 0.0, epsilon = 1e-12);
+        assert_eq!(bars.name(), "DollarBars");
+    }
+
+    #[test]
+    fn closes_when_value_reached() {
+        let mut bars = DollarBars::new(1000.0).unwrap();
+        assert!(bars.update(candle(10.0, 10.0, 10.0, 10.0, 60.0)).is_empty()); // 600
+        let out = bars.update(candle(10.0, 10.0, 10.0, 10.0, 60.0)); // 1200
+        assert_eq!(out.len(), 1);
+        assert_relative_eq!(out[0].dollar, 1200.0, epsilon = 1e-9);
+        assert_relative_eq!(out[0].volume, 120.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn aggregates_ohlc() {
+        let mut bars = DollarBars::new(1000.0).unwrap();
+        bars.update(candle(10.0, 11.0, 9.0, 10.0, 50.0)); // 500
+        let out = bars.update(candle(10.0, 12.0, 9.5, 11.0, 60.0)); // 500 + 660 = 1160
+        assert_relative_eq!(out[0].open, 10.0, epsilon = 1e-12);
+        assert_relative_eq!(out[0].high, 12.0, epsilon = 1e-12);
+        assert_relative_eq!(out[0].low, 9.0, epsilon = 1e-12);
+        assert_relative_eq!(out[0].close, 11.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn below_threshold_emits_nothing() {
+        let mut bars = DollarBars::new(1000.0).unwrap();
+        bars.update(candle(10.0, 10.0, 10.0, 10.0, 30.0)); // 300
+        assert_relative_eq!(bars.accumulated(), 300.0, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut bars = DollarBars::new(1000.0).unwrap();
+        bars.update(candle(10.0, 10.0, 10.0, 10.0, 60.0));
+        bars.reset();
+        assert_relative_eq!(bars.accumulated(), 0.0, epsilon = 1e-12);
+        assert!(bars.update(candle(20.0, 20.0, 20.0, 20.0, 10.0)).is_empty());
+    }
+
+    #[test]
+    fn batch_concatenates_completed_bars() {
+        let mut bars = DollarBars::new(1000.0).unwrap();
+        let candles = [
+            candle(10.0, 10.0, 10.0, 10.0, 60.0),
+            candle(10.0, 10.0, 10.0, 10.0, 60.0),
+            candle(10.0, 10.0, 10.0, 10.0, 60.0),
+            candle(10.0, 10.0, 10.0, 10.0, 60.0),
+        ];
+        let out = bars.batch(&candles);
+        assert_eq!(out.len(), 2);
+    }
+}

crates/wickra-core/src/indicators/imbalance_bars.rs

@@ -0,0 +1,263 @@
+//! Tick-imbalance bar builder (simplified López de Prado) — sample on cumulative signed order flow.
+
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::BarBuilder;
+
+/// One completed imbalance bar.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct ImbalanceBar {
+    /// Open of the first candle in the bar.
+    pub open: f64,
+    /// Highest high across the bar.
+    pub high: f64,
+    /// Lowest low across the bar.
+    pub low: f64,
+    /// Close of the candle that closed the bar.
+    pub close: f64,
+    /// Signed cumulative tick imbalance at the close (`Σ sign`).
+    pub imbalance: f64,
+    /// `+1` if buy-side imbalance closed the bar, `-1` if sell-side.
+    pub direction: i8,
+}
+
+/// Tick-imbalance bar builder — a **simplified** form of López de Prado's
+/// imbalance bars.
+///
+/// Each candle is assigned a tick sign by the tick rule: `+1` if its close is above
+/// the previous close, `-1` if below, and the previous sign is carried on an
+/// unchanged close. The signed imbalance `θ = Σ sign` accumulates until its absolute
+/// value reaches a fixed `threshold`, at which point a bar closes. Imbalance bars
+/// therefore sample the market when order flow becomes *one-sided* — a burst of
+/// persistent buying or selling — rather than on time, count, or volume. This makes
+/// them sensitive to informed, directional trading.
+///
+/// **Simplification.** The full method estimates a *dynamic* threshold
+/// `E[T] · |2P − 1|` from an EWMA of the expected bar length `E[T]` and the buy-tick
+/// probability `P`, and can weight each sign by volume (volume-imbalance bars) or
+/// traded value (dollar-imbalance bars). This builder uses a **fixed** threshold on
+/// the unweighted tick imbalance. For the adaptive estimator and the volume/dollar
+/// variants, see López de Prado (2018), ch. 2.
+///
+/// At most one bar closes per candle, so [`BarBuilder::update`] returns either an
+/// empty vector or a single [`ImbalanceBar`].
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{BarBuilder, Candle, ImbalanceBars};
+///
+/// let flat = |price: f64| Candle::new(price, price, price, price, 1.0, 0).unwrap();
+/// let mut bars = ImbalanceBars::new(3.0).unwrap();
+/// bars.update(flat(10.0));            // seed, no sign
+/// bars.update(flat(11.0));            // +1
+/// bars.update(flat(12.0));            // +2
+/// let out = bars.update(flat(13.0));  // +3 -> close
+/// assert_eq!(out.len(), 1);
+/// assert_eq!(out[0].direction, 1);
+/// ```
+#[derive(Debug, Clone)]
+pub struct ImbalanceBars {
+    threshold: f64,
+    count: usize,
+    open: f64,
+    high: f64,
+    low: f64,
+    close: f64,
+    prev_close: Option<f64>,
+    last_sign: i8,
+    theta: f64,
+}
+
+impl ImbalanceBars {
+    /// Construct an imbalance-bar builder with the given absolute imbalance threshold.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::InvalidPeriod`] if `threshold` is not finite and positive.
+    pub fn new(threshold: f64) -> Result<Self> {
+        if !threshold.is_finite() || threshold <= 0.0 {
+            return Err(Error::InvalidPeriod {
+                message: "threshold must be finite and positive",
+            });
+        }
+        Ok(Self {
+            threshold,
+            count: 0,
+            open: 0.0,
+            high: 0.0,
+            low: 0.0,
+            close: 0.0,
+            prev_close: None,
+            last_sign: 0,
+            theta: 0.0,
+        })
+    }
+
+    /// Configured absolute imbalance threshold.
+    pub const fn threshold(&self) -> f64 {
+        self.threshold
+    }
+
+    /// Signed imbalance accumulated into the in-progress bar.
+    pub const fn imbalance(&self) -> f64 {
+        self.theta
+    }
+}
+
+impl BarBuilder for ImbalanceBars {
+    type Bar = ImbalanceBar;
+
+    fn update(&mut self, candle: Candle) -> Vec<ImbalanceBar> {
+        if self.count == 0 {
+            self.open = candle.open;
+            self.high = candle.high;
+            self.low = candle.low;
+        } else {
+            self.high = self.high.max(candle.high);
+            self.low = self.low.min(candle.low);
+        }
+        self.close = candle.close;
+        self.count += 1;
+        if let Some(prev) = self.prev_close {
+            let sign = if candle.close > prev {
+                1
+            } else if candle.close < prev {
+                -1
+            } else {
+                self.last_sign
+            };
+            self.last_sign = sign;
+            self.theta += f64::from(sign);
+        }
+        self.prev_close = Some(candle.close);
+        if self.theta.abs() < self.threshold {
+            return Vec::new();
+        }
+        let direction = if self.theta > 0.0 { 1 } else { -1 };
+        let bar = ImbalanceBar {
+            open: self.open,
+            high: self.high,
+            low: self.low,
+            close: self.close,
+            imbalance: self.theta,
+            direction,
+        };
+        self.count = 0;
+        self.theta = 0.0;
+        vec![bar]
+    }
+
+    fn reset(&mut self) {
+        self.count = 0;
+        self.prev_close = None;
+        self.last_sign = 0;
+        self.theta = 0.0;
+    }
+
+    fn name(&self) -> &'static str {
+        "ImbalanceBars"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::assert_relative_eq;
+
+    fn flat(price: f64) -> Candle {
+        Candle::new(price, price, price, price, 1.0, 0).unwrap()
+    }
+
+    #[test]
+    fn rejects_invalid_threshold() {
+        assert!(matches!(
+            ImbalanceBars::new(0.0),
+            Err(Error::InvalidPeriod { .. })
+        ));
+        assert!(matches!(
+            ImbalanceBars::new(-3.0),
+            Err(Error::InvalidPeriod { .. })
+        ));
+        assert!(matches!(
+            ImbalanceBars::new(f64::NAN),
+            Err(Error::InvalidPeriod { .. })
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let bars = ImbalanceBars::new(10.0).unwrap();
+        assert_relative_eq!(bars.threshold(), 10.0, epsilon = 1e-12);
+        assert_relative_eq!(bars.imbalance(), 0.0, epsilon = 1e-12);
+        assert_eq!(bars.name(), "ImbalanceBars");
+    }
+
+    #[test]
+    fn buy_imbalance_closes_up_bar() {
+        let mut bars = ImbalanceBars::new(3.0).unwrap();
+        bars.update(flat(10.0)); // seed
+        bars.update(flat(11.0)); // +1
+        bars.update(flat(12.0)); // +2
+        let out = bars.update(flat(13.0)); // +3
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].direction, 1);
+        assert_relative_eq!(out[0].imbalance, 3.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn sell_imbalance_closes_down_bar() {
+        let mut bars = ImbalanceBars::new(3.0).unwrap();
+        bars.update(flat(10.0));
+        bars.update(flat(9.0)); // -1
+        bars.update(flat(8.0)); // -2
+        let out = bars.update(flat(7.0)); // -3
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].direction, -1);
+    }
+
+    #[test]
+    fn flat_tick_carries_previous_sign() {
+        let mut bars = ImbalanceBars::new(3.0).unwrap();
+        bars.update(flat(10.0));
+        bars.update(flat(11.0)); // +1
+        bars.update(flat(11.0)); // flat -> carries +1 -> +2
+        assert_relative_eq!(bars.imbalance(), 2.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn oscillation_does_not_reach_threshold() {
+        let mut bars = ImbalanceBars::new(3.0).unwrap();
+        bars.update(flat(10.0));
+        bars.update(flat(11.0)); // +1
+        bars.update(flat(10.0)); // -1 -> theta 0
+        assert!(bars.update(flat(11.0)).is_empty()); // +1
+        assert_relative_eq!(bars.imbalance(), 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut bars = ImbalanceBars::new(3.0).unwrap();
+        bars.update(flat(10.0));
+        bars.update(flat(11.0));
+        bars.reset();
+        assert_relative_eq!(bars.imbalance(), 0.0, epsilon = 1e-12);
+        // After reset the next candle re-seeds (no previous close).
+        assert!(bars.update(flat(50.0)).is_empty());
+    }
+
+    #[test]
+    fn batch_concatenates_completed_bars() {
+        let mut bars = ImbalanceBars::new(2.0).unwrap();
+        let candles = [
+            flat(10.0),
+            flat(11.0), // +1
+            flat(12.0), // +2 -> close
+            flat(13.0), // +1
+            flat(14.0), // +2 -> close
+        ];
+        let out = bars.batch(&candles);
+        assert_eq!(out.len(), 2);
+        assert!(out.iter().all(|b| b.direction == 1));
+    }
+}

crates/wickra-core/src/indicators/mod.rs

@@ -112,6 +112,7 @@ mod disparity_index;
 mod distance_ssd;
 mod doji;
 mod doji_star;
+mod dollar_bars;
 mod donchian;
 mod donchian_stop;
 mod double_bollinger;
@@ -204,6 +205,7 @@ mod hurst_channel;
 mod hurst_exponent;
 mod ichimoku;
 mod identical_three_crows;
+mod imbalance_bars;
 mod in_neck;
 mod inertia;
 mod information_ratio;
@@ -331,6 +333,7 @@ mod qstick;
 mod quartile_bands;
 mod quoted_spread;
 mod r_squared;
+mod range_bars;
 mod realized_spread;
 mod realized_volatility;
 mod recovery_factor;
@@ -358,6 +361,7 @@ mod rolling_quantile;
 mod roofing_filter;
 mod rsi;
 mod rsx;
+mod run_bars;
 mod rvi;
 mod rvi_volatility;
 mod rwi;
@@ -431,11 +435,13 @@ mod term_structure_basis;
 mod three_drives;
 mod three_inside;
 mod three_line_break;
+mod three_line_break_bars;
 mod three_line_strike;
 mod three_outside;
 mod three_soldiers_or_crows;
 mod three_stars_in_south;
 mod thrusting;
+mod tick_bars;
 mod tick_index;
 mod tii;
 mod time_based_stop;
@@ -485,6 +491,7 @@ mod volatility_cone;
 mod volatility_of_volatility;
 mod volatility_ratio;
 mod volty_stop;
+mod volume_bars;
 mod volume_by_time_profile;
 mod volume_oscillator;
 mod volume_profile;
@@ -619,6 +626,7 @@ pub use disparity_index::DisparityIndex;
 pub use distance_ssd::DistanceSsd;
 pub use doji::Doji;
 pub use doji_star::DojiStar;
+pub use dollar_bars::{DollarBar, DollarBars};
 pub use donchian::{Donchian, DonchianOutput};
 pub use donchian_stop::{DonchianStop, DonchianStopOutput};
 pub use double_bollinger::{DoubleBollinger, DoubleBollingerOutput};
@@ -711,6 +719,7 @@ pub use hurst_channel::{HurstChannel, HurstChannelOutput};
 pub use hurst_exponent::HurstExponent;
 pub use ichimoku::{Ichimoku, IchimokuOutput};
 pub use identical_three_crows::IdenticalThreeCrows;
+pub use imbalance_bars::{ImbalanceBar, ImbalanceBars};
 pub use in_neck::InNeck;
 pub use inertia::Inertia;
 pub use information_ratio::InformationRatio;
@@ -838,6 +847,7 @@ pub use qstick::Qstick;
 pub use quartile_bands::{QuartileBands, QuartileBandsOutput};
 pub use quoted_spread::QuotedSpread;
 pub use r_squared::RSquared;
+pub use range_bars::{RangeBar, RangeBars};
 pub use realized_spread::RealizedSpread;
 pub use realized_volatility::RealizedVolatility;
 pub use recovery_factor::RecoveryFactor;
@@ -865,6 +875,7 @@ pub use rolling_quantile::RollingQuantile;
 pub use roofing_filter::RoofingFilter;
 pub use rsi::Rsi;
 pub use rsx::Rsx;
+pub use run_bars::{RunBar, RunBars};
 pub use rvi::Rvi;
 pub use rvi_volatility::RviVolatility;
 pub use rwi::{Rwi, RwiOutput};
@@ -938,11 +949,13 @@ pub use term_structure_basis::TermStructureBasis;
 pub use three_drives::ThreeDrives;
 pub use three_inside::ThreeInside;
 pub use three_line_break::ThreeLineBreak;
+pub use three_line_break_bars::{LineBreakBar, ThreeLineBreakBars};
 pub use three_line_strike::ThreeLineStrike;
 pub use three_outside::ThreeOutside;
 pub use three_soldiers_or_crows::ThreeSoldiersOrCrows;
 pub use three_stars_in_south::ThreeStarsInSouth;
 pub use thrusting::Thrusting;
+pub use tick_bars::{TickBar, TickBars};
 pub use tick_index::TickIndex;
 pub use tii::Tii;
 pub use time_based_stop::TimeBasedStop;
@@ -992,6 +1005,7 @@ pub use volatility_cone::{VolatilityCone, VolatilityConeOutput};
 pub use volatility_of_volatility::VolatilityOfVolatility;
 pub use volatility_ratio::VolatilityRatio;
 pub use volty_stop::VoltyStop;
+pub use volume_bars::{VolumeBar, VolumeBars};
 pub use volume_by_time_profile::{VolumeByTimeProfile, VolumeByTimeProfileOutput};
 pub use volume_oscillator::VolumeOscillator;
 pub use volume_profile::{VolumeProfile, VolumeProfileOutput};
@@ -1573,7 +1587,18 @@ pub const FAMILIES: &[(&str, &[&str])] = &[
     ),
     (
         "Alt-Chart Bars",
-        &["RenkoBars", "KagiBars", "PointAndFigureBars"],
+        &[
+            "RenkoBars",
+            "KagiBars",
+            "PointAndFigureBars",
+            "RangeBars",
+            "TickBars",
+            "VolumeBars",
+            "DollarBars",
+            "ImbalanceBars",
+            "RunBars",
+            "ThreeLineBreakBars",
+        ],
     ),
     (
         "Market Breadth",
@@ -1681,6 +1706,6 @@ mod family_tests {
         // the actual indicator count is the early-warning signal that an
         // indicator was added without being assigned a family.
         let total: usize = FAMILIES.iter().map(|(_, ns)| ns.len()).sum();
-        assert_eq!(total, 507, "FAMILIES total drifted from indicator count");
+        assert_eq!(total, 514, "FAMILIES total drifted from indicator count");
     }
 }

crates/wickra-core/src/indicators/range_bars.rs

@@ -0,0 +1,227 @@
+//! Range bar builder — fixed price-range bars with no reversal penalty.
+
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::BarBuilder;
+
+/// One completed range bar.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct RangeBar {
+    /// Price at the bar's origin edge.
+    pub open: f64,
+    /// Price at the bar's far edge (`open ± range`).
+    pub close: f64,
+    /// `+1` for an up bar, `-1` for a down bar.
+    pub direction: i8,
+}
+
+/// Range bar builder using a fixed price increment on close prices.
+///
+/// A range bar completes every time price travels a fixed `range` from the current
+/// anchor, in *either* direction. This is the key difference from
+/// [`RenkoBars`](crate::RenkoBars): Renko imposes a `2 * box_size` penalty to
+/// reverse direction, so it filters out small oscillations; range bars have **no
+/// reversal penalty** — a move of exactly `range` against the trend prints a bar
+/// immediately. Range bars therefore track every leg of price movement, while Renko
+/// smooths them.
+///
+/// Construction rules:
+///
+/// - The first candle seeds the anchor and prints no bar.
+/// - Each subsequent candle prints one bar for every `range` of close movement away
+///   from the anchor; a candle that gaps several ranges prints them all in one
+///   [`BarBuilder::update`] call.
+/// - Bars are aligned to the `range` grid relative to the seed price.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{BarBuilder, Candle, RangeBars};
+///
+/// let flat = |price: f64| Candle::new(price, price, price, price, 1.0, 0).unwrap();
+/// let mut bars = RangeBars::new(1.0).unwrap();
+/// assert!(bars.update(flat(10.0)).is_empty()); // seed
+/// let up = bars.update(flat(12.0)); // +2 ranges
+/// assert_eq!(up.len(), 2);
+/// let down = bars.update(flat(11.0)); // -1 range, no penalty
+/// assert_eq!(down.len(), 1);
+/// ```
+#[derive(Debug, Clone)]
+pub struct RangeBars {
+    range: f64,
+    anchor: Option<f64>,
+}
+
+impl RangeBars {
+    /// Construct a range-bar builder with the given price increment.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::InvalidPeriod`] if `range` is not finite and positive.
+    pub fn new(range: f64) -> Result<Self> {
+        if !range.is_finite() || range <= 0.0 {
+            return Err(Error::InvalidPeriod {
+                message: "range must be finite and positive",
+            });
+        }
+        Ok(Self {
+            range,
+            anchor: None,
+        })
+    }
+
+    /// Configured price range.
+    pub const fn range(&self) -> f64 {
+        self.range
+    }
+
+    /// Current anchor level (the close of the last completed bar, or the seed
+    /// price before any bar has formed).
+    pub const fn anchor(&self) -> Option<f64> {
+        self.anchor
+    }
+}
+
+impl BarBuilder for RangeBars {
+    type Bar = RangeBar;
+
+    fn update(&mut self, candle: Candle) -> Vec<RangeBar> {
+        let close = candle.close;
+        let Some(mut anchor) = self.anchor else {
+            self.anchor = Some(close);
+            return Vec::new();
+        };
+        let range = self.range;
+        let mut bars = Vec::new();
+        while close >= anchor + range {
+            bars.push(RangeBar {
+                open: anchor,
+                close: anchor + range,
+                direction: 1,
+            });
+            anchor += range;
+        }
+        while close <= anchor - range {
+            bars.push(RangeBar {
+                open: anchor,
+                close: anchor - range,
+                direction: -1,
+            });
+            anchor -= range;
+        }
+        self.anchor = Some(anchor);
+        bars
+    }
+
+    fn reset(&mut self) {
+        self.anchor = None;
+    }
+
+    fn name(&self) -> &'static str {
+        "RangeBars"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::assert_relative_eq;
+
+    fn flat(price: f64) -> Candle {
+        Candle::new(price, price, price, price, 1.0, 0).unwrap()
+    }
+
+    #[test]
+    fn rejects_invalid_range() {
+        assert!(matches!(
+            RangeBars::new(0.0),
+            Err(Error::InvalidPeriod { .. })
+        ));
+        assert!(matches!(
+            RangeBars::new(-1.0),
+            Err(Error::InvalidPeriod { .. })
+        ));
+        assert!(matches!(
+            RangeBars::new(f64::NAN),
+            Err(Error::InvalidPeriod { .. })
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let bars = RangeBars::new(2.5).unwrap();
+        assert_eq!(bars.name(), "RangeBars");
+        assert_relative_eq!(bars.range(), 2.5, epsilon = 1e-12);
+        assert_eq!(bars.anchor(), None);
+    }
+
+    #[test]
+    fn first_candle_seeds_without_bar() {
+        let mut bars = RangeBars::new(1.0).unwrap();
+        assert!(bars.update(flat(10.0)).is_empty());
+        assert_eq!(bars.anchor(), Some(10.0));
+    }
+
+    #[test]
+    fn up_move_prints_aligned_bars() {
+        let mut bars = RangeBars::new(1.0).unwrap();
+        bars.update(flat(10.0));
+        let up = bars.update(flat(13.0));
+        assert_eq!(up.len(), 3);
+        assert_relative_eq!(up[0].open, 10.0, epsilon = 1e-12);
+        assert_relative_eq!(up[2].close, 13.0, epsilon = 1e-12);
+        assert!(up.iter().all(|b| b.direction == 1));
+        assert_eq!(bars.anchor(), Some(13.0));
+    }
+
+    #[test]
+    fn down_move_prints_aligned_bars() {
+        let mut bars = RangeBars::new(1.0).unwrap();
+        bars.update(flat(10.0));
+        let down = bars.update(flat(7.0));
+        assert_eq!(down.len(), 3);
+        assert!(down.iter().all(|b| b.direction == -1));
+        assert_relative_eq!(down[2].close, 7.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn reversal_needs_only_one_range() {
+        // Unlike Renko, a single-range move against the trend prints immediately.
+        let mut bars = RangeBars::new(1.0).unwrap();
+        bars.update(flat(10.0));
+        bars.update(flat(12.0)); // anchor 12, up
+        let down = bars.update(flat(11.0)); // drop of exactly one range
+        assert_eq!(down.len(), 1);
+        assert_eq!(down[0].direction, -1);
+        assert_relative_eq!(down[0].close, 11.0, epsilon = 1e-12);
+        assert_eq!(bars.anchor(), Some(11.0));
+    }
+
+    #[test]
+    fn small_move_prints_nothing() {
+        let mut bars = RangeBars::new(1.0).unwrap();
+        bars.update(flat(10.0));
+        assert!(bars.update(flat(10.5)).is_empty());
+        assert_eq!(bars.anchor(), Some(10.0));
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut bars = RangeBars::new(1.0).unwrap();
+        bars.update(flat(10.0));
+        bars.update(flat(13.0));
+        bars.reset();
+        assert_eq!(bars.anchor(), None);
+        assert!(bars.update(flat(50.0)).is_empty());
+        assert_eq!(bars.anchor(), Some(50.0));
+    }
+
+    #[test]
+    fn batch_concatenates_completed_bars() {
+        let mut bars = RangeBars::new(1.0).unwrap();
+        let candles = [flat(10.0), flat(12.0), flat(13.0)];
+        let out = bars.batch(&candles);
+        assert_eq!(out.len(), 3);
+        assert!(out.iter().all(|b| b.direction == 1));
+    }
+}

crates/wickra-core/src/indicators/run_bars.rs

@@ -0,0 +1,257 @@
+//! Run bar builder (simplified López de Prado) — sample on runs of same-signed ticks.
+
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::BarBuilder;
+
+/// One completed run bar.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct RunBar {
+    /// Open of the first candle in the bar.
+    pub open: f64,
+    /// Highest high across the bar.
+    pub high: f64,
+    /// Lowest low across the bar.
+    pub low: f64,
+    /// Close of the candle that closed the bar.
+    pub close: f64,
+    /// Length of the run that closed the bar (`== run_length`).
+    pub length: usize,
+    /// `+1` if a buy run closed the bar, `-1` if a sell run.
+    pub direction: i8,
+}
+
+/// Run bar builder — a **simplified** form of López de Prado's run bars.
+///
+/// A *run* is an uninterrupted sequence of same-signed ticks: a streak of up-ticks
+/// (a buy run) or down-ticks (a sell run), with unchanged closes extending the
+/// current run. This builder counts the current run's length and closes a bar when
+/// it reaches `run_length`; a tick in the opposite direction restarts the run from
+/// one. Where [`ImbalanceBars`](crate::ImbalanceBars) sample on the *net* signed
+/// imbalance (which oscillating flow can cancel back to zero), run bars sample on
+/// *persistence*: they fire only when the market pushes the same way without
+/// interruption, making them a cleaner sequential-trend detector.
+///
+/// **Simplification.** The full method estimates a *dynamic* expected run length
+/// from an EWMA and can weight runs by volume or traded value. This builder uses a
+/// **fixed** run-length threshold on unweighted ticks. See López de Prado (2018),
+/// ch. 2, for the adaptive estimator and weighted variants.
+///
+/// At most one bar closes per candle, so [`BarBuilder::update`] returns either an
+/// empty vector or a single [`RunBar`].
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{BarBuilder, Candle, RunBars};
+///
+/// let flat = |price: f64| Candle::new(price, price, price, price, 1.0, 0).unwrap();
+/// let mut bars = RunBars::new(3).unwrap();
+/// bars.update(flat(10.0));            // seed
+/// bars.update(flat(11.0));            // run 1
+/// bars.update(flat(12.0));            // run 2
+/// let out = bars.update(flat(13.0));  // run 3 -> close
+/// assert_eq!(out.len(), 1);
+/// assert_eq!(out[0].direction, 1);
+/// ```
+#[derive(Debug, Clone)]
+pub struct RunBars {
+    run_length: usize,
+    count: usize,
+    open: f64,
+    high: f64,
+    low: f64,
+    close: f64,
+    prev_close: Option<f64>,
+    run_sign: i8,
+    run_len: usize,
+}
+
+impl RunBars {
+    /// Construct a run-bar builder that closes a bar on a run of `run_length` ticks.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::PeriodZero`] if `run_length == 0`.
+    pub fn new(run_length: usize) -> Result<Self> {
+        if run_length == 0 {
+            return Err(Error::PeriodZero);
+        }
+        Ok(Self {
+            run_length,
+            count: 0,
+            open: 0.0,
+            high: 0.0,
+            low: 0.0,
+            close: 0.0,
+            prev_close: None,
+            run_sign: 0,
+            run_len: 0,
+        })
+    }
+
+    /// Configured run length that closes a bar.
+    pub const fn run_length(&self) -> usize {
+        self.run_length
+    }
+
+    /// Length of the in-progress run.
+    pub const fn run(&self) -> usize {
+        self.run_len
+    }
+}
+
+impl BarBuilder for RunBars {
+    type Bar = RunBar;
+
+    fn update(&mut self, candle: Candle) -> Vec<RunBar> {
+        if self.count == 0 {
+            self.open = candle.open;
+            self.high = candle.high;
+            self.low = candle.low;
+        } else {
+            self.high = self.high.max(candle.high);
+            self.low = self.low.min(candle.low);
+        }
+        self.close = candle.close;
+        self.count += 1;
+        if let Some(prev) = self.prev_close {
+            let directional = if candle.close > prev {
+                1
+            } else if candle.close < prev {
+                -1
+            } else {
+                0
+            };
+            if directional == 0 {
+                // A flat tick extends the current run (if one is under way).
+                if self.run_sign != 0 {
+                    self.run_len += 1;
+                }
+            } else if directional == self.run_sign {
+                self.run_len += 1;
+            } else {
+                self.run_sign = directional;
+                self.run_len = 1;
+            }
+        }
+        self.prev_close = Some(candle.close);
+        if self.run_sign == 0 || self.run_len < self.run_length {
+            return Vec::new();
+        }
+        let bar = RunBar {
+            open: self.open,
+            high: self.high,
+            low: self.low,
+            close: self.close,
+            length: self.run_len,
+            direction: self.run_sign,
+        };
+        self.count = 0;
+        self.run_sign = 0;
+        self.run_len = 0;
+        vec![bar]
+    }
+
+    fn reset(&mut self) {
+        self.count = 0;
+        self.prev_close = None;
+        self.run_sign = 0;
+        self.run_len = 0;
+    }
+
+    fn name(&self) -> &'static str {
+        "RunBars"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn flat(price: f64) -> Candle {
+        Candle::new(price, price, price, price, 1.0, 0).unwrap()
+    }
+
+    #[test]
+    fn rejects_zero_run_length() {
+        assert!(matches!(RunBars::new(0), Err(Error::PeriodZero)));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let bars = RunBars::new(5).unwrap();
+        assert_eq!(bars.run_length(), 5);
+        assert_eq!(bars.run(), 0);
+        assert_eq!(bars.name(), "RunBars");
+    }
+
+    #[test]
+    fn buy_run_closes_up_bar() {
+        let mut bars = RunBars::new(3).unwrap();
+        bars.update(flat(10.0)); // seed
+        bars.update(flat(11.0)); // run 1
+        bars.update(flat(12.0)); // run 2
+        let out = bars.update(flat(13.0)); // run 3
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].direction, 1);
+        assert_eq!(out[0].length, 3);
+    }
+
+    #[test]
+    fn sell_run_closes_down_bar() {
+        let mut bars = RunBars::new(3).unwrap();
+        bars.update(flat(10.0));
+        bars.update(flat(9.0)); // run 1
+        bars.update(flat(8.0)); // run 2
+        let out = bars.update(flat(7.0)); // run 3
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].direction, -1);
+    }
+
+    #[test]
+    fn opposite_tick_restarts_run() {
+        let mut bars = RunBars::new(3).unwrap();
+        bars.update(flat(10.0));
+        bars.update(flat(11.0)); // up run 1
+        bars.update(flat(12.0)); // up run 2
+        bars.update(flat(11.0)); // down -> run restarts at 1
+        assert_eq!(bars.run(), 1);
+    }
+
+    #[test]
+    fn flat_tick_extends_run() {
+        let mut bars = RunBars::new(3).unwrap();
+        bars.update(flat(10.0));
+        bars.update(flat(11.0)); // run 1
+        bars.update(flat(11.0)); // flat -> run 2
+        let out = bars.update(flat(12.0)); // run 3
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].direction, 1);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut bars = RunBars::new(3).unwrap();
+        bars.update(flat(10.0));
+        bars.update(flat(11.0));
+        bars.reset();
+        assert_eq!(bars.run(), 0);
+        assert!(bars.update(flat(50.0)).is_empty());
+    }
+
+    #[test]
+    fn batch_concatenates_completed_bars() {
+        let mut bars = RunBars::new(2).unwrap();
+        let candles = [
+            flat(10.0),
+            flat(11.0), // run 1
+            flat(12.0), // run 2 -> close
+            flat(13.0), // run 1
+            flat(14.0), // run 2 -> close
+        ];
+        let out = bars.batch(&candles);
+        assert_eq!(out.len(), 2);
+        assert!(out.iter().all(|b| b.direction == 1));
+    }
+}

crates/wickra-core/src/indicators/three_line_break_bars.rs

@@ -0,0 +1,305 @@
+//! Three-Line-Break bar builder — line-break chart segments driven by close prices.
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::BarBuilder;
+
+/// One completed line-break line.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct LineBreakBar {
+    /// Price where the line began (the previous line's far edge).
+    pub open: f64,
+    /// Price where the line ended (the new close that drew it).
+    pub close: f64,
+    /// `+1` for a rising line, `-1` for a falling line.
+    pub direction: i8,
+}
+
+/// Three-Line-Break bar builder using the classic close-based reversal rule.
+///
+/// A line-break chart draws a new line in the trend direction whenever the close
+/// makes a new extreme, and only reverses when the close breaks the extreme of the
+/// previous `lines` lines (three by default — hence "three-line break"). This filters
+/// minor noise: a pullback that fails to exceed the last three lines is ignored
+/// entirely, so the chart isolates meaningful reversals.
+///
+/// This is the **bar-builder** counterpart of the
+/// [`ThreeLineBreak`](crate::ThreeLineBreak) indicator: the indicator reports the
+/// current line *state* as a streaming value, whereas this builder emits each
+/// completed line as a [`LineBreakBar`] so you can reconstruct the full line-break
+/// chart. At most one line forms per candle, so [`BarBuilder::update`] returns either
+/// an empty vector or a single bar.
+///
+/// Construction rules:
+///
+/// - The first candle seeds a reference close and prints nothing.
+/// - The first subsequent move (up or down) draws the first line.
+/// - In an up-trend a close above the last line's top extends it (a new up line); a
+///   close below the lowest low of the last `lines` lines reverses to a down line.
+///   The down-trend is symmetric.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{BarBuilder, Candle, ThreeLineBreakBars};
+///
+/// let flat = |price: f64| Candle::new(price, price, price, price, 1.0, 0).unwrap();
+/// let mut bars = ThreeLineBreakBars::new(3).unwrap();
+/// bars.update(flat(10.0));           // seed
+/// let first = bars.update(flat(11.0)); // first up line
+/// assert_eq!(first.len(), 1);
+/// assert_eq!(first[0].direction, 1);
+/// ```
+#[derive(Debug, Clone)]
+pub struct ThreeLineBreakBars {
+    lines: usize,
+    seed: Option<f64>,
+    recent: VecDeque<LineBreakBar>,
+}
+
+impl ThreeLineBreakBars {
+    /// Construct a line-break builder that reverses on a break of the last `lines`
+    /// lines (3 for the classic three-line break).
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::PeriodZero`] if `lines == 0`.
+    pub fn new(lines: usize) -> Result<Self> {
+        if lines == 0 {
+            return Err(Error::PeriodZero);
+        }
+        Ok(Self {
+            lines,
+            seed: None,
+            recent: VecDeque::with_capacity(lines),
+        })
+    }
+
+    /// Configured number of lines a reversal must break.
+    pub const fn lines(&self) -> usize {
+        self.lines
+    }
+
+    /// Number of recent lines currently tracked for the reversal test.
+    pub fn tracked(&self) -> usize {
+        self.recent.len()
+    }
+
+    fn push_line(&mut self, bar: LineBreakBar) {
+        if self.recent.len() == self.lines {
+            self.recent.pop_front();
+        }
+        self.recent.push_back(bar);
+    }
+
+    fn lowest_low(&self) -> f64 {
+        self.recent
+            .iter()
+            .map(|bar| bar.open.min(bar.close))
+            .fold(f64::INFINITY, f64::min)
+    }
+
+    fn highest_high(&self) -> f64 {
+        self.recent
+            .iter()
+            .map(|bar| bar.open.max(bar.close))
+            .fold(f64::NEG_INFINITY, f64::max)
+    }
+}
+
+impl BarBuilder for ThreeLineBreakBars {
+    type Bar = LineBreakBar;
+
+    fn update(&mut self, candle: Candle) -> Vec<LineBreakBar> {
+        let close = candle.close;
+        let Some(last) = self.recent.back().copied() else {
+            // No line yet: seed, then draw the first line on the first move.
+            let Some(seed) = self.seed else {
+                self.seed = Some(close);
+                return Vec::new();
+            };
+            let bar = if close > seed {
+                LineBreakBar {
+                    open: seed,
+                    close,
+                    direction: 1,
+                }
+            } else if close < seed {
+                LineBreakBar {
+                    open: seed,
+                    close,
+                    direction: -1,
+                }
+            } else {
+                return Vec::new();
+            };
+            self.push_line(bar);
+            return vec![bar];
+        };
+        let new_bar = if last.direction > 0 {
+            if close > last.close {
+                Some(LineBreakBar {
+                    open: last.close,
+                    close,
+                    direction: 1,
+                })
+            } else if close < self.lowest_low() {
+                Some(LineBreakBar {
+                    open: last.close,
+                    close,
+                    direction: -1,
+                })
+            } else {
+                None
+            }
+        } else if close < last.close {
+            Some(LineBreakBar {
+                open: last.close,
+                close,
+                direction: -1,
+            })
+        } else if close > self.highest_high() {
+            Some(LineBreakBar {
+                open: last.close,
+                close,
+                direction: 1,
+            })
+        } else {
+            None
+        };
+        if let Some(bar) = new_bar {
+            self.push_line(bar);
+            vec![bar]
+        } else {
+            Vec::new()
+        }
+    }
+
+    fn reset(&mut self) {
+        self.seed = None;
+        self.recent.clear();
+    }
+
+    fn name(&self) -> &'static str {
+        "ThreeLineBreakBars"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::assert_relative_eq;
+
+    fn flat(price: f64) -> Candle {
+        Candle::new(price, price, price, price, 1.0, 0).unwrap()
+    }
+
+    #[test]
+    fn rejects_zero_lines() {
+        assert!(matches!(ThreeLineBreakBars::new(0), Err(Error::PeriodZero)));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let bars = ThreeLineBreakBars::new(3).unwrap();
+        assert_eq!(bars.lines(), 3);
+        assert_eq!(bars.tracked(), 0);
+        assert_eq!(bars.name(), "ThreeLineBreakBars");
+    }
+
+    #[test]
+    fn seed_then_first_line() {
+        let mut bars = ThreeLineBreakBars::new(3).unwrap();
+        assert!(bars.update(flat(10.0)).is_empty()); // seed
+        let first = bars.update(flat(11.0));
+        assert_eq!(first.len(), 1);
+        assert_eq!(first[0].direction, 1);
+        assert_relative_eq!(first[0].open, 10.0, epsilon = 1e-12);
+        assert_relative_eq!(first[0].close, 11.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn new_high_extends_up_line() {
+        let mut bars = ThreeLineBreakBars::new(3).unwrap();
+        bars.update(flat(10.0));
+        bars.update(flat(11.0)); // line 1 up
+        let cont = bars.update(flat(12.0)); // new high -> extend
+        assert_eq!(cont.len(), 1);
+        assert_eq!(cont[0].direction, 1);
+        assert_relative_eq!(cont[0].open, 11.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn small_pullback_prints_nothing() {
+        let mut bars = ThreeLineBreakBars::new(3).unwrap();
+        bars.update(flat(10.0));
+        bars.update(flat(11.0)); // line 1
+        bars.update(flat(12.0)); // line 2
+        bars.update(flat(13.0)); // line 3, lows are 10/11/12
+        assert!(bars.update(flat(10.5)).is_empty()); // not > 13, not < 10
+    }
+
+    #[test]
+    fn reversal_breaks_three_lines() {
+        let mut bars = ThreeLineBreakBars::new(3).unwrap();
+        bars.update(flat(10.0));
+        bars.update(flat(11.0)); // line 1, low 10
+        bars.update(flat(12.0)); // line 2, low 11
+        bars.update(flat(13.0)); // line 3, low 12
+        let rev = bars.update(flat(9.0)); // 9 < lowest low 10 -> reverse
+        assert_eq!(rev.len(), 1);
+        assert_eq!(rev[0].direction, -1);
+        assert_relative_eq!(rev[0].open, 13.0, epsilon = 1e-12);
+        assert_relative_eq!(rev[0].close, 9.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut bars = ThreeLineBreakBars::new(3).unwrap();
+        bars.update(flat(10.0));
+        bars.update(flat(11.0));
+        bars.reset();
+        assert_eq!(bars.tracked(), 0);
+        assert!(bars.update(flat(50.0)).is_empty()); // re-seeds
+    }
+
+    #[test]
+    fn flat_first_move_prints_nothing() {
+        let mut bars = ThreeLineBreakBars::new(3).unwrap();
+        assert!(bars.update(flat(10.0)).is_empty()); // seed
+        assert!(bars.update(flat(10.0)).is_empty()); // equal to seed -> no line
+    }
+
+    #[test]
+    fn first_line_down_then_down_trend_and_reversal() {
+        let mut bars = ThreeLineBreakBars::new(3).unwrap();
+        assert!(bars.update(flat(10.0)).is_empty()); // seed
+        let first = bars.update(flat(9.0)); // first line down
+        assert_eq!(first.len(), 1);
+        assert_eq!(first[0].direction, -1);
+        assert_relative_eq!(first[0].open, 10.0, epsilon = 1e-12);
+        assert_relative_eq!(first[0].close, 9.0, epsilon = 1e-12);
+        let cont = bars.update(flat(8.0)); // new low extends the down line
+        assert_eq!(cont.len(), 1);
+        assert_eq!(cont[0].direction, -1);
+        assert_relative_eq!(cont[0].open, 9.0, epsilon = 1e-12);
+        bars.update(flat(7.0)); // third down line; highs are 10/9/8
+        assert!(bars.update(flat(7.5)).is_empty()); // not < 7, not > highest high 10
+        let rev = bars.update(flat(11.0)); // > highest high 10 -> reverse up
+        assert_eq!(rev.len(), 1);
+        assert_eq!(rev[0].direction, 1);
+        assert_relative_eq!(rev[0].open, 7.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn batch_concatenates_completed_lines() {
+        let mut bars = ThreeLineBreakBars::new(3).unwrap();
+        let candles = [flat(10.0), flat(11.0), flat(12.0), flat(13.0)];
+        let out = bars.batch(&candles);
+        // seed at 10, then three rising lines.
+        assert_eq!(out.len(), 3);
+        assert!(out.iter().all(|b| b.direction == 1));
+    }
+}

crates/wickra-core/src/indicators/tick_bars.rs

@@ -0,0 +1,209 @@
+//! Tick bar builder — aggregate a fixed number of candles into one OHLCV bar.
+
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::BarBuilder;
+
+/// One completed tick bar (an OHLCV aggregate of `ticks` input candles).
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct TickBar {
+    /// Open of the first candle in the group.
+    pub open: f64,
+    /// Highest high across the group.
+    pub high: f64,
+    /// Lowest low across the group.
+    pub low: f64,
+    /// Close of the last candle in the group.
+    pub close: f64,
+    /// Summed volume across the group.
+    pub volume: f64,
+}
+
+/// Tick bar builder — emits one OHLCV bar for every `ticks` input candles.
+///
+/// Classic time bars (1-minute, 1-hour) sample the market on a clock; tick bars
+/// sample it on *activity* by grouping a fixed number of trades — here modelled as a
+/// fixed number of input candles. In fast markets a tick bar closes quickly; in
+/// quiet markets it takes longer, so each bar carries roughly equal information
+/// content. This is the simplest of the information-driven bar types; the
+/// [`VolumeBars`](crate::VolumeBars) and [`DollarBars`](crate::DollarBars) builders
+/// extend the idea to equal traded volume and equal traded value respectively.
+///
+/// The open is the first candle's open, the high and low are the extremes across the
+/// group, the close is the last candle's close, and the volume is the group sum.
+/// Exactly one bar completes every `ticks` candles, so [`BarBuilder::update`]
+/// returns either an empty vector or a single [`TickBar`].
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{BarBuilder, Candle, TickBars};
+///
+/// let c = |o, h, l, cl, v| Candle::new(o, h, l, cl, v, 0).unwrap();
+/// let mut bars = TickBars::new(3).unwrap();
+/// assert!(bars.update(c(10.0, 11.0, 9.0, 10.5, 100.0)).is_empty());
+/// assert!(bars.update(c(10.5, 12.0, 10.0, 11.0, 150.0)).is_empty());
+/// let out = bars.update(c(11.0, 11.5, 10.8, 11.2, 120.0));
+/// assert_eq!(out.len(), 1);
+/// assert_eq!(out[0].volume, 370.0);
+/// ```
+#[derive(Debug, Clone)]
+pub struct TickBars {
+    ticks: usize,
+    count: usize,
+    open: f64,
+    high: f64,
+    low: f64,
+    close: f64,
+    volume: f64,
+}
+
+impl TickBars {
+    /// Construct a tick-bar builder that groups `ticks` candles per bar.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::PeriodZero`] if `ticks == 0`.
+    pub fn new(ticks: usize) -> Result<Self> {
+        if ticks == 0 {
+            return Err(Error::PeriodZero);
+        }
+        Ok(Self {
+            ticks,
+            count: 0,
+            open: 0.0,
+            high: 0.0,
+            low: 0.0,
+            close: 0.0,
+            volume: 0.0,
+        })
+    }
+
+    /// Configured number of candles per bar.
+    pub const fn ticks(&self) -> usize {
+        self.ticks
+    }
+
+    /// Number of candles accumulated into the in-progress bar.
+    pub const fn count(&self) -> usize {
+        self.count
+    }
+}
+
+impl BarBuilder for TickBars {
+    type Bar = TickBar;
+
+    fn update(&mut self, candle: Candle) -> Vec<TickBar> {
+        if self.count == 0 {
+            self.open = candle.open;
+            self.high = candle.high;
+            self.low = candle.low;
+            self.volume = 0.0;
+        } else {
+            self.high = self.high.max(candle.high);
+            self.low = self.low.min(candle.low);
+        }
+        self.close = candle.close;
+        self.volume += candle.volume;
+        self.count += 1;
+        if self.count < self.ticks {
+            return Vec::new();
+        }
+        self.count = 0;
+        vec![TickBar {
+            open: self.open,
+            high: self.high,
+            low: self.low,
+            close: self.close,
+            volume: self.volume,
+        }]
+    }
+
+    fn reset(&mut self) {
+        self.count = 0;
+        self.volume = 0.0;
+    }
+
+    fn name(&self) -> &'static str {
+        "TickBars"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::assert_relative_eq;
+
+    fn candle(open: f64, high: f64, low: f64, close: f64, volume: f64) -> Candle {
+        Candle::new(open, high, low, close, volume, 0).unwrap()
+    }
+
+    #[test]
+    fn rejects_zero_ticks() {
+        assert!(matches!(TickBars::new(0), Err(Error::PeriodZero)));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let bars = TickBars::new(5).unwrap();
+        assert_eq!(bars.ticks(), 5);
+        assert_eq!(bars.count(), 0);
+        assert_eq!(bars.name(), "TickBars");
+    }
+
+    #[test]
+    fn emits_every_n_candles() {
+        let mut bars = TickBars::new(2).unwrap();
+        assert!(bars.update(candle(10.0, 10.0, 10.0, 10.0, 1.0)).is_empty());
+        assert_eq!(bars.update(candle(10.0, 10.0, 10.0, 10.0, 1.0)).len(), 1);
+        assert!(bars.update(candle(10.0, 10.0, 10.0, 10.0, 1.0)).is_empty());
+        assert_eq!(bars.update(candle(10.0, 10.0, 10.0, 10.0, 1.0)).len(), 1);
+    }
+
+    #[test]
+    fn aggregates_ohlcv() {
+        let mut bars = TickBars::new(3).unwrap();
+        bars.update(candle(10.0, 11.0, 9.0, 10.5, 100.0));
+        bars.update(candle(10.5, 12.0, 10.0, 11.0, 150.0));
+        let out = bars.update(candle(11.0, 11.5, 10.8, 11.2, 120.0));
+        assert_eq!(out.len(), 1);
+        assert_relative_eq!(out[0].open, 10.0, epsilon = 1e-12);
+        assert_relative_eq!(out[0].high, 12.0, epsilon = 1e-12);
+        assert_relative_eq!(out[0].low, 9.0, epsilon = 1e-12);
+        assert_relative_eq!(out[0].close, 11.2, epsilon = 1e-12);
+        assert_relative_eq!(out[0].volume, 370.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn partial_group_emits_nothing() {
+        let mut bars = TickBars::new(4).unwrap();
+        bars.update(candle(10.0, 10.0, 10.0, 10.0, 1.0));
+        bars.update(candle(10.0, 10.0, 10.0, 10.0, 1.0));
+        assert_eq!(bars.count(), 2);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut bars = TickBars::new(3).unwrap();
+        bars.update(candle(10.0, 10.0, 10.0, 10.0, 1.0));
+        bars.update(candle(10.0, 10.0, 10.0, 10.0, 1.0));
+        bars.reset();
+        assert_eq!(bars.count(), 0);
+        // After reset the next candle starts a fresh group.
+        assert!(bars.update(candle(20.0, 20.0, 20.0, 20.0, 5.0)).is_empty());
+        assert_eq!(bars.count(), 1);
+    }
+
+    #[test]
+    fn batch_concatenates_completed_bars() {
+        let mut bars = TickBars::new(2).unwrap();
+        let candles = [
+            candle(10.0, 10.0, 10.0, 10.0, 1.0),
+            candle(10.0, 10.0, 10.0, 10.0, 1.0),
+            candle(10.0, 10.0, 10.0, 10.0, 1.0),
+            candle(10.0, 10.0, 10.0, 10.0, 1.0),
+        ];
+        let out = bars.batch(&candles);
+        assert_eq!(out.len(), 2);
+    }
+}

crates/wickra-core/src/indicators/volume_bars.rs

@@ -0,0 +1,217 @@
+//! Volume bar builder — close a bar each time accumulated volume reaches a threshold.
+
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::BarBuilder;
+
+/// One completed volume bar (an OHLCV aggregate spanning ~`volume_per_bar` of volume).
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct VolumeBar {
+    /// Open of the first candle in the bar.
+    pub open: f64,
+    /// Highest high across the bar.
+    pub high: f64,
+    /// Lowest low across the bar.
+    pub low: f64,
+    /// Close of the candle that closed the bar.
+    pub close: f64,
+    /// Accumulated volume in the bar (`>= volume_per_bar`; the crossing candle's
+    /// overshoot is kept in the bar that closes).
+    pub volume: f64,
+}
+
+/// Volume bar builder — emits a bar each time accumulated volume reaches
+/// `volume_per_bar`.
+///
+/// Where [`TickBars`](crate::TickBars) sample on trade *count*, volume bars sample on
+/// traded *quantity*: a bar closes once the candles fed into it have accumulated at
+/// least `volume_per_bar` of volume. This gives each bar roughly equal participation,
+/// which de-emphasises quiet periods and resolves bursts of heavy trading into more
+/// bars. The companion [`DollarBars`](crate::DollarBars) builder uses traded *value*
+/// (`price × volume`) instead, which is more robust to price-level drift over long
+/// histories.
+///
+/// The bar is candle-granular: at most one bar closes per candle, and the candle
+/// that crosses the threshold closes the bar with its overshoot included (the next
+/// bar starts fresh). [`BarBuilder::update`] therefore returns either an empty vector
+/// or a single [`VolumeBar`].
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{BarBuilder, Candle, VolumeBars};
+///
+/// let c = |cl, v| Candle::new(cl, cl, cl, cl, v, 0).unwrap();
+/// let mut bars = VolumeBars::new(100.0).unwrap();
+/// assert!(bars.update(c(10.0, 60.0)).is_empty());
+/// let out = bars.update(c(10.5, 60.0)); // 120 >= 100 -> close
+/// assert_eq!(out.len(), 1);
+/// assert_eq!(out[0].volume, 120.0);
+/// ```
+#[derive(Debug, Clone)]
+pub struct VolumeBars {
+    volume_per_bar: f64,
+    count: usize,
+    open: f64,
+    high: f64,
+    low: f64,
+    close: f64,
+    accumulated: f64,
+}
+
+impl VolumeBars {
+    /// Construct a volume-bar builder with the given volume threshold.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::InvalidPeriod`] if `volume_per_bar` is not finite and positive.
+    pub fn new(volume_per_bar: f64) -> Result<Self> {
+        if !volume_per_bar.is_finite() || volume_per_bar <= 0.0 {
+            return Err(Error::InvalidPeriod {
+                message: "volume_per_bar must be finite and positive",
+            });
+        }
+        Ok(Self {
+            volume_per_bar,
+            count: 0,
+            open: 0.0,
+            high: 0.0,
+            low: 0.0,
+            close: 0.0,
+            accumulated: 0.0,
+        })
+    }
+
+    /// Configured volume threshold per bar.
+    pub const fn volume_per_bar(&self) -> f64 {
+        self.volume_per_bar
+    }
+
+    /// Volume accumulated into the in-progress bar.
+    pub const fn accumulated(&self) -> f64 {
+        self.accumulated
+    }
+}
+
+impl BarBuilder for VolumeBars {
+    type Bar = VolumeBar;
+
+    fn update(&mut self, candle: Candle) -> Vec<VolumeBar> {
+        if self.count == 0 {
+            self.open = candle.open;
+            self.high = candle.high;
+            self.low = candle.low;
+        } else {
+            self.high = self.high.max(candle.high);
+            self.low = self.low.min(candle.low);
+        }
+        self.close = candle.close;
+        self.accumulated += candle.volume;
+        self.count += 1;
+        if self.accumulated < self.volume_per_bar {
+            return Vec::new();
+        }
+        let bar = VolumeBar {
+            open: self.open,
+            high: self.high,
+            low: self.low,
+            close: self.close,
+            volume: self.accumulated,
+        };
+        self.count = 0;
+        self.accumulated = 0.0;
+        vec![bar]
+    }
+
+    fn reset(&mut self) {
+        self.count = 0;
+        self.accumulated = 0.0;
+    }
+
+    fn name(&self) -> &'static str {
+        "VolumeBars"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::assert_relative_eq;
+
+    fn candle(open: f64, high: f64, low: f64, close: f64, volume: f64) -> Candle {
+        Candle::new(open, high, low, close, volume, 0).unwrap()
+    }
+
+    #[test]
+    fn rejects_invalid_threshold() {
+        assert!(matches!(
+            VolumeBars::new(0.0),
+            Err(Error::InvalidPeriod { .. })
+        ));
+        assert!(matches!(
+            VolumeBars::new(-100.0),
+            Err(Error::InvalidPeriod { .. })
+        ));
+        assert!(matches!(
+            VolumeBars::new(f64::INFINITY),
+            Err(Error::InvalidPeriod { .. })
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let bars = VolumeBars::new(1000.0).unwrap();
+        assert_relative_eq!(bars.volume_per_bar(), 1000.0, epsilon = 1e-12);
+        assert_relative_eq!(bars.accumulated(), 0.0, epsilon = 1e-12);
+        assert_eq!(bars.name(), "VolumeBars");
+    }
+
+    #[test]
+    fn closes_when_threshold_reached() {
+        let mut bars = VolumeBars::new(100.0).unwrap();
+        assert!(bars.update(candle(10.0, 10.0, 10.0, 10.0, 60.0)).is_empty());
+        let out = bars.update(candle(10.5, 10.5, 10.5, 10.5, 60.0));
+        assert_eq!(out.len(), 1);
+        assert_relative_eq!(out[0].volume, 120.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn aggregates_ohlc() {
+        let mut bars = VolumeBars::new(100.0).unwrap();
+        bars.update(candle(10.0, 11.0, 9.0, 10.5, 50.0));
+        let out = bars.update(candle(10.5, 12.0, 10.0, 11.0, 60.0));
+        assert_relative_eq!(out[0].open, 10.0, epsilon = 1e-12);
+        assert_relative_eq!(out[0].high, 12.0, epsilon = 1e-12);
+        assert_relative_eq!(out[0].low, 9.0, epsilon = 1e-12);
+        assert_relative_eq!(out[0].close, 11.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn below_threshold_emits_nothing() {
+        let mut bars = VolumeBars::new(100.0).unwrap();
+        bars.update(candle(10.0, 10.0, 10.0, 10.0, 30.0));
+        assert_relative_eq!(bars.accumulated(), 30.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut bars = VolumeBars::new(100.0).unwrap();
+        bars.update(candle(10.0, 10.0, 10.0, 10.0, 60.0));
+        bars.reset();
+        assert_relative_eq!(bars.accumulated(), 0.0, epsilon = 1e-12);
+        assert!(bars.update(candle(20.0, 20.0, 20.0, 20.0, 60.0)).is_empty());
+    }
+
+    #[test]
+    fn batch_concatenates_completed_bars() {
+        let mut bars = VolumeBars::new(100.0).unwrap();
+        let candles = [
+            candle(10.0, 10.0, 10.0, 10.0, 60.0),
+            candle(10.0, 10.0, 10.0, 10.0, 60.0),
+            candle(10.0, 10.0, 10.0, 10.0, 60.0),
+            candle(10.0, 10.0, 10.0, 10.0, 60.0),
+        ];
+        let out = bars.batch(&candles);
+        assert_eq!(out.len(), 2);
+    }
+}

crates/wickra-core/src/lib.rs

@@ -55,6 +55,13 @@ pub mod indicators;
 pub use cross_section::{CrossSection, Member};
 pub use derivatives::DerivativesTick;
 pub use error::{Error, Result};
+pub use indicators::DollarBar;
+pub use indicators::ImbalanceBar;
+pub use indicators::LineBreakBar;
+pub use indicators::RangeBar;
+pub use indicators::RunBar;
+pub use indicators::TickBar;
+pub use indicators::VolumeBar;
 pub use indicators::{
     AbandonedBaby, Abcd, AbsoluteBreadthIndex, AccelerationBands, AccelerationBandsOutput,
     AcceleratorOscillator, AdOscillator, AdVolumeLine, AdaptiveCci, AdaptiveCycle,
@@ -77,8 +84,8 @@ pub use indicators::{
     CumulativeVolumeDelta, CumulativeVolumeIndex, CupAndHandle, CyberneticCycle, Cypher,
     DayOfWeekProfile, DayOfWeekProfileOutput, Decycler, DecyclerOscillator, Dema, DemandIndex,
     DemarkPivots, DemarkPivotsOutput, DepthSlope, DerivativeOscillator, DetrendedStdDev,
-    DisparityIndex, DistanceSsd, Doji, DojiStar, Donchian, DonchianOutput, DonchianStop,
-    DonchianStopOutput, DoubleBollinger, DoubleBollingerOutput, DoubleTopBottom,
+    DisparityIndex, DistanceSsd, Doji, DojiStar, DollarBars, Donchian, DonchianOutput,
+    DonchianStop, DonchianStopOutput, DoubleBollinger, DoubleBollingerOutput, DoubleTopBottom,
     DownsideGapThreeMethods, Dpo, DragonflyDoji, DrawdownDuration, DumplingTop, Dx,
     DynamicMomentumIndex, EaseOfMovement, EffectiveSpread, EhlersStochastic, Ehma, ElderImpulse,
     ElderRay, ElderRayOutput, ElderSafeZone, ElderSafeZoneOutput, Ema, EmpiricalModeDecomposition,
@@ -98,13 +105,13 @@ pub use indicators::{
     HighLowVolumeNodesOutput, HighWave, HighpassFilter, Hikkake, HikkakeModified,
     HilbertDominantCycle, HistoricalVolatility, Hma, HoltWinters, HomingPigeon, HtDcPhase,
     HtPhasor, HtPhasorOutput, HtTrendMode, HurstChannel, HurstChannelOutput, HurstExponent,
-    Ichimoku, IchimokuOutput, IdenticalThreeCrows, InNeck, Inertia, InformationRatio,
-    InitialBalance, InitialBalanceOutput, InstantaneousTrendline, IntradayIntensity,
-    IntradayMomentumIndex, IntradayVolatilityProfile, IntradayVolatilityProfileOutput,
-    InverseFisherTransform, InvertedHammer, JarqueBera, Jma, JumpIndicator, KRatio, KagiBars,
-    KalmanHedgeRatio, KalmanHedgeRatioOutput, Kama, KaseDevStop, KaseDevStopOutput,
-    KasePermissionStochastic, KasePermissionStochasticOutput, KellyCriterion, Keltner,
-    KeltnerOutput, KendallTau, Kicking, KickingByLength, Kst, KstOutput, Kurtosis, Kvo,
+    Ichimoku, IchimokuOutput, IdenticalThreeCrows, ImbalanceBars, InNeck, Inertia,
+    InformationRatio, InitialBalance, InitialBalanceOutput, InstantaneousTrendline,
+    IntradayIntensity, IntradayMomentumIndex, IntradayVolatilityProfile,
+    IntradayVolatilityProfileOutput, InverseFisherTransform, InvertedHammer, JarqueBera, Jma,
+    JumpIndicator, KRatio, KagiBars, KalmanHedgeRatio, KalmanHedgeRatioOutput, Kama, KaseDevStop,
+    KaseDevStopOutput, KasePermissionStochastic, KasePermissionStochasticOutput, KellyCriterion,
+    Keltner, KeltnerOutput, KendallTau, Kicking, KickingByLength, Kst, KstOutput, Kurtosis, Kvo,
     KylesLambda, LadderBottom, LaguerreRsi, LeadLagCrossCorrelation, LeadLagCrossCorrelationOutput,
     LinRegAngle, LinRegChannel, LinRegChannelOutput, LinRegIntercept, LinRegSlope,
     LinearRegression, LiquidationFeatures, LiquidationFeaturesOutput, LogReturn, LongLeggedDoji,
@@ -124,15 +131,15 @@ pub use indicators::{
     PivotReversal, PlusDi, PlusDm, Pmo, PointAndFigureBars, PolarizedFractalEfficiency, Ppo,
     PpoHistogram, ProfileShape, ProfitFactor, ProjectionBands, ProjectionBandsOutput,
     ProjectionOscillator, Psar, Pvi, Qqe, QqeOutput, Qstick, QuartileBands, QuartileBandsOutput,
-    QuotedSpread, RSquared, RealizedSpread, RealizedVolatility, RecoveryFactor, RectangleRange,
-    Reflex, RegimeLabel, RelativeStrengthAB, RelativeStrengthOutput, RenkoBars, RenkoTrailingStop,
-    RickshawMan, RisingThreeMethods, Rmi, Roc, Rocp, Rocr, Rocr100, RogersSatchellVolatility,
-    RollMeasure, RollingCorrelation, RollingCovariance, RollingIqr, RollingMinMaxScaler,
-    RollingPercentileRank, RollingQuantile, RollingVwap, RoofingFilter, Rsi, Rsx, Rvi,
-    RviVolatility, Rwi, RwiOutput, SampleEntropy, SarExt, SeasonalZScore, SeparatingLines,
-    SessionHighLow, SessionHighLowOutput, SessionRange, SessionRangeOutput, SessionVwap,
-    ShannonEntropy, Shark, SharpeRatio, ShootingStar, ShortLine, SignedVolume, SineWave,
-    SineWeightedMa, SinglePrints, Skewness, Sma, Smi, Smma, SmoothedHeikinAshi,
+    QuotedSpread, RSquared, RangeBars, RealizedSpread, RealizedVolatility, RecoveryFactor,
+    RectangleRange, Reflex, RegimeLabel, RelativeStrengthAB, RelativeStrengthOutput, RenkoBars,
+    RenkoTrailingStop, RickshawMan, RisingThreeMethods, Rmi, Roc, Rocp, Rocr, Rocr100,
+    RogersSatchellVolatility, RollMeasure, RollingCorrelation, RollingCovariance, RollingIqr,
+    RollingMinMaxScaler, RollingPercentileRank, RollingQuantile, RollingVwap, RoofingFilter, Rsi,
+    Rsx, RunBars, Rvi, RviVolatility, Rwi, RwiOutput, SampleEntropy, SarExt, SeasonalZScore,
+    SeparatingLines, SessionHighLow, SessionHighLowOutput, SessionRange, SessionRangeOutput,
+    SessionVwap, ShannonEntropy, Shark, SharpeRatio, ShootingStar, ShortLine, SignedVolume,
+    SineWave, SineWeightedMa, SinglePrints, Skewness, Sma, Smi, Smma, SmoothedHeikinAshi,
     SmoothedHeikinAshiOutput, SortinoRatio, SpearmanCorrelation, SpinningTop, SpreadAr1Coefficient,
     SpreadBollingerBands, SpreadBollingerBandsOutput, SpreadHurst, StalledPattern, StandardError,
     StandardErrorBands, StandardErrorBandsOutput, StarcBands, StarcBandsOutput, Stc, StdDev,
@@ -142,23 +149,24 @@ pub use indicators::{
     TdDifferential, TdLines, TdLinesOutput, TdMovingAverage, TdMovingAverageOutput, TdOpen,
     TdPressure, TdPropulsion, TdRangeProjection, TdRangeProjectionOutput, TdRei, TdRiskLevel,
     TdRiskLevelOutput, TdSequential, TdSequentialOutput, TdSetup, TdTrap, Tema, TermStructureBasis,
-    ThreeDrives, ThreeInside, ThreeLineBreak, ThreeLineStrike, ThreeOutside, ThreeSoldiersOrCrows,
-    ThreeStarsInSouth, Thrusting, TickIndex, Tii, TimeBasedStop, TimeOfDayReturnProfile,
-    TimeOfDayReturnProfileOutput, TowerTopBottom, TpoProfile, TpoProfileOutput, TradeImbalance,
-    TradeSignAutocorrelation, TradeVolumeIndex, TrendLabel, TrendStrengthIndex, Trendflex,
-    TreynorRatio, Triangle, Trima, Trin, TripleTopBottom, Tristar, Trix, TrueRange, Tsf,
-    TsfOscillator, Tsi, Tsv, TtmSqueeze, TtmSqueezeOutput, TtmTrend, TurnOfMonth, Tweezer,
-    TwiggsMoneyFlow, TwoCrows, TypicalPrice, UlcerIndex, UltimateOscillator, UniqueThreeRiver,
-    UniversalOscillator, UpDownVolumeRatio, UpsideGapThreeMethods, UpsideGapTwoCrows,
-    UpsidePotentialRatio, ValueArea, ValueAreaOutput, ValueAtRisk, Variance, VarianceRatio,
-    VerticalHorizontalFilter, Vidya, VolatilityCone, VolatilityConeOutput, VolatilityOfVolatility,
-    VolatilityRatio, VoltyStop, VolumeByTimeProfile, VolumeByTimeProfileOutput, VolumeOscillator,
-    VolumePriceTrend, VolumeProfile, VolumeProfileOutput, VolumeRsi, VolumeWeightedMacd,
-    VolumeWeightedMacdOutput, VolumeWeightedSr, VolumeWeightedSrOutput, Vortex, VortexOutput, Vpin,
-    Vwap, VwapStdDevBands, VwapStdDevBandsOutput, Vwma, Vzo, Wad, WavePm, WaveTrend,
-    WaveTrendOutput, Wedge, WeightedClose, WickRatio, WilliamsFractals, WilliamsFractalsOutput,
-    WilliamsR, WinRate, Wma, WoodiePivots, WoodiePivotsOutput, YangZhangVolatility, YoyoExit,
-    ZScore, ZeroLagMacd, ZeroLagMacdOutput, ZigZag, ZigZagOutput, Zlema, FAMILIES, T3,
+    ThreeDrives, ThreeInside, ThreeLineBreak, ThreeLineBreakBars, ThreeLineStrike, ThreeOutside,
+    ThreeSoldiersOrCrows, ThreeStarsInSouth, Thrusting, TickBars, TickIndex, Tii, TimeBasedStop,
+    TimeOfDayReturnProfile, TimeOfDayReturnProfileOutput, TowerTopBottom, TpoProfile,
+    TpoProfileOutput, TradeImbalance, TradeSignAutocorrelation, TradeVolumeIndex, TrendLabel,
+    TrendStrengthIndex, Trendflex, TreynorRatio, Triangle, Trima, Trin, TripleTopBottom, Tristar,
+    Trix, TrueRange, Tsf, TsfOscillator, Tsi, Tsv, TtmSqueeze, TtmSqueezeOutput, TtmTrend,
+    TurnOfMonth, Tweezer, TwiggsMoneyFlow, TwoCrows, TypicalPrice, UlcerIndex, UltimateOscillator,
+    UniqueThreeRiver, UniversalOscillator, UpDownVolumeRatio, UpsideGapThreeMethods,
+    UpsideGapTwoCrows, UpsidePotentialRatio, ValueArea, ValueAreaOutput, ValueAtRisk, Variance,
+    VarianceRatio, VerticalHorizontalFilter, Vidya, VolatilityCone, VolatilityConeOutput,
+    VolatilityOfVolatility, VolatilityRatio, VoltyStop, VolumeBars, VolumeByTimeProfile,
+    VolumeByTimeProfileOutput, VolumeOscillator, VolumePriceTrend, VolumeProfile,
+    VolumeProfileOutput, VolumeRsi, VolumeWeightedMacd, VolumeWeightedMacdOutput, VolumeWeightedSr,
+    VolumeWeightedSrOutput, Vortex, VortexOutput, Vpin, Vwap, VwapStdDevBands,
+    VwapStdDevBandsOutput, Vwma, Vzo, Wad, WavePm, WaveTrend, WaveTrendOutput, Wedge,
+    WeightedClose, WickRatio, WilliamsFractals, WilliamsFractalsOutput, WilliamsR, WinRate, Wma,
+    WoodiePivots, WoodiePivotsOutput, YangZhangVolatility, YoyoExit, ZScore, ZeroLagMacd,
+    ZeroLagMacdOutput, ZigZag, ZigZagOutput, Zlema, FAMILIES, T3,
 };
 // `FootprintLevel` is a row element of `FootprintOutput`, re-exported on its own
 // line so the indicator-count tooling (which scans the braced block above and

docs/README.md

@@ -6,9 +6,11 @@ That includes:
 
 - **Quickstarts** for [Rust](https://docs.wickra.org/Quickstart-Rust),
   [Python](https://docs.wickra.org/Quickstart-Python),
-  [Node](https://docs.wickra.org/Quickstart-Node), and
-  [WASM](https://docs.wickra.org/Quickstart-WASM).
-- A per-indicator deep dive for every one of the **507 indicators** across
+  [Node](https://docs.wickra.org/Quickstart-Node),
+  [WASM](https://docs.wickra.org/Quickstart-WASM),
+  [C](https://docs.wickra.org/Quickstart-C), and
+  [C#](https://docs.wickra.org/Quickstart-CSharp).
+- A per-indicator deep dive for every one of the **514 indicators** across
   the sixteen families (Moving Averages, Momentum Oscillators, Trend &
   Directional, Price Oscillators, Volatility & Bands, Bands & Channels,
   Trailing Stops, Volume, Price Statistics, Ehlers / Cycle DSP, Pivots &

examples/README.md

@@ -21,6 +21,54 @@ The Rust examples live in the `wickra-examples` workspace member crate.
 | `strategy_macd_adx.rs` | Hourly BTCUSDT trend-follower: MACD crossover entries gated by ADX(14) > 20. | `cargo run --release -p wickra-examples --bin strategy_macd_adx` |
 | `strategy_bollinger_squeeze.rs` | Daily BTCUSDT Bollinger-squeeze breakout with ATR(14) trailing stop. | `cargo run --release -p wickra-examples --bin strategy_bollinger_squeeze` |
 
+## C / C++ — `examples/c/`
+
+Build the library first (`cargo build -p wickra-c --release`), then build and run
+the examples via CMake:
+`cmake -S examples/c -B examples/c/build -DWICKRA_LIB_DIR="$PWD/target/release"` →
+`cmake --build examples/c/build` → `ctest --test-dir examples/c/build`.
+
+| Example | What it does | CMake target |
+| --- | --- | --- |
+| `smoke.c` | Links the generated header + library and asserts SMA streaming / batch values across the boundary. | `smoke` |
+| `streaming.c` | Feed a synthetic price series through SMA / EMA / RSI / MACD tick by tick. | `streaming` |
+| `backtest.c` | Basket of indicators over an OHLCV CSV; defaults to the bundled BTCUSDT daily dataset. | `backtest` |
+| `multi_timeframe.c` | Resample the bundled 1-minute CSV to 5m / 15m / 1h / 4h / 1d and print indicators per timeframe. | `multi_timeframe` |
+| `parallel_assets.c` | Serial vs OpenMP fan-out over a synthetic panel (one handle per asset), with speedup. | `parallel_assets` |
+| `strategy_rsi_mean_reversion.c` | Hourly BTCUSDT mean-reversion using RSI(14) thresholds, with PnL / Sharpe / max-DD summary. | `strategy_rsi_mean_reversion` |
+| `strategy_macd_adx.c` | Hourly BTCUSDT trend-follower: MACD crossover entries gated by ADX(14) > 20. | `strategy_macd_adx` |
+| `strategy_bollinger_squeeze.c` | Daily BTCUSDT Bollinger-squeeze breakout with ATR(14) stop. | `strategy_bollinger_squeeze` |
+| `fetch_btcusdt.c` | Download real BTCUSDT klines from the Binance REST API into `examples/data/` (shells out to `curl`). | `fetch_btcusdt` |
+| `live_binance.c` | Poll the Binance REST klines endpoint via `curl` and stream closed candles through RSI(14). | `live_binance` |
+| `smoke.cpp` | C++ RAII via `wickra::Handle` from [`wickra.hpp`](../bindings/c/include/wickra.hpp): construct, move, auto-free. | `cpp_smoke` |
+
+The data-driven examples (`backtest`, `multi_timeframe`, `parallel_assets`, the
+three `strategy_*`) build against the bundled datasets and run under `ctest`.
+`fetch_btcusdt` and `live_binance` reach the network, so they are built but not
+run in CI; run them by hand. `parallel_assets` links OpenMP when the toolchain
+provides it and falls back to a single-threaded run otherwise.
+
+## C# / .NET — `examples/csharp/`
+
+Build the C ABI library first (`cargo build -p wickra-c --release`), then run any
+example with the .NET 8 SDK; the binding resolves the native library automatically.
+
+| Example | What it does | Run |
+| --- | --- | --- |
+| `streaming` | Feed a synthetic price series through SMA / EMA / RSI / MACD tick by tick. | `dotnet run --project examples/csharp/streaming` |
+| `backtest` | Basket of indicators over an OHLCV series (CSV arg or synthetic). | `dotnet run --project examples/csharp/backtest -- <ohlcv.csv>` |
+| `multi_timeframe` | Resample a 1-minute series to 5m / 15m and print an indicator per timeframe. | `dotnet run --project examples/csharp/multi_timeframe` |
+| `parallel_assets` | SMA(20) batch over a panel, serial vs `Parallel.For`, with speedup. | `dotnet run -c Release --project examples/csharp/parallel_assets` |
+| `strategy_rsi_mean_reversion` | RSI(14) mean-reversion with PnL / Sharpe / max-DD summary. | `dotnet run -c Release --project examples/csharp/strategy_rsi_mean_reversion` |
+| `strategy_macd_adx` | Trend-follower: MACD crossover entries gated by ADX(14) > 20. | `dotnet run -c Release --project examples/csharp/strategy_macd_adx` |
+| `strategy_bollinger_squeeze` | Bollinger-squeeze breakout with an ATR(14) trailing stop. | `dotnet run -c Release --project examples/csharp/strategy_bollinger_squeeze` |
+| `fetch_btcusdt` | Download real BTCUSDT klines from the Binance REST API into a CSV. | `dotnet run --project examples/csharp/fetch_btcusdt` |
+| `live_binance` | Stream live Binance klines through EMA(20) over a WebSocket. | `dotnet run --project examples/csharp/live_binance` |
+
+The offline examples run on deterministic synthetic data (and under CI on all
+three OSes); `fetch_btcusdt` and `live_binance` reach the network and are built
+but not run in CI.
+
 ## Python — `examples/python/`
 
 | Example | What it does | Run |

examples/c/CMakeLists.txt

@@ -0,0 +1,82 @@
+cmake_minimum_required(VERSION 3.15)
+project(wickra_c_examples C CXX)
+
+# Directory holding the compiled Wickra C library (cargo output), e.g.
+# <workspace>/target/release. Override with -DWICKRA_LIB_DIR=/path/to/target/release.
+if(NOT DEFINED WICKRA_LIB_DIR)
+    set(WICKRA_LIB_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../target/release")
+endif()
+set(WICKRA_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../bindings/c/include")
+
+# Absolute path to the bundled OHLCV datasets, baked into the data-driven
+# examples as a compile definition so they run from any working directory (the
+# C counterpart of the Rust examples' CARGO_MANIFEST_DIR).
+get_filename_component(WICKRA_DATA_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../data" ABSOLUTE)
+
+# OpenMP is optional: parallel_assets links it when present and falls back to a
+# single-threaded run otherwise.
+find_package(OpenMP QUIET)
+
+# Pick the right link target per platform/toolchain.
+#  - MSVC links the generated import library (wickra.dll.lib).
+#  - MinGW/gcc on Windows links the DLL directly.
+#  - Unix links the shared object / dylib.
+if(WIN32)
+    set(WICKRA_RUNTIME "${WICKRA_LIB_DIR}/wickra.dll")
+    if(MSVC)
+        set(WICKRA_LINK_LIB "${WICKRA_LIB_DIR}/wickra.dll.lib")
+    else()
+        set(WICKRA_LINK_LIB "${WICKRA_LIB_DIR}/wickra.dll")
+    endif()
+elseif(APPLE)
+    set(WICKRA_LINK_LIB "${WICKRA_LIB_DIR}/libwickra.dylib")
+else()
+    set(WICKRA_LINK_LIB "${WICKRA_LIB_DIR}/libwickra.so")
+endif()
+
+enable_testing()
+
+# Build one example and link it to the Wickra library. On Windows the DLL is
+# copied next to the executable so the loader finds it at run time. With
+# register_test=TRUE the example is also run as a ctest; network examples pass
+# FALSE (they are built only, never run in CI).
+function(add_wickra_example name source register_test)
+    add_executable(${name} ${source})
+    target_include_directories(${name} PRIVATE "${WICKRA_INCLUDE_DIR}")
+    target_link_libraries(${name} PRIVATE "${WICKRA_LINK_LIB}")
+    target_compile_definitions(${name} PRIVATE "WICKRA_DATA_DIR=\"${WICKRA_DATA_DIR}\"")
+    if(UNIX AND NOT APPLE)
+        target_link_libraries(${name} PRIVATE m)
+    endif()
+    if(WIN32)
+        add_custom_command(TARGET ${name} POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                    "${WICKRA_RUNTIME}" "$<TARGET_FILE_DIR:${name}>")
+    endif()
+    if(register_test)
+        add_test(NAME ${name} COMMAND ${name})
+        if(NOT WIN32)
+            set_tests_properties(${name} PROPERTIES
+                ENVIRONMENT "LD_LIBRARY_PATH=${WICKRA_LIB_DIR};DYLD_LIBRARY_PATH=${WICKRA_LIB_DIR}")
+        endif()
+    endif()
+endfunction()
+
+# Offline examples — built and run as ctests.
+add_wickra_example(smoke smoke.c TRUE)                 # links the boundary, asserts values
+add_wickra_example(streaming streaming.c TRUE)         # multi-indicator tick stream
+add_wickra_example(cpp_smoke smoke.cpp TRUE)           # C++ RAII wrapper (wickra.hpp)
+add_wickra_example(backtest backtest.c TRUE)           # indicator basket over a CSV
+add_wickra_example(multi_timeframe multi_timeframe.c TRUE)  # resample + per-TF indicators
+add_wickra_example(parallel_assets parallel_assets.c TRUE)  # serial vs OpenMP fan-out
+add_wickra_example(strategy_rsi_mean_reversion strategy_rsi_mean_reversion.c TRUE)
+add_wickra_example(strategy_macd_adx strategy_macd_adx.c TRUE)
+add_wickra_example(strategy_bollinger_squeeze strategy_bollinger_squeeze.c TRUE)
+
+if(OpenMP_C_FOUND)
+    target_link_libraries(parallel_assets PRIVATE OpenMP::OpenMP_C)
+endif()
+
+# Network examples — built (so they stay compilable) but not run in CI.
+add_wickra_example(fetch_btcusdt fetch_btcusdt.c FALSE) # downloads CSVs via curl
+add_wickra_example(live_binance live_binance.c FALSE)   # polls Binance REST via curl

examples/c/README.md

@@ -0,0 +1,90 @@
+# Wickra — C / C++ examples
+
+The Wickra C ABI is a single shared/static library plus a generated header
+([`bindings/c/include/wickra.h`](../../bindings/c/include/wickra.h)). Any
+C-capable language links against the same artifact; these examples show the
+plain-C path.
+
+## Build the library
+
+From the workspace root:
+
+```sh
+cargo build -p wickra-c --release
+```
+
+This produces, in `target/release/`:
+
+| Platform | Shared library | Link target |
+|----------|----------------|-------------|
+| Linux    | `libwickra.so`     | `-lwickra` |
+| macOS    | `libwickra.dylib`  | `-lwickra` |
+| Windows (MSVC) | `wickra.dll` | `wickra.dll.lib` (import lib) |
+
+A static library (`libwickra.a` / `wickra.lib`) is emitted alongside.
+
+## Build and run the smoke example
+
+### With CMake (portable, used by CI)
+
+```sh
+cmake -S examples/c -B examples/c/build -DWICKRA_LIB_DIR="$PWD/target/release"
+cmake --build examples/c/build
+ctest --test-dir examples/c/build --output-on-failure
+```
+
+### Directly with a compiler
+
+```sh
+# Linux / macOS
+cc examples/c/smoke.c -I bindings/c/include -L target/release -lwickra -lm -o smoke
+LD_LIBRARY_PATH=target/release ./smoke        # macOS: DYLD_LIBRARY_PATH
+
+# Windows (MinGW gcc, linking the DLL directly)
+gcc examples/c/smoke.c -I bindings/c/include target/release/wickra.dll -lm -o smoke.exe
+```
+
+Expected output:
+
+```
+OK: wickra C ABI smoke passed (SMA streaming + batch + reset + NULL-safety + free)
+```
+
+## The examples
+
+| Example | What it does |
+|---------|--------------|
+| `smoke.c` | Links the boundary and asserts SMA streaming / batch / reset / NULL-safety values. |
+| `streaming.c` | Feeds a synthetic price series through SMA / EMA / RSI / MACD tick by tick. |
+| `backtest.c` | Runs an indicator basket over an OHLCV CSV (defaults to the bundled daily dataset). |
+| `multi_timeframe.c` | Resamples the bundled 1-minute CSV to 5m / 15m / 1h / 4h / 1d and prints indicators per timeframe. |
+| `parallel_assets.c` | Serial vs OpenMP fan-out over a synthetic panel (one handle per asset), with speedup. |
+| `strategy_rsi_mean_reversion.c` | Hourly RSI(14) mean-reversion with a PnL / Sharpe / max-drawdown summary. |
+| `strategy_macd_adx.c` | Hourly MACD crossover gated by ADX(14) > 20. |
+| `strategy_bollinger_squeeze.c` | Daily Bollinger-squeeze breakout with an ATR(14) stop. |
+| `fetch_btcusdt.c` | Downloads BTCUSDT klines from the Binance REST API into `examples/data/` (shells out to `curl`). |
+| `live_binance.c` | Polls the Binance REST klines endpoint via `curl` and streams closed candles through RSI(14). |
+| `smoke.cpp` | C++ RAII via `wickra::Handle` from [`wickra.hpp`](../../bindings/c/include/wickra.hpp). |
+
+`ctest` builds and runs every example except `fetch_btcusdt` and `live_binance`,
+which reach the network and are built only — run those two by hand. The C ABI
+exposes only the indicators, not the `wickra-data` IO layer, so the examples read
+CSV ([`wickra_csv.h`](wickra_csv.h)) and resample themselves; the network ones
+shell out to the system `curl` rather than adding an HTTP/TLS dependency.
+
+## Usage shape
+
+Every indicator follows the same five-function pattern over an opaque handle:
+
+```c
+#include "wickra.h"
+
+struct Sma *sma = wickra_sma_new(14);     /* NULL on invalid params */
+double v = wickra_sma_update(sma, 42.0);  /* NaN during warmup */
+wickra_sma_reset(sma);                     /* back to fresh state */
+wickra_sma_free(sma);                      /* exactly once per _new */
+```
+
+There is no RAII across the C boundary: every `wickra_<ind>_new` must be paired
+with exactly one `wickra_<ind>_free`. All functions are NULL-safe (a NULL handle
+yields `NaN` / a no-op, never a crash).

examples/c/backtest.c

@@ -0,0 +1,139 @@
+/* Backtest a basket of indicators against an OHLCV CSV with the Wickra C ABI.
+ *
+ * The C counterpart of `examples/rust/src/bin/backtest.rs` and
+ * `examples/node/backtest.js`: load an OHLCV file, run a basket of indicators
+ * (scalar ones via `_batch`, candle ones streamed bar by bar), and print the
+ * most recent value of each. Defaults to the bundled BTCUSDT daily dataset.
+ *
+ * Build (after `cargo build -p wickra-c --release`):
+ *   cc examples/c/backtest.c -I bindings/c/include -L target/release -lwickra -lm -o backtest
+ *   ./backtest [path/to/ohlcv.csv]
+ */
+
+#define WICKRA_CSV_IMPL
+#include "wickra.h"
+#include "wickra_csv.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef WICKRA_DATA_DIR
+#define WICKRA_DATA_DIR "../data"
+#endif
+
+/* Last finite value of a scalar batch result, or NaN if none warmed up. */
+static double last_finite(const double *v, size_t n) {
+    for (size_t i = n; i-- > 0;) {
+        if (isfinite(v[i])) {
+            return v[i];
+        }
+    }
+    return NAN;
+}
+
+int main(int argc, char **argv) {
+    const char *path = (argc > 1) ? argv[1] : WICKRA_DATA_DIR "/btcusdt-1d.csv";
+
+    WickraCandle *candles = NULL;
+    size_t n = wickra_load_csv(path, &candles);
+    if (n == 0) {
+        fprintf(stderr, "backtest: no candles read from %s\n", path);
+        return 1;
+    }
+
+    double *closes = (double *)malloc(n * sizeof(*closes));
+    double *rsi_out = (double *)malloc(n * sizeof(*rsi_out));
+    double *ema_out = (double *)malloc(n * sizeof(*ema_out));
+    struct Rsi *rsi = wickra_rsi_new(14);
+    struct Ema *ema = wickra_ema_new(20);
+    struct BollingerBands *bb = wickra_bollinger_bands_new(20, 2.0);
+    struct MacdIndicator *macd = wickra_macd_indicator_new(12, 26, 9);
+    struct Atr *atr = wickra_atr_new(14);
+    struct Adx *adx = wickra_adx_new(14);
+    struct Obv *obv = wickra_obv_new();
+    if (closes == NULL || rsi_out == NULL || ema_out == NULL || rsi == NULL ||
+        ema == NULL || bb == NULL || macd == NULL || atr == NULL || adx == NULL ||
+        obv == NULL) {
+        fprintf(stderr, "backtest: allocation failed\n");
+        return 1;
+    }
+
+    for (size_t i = 0; i < n; ++i) {
+        closes[i] = candles[i].close;
+    }
+
+    /* Scalar indicators: one batch call over the close series. */
+    wickra_rsi_batch(rsi, closes, rsi_out, n);
+    wickra_ema_batch(ema, closes, ema_out, n);
+
+    /* Multi-output and candle indicators: streamed bar by bar, keeping the
+     * last value each one produced. */
+    WickraBollingerOutput last_bb = {0};
+    int have_bb = 0;
+    WickraMacdOutput last_macd = {0};
+    int have_macd = 0;
+    WickraAdxOutput last_adx = {0};
+    int have_adx = 0;
+    double last_atr = NAN;
+    double last_obv = NAN;
+    for (size_t i = 0; i < n; ++i) {
+        const WickraCandle *c = &candles[i];
+        WickraBollingerOutput bo;
+        if (wickra_bollinger_bands_update(bb, c->close, &bo)) {
+            last_bb = bo;
+            have_bb = 1;
+        }
+        WickraMacdOutput mo;
+        if (wickra_macd_indicator_update(macd, c->close, &mo)) {
+            last_macd = mo;
+            have_macd = 1;
+        }
+        double av = wickra_atr_update(atr, c->open, c->high, c->low, c->close,
+                                      c->volume, c->timestamp);
+        if (isfinite(av)) {
+            last_atr = av;
+        }
+        WickraAdxOutput ao;
+        if (wickra_adx_update(adx, c->open, c->high, c->low, c->close, c->volume,
+                              c->timestamp, &ao)) {
+            last_adx = ao;
+            have_adx = 1;
+        }
+        double ov = wickra_obv_update(obv, c->open, c->high, c->low, c->close,
+                                      c->volume, c->timestamp);
+        if (isfinite(ov)) {
+            last_obv = ov;
+        }
+    }
+
+    printf("backtest summary for %s (%llu bars)\n", path, (unsigned long long)n);
+    printf("  RSI(14)  = %9.4f\n", last_finite(rsi_out, n));
+    printf("  EMA(20)  = %9.4f\n", last_finite(ema_out, n));
+    if (have_bb) {
+        printf("  BB(20,2) upper=%9.4f  middle=%9.4f  lower=%9.4f  sd=%8.4f\n",
+               last_bb.upper, last_bb.middle, last_bb.lower, last_bb.stddev);
+    }
+    if (have_macd) {
+        printf("  MACD     macd=%9.4f  signal=%9.4f  hist=%9.4f\n", last_macd.macd,
+               last_macd.signal, last_macd.histogram);
+    }
+    printf("  ATR(14)  = %9.4f\n", last_atr);
+    if (have_adx) {
+        printf("  ADX(14)  +DI=%6.2f  -DI=%6.2f  ADX=%6.2f\n", last_adx.plus_di,
+               last_adx.minus_di, last_adx.adx);
+    }
+    printf("  OBV      = %14.2f\n", last_obv);
+
+    wickra_rsi_free(rsi);
+    wickra_ema_free(ema);
+    wickra_bollinger_bands_free(bb);
+    wickra_macd_indicator_free(macd);
+    wickra_atr_free(atr);
+    wickra_adx_free(adx);
+    wickra_obv_free(obv);
+    free(closes);
+    free(rsi_out);
+    free(ema_out);
+    free(candles);
+    return 0;
+}

examples/c/fetch_btcusdt.c

@@ -0,0 +1,311 @@
+/* Download real BTCUSDT spot candles from the Binance REST API and write them as
+ * CSV datasets under examples/data/ — the C counterpart of
+ * `examples/rust/src/bin/fetch_btcusdt.rs` and `examples/node/fetch_btcusdt.js`.
+ *
+ * Like the Rust example, HTTPS is handled by shelling out to the system `curl`
+ * (shipped with Windows 10+, macOS and every Linux distro), so this example adds
+ * no HTTP/TLS dependency. Each klines response is capped at 1000 rows, so larger
+ * datasets are paginated backwards through `endTime`. Only fully closed candles
+ * are kept.
+ *
+ * This example talks to the network, so it is built but NOT run as a ctest.
+ *
+ * Build (after `cargo build -p wickra-c --release`):
+ *   cc examples/c/fetch_btcusdt.c -I bindings/c/include -L target/release -lwickra -lm -o fetch_btcusdt
+ *   ./fetch_btcusdt
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#ifdef _WIN32
+#define POPEN _popen
+#define PCLOSE _pclose
+#else
+#define POPEN popen
+#define PCLOSE pclose
+#endif
+
+#ifndef WICKRA_DATA_DIR
+#define WICKRA_DATA_DIR "../data"
+#endif
+
+#define SYMBOL "BTCUSDT"
+#define PAGE_LIMIT 1000
+
+typedef struct {
+    int64_t open_time;
+    int64_t close_time;
+    double open, high, low, close, volume;
+} Kline;
+
+typedef struct {
+    const char *interval;
+    const char *file;
+    size_t target;
+} Dataset;
+
+/* One dataset per timeframe. The monthly file is `btcusdt-1month.csv`, not
+ * `-1M`, so it does not collide with `-1m` on case-insensitive filesystems. */
+static const Dataset DATASETS[] = {
+    {"1m", "btcusdt-1m.csv", 50000},  {"5m", "btcusdt-5m.csv", 10000},
+    {"15m", "btcusdt-15m.csv", 10000}, {"1h", "btcusdt-1h.csv", 10000},
+    {"12h", "btcusdt-12h.csv", 5000}, {"1d", "btcusdt-1d.csv", 5000},
+    {"1M", "btcusdt-1month.csv", 5000},
+};
+
+/* Run `curl <url>` and return its stdout as a malloc'd, NUL-terminated buffer
+ * (caller frees), or NULL on failure. */
+static char *curl_get(const char *url) {
+    char cmd[512];
+    snprintf(cmd, sizeof(cmd),
+             "curl --silent --show-error --fail --max-time 30 \"%s\"", url);
+    FILE *p = POPEN(cmd, "r");
+    if (p == NULL) {
+        fprintf(stderr, "could not run curl (install it / put it on PATH)\n");
+        return NULL;
+    }
+    size_t cap = 1 << 16, len = 0;
+    char *buf = (char *)malloc(cap);
+    if (buf == NULL) {
+        PCLOSE(p);
+        return NULL;
+    }
+    size_t got;
+    char tmp[8192];
+    while ((got = fread(tmp, 1, sizeof(tmp), p)) > 0) {
+        if (len + got + 1 > cap) {
+            cap *= 2;
+            char *grown = (char *)realloc(buf, cap);
+            if (grown == NULL) {
+                free(buf);
+                PCLOSE(p);
+                return NULL;
+            }
+            buf = grown;
+        }
+        memcpy(buf + len, tmp, got);
+        len += got;
+    }
+    int rc = PCLOSE(p);
+    buf[len] = '\0';
+    if (rc != 0 || len == 0) {
+        fprintf(stderr, "curl failed for %s\n", url);
+        free(buf);
+        return NULL;
+    }
+    return buf;
+}
+
+/* Parse a Binance klines JSON array. Each row is
+ * [openTime, "open", "high", "low", "close", "volume", closeTime, ...].
+ * Appends parsed rows to *rows (grown via realloc) and returns the new count. */
+static size_t parse_klines(const char *body, Kline **rows, size_t count, size_t *cap) {
+    int depth = 0;
+    int in_string = 0;
+    int field = -1; /* -1 = not inside a row yet */
+    char tok[64];
+    size_t tok_len = 0;
+    Kline cur = {0};
+
+    for (const char *s = body; *s; ++s) {
+        char ch = *s;
+        if (in_string) {
+            if (ch == '"') {
+                in_string = 0;
+            } else if (tok_len + 1 < sizeof(tok)) {
+                tok[tok_len++] = ch;
+            }
+            continue;
+        }
+        switch (ch) {
+        case '[':
+            depth++;
+            if (depth == 2) {
+                field = 0;
+                tok_len = 0;
+                memset(&cur, 0, sizeof(cur));
+            }
+            break;
+        case ']':
+            if (depth == 2) {
+                /* close the final field of this row, then emit it */
+                tok[tok_len] = '\0';
+                if (field == 6) {
+                    cur.close_time = strtoll(tok, NULL, 10);
+                }
+                if (*cap == count) {
+                    *cap = *cap ? *cap * 2 : 1024;
+                    Kline *grown = (Kline *)realloc(*rows, *cap * sizeof(Kline));
+                    if (grown == NULL) {
+                        return count;
+                    }
+                    *rows = grown;
+                }
+                (*rows)[count++] = cur;
+                field = -1;
+            }
+            depth--;
+            break;
+        case '"':
+            in_string = 1;
+            break;
+        case ',':
+            if (depth == 2) {
+                tok[tok_len] = '\0';
+                switch (field) {
+                case 0: cur.open_time = strtoll(tok, NULL, 10); break;
+                case 1: cur.open = strtod(tok, NULL); break;
+                case 2: cur.high = strtod(tok, NULL); break;
+                case 3: cur.low = strtod(tok, NULL); break;
+                case 4: cur.close = strtod(tok, NULL); break;
+                case 5: cur.volume = strtod(tok, NULL); break;
+                case 6: cur.close_time = strtoll(tok, NULL, 10); break;
+                default: break;
+                }
+                field++;
+                tok_len = 0;
+            }
+            break;
+        default:
+            if (depth == 2 && tok_len + 1 < sizeof(tok)) {
+                tok[tok_len++] = ch;
+            }
+            break;
+        }
+    }
+    return count;
+}
+
+static int cmp_open(const void *a, const void *b) {
+    int64_t x = ((const Kline *)a)->open_time;
+    int64_t y = ((const Kline *)b)->open_time;
+    return (x > y) - (x < y);
+}
+
+/* Paginate backwards until `target` closed candles are collected. */
+static size_t collect(const char *interval, size_t target, int64_t now_ms,
+                      Kline **out) {
+    Kline *rows = NULL;
+    size_t count = 0, cap = 0;
+    int64_t end_time = 0; /* 0 = no endTime cap (most recent page) */
+    int pages = 0;
+
+    for (;;) {
+        char url[256];
+        if (end_time > 0) {
+            snprintf(url, sizeof(url),
+                     "https://api.binance.com/api/v3/klines?symbol=%s&interval=%s"
+                     "&limit=%d&endTime=%lld",
+                     SYMBOL, interval, PAGE_LIMIT, (long long)end_time);
+        } else {
+            snprintf(url, sizeof(url),
+                     "https://api.binance.com/api/v3/klines?symbol=%s&interval=%s"
+                     "&limit=%d",
+                     SYMBOL, interval, PAGE_LIMIT);
+        }
+        char *body = curl_get(url);
+        if (body == NULL) {
+            free(rows);
+            return 0;
+        }
+        Kline *page = NULL;
+        size_t page_cap = 0;
+        size_t page_n = parse_klines(body, &page, 0, &page_cap);
+        free(body);
+        pages++;
+
+        int64_t oldest_open = INT64_MAX;
+        for (size_t i = 0; i < page_n; ++i) {
+            if (page[i].open_time < oldest_open) {
+                oldest_open = page[i].open_time;
+            }
+            if (page[i].close_time < now_ms) { /* keep only closed candles */
+                if (count == cap) {
+                    cap = cap ? cap * 2 : 1024;
+                    Kline *grown = (Kline *)realloc(rows, cap * sizeof(Kline));
+                    if (grown == NULL) {
+                        free(page);
+                        free(rows);
+                        return 0;
+                    }
+                    rows = grown;
+                }
+                rows[count++] = page[i];
+            }
+        }
+        fprintf(stderr, "\r  %s: collected %llu candles over %d page(s)...",
+                interval, (unsigned long long)count, pages);
+
+        int page_full = page_n >= PAGE_LIMIT;
+        free(page);
+        if (count >= target || !page_full || oldest_open == INT64_MAX) {
+            break;
+        }
+        end_time = oldest_open - 1;
+    }
+    fprintf(stderr, "\n");
+
+    /* Sort ascending, drop duplicate open times, keep the most recent target. */
+    qsort(rows, count, sizeof(Kline), cmp_open);
+    size_t uniq = 0;
+    for (size_t i = 0; i < count; ++i) {
+        if (uniq == 0 || rows[i].open_time != rows[uniq - 1].open_time) {
+            rows[uniq++] = rows[i];
+        }
+    }
+    if (uniq > target) {
+        memmove(rows, rows + (uniq - target), target * sizeof(Kline));
+        uniq = target;
+    }
+    *out = rows;
+    return uniq;
+}
+
+static int write_csv(const char *path, const Kline *rows, size_t n) {
+    FILE *f = fopen(path, "w");
+    if (f == NULL) {
+        return 0;
+    }
+    fputs("timestamp,open,high,low,close,volume\n", f);
+    for (size_t i = 0; i < n; ++i) {
+        fprintf(f, "%lld,%g,%g,%g,%g,%g\n", (long long)rows[i].open_time,
+                rows[i].open, rows[i].high, rows[i].low, rows[i].close,
+                rows[i].volume);
+    }
+    fclose(f);
+    return 1;
+}
+
+int main(void) {
+    int64_t now_ms = (int64_t)time(NULL) * 1000;
+
+    printf("Fetching %s klines from Binance into %s\n", SYMBOL, WICKRA_DATA_DIR);
+    size_t n_datasets = sizeof(DATASETS) / sizeof(DATASETS[0]);
+    for (size_t d = 0; d < n_datasets; ++d) {
+        const Dataset *ds = &DATASETS[d];
+        Kline *rows = NULL;
+        size_t n = collect(ds->interval, ds->target, now_ms, &rows);
+        if (n == 0) {
+            fprintf(stderr, "Binance returned no closed candles for %s\n",
+                    ds->interval);
+            free(rows);
+            return 1;
+        }
+        char path[256];
+        snprintf(path, sizeof(path), "%s/%s", WICKRA_DATA_DIR, ds->file);
+        if (!write_csv(path, rows, n)) {
+            fprintf(stderr, "could not write %s\n", path);
+            free(rows);
+            return 1;
+        }
+        printf("  %3s  %6llu candles  ->  %s\n", ds->interval, (unsigned long long)n,
+               path);
+        free(rows);
+    }
+    printf("Done — %llu datasets written.\n", (unsigned long long)n_datasets);
+    return 0;
+}

examples/c/live_binance.c

@@ -0,0 +1,154 @@
+/* Live BTCUSDT indicator with the Wickra C ABI.
+ *
+ * The C counterpart of `examples/rust/src/bin/live_binance.rs`,
+ * `examples/python/live_trading.py` and `examples/node/live_trading.js`. Those
+ * stream Binance over a WebSocket; the C ABI ships only the indicators and no
+ * socket layer, so this example polls the Binance REST klines endpoint via the
+ * system `curl` once per interval and feeds each newly *closed* candle into a
+ * streaming RSI(14). Same "live feed -> incremental indicator" shape, no extra
+ * dependency.
+ *
+ * This example talks to the network and runs until interrupted (Ctrl+C), so it
+ * is built but NOT run as a ctest.
+ *
+ * Build (after `cargo build -p wickra-c --release`):
+ *   cc examples/c/live_binance.c -I bindings/c/include -L target/release -lwickra -lm -o live_binance
+ *   ./live_binance [SYMBOL]
+ */
+
+#include "wickra.h"
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#define SLEEP_MS(ms) Sleep(ms)
+#define POPEN _popen
+#define PCLOSE _pclose
+#else
+#include <time.h>
+#define POPEN popen
+#define PCLOSE pclose
+static void SLEEP_MS(long ms) {
+    struct timespec ts = {ms / 1000, (ms % 1000) * 1000000L};
+    nanosleep(&ts, NULL);
+}
+#endif
+
+/* Run `curl <url>` and return stdout as a malloc'd, NUL-terminated buffer. */
+static char *curl_get(const char *url) {
+    char cmd[512];
+    snprintf(cmd, sizeof(cmd),
+             "curl --silent --show-error --fail --max-time 15 \"%s\"", url);
+    FILE *p = POPEN(cmd, "r");
+    if (p == NULL) {
+        return NULL;
+    }
+    size_t cap = 1 << 15, len = 0;
+    char *buf = (char *)malloc(cap);
+    if (buf == NULL) {
+        PCLOSE(p);
+        return NULL;
+    }
+    size_t got;
+    char tmp[4096];
+    while ((got = fread(tmp, 1, sizeof(tmp), p)) > 0) {
+        if (len + got + 1 > cap) {
+            cap *= 2;
+            char *grown = (char *)realloc(buf, cap);
+            if (grown == NULL) {
+                free(buf);
+                PCLOSE(p);
+                return NULL;
+            }
+            buf = grown;
+        }
+        memcpy(buf + len, tmp, got);
+        len += got;
+    }
+    int rc = PCLOSE(p);
+    buf[len] = '\0';
+    if (rc != 0 || len == 0) {
+        free(buf);
+        return NULL;
+    }
+    return buf;
+}
+
+/* Extract the first kline's open time and close price from a klines response of
+ * the form [[openTime,"open","high","low","close",...],...]. Returns 1 on
+ * success. The first row (limit=2) is the most recent fully closed candle. */
+static int first_kline(const char *body, int64_t *open_time, double *close) {
+    const char *s = strchr(body, '[');
+    if (s == NULL) {
+        return 0;
+    }
+    s = strchr(s + 1, '['); /* into the first row */
+    if (s == NULL) {
+        return 0;
+    }
+    s++;
+    char tok[64];
+    int field = 0;
+    while (*s && *s != ']') {
+        size_t tl = 0;
+        while (*s && *s != ',' && *s != ']') {
+            if (*s != '"' && tl + 1 < sizeof(tok)) {
+                tok[tl++] = *s;
+            }
+            s++;
+        }
+        tok[tl] = '\0';
+        if (field == 0) {
+            *open_time = strtoll(tok, NULL, 10);
+        } else if (field == 4) {
+            *close = strtod(tok, NULL);
+            return 1;
+        }
+        field++;
+        if (*s == ',') {
+            s++;
+        }
+    }
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    const char *symbol = (argc > 1) ? argv[1] : "BTCUSDT";
+    char url[256];
+    snprintf(url, sizeof(url),
+             "https://api.binance.com/api/v3/klines?symbol=%s&interval=1m&limit=2",
+             symbol);
+
+    struct Rsi *rsi = wickra_rsi_new(14);
+    if (rsi == NULL) {
+        fprintf(stderr, "failed to create RSI\n");
+        return 1;
+    }
+    printf("Listening for %s 1m closes (REST poll, Ctrl+C to stop)...\n", symbol);
+
+    int64_t last_open = 0;
+    for (;;) {
+        char *body = curl_get(url);
+        if (body != NULL) {
+            int64_t open_time = 0;
+            double close = 0.0;
+            if (first_kline(body, &open_time, &close) && open_time != last_open) {
+                last_open = open_time;
+                double v = wickra_rsi_update(rsi, close);
+                if (isfinite(v)) {
+                    printf("%s  close=%.4f  rsi=%.2f\n", symbol, close, v);
+                } else {
+                    printf("%s  close=%.4f  rsi=...warmup\n", symbol, close);
+                }
+                fflush(stdout);
+            }
+            free(body);
+        }
+        SLEEP_MS(2000);
+    }
+    /* Unreachable in normal use (interrupted by Ctrl+C). */
+}

examples/c/multi_timeframe.c

@@ -0,0 +1,151 @@
+/* Multi-timeframe indicators with the Wickra C ABI.
+ *
+ * The C counterpart of `examples/rust/src/bin/multi_timeframe.rs` and
+ * `examples/python/multi_timeframe.py`: read the bundled 1-minute BTCUSDT CSV
+ * (or a path on the command line), resample it to 5m / 15m / 1h / 4h / 1d, and
+ * print the last RSI(14), MACD(12,26,9) histogram and ADX(14) at each timeframe.
+ *
+ * The Rust/Python stack resamples through `wickra-data`; the C ABI ships only
+ * the indicators, so the time-bucket aggregation is done here (open = first,
+ * high = max, low = min, close = last, volume = sum per bucket).
+ *
+ * Build (after `cargo build -p wickra-c --release`):
+ *   cc examples/c/multi_timeframe.c -I bindings/c/include -L target/release -lwickra -lm -o multi_timeframe
+ *   ./multi_timeframe [path/to/1m.csv]
+ */
+
+#define WICKRA_CSV_IMPL
+#include "wickra.h"
+#include "wickra_csv.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef WICKRA_DATA_DIR
+#define WICKRA_DATA_DIR "../data"
+#endif
+
+#define ONE_MINUTE_MS 60000LL
+
+/* Aggregate `in` into fixed-width time buckets of `tf_ms`. Writes the bucketed
+ * candles into the caller-owned `out` (capacity >= count) and returns how many
+ * buckets were produced. */
+static size_t resample(const WickraCandle *in, size_t count, int64_t tf_ms,
+                       WickraCandle *out) {
+    size_t produced = 0;
+    int open_bucket = 0;
+    int64_t bucket_start = 0;
+    WickraCandle cur = {0};
+    for (size_t i = 0; i < count; ++i) {
+        int64_t b = in[i].timestamp - (in[i].timestamp % tf_ms);
+        if (!open_bucket || b != bucket_start) {
+            if (open_bucket) {
+                out[produced++] = cur;
+            }
+            bucket_start = b;
+            cur = in[i];
+            cur.timestamp = b;
+            open_bucket = 1;
+        } else {
+            if (in[i].high > cur.high) {
+                cur.high = in[i].high;
+            }
+            if (in[i].low < cur.low) {
+                cur.low = in[i].low;
+            }
+            cur.close = in[i].close;
+            cur.volume += in[i].volume;
+        }
+    }
+    if (open_bucket) {
+        out[produced++] = cur;
+    }
+    return produced;
+}
+
+static void summarize(const char *label, const WickraCandle *candles, size_t n) {
+    if (n == 0) {
+        printf("  %-5s (empty)\n", label);
+        return;
+    }
+    struct Rsi *rsi = wickra_rsi_new(14);
+    struct MacdIndicator *macd = wickra_macd_indicator_new(12, 26, 9);
+    struct Adx *adx = wickra_adx_new(14);
+
+    double last_rsi = NAN;
+    double last_hist = NAN;
+    double last_adx = NAN;
+    for (size_t i = 0; i < n; ++i) {
+        const WickraCandle *c = &candles[i];
+        double r = wickra_rsi_update(rsi, c->close);
+        if (isfinite(r)) {
+            last_rsi = r;
+        }
+        WickraMacdOutput m;
+        if (wickra_macd_indicator_update(macd, c->close, &m)) {
+            last_hist = m.histogram;
+        }
+        WickraAdxOutput a;
+        if (wickra_adx_update(adx, c->open, c->high, c->low, c->close, c->volume,
+                              c->timestamp, &a)) {
+            last_adx = a.adx;
+        }
+    }
+
+    char b_rsi[16], b_hist[16], b_adx[16];
+    if (isfinite(last_rsi)) {
+        snprintf(b_rsi, sizeof(b_rsi), "%6.2f", last_rsi);
+    } else {
+        snprintf(b_rsi, sizeof(b_rsi), "    --");
+    }
+    if (isfinite(last_hist)) {
+        snprintf(b_hist, sizeof(b_hist), "%+6.2f", last_hist);
+    } else {
+        snprintf(b_hist, sizeof(b_hist), " --   ");
+    }
+    if (isfinite(last_adx)) {
+        snprintf(b_adx, sizeof(b_adx), "%6.2f", last_adx);
+    } else {
+        snprintf(b_adx, sizeof(b_adx), "    --");
+    }
+    printf("  %-5s bars=%5llu  last_close=%10.2f  rsi=%s  macd_hist=%s  adx=%s\n",
+           label, (unsigned long long)n, candles[n - 1].close, b_rsi, b_hist, b_adx);
+
+    wickra_rsi_free(rsi);
+    wickra_macd_indicator_free(macd);
+    wickra_adx_free(adx);
+}
+
+int main(int argc, char **argv) {
+    const char *path = (argc > 1) ? argv[1] : WICKRA_DATA_DIR "/btcusdt-1m.csv";
+
+    WickraCandle *ones = NULL;
+    size_t n = wickra_load_csv(path, &ones);
+    if (n == 0) {
+        fprintf(stderr, "multi_timeframe: no candles read from %s\n", path);
+        return 1;
+    }
+    /* Resampling only ever produces fewer candles than the 1m source. */
+    WickraCandle *buf = (WickraCandle *)malloc(n * sizeof(*buf));
+    if (buf == NULL) {
+        fprintf(stderr, "multi_timeframe: allocation failed\n");
+        free(ones);
+        return 1;
+    }
+
+    printf("Multi-timeframe view of %s\n", path);
+    summarize("1m", ones, n);
+
+    const struct {
+        const char *label;
+        int64_t minutes;
+    } frames[] = {{"5m", 5}, {"15m", 15}, {"1h", 60}, {"4h", 240}, {"1d", 1440}};
+    for (size_t f = 0; f < sizeof(frames) / sizeof(frames[0]); ++f) {
+        size_t m = resample(ones, n, frames[f].minutes * ONE_MINUTE_MS, buf);
+        summarize(frames[f].label, buf, m);
+    }
+
+    free(buf);
+    free(ones);
+    return 0;
+}

examples/c/parallel_assets.c

@@ -0,0 +1,156 @@
+/* Parallel multi-asset indicator computation with the Wickra C ABI.
+ *
+ * The C counterpart of `examples/rust/src/bin/parallel_assets.rs` (rayon) and
+ * `examples/python/parallel_assets.py` (the Rust extension drops the GIL). The C
+ * ABI is the parallelization primitive itself: each `wickra_<ind>_new` handle is
+ * independent, so the caller fans assets out across threads, one fresh handle per
+ * asset. Here a serial baseline is compared against an OpenMP `parallel for`.
+ *
+ * If the compiler has no OpenMP support the "parallel" pass simply runs the same
+ * single-threaded loop (speedup ~1x) — the result is honest either way.
+ *
+ * Build (after `cargo build -p wickra-c --release`):
+ *   cc -fopenmp examples/c/parallel_assets.c -I bindings/c/include -L target/release -lwickra -lm -o parallel_assets
+ *   ./parallel_assets --assets 200 --bars 5000 --indicator sma
+ */
+
+#include "wickra.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+/* Wall-clock seconds (not CPU time, so threaded speedup is measured correctly). */
+static double now_seconds(void) {
+#ifdef _OPENMP
+    return omp_get_wtime();
+#else
+    struct timespec ts;
+    timespec_get(&ts, TIME_UTC);
+    return (double)ts.tv_sec + (double)ts.tv_nsec * 1e-9;
+#endif
+}
+
+typedef enum { IND_SMA, IND_RSI } Which;
+
+/* Deterministic synthetic (assets, bars) panel, flat row-major. Each asset uses
+ * an independent LCG seed so the series are uncorrelated but reproducible. */
+static void synthesize_panel(double *panel, size_t assets, size_t bars) {
+    for (size_t a = 0; a < assets; ++a) {
+        double price = 100.0;
+        uint32_t state = (uint32_t)(1234567u + a) * 2654435761u;
+        for (size_t b = 0; b < bars; ++b) {
+            state = (state * 1103515245u + 12345u) & 0x7FFFFFFFu;
+            double r = (double)state / (double)0x7FFFFFFFu;
+            price += (r - 0.5) * 0.4;
+            panel[a * bars + b] = price;
+        }
+    }
+}
+
+/* Run one asset's series through a fresh handle into its output slice. */
+static void run_one(Which which, const double *prices, double *out, size_t bars) {
+    if (which == IND_SMA) {
+        struct Sma *h = wickra_sma_new(14);
+        wickra_sma_batch(h, prices, out, bars);
+        wickra_sma_free(h);
+    } else {
+        struct Rsi *h = wickra_rsi_new(14);
+        wickra_rsi_batch(h, prices, out, bars);
+        wickra_rsi_free(h);
+    }
+}
+
+int main(int argc, char **argv) {
+    size_t assets = 200;
+    size_t bars = 5000;
+    Which which = IND_SMA;
+    for (int i = 1; i < argc; ++i) {
+        if (strcmp(argv[i], "--assets") == 0 && i + 1 < argc) {
+            assets = (size_t)strtoul(argv[++i], NULL, 10);
+        } else if (strcmp(argv[i], "--bars") == 0 && i + 1 < argc) {
+            bars = (size_t)strtoul(argv[++i], NULL, 10);
+        } else if (strcmp(argv[i], "--indicator") == 0 && i + 1 < argc) {
+            ++i;
+            if (strcmp(argv[i], "sma") == 0) {
+                which = IND_SMA;
+            } else if (strcmp(argv[i], "rsi") == 0) {
+                which = IND_RSI;
+            } else {
+                fprintf(stderr, "--indicator: expected 'sma' or 'rsi'\n");
+                return 1;
+            }
+        } else {
+            fprintf(stderr, "usage: parallel_assets [--assets N] [--bars N] "
+                            "[--indicator sma|rsi]\n");
+            return 1;
+        }
+    }
+    if (assets == 0 || bars == 0) {
+        fprintf(stderr, "--assets and --bars must be positive\n");
+        return 1;
+    }
+
+    const char *ind_name = (which == IND_SMA) ? "sma" : "rsi";
+    printf("Generating %llux%llu synthetic panel...\n", (unsigned long long)assets,
+           (unsigned long long)bars);
+    double *panel = (double *)malloc(assets * bars * sizeof(*panel));
+    double *serial = (double *)malloc(assets * bars * sizeof(*serial));
+    double *parallel = (double *)malloc(assets * bars * sizeof(*parallel));
+    if (panel == NULL || serial == NULL || parallel == NULL) {
+        fprintf(stderr, "allocation failed\n");
+        return 1;
+    }
+    synthesize_panel(panel, assets, bars);
+
+    double t0 = now_seconds();
+    for (size_t a = 0; a < assets; ++a) {
+        run_one(which, &panel[a * bars], &serial[a * bars], bars);
+    }
+    double t_serial = now_seconds() - t0;
+    printf("Serial:   %8.3f s  (%llu assets, indicator=%s)\n", t_serial,
+           (unsigned long long)assets, ind_name);
+
+    /* The loop variable is declared outside the `for` and the bound is a plain
+     * variable: MSVC's OpenMP 2.0 rejects an in-init declaration or a cast in
+     * the condition (error C3015). */
+    long a;
+    long asset_count = (long)assets;
+    t0 = now_seconds();
+#ifdef _OPENMP
+#pragma omp parallel for schedule(static)
+#endif
+    for (a = 0; a < asset_count; ++a) {
+        run_one(which, &panel[(size_t)a * bars], &parallel[(size_t)a * bars], bars);
+    }
+    double t_parallel = now_seconds() - t0;
+    double denom = t_parallel > 1e-9 ? t_parallel : 1e-9;
+#ifdef _OPENMP
+    printf("Parallel: %8.3f s  (OpenMP, %d threads, speedup ~%.2fx)\n", t_parallel,
+           omp_get_max_threads(), t_serial / denom);
+#else
+    printf("Parallel: %8.3f s  (no OpenMP at build time — serial, speedup ~%.2fx)\n",
+           t_parallel, t_serial / denom);
+#endif
+
+    /* The parallel run must reproduce the serial results exactly. */
+    for (size_t i = 0; i < assets * bars; ++i) {
+        int both_nan = isnan(serial[i]) && isnan(parallel[i]);
+        if (!both_nan && serial[i] != parallel[i]) {
+            fprintf(stderr, "mismatch at %llu: serial=%g parallel=%g\n",
+                    (unsigned long long)i, serial[i], parallel[i]);
+            return 1;
+        }
+    }
+    printf("Parallel results match serial results — OK.\n");
+
+    free(panel);
+    free(serial);
+    free(parallel);
+    return 0;
+}

examples/c/smoke.c

@@ -0,0 +1,64 @@
+/* Smoke test for the Wickra C ABI.
+ *
+ * This is the one test the Rust unit tests structurally cannot do: it links a
+ * foreign C consumer against the generated `wickra.h` + the compiled library and
+ * exercises the real FFI boundary (symbol export, header correctness, opaque
+ * handle, pointer ownership, `_free`). If this passes, every C-capable language
+ * (C, C++, Go, C#, Java, R) can link the same way.
+ *
+ * Build (from the workspace root, after `cargo build -p wickra-c --release`):
+ *   cc examples/c/smoke.c -I bindings/c/include target/release/<lib> -lm -o smoke
+ */
+
+#include "wickra.h"
+#include <math.h>
+#include <stdio.h>
+
+static int near(double a, double b) { return fabs(a - b) < 1e-9; }
+
+int main(void) {
+    struct Sma *sma = wickra_sma_new(3);
+    if (sma == NULL) {
+        printf("FAIL: wickra_sma_new returned NULL\n");
+        return 1;
+    }
+
+    /* SMA(3): first two outputs are warmup (NaN), then the trailing mean. */
+    double in[5] = {1.0, 2.0, 3.0, 4.0, 5.0};
+    double r0 = wickra_sma_update(sma, in[0]); /* NaN  (1/3) */
+    double r1 = wickra_sma_update(sma, in[1]); /* NaN  (2/3) */
+    double r2 = wickra_sma_update(sma, in[2]); /* 2.0  (1+2+3)/3 */
+    double r3 = wickra_sma_update(sma, in[3]); /* 3.0  (2+3+4)/3 */
+
+    if (!isnan(r0) || !isnan(r1)) {
+        printf("FAIL: warmup not NaN (%f %f)\n", r0, r1);
+        return 1;
+    }
+    if (!near(r2, 2.0) || !near(r3, 3.0)) {
+        printf("FAIL: streaming values (%f %f), expected (2.0 3.0)\n", r2, r3);
+        return 1;
+    }
+
+    /* Batch over a reset instance must reproduce the streaming result. */
+    wickra_sma_reset(sma);
+    double out[5];
+    wickra_sma_batch(sma, in, out, 5);
+    if (!isnan(out[0]) || !isnan(out[1]) ||
+        !near(out[2], 2.0) || !near(out[3], 3.0) || !near(out[4], 4.0)) {
+        printf("FAIL: batch mismatch (%f %f %f %f %f)\n",
+               out[0], out[1], out[2], out[3], out[4]);
+        return 1;
+    }
+
+    /* NULL handle is a defined no-op / NaN, never a crash. */
+    if (!isnan(wickra_sma_update(NULL, 1.0))) {
+        printf("FAIL: NULL update did not return NaN\n");
+        return 1;
+    }
+    wickra_sma_reset(NULL);
+    wickra_sma_free(NULL);
+
+    wickra_sma_free(sma);
+    printf("OK: wickra C ABI smoke passed (SMA streaming + batch + reset + NULL-safety + free)\n");
+    return 0;
+}

examples/c/smoke.cpp

@@ -0,0 +1,36 @@
+// C++ smoke test for the Wickra C ABI via the optional RAII wrapper (`wickra.hpp`).
+//
+// Validates that the header compiles as C++ and that `wickra::Handle` constructs,
+// moves, and frees correctly across the boundary.
+
+#include "wickra.hpp"
+
+#include <cmath>
+#include <cstdio>
+#include <utility>
+
+int main() {
+    wickra::Handle<Sma, wickra_sma_free> sma(wickra_sma_new(3));
+    if (!sma) {
+        std::puts("FAIL: wickra_sma_new returned null");
+        return 1;
+    }
+
+    (void)wickra_sma_update(sma.get(), 1.0);
+    (void)wickra_sma_update(sma.get(), 2.0);
+    double value = wickra_sma_update(sma.get(), 3.0);
+    if (std::fabs(value - 2.0) > 1e-9) {
+        std::printf("FAIL: SMA(3) value %.6f, expected 2.0\n", value);
+        return 1;
+    }
+
+    // Move transfers ownership; the moved-from handle must not double-free.
+    wickra::Handle<Sma, wickra_sma_free> moved(std::move(sma));
+    if (static_cast<bool>(sma) || !static_cast<bool>(moved)) {
+        std::puts("FAIL: move semantics");
+        return 1;
+    }
+
+    std::puts("OK: wickra C++ RAII smoke passed (Handle construct + move + auto-free)");
+    return 0;
+}

examples/c/strategy_bollinger_squeeze.c

@@ -0,0 +1,137 @@
+/* Strategy example: Bollinger-Squeeze breakout with ATR stop (Wickra C ABI).
+ *
+ * Enters long when the Bollinger Bandwidth has just printed a fresh 6-month low
+ * (the squeeze) and price closes above the upper band (the release). Exits when
+ * price closes below entry minus 2*ATR(14), or when the upper band trails back
+ * below the entry price (the squeeze has played out). 0.1% fees per trade. The
+ * C counterpart of `examples/rust/src/bin/strategy_bollinger_squeeze.rs`.
+ *
+ * Educational example. NOT a live trading recommendation. Uses the checked-in
+ * `examples/data/btcusdt-1d.csv` dataset because daily bars give an
+ * interpretable "6-month low" lookback (~180 bars).
+ *
+ * Build (after `cargo build -p wickra-c --release`):
+ *   cc examples/c/strategy_bollinger_squeeze.c -I bindings/c/include -L target/release -lwickra -lm -o strat_bb
+ */
+
+#define WICKRA_CSV_IMPL
+#define WICKRA_STRATEGY_IMPL
+#include "wickra.h"
+#include "wickra_csv.h"
+#include "wickra_strategy.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef WICKRA_DATA_DIR
+#define WICKRA_DATA_DIR "../data"
+#endif
+
+#define FEE 0.001
+#define BB_PERIOD 20
+#define BB_K 2.0
+#define ATR_PERIOD 14
+#define ATR_STOP_MULT 2.0
+#define SQUEEZE_LOOKBACK 180 /* ~6 months of daily bars */
+
+int main(int argc, char **argv) {
+    const char *path = (argc > 1) ? argv[1] : WICKRA_DATA_DIR "/btcusdt-1d.csv";
+
+    WickraCandle *candles = NULL;
+    size_t n = wickra_load_csv(path, &candles);
+    if (n < SQUEEZE_LOOKBACK + BB_PERIOD) {
+        fprintf(stderr, "dataset has only %llu bars; need at least %d\n",
+                (unsigned long long)n, SQUEEZE_LOOKBACK + BB_PERIOD);
+        free(candles);
+        return 1;
+    }
+
+    struct BollingerBands *bb = wickra_bollinger_bands_new(BB_PERIOD, BB_K);
+    struct Atr *atr = wickra_atr_new(ATR_PERIOD);
+    double *trades = (double *)malloc(n * sizeof(*trades));
+    double *equity_curve = (double *)malloc(n * sizeof(*equity_curve));
+    /* Circular buffer of recent bandwidth values for the squeeze lookback. */
+    double bw_window[SQUEEZE_LOOKBACK];
+    size_t bw_len = 0, bw_head = 0;
+    if (bb == NULL || atr == NULL || trades == NULL || equity_curve == NULL) {
+        fprintf(stderr, "allocation failed\n");
+        return 1;
+    }
+
+    int in_position = 0;
+    double entry_price = 0.0, stop_level = 0.0;
+    size_t n_trades = 0;
+    double equity = 1.0;
+
+    for (size_t i = 0; i < n; ++i) {
+        const WickraCandle *c = &candles[i];
+        double price = c->close;
+        WickraBollingerOutput b;
+        int bb_ready = wickra_bollinger_bands_update(bb, price, &b);
+        double a = wickra_atr_update(atr, c->open, c->high, c->low, c->close,
+                                     c->volume, c->timestamp);
+
+        equity_curve[i] = in_position ? equity * (price / entry_price) : equity;
+
+        if (!bb_ready || !isfinite(a)) {
+            continue;
+        }
+
+        double bandwidth =
+            fabs(b.middle) > 1e-15 ? (b.upper - b.lower) / b.middle : NAN;
+        if (isfinite(bandwidth)) {
+            if (bw_len == SQUEEZE_LOOKBACK) {
+                bw_window[bw_head] = bandwidth;
+                bw_head = (bw_head + 1) % SQUEEZE_LOOKBACK;
+            } else {
+                bw_window[bw_len++] = bandwidth;
+            }
+        }
+
+        if (bw_len < SQUEEZE_LOOKBACK || !isfinite(bandwidth)) {
+            continue;
+        }
+        double min_bw = INFINITY;
+        for (size_t k = 0; k < bw_len; ++k) {
+            if (bw_window[k] < min_bw) {
+                min_bw = bw_window[k];
+            }
+        }
+
+        if (in_position) {
+            int stop_hit = price < stop_level;
+            int upper_collapse = b.upper < entry_price;
+            if (stop_hit || upper_collapse) {
+                double trade_ret = price / entry_price - 1.0;
+                trades[n_trades++] = trade_ret;
+                equity *= (1.0 + trade_ret) * (1.0 - FEE);
+                in_position = 0;
+            }
+        } else {
+            int is_new_low = fabs(bandwidth - min_bw) < 1e-12;
+            int breakout = price > b.upper;
+            if (is_new_low && breakout) {
+                entry_price = price;
+                stop_level = price - ATR_STOP_MULT * a;
+                equity *= 1.0 - FEE;
+                in_position = 1;
+            }
+        }
+    }
+    if (in_position) {
+        double trade_ret = candles[n - 1].close / entry_price - 1.0;
+        trades[n_trades++] = trade_ret;
+        equity *= (1.0 + trade_ret) * (1.0 - FEE);
+    }
+
+    wickra_print_summary("Bollinger Squeeze Breakout (1d, BTCUSDT)", candles[0].close,
+                         candles[n - 1].close, n, trades, n_trades, equity,
+                         equity_curve, n);
+
+    wickra_bollinger_bands_free(bb);
+    wickra_atr_free(atr);
+    free(trades);
+    free(equity_curve);
+    free(candles);
+    return 0;
+}

examples/c/strategy_macd_adx.c

@@ -0,0 +1,107 @@
+/* Strategy example: MACD crossover with ADX trend-strength filter (Wickra C ABI).
+ *
+ * Long-only trend follower. Entries fire when the MACD line crosses above the
+ * signal line while ADX(14) > 20 (a market with at least mild directional
+ * strength); exits on the opposite MACD crossover regardless of ADX. 0.1% fees
+ * per trade. The C counterpart of `examples/rust/src/bin/strategy_macd_adx.rs`.
+ *
+ * The ADX filter is the point: pure MACD on sideways markets chops in and out;
+ * gating entries on directional strength cuts the worst losing streak.
+ *
+ * Educational example. NOT a live trading recommendation. Uses the checked-in
+ * `examples/data/btcusdt-1h.csv` dataset.
+ *
+ * Build (after `cargo build -p wickra-c --release`):
+ *   cc examples/c/strategy_macd_adx.c -I bindings/c/include -L target/release -lwickra -lm -o strat_macd
+ */
+
+#define WICKRA_CSV_IMPL
+#define WICKRA_STRATEGY_IMPL
+#include "wickra.h"
+#include "wickra_csv.h"
+#include "wickra_strategy.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef WICKRA_DATA_DIR
+#define WICKRA_DATA_DIR "../data"
+#endif
+
+#define FEE 0.001
+#define ADX_FLOOR 20.0
+
+int main(int argc, char **argv) {
+    const char *path = (argc > 1) ? argv[1] : WICKRA_DATA_DIR "/btcusdt-1h.csv";
+
+    WickraCandle *candles = NULL;
+    size_t n = wickra_load_csv(path, &candles);
+    if (n == 0) {
+        fprintf(stderr, "CSV is empty: %s\n", path);
+        return 1;
+    }
+
+    struct MacdIndicator *macd = wickra_macd_indicator_new(12, 26, 9);
+    struct Adx *adx = wickra_adx_new(14);
+    double *trades = (double *)malloc(n * sizeof(*trades));
+    double *equity_curve = (double *)malloc(n * sizeof(*equity_curve));
+    if (macd == NULL || adx == NULL || trades == NULL || equity_curve == NULL) {
+        fprintf(stderr, "allocation failed\n");
+        return 1;
+    }
+
+    int in_position = 0;
+    double entry_price = 0.0;
+    size_t n_trades = 0;
+    double equity = 1.0;
+    /* Previous histogram sign to detect MACD-line crossovers: -1 unset, 0/1 sign. */
+    int prev_hist_sign = -1;
+
+    for (size_t i = 0; i < n; ++i) {
+        const WickraCandle *c = &candles[i];
+        double price = c->close;
+        WickraMacdOutput m;
+        int macd_ready = wickra_macd_indicator_update(macd, price, &m);
+        WickraAdxOutput a;
+        int adx_ready = wickra_adx_update(adx, c->open, c->high, c->low, c->close,
+                                          c->volume, c->timestamp, &a);
+
+        equity_curve[i] = in_position ? equity * (price / entry_price) : equity;
+
+        if (!macd_ready || !adx_ready) {
+            continue;
+        }
+
+        int hist_sign = m.histogram > 0.0 ? 1 : 0;
+        int cross_up = prev_hist_sign == 0 && hist_sign == 1;
+        int cross_down = prev_hist_sign == 1 && hist_sign == 0;
+        prev_hist_sign = hist_sign;
+
+        if (!in_position && cross_up && a.adx > ADX_FLOOR) {
+            entry_price = price;
+            equity *= 1.0 - FEE;
+            in_position = 1;
+        } else if (in_position && cross_down) {
+            double trade_ret = price / entry_price - 1.0;
+            trades[n_trades++] = trade_ret;
+            equity *= (1.0 + trade_ret) * (1.0 - FEE);
+            in_position = 0;
+        }
+    }
+    if (in_position) {
+        double trade_ret = candles[n - 1].close / entry_price - 1.0;
+        trades[n_trades++] = trade_ret;
+        equity *= (1.0 + trade_ret) * (1.0 - FEE);
+    }
+
+    wickra_print_summary("MACD + ADX Trend Filter (1h, BTCUSDT)", candles[0].close,
+                         candles[n - 1].close, n, trades, n_trades, equity,
+                         equity_curve, n);
+
+    wickra_macd_indicator_free(macd);
+    wickra_adx_free(adx);
+    free(trades);
+    free(equity_curve);
+    free(candles);
+    return 0;
+}

examples/c/strategy_rsi_mean_reversion.c

@@ -0,0 +1,95 @@
+/* Strategy example: RSI mean-reversion on hourly BTCUSDT data (Wickra C ABI).
+ *
+ * Goes long when RSI(14) crosses below 30 (oversold), exits when RSI crosses
+ * above 70 (overbought). Position is binary (full-in / full-out), fees are 0.1%
+ * per trade (Binance maker tier), no stop-loss. The C counterpart of
+ * `examples/rust/src/bin/strategy_rsi_mean_reversion.rs`.
+ *
+ * Educational example. NOT a recommended trading strategy — the point is to
+ * show how a Wickra streaming indicator wires into a signal -> fill -> PnL ->
+ * equity loop. Uses the checked-in `examples/data/btcusdt-1h.csv` dataset.
+ *
+ * Build (after `cargo build -p wickra-c --release`):
+ *   cc examples/c/strategy_rsi_mean_reversion.c -I bindings/c/include -L target/release -lwickra -lm -o strat_rsi
+ */
+
+#define WICKRA_CSV_IMPL
+#define WICKRA_STRATEGY_IMPL
+#include "wickra.h"
+#include "wickra_csv.h"
+#include "wickra_strategy.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef WICKRA_DATA_DIR
+#define WICKRA_DATA_DIR "../data"
+#endif
+
+#define FEE 0.001
+#define RSI_PERIOD 14
+#define OVERSOLD 30.0
+#define OVERBOUGHT 70.0
+
+int main(int argc, char **argv) {
+    const char *path = (argc > 1) ? argv[1] : WICKRA_DATA_DIR "/btcusdt-1h.csv";
+
+    WickraCandle *candles = NULL;
+    size_t n = wickra_load_csv(path, &candles);
+    if (n < RSI_PERIOD * 4) {
+        fprintf(stderr, "dataset too small: %llu\n", (unsigned long long)n);
+        free(candles);
+        return 1;
+    }
+
+    struct Rsi *rsi = wickra_rsi_new(RSI_PERIOD);
+    double *trades = (double *)malloc(n * sizeof(*trades));
+    double *equity_curve = (double *)malloc(n * sizeof(*equity_curve));
+    if (rsi == NULL || trades == NULL || equity_curve == NULL) {
+        fprintf(stderr, "allocation failed\n");
+        return 1;
+    }
+
+    int in_position = 0;
+    double entry_price = 0.0;
+    size_t n_trades = 0;
+    double equity = 1.0;
+
+    for (size_t i = 0; i < n; ++i) {
+        double price = candles[i].close;
+        double r = wickra_rsi_update(rsi, price);
+
+        /* Mark-to-market so the equity curve moves bar-by-bar between trades. */
+        equity_curve[i] = in_position ? equity * (price / entry_price) : equity;
+
+        if (!isfinite(r)) {
+            continue;
+        }
+        if (!in_position && r < OVERSOLD) {
+            entry_price = price;
+            equity *= 1.0 - FEE;
+            in_position = 1;
+        } else if (in_position && r > OVERBOUGHT) {
+            double trade_ret = price / entry_price - 1.0;
+            trades[n_trades++] = trade_ret;
+            equity *= (1.0 + trade_ret) * (1.0 - FEE);
+            in_position = 0;
+        }
+    }
+    /* Close any still-open trade at the last bar so metrics include it. */
+    if (in_position) {
+        double trade_ret = candles[n - 1].close / entry_price - 1.0;
+        trades[n_trades++] = trade_ret;
+        equity *= (1.0 + trade_ret) * (1.0 - FEE);
+    }
+
+    wickra_print_summary("RSI Mean-Reversion (1h, BTCUSDT)", candles[0].close,
+                         candles[n - 1].close, n, trades, n_trades, equity,
+                         equity_curve, n);
+
+    wickra_rsi_free(rsi);
+    free(trades);
+    free(equity_curve);
+    free(candles);
+    return 0;
+}

examples/c/streaming.c

@@ -0,0 +1,110 @@
+/* Streaming indicators with the Wickra C ABI.
+ *
+ * Feeds a synthetic price series through several indicators tick by tick — the
+ * same O(1)-per-update model a live trading bot would use — and prints a status
+ * line once every indicator has warmed up. The C counterpart of
+ * `examples/rust/src/bin/streaming.rs`, `examples/python/streaming.py` and
+ * `examples/node/streaming.js`, using the same seeded LCG so a side-by-side run
+ * produces visibly comparable streams.
+ *
+ * Build (after `cargo build -p wickra-c --release`):
+ *   cc examples/c/streaming.c -I bindings/c/include -L target/release -lwickra -lm -o streaming
+ */
+
+#include "wickra.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define DEFAULT_TICKS 120
+
+/* Deterministic synthetic series matching the sibling examples' seeded LCG. */
+static void make_series(double *prices, size_t n) {
+    uint64_t seed = 1234567u;
+    for (size_t t = 0; t < n; ++t) {
+        seed = (seed * 1103515245u + 12345u) & 0x7FFFFFFFu;
+        double rnd = (double)seed / (double)0x7FFFFFFFu;
+        double tf = (double)t;
+        prices[t] = 100.0 + tf * 0.05 + sin(tf * 0.07) * 8.0 + cos(tf * 0.21) * 3.0 +
+                    (rnd - 0.5);
+    }
+}
+
+/* Format an indicator value, rendering warmup (NaN) as a dashed placeholder. */
+static void fmt(char *buf, size_t buflen, double v) {
+    if (isfinite(v)) {
+        snprintf(buf, buflen, "%7.2f", v);
+    } else {
+        snprintf(buf, buflen, "  --   ");
+    }
+}
+
+int main(int argc, char **argv) {
+    size_t ticks = DEFAULT_TICKS;
+    if (argc == 3 && strcmp(argv[1], "--ticks") == 0) {
+        long parsed = strtol(argv[2], NULL, 10);
+        if (parsed <= 0) {
+            fprintf(stderr, "--ticks must be positive\n");
+            return 1;
+        }
+        ticks = (size_t)parsed;
+    } else if (argc != 1) {
+        fprintf(stderr, "usage: streaming [--ticks N]\n");
+        return 1;
+    }
+
+    struct Sma *sma = wickra_sma_new(20);
+    struct Ema *ema = wickra_ema_new(20);
+    struct Rsi *rsi = wickra_rsi_new(14);
+    struct MacdIndicator *macd = wickra_macd_indicator_new(12, 26, 9);
+    double *prices = (double *)malloc(ticks * sizeof(*prices));
+    if (sma == NULL || ema == NULL || rsi == NULL || macd == NULL || prices == NULL) {
+        fprintf(stderr, "allocation failed\n");
+        return 1;
+    }
+    make_series(prices, ticks);
+
+    printf("Wickra streaming indicator demo (C)\n\n");
+
+    size_t signals = 0;
+    for (size_t t = 0; t < ticks; ++t) {
+        double price = prices[t];
+        double sv = wickra_sma_update(sma, price);
+        double ev = wickra_ema_update(ema, price);
+        double rv = wickra_rsi_update(rsi, price);
+        WickraMacdOutput m;
+        int macd_ready = wickra_macd_indicator_update(macd, price, &m);
+
+        /* Only act once every indicator has produced a value. */
+        if (!isfinite(sv) || !isfinite(ev) || !isfinite(rv) || !macd_ready) {
+            continue;
+        }
+
+        int overbought = rv > 70.0 && m.histogram < 0.0;
+        int oversold = rv < 30.0 && m.histogram > 0.0;
+        const char *tag = overbought ? "SELL?" : (oversold ? "BUY? " : "     ");
+        if (overbought || oversold) {
+            signals++;
+        }
+
+        char b_price[16], b_sma[16], b_ema[16], b_rsi[16], b_hist[16];
+        fmt(b_price, sizeof(b_price), price);
+        fmt(b_sma, sizeof(b_sma), sv);
+        fmt(b_ema, sizeof(b_ema), ev);
+        fmt(b_rsi, sizeof(b_rsi), rv);
+        fmt(b_hist, sizeof(b_hist), m.histogram);
+        printf("t=%3llu  price=%s  sma=%s  ema=%s  rsi=%s  macd_hist=%s  %s\n",
+               (unsigned long long)t, b_price, b_sma, b_ema, b_rsi, b_hist, tag);
+    }
+
+    printf("\nDone — %llu candidate signal(s) over %llu ticks.\n",
+           (unsigned long long)signals, (unsigned long long)ticks);
+
+    wickra_sma_free(sma);
+    wickra_ema_free(ema);
+    wickra_rsi_free(rsi);
+    wickra_macd_indicator_free(macd);
+    free(prices);
+    return 0;
+}

examples/c/wickra_csv.h

@@ -0,0 +1,90 @@
+/* Shared OHLCV CSV loader for the Wickra C examples.
+ *
+ * The C ABI exposes only the indicators, not the wickra-data IO layer, so the
+ * examples read CSV themselves. This header-only helper is the C counterpart of
+ * `wickra_data::csv::CandleReader` used by the Rust examples: it parses the
+ * standard `timestamp,open,high,low,close,volume` files shipped under
+ * `examples/data/`.
+ *
+ * Header-only: define WICKRA_CSV_IMPL in exactly one translation unit (each
+ * example is a single .c file, so it just defines it before including this).
+ */
+#ifndef WICKRA_CSV_H
+#define WICKRA_CSV_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+typedef struct WickraCandle {
+    int64_t timestamp;
+    double open;
+    double high;
+    double low;
+    double close;
+    double volume;
+} WickraCandle;
+
+/* Load an OHLCV CSV into a malloc'd array. Returns the candle count and stores
+ * the array in *out (caller frees with free()). Returns 0 and leaves *out NULL
+ * on any error (missing file, no parseable rows). A leading header line whose
+ * first field is non-numeric is skipped. */
+size_t wickra_load_csv(const char *path, WickraCandle **out);
+
+#ifdef WICKRA_CSV_IMPL
+
+#include <stdio.h>
+#include <stdlib.h>
+
+size_t wickra_load_csv(const char *path, WickraCandle **out) {
+    *out = NULL;
+    FILE *f = fopen(path, "r");
+    if (f == NULL) {
+        fprintf(stderr, "wickra_load_csv: cannot open %s\n", path);
+        return 0;
+    }
+
+    size_t cap = 1024;
+    size_t n = 0;
+    WickraCandle *rows = (WickraCandle *)malloc(cap * sizeof(*rows));
+    if (rows == NULL) {
+        fclose(f);
+        return 0;
+    }
+
+    char line[512];
+    while (fgets(line, (int)sizeof(line), f) != NULL) {
+        WickraCandle c;
+        long long ts = 0;
+        /* sscanf returns the number of fields successfully matched. A header
+         * row ("timestamp,...") matches 0 and is skipped. */
+        int matched = sscanf(line, "%lld,%lf,%lf,%lf,%lf,%lf", &ts, &c.open,
+                             &c.high, &c.low, &c.close, &c.volume);
+        if (matched != 6) {
+            continue;
+        }
+        c.timestamp = (int64_t)ts;
+
+        if (n == cap) {
+            cap *= 2;
+            WickraCandle *grown = (WickraCandle *)realloc(rows, cap * sizeof(*rows));
+            if (grown == NULL) {
+                free(rows);
+                fclose(f);
+                return 0;
+            }
+            rows = grown;
+        }
+        rows[n++] = c;
+    }
+    fclose(f);
+
+    if (n == 0) {
+        free(rows);
+        return 0;
+    }
+    *out = rows;
+    return n;
+}
+
+#endif /* WICKRA_CSV_IMPL */
+#endif /* WICKRA_CSV_H */

examples/c/wickra_strategy.h

@@ -0,0 +1,92 @@
+/* Shared equity-curve summary for the Wickra C strategy examples.
+ *
+ * The Rust strategy examples repeat their `print_summary` per file; in C the
+ * presentation is factored into this header so each strategy .c file stays
+ * focused on its signal logic. Pure reporting — no indicator state.
+ *
+ * Header-only: define WICKRA_STRATEGY_IMPL in exactly one translation unit.
+ */
+#ifndef WICKRA_STRATEGY_H
+#define WICKRA_STRATEGY_H
+
+#include <stddef.h>
+
+/* Print a one-screen summary of a strategy run: returns vs buy & hold, trade
+ * win/loss counts, max drawdown, per-trade Sharpe, best/worst trade. */
+void wickra_print_summary(const char *name, double first_price, double last_price,
+                          size_t bars, const double *closed_trades, size_t n_trades,
+                          double final_equity, const double *equity_curve,
+                          size_t n_curve);
+
+#ifdef WICKRA_STRATEGY_IMPL
+
+#include <math.h>
+#include <stdio.h>
+
+void wickra_print_summary(const char *name, double first_price, double last_price,
+                          size_t bars, const double *closed_trades, size_t n_trades,
+                          double final_equity, const double *equity_curve,
+                          size_t n_curve) {
+    double buy_hold = last_price / first_price;
+    double strat_return = final_equity - 1.0;
+    double bh_return = buy_hold - 1.0;
+
+    size_t wins = 0, losses = 0;
+    double best = -INFINITY, worst = INFINITY;
+    double sum_ret = 0.0, sum_sq = 0.0;
+    for (size_t i = 0; i < n_trades; ++i) {
+        double r = closed_trades[i];
+        if (r > 0.0) {
+            wins++;
+        } else if (r < 0.0) {
+            losses++;
+        }
+        if (r > best) {
+            best = r;
+        }
+        if (r < worst) {
+            worst = r;
+        }
+        sum_ret += r;
+        sum_sq += r * r;
+    }
+    double n = (double)n_trades;
+    double mean_ret = n > 0.0 ? sum_ret / n : 0.0;
+    double var_ret = n > 1.0 ? (sum_sq - n * mean_ret * mean_ret) / (n - 1.0) : 0.0;
+    double sharpe = var_ret > 0.0 ? mean_ret / sqrt(var_ret) : 0.0;
+    if (n_trades == 0) {
+        best = 0.0;
+        worst = 0.0;
+    }
+
+    double peak = n_curve > 0 ? equity_curve[0] : 1.0;
+    double max_dd = 0.0;
+    for (size_t i = 0; i < n_curve; ++i) {
+        if (equity_curve[i] > peak) {
+            peak = equity_curve[i];
+        }
+        double dd = (peak - equity_curve[i]) / peak;
+        if (dd > max_dd) {
+            max_dd = dd;
+        }
+    }
+
+    printf("=== %s ===\n", name);
+    printf("Bars:                  %llu\n", (unsigned long long)bars);
+    printf("Trades:                %llu (W%llu / L%llu)\n", (unsigned long long)n_trades,
+           (unsigned long long)wins, (unsigned long long)losses);
+    printf("Strategy return:       %+.2f%%\n", strat_return * 100.0);
+    printf("Buy & Hold return:     %+.2f%%\n", bh_return * 100.0);
+    printf("Excess over BH:        %+.2f%%\n", (strat_return - bh_return) * 100.0);
+    printf("Max drawdown:          %.2f%%\n", max_dd * 100.0);
+    printf("Per-trade Sharpe:      %.2f  (mean %+.4f, stddev %.4f)\n", sharpe,
+           mean_ret, sqrt(var_ret));
+    printf("Best / worst trade:    %+.2f%% / %+.2f%%\n", best * 100.0, worst * 100.0);
+    printf("\n");
+    printf("NOTE: Educational example — fees, slippage, funding costs and tax "
+           "effects are simplified or omitted. Past performance is not indicative "
+           "of future results.\n");
+}
+
+#endif /* WICKRA_STRATEGY_IMPL */
+#endif /* WICKRA_STRATEGY_H */

examples/csharp/.gitignore

@@ -0,0 +1,7 @@
+# .NET build output
+bin/
+obj/
+*.user
+
+# Data fetched at runtime by fetch_btcusdt
+**/data/

examples/csharp/Directory.Build.props

@@ -0,0 +1,19 @@
+<Project>
+
+  <!-- Shared settings + references for every C# example. Each example project
+       only declares <OutputType>Exe</OutputType>. -->
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\bindings\csharp\Wickra\Wickra.csproj" />
+    <Compile Include="..\_common\MarketData.cs" Link="_common\MarketData.cs" />
+    <Compile Include="..\_common\Backtest.cs" Link="_common\Backtest.cs" />
+  </ItemGroup>
+
+</Project>

examples/csharp/README.md

@@ -0,0 +1,29 @@
+# Wickra examples — C# / .NET
+
+Runnable .NET examples for the [Wickra .NET binding](../../bindings/csharp).
+Each example is a small console project that references the `Wickra` project and
+resolves the native library automatically (from `target/release` during local
+development, or the NuGet `runtimes/` layout when packaged).
+
+Build the native library first, then run any example:
+
+```bash
+cargo build -p wickra-c --release
+dotnet run --project examples/csharp/streaming
+```
+
+| Example | What it does | Run |
+| --- | --- | --- |
+| `streaming` | Feed a synthetic price series through SMA / EMA / RSI / MACD tick by tick. | `dotnet run --project examples/csharp/streaming` |
+| `backtest` | Compute a basket of indicators over an OHLCV series and print a summary. | `dotnet run --project examples/csharp/backtest -- <ohlcv.csv>` |
+| `multi_timeframe` | Resample a 1-minute series into 5m / 15m and print an indicator per timeframe. | `dotnet run --project examples/csharp/multi_timeframe` |
+| `parallel_assets` | SMA(20) batch over a panel of assets, serial vs `Parallel.For`, with speedup. | `dotnet run -c Release --project examples/csharp/parallel_assets -- 200 5000` |
+| `strategy_rsi_mean_reversion` | RSI(14) mean-reversion with a PnL / Sharpe / max-DD summary. | `dotnet run -c Release --project examples/csharp/strategy_rsi_mean_reversion` |
+| `strategy_macd_adx` | MACD crossover entries gated by ADX(14) > 20. | `dotnet run -c Release --project examples/csharp/strategy_macd_adx` |
+| `strategy_bollinger_squeeze` | Bollinger-squeeze breakout with an ATR(14) trailing stop. | `dotnet run -c Release --project examples/csharp/strategy_bollinger_squeeze` |
+| `fetch_btcusdt` | Download real BTCUSDT klines from the Binance REST API into a CSV. | `dotnet run --project examples/csharp/fetch_btcusdt` |
+| `live_binance` | Stream live Binance klines through EMA(20) over a WebSocket. | `dotnet run --project examples/csharp/live_binance` |
+
+`fetch_btcusdt` and `live_binance` require network access; the rest run offline
+on deterministic synthetic data. Shared helpers (synthetic data, CSV loader,
+equity summary) live in [`_common/`](_common).

examples/csharp/_common/Backtest.cs

@@ -0,0 +1,45 @@
+namespace Wickra.Examples;
+
+/// <summary>Summary statistics for a long-only equity curve.</summary>
+public sealed record EquityResult(double TotalReturnPct, double Sharpe, double MaxDrawdownPct, int Trades, double FinalEquity);
+
+/// <summary>
+/// Minimal long-only backtest helper: turn a stream of per-bar fractional
+/// returns into a PnL / Sharpe / max-drawdown summary. The strategy examples
+/// produce the returns; this aggregates them.
+/// </summary>
+public static class Backtest
+{
+    /// <param name="periodReturns">Per-bar fractional returns (0.01 == +1%).</param>
+    /// <param name="trades">Number of position entries.</param>
+    /// <param name="periodsPerYear">Annualisation factor for the Sharpe ratio.</param>
+    public static EquityResult Summarize(IReadOnlyList<double> periodReturns, int trades, double periodsPerYear = 252.0)
+    {
+        double equity = 1.0, peak = 1.0, maxDrawdown = 0.0;
+        foreach (var r in periodReturns)
+        {
+            equity *= 1.0 + r;
+            peak = Math.Max(peak, equity);
+            if (peak > 0)
+            {
+                maxDrawdown = Math.Max(maxDrawdown, (peak - equity) / peak);
+            }
+        }
+
+        var mean = periodReturns.Count > 0 ? periodReturns.Average() : 0.0;
+        var variance = periodReturns.Count > 1
+            ? periodReturns.Sum(x => (x - mean) * (x - mean)) / (periodReturns.Count - 1)
+            : 0.0;
+        var stdDev = Math.Sqrt(variance);
+        var sharpe = stdDev > 1e-12 ? mean / stdDev * Math.Sqrt(periodsPerYear) : 0.0;
+
+        return new EquityResult((equity - 1.0) * 100.0, sharpe, maxDrawdown * 100.0, trades, equity);
+    }
+
+    /// <summary>Prints a one-line summary.</summary>
+    public static void Print(string name, EquityResult r)
+    {
+        Console.WriteLine(
+            $"{name,-26} return={r.TotalReturnPct,8:F2}%  sharpe={r.Sharpe,6:F2}  maxDD={r.MaxDrawdownPct,6:F2}%  trades={r.Trades}");
+    }
+}

examples/csharp/_common/MarketData.cs

@@ -0,0 +1,78 @@
+namespace Wickra.Examples;
+
+/// <summary>One OHLCV bar with a millisecond timestamp.</summary>
+public readonly record struct Bar(double Open, double High, double Low, double Close, double Volume, long Timestamp);
+
+/// <summary>
+/// Deterministic synthetic market data plus a small OHLCV CSV loader, shared by
+/// the offline examples so they run without network access.
+/// </summary>
+public static class MarketData
+{
+    /// <summary>A reproducible price path (trend + two cycles), no randomness.</summary>
+    public static double[] SyntheticPrices(int count, double start = 100.0)
+    {
+        var prices = new double[count];
+        for (var i = 0; i < count; i++)
+        {
+            prices[i] = start + 12.0 * Math.Sin(i * 0.05) + 5.0 * Math.Sin(i * 0.013) + i * 0.01;
+        }
+
+        return prices;
+    }
+
+    /// <summary>A reproducible OHLCV series derived from <see cref="SyntheticPrices"/>.</summary>
+    public static Bar[] SyntheticCandles(int count, long startTimestamp = 0, long stepMs = 3_600_000)
+    {
+        var prices = SyntheticPrices(count + 1);
+        var bars = new Bar[count];
+        for (var i = 0; i < count; i++)
+        {
+            var open = prices[i];
+            var close = prices[i + 1];
+            var high = Math.Max(open, close) + 0.5 + Math.Abs(Math.Sin(i * 0.7));
+            var low = Math.Min(open, close) - 0.5 - Math.Abs(Math.Cos(i * 0.7));
+            var volume = 1_000.0 + 500.0 * (1.0 + Math.Sin(i * 0.1));
+            bars[i] = new Bar(open, high, low, close, volume, startTimestamp + i * stepMs);
+        }
+
+        return bars;
+    }
+
+    /// <summary>
+    /// Loads an OHLCV CSV. Accepts rows of <c>timestamp,open,high,low,close,volume</c>
+    /// or <c>open,high,low,close,volume</c>; a non-numeric first row is treated as a header.
+    /// </summary>
+    public static Bar[] LoadOhlcvCsv(string path)
+    {
+        var bars = new List<Bar>();
+        foreach (var rawLine in File.ReadLines(path))
+        {
+            var line = rawLine.Trim();
+            if (line.Length == 0)
+            {
+                continue;
+            }
+
+            var cols = line.Split(',');
+            if (!double.TryParse(cols[0], System.Globalization.CultureInfo.InvariantCulture, out _) &&
+                !long.TryParse(cols[0], out _))
+            {
+                continue; // header row
+            }
+
+            double F(int i) => double.Parse(cols[i], System.Globalization.CultureInfo.InvariantCulture);
+
+            if (cols.Length >= 6)
+            {
+                bars.Add(new Bar(F(1), F(2), F(3), F(4), F(5), long.Parse(cols[0])));
+            }
+            else
+            {
+                bars.Add(new Bar(F(0), F(1), F(2), F(3), F(4), bars.Count));
+            }
+        }
+
+        return bars.ToArray();
+    }
+}

examples/csharp/backtest/Program.cs

@@ -0,0 +1,33 @@
+using Wickra;
+using Wickra.Examples;
+
+// Compute a basket of indicators over an OHLCV series and print a summary.
+// Pass a CSV path (timestamp,open,high,low,close,volume) or run on synthetic data.
+var source = args.Length > 0 ? args[0] : "synthetic";
+Bar[] bars = args.Length > 0 ? MarketData.LoadOhlcvCsv(args[0]) : MarketData.SyntheticCandles(1000);
+
+Console.WriteLine($"Backtest over {bars.Length} bars ({source}):");
+
+using var sma = new Sma(20);
+using var ema = new Ema(50);
+using var rsi = new Rsi(14);
+using var atr = new Atr(14);
+
+double lastSma = 0, lastEma = 0, lastRsi = 0, lastAtr = 0;
+var oversold = 0;
+foreach (var b in bars)
+{
+    lastSma = sma.Update(b.Close);
+    lastEma = ema.Update(b.Close);
+    lastRsi = rsi.Update(b.Close);
+    lastAtr = atr.Update(b.Open, b.High, b.Low, b.Close, b.Volume, b.Timestamp);
+    if (double.IsFinite(lastRsi) && lastRsi < 30.0)
+    {
+        oversold++;
+    }
+}
+
+Console.WriteLine($"  SMA(20) last = {lastSma:F4}");
+Console.WriteLine($"  EMA(50) last = {lastEma:F4}");
+Console.WriteLine($"  RSI(14) last = {lastRsi:F4}  ({oversold} oversold bars)");
+Console.WriteLine($"  ATR(14) last = {lastAtr:F4}");

examples/csharp/backtest/backtest.csproj

@@ -0,0 +1,5 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+</Project>

examples/csharp/fetch_btcusdt/Program.cs

@@ -0,0 +1,33 @@
+using System.Globalization;
+using System.Text.Json;
+
+// Download real BTCUSDT hourly klines from the Binance REST API into a CSV that the
+// other examples can consume. Requires network access (build-only in CI).
+const string url = "https://api.binance.com/api/v3/klines?symbol=BTCUSDT&interval=1h&limit=500";
+
+using var http = new HttpClient();
+Console.WriteLine($"Fetching {url}");
+var json = await http.GetStringAsync(url);
+
+using var doc = JsonDocument.Parse(json);
+var dir = Path.Combine(AppContext.BaseDirectory, "data");
+Directory.CreateDirectory(dir);
+var path = Path.Combine(dir, "btcusdt_1h.csv");
+
+using var writer = new StreamWriter(path);
+writer.WriteLine("timestamp,open,high,low,close,volume");
+var count = 0;
+foreach (var kline in doc.RootElement.EnumerateArray())
+{
+    // Binance kline array: [openTime, open, high, low, close, volume, ...]
+    var ts = kline[0].GetInt64();
+    var o = kline[1].GetString();
+    var h = kline[2].GetString();
+    var l = kline[3].GetString();
+    var c = kline[4].GetString();
+    var v = kline[5].GetString();
+    writer.WriteLine(string.Create(CultureInfo.InvariantCulture, $"{ts},{o},{h},{l},{c},{v}"));
+    count++;
+}
+
+Console.WriteLine($"Wrote {count} klines to {path}");

examples/csharp/fetch_btcusdt/fetch_btcusdt.csproj

@@ -0,0 +1,5 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+</Project>

examples/csharp/live_binance/Program.cs

@@ -0,0 +1,40 @@
+using System.Globalization;
+using System.Net.WebSockets;
+using System.Text;
+using System.Text.Json;
+using Wickra;
+
+// Stream live BTCUSDT 1-minute klines from Binance and feed each close through EMA(20).
+// Requires network access (build-only in CI). Runs for up to 60 seconds.
+var uri = new Uri("wss://stream.binance.com:9443/ws/btcusdt@kline_1m");
+Console.WriteLine($"Connecting to {uri} (up to 60s)...");
+
+using var ws = new ClientWebSocket();
+using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
+using var ema = new Ema(20);
+var buffer = new byte[8192];
+
+try
+{
+    await ws.ConnectAsync(uri, cts.Token);
+    while (ws.State == WebSocketState.Open && !cts.IsCancellationRequested)
+    {
+        var result = await ws.ReceiveAsync(buffer, cts.Token);
+        if (result.MessageType == WebSocketMessageType.Close)
+        {
+            break;
+        }
+
+        using var doc = JsonDocument.Parse(Encoding.UTF8.GetString(buffer, 0, result.Count));
+        if (doc.RootElement.TryGetProperty("k", out var k))
+        {
+            var close = double.Parse(k.GetProperty("c").GetString()!, CultureInfo.InvariantCulture);
+            var value = ema.Update(close);
+            Console.WriteLine($"close={close:F2}  EMA(20)={value:F2}");
+        }
+    }
+}
+catch (OperationCanceledException)
+{
+    Console.WriteLine("Done (time limit reached).");
+}

examples/csharp/live_binance/live_binance.csproj

@@ -0,0 +1,5 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+</Project>

examples/csharp/multi_timeframe/Program.cs

@@ -0,0 +1,44 @@
+using Wickra;
+using Wickra.Examples;
+
+// Resample a 1-minute series into higher timeframes and run an indicator per timeframe.
+var oneMinute = MarketData.SyntheticCandles(1200, startTimestamp: 0, stepMs: 60_000);
+
+Console.WriteLine("EMA(20) of close across timeframes (resampled from 1-minute bars):");
+foreach (var factor in new[] { 1, 5, 15 })
+{
+    var bars = Resample(oneMinute, factor);
+    using var ema = new Ema(20);
+    double last = 0;
+    foreach (var b in bars)
+    {
+        last = ema.Update(b.Close);
+    }
+
+    Console.WriteLine($"  {factor,2}m: {bars.Length,5} bars  EMA(20) last = {last:F4}");
+}
+
+static Bar[] Resample(Bar[] source, int factor)
+{
+    if (factor <= 1)
+    {
+        return source;
+    }
+
+    var output = new List<Bar>();
+    for (var i = 0; i < source.Length; i += factor)
+    {
+        var end = Math.Min(i + factor, source.Length);
+        double high = double.MinValue, low = double.MaxValue, volume = 0;
+        for (var j = i; j < end; j++)
+        {
+            high = Math.Max(high, source[j].High);
+            low = Math.Min(low, source[j].Low);
+            volume += source[j].Volume;
+        }
+
+        output.Add(new Bar(source[i].Open, high, low, source[end - 1].Close, volume, source[i].Timestamp));
+    }
+
+    return output.ToArray();
+}

examples/csharp/multi_timeframe/multi_timeframe.csproj

@@ -0,0 +1,5 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+</Project>

examples/csharp/parallel_assets/Program.cs

@@ -0,0 +1,47 @@
+using System.Diagnostics;
+using Wickra;
+using Wickra.Examples;
+
+// Run SMA(20) batch over a panel of assets, serial vs Parallel.For, and report the speedup.
+var assets = args.Length > 0 ? int.Parse(args[0]) : 500;
+var bars = args.Length > 1 ? int.Parse(args[1]) : 20_000;
+
+var panel = new double[assets][];
+for (var a = 0; a < assets; a++)
+{
+    panel[a] = MarketData.SyntheticPrices(bars, start: 50.0 + a * 0.1);
+}
+
+// Warm up the JIT and thread pool so the comparison is fair.
+using (var warm = new Sma(20))
+{
+    warm.Batch(panel[0]);
+}
+
+var sink = 0.0;
+var sw = Stopwatch.StartNew();
+for (var a = 0; a < assets; a++)
+{
+    using var sma = new Sma(20);
+    var result = sma.Batch(panel[a]);
+    sink += result[^1];
+}
+
+sw.Stop();
+var serialMs = sw.Elapsed.TotalMilliseconds;
+
+var lasts = new double[assets];
+sw.Restart();
+Parallel.For(0, assets, a =>
+{
+    using var sma = new Sma(20);
+    var result = sma.Batch(panel[a]);
+    lasts[a] = result[^1];
+});
+sw.Stop();
+var parallelMs = sw.Elapsed.TotalMilliseconds;
+
+Console.WriteLine($"{assets} assets x {bars} bars, SMA(20) batch:");
+Console.WriteLine($"  serial   {serialMs,8:F1} ms");
+Console.WriteLine($"  parallel {parallelMs,8:F1} ms  ({serialMs / Math.Max(parallelMs, 1e-9):F1}x speedup)");
+GC.KeepAlive(sink);

examples/csharp/parallel_assets/parallel_assets.csproj

@@ -0,0 +1,5 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+</Project>

examples/csharp/strategy_bollinger_squeeze/Program.cs

@@ -0,0 +1,46 @@
+using Wickra;
+using Wickra.Examples;
+
+// Breakout: when Bollinger bandwidth is tight (a "squeeze") and price closes above the
+// upper band, go long with an ATR(14) trailing stop.
+var bars = args.Length > 0 ? MarketData.LoadOhlcvCsv(args[0]) : MarketData.SyntheticCandles(2000);
+
+using var bollinger = new BollingerBands(20, 2.0);
+using var atr = new Atr(14);
+
+var returns = new List<double>();
+var trades = 0;
+var inPosition = false;
+var entry = 0.0;
+var stop = 0.0;
+
+foreach (var b in bars)
+{
+    var bands = bollinger.Update(b.Close);
+    var atrValue = atr.Update(b.Open, b.High, b.Low, b.Close, b.Volume, b.Timestamp);
+    if (bands is not { } band || !double.IsFinite(atrValue))
+    {
+        continue;
+    }
+
+    var bandwidth = band.Middle != 0.0 ? (band.Upper - band.Lower) / band.Middle : double.MaxValue;
+
+    if (!inPosition && bandwidth < 0.06 && b.Close > band.Upper)
+    {
+        inPosition = true;
+        entry = b.Close;
+        stop = b.Close - 2.0 * atrValue;
+        trades++;
+    }
+    else if (inPosition)
+    {
+        stop = Math.Max(stop, b.Close - 2.0 * atrValue); // trail the stop up
+        if (b.Close < stop)
+        {
+            returns.Add((b.Close - entry) / entry);
+            inPosition = false;
+        }
+    }
+}
+
+Backtest.Print("Bollinger squeeze", Backtest.Summarize(returns, trades));