⏱️ Lectura: 11 min
Unkernel es un kernel Linux real que arranca dentro del navegador en menos de un segundo, compilado entero a WebAssembly junto con sus syscalls, planificador y el sistema de archivos ext4, sin animaciones ni terminales simuladas. Eso le importa a quien mantiene documentación o un onboarding con un botón de «probalo ahora»: en vez de depender de una VM o un contenedor corriendo en un servidor, la demo corre entera del lado del cliente, en la misma pestaña donde el usuario la ve.
📑 En este artículo
- Un kernel Linux real, compilado entero a WebAssembly
- Demos interactivas sin servidor: a quién le cambia algo unkernel
- Qué tan rápido arranca unkernel, según sus propios números
- El build se rompe con Node 18: lo que probamos en nuestro sandbox
- unkernel frente a otras formas de llevar Linux al navegador
- Limitaciones de hoy: de Node 24 a la licencia GPL-2.0
- Preguntas frecuentes sobre unkernel
- Referencias
El proyecto es de pithings y vive en GitHub bajo licencia GPL-2.0, escrito mayormente en TypeScript según la etiqueta de lenguaje principal de GitHub; la última versión publicada es v0.2.0-261121-e69adda, del 21 de noviembre de 2026. Esto es lo que encontramos al revisarlo y probar su build en un sandbox propio.
Un kernel Linux real, compilado entero a WebAssembly
La diferencia central está en la palabra “compilado”. El kernel (syscalls, planificador, gestión de memoria, ext4, la pila TCP/IP) es código compilado, no emulado, así que los programas ven el comportamiento real de Linux hasta en los casos límite. Lo único que se emula son los programas de usuario: binarios aarch64 sin modificar, por lo que los paquetes de Alpine y Debian corren tal cual.
Eso incluye una MMU real, con tablas de páginas Sv39 bajo arch/wasm: fork, mmap, copy-on-write, memoria compartida, hilos y señales se comportan como en hardware. El propio repositorio lo remarca: “This is not a NOMMU port where programs are limited to vfork”. También monta ext4, overlayfs, tmpfs, loop devices, FUSE y 9p, y trae su propia pila TCP/IP con DHCP y DNS.
flowchart TD
A["Navegador o Node.js"] --> B["Módulo WebAssembly: kernel Linux 7.x"]
B --> C["MMU real (Sv39), syscalls y planificador"]
B --> D["ext4, overlayfs y pila TCP/IP"]
C --> E["JIT: aarch64 a wasm"]
E --> F["Binarios Alpine o Debian sin modificar"]
El código está organizado en carpetas separadas para el núcleo, el runtime de invitado, los bindings de JavaScript y las pruebas (kernel/, guest/, js/, test/), con build.zig y build.zig.zon en la raíz. Eso sugiere que el núcleo del kernel se compila con el toolchain de Zig hacia wasm, aunque GitHub etiqueta TypeScript como lenguaje principal, probablemente por el peso del SDK y las herramientas alrededor. El repositorio también incluye una carpeta .agents/ y un archivo AGENTS.md, señal de que el proyecto ya documenta cómo trabajan agentes de IA sobre su propio código.
Para dar escala: el historial del repositorio acumula 139 commits, con unas 993 estrellas y 52 forks al 2026-11-22, y el último push es de hoy mismo.
Demos interactivas sin servidor: a quién le cambia algo unkernel
Para alguien que mantiene documentación o un onboarding con un botón “probalo ahora”, hoy la opción habitual es una VM o un contenedor en un servidor, con el costo y la latencia de mantenerlo corriendo. Unkernel mueve esa demo entera al cliente: el kernel corre en la misma pestaña donde el usuario lo ve, sin ida y vuelta a un backend remoto.
La propia comunidad ya lo está pidiendo como funcionalidad: el issue #1 propone enlaces de “probalo” configurables con un archivo unkernel.json dentro del repo que se quiere mostrar, para que cualquier proyecto en GitHub o GitLab pueda sumar un botón así sin escribir su propio backend. El mismo modelo le sirve a quien enseña Linux desde cero, porque nadie instala una VM para seguir la clase, y a quien necesita aislar código no confiable para probarlo rápido, sin levantar infraestructura.
Qué significa esto para vos: si mantenés la documentación o el sitio de un CLI o una librería que corre en Linux aarch64, y hoy pagás por sandboxes de servidor solo para que alguien prueba tu-herramienta --help en el navegador, vale la pena evaluar la SDK de TypeScript de unkernel antes de renovar ese backend. La condición a revisar antes de migrar: que la demo sea liviana en CPU, comandos interactivos y no builds pesados, porque ahí es donde unkernel compite de verdad con una VM remota.
Qué tan rápido arranca unkernel, según sus propios números
El propio repositorio publica sus medidas de arranque: el kernel llega a /init unos 70 ms después de iniciar, y el prompt de Alpine aparece 0,3 s después de lanzar node. La página pesa unos 10 MB y Alpine arranca con 48 MiB de memoria de invitado.
Para los syscalls, el proyecto compara contra Linux nativo y contra qemu-system, que emula la CPU completa en lugar de compilarla:
| Operación | Nativo | unkernel (wasm) | qemu-system |
|---|---|---|---|
| getppid | ~110 ns | ~170 ns | ~1,7 µs |
| read de 64 bytes | ~160 ns | ~170 ns | no reportado |
| fork + exit + wait | ~70 µs | ~60 µs | ~1,2 ms |
El dato que llama la atención es el de fork: unkernel lo hace en unos 60 µs, más rápido que los ~70 µs nativos. Esos números se midieron el 2026-11-14, todavía con el espacio de usuario riscv64 con el que arrancó el proyecto; el camino dentro del kernel es el mismo, aclara el repositorio.
La otra pieza es un JIT para el código de usuario: las instrucciones aarch64 calientes, incluidas las de AES, PMULL y SHA que usa OpenSSL, se compilan a WebAssembly mientras corren. Con eso, un bucle de shell corre 1,6 veces más rápido y sort 2,3 veces más rápido que con el intérprete solo, y OpenSSL hace AES-128-GCM a unos 100 MB/s y SHA-256 a unos 160 MB/s; estas cifras del JIT se midieron el 2026-11-18.
Lo que no mejora tanto es el trabajo intensivo en CPU: un apk search sobre el índice principal tarda unos 0,8 s y un apk add python3 unos 3,4 s, según el propio proyecto. Para ese tipo de carga, la ventaja frente a una VM remota se achica bastante.
El build se rompe con Node 18: lo que probamos en nuestro sandbox
Clonamos el repositorio e intentamos compilarlo en un sandbox aislado, con Node v18.20.4, npm 9.2.0 y git 2.39.5. El clon y la instalación de dependencias (35 paquetes) terminaron bien, en 1,307 s y 7,658 s respectivamente, con un pico de memoria de 203,6 MB durante el 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
El install ya avisó, sin bloquear nada, que el package.json pide Node 24 o superior para unkernel, rolldown, rolldown-plugin-dts, dts-resolver y get-tsconfig. El build sí rompió, porque Node 18 no resuelve una importación que usa rolldown:
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
No es un fallo del proyecto: es exactamente lo que el package.json advierte y nosotros ignoramos a propósito para medir qué tan duro era el límite. Si tu pipeline de CI todavía fija Node 18 o 20 LTS para otros proyectos, compilar unkernel desde el código fuente no va a funcionar sin actualizar esa imagen primero.
unkernel frente a otras formas de llevar Linux al navegador
Dentro del nicho de correr un sistema completo en wasm, el diferencial que el propio repositorio reivindica es la MMU real. Existen ports de kernels a WebAssembly limitados a NOMMU, donde los programas solo pueden usar vfork y no hay copy-on-write completo; unkernel no es uno de esos, según su propia documentación.
| Aspecto | unkernel | Ports wasm tipo NOMMU | v86 / WebVM (CheerpX) |
|---|---|---|---|
| Qué corre | Kernel Linux 7.x real, con binarios aarch64 sin modificar | Kernel adaptado sin gestión de memoria completa | Instrucciones x86 interpretadas o traducidas a wasm/JS |
| Memoria y procesos | MMU real (Sv39): fork, mmap, copy-on-write, hilos y señales como en hardware | Procesos limitados a vfork | Depende del emulador, no expone una MMU de Linux real |
| Arquitectura de usuario | aarch64, con JIT para código caliente | Variable según el port | x86 o x86_64 |
| Dónde corre | 100% en el navegador o en Node, sin servidor | Depende del proyecto | 100% en el navegador |
v86, que interpreta instrucciones x86 en JavaScript, y WebVM de Leaning Technologies, con su motor CheerpX que compila x86 a wasm, resuelven un problema parecido: meter un sistema completo dentro de la pestaña del navegador. No tenemos benchmarks propios ni del ResearchBundle para compararlos cabeza a cabeza con unkernel, así que la diferencia que sí podemos sostener con fuente es la arquitectónica: esos proyectos emulan una CPU de escritorio clásica, mientras unkernel compila un kernel aarch64 real con una MMU completa.
En la discusión de Hacker News sobre el lanzamiento, el comentario de skybrian apunta en una dirección relacionada: según su experiencia, escribir intérpretes rápidos es un caso de uso de nicho que la mayoría de los runtimes no optimiza bien, con tipos de unión poco eficientes en el camino crítico. Es un argumento a favor de por qué el JIT de unkernel, compilar aarch64 a wasm en caliente en vez de interpretar, importa más de lo que parece para el rendimiento real.
Limitaciones de hoy: de Node 24 a la licencia GPL-2.0
La primera limitación la encontramos nosotros: compilar el proyecto desde el código fuente hoy exige Node 24 o superior, y con Node 18 el build falla antes de producir nada. El propio repositorio también mantiene su propia lista de límites conocidos, aunque no accedimos a su contenido más allá del enlace.
La comunidad ya reportó al menos una rareza concreta: el issue #4 describe que los comandos que empiezan con mayúscula hacen que el prompt no vuelva a responder, un bug todavía abierto. Y el trabajo pesado en CPU, instalar paquetes o compilar, sigue siendo más lento que en una máquina nativa, como ya vimos con apk add python3.
Por último, el kernel se distribuye bajo GPL-2.0. Si pensás embeberlo dentro de un producto propietario, esa licencia, y si el wasm que se distribuye cuenta como derivado a efectos de copyleft, es lo primero que hay que revisar con tu equipo legal antes de integrar el módulo, no después. El proyecto, además, recién va por su release v0.2.0: todavía es joven, aunque con actividad diaria.
Preguntas frecuentes sobre unkernel
¿unkernel corre binarios x86 o x86_64?
No. El espacio de usuario que emula es aarch64 (ARMv8) sin modificar: corre paquetes de Alpine o Debian compilados para esa arquitectura, no para x86_64.
¿Necesito un servidor para usarlo?
No. Todo corre del lado del cliente, en el navegador o en Node, sin backend ni instalación: la SDK de TypeScript expone el mismo archivo de kernel que corre en ambos entornos, incluso dentro de un worker.
Referencias
- pithings/unkernel: repositorio y documentación oficial del proyecto.
- Release v0.2.0-261121-e69adda: última versión publicada, del 21 de noviembre de 2026.
- Issue #1: propuesta de enlaces “probalo” vía
unkernel.json. - Issue #4: bug abierto con comandos que empiezan en mayúscula.
- Comentario de skybrian en Hacker News: discusión sobre el rendimiento de intérpretes frente a JIT.
Seguimos el tema en @programacion.
Imagen destacada: Foto de Xavier Cee en Unsplash
Así preparamos cada artículo (fuentes, pruebas y criterio editorial): Cómo trabajamos.
¿Te sirvió? ¿Te dio otro error? Contalo abajo: las preguntas se responden y le sirven al siguiente que llegue.
Dejar un comentario
0 Comentarios