EN
Sign in Free assessment
For your own program

Your program is slow, and it is yours? We make it faster, and you pay only for a measured result.

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.

How it works first check is free
  1. Tell us what you run.

    Which program, how big the task is, how often you run it and how long you wait. No files needed.

  2. We check it for free.

    We find out whether we can speed it up, then run your task both ways and compare the time and the results.

  3. You pay only if it got faster, as agreed up front.

    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.

How it works, step by step ↓

Design partners: 50% of your first order comes back to your balance as credit. 10 places. Get a free speed check

How it works

From a slow job to a faster one, in five steps

You tell us what you run.

Which program, how big the job is, how often you run it and how long you wait. No files, no setup.

We check whether it will work.

Most jobs that repeat with small changes can be sped up. If yours cannot, we tell you so.

We measure your job both ways.

The normal way and our way, start to finish, on the same machine, with the results compared. You see the numbers before you decide.

You choose.

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.

You pay only for what you got.

The price depends on how much time you save. If the job did not get faster, you owe nothing.

Pricing

You see the result before you pay

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.

Do it yourself
$0
  • 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.

Custom engineering
quoted 30% upfront
  • First we change how the computation is organised, then the data layout and the rest
  • From a couple of hours to a couple of days
  • The rest after the agreed result is confirmed

If the guaranteed minimum is not reached, the money goes back to your balance as the contract table says.

Automatic option prices

Gain over the do-it-yourself versionup to 1k lines1k–3k lines3k–10k linesover 10k lines
10–25%$290$490$890on request
25–100%$790$1,190$2,390on request
100–200%$1,190$1,790$3,590on request
over 200%$1,990$2,990$5,990on 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?”).

What it saves you

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.

Before

Time per month—
Compute cost per month—

After

Time per month—
Compute cost per month—

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.

Subscription: the gain survives your new releases

PlanPer month, billed yearlyWhat’s included
Crate$149Hot code up to 2k lines, up to 4 releases a month, one platform
Team$399Up to 10k lines, up to 20 releases a month, two platforms
Enterprisefrom $1,500Several 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.

For those who want the details

The evidence

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.

Guarantee

Agree how success will be measured

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.

M1Cycles on a real CPUThe PMU counter on the reference rig at a fixed frequency, baseline and new version interleaved. This is the promise.
M2Deterministic cycles and instructionsSimulation of a pinned version. The same number for us and for you, for cross-checks and CI.
M3Time p50 / p99For latency-sensitive work the promise can be given on p99.
M4Peak memoryConstraint: no worse than the baseline by more than an agreed percentage.
M5CorrectnessDifferential tests and fuzzing, including on hidden inputs the optimizer has never seen.
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.

Free checking tool

Compare the builds yourself

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.

run

Cycles, 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.

compare

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

show

Review 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).

Security

Your code runs in isolation, without network access

Isolation

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.

Encryption and deletion

A separate key for every project. After 30 days, or when you press the button, the key is destroyed together with the data.

Your code stays yours

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.

Signed package

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.

Verifiable cleanliness

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.

Only the hot module

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.

How delivery works and what you can check yourself

Comparison

Compare your options

An AI agent on your ownCI benchmarking servicesA consultantTAKT
Speeds up codeyesno, catches regressionsyesyes
Result known before paymentno—noyes, for the automatic option
Guarantee in the contractnonousually notyes, on the agreed measure
Protection against fitting to the benchmarkup to you—depends on the personhidden inputs
Proof of correctness for every changeno, only your tests—rarelyyes, with independent review
Own optimization methodsthe model’s general knowledge—one person’s experiencea library of proven methods that grows with every project
An honest refusal when there is nothing to speed upan agent always changes something—not alwaysyes, before payment
Reference hardwareyoursyesyoursyes
Pricing modeltokensper userper hourper result
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.

Beyond TAKT

Our other projects

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.

escrow-box

A prototype for conditional secret escrow in a TPM virtual machine. Source deposits can be verified by rebuilding before release.

  • TPM 2.0
  • UKI
  • Clevis

zbm-openwrt-clevis

A measured OpenWrt boot runtime that unlocks an encrypted ZFS root with Clevis and the TPM, then boots the system through ZFSBootMenu.

  • OpenWrt
  • ZFS
  • TPM 2.0
  • Clevis

zfs

A fork of OpenZFS with a prototype of in-place RAIDZ reshaping: change parity between raidz1, raidz2 and raidz3 without exporting the pool.

  • OpenZFS
  • RAIDZ
  • C

qsm-rd

QSM Direct: a WebRTC graphical console for Proxmox VE virtual machines and LXC containers, hardware-encoded where the node has an encoder.

  • Proxmox VE
  • WebRTC
  • LXC

qemu-thunderbolt

A Thunderbolt-flavoured PCIe hotplug layer for QEMU: add and remove devices in guests such as macOS that cannot hotplug them directly.

  • QEMU
  • Thunderbolt
  • PCIe
  • macOS
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.