LifoExperimental
Try Demo
██╗     ██╗███████╗ ██████╗
 ██║     ██║██╔════╝██╔═══██╗
 ██║     ██║█████╗  ██║   ██║
 ██║     ██║██╔══╝  ██║   ██║
 ███████╗██║██║     ╚██████╔╝
 ╚══════╝╚═╝╚═╝      ╚═════╝

A browser-native operating system.

Run agents securely on your machine — no VM, no cloud sandbox, no setup.

300+ GitHub stars210K views on launchMIT licensedboots in ~0ms
Open in Browser
lifo -- bash

Try commands like help, ls, echo "hello", or neofetch

Lifo in 3 Minutes

Why Lifo?

Why the Browser?

Every tab is already a sandboxed OS — with a filesystem, a network stack, and a process model. Cloud VMs re-create all of this from scratch. Lifo doesn't. It maps the OS you're already running.

~0ms

No VM to boot. No container to pull. Just open a tab.

AI agents need a sandbox

AI-generated code needs to execute somewhere safe. As agents write and run code autonomously, secure sandboxing is no longer optional — it's a requirement.

Cloud sandboxes are expensive

Spinning up cloud VMs for every execution is costly and slow. Browsers already have powerful, isolated environments — why not use them?

Vibecoding needs OS-level APIs

Vibecoding in the browser needs filesystem, shell, and process APIs. The browser already has it all — Lifo just maps them to familiar interfaces.

VMs are slow, Lifo is instant

VMs are slow to load because they secure and provision resources. Lifo runs instantly — it doesn't allocate resources, it just maps browser APIs.

Desktop

A full desktop environment running entirely in your browser — powered by Lifo.

lifo -- bash

What Lifo Is

A library that gives browser APIs a Linux-like interface for your agents.

Linux-like API

Wraps IndexedDB, Fetch, and Web Workers behind familiar POSIX/Unix-style interfaces. Work with files, processes, and networking using APIs you already know.

Node.js Compatibility

Shims for fs, path, process, and child_process. Run Node-style scripts directly in the browser.

What Lifo Is Not

✗Not a virtual machine
✗Not a full operating system
✗Not a Docker replacement
✗Not a server-side runtime

Lifo is a browser library that provides Linux-like APIs on top of existing Web APIs. It runs entirely in your browser tab — no backend, no VM, no containers.

Lightning Fast

~0ms
Boot Time
0
Cloud Round-trips
$0
Infra Cost

Quick Start

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

// One line to get a full interactive shell
const sandbox = await Sandbox.create({
  persist: true,
  terminal: '#terminal',
})

How Lifo Compares

FeatureLifoWebContainersCloudflare SandboxVercel Sandbox
Runs inBrowser tabBrowser (WASM)Edge workerCloud VM
Boot timeInstant (~0ms)Moderate (~2-5s)Fast (~50ms)Fast (~50ms)
Network requiredNoYes (to load)YesYes
CostFree (client-side)Commercial licensePer-request pricingPer-execution pricing
Offline supportYesNoNoNo
Real filesystemVirtual (IndexedDB)In-memoryLimitedFull (ephemeral)
Node.js compatPartial (shims)Near-fullWorkers APIFull
LicensingMIT (open source)Proprietary (commercial license required)Proprietary SaaSProprietary SaaS
Best forAI sandboxing, demos, prototypingBrowser IDEs, tutorialsEdge compute, API workersFull backend execution

Use Cases

🤖
AI Agent Sandboxing
Let AI agents execute generated code safely in a browser sandbox. No cloud VMs, no security risks.
📖
Interactive Tutorials
Build zero-setup coding tutorials where learners run real commands directly in the browser.
💻
Browser-Based IDEs
Power browser IDEs with a real filesystem, shell, and process model. No server required.
⚡
Rapid Prototyping
Spin up environments in milliseconds. Test ideas instantly without provisioning infrastructure.
📡
Offline-First Apps
Build apps that work without internet. Files persist in IndexedDB across sessions.
🎓
Educational Platforms
Teach Linux, shell scripting, and system concepts without requiring students to install anything.

Features

📁
Virtual Filesystem
POSIX-like VFS with directories, files, symlinks, and permissions. Backed by IndexedDB for persistence across sessions.
🐚
Bash-like Shell
Pipes, redirects, command chaining (&&, ||, ;), environment variables, and tab completion out of the box.
⚡
60+ Commands
ls, cat, grep, awk, sed, curl, tar, git-like ops, and more. Familiar Unix tools running entirely in the browser.
🟢
Node.js Compat
Shims for fs, path, process, and child_process. Run Node-style scripts without a server.
💾
IndexedDB Persistence
Files and state survive page refreshes. Your virtual filesystem persists automatically in the browser.
📦
Package ManagerComing Soon
Install and manage packages directly in the browser environment with a built-in package manager.

58+ Built-in Commands

Familiar Unix tools running entirely in the browser

lscatcpmvrmtouchmkdirrmdirlnchmodchownstatfilefindtreedudfrealpathdirnamebasenamemktempgrepsedawksortuniqwcheadtailcuttrrevnldiffteexargsprintftarzipunzipgzipgunzipenvunamehostnamewhoamiuptimefreedatecalsleepyeswhichmanwgetpingdigbc

Limitations

No native binary execution

Only JavaScript and TypeScript can run. No compiled binaries.

.wasm support coming soon — ffmpeg, ImageMagick, SQLite and more

Virtual filesystem

Files live in IndexedDB, not on a real disk. Storage quotas vary by browser.

Mountable FS coming — local disk, cloud storage and more

No true process isolation

Processes share the main JS thread. Web Workers are available for parallelism.

Browser storage limits

IndexedDB quotas depend on the browser and available disk space.

No network sockets

Networking goes through the Fetch API. No raw TCP/UDP socket access.

Tunneling in progress — run Next, Expo, Express with real domains

Not for high-security sandboxing

If you need full VM-level isolation, use a cloud sandbox instead.

Roadmap

Git Integration

In Progress

Full git support via isomorphic-git. Clone, commit, push, and pull directly in the browser.

Port Exposing

Planned

Tunnel local ports to real domains. Run dev servers and access them from anywhere.

Run Full Projects

Planned

Run frameworks like Next.js, Express, Expo, Hono, and OpenClaw directly in the browser sandbox.

Package Manager & Wasm Runtimes

Planned

Run lifo install ffmpeg and get the full ffmpeg CLI in your browser. Install ImageMagick, Python, SQLite, Postgres the same way — powered by WebAssembly.

Learn more →

Snapshot, Hibernate & Resume

Exploring

Take a snapshot of the filesystem state, hibernate a sandbox, and resume it later. Exploring what levels of hibernation are possible beyond FS snapshots.

Node.js & Serverless Runtime Support

Planned

Currently Lifo runs in the browser using Web APIs. We plan to open it up so the same sandbox can run in Node.js and edge/serverless environments too.

How Lifo Started

At RapidNative, we were frustrated with vibecoding apps that took seconds to boot. We didn't want that. So we started building an in-browser virtual filesystem and renderer using ES Modules — a way to run code instantly without waiting for cloud VMs to spin up.

It worked. But ultimately we chose a different direction for RapidNative, going with bundling (like Metro) instead. The in-browser OS layer we'd built was a natural next step on its own.

Then we came across almostnode.dev and it clicked — what we were building was very close to what they were doing. It confirmed that a browser-native OS was not only possible but practical. Lifo happened over a weekend.

The name? It's pronounced like LIFO as in FIFO/LIFO (Last In, First Out). But it also works nicely as Linux For anything.