Skip to content

Performance status

The goal is Rust-class speed and control. Every current qualification is incomplete.

Turbo compiles to native code today, but native code is not the same as a blanket Rust-performance claim. This page tracks the committed evidence, the eight diagnostic categories still being qualified, and the concrete gates Turbo must pass before stronger claims are earned.

Committed baseline

Committed diagnostics recorded on 2026-09-06. The statistical baseline is benchmarks/results/g2-initial-20260906; tree and particle allocation profiles are separate committed diagnostics. None of these qualify Rust parity.

Roadmap →
CaseCategoryTurboRustPaired ratio95% interval
Recursive fib(40)
Pure recursion/function-call diagnostic; misses the current target.
CPU233.31 ms161.09 ms1.444×1.4325–1.4618
Existing 5 MiB word count
Output-equivalent application case; implementation shapes are not identical.
Application88.62 ms22.64 ms3.871×3.7976–3.9549
Recursive tree diagnostic
One-pair smoke plus allocation profile; tracked ARC allocations/frees balanced with zero tracked live allocations at return.
Diagnostic507.60 ms385.34 ms1.317×not statistical
Particle allocation diagnostic
10,000 particles × 512 steps; 5,130,018 tracked allocations/frees and zero tracked live allocations at return.
Diagnosticprofile onlynot comparatornot speed claimnot statistical

Measurement method

  • Evaluator revision 75f27e5e293c7c7f89e64ca06621287ab24600b3.
  • Apple M5 Max / macOS 26.5.1; additional macOS ARM64 and Linux x86_64 gates are required before broad claims.
  • Three batches, three warmup pairs per case per batch, 20 measured pairs per case per batch.
  • Randomized execution order with paired ratio estimation and 2000 hierarchical bootstrap draws.
  • Every measured runtime output matched an independent oracle with empty stderr.
  • Peak RSS is reported separately from allocation, live-payload, and RC counters.

Known blockers

  • All current qualification is incomplete: this is diagnostic evidence, not a Rust-parity release gate.
  • Samples below 200ms are still flagged; some workloads need in-program batching.
  • The fixed evaluator catalog has eight required diagnostic categories: recursive compute, word count/text processing, JSON parse/transform, string/token processing, hashmap churn, buffer scan, packed particle update, and tree traversal.
  • Word count proves output equivalence, not identical implementation shape, so it is excluded from CPU geometric mean claims.
  • Controlled Turbo is a future target, not profiled current evidence; borrowed views, owned buffers, regions, and noalloc kernels do not exist as accepted controlled-language features yet.
  • Allocation and RC instrumentation covers targeted shared-header ARC fixtures, not the whole process heap.
  • Windows and Linux ARM64 are separate validation surfaces until proven by their own runs.

Public performance targets

These targets guide compiler/runtime work. They are public because Turbo's market only makes sense if users can trust when a claim has actually been earned. Controlled-code targets are included as goals, not current profiled results.

Managed CPU mean

≤1.15× Rust

Readable default Turbo code.

Controlled CPU mean

≤1.05× Rust

Code using explicit lower-level controls.

Individual CPU cases

≤1.35× / ≤1.15×

Managed / controlled upper bounds.

Live payload memory

≤1.25× / ≤1.10×

Managed / controlled memory workloads.

Controlled no-allocation

0 after warmup

Exact allocation and RC counters, not RSS inference.

What Turbo can honestly say today

Turbo has native execution, a friendly syntax surface, and early evidence that simple CPU code can get within striking distance of Rust. It also has clear gaps in strings, hashmaps, JSON equivalence, memory attribution, service primitives, controlled memory features, and cross-platform proof.

That is a good release posture: useful now for the strongest fit cases, transparent about the gaps, and pointed at specific work that can turn the original “TypeScript feel, Rust-class control” concept into something measurable.