Rust Coreutils 0.6.0 lançado: A maturidade do “Linux em Rust” e o fim do código inseguro

Com a remoção do código unsafe e um salto massivo na compatibilidade, a versão 0.6.0 do uutils é o sinal mais claro de que o Rust está pronto para o coração do Linux.

Por
Emanuel Negromonte
Emanuel Negromonte é Jornalista, Mestre em Tecnologia da Informação e atualmente cursa a segunda graduação em Engenharia de Software. Com 14 anos de experiência escrevendo sobre...
6 min
Destaques
  • Segurança de memória, performance superior e 96% de compatibilidade com o padrão GNU.
  • O fim da era C? Rust Coreutils prova que segurança e velocidade podem andar juntas.
  • Mais seguro, mais rápido e quase pronto para assumir o controle do seu terminal.

O projeto uutils/coreutils acaba de atingir o marco da versão 0.6.0, consolidando-se como a implementação em Rust mais robusta das ferramentas básicas do sistema. Apresentada durante a FOSDEM 2026, esta atualização não é apenas incremental; ela resolve gargalos críticos de performance e segurança que impediam sua adoção em larga escala.

O que é e por que importa

O Coreutils é a espinha dorsal de qualquer sistema Linux. Comandos como ls, cp, mv e date são usados bilhões de vezes por dia em servidores e desktops. Tradicionalmente escritos em C (pela Free Software Foundation), esses utilitários estão sujeitos a falhas de memória que o Rust, por design, elimina.

O projeto uutils visa substituir esse código de 30 anos por uma versão moderna, segura e — em muitos casos — mais rápida, garantindo que o núcleo do sistema operacional esteja preparado para as exigências de segurança do século XXI.

O salto da compatibilidade: 96% e contando

A grande barreira para substituir o código clássico da GNU é a compatibilidade. Scripts de décadas dependem de comportamentos específicos de cada flag. A versão 0.6.0 alcançou um nível de paridade impressionante:

ResultadoVersão 0.5.0Versão 0.6.0Evolução
Passou566622+56 testes
Falhou5516-39 falhas
Pulado237-16 pulados
Total de Compatibilidade87.75%96.28%+8.53%

Com apenas 16 falhas restantes em mais de 600 testes, o uutils está a um passo de se tornar o padrão absoluto, eliminando o medo de que scripts legados “quebrem” ao migrar para Rust.

Performance: Onde o Rust já vence o C

A narrativa de que “Rust é mais lento que C” está sendo desmistificada na prática. Graças a otimizações de baixo nível e ao gerenciamento inteligente de buffers, vários utilitários agora superam seus equivalentes originais:

  • base64 & base32: Graças à redução de operações memset, o utilitário Rust agora é cerca de 1.5x mais rápido que a versão GNU original.
  • shuf: A geração de números aleatórios e a saída numérica foram otimizadas para evitar alocações desnecessárias, tornando-o ideal para processamento de grandes volumes de dados.
  • A “Redenção” do cksum: Em versões anteriores de teste, o cksum em Rust chegou a ser 17x mais lento em arquivos grandes. A versão 0.6.0 resolve isso completamente, unificando a lógica com o motor de hash otimizado do hashsum.

O “Caso Ubuntu” e a repercussão externa

Esta atualização chega em um momento de alta tensão política na comunidade Linux. A Canonical escolheu o Rust Coreutils como padrão nas versões de desenvolvimento do Ubuntu 25.10, servindo como o “campo de testes” definitivo.

O bug da atualização automática

Recentemente, o Ubuntu enfrentou um problema grave onde as atualizações automáticas pararam de funcionar. O culpado? Um bug no comando date do uutils que não interpretava corretamente a flag --reference.

  • A Solução na 0.6.0: Esta versão foca massivamente no date, corrigindo o suporte a locales e referências de arquivos, o que deve estabilizar o sistema de updates do Ubuntu para a próxima versão 26.04 LTS.

Repercussão no Reddit e Hacker News

Enquanto entusiastas elogiam o “fim do código unsafe”, críticos no Hacker News argumentam que a substituição de ferramentas estáveis por versões em Rust é um “marketing de segurança” que pode introduzir bugs lógicos. No entanto, o consenso técnico é que a detecção de erros de lógica é mais fácil do que a caça a vazamentos de memória (memory leaks) e buffers overflows, justificando o esforço de oxidação do Linux.

Bastidores técnicos: Adeus ao unsafe

Para os desenvolvedores, o maior orgulho da 0.6.0 é a limpeza do código. O Rust permite escrever blocos unsafe para performance extrema ou interação direta com o sistema, mas isso anula parte de suas vantagens.

  • Desminagem de código: Utilitários complexos como sort, date e as bibliotecas de locale.rs tiveram quase todo o código inseguro removido.
  • Abstração com nix: Em vez de falar diretamente com a libc do C, o projeto agora usa a crate nix, que atua como uma camada de segurança adicional entre o utilitário e o kernel do Linux.

Resumo técnico (Changelog)

  • Locales Modernos: Implementação do suporte a ICU para calendários e ordenação numérica ciente de regiões (milhares/decimais).
  • Segurança SMACK: Suporte ao módulo de segurança SMACK para comandos como mkdir, mkfifo e ls.
  • Novas Arquiteturas: Otimização para RISC-V 64-bit musl, garantindo que o Rust Coreutils rode em hardware de baixo custo e arquiteturas abertas.
  • Correções em tail: Adição da flag --debug e correções no rastreamento de links simbólicos com -F.

Disponibilidade

  • Ubuntu: Já disponível via PPA para testadores do 25.10 e 26.04.
  • Arch Linux: Atualização iminente nos repositórios extra e AUR.
  • Fedora: Esperado para o Fedora 44 como opção instalável.
  • Compilação Manual: Através do Cargo com cargo install coreutils.
Compartilhe este artigo
Sair da versão mobile