Benchmarks#

Machine: AMD Ryzen 7 260 w/ Radeon 780M Graphics, 16 hw threads · Bun 1.4.3 · GEOS 3.14.1-CAPI-1.20.5 · commit a1fffdc · 2026-10-22T08:02[unknown component: 56].169Z

Best-of-N wall time, warm-up excluded (see bench/run.ts). Regenerate with bun run bench; this page is rendered by bun run bench:report. The competitor comparison below renders when bench/competitors/results.json exists — bun run bench:competitors (provision with bench:competitors:setup). Positioning rule (testing.md §4): robust overlays, repair, and indexed/ batched workloads — never trivial-op marketing.

prepared scan (1 polygon × 100k points)#

prepared 33× vs unprepared

STRtree query (100000 items × 1000 envelopes)#

90× vs naive scan

unionAll ladder (961 aligned tiles)#

coverage 2× vs unary

batch vs singular (10⁵ squares)#

engine-native FFI makes per-object calls cheap; batch = one crossing + C loops (D22 note)

ingest (20000 squares)#

19.6× read-many vs per-geometry

makeValid (1,000 bowties)#

29 geoms/s

coverageClean (dirty 20×20 coverage)#

construction batch (10⁵ squares)#

D27 unary batch layer — one crossing per array (D22 note applies)

parallel makeValid (100000 bowties)#

4× vs per-object calls (concurrency 12, chunkFactor 3 — the ≥5× exit axis, D23; WKB serialization bounds the pool at high ratios)

parallel mask scan (100000 bowties × 1 polygon)#

1× (WKB transfer bounds light ops)

parallel overlay scaling (10⁵ squares × wobble(720))#

serialization-bound: the main thread builds 100k chunk WKBs per op (~1s) — cheap-geometry overlays don't parallelize past it; heavy per-item ops do

Reading the batch numbers honestly (D22)#

On Bun 1.4.x the engine-native FFI makes per-object calls cheap (~tens of ns), so main-thread shim batch paths converge toward the GEOS-bound cost of the workload (~1× on overlay; 0.8–1.2× on masks/measures). The batch layer's measured ≥5× axis is the worker pool (see the parallel makeValid rows): the one-crossing property remains load-bearing for interrupt granularity (between-item aborts), all-or-nothing error contracts, and future Bun versions where per-call costs regress.

Competitor comparison#

Same seeded workloads, same methodology (best-of-N wall ms, warm-up excluded, answer fingerprints accumulated inside the timed region), every boundary: native FFI (bun-geos), direct C (geos-cpp), WASM (geos-wasm), ctypes (Shapely), and pure JS (JSTS / turf / polygon-clipping / rbush / flatbush / wkx). Run 2026-10-22T08:01:08.571Z on AMD Ryzen 7 260 w/ Radeon 780M Graphics · commit a1fffdc — regenerate with bun run bench:competitors (optional devDependencies: bun run bench:competitors:setup).

fp = answer fingerprint vs bun-geos at the same size (✓ agree / ✗ differs — read the engine's note before trusting a ✗ row, e.g. turf's buffer projects geographically by design). × vs bun-geos compares each engine's variant against the reference's BEST variant at that size; ratios within [0.9, 1.1] render as ≈ (the cross-process noise floor). Speedups are same-machine, same-input numbers.

Engines#

overlay#

union#

prepared-scan#

strtree#

ingest#

makevalid#

buffer#

Failures & skips#

• geos-wasm strtree@100000: GEOSSTRtree_query callback binding unusable (call_indirect to a signature that does not match (evaluating '$(A)(g, I, B)'))
• jsts prepared-scan: skipped — op not workable against the installed package's API