Skip to content
Knitting

Bun

This page summarizes Bun benchmark runs for Knitting 0.1.24 on bun 1.3.6 (arm64-darwin), recorded in March 2026.

IPC (Bun)

Section titled “IPC (Bun)”

This benchmark measures round-trip communication between the main thread and workers using different transports. Knitting has the lowest overhead in this setup:

  • 1 message: Knitting is about 4.4x faster than worker postMessage, 8.1x faster than WebSocket, and 16.5x faster than HTTP.
  • 25 messages: Knitting is about 5.5x faster than worker postMessage.
  • 50 messages: Knitting is about 5.3x faster than worker postMessage.

Data

Section titled “Data”
Bun IPC benchmark

Knitting vs Worker (Bun)

Section titled “Knitting vs Worker (Bun)”

These charts compare the same payload types sent through Knitting and Bun workers.

One message

Section titled “One message”

With a single value per call, Knitting is faster in these measurements:

  • For small primitives, Knitting is roughly ~6-17x faster than workers.
  • For string/array/object payloads, Knitting is usually around ~4-6x faster.
  • For larger payloads, Knitting still holds a clear advantage (for example, big object: 3.97 µs vs 16.38 µs, about 4.1x faster).
Bun knitting vs worker benchmark 1

100 messages

Section titled “100 messages”

At 100 messages per iteration:

  • Primitive payloads are ~7-9x faster with Knitting.
  • Heavier payloads are about ~3.7-3.9x faster.
  • Batching improves throughput for both, but Knitting has lower overhead across the tested payload types.
Bun knitting vs worker benchmark 100

Call growth throughput (Bun)

Section titled “Call growth throughput (Bun)”

This benchmark increases payload size from 32 B up to 1,048,576 B (1 MiB) and reports the time per batch with batch=64.

Using the 1048576 B row (avg) from the batch=64 run, one-way transfer throughput is:

  • string: 5.66 ms/iter -> 11.86 GB/s
  • Uint8Array: 4.14 ms/iter -> 16.21 GB/s

Interpretation:

  • Bun remains the fastest runtime in this 1 MiB batch test for both string and binary payloads.
  • The Uint8Array path clears 16 GB/s one-way equivalent in this run, with strings close to 12 GB/s.

Data

Section titled “Data”
bun_call-growth-batch.md
clk: ~3.68 GHz
cpu: Apple M3 Ultra
runtime: bun 1.3.6 (arm64-darwin)


| • call growth batch string (ascii 32..1048576 x4, batch=64) |              avg |         min |         p75 |         p99 |         max |
| --------- | ---------------- | ----------- | ----------- | ----------- | ----------- |
| 32 B      | ` 25.85 µs/iter` | ` 11.46 µs` | ` 29.63 µs` | ` 80.08 µs` | `  1.94 ms` |
| 128 B     | ` 22.32 µs/iter` | ` 20.54 µs` | ` 22.99 µs` | ` 23.68 µs` | ` 25.10 µs` |
| 512 B     | ` 28.31 µs/iter` | ` 25.67 µs` | ` 29.32 µs` | ` 29.67 µs` | ` 30.50 µs` |
| 2048 B    | ` 67.00 µs/iter` | ` 28.96 µs` | ` 70.29 µs` | `247.21 µs` | `  2.73 ms` |
| 8192 B    | `130.66 µs/iter` | ` 71.17 µs` | `142.79 µs` | `323.83 µs` | `  1.84 ms` |
| 32768 B   | `208.32 µs/iter` | `123.29 µs` | `214.96 µs` | `652.54 µs` | `  1.84 ms` |
| 131072 B  | `592.88 µs/iter` | `418.63 µs` | `592.92 µs` | `  1.88 ms` | `  2.25 ms` |
| 524288 B  | `  2.82 ms/iter` | `  1.77 ms` | `  3.36 ms` | `  6.20 ms` | `  6.64 ms` |
| 1048576 B | `  5.66 ms/iter` | `  3.85 ms` | `  5.85 ms` | ` 10.93 ms` | ` 10.98 ms` |


| • call growth batch uint8array (32..1048576 x4, batch=64) |              avg |         min |         p75 |         p99 |         max |
| --------- | ---------------- | ----------- | ----------- | ----------- | ----------- |
| 32 B      | ` 25.21 µs/iter` | ` 13.38 µs` | ` 30.13 µs` | ` 56.04 µs` | `  1.53 ms` |
| 128 B     | ` 23.71 µs/iter` | ` 20.35 µs` | ` 25.02 µs` | ` 25.26 µs` | ` 26.54 µs` |
| 512 B     | ` 22.87 µs/iter` | ` 20.79 µs` | ` 23.68 µs` | ` 23.82 µs` | ` 24.01 µs` |
| 2048 B    | ` 67.13 µs/iter` | ` 33.50 µs` | ` 70.92 µs` | `132.92 µs` | `  7.98 ms` |
| 8192 B    | `116.93 µs/iter` | ` 62.04 µs` | `114.25 µs` | `221.04 µs` | `  3.13 ms` |
| 32768 B   | `193.72 µs/iter` | `131.08 µs` | `173.92 µs` | `  1.01 ms` | `  2.90 ms` |
| 131072 B  | `571.40 µs/iter` | `348.29 µs` | `523.71 µs` | `  2.01 ms` | `  2.32 ms` |
| 524288 B  | `  2.37 ms/iter` | `  1.59 ms` | `  3.00 ms` | `  5.19 ms` | `  6.12 ms` |
| 1048576 B | `  4.14 ms/iter` | `  3.08 ms` | `  4.64 ms` | `  6.30 ms` | `  9.65 ms` |

Efficiency under heavy tasks (Bun)

Section titled “Efficiency under heavy tasks (Bun)”

This stress test computes prime numbers over a large range, then serializes and parses large JSON payloads:

const N = 10_000_000; // search range: [1..N]
const CHUNK_SIZE = 250_000;

Even under this heavier workload, parallel workers scale well:

  • main + 1 extra thread: ~1.8x faster than main only.
  • main + 2 extra threads: ~2.5x faster than main only.
  • main + 3 extra threads: ~3.3x faster than main only.
  • main + 4 extra threads: ~3.8x faster than main only.

Data

Section titled “Data”
bun_withload.md
clk: ~3.69 GHz
cpu: Apple M3 Ultra
runtime: bun 1.3.6 (arm64-darwin)


| • knitting: primes up to 10,000,000 (chunk=250,000) |              avg |         min |         p75 |         p99 |         max |
| ----------------------------------- | ---------------- | ----------- | ----------- | ----------- | ----------- |
| main                                | `572.57 ms/iter` | `569.05 ms` | `573.73 ms` | `576.83 ms` | `577.70 ms` |
| main + 1 extra threads → full range | `304.05 ms/iter` | `299.51 ms` | `305.94 ms` | `310.39 ms` | `310.63 ms` |
| main + 2 extra threads → full range | `224.68 ms/iter` | `220.21 ms` | `228.08 ms` | `230.10 ms` | `230.84 ms` |
| main + 3 extra threads → full range | `179.33 ms/iter` | `174.37 ms` | `181.15 ms` | `181.78 ms` | `182.35 ms` |
| main + 4 extra threads → full range | `157.48 ms/iter` | `153.46 ms` | `159.02 ms` | `159.85 ms` | `160.47 ms` |

All types in Knitting

Section titled “All types in Knitting”

This benchmark covers primitives, structured values, collections, typed arrays, errors, dates, symbols, and promise arguments. It also compares static and dynamic payload allocation. Results are reported for count 1 and count 100 to show both per-call latency and batched throughput.

Quick takeaways:

  • At count 100, primitive payloads are usually in the ~16-25 µs range, while heavier structured/collection payloads are often ~60-270 µs with occasional larger spikes.
  • The static payload path is usually around ~1.3x-3.1x faster than dynamic allocator paths (for example: string ~1.8x, JSON ~2.1x, Uint8Array ~1.3x, symbol ~3.1x at count 100).

Payload sizes (approximate):

PayloadSize
jsonObj206 B
jsonArr217 B
mapPayload284 B
Uint8Array1024 B
Int32Array1024 B
Float64Array1024 B
BigInt64Array1024 B
BigUint64Array1024 B
DataView1024 B
smallU8480 B
largeU8481 B

Data

Section titled “Data”
bun_types_knitting.md
payload sizes (approx bytes):
  jsonObj: 206 bytes
  jsonArr: 217 bytes
  stringHuge: 1024 bytes
  Uint8Array: 1024 bytes
  Int32Array: 1024 bytes
  Float64Array: 1024 bytes
  BigInt64Array: 1024 bytes
  BigUint64Array: 1024 bytes
  DataView: 1024 bytes


clk: ~3.69 GHz
cpu: Apple M3 Ultra
runtime: bun 1.3.6 (arm64-darwin)


| • knitting-types 1    |              avg |         min |         p75 |         p99 |         max |
| --------------------- | ---------------- | ----------- | ----------- | ----------- | ----------- |
| number -> (1)         | `  1.88 µs/iter` | `459.00 ns` | `  2.83 µs` | `  8.17 µs` | `433.21 µs` |
| bigint small -> (1)   | `  2.19 µs/iter` | `  1.50 µs` | `  2.48 µs` | `  3.01 µs` | `  3.07 µs` |
| bigint large -> (1)   | `  4.01 µs/iter` | `  2.04 µs` | `  4.04 µs` | ` 12.50 µs` | `  1.73 ms` |
| boolean true -> (1)   | `  1.33 µs/iter` | `707.16 ns` | `  1.68 µs` | `  2.48 µs` | `  2.74 µs` |
| boolean false -> (1)  | `  1.09 µs/iter` | `710.70 ns` | `  1.35 µs` | `  2.14 µs` | `  2.47 µs` |
| undefined -> (1)      | `  1.16 µs/iter` | `648.72 ns` | `  1.51 µs` | `  2.57 µs` | `  2.89 µs` |
| null -> (1)           | `  1.03 µs/iter` | `649.21 ns` | `  1.30 µs` | `  2.70 µs` | `  2.92 µs` |
| string -> (1)         | `  2.39 µs/iter` | `625.00 ns` | `  2.92 µs` | `  7.88 µs` | `448.88 µs` |
| json object -> (1)    | `  3.59 µs/iter` | `  3.00 µs` | `  3.82 µs` | `  4.37 µs` | `  4.37 µs` |
| json array -> (1)     | `  4.61 µs/iter` | `  4.15 µs` | `  4.76 µs` | `  5.04 µs` | `  5.09 µs` |
| Uint8Array -> (1)     | `  4.34 µs/iter` | `  1.54 µs` | `  4.67 µs` | ` 14.04 µs` | `  3.75 ms` |
| ArrayBuffer -> (1)    | `  3.98 µs/iter` | `  1.33 µs` | `  4.42 µs` | ` 11.83 µs` | `  3.49 ms` |
| Buffer -> (1)         | `  3.15 µs/iter` | `  2.44 µs` | `  3.46 µs` | `  3.79 µs` | `  3.84 µs` |
| string huge -> (1)    | `  3.51 µs/iter` | `  1.29 µs` | `  3.79 µs` | ` 11.96 µs` | `  1.59 ms` |
| Int32Array -> (1)     | `  3.55 µs/iter` | `  2.61 µs` | `  3.92 µs` | `  4.21 µs` | `  4.25 µs` |
| Float64Array -> (1)   | `  3.00 µs/iter` | `  1.08 µs` | `  3.38 µs` | `  8.79 µs` | `  1.68 ms` |
| BigInt64Array -> (1)  | `  3.48 µs/iter` | `  2.54 µs` | `  3.86 µs` | `  4.45 µs` | `  4.65 µs` |
| BigUint64Array -> (1) | `  3.57 µs/iter` | `  2.58 µs` | `  4.05 µs` | `  4.84 µs` | `  4.90 µs` |
| DataView -> (1)       | `  3.24 µs/iter` | `  2.50 µs` | `  3.50 µs` | `  4.65 µs` | `  5.04 µs` |
| Date -> (1)           | `  1.68 µs/iter` | `541.00 ns` | `  1.96 µs` | `  5.21 µs` | `466.54 µs` |
| Symbol.for -> (1)     | `  2.41 µs/iter` | `  1.76 µs` | `  2.64 µs` | `  3.04 µs` | `  3.04 µs` |


| • knitting-types 100    |              avg |         min |         p75 |         p99 |         max |
| ----------------------- | ---------------- | ----------- | ----------- | ----------- | ----------- |
| number -> (100)         | ` 32.00 µs/iter` | ` 13.96 µs` | ` 27.54 µs` | `215.88 µs` | `  3.23 ms` |
| bigint small -> (100)   | ` 30.26 µs/iter` | ` 27.43 µs` | ` 31.73 µs` | ` 32.18 µs` | ` 35.93 µs` |
| bigint large -> (100)   | `122.70 µs/iter` | ` 84.33 µs` | `120.96 µs` | `425.79 µs` | `  1.91 ms` |
| boolean true -> (100)   | ` 27.23 µs/iter` | ` 24.14 µs` | ` 27.49 µs` | ` 29.92 µs` | ` 34.21 µs` |
| boolean false -> (100)  | ` 28.04 µs/iter` | ` 23.23 µs` | ` 29.87 µs` | ` 32.86 µs` | ` 36.96 µs` |
| undefined -> (100)      | ` 28.24 µs/iter` | ` 22.49 µs` | ` 29.58 µs` | ` 30.68 µs` | ` 32.45 µs` |
| null -> (100)           | ` 25.01 µs/iter` | ` 22.17 µs` | ` 26.19 µs` | ` 27.17 µs` | ` 27.45 µs` |
| string -> (100)         | ` 28.18 µs/iter` | ` 23.32 µs` | ` 30.81 µs` | ` 33.08 µs` | ` 41.07 µs` |
| json object -> (100)    | `122.98 µs/iter` | ` 93.67 µs` | `125.88 µs` | `223.46 µs` | `  1.62 ms` |
| json array -> (100)     | `149.52 µs/iter` | `113.92 µs` | `154.54 µs` | `279.08 µs` | `  1.66 ms` |
| Uint8Array -> (100)     | `112.02 µs/iter` | ` 54.00 µs` | `112.13 µs` | `928.79 µs` | `  3.12 ms` |
| ArrayBuffer -> (100)    | `115.93 µs/iter` | ` 61.33 µs` | `113.54 µs` | `922.46 µs` | `  3.59 ms` |
| Buffer -> (100)         | `104.68 µs/iter` | ` 44.46 µs` | `115.63 µs` | `747.96 µs` | `  2.11 ms` |
| string huge -> (100)    | ` 93.47 µs/iter` | ` 46.04 µs` | `110.38 µs` | `207.17 µs` | `  1.73 ms` |
| Int32Array -> (100)     | `101.19 µs/iter` | ` 49.92 µs` | ` 98.04 µs` | `900.71 µs` | `  3.78 ms` |
| Float64Array -> (100)   | ` 71.52 µs/iter` | ` 37.50 µs` | ` 82.33 µs` | `167.50 µs` | `  1.58 ms` |
| BigInt64Array -> (100)  | `103.28 µs/iter` | ` 50.00 µs` | ` 98.63 µs` | `920.00 µs` | `  3.84 ms` |
| BigUint64Array -> (100) | `101.80 µs/iter` | ` 50.13 µs` | ` 98.13 µs` | `908.42 µs` | `  4.21 ms` |
| DataView -> (100)       | `102.14 µs/iter` | ` 50.29 µs` | ` 98.92 µs` | `895.21 µs` | `  3.87 ms` |
| Date -> (100)           | ` 31.00 µs/iter` | ` 27.10 µs` | ` 32.35 µs` | ` 34.37 µs` | ` 38.53 µs` |
| Symbol.for -> (100)     | ` 37.43 µs/iter` | ` 21.46 µs` | ` 47.08 µs` | ` 83.50 µs` | `  1.56 ms` |


| • knitting-promise-args 1 |              avg |         min |         p75 |         p99 |         max |
| --------------------- | ---------------- | ----------- | ----------- | ----------- | ----------- |
| promise number -> (1) | `  2.44 µs/iter` | `  1.76 µs` | `  2.78 µs` | `  3.16 µs` | `  3.20 µs` |
| promise object -> (1) | `  3.13 µs/iter` | `  2.35 µs` | `  3.34 µs` | `  3.74 µs` | `  3.79 µs` |


| • knitting-promise-args 100 |              avg |         min |         p75 |         p99 |         max |
| ----------------------- | ---------------- | ----------- | ----------- | ----------- | ----------- |
| promise number -> (100) | ` 43.54 µs/iter` | ` 39.69 µs` | ` 45.25 µs` | ` 47.23 µs` | ` 48.48 µs` |
| promise object -> (100) | ` 61.77 µs/iter` | ` 38.13 µs` | ` 68.83 µs` | `122.88 µs` | `  1.49 ms` |