TAKT showcase: QuantLib 1.43 Monte Carlo, drop-in with bit-identical output, 2–24× faster

The numbers below are measured. The free package is on PyPI (pip install quantlib-takt); the full version is a commercial licence (see "Availability"). This directory holds the measurement scripts and every reading.

Not affiliated with QuantLib. TAKT is not affiliated with, endorsed or sanctioned by the QuantLib project or its contributors. The names QuantLib and QuantLib-SWIG are used only to identify the software we measured and build on.

QuantLib (BSD 3-clause) is a widely used C++ library for quantitative finance, with Python bindings on PyPI (the QuantLib package, ~1M downloads/month). Its Monte Carlo engines price options by simulating many price paths.

TAKT builds QuantLib 1.43 so that its Monte Carlo pricing runs several times faster, with every result identical to the official build, bit for bit on the same machine. The Python bindings and the public API are unchanged (import QuantLib); only the C++ library is replaced.

Headline

Factors are over the official QuantLib 1.43 build, by user-mode cycles:u, 95% bootstrap CIs, measured on two machines. The output was identical in every single run.

Free package vs full version

In the free package, everything other than European Monte Carlo runs the original QuantLib code and returns the original result at the original speed. The full version accelerates all of it, with the same bit-identical output.

What was measured

One C++ driver (tools/qlmc.cpp), built against the official QuantLib 1.43 headers, runs with the library swapped: official (the library in the official PyPI wheel) versus TAKT. A Python driver (tools/qlmc.py) runs the same workloads through the wheel: the official wheel versus the TAKT wheel. Both drivers print every result to full precision (17 significant digits and the hex float), so a byte compare of their output is a bit compare. The Python driver's output is byte-identical to the C++ driver's.

Workloads (fixed seeds):

Stands. AMD Threadripper PRO 5975WX (Zen 3), Ubuntu 24.04; AMD Ryzen 9 7950X3D (Zen 4), Debian 13. Both with the performance governor, each run pinned to one core, takt-harness 0.2.1, 9 interleaved rounds after one warm-up, user-mode cycles:u and whole-process wall time, 95% bootstrap CIs. The harness compared stdout across the builds in every run. Raw readings: results/zen3/ and results/zen4/.

C++ — AMD Zen 3

C++ — AMD Zen 4

Python, end to end and in a running interpreter — AMD Zen 3

End to end times the whole process (interpreter start, import QuantLib, building the market, pricing). "Running interpreter" repeats the workload five times in one process (the market built once).

End to end

Running interpreter

Python — AMD Zen 4

End to end

Running interpreter

Equivalence

"Same" means byte-identical printed output, every number at 17 significant digits and as a hex float.

• C++ matrix: 867 printed results — six market setups (flat and non-flat curves, several day counters and calendars, zero and spreaded curves, a volatility surface), every Monte Carlo engine with its variants (time steps, antithetic, seeds, control variates, Brownian bridge, pseudo-random and Sobol), Greeks by bumping, notification edge cases, direct path use, the Black process family, Heston in all schemes, Bates, baskets, and non-Monte-Carlo engines (analytic, trees, finite differences). Identical between the official and the TAKT build.
• Python: 270 results plus every workload, identical between the official wheel and the TAKT wheel, verified with Python 3.12 on glibc 2.28 and 2.39, Python 3.13, and free-threaded Python 3.14t (GIL off), including a four-thread run.
• QuantLib's own test suites: the C++ test suite (1,339 cases) passes with the TAKT library, with reports identical to the official library; the QuantLib-SWIG Python test suite gives 211 passed, 1 skipped.

Bit-identity is per system. QuantLib's results come from the system's maths library, so the official build itself prints slightly different last bits on different glibc versions (205 of the 867 values differ between glibc 2.28 and 2.39, by at most 1.5e-6 relative). The TAKT build reproduces the official build's output on the same system, bit for bit.

Where the speed-up applies, and where it does not

• Accelerated: Monte Carlo on the Black–Scholes process family (any yield/dividend curves, constant or term-structure volatility), on Heston and Bates, and on local-volatility surfaces; and paths drawn with QuantLib's path generators. In the free package, only the European part of this is accelerated.
• Runs the original code at the original speed, with the original result: process classes a user derives in C++, a few uncommon ways of wiring term structures and threads, and every non-Monte-Carlo engine (LIBOR market models, finite differences, trees, analytic engines).
• Two call patterns that QuantLib's own engines never produce were measured directly: they run at 0.90–1.00× (Zen 3 and Zen 4) with identical output. Licence customers get the details.

Availability

• Free: pip install quantlib-takt (after pip uninstall -y QuantLib). European Monte Carlo accelerated; everything else is the original code. Linux x86-64, Python 3.9–3.13.
• Full version: a commercial licence adds all the engines above, the C++ library (.so/.a, a drop-in with the same ABI), the free-threaded wheel, builds for other platforms and QuantLib versions, support, and source escrow (the modified source in an encrypted escrow box, released to you on the conditions of our Terms of Service).
• Prices:
• Team, $399 a month billed yearly ($4,788): all engines, the C++ library and the free-threaded wheel on one platform, with every new QuantLib release rebuilt and checked bit for bit again.
• Enterprise, from $1,500 a month billed yearly: other platforms and QuantLib versions, an SLA, source escrow and acceptance on your own hardware.
• A licence, a quote, or a free speed check of your own code: https://taktcycles.com/?src=showcase-quantlib#start

Reproducing the baseline

# C++: build the driver against the official QuantLib 1.43 headers, run it against each library.
g++ -std=c++17 -O3 tools/qlmc.cpp -o qlmc -lQuantLib         # with QuantLib 1.43 installed
LD_LIBRARY_PATH=/path/to/official/lib ./qlmc equiv > official.txt   # the PyPI wheel's library

# Python: price the same workloads through the official wheel and through quantlib-takt, compare bytes.
python -m venv a && a/bin/pip install -q QuantLib==1.43  && a/bin/python tools/qlmc.py eu_book_curve > a.txt
python -m venv c && c/bin/pip install -q quantlib-takt    && c/bin/python tools/qlmc.py eu_book_curve > c.txt
diff a.txt c.txt && echo identical

tools/vsbest.py and tools/table.py print the factor tables above from the readings in results/.

Contents

• tools/: the C++ and Python workload drivers (qlmc.cpp, qlmc.py, qlmc_steady.py) and the scripts that turn the readings into the tables (vsbest.py, table.py).
• results/zen3/, results/zen4/: takt-harness readings (.json) and summaries (.log) for every workload, C++ and Python.