⏱️ Reading time: 9 min
Unkernel is a real Linux kernel that boots inside the browser in under a second, compiled entirely to WebAssembly along with its syscalls, scheduler and ext4 filesystem, with no animations or simulated terminals. That matters to anyone who maintains documentation or an onboarding flow with a “try it now” button: instead of depending on a VM or a container running on a server, the demo runs entirely on the client side, in the same tab where the user sees it.
📑 En este artículo
- A real Linux kernel, compiled entirely to WebAssembly
- Server-free interactive demos: who unkernel actually changes things for
- How fast unkernel boots, according to its own numbers
- The build breaks on Node 18: what we tested in our sandbox
- Unkernel compared to other ways of bringing Linux to the browser
- Current limitations: from Node 24 to the GPL-2.0 license
- Frequently Asked Questions about unkernel
- References
The project comes from pithings and lives on GitHub under the GPL-2.0 license, written mostly in TypeScript according to GitHub’s primary language tag; the latest published release is v0.2.0-261121-e69adda, from November 21, 2026. Here is what we found reviewing it and testing its build in our own sandbox.
A real Linux kernel, compiled entirely to WebAssembly
The core difference is in the word “compiled”. The kernel (syscalls, scheduler, memory management, ext4, the TCP/IP stack) is compiled code, not emulated, so programs see real Linux behavior even in edge cases. The only thing that gets emulated is user-space programs: unmodified aarch64 binaries, so Alpine and Debian packages run as-is.
That includes a real MMU, with Sv39 page tables under arch/wasm: fork, mmap, copy-on-write, shared memory, threads and signals behave as they do on hardware. The repository itself points this out: “This is not a NOMMU port where programs are limited to vfork”. It also mounts ext4, overlayfs, tmpfs, loop devices, FUSE and 9p, and ships its own TCP/IP stack with DHCP and DNS.
flowchart TD
A["Browser or Node.js"] --> B["WebAssembly module: Linux 7.x kernel"]
B --> C["Real MMU (Sv39), syscalls and scheduler"]
B --> D["ext4, overlayfs and TCP/IP stack"]
C --> E["JIT: aarch64 to wasm"]
E --> F["Unmodified Alpine or Debian binaries"]
The code is organized into separate folders for the kernel core, the guest runtime, the JavaScript bindings and the tests (kernel/, guest/, js/, test/), with build.zig and build.zig.zon at the root. That suggests the kernel core is compiled with the Zig toolchain to wasm, even though GitHub tags TypeScript as the primary language, likely because of the weight of the SDK and the tooling around it. The repository also includes a .agents/ folder and an AGENTS.md file, a sign that the project already documents how AI agents work on its own code.
For scale: the repository’s history has 139 commits, with about 993 stars and 52 forks as of 2026-11-22, and the latest push is from today.
Server-free interactive demos: who unkernel actually changes things for
For someone maintaining documentation or an onboarding flow with a “try it now” button, the usual option today is a VM or a container on a server, with the cost and latency of keeping it running. Unkernel moves that entire demo to the client: the kernel runs in the same tab where the user sees it, with no round trip to a remote backend.
The community is already requesting this as a feature: issue #1 proposes configurable “try it” links via an unkernel.json file inside the repo being showcased, so any project on GitHub or GitLab can add a button like that without writing its own backend. The same model works for anyone teaching Linux from scratch, since nobody has to install a VM to follow along, and for anyone who needs to sandbox untrusted code to test it quickly, without spinning up infrastructure.
What this means for you: if you maintain the documentation or the site for a CLI or a library that runs on Linux aarch64, and you currently pay for server sandboxes just so someone can try your-tool --help in the browser, it is worth evaluating unkernel’s TypeScript SDK before renewing that backend. The condition to check before migrating: the demo needs to be CPU-light, interactive commands rather than heavy builds, because that is where unkernel genuinely competes with a remote VM.
How fast unkernel boots, according to its own numbers
The repository itself publishes its boot measurements: the kernel reaches /init about 70 ms after starting, and the Alpine prompt appears 0.3 s after launching node. The page weighs about 10 MB, and Alpine boots with 48 MiB of guest memory.
For syscalls, the project compares against native Linux and against qemu-system, which emulates the full CPU instead of compiling it:
| Operation | Native | unkernel (wasm) | qemu-system |
|---|---|---|---|
| getppid | ~110 ns | ~170 ns | ~1.7 µs |
| 64-byte read | ~160 ns | ~170 ns | not reported |
| fork + exit + wait | ~70 µs | ~60 µs | ~1.2 ms |
The number that stands out is fork: unkernel does it in about 60 µs, faster than the ~70 µs native figure. Those numbers were measured on 2026-11-14, still with the riscv64 userspace the project launched with; the in-kernel path is the same, the repository clarifies.
The other piece is a JIT for user-space code: hot aarch64 instructions, including the AES, PMULL and SHA ones OpenSSL uses, get compiled to WebAssembly while they run. With that, a shell loop runs 1.6 times faster and sort 2.3 times faster than with the interpreter alone, and OpenSSL does AES-128-GCM at about 100 MB/s and SHA-256 at about 160 MB/s; these JIT figures were measured on 2026-11-18.
What does not improve as much is CPU-intensive work: an apk search over the main index takes about 0.8 s and an apk add python3 about 3.4 s, according to the project itself. For that kind of workload, the advantage over a remote VM shrinks considerably.
The build breaks on Node 18: what we tested in our sandbox
We cloned the repository and tried to compile it in an isolated sandbox, with Node v18.20.4, npm 9.2.0 and git 2.39.5. The clone and the dependency install (35 packages) both finished fine, in 1.307 s and 7.658 s respectively, with a peak memory of 203.6 MB during the install.
git -c protocol.allow=never -c protocol.https.allow=always -c core.hooksPath=/dev/null clone --depth 1 --single-branch --no-tags -- https://github.com/pithings/unkernel /tmp/lab-runs/lab-ptytulm4/w/repo
npm install --no-audit --no-fund
npm run build
The install already warned, without blocking anything, that package.json requires Node 24 or higher for unkernel, rolldown, rolldown-plugin-dts, dts-resolver and get-tsconfig. The build did break, because Node 18 cannot resolve an import that rolldown uses:
file:///tmp/lab-runs/lab-ptytulm4/w/repo/node_modules/rolldown/dist/shared/validator-DzeDk-lR.mjs:1
import { styleText as styleText$1 } from "node:util";
^^^^^^^^^
SyntaxError: The requested module 'node:util' does not provide an export named 'styleText'
at ModuleJob._instantiate (node:internal/modules/esm/module_job:123:21)
at async ModuleJob.run (node:internal/modules/esm/module_job:191:5)
at async ModuleLoader.import (node:internal/modules/esm/loader:337:24)
at async loadESM (node:internal/process/esm_loader:34:7)
at async handleMainPromise (node:internal/modules/run_main:106:12)
Node.js v18.20.4
This is not a bug in the project: it is exactly what package.json warns about, and we ignored it on purpose to measure how hard that limit was. If your CI pipeline still pins Node 18 or 20 LTS for other projects, compiling unkernel from source will not work without updating that image first.
Unkernel compared to other ways of bringing Linux to the browser
Within the niche of running a full system in wasm, the differentiator the repository itself claims is the real MMU. There are kernel-to-WebAssembly ports limited to NOMMU, where programs can only use vfork and there is no full copy-on-write; unkernel is not one of those, according to its own documentation.
| Aspect | unkernel | NOMMU-style wasm ports | v86 / WebVM (CheerpX) |
|---|---|---|---|
| What runs | Real Linux 7.x kernel, with unmodified aarch64 binaries | Adapted kernel without full memory management | x86 instructions interpreted or translated to wasm/JS |
| Memory and processes | Real MMU (Sv39): fork, mmap, copy-on-write, threads and signals as on hardware | Processes limited to vfork | Depends on the emulator, does not expose a real Linux MMU |
| User architecture | aarch64, with JIT for hot code | Varies by port | x86 or x86_64 |
| Where it runs | 100% in the browser or in Node, no server | Depends on the project | 100% in the browser |
v86, which interprets x86 instructions in JavaScript, and Leaning Technologies’ WebVM, with its CheerpX engine that compiles x86 to wasm, solve a similar problem: fitting a complete system inside the browser tab. We do not have our own benchmarks, nor any from the ResearchBundle, to compare them head-to-head with unkernel, so the difference we can actually back with a source is architectural: those projects emulate a classic desktop CPU, while unkernel compiles a real aarch64 kernel with a complete MMU.
In the Hacker News discussion about the launch, a comment from skybrian points in a related direction: in their experience, writing fast interpreters is a niche use case that most runtimes do not optimize well, with inefficient union types in the hot path. It is an argument for why unkernel’s JIT, compiling aarch64 to wasm on the fly instead of interpreting, matters more than it seems for real-world performance.
Current limitations: from Node 24 to the GPL-2.0 license
We found the first limitation ourselves: compiling the project from source today requires Node 24 or higher, and on Node 18 the build fails before producing anything. The repository itself also keeps its own list of known limitations, though we did not access its content beyond the link.
The community has already reported at least one concrete quirk: issue #4 describes how commands starting with an uppercase letter make the prompt stop responding, a bug that is still open. And CPU-heavy work, installing packages or compiling, is still slower than on a native machine, as we already saw with apk add python3.
Finally, the kernel is distributed under GPL-2.0. If you are thinking about embedding it inside a proprietary product, that license, and whether the distributed wasm counts as a derivative for copyleft purposes, is the first thing to check with your legal team before integrating the module, not after. The project is also only at release v0.2.0 so far: it is still young, though with daily activity.
Frequently Asked Questions about unkernel
Does unkernel run x86 or x86_64 binaries?
No. The userspace it emulates is unmodified aarch64 (ARMv8): it runs Alpine or Debian packages compiled for that architecture, not for x86_64.
Do I need a server to use it?
No. Everything runs on the client side, in the browser or in Node, with no backend or installation: the TypeScript SDK exposes the same kernel file that runs in both environments, even inside a worker.
References
- pithings/unkernel: the project’s official repository and documentation.
- Release v0.2.0-261121-e69adda: the latest published release, from November 21, 2026.
- Issue #1: proposal for configurable “try it” links via
unkernel.json. - Issue #4: open bug with commands that start with an uppercase letter.
- skybrian’s comment on Hacker News: discussion on interpreter performance versus JIT.
Featured image: Foto de Xavier Cee en Unsplash
How each article is made (sources, testing and editorial criteria): How we work.
Did it work for you? Got a different error? Say so below: questions get answered and help the next reader.
Leave a comment
0 Comments