Blog
Long-form writing on what AtollJS is for and how its pieces fit together. Posts live in docs/blog/ in the repo and are compiled into this site.
Introducing AtollJS
Islands-based multithreading: pools, shared memory, and worker-rendered UI under one contract
JavaScript has had workers for fifteen years, and the way most apps use them hasn't changed: pick the expensive function, post it some data, await the result. That works: until the work isn't a function call. It's a million-row scan. It's a UI tree re-rendering every frame. It's state that both threads need live, not cloned-and-stale.
Devtools for the Other Thread
Zero-cost instrumentation, one transport, and a dashboard that draws your worker graph
There's a version of the worker story nobody puts in the pitch deck: the part where something is slow and you can't see it. The pool is a Proxy: great ergonomics, terrible visibility. console.log from inside a worker does arrive, interleaved with seven other workers' logs, stripped of any sense of which thread said it or what it was doing when it did.
Where Worker-rendered MFEs Pay Off
Use cases, and the honest limits
The previous three posts covered how: worker isolation, the contract, distribution. This one is about when, including when not to bother.
Publishing an MFE: npm or CDN
Two artifacts, two distribution shapes
A published MFE is two artifacts with different kinds of entry:
The Contract Is the MFE
A framework-free module between producer and consumer
Once an MFE lives in a worker, the question "what does the shell import?" gets an interesting answer: not the component. The component , plus its entire framework, is inside the worker bundle, which the browser fetches as an asset. What the shell imports is a contract:
Five Frameworks, One Page, Zero Runtime Tax, Micro-frontends in Web Workers
Your micro-frontends are sharing one thread. AtollJS's aren't.
The micro-frontend pitch is great: teams own their features, ship on their own cadence, pick the framework that fits the problem. The asterisk nobody puts in the README: every one of those frameworks runs on the same main thread, in the same module graph, fighting for the same 16ms frame budget.
Micro-frontends Without the Runtime Tax
Why the shell shouldn't ship the MFE's framework
Micro-frontend architecture has always had an asterisk. Module federation, import maps, iframe sandwiches: the orchestration differs, but they share a constraint: every MFE's renderer runs on the host page's main thread. Pick Angular for one widget and Vue for another and the "independent teams" story quietly becomes "every user loads every framework, and they all fight over the same 16ms frame budget."
Facades Over Threads
How AtollJS makes real JavaScript multithreading feel like ordinary code
JavaScript has had real threads for fifteen years, and the honest answer to "why isn't everything multithreaded" is that the API makes you earn it. postMessage gives you a pipe and a serialization boundary; the protocol on top, request ids, response matching, error plumbing, progress events, is work nobody assigned you but everybody pays for.
Dependency Injection Across the Boundary
`@AtollService`: a NestJS provider whose methods run in a pool
NestJS is where this question matters most, because Nest's value proposition is that the provider graph is the architecture. If worker code lives outside that graph, reached through a bespoke client with its own error conventions, you've given up the reason you chose the framework.
Shipping SharedArrayBuffer
COOP/COEP, cross-origin isolation, and what works without it
Here's the bug report every shared-memory project eventually gets: the demo works locally, deploys fine, and in production SharedArrayBuffer is undefined and nothing renders. That's crossOriginIsolated: browsers gate SAB behind cross-origin isolation because shared memory is a Spectre-class timing primitive.
Clustering and Persistence
Socket-transfer, sticky sessions, and Redis-backed shared memory
Gateway routing moves compute off the main thread, but every connection still lands there first. For most apps that's fine. For workloads where the per-request cost is the product, hashing, compression, aggregation over shared state, Node 26 added the missing primitive: transferring the accepted socket itself to a worker.
Atoll on the Server
`node:worker_threads`, HTTP offload, and gateway routing
Everything so far assumed a browser. The backend has the same story with higher stakes: an endpoint that aggregates a million records parks the event loop for tens of milliseconds per request, and while it runs, every other request on that process waits. One slow route is a denial of service on your own server.
The Proxy DOM
How worker-rendered UI stays fast: an op stream, not a VDOM diff
The objection writes itself: a worker can't touch the DOM. True, and it's exactly why most off-main-thread rendering experiments end at a <canvas> or a proof-of-concept nobody ships.
Islands That Render in Workers
Real framework components, off the main thread
"Islands" in this industry usually means small interactive widgets in a mostly-static page: a like button here, a date picker there. A fine pattern that's answering the wrong question for CPU-bound UI.
One Pool Per Browser
`SharedWorker` makes shared memory actually shared
Open your app in three tabs and count what you just paid for: three pools, three copies of the same dataset, three workers running the same queries. Every tab pays full price because Worker is per-page: that's the API, not your design.
Reactivity Without Messages
`Atomics` beats `postMessage` fan-out
Getting worker state into a UI conventionally means a subscription fan-out: the worker posts updates, the main thread forwards them to whoever subscribed: a message for every field change, on every client, even when nothing is looking at that field. It's the part of every worker integration everyone builds and nobody enjoys.
Worker Pools That Fail Gracefully
Dispatch, cancellation, timeouts, backpressure, and crash respawn
Picture the failure mode: your worker throws during module init, or OOMs mid-task, and the postMessage you sent it simply never gets an answer. The await hangs forever. Your loading spinner is now a permanent fixture.
Shared Memory Is a Contract, Not a Buffer
Why AtollJS's `SharedArrayBuffer` layer starts with a schema
If you've ever allocated a SharedArrayBuffer and then written Float64Array offsets into a comment so both files agree: you already know the failure mode this post is about.