Skip to content

Results and methodology

These reports provide the full measurements behind the Performance page. All benchmarks were measured with Knitting 0.1.77.

The M3 Ultra tests use macOS arm64. Each report names its runtime and gives average, minimum, p75, p99 and maximum elapsed time. The performance charts use the averages.

A count of 100 means 100 calls in flight, and the reported time is for the whole batch. Dividing by 100 gives amortized time per call, useful for comparing throughput. It does not tell you how long an individual call waits.

The empty-call and payload tests use one worker. The prime search uses the main thread and the listed number of workers; its timings include returning the results to the main thread.

Charts use the Markdown reports below. The separate JSON exports contain different runs.

Node.js 24.12.0 (arm64-darwin).

node_latency.md
clk: ~3.74 GHz
cpu: Apple M3 Ultra
runtime: node 24.12.0 (arm64-darwin)
| • knitting | avg | min | p75 | p99 | max |
| ----------------- | ---------------- | ----------- | ----------- | ----------- | ----------- |
| 1 thread → (1) | ` 1.24 µs/iter` | `333.00 ns` | ` 1.63 µs` | ` 2.38 µs` | ` 1.39 ms` |
| 1 thread → (10) | ` 3.07 µs/iter` | ` 2.00 µs` | ` 3.50 µs` | ` 4.03 µs` | ` 4.04 µs` |
| 1 thread → (100) | ` 26.99 µs/iter` | ` 14.46 µs` | ` 34.29 µs` | ` 61.63 µs` | `202.00 µs` |
| 1 thread → (1000) | `284.65 µs/iter` | `162.88 µs` | `376.33 µs` | `521.42 µs` | `618.58 µs` |
| • worker | avg | min | p75 | p99 | max |
| ----------------- | ---------------- | ----------- | ----------- | ----------- | ----------- |
| 1 thread → (1) | ` 11.01 µs/iter` | ` 10.92 µs` | ` 11.04 µs` | ` 11.18 µs` | ` 11.18 µs` |
| 1 thread → (10) | ` 24.05 µs/iter` | ` 23.32 µs` | ` 24.27 µs` | ` 24.56 µs` | ` 24.80 µs` |
| 1 thread → (100) | `158.03 µs/iter` | `114.67 µs` | `162.08 µs` | `310.79 µs` | ` 3.60 ms` |
| 1 thread → (1000) | ` 1.33 ms/iter` | ` 1.14 ms` | ` 1.38 ms` | ` 3.42 ms` | ` 3.79 ms` |

Deno 2.6.6 (aarch64-apple-darwin).

deno_latency.md
clk: ~3.63 GHz
cpu: Apple M3 Ultra
runtime: deno 2.6.6 (aarch64-apple-darwin)
| • knitting | avg | min | p75 | p99 | max |
| ----------------- | ---------------- | ----------- | ----------- | ----------- | ----------- |
| 1 thread → (1) | ` 4.99 µs/iter` | `416.00 ns` | ` 4.71 µs` | ` 20.67 µs` | `142.83 µs` |
| 1 thread → (10) | ` 2.92 µs/iter` | ` 2.08 µs` | ` 3.30 µs` | ` 3.85 µs` | ` 3.88 µs` |
| 1 thread → (100) | ` 25.28 µs/iter` | ` 14.00 µs` | ` 32.71 µs` | ` 59.54 µs` | `215.58 µs` |
| 1 thread → (1000) | `274.10 µs/iter` | `153.38 µs` | `363.25 µs` | `501.08 µs` | `701.04 µs` |
| • worker | avg | min | p75 | p99 | max |
| ----------------- | ---------------- | ----------- | ----------- | ----------- | ----------- |
| 1 thread → (1) | ` 21.57 µs/iter` | ` 13.50 µs` | ` 21.96 µs` | ` 65.63 µs` | `388.63 µs` |
| 1 thread → (10) | ` 80.69 µs/iter` | ` 53.58 µs` | ` 81.50 µs` | `173.04 µs` | ` 1.63 ms` |
| 1 thread → (100) | `656.91 µs/iter` | `544.04 µs` | `697.83 µs` | `863.25 µs` | ` 2.31 ms` |
| 1 thread → (1000) | ` 6.50 ms/iter` | ` 6.05 ms` | ` 6.61 ms` | ` 7.19 ms` | ` 7.30 ms` |

Bun 1.3.6 (arm64-darwin).

bun_latency.md
clk: ~3.65 GHz
cpu: Apple M3 Ultra
runtime: bun 1.3.6 (arm64-darwin)
| • knitting | avg | min | p75 | p99 | max |
| ----------------- | ---------------- | ----------- | ----------- | ----------- | ----------- |
| 1 thread → (1) | ` 2.49 µs/iter` | `417.00 ns` | ` 2.79 µs` | ` 8.92 µs` | `394.63 µs` |
| 1 thread → (10) | ` 3.59 µs/iter` | ` 2.23 µs` | ` 4.29 µs` | ` 5.07 µs` | ` 5.26 µs` |
| 1 thread → (100) | ` 30.24 µs/iter` | ` 24.25 µs` | ` 32.29 µs` | ` 32.54 µs` | ` 34.28 µs` |
| 1 thread → (1000) | `330.86 µs/iter` | `172.04 µs` | `546.96 µs` | `818.58 µs` | `883.29 µs` |
| • worker | avg | min | p75 | p99 | max |
| ----------------- | ---------------- | ----------- | ----------- | ----------- | ----------- |
| 1 thread → (1) | ` 10.86 µs/iter` | ` 5.79 µs` | ` 11.04 µs` | ` 33.38 µs` | `331.83 µs` |
| 1 thread → (10) | ` 24.71 µs/iter` | ` 23.95 µs` | ` 24.94 µs` | ` 25.18 µs` | ` 25.33 µs` |
| 1 thread → (100) | `190.51 µs/iter` | `118.42 µs` | `205.17 µs` | `678.42 µs` | ` 1.35 ms` |
| 1 thread → (1000) | ` 1.64 ms/iter` | ` 1.33 ms` | ` 1.75 ms` | ` 2.40 ms` | ` 2.71 ms` |

The knit-tex benchmark typesets Pride and Prejudice (2,118 paragraph tasks, 216 pages) with either the main thread or a Knitting pool. The Intel Core i5-1135G7 has four physical cores and eight logical CPUs; the reports use Node 24.19.0 and Bun 1.4.0 with Knitting 0.1.77. Each warm result is the median of five runs on a reused executor. The source reports include cold runs, CPU time, timer gaps, and output-hash checks:

RuntimeMain thread, warmFour workers, warmSpeedupCPU time, main → workers
Node 24.19.0427 ms229 ms1.86×509 → 871 ms
Bun 1.4.0449 ms254 ms1.77×607 → 1,266 ms

Four workers were faster after warm-up but used more CPU time. Cold and fresh-process runs were slower. The reports contain medians from one machine. In a separate batch of 2,115 paragraph tasks, four-worker work stealing finished 9.7–23.3% sooner on Node.js across three seeds. Bun ranged from 5.5% slower to 17.5% faster. Timer gaps in these reports measure event-loop responsiveness; they do not measure HTTP latency. See the Node report, Bun report, and project README for methodology and additional comparisons.

With 100 number calls in flight, amortized time per call is 0.81 µs on Node.js, 0.86 µs on Deno, 0.72 µs on Bun. Each figure is the median across runs of the average batch time divided by 100.

Knitting
0.1.77
Machine
Intel Xeon Platinum 8168 @ 2.70GHz, 8 threads
Runtimes
Node.js 24.19.0, Deno 2.7.4, Bun 1.4.0
Source runs
12 September 2026, 3 runs
Source details

1789245992919, 1789246042357, 1789246092383

Bench commit bcd182e with uncommitted changes. Original run versions: 0.1.70.

The Payload types page has the full chart and table.

In the Hono report, fifteen idle workers used 0.164 cores, compared with 6.368 under the earlier spin policy on the same hardware.

The IPC reports above compare Knitting with worker messaging, loopback WebSocket and HTTP round trips. Across those runs, Knitting was 4.0–12.1× faster than WebSocket and 10.5–61.9× faster than HTTP. These comparisons measure local round-trip overhead.

The M3 Ultra payload-growth tests send 64 calls per batch, each carrying 1 MiB. The rates below divide 64 MiB by average batch time. They count request bytes only, although the timing includes the reply:

RuntimeString (GB/s)Uint8Array (GB/s)
Node.js1.447.50
Deno3.375.78
Bun11.8616.21

The saved reports include the batch times. These rates include worker coordination, encoding and decoding as well as copying.

The Tokio comparison uses an AMD Ryzen 7 4700U running Ubuntu 23.10 x86_64. It includes every binary payload size, the scalar tests and a separate shared-ownership reference. Its raw report records source filenames and methodology, but omits runtime versions.

The M3 Ultra harness lives under bench/ in mimiMonads/knitting: bench/latency.ts for empty calls and bench/withload.ts for primes. Run the driver from the repository root:

Terminal window
./run.sh

Use Knitting 0.1.77 to match these results. Reports go to results/; ./run.sh --json emits JSON.

The Hono report includes the server in Appendix B and harness in Appendix C. The Tokio comparison and newer payload suite live in knitting-vs-tokio-bench. See Payload types for copying committed runs into the docs.