Rust: escribiendo un código para Windows, macOS y Linux sin dolor

¿Por qué Rust es el candidato ideal para el desarrollo multiplataforma?

En el mundo del desarrollo de software hay un dolor eterno: escribir un programa una vez y ejecutarlo en Windows, macOS y Linux. Normalmente, esto se convierte en un infierno con directivas condicionales, bailes alrededor de las rutas de archivos y pruebas interminables. Pero hay un lenguaje que resuelve este problema a nivel de sistema: Rust.

Rust fue diseñado pensando en la multiplataforma. Su compilador (rustc) puede generar binarios para docenas de arquitecturas y SO. Pero lo principal es que en la biblioteca estándar (std) ya está incorporada una abstracción sobre el sistema operativo. Usted escribe código y Rust se encarga de cómo trabajar con archivos, hilos o red en una plataforma específica. No es magia, es un diseño inteligente.

En este artículo no solo hablaremos de teoría. Analizaremos ejemplos de código reales: desde un simple «¡Hola, mundo!» hasta el trabajo con el sistema de archivos y la creación de una aplicación GUI. Verá cómo el desarrollo multiplataforma en Rust pasa de ser un dolor de cabeza a un placer. ¡Allá vamos!

¿Cómo garantiza Rust la multiplataforma?

El secreto de Rust reside en su sistema de abstracción de tres niveles:

\n
• Código independiente de la plataforma — el 90% de su programa. Utiliza solo std, funciona igual en todas partes.
\n
• Compilación condicional — para fragmentos dependientes de la plataforma. Rust permite incluir o excluir código según el SO de destino.
\n
• Crates externos — bibliotecas como serde o tokio, que ya resuelven problemas multiplataforma por usted.
\n

El principio básico: usted escribe código común y para excepciones raras utiliza las directivas #[cfg(target_os = "...")]. Esto es más limpio que en C/C++, donde a menudo hay que construir bloques enteros de #ifdef.

Ejemplo: determinando la plataforma en el código

Veamos cómo saber bajo qué SO se ejecuta el programa, sin trucos sucios:

fn main() {\n    if cfg!(target_os = "windows") {\n        println!("Ejecutándose en Windows");\n    } else if cfg!(target_os = "macos") {\n        println!("Ejecutándose en macOS");\n    } else if cfg!(target_os = "linux") {\n        println!("Ejecutándose en Linux");\n    } else {\n        println!("SO desconocido (¡pero Rust sigue funcionando!)");\n    }\n}\n

Importante: cfg! es una macro que se evalúa en tiempo de compilación. Si compila este código en Linux, solo la rama de Linux se incluirá en el binario. Sin código extra, sin problemas.

Trabajo con el sistema de archivos: escribiendo una vez

Un dolor de cabeza clásico son las rutas de archivos. En Windows es C:\\Users\\nombre\\archivo.txt, en Linux es /home/nombre/archivo.txt. Rust resuelve esto mediante el trait Path y la estructura PathBuf.

Veamos un ejemplo: crear un directorio y escribir en un archivo. El código funcionará en cualquier SO sin cambios:

use std::fs;\nuse std::path::PathBuf;\n\nfn main() -> Result<(), Box<dyn std::error::Error>> {\n    // Construir la ruta al directorio personal del usuario\n    let home = dirs::home_dir().expect("No se pudo obtener el directorio personal");\n    let mut path = PathBuf::from(home);\n    path.push("mi_app_rust");\n    path.push("datos");\n    \n    // Crear el directorio (recursivamente)\n    fs::create_dir_all(&path)?;\n    \n    // Crear el archivo\n    let file_path = path.join("salida.txt");\n    fs::write(&file_path, "¡Hola, mundo multiplataforma!")?;\n    \n    println!("Archivo guardado: {:?}", file_path);\n    Ok(())\n}\n

Aquí usamos el crate dirs, que proporciona acceso multiplataforma a rutas del sistema (carpeta personal, AppData, etc.). Sin él, habría que escribir compilación condicional para cada SO.

Red y trabajo con hilos

La biblioteca estándar de Rust proporciona una API unificada