Tauri : Une Technologie d'Avenir pour les Applications de Bureau

Tauri : Une Technologie d'Avenir pour les Applications de Bureau

8 Août 2023

Le rythme effréné de l'évolution technologique n'épargne aucun domaine, pas même celui du développement d'applications de bureau. Si, comme moi, vous êtes un développeur qui aime l'excitation de la nouveauté et les défis à relever, laissez-moi vous présenter Tauri. Cette technologie est en train de chambouler la manière dont nous créons des applications de bureau, et elle pourrait bien secouer les bases mêmes d'Electron. Dans les lignes qui suivent, je vous emmène dans un voyage pour comprendre pourquoi Tauri est l'une des étoiles montantes à garder à l'œil. Qui sait, peut-être que demain, c'est avec Tauri que nous créerons nos logiciels de bureau !

1. Tauri : Une Brève Présentation

Tauri est un framework open source qui offre une alternative moderne pour la création d'applications de bureau à l'aide de technologies web telles que HTML, CSS et JavaScript. Ce framework se distingue par sa capacité à créer des applications multiplateformes tout en mettant l'accent sur les performances et l'expérience utilisateur. Voyons pourquoi Tauri est considéré comme une technologie d'avenir.

2. Bases Technologiques

Tauri s'appuie sur un ensemble de technologies et de bibliothèques pour offrir une expérience de développement fluide et performante :

  • Rust : Tauri fait usage du langage de programmation Rust pour le backend de l'application. Afin d'interagir directement avec les fonctionnalités du système d'exploitation et d'offrir une expérience native.

  • WebView : Tauri utilise un composant WebView pour afficher l'interface utilisateur de l'application. Cela signifie que vous pouvez exploiter les technologies web familières pour créer des interfaces utilisateur riches et interactives.

  • Tao & Wry : Tauri tire parti de projets connexes pour la gestion avancée de WebView. Ces composants optimisent la manière dont l'interface utilisateur est affichée et interagit avec le reste de l'application, contribuant ainsi à l'efficacité et aux performances globales de Tauri.

3. Transition Facile des Technologies Web

L'un des points forts de Tauri est sa capacité à porter des technologies web sur des applications de bureau. Cela signifie que si vous êtes un développeur web familier avec les langages HTML, CSS et JavaScript, vous pouvez facilement passer à Tauri pour créer des applications de bureau. Cette transition douce vous permet de réutiliser vos compétences existantes durement acquise. Ou encore porter un projet web en application de bureau rapidement.

4. Frameworks Frontend Compatibles

L'un des avantages de Tauri réside dans sa flexibilité en matière de choix de framework frontend. Vous pouvez utiliser la majorité des frameworks frontend populaires pour construire l'interface utilisateur de votre application. Tel que :

  • React: La bibliothèque JavaScript la plus populaire du moment.

  • Svelte: La technologie frontend du futur dont nous avons déjà discuté.

  • Vue.js: Très apprécié par la communauté.

  • plein d'autre

5. Le Pouvoir du Backend Rust Un Avantages Indiscutables

Lorsque l'on compare le backend Rust de Tauri avec le backend Node.js d'Electron, des avantages significatifs se dégagent. Bien que l'idée d'adopter Rust puisse sembler intimidante pour certains développeurs, ses avantages sont indéniables.

5.1 Avantages du Backend Rust

  • Performance: Rust est conçu pour offrir des performances optimales grâce à sa gestion fine de la mémoire et son système de threads sans avoir à sacrifier la sécurité. Comparé à Node.js, qui est basé sur un modèle asynchrone (boucle événementielle), Rust permet des opérations concurrentes plus efficaces et un traitement multitâche plus fluide, améliorant ainsi la réactivité et la fluidité de l'application. Son absence de ramasse-miettes lui assure aussi moins de temps mort.

  • Sécurité : Rust est intrinsèquement conçu pour prévenir les erreurs de mémoire telles que les pointeurs nuls et les dépassements de tampon, ce qui réduit considérablement les risques d'erreurs courantes dans le développement. En revanche, Node.js peut être plus vulnérable aux erreurs de gestion de la mémoire.

  • Consommation de Mémoire : En raison de sa gestion fine de la mémoire et de son modèle d'exécution, Rust a tendance à avoir une consommation de mémoire plus faible par rapport à Node.js, ce qui peut contribuer à des applications de bureau plus légères et réactives.

  • Interopérabilité Natives : L'avantage majeur de Rust réside dans sa capacité à interagir facilement avec des fonctionnalités natives du système d'exploitation. Cette interopérabilité permet d'offrir une expérience utilisateur plus native et des performances élevées en exploitant directement les fonctionnalités de la plateforme.

5.2 Rust sans Contraintes

Bien qu'il soit possible d'interagir avec le backend Rust pour tirer pleinement parti des avantages susmentionnés, il est important de noter que vous n'avez pas nécessairement besoin d'une maîtrise approfondie de Rust pour créer une application Tauri. Les applications Tauri peuvent être conçues avec peu d'interactions natives, et les appels à des API distantes peuvent très bien être gérés du côté frontend, de la même manière qu'une application web classique.

6. Comparaison avec Electron

Tauri se positionne comme un concurrent sérieux à Electron, une technologie bien établie pour le développement d'applications de bureau avec des technologies web. Alors, en quoi Tauri se démarque-t-il ?

  • Performance : Tauri se targue de performances supérieures à celles d'Electron. Grâce à son utilisation du composant WebView et le backend en rust, Tauri peut garantir des temps de démarrage plus rapides et une consommation de mémoire grandement réduite.

  • Taille de l'Application : Les applications Tauri ont tendance à avoir une taille plus réduite par rapport aux applications Electron, ce qui peut être un avantage considérable.

Usage Tauri Electron
Taille de l'installeur 3.1MB 52.1MB
Utilisation mémoire 180MB 462MB
Temps de démarrage 2s 4s

7. Exemple Simple d'Utilisation de Tauri en Svelte

Voyons comment Tauri en combinaison avec le framework frontend Svelte peut résoudre des défis de développement concrets.

7.1 Lecture et Écriture de Fichiers en Tauri-Svelte

Imaginez que vous développez une application de traitement de texte. Vous avez besoin d'interagir avec des fichiers locaux pour ouvrir et enregistrer des documents. Voici comment Tauri et Svelte travaillent main dans la main pour gérer cette tâche :

<script>
  let fileContent = "";
  async function readFile() {
    fileContent = await Tauri.invoke('read_file', 'example.txt');
  }

  async function writeFile() {
    await Tauri.invoke('write_file', 'example.txt', fileContent);
  }
</script>

<main>
  <button on:click={readFile}>Lire le Fichier</button>
  <textarea bind:value={fileContent}></textarea>
  <button on:click={writeFile}>Enregistrer dans le Fichier</button>
</main>

<style> /* on avait pas vu ça la dernière fois */
  textarea { /* rien d'exceptionnel juste du style scoppé */
    width: 100%;
    height: 200px;
    margin-top: 10px;
  }
</style>

#[tauri::command]
fn read_file(file_name: String) -> Result<String, String> {
    let content = std::fs::read_to_string(file_name).map_err(|e| e.to_string())?;
    Ok(content)
}

#[tauri::command]
fn write_file(file_name: String, content: String) -> Result<(), String> {
    std::fs::write(file_name, content).map_err(|e| e.to_string())?;
    Ok(())
}

7.2 Tâche Lourde Multithreadée en Tauri-Svelte

Prenons l'exemple d'une application qui nécessite de compresser de nombreux répertoire. Voici comment Tauri en collaboration avec Svelte gère cette tâche lourde en utilisant le multithreading de Rust :

<script>
  async function compressDirectories() {
    const directories = ['dir1', 'dir2', 'dir3', 'dir4', 'dir5'];
    const results = await Tauri.invoke('compress_directories', directories);
    console.log('Résultats de la compression:', results);
  }
</script>

<main>
  <button on:click={compressDirectories}>Compresser les Répertoires</button>
</main>

use std::fs;
use std::io::Write;
use flate2::{Compression, write::GzEncoder};
use std::thread;

#[tauri::command]
fn compress_directories(directories: Vec<String>) -> Result<Vec<String>, String> {
    let compressed_directories: Vec<String> = directories
        .into_iter()
        .map(|directory_name| {
            let files = fs::read_dir(&directory_name).map_err(|e| e.to_string())?;
            let compressed_directory = format!("{}_compressed", directory_name);
            fs::create_dir(&compressed_directory).map_err(|e| e.to_string())?;

            let handles: Vec<_> = files
                .filter_map(|file| {
                    let file = file.ok()?;
                    let path = file.path();
                    let target_path = path.strip_prefix(&directory_name).ok()?;
                    let compressed_path = format!("{}/{}", compressed_directory, target_path.display());
                    Some(thread::spawn(move || {
                        compress_file(&path, &compressed_path)
                    }))
                })
                .collect();

            let results: Vec<_> = handles
                .into_iter()
                .map(|handle| handle.join().unwrap_or_else(|_| Err("Erreur lors de la compression".to_string())))
                .collect();

            if results.iter().any(|result| result.is_err()) {
                Err("Au moins une compression a échoué".to_string())
            } else {
                Ok(compressed_directory)
            }
        })
        .collect();

    Ok(compressed_directories)
}

fn compress_file(source: &std::path::Path, target: &str) -> Result<(), String> {
    let content = fs::read(&source).map_err(|e| e.to_string())?;

    let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
    encoder.write_all(&content).map_err(|e| e.to_string())?;

    let compressed_content = encoder.finish().map_err(|e| e.to_string())?;
    fs::write(target, &compressed_content).map_err(|e| e.to_string())?;

    Ok(())
}

8. Conclusion : Tauri en Perspective

En somme, Tauri offre un aperçu excitant du futur du développement d'applications de bureau. Son association avec des frameworks frontend familiers facilite la création d'applications natives et performantes. Cependant, tout en étant enthousiastes quant aux avantages que Tauri apporte, il est judicieux de garder à l'esprit la place d'Electron dans l'écosystème actuel. Électron est largement adopté, bien documenté et éprouvé dans de nombreuses applications. Tauri, quant à lui, émerge comme une option prometteuse et mérite d'être exploré et expérimenté.

Alors, que vous commenciez à adopter Tauri pour de nouveaux projets ou que vous continuiez à utiliser Electron, gardez un œil sur l'évolution de Tauri. Cette technologie ouvre de nouvelles perspectives pour le développement de client lourd, et il sera passionnant de voir comment elle évolue et s'intègre dans le paysage du développement logiciel.

# Rust# Javascript# Frontend