Foi lançado o Rust 1.84, uma linguagem de programação de propósito geral originada pelo projeto Mozilla, atualmente desenvolvida sob a supervisão da organização independente e sem fins lucrativos Rust Foundation. A linguagem foca na segurança do gerenciamento de memória e oferece ferramentas para alcançar alta paralelização de tarefas, sem a necessidade de um coletor de lixo e runtime (o runtime é reduzido à inicialização básica e ao suporte da biblioteca padrão).
Os métodos de manipulação de memória em Rust protegem o desenvolvedor de erros ao trabalhar com ponteiros e evitam problemas decorrentes de manipulação de memória de baixo nível, como acesso a áreas de memória após sua liberação, desreferenciação de ponteiros nulos, e estouro de buffer, entre outros. Para distribuição de bibliotecas, construção e gerenciamento de dependências, o projeto conta com o gerenciador de pacotes Cargo. O repositório crates.io é suportado para hospedagem de bibliotecas.
A manipulação segura da memória em Rust é garantida em tempo de compilação através da verificação de referências, rastreamento de propriedade de objetos, controle do tempo de vida dos objetos (escopos) e avaliação da correção do acesso à memória durante a execução do código. Rust também oferece mecanismos para proteção contra estouros inteiros, exige a inicialização obrigatória de valores de variáveis antes do uso, trata erros de forma superior na biblioteca padrão, aplica o conceito de referências e variáveis imutáveis (immutable) por padrão e oferece uma forte tipagem estática para minimizar erros lógicos.
Principais novidades:
- No gerenciador de pacotes Cargo, foi estabilizado um mecanismo de gerenciamento de dependências que seleciona versões de componentes dependentes levando em consideração a compatibilidade com as versões do compilador Rust, definidas como minimamente suportadas pelo projeto (MSRV, Minimum Supported Rust Version). A nova funcionalidade permite que os mantenedores não precisem escolher manualmente versões antigas de cada dependência em projetos que mantêm compatibilidade com versões anteriores do ambiente Rust. O novo modo de definição de dependências será ativado por padrão na versão Rust 1.85, mas enquanto isso está disponível como uma opção, que deve ser ativada na seção '[resolver]' no arquivo '.cargo/config.toml' indicando 'incompatible-rust-versions = "fallback"'.
- Foi iniciado o trabalho de tradução do compilador para um novo resolvedor de tipos (trait solver), destinado a verificar os limites de aplicabilidade dos traits, normalizar tipos e avaliar a compatibilidade dos tipos. Na versão 1.84, o novo resolvedor é utilizado para verificar a consistência das implementações de traits, ou seja, avaliar a existência de mais de um trait para um determinado tipo, considerando o código de outros pacotes crate. Essa verificação eliminou problemas na antiga implementação do resolvedor de tipos, que poderiam potencialmente causar conflitos devido à sobreposição de diferentes implementações de traits.
- Foi proposto um novo API "Strict Provenance", que pode ser usado para converter ponteiros em inteiros e vice-versa, considerando os metadados anexados ao ponteiro com informações sobre sua origem e área de uso (além do endereço do ponteiro, um valor "provenance" é anexado com informações sobre a relação com outros ponteiros, permitindo determinar onde e quando o ponteiro pode acessar a memória). Ao converter um ponteiro em um inteiro e vice-versa, ocorre um comportamento indefinido devido à dificuldade de rastrear a origem do ponteiro resultante. O novo API permite realizar operações de baixo nível com ponteiros, como armazenar informações adicionais nos bits inferiores do ponteiro, sem a necessidade de converter o ponteiro em um inteiro.
- Uma nova leva de APIs foi traduzida para a categoria estável, incluindo estabilizações de métodos e implementações de traits:
- Ipv6Addr::is_unique_local
- Ipv6Addr::is_unicast_link_local
- core::ptr::with_exposed_provenance
- core::ptr::with_exposed_provenance_mut
- ::addr
- ::expose_provenance
- ::with_addr
- ::map_addr
- ::isqrt
- ::checked_isqrt
- ::isqrt
- NonZero::isqrt
- core::ptr::without_provenance
- core::ptr::without_provenance_mut
- core::ptr::dangling
- core::ptr::dangling_mut
- Pin::as_deref_mut
- O modificador «const» é aplicado em funções:
- AtomicBool::from_ptr
- AtomicPtr::from_ptr
- AtomicU8::from_ptr
- AtomicU16::from_ptr
- AtomicU32::from_ptr
- AtomicU64::from_ptr
- AtomicUsize::from_ptr
- AtomicI8::from_ptr
- AtomicI16::from_ptr
- AtomicI32::from_ptr
- AtomicI64::from_ptr
- AtomicIsize::from_ptr
- ::is_null
- ::as_ref
- ::as_mut
- Pin::new
- Pin::new_unchecked
- Pin::get_ref
- Pin::into_ref
- Pin::get_mut
- Pin::get_unchecked_mut
- Pin::static_ref
- Pin::static_mut
- Foi estabilizado o suporte para inserções inline de assembler para arquiteturas s390x e Arm64EC.
- Para a plataforma de destino WebAssembly, foi estabilizado o suporte para funcionalidades multivalue, reference-types e tail-call.
- Foi implementado o segundo nível de suporte para a plataforma wasm32v1-none. O segundo nível de suporte implica uma garantia de compilação.
Adicionalmente, é possível destacar vários projetos relacionados ao Rust:
- Foi lançado o sistema operacional Tock 2.2, desenvolvido na linguagem Rust e voltado para uso em microcontroladores. O sistema permite a execução simultânea de vários aplicativos não confiáveis em dispositivos embarcados com memória RAM limitada, como sensores, TPM (Trusted Platform Module), chaves de autenticação e dispositivos vestíveis. Suporta plataformas com microcontroladores baseados nas arquiteturas ARM Cortex-M e RISC-V. Uma característica chave do Tock é a isolação dos níveis de aplicativos, do núcleo e da camada de drivers, assim como a isolação de cada aplicativo e driver individualmente. A isolação utiliza tanto os recursos da linguagem Rust quanto a separação em nível de proteção de memória.
- O projeto VEKOS (Verified Experimental Kernel OS) desenvolve um núcleo de sistema operacional na linguagem Rust, garantindo a verificação dos componentes executáveis. A cada operação com o sistema de arquivos, criação de processo e alocação de memória, é gerada uma confirmação criptográfica que permite verificar a operação em tempo real (a implementação é comparada com o uso de blockchain para a verificação de ações no sistema operacional). No sistema de arquivos VKFS, para garantir a integridade e proteção contra alterações retrospectivas, é utilizada a estrutura de "árvore de Merkle" (Merkle Tree), onde cada ramo verifica todos os ramos e nós abaixo dele, graças à hashização em árvore. A alocação de memória é realizada no modo COW (Copy-On-Write).
- Um grupo de pesquisadores da Microsoft e da Inria está desenvolvendo um subconjunto da linguagem C — Mini-C, destinado à tradução automática de programas em C para uma representação em Rust. Ao contrário do compilador c2rust, o novo projeto permite gerar código Rust sem o uso de unsafe, mas é principalmente focado na conversão de projetos em C que possuem prova formal de confiabilidade. Supõe-se que será mais fácil primeiro traduzir um projeto em C para a representação em Mini-C, que não permite operações aritméticas com ponteiros, do que reescrever blocos unsafe após a compilação direta de C para Rust.
A implementação do compilador é baseada na ferramenta KaRaMeL. O Mini-C foi desenvolvido e testado dentro do projeto de reescrita em Rust da biblioteca criptográfica HACL*, para a qual foi fornecida uma prova formal de confiabilidade. Essa prova foi utilizada para demonstrar a capacidade de gerar código seguro em Rust a partir do Mini-C.
- Daniel Stenberg, autor da ferramenta curl, anunciou a interrupção do desenvolvimento e suporte ao backend HTTP alternativo do projeto Curl, escrito em Rust utilizando a biblioteca Hyper. A razão apresentada foi a falta de interesse por parte dos desenvolvedores e usuários.
- Foi anunciado o lançamento beta do shell Fish 4.0, reescrito na linguagem Rust. Observa-se que, após dois anos de desenvolvimento, a base de código do Fish foi totalmente transferida de C++ para Rust. A transição para Rust permitiu resolver problemas de multithreading, obter uma ferramenta moderna que identifica erros em tempo de compilação, aumentar a segurança no gerenciamento de memória e tornar o projeto mais atraente para novos desenvolvedores.
- O projeto Tor publicou a versão Arti 1.3.2, uma implementação alternativa do cliente Tor na linguagem Rust. Arti fornece uma biblioteca embutida que pode ser utilizada por diversos aplicativos. Ao criar o Arti, foi levado em conta a experiência anterior no desenvolvimento do Tor a fim de evitar problemas arquiteturais conhecidos, tornando o projeto mais modular e eficiente. A ramificação 1.x é marcada como apropriada para uso por usuários comuns e garante o mesmo nível de privacidade, usabilidade e estabilidade que a implementação principal em C. Na nova versão, a continuidade do desenvolvimento RPC é mantida, o suporte a relais é preparado e adicionada proteção contra ataques DoS em serviços Onion.
- Foi lançada a versão 0.15 do motor de jogos Bevy, escrito em Rust. O motor utiliza um modelo centrado em dados (Data Driven) para definir a lógica do jogo, construído sobre um conjunto de componentes prontos Bevy ECS (Entity Component System), que podem ser executados em paralelo. Suporte é fornecido para renderização 2D e 3D, animação esquelética, definição de gráfico de renderização, sistema de formação de cenas, estrutura para construção de interface de usuário, e permite alterações em cenas e recursos sem a necessidade de reinicialização.
- Foi lançado o editor de texto em console Helix 25.01, escrito em Rust, que expande as ideias estabelecidas no vim e neovim. A integração com servidores LSP e com Tree-sitter é suportada, permitindo a seleção simultânea de vários blocos e o uso de múltiplos cursos durante a edição, além de temas personalizados e o protocolo de depuração DAP (Debug Adapter Protocol).
- O mecanismo de navegador Servo, escrito em Rust, agora suporta o modo escuro. O tamanho do navegador ServoShell foi reduzido em 20%. O suporte às especificações web foi ampliado para permitir o login e leitura de mensagens no Discord (o envio de mensagens ainda não é possível).
- A empresa Mozilla apresentou a Uniffi for React Native, uma ferramenta para criar módulos para React Native na linguagem Rust.
- Foram realizados testes de performance de codificadores de imagens no formato PNG. Os decodificadores em Rust (png, zune-png, wuffs) se mostraram mais rápidos do que os decodificadores em C (libpng, spng, stb_image). Por exemplo, o pacote crate png (image-rs) superou o libpng em 1,8 vezes no sistema x86 e em 1,5 vezes no sistema ARM. image-rs: 375.401 MP/s (média) 318.632 MP/s (geomean) zune-png: 376.649 MP/s (média) 302.529 MP/s (geomean) wuffs: 376.205 MP/s (média) 287.181 MP/s (geomean) libpng: 208.906 MP/s (média) 173.034 MP/s (geomean) spng: 299.515 MP/s (média) 235.495 MP/s (geomean) stb_image: 234.353 MP/s (média) 171.505 MP/s (geomean)
Fonte: opennet.ru
