--- title: "Rust 1.94: Novidades e Recursos Estabilizados — 2026" url: "https://rustlang.com.br/blog/rust-1-94-novidades-array-windows-2026/" markdown_url: "https://rustlang.com.br/blog/rust-1-94-novidades-array-windows-2026.MD" description: "Conheça as novidades do Rust 1.94: array_windows para slices, AVX-512 FP16, TOML 1.1 no Cargo, LazyCell, constantes matemáticas e muito mais." date: "2026-04-01" author: "Equipe Rust Brasil" --- # Rust 1.94: Novidades e Recursos Estabilizados — 2026 Conheça as novidades do Rust 1.94: array_windows para slices, AVX-512 FP16, TOML 1.1 no Cargo, LazyCell, constantes matemáticas e muito mais. ## Introdução O Rust 1.94.0, lançado em 5 de março de 2026, trouxe uma safra excelente de estabilizações que impactam desde quem trabalha com processamento de sinais até quem mantém grandes projetos com o [Cargo](/ecossistema/cargo/). Neste artigo, vamos explorar cada recurso novo, com exemplos de código prontos para você copiar e testar. Se você ainda não atualizou, basta rodar: ```rust // No terminal: // rustup update stable ``` Vamos às novidades! ## array_windows: Iteração Tipada sobre Slices O método `array_windows` é, sem dúvida, o destaque desta release. Ele funciona de forma semelhante ao já conhecido `windows()`, mas retorna referências a arrays de tamanho fixo (`&[T; N]`) em vez de slices dinâmicos (`&[T]`). ```rust fn main() { let dados = [10, 20, 30, 40, 50, 60]; // Com windows() — retorna &[i32] (tamanho dinâmico) for janela in dados.windows(3) { println!("slice: {:?}", janela); } // Com array_windows() — retorna &[i32; 3] (tamanho fixo!) for janela in dados.array_windows::<3>() { let [a, b, c] = *janela; println!("a={}, b={}, c={}", a, b, c); } } ``` ### Por que isso importa? Quando o compilador sabe o tamanho exato da janela em tempo de compilação, ele pode **eliminar verificações de limites** (*bounds checks*) automaticamente. Para quem faz processamento numérico, isso significa ganho de performance sem nenhum `unsafe`: ```rust fn media_movel(valores: &[f64]) -> Vec { valores .array_windows::<5>() .map(|janela| { let soma: f64 = janela.iter().sum(); soma / 5.0 }) .collect() } fn main() { let precos = vec![100.0, 102.5, 101.0, 103.0, 105.5, 104.0, 106.0]; let medias = media_movel(&precos); println!("Médias móveis: {:?}", medias); } ``` Se você trabalha com séries temporais, processamento de áudio, ou análise de dados em Rust, `array_windows` é um upgrade gratuito de performance. Confira também nosso artigo sobre [otimização de performance](/artigos/otimizacao-performance/) para mais técnicas. ## AVX-512 FP16 e NEON FP16 Estabilizados O Rust 1.94 promove as **intrinsics AVX-512 FP16** (x86) e **NEON FP16** (AArch64) para estáveis. Isso significa que agora é possível usar instruções de ponto flutuante de meia precisão (16 bits) sem a flag `nightly`. ```rust #[cfg(target_arch = "x86_64")] use std::arch::x86_64::*; #[cfg(target_arch = "x86_64")] fn soma_fp16_avx512(a: &[u16], b: &[u16]) -> Vec { // Exemplo conceitual — requer CPU com suporte AVX-512 FP16 // (Intel Sapphire Rapids ou posterior) assert_eq!(a.len(), b.len()); a.iter() .zip(b.iter()) .map(|(&x, &y)| x.wrapping_add(y)) .collect() } ``` Embora o uso direto de intrinsics seja mais comum em bibliotecas especializadas, a estabilização abre caminho para crates de machine learning e processamento de imagem aproveitarem FP16 nativo. Se você se interessa por IA em Rust, confira nosso post sobre [Rust e inteligência artificial](/blog/rust-inteligencia-artificial-ml-2026/). Para quem desenvolve para [sistemas embarcados](/blog/rust-embedded-embassy-iot-2026/) com processadores ARM, o suporte NEON FP16 estável é igualmente importante — especialmente em dispositivos IoT com restrições de memória. ## TOML 1.1 no Cargo O Cargo agora parseia **TOML v1.1** nos manifestos (`Cargo.toml`) e arquivos de configuração. As principais melhorias incluem: ```toml # Cargo.toml — agora com TOML 1.1 [package] name = "meu-projeto" version = "0.1.0" edition = "2024" # TOML 1.1: datas sem offset de timezone criado = 2026-03-05 # TOML 1.1: strings com escape \x para bytes hex [package.metadata] prefixo = "\x1B[32m" # escape ANSI verde ``` Além disso, o Cargo 1.94 introduziu a chave `include` no topo do arquivo de configuração, permitindo compartilhar configurações entre projetos: ```toml # .cargo/config.toml include = ["../../shared-cargo-config.toml"] [build] jobs = 8 ``` Isso é especialmente útil em [workspaces](/artigos/gerenciamento-dependencias/) com muitos crates, onde manter configurações DRY economiza tempo e evita erros. ## Novas APIs Estabilizadas ### LazyCell e LazyLock Ganham Métodos Os tipos `LazyCell` e `LazyLock` — muito úteis para inicialização preguiçosa — ganharam métodos `get`, `get_mut` e `force_mut`: ```rust use std::cell::LazyCell; fn main() { let valor = LazyCell::new(|| { println!("Inicializando..."); 42 }); // Verifica se já foi inicializado sem forçar assert!(LazyCell::get(&valor).is_none()); // Agora força a inicialização println!("Valor: {}", *valor); // get() agora retorna Some assert_eq!(LazyCell::get(&valor), Some(&42)); } ``` Para a versão thread-safe com `LazyLock`, o padrão é idêntico: ```rust use std::sync::LazyLock; static CONFIG: LazyLock = LazyLock::new(|| { std::fs::read_to_string("config.toml") .unwrap_or_else(|_| String::from("default")) }); fn main() { // Verifica sem inicializar if LazyLock::get(&CONFIG).is_none() { println!("Config ainda não carregada"); } // Acessa e inicializa println!("Config: {}", *CONFIG); } ``` Confira também nosso conteúdo sobre [OnceCell e OnceLock](/stdlib/once-oncelock/) na standard library. ### Constantes Matemáticas: EULER_GAMMA e GOLDEN_RATIO Duas novas constantes foram adicionadas tanto para `f32` quanto para `f64`: ```rust fn main() { // Constante de Euler-Mascheroni (γ ≈ 0.5772) let gamma_64 = f64::EULER_GAMMA; let gamma_32 = f32::EULER_GAMMA; // Proporção áurea (φ ≈ 1.6180) let phi_64 = f64::GOLDEN_RATIO; let phi_32 = f32::GOLDEN_RATIO; println!("Euler-Mascheroni: {gamma_64}"); println!("Proporção áurea: {phi_64}"); println!("f32 — γ: {gamma_32}, φ: {phi_32}"); } ``` Essas constantes são úteis em computação científica, análise numérica e [algoritmos matemáticos](/algoritmos/fibonacci-dp/). Anteriormente, era necessário defini-las manualmente ou depender de crates externos. ### Peekable::next_if_map O novo método `next_if_map` no iterador `Peekable` permite espiar e transformar condicionalmente o próximo elemento: ```rust fn main() { let numeros = vec!["42", "abc", "7", "xyz", "100"]; let mut iter = numeros.iter().peekable(); let mut resultado = Vec::new(); while iter.peek().is_some() { // Tenta converter; se funcionar, consome o elemento if let Some(n) = iter.next_if_map(|s| s.parse::().ok()) { resultado.push(n); } else { // Pula elementos não numéricos iter.next(); } } println!("Números parseados: {:?}", resultado); // Saída: [42, 7, 100] } ``` Isso simplifica muito o código de parsers e [lexers](/artigos/pattern-matching-avancado/) que precisam consumir tokens condicionalmente. ### element_offset para Slices O método `element_offset` permite descobrir o índice de um elemento dentro de um slice a partir de sua referência: ```rust fn main() { let dados = [10, 20, 30, 40, 50]; let slice = &dados[..]; let elemento = &slice[2]; // referência ao 30 let offset = slice.element_offset(elemento); println!("Offset: {:?}", offset); // Some(2) } ``` ## Guia de Migração A atualização para o Rust 1.94 é tranquila para a maioria dos projetos. Pontos de atenção: 1. **TOML 1.1**: Se seu `Cargo.toml` usava workarounds para limitações do TOML 1.0, revise — pode simplificar. 2. **Clippy**: Novos lints foram adicionados. Rode `cargo clippy` após atualizar e corrija avisos. 3. **MSRV**: Se mantém uma Minimum Supported Rust Version, atualize a documentação. ```bash # Atualizar toolchain rustup update stable # Verificar compatibilidade cargo check cargo clippy cargo test ``` Confira nosso guia sobre [CI/CD com Rust](/artigos/ci-cd-rust/) para automatizar essas verificações em seu pipeline. ## Conclusão O Rust 1.94 é uma release que reforça a maturidade da linguagem: `array_windows` melhora a ergonomia e performance de código numérico, as estabilizações de `LazyCell`/`LazyLock` simplificam padrões de inicialização preguiçosa, e o suporte a TOML 1.1 moderniza o Cargo. Se você quer começar com Rust, confira nosso guia de [como aprender Rust em 2026](/blog/como-aprender-rust-2026/). Para quem já programa, aproveite também nosso tutorial sobre [primeiros passos](/tutoriais/primeiros-passos/) e o [cheatsheet](/cheatsheet/) completo. Acompanhe o [Rust Brasil](/) para ficar por dentro das próximas releases! --- **Leia também:** - [Ecossistema Rust em 2026](/blog/ecossistema-rust-2026/) - [Async Rust: O Ecossistema em 2026](/blog/async-rust-ecossistema-2026/) - [Testes em Rust: Estratégias e Boas Práticas em 2026](/blog/testes-rust-estrategias-boas-praticas-2026/) - [Compilação Condicional com cfg e Features](/blog/compilacao-condicional-rust-cfg-features/) **Fontes externas:** - Anúncio oficial do Rust 1.94.0 - Changelog completo no releases.rs **Veja também nossos sites parceiros:** - Go Brasil — para quem também se interessa por Go, outra linguagem de sistemas - Python Brasil Dev — se você está migrando de Python para Rust - Zig Brasil — para quem acompanha linguagens de sistemas modernas