Shopping cart

Subtotal $0.00

View cartCheckout

Building better devs

TnewsTnews
Programação

Linux no Browser: Kernel Real, apt-get e Zero Servidores

Email : 11

Abra uma aba do Chrome. Digite um endereço. Em menos de um segundo, você tem um terminal Linux completo rodando no seu navegador. Não é uma simulação. Não é um container remoto. É o kernel Linux 7.x de verdade, compilado para WebAssembly, executando localmente na sua máquina. Sem backend, sem servidor, sem Docker.

O projeto se chama unkernel, apareceu no GitHub há poucos dias e já está gerando discussões acaloradas na comunidade. E eu entendo o motivo: a ideia de rodar um sistema operacional inteiro dentro de uma aba do navegador soa como ficção científica. Só que funciona. E funciona bem.

O que exatamente é o unkernel?

O unkernel pega o código-fonte do kernel Linux (versão 7.x), compila tudo para um único módulo WebAssembly e empacota junto com um userland Alpine ou Debian. O resultado é um arquivo .wasm que roda em qualquer navegador moderno ou no Node.js.

Quando digo “tudo”, é tudo mesmo. Syscalls, scheduler, gerenciamento de memória, sistema de arquivos ext4, stack TCP/IP. Nada disso é emulado ou reimplementado em JavaScript. É o código C do kernel, compilado direto para WebAssembly.

Componente O que faz
— —
Kernel Linux 7.x Compilado para WebAssembly como módulo único
kwemu Emulador de CPU aarch64 escrito em Zig, linkado no kernel
JSPI Permite ao kernel suspender e resumir execução no browser
Userland Alpine ou Debian com shell, package manager e ferramentas

A diferença para projetos anteriores como o v86 é brutal. O v86 emula um processador x86 inteiro em JavaScript para depois rodar o Linux em cima. O unkernel pula essa camada: o kernel roda nativamente como código WebAssembly. Programas do usuário rodam em cima do kwemu, um emulador aarch64 escrito em Zig que é linkado diretamente dentro do kernel.

A arquitetura por baixo dos panos

Vou ser honesto: a engenharia por trás disso é absurda. Vamos destrinchar.

kwemu: um CPU dentro do kernel

O kwemu é o coração do projeto. É um emulador de processador ARM64 (aarch64) escrito em Zig que roda programas de usuário. O detalhe genial: ele caminha pelas page tables do próprio kernel Linux. Ou seja, o gerenciamento de memória não é uma gambiarra separada. É o MMU do Linux de verdade, implementando page tables Sv39.

Quando um programa faz uma syscall, o kwemu devolve o controle para o kernel. O kernel processa a syscall como código WebAssembly nativo. Não existe mecanismo de trap emulado entre modo usuário e modo kernel.

JIT em duas camadas

Para performance, o kwemu usa um modelo de execução em dois níveis:


Primeira camada (interpretador):
  - Decodifica o código uma vez em operações intermediárias compactas
  - ~250-300 milhões de instruções guest por segundo
  - Roda código que executa poucas vezes

Segunda camada (JIT):
  - Código "quente" é compilado para módulos WebAssembly em runtime
  - Speedup de 1.6x a 2.3x sobre o interpretador
  - AES-128-GCM atinge ~100 MB/s
  - SHA-256 performa a ~160 MB/s

Esse modelo de duas camadas é a mesma estratégia usada pela JVM e pelo V8. Código frio roda no interpretador (rápido para iniciar), código quente é otimizado pelo JIT (rápido para executar). A diferença é que aqui estamos compilando código ARM64 para WebAssembly em tempo real, dentro de um navegador.

JSPI: a cola que faz tudo funcionar

Aqui entra uma peça fundamental do quebra-cabeça: o JSPI (JavaScript Promise Integration). Essa feature do WebAssembly, que atingiu Phase 4 em 2026, permite que código síncrono dentro de um módulo Wasm faça chamadas assíncronas para APIs do navegador sem bloquear a UI.

Na prática, quando o kernel precisa fazer I/O (ler um arquivo, acessar a rede), ele “pausa” sua execução via JSPI, o navegador processa a operação assíncrona, e quando o resultado chega, o kernel retoma de onde parou. É como se o kernel tivesse um await nativo, só que implementado no nível do WebAssembly.

O suporte a JSPI já está disponível no Chrome 137+, Firefox 153+, Safari 27+ e Edge 137+. Dois anos atrás, isso seria impossível.

Benchmarks que surpreendem

Os números de performance são o que mais chamam atenção. Veja a comparação de latência de syscalls:

Operação unkernel Linux nativo QEMU user QEMU system
— — — — —
getppid ~172 ns 110 ns 320 ns 1.662 ns
read(64 bytes) ~172 ns ~110 ns ~300 ns ~1.500 ns
fork + exit + wait ~57 µs 73 µs ~200 µs 1.178 µs

Leu certo. O fork + exit + wait do unkernel é mais rápido que o Linux nativo. 57 microsegundos contra 73 do nativo. Isso acontece porque o fork dentro do WebAssembly não precisa lidar com toda a complexidade de hardware real (TLB flushes, context switches de CPU física).

Para syscalls simples como getppid, o unkernel fica a ~56% da velocidade nativa, o que é extraordinário considerando que estamos falando de código rodando dentro de uma aba do navegador. E comparado com QEMU em modo system (a forma tradicional de emular Linux completo), o unkernel é quase 10x mais rápido.

Claro, trabalho intensivo de CPU puro ainda é mais lento que nativo. Um apk search leva ~0.8 segundos, apk add python3 demora ~3.4 segundos. Mas para a maioria dos casos de uso, é perfeitamente usável.

O que você consegue fazer (de verdade)

Não é uma demo de brinquedo. O unkernel roda funcionalidades que você esperaria de um Linux completo:

Sistema de arquivos: ext4, overlayfs, tmpfs, loop devices, FUSE e 9p. Seus arquivos persistem entre sessões usando IndexedDB do navegador.

Rede: A stack TCP/IP do Linux acessa a internet através de host sockets (no Node.js) ou um proxy Wisp no browser. DHCP e DNS funcionam nativamente.

Package manager: apk (Alpine) ou apt (Debian) funcionam. Você pode instalar Python, GCC, Node.js, o que precisar.

Dispositivos: Framebuffer (/dev/fb0), input via evdev, som via ALSA, AF_VSOCK para comunicação com o host.

Containers (sim, containers!): cgroups, namespaces, userfaultfd, fanotify, TUN. Funcionalidades suficientes para o systemd bootar Ubuntu até multi-user.target.


# Instalar no seu projeto via npm
npm install unkernel

# Ou rodar direto no terminal
npx unkernel shell

# Dentro do shell, é Linux normal
apk add python3
python3 -c "print('rodando no browser')"

Você leu certo: npm install te dá um kernel Linux. O mundo chegou num ponto estranho.

v86, WebVM e agora unkernel: qual a diferença?

Para quem acompanha esse espaço, vale contextualizar. Já existem outras formas de rodar Linux no browser:

v86: Emula um processador x86 completo em JavaScript/WebAssembly. Funciona, mas é lento. Cada instrução x86 passa por uma camada de tradução. Não suporta kernels 64-bit nem múltiplos cores emulados.

WebVM (CheerpX): Traduz instruções x86 e emula syscalls Linux. Mais rápido que o v86, mas ainda trabalha no nível de emulação de CPU.

unkernel: Compila o kernel diretamente para WebAssembly. Não emula CPU para o kernel, apenas para programas de usuário (via kwemu). Resultado: syscalls são ordens de magnitude mais rápidas.

Aspecto v86 WebVM unkernel
— — — —
Abordagem Emulação x86 completa Tradução x86 + syscall Kernel nativo Wasm
Arquitetura guest x86 (32-bit) x86/x86_64 aarch64
Kernel Emulado Emulado Compilado nativo
Performance syscall Lenta Média Próxima do nativo
Boot time Segundos Segundos < 1 segundo
Package manager Limitado Sim Sim (apk/apt)

A jogada do unkernel é que, ao compilar o kernel diretamente para WebAssembly, todas as operações do kernel (filesystem, rede, memória) rodam na velocidade do Wasm. Só os programas de usuário passam pelo emulador, e mesmo esses ganham com o JIT.

Casos de uso que fazem sentido

Beleza, é impressionante tecnicamente. Mas pra que serve na prática?

Ambientes de desenvolvimento instantâneos

Imagine um tutorial de programação onde o leitor clica num botão e tem um ambiente Linux completo pronto pra usar. Sem precisar instalar nada, sem configurar VM, sem esperar container subir. O unkernel boota em menos de um segundo.

Plataformas como Replit, Gitpod e CodeSpaces já oferecem algo parecido, mas dependem de servidores. Com unkernel, tudo roda no navegador do usuário. Zero custo de infraestrutura.

Educação

Ensinar Linux para iniciantes é complicado porque exige que o aluno configure um ambiente. Dual boot, VM, WSL… Tudo tem fricção. Um link que abre um Linux funcional no Chrome elimina toda essa barreira.

CI/CD e testes

O SDK TypeScript/JavaScript do unkernel permite embalar ambientes Linux inteiros em testes automatizados. Precisa testar um script bash em diferentes distribuições? Precisa validar que seu binário roda em ARM64? O unkernel pode fazer isso sem precisar de máquinas virtuais ou containers Docker.


import { Unkernel } from 'unkernel';

const vm = await Unkernel.boot({ distro: 'alpine' });
const result = await vm.exec('apk add python3 && python3 script.py');
console.log(result.stdout);
await vm.shutdown();

Aplicações offline-first

Como tudo roda localmente, sua aplicação Linux funciona sem conexão com a internet (depois do primeiro carregamento). O sistema de arquivos persiste via IndexedDB. Para ferramentas de desenvolvimento que precisam funcionar em qualquer lugar, isso é poderoso.

As limitações (porque sempre tem)

Não vou fingir que é perfeito. Existem limitações reais:

Single CPU por padrão. A versão web suporta múltiplas CPUs via Web Workers, mas a versão CLI roda em uma thread só.

Sem IPv6. UDP limitado a DHCP/DNS. Sem conexões de entrada (precisa usar vsock).

Sem ptrace. strace e gdb não funcionam. Se você precisa debuggar no nível de registradores, o unkernel não é pra você.

Floating-point no interpretador. Mesmo com o JIT ativo, operações de ponto flutuante passam pelo interpretador. Workloads pesados em float (machine learning, simulações numéricas) vão sofrer.

Networking limitada. No browser, a rede passa por um proxy Wisp porque navegadores não expõem sockets TCP/UDP raw. No Node.js, usa host sockets direto e funciona melhor.

Essas limitações fazem sentido dado o contexto. Estamos rodando um kernel dentro de um browser. O fato de que funciona tão bem apesar dessas restrições é o que impressiona.

O ecossistema WebAssembly em 2026

O unkernel não surgiu no vácuo. Ele só é possível porque o ecossistema WebAssembly amadureceu consideravelmente:

JSPI (Phase 4): Permite I/O assíncrono sem callback hell. Essencial para o kernel interagir com o browser.

Wasm Threads: Web Workers + SharedArrayBuffer permitem paralelismo real. O unkernel usa isso para multi-CPU na versão browser.

Garbage Collection (WasmGC): Embora o unkernel não use diretamente, o WasmGC pavimentou o caminho para linguagens com GC compilarem para Wasm, expandindo o ecossistema.

Component Model: A proposta de componentes WebAssembly está criando um padrão para módulos Wasm interoperarem. Isso pode permitir que diferentes “kernels” Wasm compartilhem recursos no futuro.

Chrome virou, efetivamente, um sistema operacional. Com WebGPU para GPU, WebCodecs para vídeo, File System Access API para disco, e agora JSPI para I/O síncrono, o navegador tem acesso a praticamente todos os recursos que um OS tradicional oferece.

Como experimentar agora

O projeto é open source (MIT) e já está disponível:


# Via npm (Node.js)
npm install unkernel
npx unkernel shell

# No browser
# Acesse unkernel.dev e abra um terminal

# Em projetos TypeScript/JavaScript
import { Unkernel } from 'unkernel';

const vm = await Unkernel.boot({
  distro: 'alpine',
  persist: true  // salva filesystem entre sessões
});

Requisitos de browser: Chrome 137+, Firefox 153+, Safari 27+, Edge 137+. Basicamente qualquer navegador atualizado em 2026 roda.

O kernel GPL-2.0 vem junto no pacote npm (sim, existe um kernel Linux distribuído via npm agora). As imagens de distribuição baixam do GitHub Releases no primeiro uso e ficam em cache local.

O que isso significa pro futuro

Eu fico pensando nas implicações de longo prazo. Se um Linux completo roda no browser, o que mais podemos compilar para Wasm? Bancos de dados? Servidores web? Compiladores?

Na real, já estamos vendo isso acontecer. SQLite roda em Wasm há anos. O LLVM já compila para Wasm. PostgreSQL tem ports experimentais. O unkernel é a prova de que até o componente mais fundamental de um sistema operacional pode viver dentro do navegador.

A pergunta que fica: se o browser pode ser o OS, por que ainda precisamos de um OS por baixo? Talvez, daqui a alguns anos, a resposta seja “não precisamos”. Ou talvez o unkernel continue sendo um hack genial que ninguém usa em produção. De qualquer forma, o fato de que existe já diz muito sobre onde a computação está indo.

O código está no GitHub do projeto e, se você é o tipo de dev que gosta de abrir o capô pra ver o motor, vale cada minuto de leitura.


Fonte de inspiração: unkernel – A real Linux kernel, compiled to WebAssembly (GitHub)

Leave a Reply

Your email address will not be published. Required fields are marked *

Related Posts