- Build settings that already help: LTO, codegen-units, target-cpu, PGO
- A recipe you apply yourself
- For a slow part up to 2k lines
- Ready in minutes
The gain is measured on our machine, not guessed.
We measure your program on your job, make it faster, check that the results are the same, and name the number before you pay. Below: how it goes, what it costs, what we guarantee and what you can check yourself.
Prefer a ready faster version of a program you already use? The catalog is one click away in the menu.
Which program, how big the task is, how often you run it and how long you wait. No files needed.
We find out whether we can speed it up, then run your task both ways and compare the time and the results.
If the results are the same and the time dropped as agreed, you get the faster version. If not, you owe nothing. Price and terms are agreed before the work starts.
Design partners: 50% of your first order comes back to your balance as credit. 10 places. Get a free speed check
Which program, how big the job is, how often you run it and how long you wait. No files, no setup.
Most jobs that repeat with small changes can be sped up. If yours cannot, we tell you so.
The normal way and our way, start to finish, on the same machine, with the results compared. You see the numbers before you decide.
If the job got faster as agreed, you get the faster version: a file next to your program, or a service we run for you.
The price depends on how much time you save. If the job did not get faster, you owe nothing.
The price depends on how much time you save. We agree it before the work starts, and you pay only after the measurement shows the gain.
The gain is measured on our machine, not guessed.
The gain is measured before you pay. No gain, nothing to pay.
If the guaranteed minimum is not reached, the money goes back to your balance as the contract table says.
| Gain over the do-it-yourself version | up to 1k lines | 1k–3k lines | 3k–10k lines | over 10k lines |
|---|---|---|---|---|
| 10–25% | $290 | $490 | $890 | on request |
| 25–100% | $790 | $1,190 | $2,390 | on request |
| 100–200% | $1,190 | $1,790 | $3,590 | on request |
| over 200% | $1,990 | $2,990 | $5,990 | on request |
Speedup is how many times faster the new version is than the free build-settings version, minus one: 100% means twice as fast, 200% three times. The price table counts it in processor work (cycles): −20% at 25%, −50% at 100% and −67% at 200%. The free build-settings option covers hot code up to 2,000 lines; above that it is included in the automatic option. An additional platform: +30%. Lines are counted with llvm-cov for Rust and gcov for C and C++: only code executed by the agreed benchmark (details in the question “How are lines counted?”).
Enter how long one run takes now and how often you run it. Take the speedup from your free estimate; 5.7× is the measured ta case.
After = before ÷ speedup. Compute cost uses your core count and price per core-hour. Cash savings require usage-based billing or resources you can release. Use a factor measured for your workload.
| Plan | Per month, billed yearly | What’s included |
|---|---|---|
| Crate | $149 | Hot code up to 2k lines, up to 4 releases a month, one platform |
| Team | $399 | Up to 10k lines, up to 20 releases a month, two platforms |
| Enterprise | from $1,500 | Several projects, a service-level agreement, acceptance on your own hardware |
The subscription runs for a year; the annual fee ($1,788, $4,788 or from $18,000) is debited from your balance at the start. Every new release is optimized again and checked to give the same results. If a release could not be brought to the agreed level, you get the share of the month such releases make up, as you choose: that share of the monthly fee on your balance, or the subscription extended by that share of the month. One of four releases in a month failed: a quarter of the monthly fee, or a quarter of a month.
All payments go through the balance in the dashboard. Top it up by card through Stripe (cards, Apple Pay, Google Pay and local payment methods), by bank transfer or with a promo code; each service is debited when you order it. Unused paid funds are paid back on request; bonus funds from promo codes and bonuses pay for services.
What we sign, how we measure and what you can check yourself: the measurement record, our free checking tool, how your code is kept isolated, and a comparison with the usual options.
Before work starts we fix the measurement passport: the CPU model and frequency, the workload with hashes of the input data, the compiler and tool versions, the measurement protocol. The contract speaks only about these metrics.
Wording in the contract“On platform P, under the measurement passport protocol, the median of M1 will drop by at least X% relative to the baseline, provided M4 and M5 hold.”
Why cycles on a real CPU. A simulator gives a repeatable number, but not always the right one: it does not see the frequency drop under wide SIMD, the prefetcher or multithreading. So the contract uses real hardware, and the simulation serves for cross-checks.
Hidden inputs. Part of your data is held back until acceptance, so the speedup cannot be fitted to the benchmark. You send us this data encrypted and give the key once the binary is ready.
A free open-source command-line tool (MIT) takes the same kind of readings as our rig: user-mode cycles and instructions from the hardware counters. Send us the readings without code, and accept the work yourself.
runCycles, instructions, cache and branch misses, wall time and memory. Median, spread, 95% confidence interval and a quality grade.
:::Several builds in interleaved rounds, so drift in temperature and load affects them all alike.
compareBefore and after: the speed-up factor with its interval, as defined in our Terms, and a check that the outputs match. The exit code can gate a CI job.
showReview the bundle before you send it: no code, no output, no file contents, only hashes and machine facts. --redact hashes paths and arguments too.
$ TAKT_INPUTS=data taskset -c 44 takt-harness run --input data \ -- bin/ta-bench-base ::: bin/ta-bench-level2 machine AMD Ryzen Threadripper PRO 5975WX 32-Cores · x86-64-v3 checks pinned to CPU 44 · governor performance · SMT on protocol 9 rounds after 1 warm-up · CI: percentile bootstrap metric baseline new factor 95% CI of factor cycles:u 1.370 G 141.3 M 9.695× 9.582 – 9.927 instructions:u 3.156 G 391.7 M 8.057× 8.057 – 8.057 wall time 484.7 ms 66.90 ms 7.245× 6.983 – 7.346 stdout match · sha256 ada682c61e5e… · 973 B quality good · 9 runs, typical deviation 0.06% / 0.73% (MAD) verdict outputs identical · cycles:u speed-up factor 9.695× bundle readings.json # can be sent without source code
Shortened real output on our ta indicators example (1 million bars): the original build against the custom-engineering build. The readings bundle holds the machine facts, hashes of the programs, inputs and output, and the metrics with their spread and a quality grade.
Source code and a ready Linux binary: github.com/abx-takt/takt-harness (MIT).
Automatic builds run in throwaway virtual machines with no network. Custom work can also use a separate project workspace with checked access rights and no network during compilation and runs; connections to approved AI models are handled separately.
A separate key for every project. After 30 days, or when you press the button, the key is destroyed together with the data.
Your materials are never used in work for other clients. If custom work uses an AI model, Anthropic or OpenAI receives material only under commercial API terms and only with your separate permission for the project, which you can withdraw. Local and provider copies have different retention periods, described in the DPA.
A SHA-256 hash of every file, signed with our published key; a list of the components; the measurement report and the toolchain the build was made with.
The build makes no network calls, starts no other programs and writes no files. A script in the package shows this on your own inputs.
You can send only the slow part of the program without your business logic. The documentation explains how to cut it out.
We deliver the faster program as a ready file, with the evidence of its measurements and checks; the method remains our know-how. Source escrow is available on written request before payment through an order-specific escrow box under the escrow rider. Its platform and provisioning/handover procedure must qualify and be recorded for the order. Shadow mode needs replayable isolated state; you may test the build’s security yourself or with contractors.
| An AI agent on your own | CI benchmarking services | A consultant | TAKT | |
|---|---|---|---|---|
| Speeds up code | yes | no, catches regressions | yes | yes |
| Result known before payment | no | — | no | yes, for the automatic option |
| Guarantee in the contract | no | no | usually not | yes, on the agreed measure |
| Protection against fitting to the benchmark | up to you | — | depends on the person | hidden inputs |
| Proof of correctness for every change | no, only your tests | — | rarely | yes, with independent review |
| Own optimization methods | the model’s general knowledge | — | one person’s experience | a library of proven methods that grows with every project |
| An honest refusal when there is nothing to speed up | an agent always changes something | — | not always | yes, before payment |
| Reference hardware | yours | yes | yours | yes |
| Pricing model | tokens | per user | per hour | per result |
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Systems software from the same team: unlocking an encrypted ZFS root at boot, reshaping RAIDZ in place, a browser console for Proxmox VE and Thunderbolt hotplug in QEMU. Each card opens a short description; the code is on GitHub. Also included: conditional secret escrow in a TPM virtual machine.
A prototype for conditional secret escrow in a TPM virtual machine. Source deposits can be verified by rebuilding before release.
A measured OpenWrt boot runtime that unlocks an encrypted ZFS root with Clevis and the TPM, then boots the system through ZFSBootMenu.
A fork of OpenZFS with a prototype of in-place RAIDZ reshaping: change parity between raidz1, raidz2 and raidz3 without exporting the pool.
QSM Direct: a WebRTC graphical console for Proxmox VE virtual machines and LXC containers, hardware-encoded where the node has an encoder.
A Thunderbolt-flavoured PCIe hotplug layer for QEMU: add and remove devices in guests such as macOS that cannot hotplug them directly.
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.
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.