Rust: escreva um código para Windows, macOS e Linux sem dor

Por que Rust é o candidato ideal para desenvolvimento multiplataforma?

No mundo do desenvolvimento de software, existe uma dor eterna: escrever um programa uma vez e executá-lo no Windows, macOS e Linux. Normalmente, isso se transforma em um inferno de diretivas condicionais, danças com o diabo em torno de caminhos de arquivos e testes intermináveis. Mas existe uma linguagem que resolve esse problema em nível de sistema — Rust.

Rust foi projetado com foco em multiplataforma. Seu compilador (rustc) é capaz de gerar binários para dezenas de arquiteturas e sistemas operacionais. Mas o principal é que a biblioteca padrão (std) já possui uma abstração sobre o sistema operacional. Você escreve o código, e o Rust cuida de como trabalhar com arquivos, threads ou rede em cada plataforma específica. Isso não é mágica, é design inteligente.

Neste artigo, não vamos apenas falar de teoria. Vamos analisar exemplos reais de código: desde um simples "Hello, World!" até manipulação do sistema de arquivos e criação de uma aplicação GUI. Você verá como o desenvolvimento multiplataforma em Rust se transforma de dor de cabeça em prazer. Vamos nessa!

Como o Rust garante a multiplataforma?

O segredo do Rust está em seu sistema de abstração de três níveis:

\n
• Código independente de plataforma — 90% do seu programa. Usa apenas std, funciona igual em todos os lugares.
\n
• Compilação condicional — para partes dependentes de plataforma. Rust permite ativar ou desativar código dependendo do SO alvo.
\n
• Crates externos — bibliotecas como serde ou tokio, que já resolvem problemas multiplataforma para você.
\n

O princípio básico: você escreve o código comum e, para exceções raras, usa as diretivas #[cfg(target_os = "...")]. Isso é mais limpo do que em C/C++, onde muitas vezes você precisa criar blocos inteiros de #ifdef.

Exemplo: identificando a plataforma no código

Veja como descobrir em qual SO o programa está sendo executado, sem gambiarras:

fn main() {\n    if cfg!(target_os = "windows") {\n        println!("Executando no Windows");\n    } else if cfg!(target_os = "macos") {\n        println!("Executando no macOS");\n    } else if cfg!(target_os = "linux") {\n        println!("Executando no Linux");\n    } else {\n        println!("SO desconhecido (mas Rust ainda funciona!)");\n    }\n}\n

Importante: cfg! é uma macro que é avaliada em tempo de compilação. Se você compilar este código no Linux, apenas o bloco do Linux será incluído no binário. Sem código extra — sem problemas.

Trabalhando com o sistema de arquivos: escreva uma vez

Uma dor de cabeça clássica são os caminhos de arquivos. No Windows é C:\\Users\\nome\\arquivo.txt, no Linux é /home/nome/arquivo.txt. O Rust resolve isso através da trait Path e da struct PathBuf.

Veja um exemplo: criar um diretório e escrever em um arquivo. O código funcionará em qualquer SO sem alterações:

use std::fs;\nuse std::path::PathBuf;\n\nfn main() -> Result<(), Box<dyn std::error::Error>> {\n    // Construindo o caminho para o diretório home do usuário\n    let home = dirs::home_dir().expect("Não foi possível obter o diretório home");\n    let mut path = PathBuf::from(home);\n    path.push("my_rust_app");\n    path.push("data");\n    \n    // Criando o diretório (recursivamente)\n    fs::create_dir_all(&path)?;\n    \n    // Criando o arquivo\n    let file_path = path.join("output.txt");\n    fs::write(&file_path, "Olá, mundo multiplataforma!")?;\n    \n    println!("Arquivo salvo em: {:?}", file_path);\n    Ok(())\n}\n

Aqui usamos o crate dirs, que fornece acesso multiplataforma a caminhos do sistema (pasta home, AppData, etc.). Sem ele, teríamos que escrever compilação condicional para cada SO.

Rede e trabalho com threads

A biblioteca padrão do Rust fornece uma API unificada