--- title: "Novidades do Rust: O que chegou de novo" url: "https://rustlang.com.br/blog/rust-2024-novidades/" markdown_url: "https://rustlang.com.br/blog/rust-2024-novidades.MD" description: "Um resumo das principais novidades e melhorias que chegaram ao Rust recentemente." date: "2025-01-20" author: "Equipe Rust Brasil" --- # Novidades do Rust: O que chegou de novo Um resumo das principais novidades e melhorias que chegaram ao Rust recentemente. 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. ```rust // 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: ```rust 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: ```rust trait Container { fn items(&self) -> impl Iterator; } ``` ## 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>` 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. ```toml # 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](https://blog.rust-lang.org/) para anúncios detalhados, acompanhe o [This Week in Rust](https://this-week-in-rust.org/) para novidades semanais e participe das discussões no nosso [Discord](https://discord.gg/rust-lang)! --- 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