EN
Sign in Free assessment
Faster versions of programs you already use

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 works free part first
  1. Find the program you wait for.

    The catalog below lists programs we have already made faster, with the measured numbers and what was checked.

  2. 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.

  3. 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.

What is inside the file, and who we are ↓
Who it is for

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.

What you runHow much fasterDetails
Noise maps: trying different barriers2.4–2.5×NoiseModelling 5.0.1
Radiation shielding: trying different materials3.6–3.8×OpenMC 0.15.3
Building models: checking clashes after moving parts2.2×IfcClash 0.8.4
Structures: many loads on one model2.7× (1.5× on one real model)CalculiX 2.21
Sunlight on terrain after editing the map2.4×GRASS GIS 8.4.2 r.sun
Genome scans after a change in the reference5.8–6.1×Cas-OFFinder 2.4.1, chr1 and chr2
Cleaning large 3D microscope images7.0×SciPy 1.15.3 grey_opening
Reports on tree models: which features matter, what-if1.9–10×XGBoost, LightGBM, CatBoost, scikit-learn
Backtests, parameter searches, option pricing2.2–23×vn.py, backtrader, freqtrade, TA-Lib, QuantLib

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 checkHow to check it
SpeedRun 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.
OutputCompare 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 filesFor 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 reference 463 ms1,248.6 M cycles
Automaticour automatic version 342 ms1.35× faster · 791.4 M cycles
Custom engineeringa new way to compute the same result 81 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.
Download · MIT · Linux x86-64 full package1 MB: all versions, original source, data generator, measurements original build settings automatic custom how to verify SHA256SUMS
Three versions · ready programs published

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 reference 865 ms3,742.6 M cycles
Automaticour automatic version 222 ms3.90× faster · 962.4 M cycles
Custom engineeringa new way to compute the same result 60.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.
Download · MIT · Linux x86-64 full package0.8 MB: all versions, original source, BindsNET script, data generator, measurements original build settings automatic custom how to verify SHA256SUMS
16–20×vs a competent native port
≈12,000×vs vn.py’s own optimizer
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-64 full 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.

Measurements · no binary what was measured readings and scripts23 KB: configs, run scripts, result digests, takt-harness readings on two platforms
2.2–5.2×whole optimization run, same results
91,022trades compared, all identical
Strategy optimization · backtrader · measured

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.

Measurements · no binary what was measured readings and scripts87 KB: strategies, run scripts, result digests, takt-harness readings on two platforms
2.3–7.4×seven indicators, C
2.0–6.0×from Python, unchanged
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.

Download · BSD-3 · Linux x86-64 full package3.2 MB: the library, benchmark drivers, the bit-exactness checker, measurements on two platforms what was measured pip install ta-lib-takt
5–18×European MC, free, Python
2–24×all engines, full version
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.

pip · free · Linux x86-64 pip install quantlib-takt showcase packagethe workload drivers, the measurement scripts and every reading on two platforms what was measured
up to 3.2×free analyses, default threads
up to 19×full analyses, one core
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.

pip · free · Linux x86-64 pip install lightgbm-takt showcase packagethe workload scripts, the measurement scripts and every reading on two platforms what was measured
5.6–5.9×vs the original Rust
2.3–3.6×vs PyTorch + Inductor on all cores

Time-series forecasting in Rust

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×.

1.29–1.36×

rav1e 0.8: AV1 encoding

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.

Download · BSD-2 · Linux x86-64 full package original TAKT how to verify SHA256SUMS
3.4×vs the original Rust
4.0×vs libbz2 in C

bzip2 decompression

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.

Download · MIT · Linux x86-64 full package original TAKT how to verify SHA256SUMS
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.

Readings · CC BY 4.0 All classes, checks and links
2.2–3.8×scenario families on simulation engines
✓every output checked against the original, as stated on each page

Scenario families: OpenMC, NoiseModelling, IfcClash, GRASS r.sun

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.

Readings · CC BY 4.0 How it was run and how to check
1.9–10×tree-model analysis calls on fixed models
7 cardsXGBoost, scikit-learn, CatBoost: outputs equal to the originals

Tree-model reports: permutation importance, PDP/ICE, scenario books

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.

Readings · CC BY 4.0 Cases, originals and conditions
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.

How delivery works and what you can check yourself

Your own program

Is the slow program your own?

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.

Company and technical details (optional)
No files are needed at this step. By sending the request you agree to the processing of your contact details.
Not ready yet?

What stops you from trying TAKT? One click tells us what to fix.