01What happened
The story, straight
Bun creator Jarred Sumner opened a pull request on June 6, 2026, that adds shared-memory threads to JavaScriptCore — the JavaScript engine Bun uses. The PR implements a new `Thread(fn)` primitive that runs a function on another thread in the same heap with the same objects, eliminating the need for structured clone, message passing, or SharedArrayBuffer-only workarounds. According to the PR's bring-up log, parallel JavaScript executes through all four JIT tiers with no global lock, and the thread test suite passes. The work is not complete: thread-sanitizer cleanup, fuzzing, one benchmark still over budget, and a long soak period remain before it could ship.
jarred sumner opened a PR on jun 6 that gives JavaScriptCore actual shared-memory threads — you call `new Thread(fn)` and the function runs on another thread, same heap, same objects. no structured clone, no message passing, no SharedArrayBuffer escape hatch. it passes the thread test suite through all four JIT tiers with no global lock. not done yet though — needs sanitizer cleanup, fuzzing, and one benchmark is still over budget. sumner says it may never merge.
02Spread timeline
Where it actually started
03Source receipts
Every claim, linked
04What's solid, what isn't
What's solid and what isn't
- The PR exists and implements shared-memory threads for JavaScriptCore with a new Thread(fn) API.
- The thread test suite passes through all four JIT tiers with no global lock.
- The work is incomplete — sanitizer cleanup, fuzzing, benchmark tuning, and soak testing remain.
- Jarred Sumner explicitly states the PR may never merge.
- Whether this approach has any hidden correctness issues that sanitizer cleanup or fuzzing will surface.
- Performance characteristics of the shared-memory model vs. existing worker/message-passing approaches.
- The PR is open for design review and community feedback — outcome (merge, rework, abandon) is unknown.
05Why it matters
The editorial take
JavaScript has never had true shared-memory multithreading at the language level — workers use message passing, SharedArrayBuffer requires manual coordination, and every other approach clones data between threads. If this PR lands, Bun would be the first JS runtime to let developers share objects across threads directly, which would be a fundamental change to how concurrent JavaScript programs are written. The "it may never merge" caveat is real, but the fact that it runs through four JIT tiers with no global lock is a significant engineering milestone.
JS has never had real shared-memory threads — you either clone everything or use SharedArrayBuffer and pray. this PR would let you just share an object by sharing the object. it's a fundamental shift for concurrent JS, and the fact that it already passes tests through all four JIT tiers without a global lock is kind of insane. big 'if it ships' energy, but the engineering alone is worth watching.