O Linux 0.11 foi o kernel que transformou um passatempo de estudante no sistema operativo mais importante do planeta. Trinta e cinco anos depois, alguém reescreveu-o em Rust do zero.
O Poseidon-fan pegou no código do Linux 0.11 — a versão de 1991, quando o Linus ainda usava assembly e C K&R — e reimplementou-o em Rust idiomático. O resultado não é uma tradução linha-a-linha. É uma reinterpretação que aproveita o sistema de tipos, a segurança de memória e os traços (traits) do Rust para expressar o kernel de uma forma que o original simplesmente não conseguia.
O projeto não é pequeno: kernel, uma biblioteca user-space ao estilo da std do Rust, mais de oitenta coreutils e uma shell própria. Tudo a bootar num emulador i386 no QEMU.
Neste artigo vou explorar o que este projeto significa — não só para quem gosta de Rust, mas para quem quer perceber como é que um kernel arranca, e como é que as ideias de 1991 se comparam com as de hoje.
De Volta a 1991
O Linux 0.11 foi lançado em dezembro de 1991, cinco meses depois do anúncio original do Linus no grupo comp.os.minix. Era um kernel minúsculo para os padrões de hoje — corria em 386, não tinha rede, suportava apenas o filesystem Minix v1, e a maior parte do código estava em assembly e C à moda antiga.
Mas já tinha o essencial: processos, memória virtual, um sistema de ficheiros funcional, e uma consola.
Foi a base de tudo o que veio a seguir.
O projeto linux-0.11-rs não se limita a recriar esse kernel. Usa-o como especificação — uma referência de comportamento — para construir um sistema equivalente, mas escrito com as ferramentas de hoje.
O Que o Projeto Faz
O repositório está organizado em várias componentes:
- Kernel — processos, memória virtual com demand paging e copy-on-write no fork, filesystem Minix v1, driver de disco ATA, consola VGA, porta série 8250, camada TTY, sinais, e a tabela de syscalls completa.
- user_lib — uma biblioteca ao estilo da
stddo Rust, comfs,io,path,env,process,time. Os programas de user-space escrevem-se como Rust normal, não como chamadas de sistema embrulhadas à pressa. - Mais de 80 coreutils — incluindo uma shell (
sh) que suporta pipes, controlo de fluxo, funções, glob, substituição de comandos e aritmética, e um editor de linha interativo com histórico e tab completion. - Testes end-to-end — o QEMU arranca o kernel e uma framework de testes (ktest) conduz a consola série com scripts, validando o comportamento do sistema completo.
Tudo isto cabe num comando:
cd kernel && make run
E aparece um prompt.
Porque é Que Isto Importa
Há vários ângulos para olhar para este projeto.
O primeiro é o valor educativo. O Linux 0.11 é pequeno o suficiente para uma pessoa perceber o kernel inteiro. Mas o código original está em C e assembly de 1991 — denso, cheio de macros, com comentários que fazem sentido para quem já sabe o que está a fazer. Uma versão em Rust, com tipos fortes, módulos bem definidos, e abstrações modernas, é muito mais legível para quem está a aprender.
O segundo é a demonstração de que Rust funciona em sistemas bare-metal. Não é um kernel experimental que corre num ambiente académico. É o Linux 0.11 — que já correu em máquinas reais — reescrito e funcional. O projeto prova que Rust consegue substituir C na camada mais baixa do sistema sem perder performance nem controlo.
O terceiro é a nostalgia. Há algo de especial em ver o login prompt do Linux 0.11 a aparecer num terminal trinta e cinco anos depois. E ver que esse prompt vem de código Rust — uma linguagem que nem sequer existia quando o Linus escreveu as primeiras linhas — é um lembrete de como a engenharia de software evoluiu.
Uma Nova Camada de Abstração
Uma das decisões mais interessantes do projeto foi a biblioteca user_lib. Em vez de expor as syscalls diretamente, o Poseidon-fan criou uma API que imita a std do Rust. Isto significa que programas de user-space se escrevem como Rust normal — fs::read_to_string, process::Command, io::Write — e a biblioteca trata do resto.
Isto não é um pormenor de implementação. É uma declaração de intenções: o kernel não é só para ser usado, é para ser programado. E programar um sistema operativo deve ser tão natural quanto programar uma aplicação.
A shell (sh) é outro exemplo. Suporta for loops, if/else, funções, $(()) para aritmética, tab completion, e histórico com setas. Para um sistema embebido num emulador i386, é impressionante.
O Estado Atual
O projeto está funcional. O kernel está substancialmente completo em relação ao Linux 0.11 original. A biblioteca de user-space cobre o que a shell e os coreutils precisam. E o sistema é usável para trabalho interativo real.
O que falta? Polimento e ferramentas. Suporte de disquetes está fora de escopo (ninguém usa disquetes há vinte anos). Há um tutorial em progresso (em mdbook) que promete ser um walkthrough completo de construção do zero.
Tudo está licenciado sob GPL-2.0, como o original.
Conclusão
O linux-0.11-rs é mais do que um exercício de tradução de C para Rust. É uma ponte entre duas eras do desenvolvimento de sistemas — o minimalismo funcional dos anos 90 e a expressividade tipada dos anos 20.
Para quem trabalha com sistemas operativos, é uma oportunidade de estudar um kernel clássico sem ter de decifrar assembly. Para quem gosta de Rust, é uma demonstração do que a linguagem consegue fazer no limite. E para quem simplesmente gosta de tecnologia, é uma viagem no tempo — ao início de tudo, reescrito para o presente.
Eu já testei. O prompt aparece, os comandos correm, e o sistema responde. Trinta e cinco anos depois, o Linux 0.11 ainda funciona. Agora em Rust.
Comentários (0)
Nenhum comentário ainda. Seja o primeiro!
Deixar comentário