LinuxOnTab boots a real x86 Linux kernel and Alpine userland inside your browser using WebAssembly and the v86 emulator. A zero-install, local-first, in-browser Linux terminal — a lightweight Docker alternative for instant sandboxes, teaching, demos, and disposable shells.
LinuxOnTab is a browser-only Linux desktop. Open the page and a real x86 Linux kernel boots inside the v86 WebAssembly emulator, presenting an Alpine Linux shell over xterm.js. Every system call hits a real kernel running in your tab — not a transpiled toy, not a remote container, not a cloud VM you have to log into.
Networking is opt-in. When you want it, the guest connects to a backend over a WISP v1 WebSocket and gets full TCP egress. You can then expose in-guest ports back to your host over a pairing-code tunnel and SSH, SCP, SFTP, or rsync into the browser tab as if it were any other Linux box.
Boots an actual x86 kernel image plus an Alpine userland inside the v86 WebAssembly emulator — not a faked terminal.
Code runs in your tab. Your data lives in IndexedDB. Close the tab and the VM is gone — no orphan containers, no zombie processes on your laptop.
Static site over HTTPS. No daemon, no kernel modules, no admin rights, no package install. Works on Mac, Windows, Linux, ChromeOS.
Full Alpine package ecosystem: apk add python3 nodejs git openssh syncthing — install whatever you need, persist via snapshot.
Save full VM state to IndexedDB. Restore on next boot with installed packages, files, and shell history intact.
Tunnel guest TCP ports out through a pairing-code WebSocket bridge. Run ssh -p 2222 root@localhost on your Mac and you're in.
Anything you drop in ~/public in the guest is browsable from any HTTPS client via a 4-character pairing code.
Share folders peer-to-peer over Nostr relays. No accounts, no servers — just keypairs and public manifests.
Once the page and ISO are cached, the VM boots without a network connection. Networking inside the guest is the only piece that needs the internet.
man page — no SSH keys, no cloud accounts, no install.python3 -m http.server, a static site, a tiny API) and expose it via the tunnel CDN.docker run -it alpine sh just to get a quick shell — open a tab instead.~/public, share linuxontab.com/viewer/?code=XXXX.For ephemeral, browser-side Linux work, LinuxOnTab and Docker are not really competitors — they cover different ground. Here's the rough split:
| LinuxOnTab | Docker | Cloud shell (e.g. SSH VM) | |
|---|---|---|---|
| Install required | No | Yes (daemon) | No (but account needed) |
| Account / signup | No | No | Yes |
| Real Linux kernel | Yes (in WASM) | Yes (host kernel) | Yes |
| Runs offline | Yes | Yes | No |
| State after closing tab | IndexedDB snapshots | Persistent volumes | Persistent disk |
| Cleanup overhead | Close the tab | Containers, volumes, networks | Stop / destroy VM |
| Resource cost | Browser RAM only | Daemon + kernel resources | $ per hour |
| Sandboxed from host | Browser-grade | Namespaces only | Network-isolated |
| Best for | Disposable shells, teaching, demos | Reproducible builds, prod images | Long-running compute |
Verdict: LinuxOnTab is a complement to Docker, not a replacement for it. For one-off shells, demos, and "I just need a Linux box for two minutes," it is dramatically faster and lighter than spinning up a container or a VM.
x86 emulator in WebAssembly. Boots real kernel images in any modern browser. The core that makes LinuxOnTab possible.
Minimal, fast-booting userland with a great package manager. Default ISO ships with BusyBox and apk.
Front-end terminal that renders the guest serial console.
Streaming TCP-over-WS protocol. Lets the in-browser kernel speak real TCP through a backend server.
Optional services for DoH, port tunnels, and TCP egress. Source is in this repo — self-host the whole stack if you want.
Stores full VM snapshots client-side, so reload doesn't blow away your work.
1. Launch the shell. Wait for the Alpine login prompt.
2. Set a root password and install useful tools:
printf 'changeme\nchangeme\n' | passwd root
apk add websocat curl jq openssh-server unbound3. Open a tunnel to your host:
wget -qO- https://linuxontab.com/local/tunnel-up.sh | sh
# → prints a 4-character pairing code, e.g. ARXN4. On your Mac / Linux host, open a local listener bridged to the guest:
sh <(curl -sS https://linuxontab.com/local/tunnel-listen.sh) ARXN
ssh -p 2222 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null root@localhostThat's it — you're SSH'd into a Linux kernel running inside a browser tab.
Real kernel. LinuxOnTab boots an x86 Linux kernel image and an Alpine userland inside the v86 WebAssembly emulator. Every syscall, every /proc entry, every man page is genuine.
For ephemeral browser-side shells: yes. LinuxOnTab gives you a disposable Linux box without a daemon, an install, or a cleanup step. For reproducible production builds and image distribution, stick with Docker — the two are complementary.
Once the page and ISO have been fetched, the VM runs entirely in your browser and survives going offline. Networking inside the guest needs internet, but the kernel itself doesn't.
Yes. Run the in-guest tunnel-up.sh script to register a pairing code, then run tunnel-listen.sh on your host. SSH, SCP, SFTP, and rsync all work as if the guest were a remote box.
Snapshots are stored in IndexedDB on demand. Save before closing the tab and you'll boot back into the same state next time.
The kernel runs inside the browser's WebAssembly sandbox. It has no direct access to your filesystem, devices, or other tabs. Network egress only happens through the explicit WISP/WebSocket tunnel — and you can disable that entirely.
Yes. The shell page, helper scripts, and backend services are all in the public LinuxOnTab repo. The v86 emulator is upstream and BSD-licensed.
Replit and Codespaces run on remote servers — you're paying for a cloud VM. WebContainers (StackBlitz) runs Node.js in the browser via a custom kernel — fast, but it's not a real Linux kernel. LinuxOnTab is the rare combination: real kernel + fully local + no account.