Rust : écrire un seul code pour Windows, macOS et Linux sans douleur

Pourquoi Rust est-il le candidat idéal pour le développement multiplateforme ?

Dans le monde du développement logiciel, il y a une douleur éternelle : écrire un programme une seule fois et l'exécuter sur Windows, macOS et Linux. Cela se transforme généralement en un enfer de directives conditionnelles, de contorsions autour des chemins de fichiers et de tests interminables. Mais il existe un langage qui résout ce problème au niveau système : Rust.

Rust a été conçu dans une optique de multiplateforme. Son compilateur (rustc) sait générer des binaires pour des dizaines d'architectures et d'OS. Mais le principal, c'est que la bibliothèque standard (std) intègre déjà une abstraction du système d'exploitation. Vous écrivez le code, et Rust se charge de gérer la façon de travailler avec les fichiers, les threads ou le réseau sur la plateforme spécifique. Ce n'est pas de la magie, c'est une conception intelligente.

Dans cet article, nous ne nous contenterons pas de parler de théorie. Nous analyserons des exemples de code concrets : du simple « Hello, World! » à la gestion du système de fichiers et à la création d'une application GUI. Vous verrez comment le développement multiplateforme en Rust passe d'un casse-tête à un plaisir. C'est parti !

Comment Rust assure-t-il la multiplateforme ?

Le secret de Rust réside dans son système d'abstraction à trois niveaux :

\n
• Code indépendant de la plateforme — 90% de votre programme. Utilise uniquement std, fonctionne partout de la même manière.
\n
• Compilation conditionnelle — pour les parties dépendantes de la plateforme. Rust permet d'inclure ou d'exclure du code en fonction de l'OS cible.
\n
• Crates externes (crates) — des bibliothèques comme serde ou tokio, qui résolvent déjà les problèmes multiplateformes pour vous.
\n

Le principe de base : vous écrivez du code commun, et pour les rares exceptions, vous utilisez les directives #[cfg(target_os = "...")]. C'est plus propre qu'en C/C++, où l'on doit souvent construire des blocs entiers de #ifdef.

Exemple : déterminer la plateforme dans le code

Voyons comment savoir sous quel OS le programme est exécuté, sans astuces douteuses :

fn main() {\n    if cfg!(target_os = "windows") {\n        println!("Exécuté sous Windows");\n    } else if cfg!(target_os = "macos") {\n        println!("Exécuté sous macOS");\n    } else if cfg!(target_os = "linux") {\n        println!("Exécuté sous Linux");\n    } else {\n        println!("OS inconnu (mais Rust fonctionne quand même !)");\n    }\n}\n

Important : cfg! est une macro qui est évaluée à la compilation. Si vous compilez ce code sous Linux, seule la branche Linux sera incluse dans le binaire. Pas de code superflu, pas de problèmes.

Gestion du système de fichiers : écrire une seule fois

Un casse-tête classique : les chemins de fichiers. Sous Windows, c'est C:\\Users\\nom\\fichier.txt, sous Linux, c'est /home/nom/fichier.txt. Rust résout cela avec le trait Path et la structure PathBuf.

Prenons un exemple : création d'un répertoire et écriture dans un fichier. Le code fonctionnera sur n'importe quel OS sans modification :

use std::fs;\nuse std::path::PathBuf;\n\nfn main() -> Result<(), Box<dyn std::error::Error>> {\n    // Construction du chemin vers le répertoire personnel de l'utilisateur\n    let home = dirs::home_dir().expect("Impossible d'obtenir le répertoire personnel");\n    let mut path = PathBuf::from(home);\n    path.push("my_rust_app");\n    path.push("data");\n    \n    // Création du répertoire (récursivement)\n    fs::create_dir_all(&path)?;\n    \n    // Création du fichier\n    let file_path = path.join("output.txt");\n    fs::write(&file_path, "Bonjour, monde multiplateforme !")?;\n    \n    println!("Fichier sauvegardé : {:?}", file_path);\n    Ok(())\n}\n

Ici, nous avons utilisé la crate dirs, qui donne un accès multiplateforme aux chemins système (dossier personnel, AppData, etc.). Sans elle, il aurait fallu écrire de la compilation conditionnelle pour chaque OS.

Réseau et gestion des threads

La bibliothèque standard de Rust fournit une API unifiée