bext lite · the isomorphic deploy target

Write once.
Ship to every runtime.

bext-lite takes one PRISM app and runs it natively, on the desktop, at the edge, in the browser, on mobile and on embedded hardware - from the same source. No Node, no V8 cage, no platform. The whole app ships in about 4 MB.

Get startedSee the targets
terminalCopy
# build your PRISM app to a self-contained bundle
bext-lite build ./app -o ./dist

# run it - 1.8 MB binary, no Node, no V8 required
bext-lite serve ./dist
NativeDesktopEdgeBrowserMobileEmbedded
1.8 MB
v8-free native host binary
~4 MB
whole app, shipped
0
Node or V8 required
100%
byte-identical HTML vs server
One bundle, six runtimes

Swap the runtime, not the code

The AOT exporter emits the same bundle for every target. Pick the shape that fits - the app is identical.

Single static binary

One file. Double-click to run.

~4 MB totalV8 or QuickJS

Desktop app

Native apps, 10x smaller than Electron.

5-20 MBV8 (snapshot React)

Edge functions

PRISM at the edge, sub-MB cold.

sub-MB coldQuickJS on WASM

Browser / offline

The whole app runs client-side.

~3.5 MB cachedQuickJS on WASM

Mobile - iOS & Android

Offline-first, on-device data.

per-render <5 MBQuickJS (no JIT)

IoT / embedded

Runs on a Raspberry Pi.

<5 MB + appQuickJS
Four layers

How one app runs everywhere

Compile ahead of time, render with a tiny engine, bridge to the host, serve. Two of the four layers are fully portable - the client runtime is free on every target.

CompileAOT, build-time
ts-rs transpiles your TSX and turbopack bundles each route to CJS that references host globals by name. You ship JavaScript - there's no compiler on the device.
Fully portable
Renderthe engine decision
A JS engine evaluates the bundle plus 122 KB of pure-JS, engine-agnostic polyfills, then calls __bextPrismRender(props) -> HTML. V8 on desktop/server, QuickJS everywhere else.
Polyfills portable
Hostper-target bridge
Rust implementations of the bridge functions - filesystem, HTTP, SQLite (KV + per-app DB), object storage, env, logging. Native impls copy straight from the bext core.
Re-implemented per target
Shellrouting & serve
A tiny single-app router that matches a route and serves the result - or a Tauri WebView, or an edge fetch handler. No WAF, no TLS, no multi-tenancy. Small by design.
Small per target
The full architecture
Why bext-lite

Small, faithful, everywhere

Tiny by construction

No Node runtime, no V8 pointer cage, no multi-tenant platform. The QuickJS path is a pure interpreter - the whole app ships in megabytes, not hundreds.

Same source, every target

Write a PRISM app once. The AOT exporter produces the same bundle for native, desktop, edge, browser, mobile and embedded - swap the runtime, not the code.

Byte-faithful

Every target renders the exact HTML the bext server would. The output is verified identical, so what you test is what every device ships.

Local-first data

KV, a per-app database and object storage are self-contained SQLite - copyable to any target. On-device data with optional sync to a remote bext.

Free client runtime

The island hydration runtime is pure browser JS with zero server coupling - it runs unchanged in any WebView, on every target, at no extra cost.

One CLI

bext-lite build, serve, dev and package. Hot-reload locally, export a self-contained bundle, ship it. No config sprawl.

Footprint

Megabytes, not hundreds

The whole app - the runtime and your assets - ships in about 4 MB. The fat runtimes it replaces do not.

bext-lite
~4 MB
Node + framework
~120 MB
Electron app
150 MB+
The difference

One codebase the others can't tell

Electron does desktop. Workers do edge. Neither does both - let alone mobile and embedded too.

bext-liteElectronNext-on-Workers
Footprint~4 MB150 MB+platform-bound
Desktop✓✓-
Edge / WASM✓-✓
Mobile✓--
Embedded / ARM✓--
One codebase✓per-targetper-target

Ship your PRISM app anywhere

Build a self-contained bundle and run it from a single binary in two commands.

Get startedView on GitHub