In Part 1 of this series, we explored how developer Joel Sever achieved something extraordinary — running a full Linux kernel inside a browser, powered purely by WebAssembly.
If you haven’t read it yet, it’s worth visiting that article first to understand the history and the technological leap behind this project.
But theory is only half the story. The real fun begins when you actually see it running in your own browser — booting, initializing, and letting you type Linux commands right there on your screen.
This guide will walk you through everything step-by-step: from opening the live demo to understanding what’s happening behind the scenes.
It’s not about typing a few ls or cd commands for show — this is about watching a Linux kernel come alive inside your browser tab.
1. Before You Begin — What You’ll Need
Let’s start simple.
To run Linux-on-WebAssembly, you don’t need a virtual machine, cloud account, or installation process. All you need is:
✅ A modern browser
Any of the following will work:
- Google Chrome (recommended for best performance)
- Microsoft Edge
- Mozilla Firefox (works, though slightly slower)
- Brave or Chromium builds
Make sure your browser is updated to the latest version, as older releases may lack WebAssembly threading and shared-memory support.
✅ A decent computer
While the demo works on almost any modern device, here are some rough expectations:
- At least 4 GB RAM
- A dual-core CPU or better
- Desktop or laptop (mobile browsers may not fully support it yet)
✅ Stable internet connection
The first load fetches the WebAssembly binaries — around 50–100 MB in total. Once loaded, everything runs locally inside your browser.
That’s it. You’re ready.
2. Launch the Live Demo
Let’s move to the exciting part — seeing Linux actually boot in your browser.
Visit the official live demo created by Joel Sever:
👉 Live Demo: joelseverin.github.io/linux-wasm
After the page loads, you’ll see a dark console window and some text scrolling rapidly. Congratulations — that’s not fake output. It’s the real Linux 6.4.16 kernel initializing inside your browser.
Within a second or two, you’ll see the familiar Linux prompt:
/ #
That’s your shell. You now have a working Linux environment — entirely in the browser.
3. Understanding What You’re Seeing
Let’s pause and understand what’s actually happening behind that blinking cursor.
When the page loads, the browser downloads:
- The Linux kernel, compiled to WebAssembly
- A minimal BusyBox user-space, providing essential commands
- JavaScript glue code to handle boot, memory, and I/O
Once initialized, the WebAssembly module runs directly on your local CPU — not through emulation.
There’s no cloud backend, no remote VM, just your browser executing real kernel code.
That’s why Joel Sever describes it as:
“No VM, No Cloud, Just WebAssembly.”
4. Exploring the Linux Shell
Now that your kernel is running, it’s time to explore.
You can type standard Linux commands, and the system will respond instantly.
Here are some examples you can try:
| Command | Purpose | Example Output |
|---|---|---|
ls | Lists files in the current directory | bin dev etc home tmp |
pwd | Shows current directory | / |
cat /proc/version | Displays kernel info | Linux version 6.4.16 (wasm build) |
echo Hello World | Prints text to screen | Hello World |
uname -a | Shows system details | wasm-linux 6.4.16 #1 WASM build |
You’ll notice that commands execute surprisingly fast — because everything runs client-side.
Pro Tip
If the page freezes or output stops scrolling, simply refresh the browser tab.
WebAssembly threads can sometimes crash under heavy debugging. Chrome tends to recover better than Firefox.
5. What You Can and Can’t Do
The demo is powerful, but it’s still a proof-of-concept. Here’s what currently works — and what doesn’t yet.
✅ Works perfectly
- Running basic shell commands (
ls,cat,pwd,echo) - Viewing system info and virtual files
- Exploring the virtual filesystem structure
- Experimenting safely — no risk to your PC
⚠️ Partially supported
- Simple file writes (temporary memory only)
- Multiple shell sessions (via browser tabs)
❌ Not yet available
- Internet networking
- Graphical interfaces (GUI)
- Persistent storage or disk saving
- Compiling programs
Still, the ability to boot a real Linux kernel in this environment is already a remarkable leap.
6. A Look Inside the Filesystem
So what kind of filesystem are you actually seeing?
Inside the environment is a virtual memory filesystem (tmpfs) — all files exist in browser memory. When you close the tab, everything disappears.
Try running:
ls /
You’ll see directories like:
bin dev etc home proc sys tmp usr
Each folder corresponds to a typical Linux structure, but they’re virtual. For instance:
/proccontains live kernel data (also virtualized)./syssimulates system information./binand/usr/bincontain BusyBox command utilities.
Even though these aren’t stored on disk, they behave the same way as they would on a real Linux system.
7. Behind the Scenes — The Boot Process
Let’s move deeper into the magic happening under the hood.
When you open the demo, here’s roughly what occurs:
- Browser loads the WebAssembly kernel module
The.wasmbinary (~50 MB) is downloaded and compiled just-in-time. - Initialization of memory space
WebAssembly allocates virtual memory using its linear memory model. - Kernel boots
The Linux 6.4.16 kernel initializes as if it were starting on real hardware. - Virtual devices
Joel implemented fake “devices” — a console, clock, and I/O stream — to satisfy Linux’s hardware calls. - Mount BusyBox user-space
The minimal user-space is loaded, providing the command-line tools. - Present interactive shell
Finally, you get the/ #prompt.
It’s like watching a tiny data center boot inside your browser tab — except the “hardware” is just software abstractions mapped to WebAssembly APIs.
8. Advanced Features — Developer Mode
If you’re curious about debugging or contributing, you can explore the source code itself.
Visit the GitHub project:
👉 GitHub Project: joelseverin/linux-wasm
There, you’ll find:
- Build scripts (
Makefile,build.sh) - Patches that add WebAssembly as a target architecture
- Kernel modifications for virtual console and syscall handling
- Open issues for upcoming features
You can even clone the repository and compile your own version using LLVM 18.1.2 and the WASI SDK.
For those interested in kernel development, Joel’s detailed explanation is archived here:
📩 Kernel Mailing List Announcement
9. Troubleshooting and Tips
Let’s go over some common questions new users might face.
Q 1. The demo doesn’t load at all.
Ensure your browser supports WebAssembly threads. Update Chrome or Edge to the latest version. If using Firefox, enable
dom.postMessage.sharedArrayBuffer.bypassCOOP_COEPinabout:config.
Q 2. I get “stuck” during boot.
Refresh the page. Some systems delay execution when CPU load spikes.
Q 3. Can I save files?
Not yet. The filesystem is volatile and exists only in browser memory.
Q 4. Does it work offline?
Yes, once cached — but the first load requires internet to fetch binaries.
Q 5. Is it dangerous to run?
No. Everything runs inside the browser’s secure sandbox; it cannot access your local drives or data.
10. Understanding “No VM, No Cloud, Just WebAssembly”
In Part 1 we explored this phrase conceptually, but using the demo makes it real.
Unlike a virtual machine, there’s no hidden hypervisor or OS overhead.
Unlike a cloud instance, there’s no server sending back responses.
This is pure local execution — WebAssembly acting as a tiny, universal CPU architecture.
Every time you type ls or echo, your browser executes Linux kernel code directly, just translated into WebAssembly bytecode.
It’s an entirely new paradigm — the operating system as a web app.
11. Comparing Cloud Linux vs WebAssembly Linux
| Feature | Cloud-based Linux (e.g., AWS, Google Cloud) | Browser-based Linux (WebAssembly) |
|---|---|---|
| Execution Location | Remote data center | Your local browser |
| Latency | Network dependent | Near-instant (local CPU) |
| Offline Access | ❌ Needs Internet | ✅ Works after cache |
| Security Model | Server sandbox & account permissions | Browser sandbox & memory isolation |
| Cost | Pay for resources | Completely free |
| Ease of Use | Requires setup & SSH | Open a tab and type |
| Persistence | Full disk storage | Volatile memory only |
| Use Case | Hosting, servers | Education, learning, sandbox testing |
| Tagline | “Linux in the cloud.” | “No VM, No Cloud, Just WebAssembly.” |
12. Educational and Research Potential
This project isn’t just a toy — it could transform how people learn and teach Linux.
- Students can practice commands without installations or risk.
- Developers can demonstrate system-level behavior during lectures.
- Researchers can analyze kernel behavior in a completely isolated environment.
Imagine online courses embedding an interactive Linux terminal that boots instantly, runs locally, and resets with one click.
It removes one of the biggest barriers for beginners: setup complexity.
13. Extending the Project — For Enthusiasts
If you’re curious about experimenting further:
- Clone the repo:
git clone https://github.com/joelseverin/linux-wasm.git cd linux-wasm - Build using LLVM 18+ and WASI SDK:
make - Launch via a local HTTP server:
python3 -m http.server 8080 - Open http://localhost:8080 in Chrome.
This rebuilds the kernel yourself — giving full transparency into how Linux transforms into a WebAssembly target architecture.
14. Future Possibilities
The current version is only the foundation. With community help, we could soon see:
- Persistent storage via IndexedDB
- Networking support using WebSockets
- GUI interfaces via WebGL or virtual framebuffer
- Performance optimization using multi-threaded WASM
It’s an open door for innovation — one that could redefine lightweight computing and embedded learning environments.
15. Final Thoughts
What started as a weekend curiosity turned into one of the most remarkable experiments in open-source history.
Joel Sever’s Linux-on-WebAssembly project proves that the future of computing might not lie in more hardware, but in more efficient abstraction.
Open your browser, watch the kernel boot, and think about what’s really happening:
an operating system once confined to servers now lives inside your web tab.
No VM.
No Cloud.
Just WebAssembly.
References
- Live Demo: https://joelseverin.github.io/linux-wasm/
- GitHub Project: https://github.com/joelseverin/linux-wasm
- Kernel Mailing List Announcement: https://lore.kernel.org/lkml/618f3602-03aa-46a8-b2d4-3c9798c4cd2b@icemanor.se/
#Linux #WebAssembly #WASM #OpenSource #Technology #Tutorial #LinuxInBrowser #NoVMNoCloud #FutureComputing
