Novidades do Rust: O que chegou de novo

O Rust continua evoluindo rapidamente, com novas versões estáveis sendo lançadas a cada seis semanas. Mas 2024 foi um ano particularmente especial: a chegada da Edition 2024, a estabilização de funcionalidades aguardadas há anos e uma onda de adoção industrial sem precedentes marcaram um dos períodos mais transformadores da história da linguagem. Vamos explorar em detalhes tudo o que aconteceu.

Rust Edition 2024

As editions do Rust são marcos que permitem introduzir mudanças que, embora retrocompatíveis no ecossistema, podem alterar comportamentos padrão dentro de novos projetos. A Edition 2024, lançada com o Rust 1.85, trouxe diversas melhorias importantes:

• gen como palavra-chave reservada — Preparando o terreno para geradores nativos (generators) em versões futuras, gen agora é uma palavra reservada. Isso permite que a equipe de desenvolvimento trabalhe na sintaxe de geradores sem breaking changes no futuro.
• Mudanças em unsafe_op_in_unsafe_fn — Na Edition 2024, operações unsafe dentro de funções unsafe agora exigem um bloco unsafe explícito. Isso melhora a granularidade e a clareza sobre quais operações específicas são inseguras dentro de uma função.
• Melhorias em impl Trait em posição de retorno — A Edition 2024 refinou as regras de captura de lifetimes para impl Trait em posições de retorno, tornando o comportamento mais intuitivo e previsível.
• let chains em if let e while let — Agora é possível encadear múltiplas condições let com operadores lógicos, simplificando padrões de matching complexos.

// let chains na Edition 2024
if let Some(x) = opt_a && let Some(y) = opt_b && x > y {
    println!("x ({x}) é maior que y ({y})");
}

Para migrar seu projeto para a Edition 2024, basta atualizar o campo edition no Cargo.toml para "2024" e executar cargo fix --edition para aplicar as correções automáticas.

Async traits: RPITIT finalmente estabilizado

Uma das funcionalidades mais aguardadas da história do Rust finalmente chegou: a possibilidade de usar async fn diretamente em traits, sem precisar da crate async-trait. Isso foi possível graças à estabilização do RPITIT (Return Position Impl Trait in Traits).

Anteriormente, para ter métodos assíncronos em traits, era necessário usar a macro #[async_trait], que introduzia alocações dinâmicas (boxing) e overhead de runtime. Agora, o suporte é nativo:

trait Service {
    async fn handle(&self, request: Request) -> Response;
}

struct MyService;

impl Service for MyService {
    async fn handle(&self, request: Request) -> Response {
        // Processamento assíncrono sem boxing, sem overhead
        let data = fetch_data(&request).await;
        Response::new(data)
    }
}

Na prática, isso significa que traits assíncronas agora têm zero overhead adicional — o compilador gera código tão eficiente quanto chamar uma função assíncrona diretamente. Para bibliotecas como tower, axum e tonic, essa mudança simplifica significativamente a API e melhora a performance.

Além disso, a estabilização de impl Trait em mais posições permite retornar tipos complexos sem precisar nomeá-los explicitamente, o que é especialmente útil para closures e iteradores:

trait Container {
    fn items(&self) -> impl Iterator<Item = &str>;
}

Melhorias no compilador e diagnósticos

O compilador Rust ficou significativamente mais rápido e mais inteligente em 2024. Algumas melhorias notáveis:

Tempos de compilação reduzidos — Otimizações no frontend do compilador e melhorias no linker resultaram em reduções de 10% a 20% nos tempos de compilação para muitos projetos. O uso de compilação paralela no frontend (-Zthreads) começou a ser habilitado por padrão em builds nightly, com estabilização prevista para breve.

Mensagens de erro mais claras — Os diagnósticos do Rust, já considerados entre os melhores da indústria, ficaram ainda mais úteis. Exemplos concretos:

error[E0382]: borrow of moved value: `nome`
 --> src/main.rs:5:20
  |
3 |     let nome = String::from("Rust");
  |         ---- move occurs because `nome` has type `String`
4 |     let outro = nome;
  |                 ---- value moved here
5 |     println!("{}", nome);
  |                    ^^^^ value borrowed here after move
  |
help: consider cloning the value if you need to use it again
  |
4 |     let outro = nome.clone();
  |                     ++++++++

As sugestões de correção (help) ficaram mais precisas, com o compilador frequentemente sugerindo exatamente a mudança necessária para resolver o problema — incluindo a inserção de .clone(), adição de lifetimes, uso de Arc<Mutex<T>> e outras correções comuns.

Lint melhorados — Novos lints foram adicionados para detectar padrões problemáticos, como comparações de ponto flutuante, uso desnecessário de .clone() e imports não utilizados. O Clippy também recebeu dezenas de novos lints e melhorias em lints existentes.

Melhorias no Cargo

O gerenciador de pacotes e build system do Rust também recebeu atualizações importantes:

• Workspace inheritance consolidado — A capacidade de compartilhar metadados (versão, autores, licença, dependências) entre crates de um workspace via [workspace.package] e [workspace.dependencies] foi polida e documentada de forma mais clara, tornando monorepos em Rust mais gerenciáveis.

# Cargo.toml do workspace
[workspace.package]
version = "0.1.0"
edition = "2024"
authors = ["Equipe Rust Brasil"]

[workspace.dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }

# Cargo.toml de uma crate do workspace
[package]
name = "minha-crate"
version.workspace = true
edition.workspace = true

[dependencies]
serde.workspace = true
tokio.workspace = true

• Sparse registry como padrão — O protocolo sparse para o crates.io registry, que reduz drasticamente o tempo de atualização do índice de crates (de minutos para segundos em muitos casos), tornou-se o padrão. Em vez de clonar um repositório Git gigante, o Cargo agora baixa apenas os metadados das crates necessárias.
• Melhor resolução de features — O resolver de features foi aprimorado para evitar a ativação desnecessária de features em dependências, reduzindo tempos de compilação e o tamanho dos binários.

Atualizações no ecossistema de crates

O ecossistema Rust nunca esteve tão vibrante. O crates.io ultrapassou 160.000 crates publicadas, e várias bibliotecas importantes tiveram lançamentos significativos:

• Tokio — O runtime assíncrono mais popular do ecossistema continua evoluindo, com melhorias de performance e melhor integração com os novos async traits nativos.
• Axum — O framework web da equipe Tokio consolidou sua posição como o principal framework para APIs em Rust, com uma API ergonômica baseada em traits e extractors.
• Bevy — A game engine em Rust continua em desenvolvimento acelerado, com melhorias significativas em renderização, UI e developer experience. A comunidade Bevy é uma das mais ativas do ecossistema Rust.
• Tauri — A alternativa ao Electron para aplicações desktop alcançou a versão 2.0, com suporte a mobile (iOS e Android), tornando-se uma opção ainda mais atrativa para aplicações multiplataforma.
• Leptos — O framework de UI reativo para web consolidou-se como uma das melhores opções para construir aplicações web fullstack em Rust, com server-side rendering, streaming e hidratação parcial.

Rust Foundation e governança

A Rust Foundation continuou seu trabalho de apoiar o ecossistema:

• Investimentos em infraestrutura de segurança, incluindo auditorias de crates populares e melhorias no crates.io.
• Programa de grants e bolsas para mantenedores de projetos open source importantes do ecossistema.
• Expansão da equipe e de iniciativas para tornar o desenvolvimento do Rust mais sustentável a longo prazo.
• Trabalho contínuo em uma política de marcas que equilibra proteção da marca Rust com liberdade da comunidade.

Adoção industrial: um ano de marcos históricos

O ano de 2024 consolidou Rust como linguagem de produção em escala global:

• Linux Kernel — O suporte a Rust no kernel expandiu significativamente, com drivers reais sendo escritos em Rust. O framework de drivers Rust amadureceu, e a comunidade de kernel está cada vez mais receptiva à linguagem.
• Android — O Google reportou que Rust já é responsável por mais de 20% do novo código nativo no Android, e que as vulnerabilidades de memória caíram drasticamente nos componentes reescritos em Rust.
• Windows — A Microsoft continua investindo pesado em Rust, reescrevendo componentes críticos do Windows e financiando iniciativas de segurança no ecossistema Rust.
• Governo dos EUA — A Casa Branca e a CISA (Cybersecurity and Infrastructure Security Agency) publicaram relatórios recomendando a adoção de linguagens memory-safe como Rust, dando impulso político à adoção da linguagem.

O que esperar daqui para frente

Olhando para o futuro, algumas funcionalidades e tendências merecem atenção:

• Generators/coroutines — Com gen reservado como palavra-chave, geradores nativos devem chegar em versões futuras, simplificando iteradores complexos e padrões de streaming.
• Async closures — Melhorias contínuas no modelo de async Rust, incluindo closures assíncronas e melhor integração com traits.
• Polonius — O novo borrow checker, mais permissivo e preciso que o atual, continua em desenvolvimento e deve ser estabilizado eventualmente.
• Ferramentas de IA e Rust — A combinação de segurança de tipos e performance torna Rust uma opção cada vez mais atrativa para infraestrutura de IA e machine learning.

Conclusão

O Rust está em um momento excepcional. A combinação de Edition 2024, async traits nativos, melhorias no compilador e adoção massiva pela indústria faz de 2024/2025 um dos melhores momentos para ser um desenvolvedor Rust. Se você ainda não experimentou as novidades, atualize seu toolchain com rustup update e explore o que mudou.

Quer saber mais? Confira o blog oficial do Rust para anúncios detalhados, acompanhe o This Week in Rust para novidades semanais e participe das discussões no nosso Discord!

Acompanhe também as novidades de outras linguagens nos nossos portais irmãos:

• Go Brasil — veja como Go evoluiu e compare com as novidades do Rust
• Zig Brasil — acompanhe Zig, linguagem de sistemas que também desafia o domínio do C