How a Linux machine runs in your tab

A real Linux 6.18 kernel and Debian 13 run on an arm64 machine that our own engine emulates inside your browser. Nothing runs on our servers; the relay only carries your network traffic.

Open your outpost See the whole outpost

$ uname -srm

Linux 6.18 aarch64

$ cat /etc/debian_version

engine: NWE, in this tab

Our own engine, NWE

NWE, the Neutrium Wasm Engine, is written in Rust and compiled to WebAssembly. It emulates a 64-bit arm64 computer: processor, memory, disk and timers. On that computer boots our own build of Linux and a Debian image, so programs run exactly as they would on an arm64 server.

Not a rebuilt userland: real Linux programs
Not a server: it runs in your tab
Our own engine, not a port of another emulator

$ sudo apt install -y redis-server

$ systemctl is-active redis-server

active

what happens to a loop

first runs: interpreted

hot: compiled to WebAssembly

browser: compiled to machine code

Interpreted when cold, compiled when hot

Code that runs once is interpreted. Code that runs often is compiled by NWE into WebAssembly, and your browser’s own compiler turns that into machine code for your processor. That is what makes builds and agents usable in a tab.

Cold code: interpreted
Hot code: compiled to WebAssembly by our JIT
Then to machine code by the browser

Node and Bun skip the emulator

When you run node or bun, 0cloud runs it on your browser’s own JavaScript engine, which is far faster than emulating it. If a program needs something only the real binary does, it falls back to the binary by itself and gives you the same result.

npm install on the browser engine
Falls back to the real binary by itself
Can be switched off

~/shop-api

$ node -v

v26.13.0

$ npm install

runs on the browser engine

dev@shop-api ~/shop-api

$ claude

❯ fix the failing cart test

Read test/cart.test.js

Edited src/cart.ts

● Fixed. 12 passed.

* Worked for 9s

Compose a long prompt

EscTabCtrlAlt^C|~/↑↓

The same engine on iPhone and iPad

NWE runs in WebKit too. An iOS app may not make machine code by itself, which is why other iOS shells interpret; the 0cloud app runs NWE inside WebKit, whose JIT compiles the WebAssembly. So the phone runs the same machine as your laptop.

Same engine, same Linux, same workspaces
WebKit compiles the hot code
Snapshots when the app goes to the background

Your disk stays in the browser

The machine’s disk lives in your browser’s storage on this device, and the outpost snapshots itself when you close the tab. The network goes through the 0cloud relay, and with an account your workspaces sync, encrypted in your browser first.

Disk in browser storage on your device
Snapshot on close, back where you left
Sync is end-to-end encrypted

Your browserencrypts before uploadOur servers

~/.ssh/id_ed25519key→x9Fq…7Ld2
~/.bashrcdotfile→x9Fq…7Ld2
~/.bash_historyhistory→x9Fq…7Ld2
~/work/shop-apifiles→x9Fq…7Ld2

The key never leaves your browser. We store the right-hand column only.

Questions

Is it QEMU or v86?

Every workspace runs on NWE by default, our own engine written for WebAssembly from the start.

Does my code run on your servers?

No. The machine runs in your tab. Our servers relay network traffic and store encrypted sync data they cannot read.

Why arm64?

Phones, Macs and many servers are arm64, and every Debian package and coding agent ships an arm64 build.

How fast is it?

Node and Bun run on the browser engine at near full speed. Other programs are emulated: hot code is compiled, but heavy builds take longer than on your laptop.