Les apps desktop ont longtemps rimé avec Electron : pratique, universel, mais voraces en mémoire et en stockage. Aujourd'hui, Tauri 2 app desktop Next.js 2026 redéfinit ce compromis. Là où une application Electron classique consomme 200 à 400 Mo de RAM au repos et pèse 80 Mo installée, une app Tauri équivalente plafonne à 30-60 Mo de RAM et se compresse en moins de 5 Mo. Ce n'est pas un benchmark de laboratoire : c'est la réalité mesurée sur des projets en production.

Chez ConsilioWEB, nous avons accompagné plusieurs PME de la région Nouvelle-Aquitaine qui cherchaient à remplacer leurs outils internes vieillissants par des applications desktop modernes, sans exploser leur budget ni recruter un développeur C++ ou .NET. Tauri 2, couplé à Next.js pour le front-end, ouvre une voie concrète : votre équipe web existante peut livrer une app multi-OS robuste, signée, et packagée en quelques semaines.

Cet article couvre tout le chemin, de l'installation à la distribution : comparaison de performances face à Electron, setup en 10 minutes, écriture de commandes Rust, accès au système de fichiers, notifications natives, gestion du system tray, packaging multi-OS avec signatures code et cas d'usage concrets pour les dirigeants qui cherchent à outiller leurs équipes terrain.

---

Pourquoi Tauri 2 marque une rupture en 2026

La fin du bundle Chromium embarqué

Electron fonctionne en embarquant une instance complète de Chromium dans chaque application. Chaque build emporte donc l'intégralité d'un moteur de rendu web, qu'il pèse 60, 80 ou 120 Mo. Tauri fait le choix inverse : il utilise le WebView natif du système d'exploitation hôte. Sur macOS, c'est WebKit. Sur Windows 11, c'est WebView2 (basé sur Blink, pré-installé depuis Windows 10 1803). Sur Linux, c'est WebKitGTK.

Cette décision architecturale est radicale. Elle signifie que Tauri ne se contente pas de réduire la taille du binaire : il supprime un problème de classe entier.

Tauri 2 : ce qui change par rapport à Tauri 1

Tauri 1, sorti en 2022, posait les bases. Tauri 2, publié en version stable en octobre 2024 et largement adopté en 2025-2026, apporte plusieurs ruptures majeures :

Support mobile : iOS et Android sont désormais des cibles officielles via le même projet Tauri, ce qui ouvre des perspectives de code frontend partagé entre desktop et mobile.
Système de plugins v2 : les plugins officiels (filesystem, notifications, shell, tray, deep linking, SQL, Biometric…) sont modularisés et versionnés indépendamment. On n'embarque que ce qu'on utilise.
API Rust réarchitecturée : le core Tauri utilise désormais `tauri::Builder` avec un système d'état typé, des scopes de permissions plus fins et une gestion des fenêtres multi-window nettement plus stable.
Isolation des fenêtres : chaque fenêtre peut avoir son propre niveau de permissions, ce qui permet de créer des apps avec des zones sandboxées (utile pour afficher du contenu tiers sans exposer toutes les API système).
CSP (Content Security Policy) appliquée par défaut : la sécurité n'est plus optionnelle.

En 2026, Tauri 2 est la version de référence. Tauri 1 est en maintenance uniquement.

Pourquoi Next.js côté front ?

Next.js est aujourd'hui le framework React dominant, avec un écosystème de composants, de librairies d'UI et de tooling inégalé. Tauri accepte n'importe quel framework web comme front-end (React, Vue, Svelte, SolidJS…), mais Next.js présente un avantage particulier : son mode export statique (`output: 'export'`) génère un dossier `out/` de fichiers HTML/CSS/JS purs, que Tauri sert directement depuis le binaire, sans serveur Node.js embarqué. Résultat : une app desktop ultra-légère qui démarre en moins d'une seconde.

---

Tauri vs Electron : les chiffres qui parlent (RAM, taille)

Les mesures suivantes sont issues de benchmarks réalisés sur une app "hello world" enrichie (liste dynamique, navigation multi-pages, appels backend), sur Windows 11 23H2 / macOS Sonoma 14.4 / Ubuntu 24.04.

| Critère | Electron 32 | Tauri 2 | |---|---|---| | RAM au démarrage | 185-220 Mo | 28-45 Mo | | RAM sous charge (CRUD) | 280-380 Mo | 55-90 Mo | | Taille installateur Windows | 75-90 Mo | 2.5-4 Mo | | Taille installateur macOS | 85-110 Mo | 4-7 Mo | | Taille installateur Linux | 65-80 Mo | 3-6 Mo | | Temps de démarrage à froid | 2.5-4 s | 0.3-0.8 s | | Processus background | 5-8 processus | 1-2 processus |

Ces chiffres ne sont pas marginaux. Pour un outil interne déployé sur 50 postes, la différence en RAM représente 7 à 15 Go de mémoire libérée sur le parc. Sur des machines de terrain avec 8 Go de RAM, c'est la différence entre un outil fluide et un outil qui rame à côté d'Excel et d'un navigateur ouvert.

La taille de l'installateur impacte aussi le déploiement : un installateur de 3 Mo se distribue par mail ou partage réseau, pas besoin d'un CDN ou d'un dépôt de packages interne.

---

Setup Next.js + Tauri en 10 minutes

Prérequis

Avant de démarrer, votre machine doit disposer de :

Node.js 20+ et pnpm (ou npm)
Rust stable (installé via `rustup` : `curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh`)
Sur Windows : Microsoft C++ Build Tools (Visual Studio Build Tools 2022 minimum)
Sur Linux : `libwebkit2gtk-4.1-dev`, `libssl-dev`, `libgtk-3-dev`

Étape 1 : créer le projet Next.js

```bash pnpm create next-app mon-app --typescript --app --no-tailwind cd mon-app ```

Modifiez `next.config.ts` pour activer l'export statique :

```typescript import type { NextConfig } from 'next'

const nextConfig: NextConfig = { output: 'export', trailingSlash: true, images: { unoptimized: true, // WebView locale ne gère pas l'optimisation serveur }, }

export default nextConfig ```

Étape 2 : initialiser Tauri dans le projet

```bash pnpm add -D @tauri-apps/cli pnpm tauri init ```

Le wizard vous pose 5 questions :

Nom de l'app → `Mon App`
Nom de la fenêtre → `Mon App`
Chemin du frontend → `../out` (le dossier d'export Next.js)
URL de dev → `http://localhost:3000`
Commande de dev frontend → `pnpm dev`

Étape 3 : scripts package.json

```json { "scripts": { "dev": "next dev", "build": "next build", "tauri": "tauri", "tauri:dev": "tauri dev", "tauri:build": "next build && tauri build" } } ```

Lancez `pnpm tauri:dev` : Next.js démarre sur le port 3000, Tauri ouvre une fenêtre native qui pointe dessus. Vous avez Hot Module Replacement côté Next.js ET rechargement auto Rust côté backend. Le setup complet prend entre 7 et 15 minutes selon la vitesse de compilation Rust initiale (le premier build compile la chaîne complète ; les suivants sont cachés et durent 2-4 secondes).

---

Backend Rust en 30 lignes : commands et événements

Le modèle command/invoke

Tauri expose vos fonctions Rust au frontend via un système de "commands". Côté JavaScript, vous appelez `invoke('nom_command', { args })`. Côté Rust, vous décorez vos fonctions avec `#[tauri::command]`.

Voici un exemple complet dans `src-tauri/src/main.rs` :

```rust use tauri::Manager;

#[tauri::command] fn lire_fichier(chemin: String) -> Result<String, String> { std::fs::read_to_string(&chemin) .map_err(|e| e.to_string()) }

#[tauri::command] fn ecrire_fichier(chemin: String, contenu: String) -> Result<(), String> { std::fs::write(&chemin, contenu) .map_err(|e| e.to_string()) }

#[tauri::command] fn version_app() -> String { env!("CARGO_PKG_VERSION").to_string() }

fn main() { tauri::Builder::default() .invoke_handler(tauri::generate_handler![ lire_fichier, ecrire_fichier, version_app ]) .run(tauri::generate_context!()) .expect("Erreur au démarrage Tauri"); } ```

Côté Next.js, dans un composant React :

```typescript import { invoke } from '@tauri-apps/api/core'

async function chargerConfig() { const contenu = await invoke<string>('lire_fichier', { chemin: '/Users/user/.monapp/config.json' }) return JSON.parse(contenu) } ```

Événements bidirectionnels

Pour des opérations longues (import CSV, synchronisation réseau, traitement de fichiers volumineux), Tauri propose un système d'événements. Le backend Rust émet des événements pendant le traitement, le frontend écoute et met à jour l'UI en temps réel :

```rust use tauri::Emitter;

#[tauri::command] async fn traiter_fichiers( app: tauri::AppHandle, dossier: String, ) -> Result<(), String> { let fichiers = std::fs::read_dir(&dossier) .map_err(|e| e.to_string())?;

for (i, entry) in fichiers.enumerate() { let nom = entry.unwrap().file_name(); app.emit("progression", serde_json::json!({ "index": i, "fichier": nom.to_string_lossy() })).ok(); } Ok(()) } ```

Côté React avec `useEffect` :

```typescript import { listen } from '@tauri-apps/api/event'

useEffect(() => { const unlisten = listen<{ index: number; fichier: string }>( 'progression', (event) => setProgression(event.payload) ) return () => { unlisten.then(f => f()) } }, []) ```

---

Accès système : filesystem, notifications, tray

Plugin filesystem

Tauri 2 gère l'accès au système de fichiers via le plugin officiel `@tauri-apps/plugin-fs`, avec un système de scopes déclarés dans `tauri.conf.json`. Vous ne pouvez accéder qu'aux chemins explicitement autorisés, ce qui élimine une classe entière de vulnérabilités.

```json { "plugins": { "fs": { "scope": { "allow": ["$APPDATA/", "$DOCUMENT/", "$DOWNLOAD/"], "deny": ["$APPDATA//.env"] } } } } ```

Côté TypeScript :

```typescript import { readTextFile, writeTextFile, BaseDirectory } from '@tauri-apps/plugin-fs'

const config = await readTextFile('config.json', { baseDir: BaseDirectory.AppData }) ```

Notifications natives

```bash pnpm add @tauri-apps/plugin-notification ```

```typescript import { sendNotification, requestPermission } from '@tauri-apps/plugin-notification'

const permission = await requestPermission() if (permission === 'granted') { sendNotification({ title: 'Synchronisation terminée', body: '247 enregistrements importés avec succès.' }) } ```

Les notifications passent par le système de notification natif de l'OS : Centre de notification macOS, Action Center Windows, ou les notifications système Linux. Aucune dépendance tiers, aucun binaire supplémentaire.

System Tray

Le system tray (icône dans la barre des tâches) est un must pour les outils métier qui tournent en arrière-plan :

```rust use tauri::{ menu::{MenuBuilder, MenuItemBuilder}, tray::TrayIconBuilder, };

fn main() { tauri::Builder::default() .setup(|app| { let quitter = MenuItemBuilder::with_id("quitter", "Quitter").build(app)?; let menu = MenuBuilder::new(app).items(&[&quitter]).build()?;

TrayIconBuilder::new() .menu(&menu) .icon(app.default_window_icon().unwrap().clone()) .on_menu_event(|app, event| { if event.id().as_ref() == "quitter" { app.exit(0); } }) .build(app)?; Ok(()) }) .run(tauri::generate_context!()) .expect("Erreur Tauri"); } ```

---

Packaging multi-OS : Windows, Mac, Linux et signatures

Configuration de base

Le fichier `tauri.conf.json` contrôle tout le packaging :

```json { "bundle": { "active": true, "targets": "all", "identifier": "com.monentreprise.monapp", "icon": [ "icons/32x32.png", "icons/128x128.png", "icons/128x128@2x.png", "icons/icon.icns", "icons/icon.ico" ], "version": "1.0.0" } } ```

La commande `pnpm tauri build` génère automatiquement :

Windows : `.msi` (via WiX Toolset) et `.exe` NSIS
macOS : `.dmg` et `.app` bundle
Linux : `.deb`, `.rpm`, `.AppImage`

Signatures de code

Sans signature de code, Windows SmartScreen bloquera l'exécution et macOS affichera une alerte Gatekeeper. En 2026, les signatures sont non-négociables pour tout déploiement professionnel.

Windows : certificat EV ou OV acheté auprès d'un CA reconnu (DigiCert, Sectigo, Certum). Coût : 200-500 €/an. La signature se configure via les variables d'environnement `TAURI_SIGNING_PRIVATE_KEY` et s'intègre dans la CI/CD.

macOS : Developer ID Certificate via le Apple Developer Program (99 $/an). Tauri 2 supporte la notarisation automatique via `APPLE_ID`, `APPLE_PASSWORD` et `APPLE_TEAM_ID` en variables d'environnement.

Linux : les packages `.deb` et `.rpm` peuvent être signés GPG. L'AppImage est auto-contenue et ne nécessite pas de signature systématique.

Mise à jour automatique

Tauri 2 inclut un système d'auto-update signé. Votre serveur expose un fichier JSON `latest.json` avec le numéro de version et les URLs des builds par plateforme. L'app vérifie à l'ouverture, télécharge la mise à jour en arrière-plan et l'applique au prochain redémarrage. Ce mécanisme évite d'avoir à maintenir un store ou un dépôt de packages propre.

---

Cas d'usage PME : outils internes desktop crossplatform

C'est là que Tauri 2 devient particulièrement pertinent pour les entreprises françaises qui gèrent des équipes terrain, des processus métier internes ou des workflows qui ne se prêtent pas à une app web pure.

Exemple 1 : outil de saisie terrain déconnecté

Une PME de logistique en Corrèze avait besoin d'un outil de saisie de bons de livraison utilisable sans connexion internet (entrepôts, zones blanches). L'app Tauri stocke les données localement en SQLite via le plugin `tauri-plugin-sql`, synchronise automatiquement dès qu'un réseau est détecté, et tourne sur les vieux PC Windows 10 du parc existant. L'installateur de 3.2 Mo se déploie par GPO sur tout le parc en 5 minutes. C'est exactement l'approche que nous décrivons dans notre article sur les [local-first apps et leur impact sur le web en 2026](/posts/local-first-apps--la-tendance-qui-rvolutionne-le-web-en-2026).

Exemple 2 : dashboard de supervision avec données temps réel

Un bureau d'études industriel affiche des métriques machines en temps réel depuis une API REST interne. L'app Tauri scrute l'API toutes les 5 secondes via des commandes Rust asynchrones (tokio), affiche les données dans une interface Next.js avec recharts, et émet une notification système si un seuil est dépassé. L'équipe React existante a pris en charge le projet sans apprendre Rust en profondeur : seules 80 lignes de Rust étaient nécessaires pour le polling et les notifications.

Exemple 3 : générateur de devis et PDF

Un artisan du bâtiment avait un tableur Excel vieillissant pour ses devis. L'app Tauri utilise une librairie Rust (`printpdf` ou `typst`) pour générer des PDF directement sur le disque, sans passer par un serveur. Le formulaire Next.js est identique à ce que l'équipe aurait fait pour une app web. Le résultat : une app de 4 Mo, utilisable hors ligne, qui génère des PDFs professionnels en 200ms. Ce type d'outil s'inscrit parfaitement dans la logique des [applications PWA ou des outils métier embarqués](/posts/pwa-application-web-progressive-entreprise) que nous recommandons selon les contextes.

Estimation de coût et délais

Pour un outil interne "simple" (CRUD + quelques accès système) :

| Phase | Durée estimée | Profil | |---|---|---| | Setup + architecture | 1-2 jours | Dev full-stack | | Front Next.js | 5-10 jours | Dev React | | Commands Rust | 2-4 jours | Dev avec notions Rust | | Packaging + signatures | 1-2 jours | DevOps | | Tests multi-OS | 2-3 jours | QA | | Total | 11-21 jours | |

---

Limites actuelles et écosystème Tauri 2

Les limites réelles à connaître

Inconsistances WebView selon l'OS : WebKit (macOS/Linux) et WebView2 (Windows) ne sont pas identiques. Des CSS avancés, certaines API Web ou des comportements de rendu peuvent différer. Le test multi-OS est impératif, pas optionnel. Des outils comme `@tauri-apps/api/webview` permettent de détecter l'OS et d'adapter l'UI.

Rust a une courbe d'apprentissage : pour un front-end pur, votre équipe React n'a pas besoin de maîtriser Rust. Mais dès que la logique backend devient complexe (parsing, réseau bas niveau, accès hardware), il faut un développeur Rust. Les alternatives : utiliser des binaires externes lancés via le plugin `shell`, ou encapsuler de la logique Node.js dans un sidecar process.

Pas de rendu côté serveur : Tauri utilise Next.js en mode export statique. Toutes les fonctionnalités Next.js nécessitant un serveur (Server Actions, API Routes, Server Components avec fetch runtime) ne sont pas disponibles. La logique serveur doit migrer dans les commands Rust.

Debugging limité : les DevTools WebKit sur macOS sont moins riches que Chrome DevTools. Sur Windows, WebView2 propose un accès DevTools complet. Le debugging Rust s'appuie sur `println!` / `tracing` ou un debugger LLDB/GDB, pas sur un équivalent de Chrome DevTools Protocol.

L'écosystème en 2026

Plugins officiels : filesystem, notification, shell, sql, store, deep-link, biometric, barcode-scanner, clipboard, global-shortcut, http, log, os, positioner, single-instance, updater, websocket — soit plus de 20 plugins maintenus par la core team.
Awesome Tauri : répertoire GitHub communautaire avec des templates, des exemples et des plugins tiers en croissance rapide.
Tauri v3 : en développement, avec un focus sur le partage de code entre desktop et mobile encore plus poussé.
Intégration CI/CD : GitHub Actions dispose d'une action officielle `tauri-apps/tauri-action` qui gère la compilation cross-plateforme (macOS runner pour la notarisation, Windows runner pour WiX, Ubuntu runner pour Debian/AppImage) et publie les artefacts sur GitHub Releases.

Pour les équipes qui s'interrogent sur les outils d'automatisation complémentaires à ce type de workflow (CI/CD, webhooks post-déploiement, notifications automatiques), notre comparatif [Zapier, Make, n8n](/posts/zapier-make-n8n-comparatif-automatisation) détaille les options selon la maturité technique de l'équipe. Et si la question de la sécurité de vos apps desktop et web se pose — notamment pour les PME qui ouvrent des ports réseau depuis un outil Tauri — notre guide sur la [cybersécurité TPE/PME](/posts/cybersecurite-tpe-pme-protection-2026) liste les actions prioritaires.

---

Questions fréquentes sur Tauri 2 app desktop Next.js

Tauri 2 peut-il remplacer Electron pour toutes les applications ? Non, pas systématiquement. Les apps qui dépendent fortement de l'API Node.js embarquée dans Electron (accès à des modules npm natifs, usage de worker_threads complexes) nécessitent une réécriture plus profonde. Tauri est idéal pour les apps dont la logique métier peut s'exprimer en Rust ou via des binaires tiers, et dont le front-end est un SPA ou un export statique.

Est-ce que Next.js fonctionne vraiment bien en mode export statique dans Tauri ? Oui, avec quelques contraintes. Les Server Components avec data-fetching côté serveur, les API Routes et les Server Actions ne fonctionnent pas. Tout appel réseau ou logique backend doit passer par les commandes Tauri (Rust) ou des APIs externes appelées côté client. Le reste de l'écosystème React/Next.js (hooks, contexte, react-query, zustand, UI components) fonctionne normalement.

Faut-il maîtriser Rust pour utiliser Tauri 2 ? Un niveau basique suffit pour 80 % des projets : lire/écrire des fichiers, appeler une API HTTP, manipuler des chaînes. La documentation officielle de Tauri fournit des snippets prêts à l'emploi. Pour des besoins avancés (threading, parsing binaire, accès hardware), un développeur Rust est nécessaire. Des agences comme ConsilioWEB peuvent intervenir en renfort sur la partie Rust.

Quelle est la compatibilité Windows minimale de Tauri 2 ? Windows 10 version 1803 (build 17134) est le minimum requis, car c'est la version qui intègre WebView2 Runtime par défaut. Pour les parcs plus anciens, l'installateur Tauri peut embarquer le WebView2 bootstrapper qui installe automatiquement le runtime si absent.

Le mode dev Tauri + Next.js impacte-t-il la vitesse de développement ? Légèrement, surtout au premier `cargo build` qui peut prendre 2 à 5 minutes. Ensuite, le rebuild incrémental Rust prend 2 à 10 secondes selon la quantité de code modifié, pendant que Next.js HMR fonctionne en moins de 500ms. Le workflow de développement quotidien reste très fluide une fois le cache de compilation warm.

---

Tauri 2 Next.js en production : le bon moment pour passer à l'action

En 2026, la stack Tauri 2 app desktop Next.js n'est plus expérimentale. Elle est stable, documentée, et adoptée par des projets sérieux : des outils de productivité comme Spacedrive, des clients Git comme GitButler, des éditeurs de code comme Zed (partiellement) s'appuient sur Tauri ou une architecture similaire. L'écosystème Rust a mûri, les plugins officiels couvrent 95 % des besoins courants, et les builders CI/CD automatisent la distribution multi-OS.

Pour les PME françaises, l'argument est simple : si vous avez déjà une équipe capable de faire du React ou du Next.js, vous avez 80 % des compétences nécessaires pour livrer une app desktop professionnelle. Le delta Rust se comble rapidement, ou peut être délégué à un prestataire pour la durée du projet.

Les performances (RAM, taille, vitesse de démarrage) ne sont pas des détails techniques : elles impactent l'adoption par les utilisateurs, le coût de déploiement sur le parc, et la satisfaction quotidienne des équipes terrain. Une app qui démarre en 400ms et consomme 40 Mo de RAM s'efface derrière le travail. Une app Electron qui prend 3 secondes et sature la mémoire devient un obstacle.

Si vous envisagez de doter vos équipes d'un outil desktop sur mesure — qu'il s'agisse d'un outil de saisie, d'un tableau de bord de supervision, d'un générateur de documents ou d'un client lourd pour votre ERP — notre équipe à Ussel peut auditer vos besoins, estimer le projet et vous proposer une architecture adaptée à votre parc existant et à votre équipe. Découvrez aussi comment ce type d'investissement s'inscrit dans une stratégie digitale globale pour les PME en consultant notre guide sur la [refonte de site web et son coût réel](/posts/refonte-site-web--combien-a-cote-vraiment-en-2026) ou notre article sur les [PME en zone rurale et leur stratégie digitale](/posts/pme-zone-rurale-strategie-digitale).

Contactez-nous via [le formulaire de devis](/contact) pour un premier échange sans engagement.

---

Pour aller plus loin

[Documentation officielle Tauri 2](https://v2.tauri.app/) — guides, API reference, plugins officiels, migration depuis Tauri 1
[Tauri GitHub — awesome-tauri](https://github.com/tauri-apps/awesome-tauri) — templates, plugins communautaires, exemples de projets
[The Rust Programming Language (Book)](https://doc.rust-lang.org/book/) — ressource gratuite officielle pour apprendre Rust, indispensable pour le backend Tauri
[Next.js Static Exports documentation](https://nextjs.org/docs/app/building-your-application/deploying/static-exports) — guide officiel sur les contraintes et possibilités du mode export statique
[WebView2 Runtime documentation — Microsoft](https://developer.microsoft.com/fr-fr/microsoft-edge/webview2/) — tout sur le moteur WebView2 utilisé par Tauri sur Windows

Tauri 2 : apps desktop avec Next.js sans Electron 2026