Tired of waiting for your program to finish? Find it here and get the faster version.
A faster version gives the same results, checked against the original, and installs in place of the one you have. Start with the free part, see the difference on your own job, then decide. Published performance figures identify the program, workload, machine and comparison method used.
Not in the catalog yet? Tell us what you run: the first check is free, and the programs people ask for most come first.
How it worksfree part first
Find the program you wait for.
The catalog below lists programs we have already made faster, with the measured numbers and what was checked.
Try the free part on your own job.
Install it in place of the original, run the same job, and compare the time and the results with our free checking tool.
Get the full version.
The catalogue checkout for consumers and businesses is in preparation. When it opens, purchases will be from the seller identified at checkout under its purchase terms and TAKT's Product Licence and Hosted Terms. The total price, including applicable VAT for your country, and delivery time will be shown before payment.
People who wait for the same calculation again and again
Every day someone runs a long calculation, changes one thing and runs it all over again: another barrier on a noise map, another load on a structure, another version of a dataset, another set of parameters. The first run is unavoidable. The next ten do not have to take as long. That is what we fix.
Simulations
Noise maps, radiation shielding, building models, structural loads, sunlight on terrain. The measured examples range from about 1.5 to 4 times faster.
Genomics and microscopy
Genome scans after a change in the reference, cleaning large 3D microscope images. Measured examples: about 6 to 7 times faster.
Model reports
Which features matter and what-if reports on tree models. Measured: 2 to 10 times faster, every number identical.
Trading and pricing
Strategy backtests, parameter searches, option pricing. Measured: 2 to 23 times faster, the same answers.
What we cannot speed up
One-off runs where nothing repeats, training neural networks on GPUs, hand-tuned codecs and cryptography. We tried; there is nothing to gain there.
Each number is how much sooner the whole job finished on our test machine, with the results checked against the original. Details are on each page.
Check it, don’t trust it
You can run our examples and compare the results yourself. Here is how.
What to check
How to check it
Speed
Run the original and the faster version on the same inputs with our free benchmark tool. It shows how much faster it got and how much the time varies between runs.
Output
Compare what the faster version produces with what your original produces, including on inputs we never saw. By default every byte must match; the only exceptions are the small NaN-payload case in the Terms and anything else written down and agreed before the work.
Delivered files
For a paid build, check the file hashes in SHA256SUMS and the signature SHA256SUMS.sig with the TAKT signing key published on Trust and delivery, not with the copy inside the package.
For the automatic option, the price is set from the time measured on our reference machine under the agreed protocol. You can also check the build on your own machine; that does not change the price unless your order says so.
Before sharing code, read Security to see how your materials are handled.
Design partners: 50% of your first order comes back to your balance as credit. 10 places. Get a free speed check
Already measured
What we have already sped up
Real programs, public data, every run timed from start to finish and every result compared with the original. Open any card to see the numbers and how to check them yourself.
Three versions · ready programs published
ADX, ATR and PSAR indicators from Python ta
Our version of the Python ta 0.11 indicator library, giving exactly the same output. A parameter sweep over one million bars: ATR, ADX and ±DI for five windows and Parabolic SAR in four configurations. All three versions are built, measured on our test machine and published; every version gives the same output to the byte, including on inputs where the program stops with an error.
5.7×faster, whole run: custom engineering vs the free build-settings version
18×vs Numba on the computation
Customengineering: a new way to compute the same result, checked against the original
The same algorithm in Numba (also the same output, bit for bit): 335 ms of computation and 201 ms of pandas.read_csv. Custom engineering: 18 ms of computation and 20 ms of CSV parsing, 81 ms for the whole program. Python ta: 20.5 s per 100k bars.
Original program · time per run (median)503 ms 1,376.9 M cycles
Build settings onlyfree · the reference463 ms1,248.6 M cycles
Automaticour automatic version342 ms1.35× faster · 791.4 M cycles
Custom engineeringa new way to compute the same result81 ms5.7× faster · 143.3 M cycles
Measured on our test machine (AMD Zen 3), 9 alternating rounds; time is the whole program, including reading the data. The automatic and custom versions are compared with the free build-settings version. The original release was measured. Here the automatic version alone gives 1.35× in time; the big gain comes from custom engineering.
Training sweep of a spiking neural network (a BindsNET model)
A reservoir of 128 leaky integrate-and-fire neurons with recurrent connections; the input weights are trained online by STDP (BindsNET PostPre). The sweep trains 24 networks over threshold, membrane time constant and learning rate on a synthetic market-like stream of 5,000 steps. The Rust program prints exactly what the BindsNET script prints, to the bit, on the main input and on 54 generated datasets.
14.2×faster, whole run: custom engineering vs the free build-settings version
395×vs the same sweep in BindsNET, one core
0 bitsof difference from BindsNET
BindsNET 0.3.3 on PyTorch (one processor core, the same core): 24.0 s for the sweep, mostly per-step Python overhead. Custom engineering: 60.9 ms on that core. Build settings alone are 6% slower than the plain build here; the automatic version is 3.90× faster than the build-settings version, custom engineering 14.2× (15.8× in processor cycles).
Original program · time per run (median)805 ms 3,525.0 M cycles
Build settings onlyfree · the reference865 ms3,742.6 M cycles
Automaticour automatic version222 ms3.90× faster · 962.4 M cycles
Custom engineeringa new way to compute the same result60.7 ms14.2× faster · 237.0 M cycles
Measured on our test machine (AMD Zen 3) in an isolated virtual machine, 9 alternating rounds; the processor block was reserved for the measurement. The automatic and custom versions are compared with the free build-settings version. The original release was measured.
Strategy optimization · vn.py · binaries published
vn.py parameter optimization: the same top 10, an order of magnitude faster
The brute-force optimizer of vn.py over 600 parameter sets of its stock moving-average strategy. Our program prints the same ten best sets with the same Sharpe ratios, returns, drawdowns and trade counts, bit for bit on AVX2 machines. It is 16–20× faster than a competent native port that computes each moving average once, and about 12,000× faster than vn.py itself, most of which comes from leaving Python. Measured on AMD Zen 3 and Zen 4.
Download · MIT · Linux x86-64full package60 KB: our program, both native ports, the vn.py driver, data generator, measurements on two platforms
what was measured
6–11×whole hyperopt run, same result file
204,132trades compared, all identical
Strategy optimization · freqtrade · measured
freqtrade hyperopt: the same result file, 6–11× faster
freqtrade’s own hyperopt on five crypto pairs and two years of 5-minute candles. With our build loaded into the same freqtrade, every epoch’s parameters, loss and metrics and every trade in the result file are identical, and the whole run is 5.9–6.7× faster over 30 epochs and 7.2–11× over 100 epochs, on AMD Zen 3 and Zen 4. Checked on 15 cases: ten strategies, four timeframes, 204,132 trades. freqtrade is GPL-3.0, so the build is not distributed: we run your hyperopt on our machines and return the same result file. The first 20 core-hours are free. After that, $0.10 per core-hour of our machine time, paid from your dashboard balance. TAKT is not affiliated with, endorsed or sanctioned by the freqtrade project.
backtrader optstrategy: the same results, 2.2–5.2× faster
backtrader’s own optstrategy grid search: the SmaCross strategy from backtrader’s documentation, 100 parameter sets, three years of hourly BTC/USDT candles. With our build loaded into the same backtrader, the result of every parameter set is identical: every analyzer’s output, every order and trade notification and the final broker state. The whole run is 4.7–5.2× faster, and 2.2–3.9× on five other workloads, on AMD Zen 3 and Zen 4. Checked on 25 cases: twelve strategies, 91,022 trades, 600,613 order notifications. backtrader is GPL-3.0, so the build is not distributed: we run your optimization on our machines and return exactly what backtrader returns. The first 20 core-hours are free. After that, $0.10 per core-hour of our machine time, paid from your dashboard balance. TAKT is not affiliated with, endorsed or sanctioned by the backtrader project or its author.
C library · swap-in replacement · ready files published
TA-Lib technical indicators: a faster drop-in library
A replacement for the TA-Lib 0.8.1 C library with the same ABI: C programs and the TA-Lib Python wrapper use it without changes, and every output matches the official library bit for bit (4.59 million calls checked). In a parameter sweep over a million bars, seven indicators (CCI, SAR, DX, ADX, EMA, STOCH, RSI) are 2.3–7.4× faster than the fastest of the official and the -march=native builds, measured on AMD Zen 3 and Zen 4. Through the unchanged Python wrapper the same sweep is 2.0–6.0× faster.
Python package · swap-in replacement · European options · free on PyPI
QuantLib Monte Carlo: faster European option pricing
The official QuantLib Python wheel with a faster Monte Carlo core; every result is identical to the official wheel, bit for bit, on the same machine. The free package (pip install quantlib-takt) accelerates European options: a book of European options prices about 5–8× faster through the unchanged API, Greeks by bumping up to 18×, measured on AMD Zen 3 and Zen 4. The commercial version adds all the other engines (Asian, American, barrier, basket, Heston, local volatility) at 2–9×, the C++ library and support. Full version: charged annually, with no automatic renewal. The total annual price and monthly equivalent, including applicable VAT for your country, are shown before you order. Sold by the merchant of record identified at checkout under its purchase terms. TAKT's Product Licence and Hosted Terms apply to use and technical delivery.
Python package · swap-in replacement · model explanations · free on PyPI
LightGBM: faster permutation importance, partial dependence and what-if
The official LightGBM Python package with a faster library inside; predictions match the official package bit for bit on the same machine. The free package (pip install lightgbm-takt), version 4.7.0.post2, accelerates repeated-call analyses on models up to 300 trees using one or several LightGBM threads: permutation importance, partial dependence and ICE, MDA and what-if sweeps, through the unchanged API. In our AMD Zen 3/4 measurements, whole-process elapsed time improved by up to 3.2× with the default thread setting, using 7/4 allocated CPUs. Other paths retain LightGBM's own code. The full version also accelerates larger models (these analyses up to 19× on one core with a 1,000-tree model), batch prediction and SHAP's permutation explainer, and adds the C/C++ library and support. Full version from $399/month, billed yearly.
DLinear with the officially trained weights on the four ETT sets, every window of the test split, against the original Rust implementation. On all cores it is 2.3–3.6× faster than PyTorch with the Inductor compiler. PatchTST: 2.2–2.5×.
Five Xiph clips picked at random before measuring: Elephants Dream, Park Joy, Johnny, Bus, Stefan. The full encoding cycle at speed 6 and 10. Every clip is faster, and the bitstreams match byte for byte.
The pure-Rust bzip2-rs crate, all 12 files of the Silesia corpus, 212 MB. Every file is faster, by 2.8× to 4.2×. On 400,000 test streams, 360,000 of them corrupted, both the data and the error messages match.
10 classesof programs measured on fixed jobs, each with its own result check
Timeof the whole job, original vs ours; each page says exactly what was timed
Measured classes: one table of all results
Trees, parameter grids, Monte Carlo greeks, neutron transport, noise maps, BIM clash, terrain solar, sequence search, structural load cases, volume morphology: how much faster, what was checked and on what, with links to the readings.
Ten scenarios of one model, measured as a complete family: shield densities, barrier heights, placement scenarios, terrain edits. The engine’s own outputs, checked against the original as stated on each page; 3.55–3.79× on OpenMC, 2.54× on noise maps, 2.23× on BIM clash detection, 2.38× on terrain irradiance.
Complete analysis calls on fixed models and inputs: 90-feature permutation importance, PDP/ICE suites, credit and insurance scenario books. The libraries’ own outputs, equal to the originals, in less elapsed time.
2.2–23×strategy grids, hyperopt and pricing workloads
5 enginesvn.py, backtrader, freqtrade, TA-Lib, QuantLib: the same requested results
Strategy and parameter grids: the same requested result, less time
Whole grids, hyperopt jobs, indicator and pricing workloads against the unchanged engine or a named reference. Each case says what was compared and how the time was taken.
5.77×sequence-search family on one frozen workload
30/30complete hit lists equal, as stated on the page
Sequence-search families: ten reference edits on Cas-OFFinder
Ten fixed-length edits of human chromosome 1, 100 guide occurrences, every reported hit kept. Ten stock searches versus a fresh base plus ten variants, measured as complete families.
2.72×structural load-case family on one frozen CalculiX study
3/3complete result files (DAT and FRD) equal, as stated on the page
Structural load-case families: ten load cases on CalculiX
Ten load cases on one fixed structural model with about half a million unknowns, run as one complete ten-step job against stock CalculiX 2.21. The solver’s own results, equal as stated on the page, in less time.
6.96×volume-morphology family on one synthetic 512³ study
30/30complete 16-bit outputs equal byte for byte
Volume-morphology families: ten local edits of a 512³ stack
Ten local edits of a 512³ 16-bit volume, each opened with a ball-shaped footprint, measured as complete families against stock SciPy, with a fresh base calculation in every research run. Every output equal byte for byte.
Test machine: AMD Threadripper PRO 5975WX (Zen 3, AVX2). Ratio of medians of real runs over the whole set: seven rounds for codecs, five repeats for models. On a single core PyTorch is still faster on these models: it reorders additions, while we keep the output identical to the original code. These are results on specific code, not a promise for yours: for your program we name numbers after measuring.
Trust
What is inside the file, and who we are
Who we are
TAKT is a product of ABX DEVELOPMENT LLP, registered in Scotland, United Kingdom, number SO301872, 39/5 Granton Crescent, Edinburgh EH5 1BN (public register entry). Questions: [email protected].
What the file does
Each product page lists the file’s runtime network access, child processes and file writes, separately from installation. Where supplied, our check script reports the behaviour observed in the cases you run; it does not certify every possible execution or your computer’s security.
The same results
You compare the output of the original and of the faster version yourself with our free checking tool. Where results are the same byte for byte, the page says so; where a program’s own output varies between runs, the page says exactly what was compared.
Signed files
Paid builds come with SHA-256 checksums signed with our published key, a list of components and the measurement report. The public packages and showcase files carry plain SHA-256 checksums today; signatures you can verify without us (Sigstore) and verified publishing on PyPI are in preparation.
Checks you can inspect
Our checking tool is open source, our measurements are mirrored on GitHub for anyone to read, and we contribute tests and benchmarks to the projects we speed up. These are things you can inspect yourself, not an external audit or endorsement. Public virus-scanner reports for each file are being added.
A path without a binary
If you would rather not run our file, we can run the job on our machines and send back the result. For organisations, the source can be placed in escrow under written terms.
14-day performance refund: if your supported workload misses the minimum agreed before purchase, request your money back. Your statutory rights are unaffected.
Then the catalog will not help, but we can: we measure your program, make it faster, and you pay only if it got faster, as agreed up front. How custom work goes
FAQ
Questions before you start
How do you do it?
We analyse the code and apply the Pareto principle as deeply as it goes: we remove computation that isn’t needed and use different computational methods, moving a significant part of the work from run time to compile time.
Why do I get a ready program and not the source code?
How we make programs faster is our know-how, so you receive a ready file, never source code: for a Rust project, a library with a header and a one-line hookup; for a C or C++ project, the executable. You check it by running it: the results must match your original, and you can verify the signature and the file hashes.
What happens when I change my code?
The delivered build is tied to the version we measured. If the slow part changes, send the new version for another measurement; keeping up with your releases is a separate subscription. For business continuity, source escrow can be requested before payment under the escrow rider.
Do I have to send you my strategy or my data?
Not for the first answer: a description is enough, and our free tool produces readings without source code. For the build we need only the code that runs in the slow loop, usually the simulator, the indicators and the portfolio state. It is covered by an NDA, is not used for other clients and is deleted together with the key.
Why not just add more cores?
Do both. Independent runs spread across cores well, and our build makes each run faster on every core. More cores do not help a single simulation that goes step by step, where each step depends on the previous one, and that is exactly where we help.
What if it does not get faster?
For the automatic option you pay only for a result that is already measured, so this cannot happen. For custom work we name a guaranteed minimum; if it is not reached, the money goes back to your balance as the contract table says, and paid funds on the balance are returned on request.
How do you count the size of the slow part?
We build your code with coverage switched on, in the agreed settings, run the agreed benchmark and count the lines of your own code that ran at least once (llvm-cov for Rust, gcov for C and C++). Libraries do not count.
Which computers does it run on?
Our public examples run on Linux x86-64 with AVX2/FMA; the TA-Lib and vn.py numbers were taken on AMD Zen 3 and Zen 4. For a paid build the CPU, the operating system and the acceptance machine are fixed in the order. Intel, ARM and other environments are assessed separately.
What cannot be sped up much?
Formats that already have highly tuned C libraries (LZ4, zstd, deflate), mature video codecs with hand-written assembly (x264, x265), cryptography such as SHA-256 and ChaCha20, and code that mostly waits for random memory accesses. We say so before you pay.
Your numbers and mine differ. Why?
Timings depend on the CPU model, frequency, turbo, memory and inputs. Contract numbers are taken on our machine under the agreed protocol. Our benchmark tool reads the same counters, so on the same CPU model and settings your numbers should be close to ours.
What about rounding and floating point?
By default the results match bit for bit. The one exception is a narrow case with NaN values, where the language itself allows different internal encodings; everything else stays exact unless you agree otherwise in writing.
Will it run on an old server?
Check the CPU requirements of each package. Our public examples may need AVX2/FMA and will not run on an older CPU. For a paid build the supported CPU features and any fallback are agreed in the order.
Will it cut the delay of my live trading?
Only if the computation is the bottleneck. For a live path we measure the whole path from the market event to the order on your server, not one function: often most of the time goes to the network and the exchange. We tell you what we found.
Do you work with C, C++ and Python?
Yes. C and C++ projects built with CMake or make go through the dashboard like Rust projects, are measured before you pay, and you receive the executable. For Python we deliver a drop-in replacement library with the same interface, so your programs keep working as before.
Get started
Tell us what you run
Describe one job: which program, how big it is, how often you run it and how long you wait. No files are needed at this step. Developers with a Rust or C/C++ project can also open the dashboard.
Not ready yet?
What stops you from trying TAKT? One click tells us what to fix.
Legal documents
The documents are in English. Catalogue purchases use the seller's purchase terms and TAKT's Product Licence. Custom business services agreed directly with ABX use separate Terms; they are not part of the catalogue checkout.