TAKT showcase: TA-Lib 0.8.1, drop-in library with bit-identical output

lib/ holds a replacement for the TA-Lib 0.8.1 C library (libta-lib.so.1.1.0 and libta-lib.a). It exports exactly the same C ABI as the official release: the same 2,331 exported functions under the same names and SONAME. C programs and the TA-Lib Python wrapper use it unchanged. Every output array, outBegIdx and outNBElement are identical bit for bit to the official library's.

Seven indicators run at least 2× faster than the faster of two baselines, measured on a 1M-bar series: EMA, RSI, ADX, DX, SAR (parabolic SAR), STOCH and CCI. Three more (ATR, MACD and BBANDS) are faster but by less than 2×. All other TA-Lib functions run the original code.

What was measured

There are three builds of the same benchmark driver (tools/talib_bench.c). Each is statically linked against one library:

All three drivers print the same output. Every factor below is taken over the faster baseline, and conservatively over both baselines: for each metric, the smaller of the two factors is shown.

The driver generates a synthetic OHLCV random walk of 1,000,000 bars from a fixed seed. It runs one of two workloads and prints a 128-bit checksum of every output value, plus outBegIdx and outNBElement:

• sweep: 99 calls of one indicator over a parameter grid, as a backtest optimiser does. The grid is periods 2..100. For MACD it is 99 (fast, slow) pairs with signal 9. For SAR it is 33 accelerations × 3 maxima.
• single: one call of one indicator with TA-Lib's default parameters on the same series (BBANDS uses period 5; its default is 20). The call is repeated 30–300 times so that a run lasts 0.2–2 s.

The stand is an AMD Threadripper PRO 5975WX (Zen 3) with the performance governor. Runs were pinned to one core with taskset -c 38. The tool was takt-harness 0.2.1, with 11 interleaved rounds after one warm-up and the median taken. It counts user-mode cycles:u and instructions:u and measures the wall time of the whole process, including data generation. The 95% CIs are bootstrap intervals of the factor. The harness checked that stdout is identical across the three builds in every run. The raw readings are in results/*.json.

Sweep (99 calls, 1M bars)

Single calls (default parameters, 1M bars, repeated)

Build tuning alone (tuned over official) gives 0.93–1.17× on these workloads, so almost all of the gain is outside what compiler flags provide.

End to end through the Python wrapper

This is the same sweep run through talib.<FUNC> from the TA-Lib Python wrapper 0.8.1, numpy 2.5, with the wrapper unchanged. Only the shared library changes between runs (LD_LIBRARY_PATH). The process time includes the interpreter, numpy import, data generation and the wrapper's per-call work (it allocates and fills a new output array on every call). The sweep folds a fixed sample of every result (every 997th value and the last) into its printed digest, as a client's code reads its results; bit-exactness through the wrapper is checked in full separately (see Equivalence).

Seven indicators are about 2× or more faster end to end from Python (RSI's interval reaches down to 1.97×); the code around the calls in a client's own program is not accelerated.

Second platform: AMD Ryzen 9 7950X3D (Zen 4)

The same binaries, unchanged, were measured on a second machine: an AMD Ryzen 9 7950X3D (Zen 4, AVX-512, 3D V-Cache), Debian 13, pinned to one core of the V-Cache CCD, with user-mode counters, 11 interleaved rounds. A third baseline was added: TA-Lib 0.8.1 rebuilt on that machine with -O3 -march=native and LTO (AVX-512). Each factor is over the fastest of the three baselines for that metric. The EMA sweep was re-run with 21 rounds because a frequency drop on the shared host doubled the wall time of all builds in the first rounds (cycles were unaffected). Readings are in results/zen4/.

The gains carry over to Zen 4 and are slightly higher on most indicators. Building TA-Lib for Zen 4 with AVX-512 does not change the picture: on the EMA sweep it is even slower than the official build.

Equivalence

• C API: 4,585,536 calls, 0 differing (bin/talib-exact, summary in results/exactness.txt). The tool loads two shared libraries side by side and compares the return code, outBegIdx, outNBElement and every output buffer bit for bit, including a guard area past the last output. It covers EMA, RSI, ATR, ADX, DX, ADXR, MACD, SAR, BBANDS, STOCH, CCI and MA(EMA), with this grid:
• 9 series shapes: random walk, constant, alternating, steps, volatile, two-decimal prices, and random walk with injected NaN, ±Inf and zeros;
• 5 magnitudes: 1, 1e−6, 1e9, 1e−300 and 1e300;
• lengths from 1 to 1,000,000 bars;
• 20 periods from 1 to 5,000;
• 8 startIdx/endIdx variants;
• unstable period 0 (the default), 7 and 50.

The calls split as follows: - 2,896,200 against the official release library; - 1,345,176 against the tuned build; - 344,160 long-series calls against the official library, made with a build of the same code that counts calls. 116,392 of them took the faster code path. - Through the Python wrapper: 40,824 talib.<FUNC> calls with each of the three libraries, all identical (tools/py_exact.py). That is 12 functions × 6 seeds × 5 shapes × lengths up to 1M × 3 magnitudes × 9 periods. - Measured runs: the stdout of every run in results/ is identical across the three builds; expected_stdout.txt holds the reference checksums.

TA-Lib 0.8.1 makes TA_SetCompatibility a no-op. The unstable-period setting is honoured exactly as in the original.

Where the gain applies

• The gains are measured on 1M-bar series. Below a few thousand output bars, and for long periods below proportionally longer series (up to about 500,000 bars for ADX at period 100), calls run the original TA-Lib code at its original speed.
• The faster paths also stay out of the way in these cases, which run the original code with the original result:
• inputs that contain NaN or ±Inf (such a call may take up to about twice its original time);
• input and output buffers that overlap (in-place calls);
• STOCH with a moving-average type other than SMA;
• BBANDS with an MA type other than SMA.
• The faster paths need an x86-64 CPU with AVX2 and FMA, which means Intel Haswell or AMD Zen and newer. The CPU is detected at run time; on other CPUs the library runs the original code.
• Linux x86-64, glibc.

Reproducing

# C workloads: the three drivers, interleaved, on one core (about 15 minutes)
TAKT_HARNESS=/path/to/takt-harness tools/run_c.sh results-local 38 11
TAKT_HARNESS=/path/to/takt-harness python3 tools/split_compare.py results-local/sweep-EMA.json

# One run by hand
bin/talib-bench-takt sweep EMA          # prints "sweep EMA calls=99 hash=…"
bin/talib-bench-official sweep EMA      # same line, slower
diff <(bin/talib-bench-takt sweep all; bin/talib-bench-takt single all) expected_stdout.txt

# Bit-exactness of the libraries (any shared library pair; official .so from the release .deb)
bin/talib-exact /path/to/official/libta-lib.so.1.1.0 lib/libta-lib.so.1.1.0 EMA 1

# Python wrapper: pip install TA-Lib==0.8.1 against TA-Lib 0.8.1 headers, then
LD_LIBRARY_PATH=lib python3 tools/py_exact.py > takt.txt
LD_LIBRARY_PATH=/path/to/official/lib python3 tools/py_exact.py > official.txt
cmp takt.txt official.txt

tools/run_py.sh runs the Python end-to-end measurement. It expects libs/{official,tuned,takt}/ next to tools/, each holding a libta-lib.so.1.

Contents

• lib/: libta-lib.so.1.1.0 (with the libta-lib.so.1 and libta-lib.so links), libta-lib.a and pkgconfig/ta-lib.pc;
• include/ta-lib/: the original TA-Lib 0.8.1 headers, unchanged;
• bin/: the three measured benchmark drivers and talib-exact, the bit-exactness comparison tool;
• tools/: sources of the driver and the test tools, the Python scripts and the measurement scripts;
• results/: takt-harness readings (sweep-*, single-*, py-*), measurements.json and exactness.txt;
• expected_stdout.txt, SHA256SUMS, LICENSE.

Licence

TA-Lib is © 1999–2026 Mario Fortier and distributed under the BSD 3-clause licence (LICENSE). This library is a modified build of TA-Lib 0.8.1, distributed under the same licence. The Python wrapper (TA-Lib 0.8.1, BSD 2-clause) is not included. The source of the modified functions is not published: we deliver builds.