Lançamento do Rust 1.94. Experimentos com Rust no núcleo do FreeBSD. SGBD Turso e CAD vcad em Rust

Foi lançado o Rust 1.94, a linguagem de programação originada do projeto Mozilla, mas atualmente desenvolvida sob a tutela da organização sem fins lucrativos Rust Foundation. A linguagem foca na segurança do uso da memória e fornece ferramentas para alcançar alto paralelismo na execução das tarefas, evitando o uso de coletor de lixo e tempo de execução (runtime reduzido a inicialização básica e suporte à biblioteca padrão).

Os métodos de gerenciamento de memória no Rust visam eliminar erros ao manipular ponteiros e proteger contra problemas que surgem devido ao trabalho de baixo nível com a memória, como o acesso à memória após a liberação, a desreferenciação de ponteiros nulos, estouro de buffer, entre outros. Para a distribuição de bibliotecas, a construção e o gerenciamento de dependências, o projeto tem evoluído com o gerenciador de pacotes Cargo. O repositório crates.io é suportado para o armazenamento 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 tipo slice, foi adicionado o método array_windows, que cria um iterador para percorrer fatias (slices) em 'janelas' de tamanho fixo, deslocando-se um elemento por vez. Diferente do método anterior windows, o método array_windows opera com um tamanho de janela constante e retorna a cada iteração uma referência a um array de tamanho fixo (&[T; N]), em vez de uma fatia de tamanho indefinido (&[T]). Como o tamanho do array é conhecido pelo compilador inicialmente, para melhorar o desempenho, é possível dispensar a verificação de limites do array em cada etapa da iteração. let slice = [0, 1, 2, 3]; let mut iter = slice.array_windows(); assert_eq!(iter.next().unwrap(), &[0, 1]); assert_eq!(iter.next().unwrap(), &[1, 2]); assert_eq!(iter.next().unwrap(), &[2, 3]); assert!(iter.next().is_none());
• Nos arquivos de configuração do gerenciador de pacotes Cargo (.cargo/config.toml) foi implementada a diretiva 'include', permitindo a inclusão do conteúdo de outros arquivos no local. include = [ 'frodo.toml', 'samwise.toml', ] include = [ { path = 'required.toml' }, { path = 'optional.toml', optional = true }, ]
• Nos arquivos de manifestos e arquivos de configuração, foi adicionada a compatibilidade com a nova versão da linguagem de marcação TOML 1.1, que introduziu suporte a tabelas incorporadas de várias linhas, sequências de escape '\xHH' para inserção de representações hexadecimais de bytes e '\e' para substituir '\u001B', a possibilidade de deixar uma vírgula no final do último elemento e de omitir a especificação de segundos nos valores de tempo. serde = { version = '1.0', features = ['derive'] } agora pode ser substituído por serde = { version = '1.0', features = ['derive'], }
• Uma nova leva de APIs foi traduzida para a categoria estável, incluindo estabilizações de métodos e implementações de traits:
  • ::array_windows
  • ::element_offset
  • LazyCell::get
  • LazyCell::get_mut
  • LazyCell::force_mut
  • LazyLock::get
  • LazyLock::get_mut
  • LazyLock::force_mut
  • impl TryFrom for usize
  • std::iter::Peekable::next_if_map
  • std::iter::Peekable::next_if_map_mut
  • Funções embutidas para instruções avx512fp16 x86
  • Funções embutidas para instruções NEON fp16 AArch64
  • f32::consts::EULER_GAMMA
  • f64::consts::EULER_GAMMA
  • f32::consts::GOLDEN_RATIO
  • f64::consts::GOLDEN_RATIO
• O modificador «const» é aplicado em funções:
  • f32::mul_add
  • f64::mul_add
• A plataforma riscv64im-unknown-none-elf foi traduzida para o terceiro nível de suporte. O terceiro nível abrange suporte básico, mas sem testes automatizados, publicação de compilações oficiais e verificação da capacidade de construção do código.

Adicionalmente, podem ser mencionados os projetos e eventos recentemente anunciados relacionados ao Rust:

• Ayrton Muñoz, que na época implementou o suporte para a plataforma Sony PlayStation 1 no compilador Rust e trabalhou na portabilidade do FreeBSD para computadores com chips Apple Silicon, possibilitou para o FreeBSD a criação de componentes do kernel e drivers de dispositivos na linguagem Rust. Para teste, foi proposto um conjunto de interfaces de programação de kernel (KPI) que permitem o uso de código Rust no núcleo do FreeBSD, além do driver de áudio virtio (virtio_snd), o driver HID DockChannel para teclado no M2 MacBook e vários drivers de baixo nível para subsistemas de computadores Mac com chips Apple Silicon.

  É observado que o trabalho nas interfaces Rust começou no final de 2024. As interfaces implementaram apenas parte das C-KPI e estão posicionadas como não estáveis, mas com o tempo pretende-se elevar o nível de estabilidade para um nível semelhante ao da interface da linguagem C. O driver virtio_snd proposto como exemplo é adequado para reprodução de música no QEMU. Supõe-se que em 2026 as interfaces Rust estarão suficientemente estabilizadas para que desenvolvedores interessados possam começar a usá-las para escrita de código.

• Benny Siegert, que participa do desenvolvimento do NetBSD, tentou justificar as razões pelas quais o suporte à linguagem Rust não aparecerá no núcleo do NetBSD: o NetBSD suporta arquiteturas para as quais Rust não está disponível; manter a ferramenta Rust existente no pkgsrc requer um grande esforço e conta com apenas alguns desenvolvedores; o suporte a Rust no núcleo exige a inclusão do compilador Rust no sistema base; ao fazer bootstrapping do Rust no NetBSD, é usada uma versão anterior do pacote binário, o que é inaceitável para distribuições autossuficientes distribuídas em código-fonte; os ciclos de lançamento do Rust são incompatíveis com o ciclo de desenvolvimento do NetBSD e com o suporte a versões anteriores (por exemplo, a versão 9 do NetBSD, lançada em 2020, ainda continua sendo suportada, e nessas condições, seria necessário fornecer e manter um compilador Rust de seis anos atrás).
• Foi publicado o lançamento do SGBD embutido Turso 0.5, escrito em Rust e compatível com SQLite a nível de dialeto SQL, formato de arquivos de banco de dados e C API. Dentre os recursos avançados, destaca-se o mecanismo CDC (Change Data Capture) para rastreamento de mudanças no banco de dados em tempo real, uso de io_uring para entrada/saída assíncrona no Linux, suporte a busca vetorial, presença da expressão ALTER para modificação do esquema do banco de dados, possibilidade de criptografia de dados no banco de dados, modo de cálculos incrementais e a construção "BEGIN CONCURRENT".
• Projeto para permitir o uso da biblioteca padrão Rust em programas executados no lado da GPU.
• Emuko — emulador RISC-V, escrito em Rust, capaz de carregar o Linux, suporta compilação JIT e é capaz de salvar e restaurar snapshots de estado.
• RustConn (flatpak) — interface gráfica para gerenciar conexões de rede externas a outros hosts, suportando SSH, RDP, VNC, SPICE, Telnet, Serial, Kubernetes, Zero Trust e SFTP. O código é escrito em Rust utilizando GTK4 e Wayland.
• Foi apresentada uma nova ramificação do projeto zlib-rs 0.6, marcada como a primeira versão estável, totalmente compatível com a API C do zlib e adequada para substituição transparente do zlib. O projeto visa criar uma alternativa segura à biblioteca de compressão de dados zlib. O desenvolvimento é realizado com atenção ao projeto zlib-ng, que desenvolve uma versão de alto desempenho do zlib.
• Foi apresentado o projeto vcad, que desenvolve um sistema paramétrico de design assistido por computador (CAD), escrito em Rust e integrável com agentes de IA por meio do protocolo MCP. Suporte para modelagem 3D, simulação, trabalho com esboços 2D, montagem de componentes, importação no formato STEP e exportação nos formatos STL/GLB/STEP/DXF.
• Foi publicada um sistema de reconhecimento de fala, escrito em Rust e utilizando o modelo de IA Mistral Voxtral Mini 4B Realtime e o framework de aprendizado de máquina Burn. O projeto é voltado para o reconhecimento de fala em tempo real para a formação de transcrições durante transmissões ao vivo.
• Foi lançado o conjunto de ferramentas c2rust 0.22, destinado à tradução de código C (C99) para uma representação unsafe em Rust, próxima em estrutura ao código original em C. A estrutura de trabalho resultante pode ser utilizada posteriormente para uma transição gradual para um Rust idiomático e eliminação de blocos unsafe.

Fonte: opennet.ru