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

Current download

The tables, earlier measurement files and rebuild comparisons below document the original release. The current download has since undergone release protection. Current release checks list its SHA-256 hashes, bitwise output checks, ABI compatibility and measured performance before and after protection. This release check covers the listed inputs on the stated CPU; it does not repeat every earlier campaign.

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.