Framework · Depuis 2022

Tauri

Tauri est un framework pour créer des applications de bureau et mobiles légères et sûres, avec un cœur en Rust, la WebView du système et une interface web.

Commencer le guide Discussions

Tauri est un framework open source qui associe une interface construite en HTML, CSS et JavaScript à un cœur écrit en Rust pour produire des applications Windows, macOS, Linux, Android et iOS. Sa première version stable est sortie en 2022, et il prend aujourd'hui en charge aussi bien le bureau que le mobile. Au lieu d'embarquer un moteur de navigateur, Tauri utilise la WebView fournie par le système d'exploitation (WebView2 sous Windows, WKWebView sous macOS, WebKitGTK sous Linux, etc.), ce qui garde des installateurs petits et une consommation de mémoire modérée.

Tauri convient bien lorsque vous voulez réutiliser vos compétences web pour une application de bureau tout en surveillant la taille et la sécurité. Tout frontend qui se compile en fichiers statiques fonctionne, qu'il s'agisse de React, Vue, Svelte ou Angular, tandis que les tâches proches du système, comme l'accès aux fichiers ou la zone de notification, sont confiées à des commandes Rust et à des plugins officiels. Le code de la WebView ne peut utiliser que les fonctions que les capabilities et les permissions accordent explicitement à sa fenêtre, si bien que les applications n'exposent naturellement que le nécessaire.

Pour commencer, installez Rust et les bibliothèques de développement WebView de votre plateforme, créez un projet avec create-tauri-app et lancez-le en mode développement. Inutile de maîtriser Rust en profondeur : modifier la commande greet du modèle est une bonne première étape. La documentation officielle présente ensuite les commandes, les événements, le modèle de sécurité et la distribution, et le guide ci-dessous suit le même ordre.

Points forts

Applications légères

Tauri s'appuie sur la WebView du système au lieu d'embarquer un moteur de navigateur, ce qui réduit la taille des installateurs et l'usage mémoire.

Cœur en Rust

La gestion des fenêtres, l'accès aux fichiers et les calculs lourds s'exécutent en Rust, pour un backend rapide et sûr en mémoire.

Sécurité fondée sur les permissions

Capabilities, permissions et scopes définissent les commandes et chemins accessibles à chaque fenêtre ; tout le reste est refusé par défaut.

Bureau et mobile

Une seule base de code permet de cibler Windows, macOS et Linux ainsi qu'Android et iOS.

Domaines d'utilisation

Applications de productivité de bureau en technologies web
Versions de bureau d'applications web existantes
Utilitaires de zone de notification et outils de développement
Applications à la fois de bureau et mobiles

Installation

1
Installer Rust et les dépendances système
Installez Rust avec rustup. Windows nécessite en plus Microsoft C++ Build Tools et WebView2, macOS les Xcode Command Line Tools, et Linux des bibliothèques de développement comme WebKitGTK. Installez aussi Node.js si vous utilisez un frontend web.
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
2
Créer un projet
create-tauri-app demande le nom du projet, l'identifiant, le langage du frontend, le gestionnaire de paquets et le modèle d'interface, puis génère le projet.
```
npm create tauri-app@latest
```
3
Lancer en mode développement
Installez les dépendances et démarrez l'application en mode développement. Le premier lancement prend quelques minutes pour compiler les dépendances Rust ; ensuite, les modifications du frontend apparaissent immédiatement.
```
cd tauri-app && npm install && npm run tauri dev
```

Votre premier programme

Votre premier projet

src-tauri/src/lib.rs contient le cœur Rust de l'application. La fonction greet, marquée par #[tauri::command], est une commande que le frontend peut appeler avec invoke("greet", { name }) ; elle est enregistrée via generate_handler!. La fonction run assemble et démarre l'application ; sur le bureau, c'est main.rs qui l'appelle. Lancez npm run tauri dev et la fenêtre de l'application s'ouvre.

src-tauri/src/lib.rs

#[tauri::command]
fn greet(name: &str) -> String {
    format!("Hello, {name}! You've been greeted from Rust!")
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![greet])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

npm run tauri dev

Outils du quotidien

Tauri CLI: Des commandes comme tauri dev, tauri build, tauri add et tauri icon lancent l'application en développement, la compilent et l'empaquettent, ajoutent des plugins et génèrent les icônes.
create-tauri-app: Crée un nouveau projet Tauri à partir du modèle de frontend et du gestionnaire de paquets choisis.
@tauri-apps/api: Le paquet JavaScript officiel pour appeler des commandes avec invoke, s'abonner aux événements et piloter les fenêtres depuis le frontend.
tauri-action: La GitHub Action officielle qui compile votre application pour Windows, macOS et Linux et la publie dans une release.

Guide pas à pas

Six chapitres pour aller de l'installation aux notions essentielles de Tauri.

Documentation officielle et ressources

Langages

Discussions

Lancer une discussion

Posez vos questions, partagez votre expérience et échangez vos avis sur Tauri.

Aucune discussion pour l'instant. Lancez la première.