atoll
typed worker pools · shared memory · worker islands

Islands based multithreading

Worker pools and shared workers joined to your app through one shared-memory fabric. Contracts share fixed-layout SharedArrayBuffer state across threads; work is offloaded via task commands and state reactivity.

$npm install @atolljs/core
The bridge

UI where it belongs, work where it belongs

Main-thread UI strengths and web worker strengths converging into AtollJS: proxy DOM and op protocol, typed shared-memory tasks, five framework island adapters, nested and keep-alive workers, DevTools instrumentation, and the atoll CLI
The fabric

One contract, every thread

Worker pools

Typed task dispatch over lazily-spawned workers. Call a method, get a promise.

Shared-memory contracts

Fixed-layout SharedArrayBuffer state, declared once and identical on both threads.

Cross-thread reactivity

observe, watch, and task state subscribe on either side of the boundary.

Worker-rendered islands

Whole framework trees committed off the main thread, replayed as DOM ops.

Live

Five frameworks, five workers, one page

Every card below is a running micro-frontend: a real React, Vue, Solid, Svelte, or Angular component rendering inside its own dedicated worker. Clicks, timers, and state all live off the main thread; only DOM mutation ops cross back.

worker islands · mounted via mountIsland() mounting islands…
Reactcounterspawning…
react-reconciler · dedicated worker
Vuenotesspawning…
createRenderer on the proxy DOM
Solidtickerspawning…
solid-js/universal · timer emits
Sveltedialspawning…
mount() on the proxy DOM
Angularcheckoutspawning…
Renderer2 · JIT + zoneless
waiting for island events… main thread idle
Why atoll

Micro-frontends without the plumbing

Typed contracts

defineSharedMemory and defineIslandContract declare the wire once. Both threads type-check against it, and payloads validate at the boundary.

Any framework, or none

One op protocol carries React, Vue, Solid, Svelte, and Angular trees side by side, plus imperative proxy-DOM apps. The shell never imports another framework.

Topology per mount

Dedicated worker, shared client, or nested sub-worker: the mount call decides, the app doesn't change. The demos put all three on one page.

Remote MFEs

Worker bundles can live on another origin, versioned and cached like any asset. The contract module is the only import the host needs.

Mission: make multithreaded JavaScript feel like single-threaded JavaScript. Atoll turns the worker boundary into a typed contract: pools, task dispatch, reactivity, and worker-rendered UI islands all speak one fixed-layout shared-memory fabric. Heavy work leaves the main thread without leaving your framework's idioms: no bespoke postMessage plumbing, no serialization guesswork. Declare the contract once, and both threads speak it.