Your agent builds it.
Lifo runs it.

Run agent-generated apps, terminals, editors and databases right in the browser. Go to the cloud only when you need to.

$0 in your browser · $0.005/hr for a Lite box in Lifo Cloud, $0 while it sleeps

Browser
Real Lifo, running in your browser. Click the terminal to type.
What this session has cost so far00:00
Lifo, in your browser
$0.00000
A Lite box in Lifo Cloud$0.005/hr
$0.00000
A cloud sandbox VM2 vCPU · $0.10/hr
$0.00000

Benchmarks

Boots before the page finishes loading.

A Linux-like OS written in TypeScript: a kernel, a shell, a filesystem and Node, without a VM or an emulator underneath. Cold start to a ready box with node and npm:

  • 300+ GitHub stars
  • 210K views on launch
  • MIT licensed
  • In production at RapidNative
Lifo · browser tab~27 ms
0.3 MB$0
Cloud microVM · E2B, published~150–300 ms
a VM per session~$0.05 / vCPU-hr
WebContainers · browser tab~6.6 s
75–85 MBcommercial license

Lifo and WebContainers measured with lifo/bench in the same headless Chromium, each spawning node and npm (bench/COMPARISON.md). The cloud microVM figure is E2B's published cold start and excludes the network round trip. Lifo also runs in Node, where a box boots in about 0.5 ms.

Try it here

Real examples, running in this page.

Each one boots a Lifo box in your tab and runs a real toolchain in it. Nothing is streamed from a server, and nothing here costs anyone a cent of compute.

Browser
Real Lifo, running in your browser. Click the terminal to type.
Render a React UI: paste it into Claude Code, Cursor or Codex.
What Lifo runs, today

Everything an agent generates, running in the tab.

Not a frontend preview. The whole app: its server, its database, its git history and a shell to drive it. All of it works now, unmodified.

Web apps

Vite and React, Express and other Node servers, with real npm installs and hot reload.

Mobile apps

Expo, Expo Router and create-expo-app (SDK 54 and 57) as live previews; npx expo start just works. Open them on a phone with Expo Go.

Databases

Postgres through PGlite, and a Supabase-compatible backend through tinbase, Studio included: type supabase start.

Terminals

A bash-like shell with 60+ commands, pipes, job control and a process manager.

Git

Clone, commit, push and pull, against GitHub or any remote.

Code editors

Monaco in an embeddable file explorer, plus nano and vi in the terminal.

Wasm tools

Installable packages like ffmpeg (Wasm), less, man and bc, with lifo install.

Agents

Coding agents run their shell tools inside a Lifo box, in the browser or in Node.

In production at RapidNative. Its Expo previews, its tinbase backends and its coding agent's shell all run on Lifo.

See RapidNative →
Under the hood

A real OS, made of browser parts.

Every tab already has a filesystem, a network stack and a process model. Lifo maps them to the interfaces developers and agents already know, enough to run a whole desktop.

lifo desktop · same kernel, filesystem and processes

Virtual filesystem

POSIX-like: directories, files, symlinks, permissions, /proc and /dev.

Bash-like shell

Pipes, redirects, globs, job control and 60+ commands, all in the browser.

Node.js compatible

fs, http, net, child_process, streams, crypto, zlib and more. Real npm and npx.

Persists itself

Saved to IndexedDB in the browser, with tar.gz snapshot and restore.

Installable packages

ffmpeg (Wasm), git, nano, vi, less, man and bc, with lifo install.

Same box in Node

The identical VM runs in a Node process or as a single binary, for CI and servers.

lscatcpmvrmtouchmkdirlnchmodstatfindtreedudfgrepsedawksortuniqwcheadtailcuttrdiffteexargsprintftarzipunzipgzipenvunamewhoamiuptimedatewhichmanwgetpingdigbcgit

Honest limits

Some workloads will never fit in a tab. Those go to cloud compute, only when you need it.

No native Linux binaries
Tools need a JavaScript or Wasm build. ffmpeg, git and the editors have one; Python and more are planned.
Node through a compatibility layer
It isn't the real Node engine. Most stacks run unmodified, but some packages won't.
Isolation comes from the browser
Inside a box, processes share one JavaScript realm. The browser tab is what keeps code away from the device.
No raw sockets to the internet
Outside traffic goes through fetch and WebSocket. In-box servers talk over the virtual network.
The $0 sandbox

A sandbox in the browser. $0 to run.

Cloud sandboxes bill you for every minute a user previews, tests or runs what an agent made. Lifo runs that same work in the user's own browser tab, so the compute bill is zero. Not discounted. Zero.

  • The tab is the sandbox

    Every browser tab is already isolated, with its own memory, storage and process model. Lifo maps a Unix-like OS onto it instead of renting a VM.

  • Your user's device does the work

    Code runs on the laptop or phone that opened the tab. There is no server per session, so there is nothing to meter.

  • Nothing to boot

    No VM to start and no container to pull. The OS is up in 27 ms, so a preview opens as fast as the page does.

Preview and sandbox sessions your product runs
vCPUs per sandbox
Cloud sandboxes, per month$5,040
Lifo in the browser, per month$0.00

That is $60,480 a year back in your margin.

Illustrative. Cloud figure uses the published $0.0504 per vCPU-hour rate for E2B and Daytona, vCPU time only; memory, storage and egress cost extra. Cloud actions on Lifo, like sharing or keeping an app running, are billed separately.

For people building products

Embed Lifo. Stop paying for every preview.

Building an AI app builder, an agent tool or interactive docs? Run what your users generate in their own browser tab instead of on a cloud VM you pay for.

Runs today
npm install @lifo-sh/core xterm

import { Sandbox } from '@lifo-sh/core'
import 'xterm/css/xterm.css'

// A full interactive shell, persisted in IndexedDB
const sandbox = await Sandbox.create({
  persist: true,
  terminal: '#terminal',
})

Zero compute bill

Every preview and agent session runs on hardware your user already owns.

Full stack in a tab

Frontend, backend, Postgres and git. Not just a frontend preview.

Cloud on demand

Share, persist, keep running and deploy in one click, only when needed.

Contained by the browser

Generated code runs in the user’s browser sandbox, never on your servers.

Built forAI app buildersAgent toolsInteractive docsBrowser IDEsCoding education
Cloud on demand

Local by default. The cloud is one click away.

When the tab isn't enough, the same app moves to the cloud without changes: same files, same Postgres schema, same git history. You only pay from that moment on.

Runs today

Push

Git push to GitHub or any remote, straight from the box.

Handing off to a real repo

In progress

Share

lifo tunnel 3000 gives a port in the box a public URL, from a tab, Node or your terminal.

“I want someone to see this”

Planned

Persist

Sync across devices and back up the database. Snapshot export already works locally.

“Don’t lose my work”

In progress

Keep running

lifo cloud push moves the box to Lifo’s servers. It sleeps when idle and wakes on the next request.

“I closed my laptop and it stopped”

Planned

Deploy

Promote to a production URL. Mobile apps go to the app stores.

“Ship it”

Planned

Scale

Run builds or jobs the browser can’t handle.

A workload that outgrows the device

Runs on your device

$0

Open source under MIT: the runtime, web and React Native renderers, the database in the tab, git, terminal, editor and the agent interface. Browser execution is never metered.

Runs on Lifo's servers

Paid

Tunnels, persistence, hosting, deploys and the build cache. Priced on what you use, so the bill only starts when the cloud does something for you. See pricing

How Lifo compares

Others run code. Lifo runs the whole app.

Others render a frontend or execute code. Lifo runs the generated app in the tab, frontend, backend, database and git, and gives it a one-click path to the cloud.

LifoWebContainersBrowserPodSandpack, Expo SnackCloud sandboxes
Runs inBrowser tabBrowser tabBrowser tabBrowser tabRemote VM or container
What runsVite and Node servers, Expo and React Native previews, Postgres and Supabase, git, shell, Wasm toolsNode.js dev serversNode.js plus bash and gitFrontend (Sandpack) and React Native (Snack) previewsFull Linux
LicenseMIT, open sourceCommercial license for productionMetered subscriptionFreeUsage-based cloud
Compute cost to your product$0None~$0.01 per sandbox hourNone~$0.05 per vCPU-hour
Path to the cloudShare, persist, keep running, deploy in one clickNone built inNone built inNone built inAlready there

Prices are public list prices as of November 2026: E2B and Daytona at $0.0504 per vCPU-hour, BrowserPod at about $0.01 per sandbox hour.

Roadmap

Where Lifo is going.

Shipped6

Real stacks, unmodified

Real npm and npx. Vite + React, Express, create-expo-app (SDK 54 and 57), Expo Router.

Live previews with HMR

In-box ports served through a service worker, multi-port, Expo Go on a real phone.

Postgres and Supabase

PGlite, and tinbase with migrations, seed data, realtime and Studio.

Git, editors, packages

isomorphic-git, Monaco, nano and vi, and Wasm packages like ffmpeg.

Learn more →

Snapshots and Node

Snapshot and restore a box. The same VM runs in Node and as a single binary.

Embeddable UI

Terminal, preview browser and file explorer in @lifo-sh/ui.

In progress3

Preview SDK

One SDK that boots a generated full-stack app in the tab, with its database and git, driven by an agent over MCP.

Public share URLs

The tunnel and relay work self-hosted today. Next: hosted URLs with auth and reconnect.

Benchmarks in CI

Boot and throughput are measured; next is Vite cold start and catching regressions on every PR.

Planned5

Cloud actions

Persist, keep running and deploy in one click. Same files, schema and git history.

lifo CLI

lifo run a script, mount a host directory, expose a port to localhost.

More Wasm runtimes

Python and native CLIs inside the box.

Off-main-thread VM

Run the box in a Web Worker so heavy work never blocks the page.

Agents in the tab

Full agent workflows running in the user's browser, isolated by it.

How Lifo started

At RapidNative, we were frustrated with vibecoding apps that took seconds to boot. So we started building an in-browser virtual filesystem and renderer on ES modules, a way to run code instantly without waiting for cloud VMs to spin up.

It worked, and the in-browser OS layer grew into a project of its own. Then almostnode.dev showed us someone else was close to the same idea, which confirmed a browser-native OS was practical. Lifo happened over a weekend.

Now it comes full circle: RapidNative is Lifo's customer zero, running the apps its agent generates right in the tab.

The name is LIFO as in last in, first out. It also works as Linux For anything.

Your agent builds it.
Lifo runs it.

Free while it runs in your browser. Pay when it needs the cloud.