Tauri und Rust: Desktop-Anwendungen schlank und sicher bauen

Wie Tauri 2 ein Web-Frontend mit einem Rust-Kern verbindet, was das Rechtesystem leistet und wo die Grenzen gegenüber Electron liegen
Aktualisiert:
Abstract
- #Tauri
- #Rust
- #Desktop-Entwicklung
- #Cross-Platform
- #Webtechnologien
- #Electron
- #JavaScript
- #Frontend
- #Backend
- #Sicherheit
- #Performance
Warum eine Desktop-App keinen eigenen Browser mitbringen muss – und was Teams dafür in Kauf nehmen
Ein kleines Werkzeug für die Zeiterfassung, ein Etikettendrucker-Programm für das Lager, eine Oberfläche für die Konfiguration einer Maschine: Viele Unternehmen brauchen Desktop-Anwendungen, die auf Windows, macOS und Linux laufen. Lange war die bequemste Antwort Electron. Das Framework packt eine komplette Chromium-Browser-Engine samt Node.js in jede App. Das funktioniert zuverlässig, macht aber selbst einfache Programme zu Paketen von deutlich über hundert Megabyte, die beim Start spürbar Arbeitsspeicher belegen.
Tauri geht einen anderen Weg. Die Oberfläche entsteht weiterhin mit HTML, CSS und JavaScript, angezeigt wird sie aber in der Web-Komponente, die das Betriebssystem ohnehin mitbringt. Die Programmlogik, die Zugriff auf Dateien, Netzwerk und Hardware braucht, steckt in einem kleinen Kern in Rust. Seit Version 2.0, die im Herbst 2024 erschien, unterstützt Tauri neben den drei Desktop-Systemen auch iOS und Android. Wie funktioniert das im Detail, und für welche Projekte passt dieser Weg?
Was Tauri ist und wie es aufgebaut ist
Tauri ist ein quelloffenes Framework für Anwendungen, deren Oberfläche aus Webtechnik besteht. Es steht unter den Lizenzen MIT und Apache 2.0 und wird als „Tauri Programme“ unter dem Dach der gemeinnützigen niederländischen Commons Conservancy organisiert. Eine Tauri-App besteht aus zwei Teilen, die in getrennten Prozessen laufen.
Das Frontend im Webview
Das Frontend ist eine gewöhnliche Webanwendung. Ob sie mit React, Vue, Svelte, Angular, Solid oder ganz ohne Framework gebaut ist, spielt für Tauri keine Rolle. Voraussetzung ist nur, dass am Ende statische Dateien herauskommen, also HTML, CSS und JavaScript. Angezeigt werden sie in einem Webview, einer eingebetteten Browser-Komponente ohne Adressleiste. Tauri nutzt dafür auf jedem System die vorhandene Engine: WebView2 auf Windows (auf Basis von Microsoft Edge und damit Chromium), WKWebView auf macOS und iOS (WebKit, die Engine von Safari), WebKitGTK auf Linux und den System-Webview auf Android.
Der Kern in Rust
Der zweite Teil ist ein Rust-Programm. Rust ist eine kompilierte Systemsprache, die Speicherfehler wie Pufferüberläufe oder den Zugriff auf bereits freigegebenen Speicher schon beim Übersetzen verhindert, ohne einen Garbage Collector zu benötigen. Der Kern öffnet die Fenster, verwaltet Menüs und Tray-Symbole und stellt dem Frontend Funktionen bereit. Wer keine eigene Logik in Rust schreiben möchte, kommt für einfache Apps mit den fertigen Plugins aus. Spätestens bei rechenintensiven Aufgaben, Gerätezugriffen oder Hintergrundprozessen lohnen sich aber Grundkenntnisse in Rust.
Die Brücke: Commands und Events
Frontend und Kern sprechen über eine Nachrichtenschnittstelle miteinander, die Tauri IPC (Inter-Process Communication) nennt. Das Frontend ruft benannte Commands auf, das sind Rust-Funktionen mit einer Markierung. Umgekehrt kann der Kern Events an das Frontend schicken, etwa den Fortschritt eines langen Imports. Die Daten werden dabei als JSON übertragen, größere Binärdaten seit Version 2 auch direkt.
Tauri und Electron im Vergleich
Der Vergleich mit Electron ist der naheliegendste, denn beide Frameworks lösen dasselbe Problem. Die Unterschiede liegen in der Architektur und haben Folgen für Größe, Verhalten und Aufwand.
| Kriterium | Tauri | Electron |
|---|---|---|
| Browser-Engine | System-Webview, je nach Plattform anders | Mitgeliefertes Chromium, überall gleich |
| Programmlogik | Rust, ergänzt durch Plugins | Node.js (JavaScript oder TypeScript) |
| Paketgröße | typischerweise wenige Megabyte | typischerweise weit über 100 Megabyte |
| Zugriffsrechte | standardmäßig gesperrt, explizit freigeben | Node-APIs im Hauptprozess voll verfügbar |
| Mobile Plattformen | iOS und Android seit Version 2 | nicht vorgesehen |
| Ökosystem | jünger, wächst | groß und seit Jahren erprobt |
Die geringe Paketgröße ist das sichtbarste Argument. Sie entsteht schlicht dadurch, dass Tauri keine Browser-Engine mitliefert. Auch der Speicherbedarf fällt meist kleiner aus, wobei hier der Webview des Systems den größten Teil ausmacht und die Unterschiede stark von der jeweiligen App abhängen. Pauschale Faktoren, wie sie in Vergleichstabellen kursieren, sollten Sie mit Vorsicht lesen.
Der Preis für die schlanken Pakete ist die Abhängigkeit vom System. Eine App, die auf dem Entwicklerrechner unter Windows einwandfrei aussieht, kann in Safaris Engine auf dem Mac eine CSS-Eigenschaft anders darstellen oder eine neuere Web-API noch nicht kennen. Unter Linux hängt das Verhalten von der installierten WebKitGTK-Version der Distribution ab. Electron dagegen bringt überall dasselbe Chromium mit und verhält sich entsprechend einheitlich. Einen ausführlichen Praxisvergleich beider Frameworks, inklusive einer Next.js-Integration, finden Sie im Beitrag Electron vs. Tauri: der praktische Vergleich für Desktop-Apps.
Die erste Tauri-App einrichten
Für den Einstieg brauchen Sie eine aktuelle Rust-Installation über rustup, Node.js mit einem Paketmanager und die Systemvoraussetzungen der jeweiligen Plattform. Unter Windows sind das die C++-Build-Tools von Visual Studio und WebView2, das auf aktuellen Windows-Versionen bereits vorinstalliert ist. Unter macOS genügen die Xcode Command Line Tools, unter Linux die Entwicklerpakete von WebKitGTK und einigen Bibliotheken, die die Tauri-Dokumentation je Distribution auflistet.
Ein neues Projekt legt der offizielle Assistent an. Er fragt nach Paketmanager, Frontend-Framework und Sprache und erzeugt ein lauffähiges Grundgerüst:
npm create tauri-app@latest zeiterfassung
cd zeiterfassung
npm install
npm run tauri dev
Der letzte Befehl startet den Entwicklungsserver des Frontends, übersetzt den Rust-Kern und öffnet ein Fenster mit der App. Änderungen am Frontend erscheinen sofort, Änderungen am Rust-Code lösen eine neue Übersetzung aus. Der erste Durchlauf dauert spürbar länger, weil Cargo, der Paketmanager von Rust, alle Abhängigkeiten herunterlädt und kompiliert. Für die Auslieferung erzeugt npm run tauri build Installationspakete für das jeweilige System, etwa MSI- oder NSIS-Installer unter Windows, DMG-Dateien unter macOS sowie Debian-Pakete, RPM und AppImage unter Linux.
Was im Projekt liegt
- Im Projektwurzelverzeichnis liegt das Frontend, aufgebaut wie jedes andere Webprojekt mit
package.jsonund Build-Werkzeug, häufig Vite. - Der Ordner
src-taurienthält den Rust-Kern. Insrc/lib.rswird die App zusammengesetzt,src/main.rsruft sie nur auf. Abhängigkeiten stehen inCargo.toml. src-tauri/tauri.conf.jsonbeschreibt App-Name, Kennung, Fenster, Build-Befehle und Paketierung.- Im Ordner
src-tauri/capabilitieslegen JSON-Dateien fest, welche Fenster welche Rechte erhalten. Dazu gleich mehr.
Commands: Rust-Funktionen aus dem Frontend aufrufen
Angenommen, die Zeiterfassung soll die erfassten Stunden eines Monats zusammenrechnen. Die Berechnung gehört in den Kern, weil sie später vielleicht auf eine lokale Datenbank zugreift. Im Rust-Code sieht das so aus:
// src-tauri/src/lib.rs
#[tauri::command]
fn summe_stunden(eintraege: Vec<f64>) -> f64 {
eintraege.iter().sum()
}
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
tauri::Builder::default()
.plugin(tauri_plugin_dialog::init())
.plugin(tauri_plugin_fs::init())
.invoke_handler(tauri::generate_handler![summe_stunden])
.run(tauri::generate_context!())
.expect("Fehler beim Start der Anwendung");
}
Das Attribut #[tauri::command] macht die Funktion für das Frontend aufrufbar, generate_handler! registriert sie. Im Frontend genügt ein Aufruf von invoke mit dem Namen des Commands und den Argumenten:
import { invoke } from '@tauri-apps/api/core';
const stunden = await invoke<number>('summe_stunden', {
eintraege: [7.5, 8, 6.25],
});
console.log(`Summe: ${stunden} Stunden`);
Tauri wandelt die Argumente in Rust-Typen um und prüft dabei die Struktur. Kommt statt einer Zahlenliste etwas anderes an, scheitert der Aufruf mit einer Fehlermeldung, statt mit falschen Daten weiterzurechnen. Commands können auch asynchron sein und Fehler als Result zurückgeben, die im Frontend als abgelehntes Promise ankommen.
Dateien und Dialoge über Plugins
In Tauri 1 steckten Funktionen wie Dateizugriff und Dialoge direkt im Paket @tauri-apps/api. Mit Version 2 wurden sie in eigenständige Plugins ausgelagert. Ältere Tutorials, die import { writeFile } from '@tauri-apps/api/fs' verwenden, funktionieren deshalb nicht mehr. Die Plugins installiert der Befehl npm run tauri add, etwa npm run tauri add fs und npm run tauri add dialog. Er ergänzt die Rust-Abhängigkeit, das JavaScript-Paket und eine Grundberechtigung.
Ein Beispiel, das nach einer Rückfrage einen Monatsbericht in das Datenverzeichnis der App schreibt:
import { ask } from '@tauri-apps/plugin-dialog';
import { writeTextFile, BaseDirectory } from '@tauri-apps/plugin-fs';
async function berichtSpeichern(inhalt: string) {
const bestaetigt = await ask('Monatsbericht jetzt speichern?', {
title: 'Zeiterfassung',
kind: 'info',
});
if (!bestaetigt) return;
await writeTextFile('bericht.txt', inhalt, {
baseDir: BaseDirectory.AppData,
});
}
Ohne passende Berechtigung schlägt der Schreibzugriff fehl, auch wenn der Code korrekt ist. Das ist kein Fehler, sondern das zentrale Sicherheitsprinzip von Tauri.
Sicherheit: Rechte müssen ausdrücklich vergeben werden
In Electron hat der Hauptprozess grundsätzlich vollen Zugriff auf das System. Ob das Frontend diesen Zugriff mitbenutzen darf, hängt von Einstellungen ab, die Entwicklerteams korrekt setzen müssen. Tauri dreht das Prinzip um: Das Frontend darf zunächst fast nichts. Jede Fähigkeit muss in einer Capability freigegeben werden, einer JSON-Datei, die Berechtigungen bestimmten Fenstern zuordnet.
{
"$schema": "../gen/schemas/desktop-schema.json",
"identifier": "default",
"description": "Rechte für das Hauptfenster",
"windows": ["main"],
"permissions": [
"core:default",
"dialog:allow-message",
{
"identifier": "fs:allow-write-text-file",
"allow": [{ "path": "$APPDATA/*" }]
}
]
}
Diese Datei erlaubt dem Hauptfenster eine Rückfrage per Dialog und das Schreiben von Textdateien, aber nur im Datenverzeichnis der App. Ein Skript, das über eine Sicherheitslücke ins Frontend gelangt, etwa durch eine kompromittierte npm-Abhängigkeit, könnte damit weder die Dokumente der Nutzerin auslesen noch beliebige Programme starten. Für Tauri 1 nutzte das Projekt noch eine einfachere „Allowlist“. Das Capability-System ist feiner und lässt sich je Fenster und Plattform unterschiedlich gestalten.
Dazu kommen weitere Schutzmechanismen. Eine Content Security Policy in tauri.conf.json legt fest, aus welchen Quellen das Frontend Skripte laden darf. Das optionale Isolation Pattern schaltet zwischen Frontend und Kern eine abgeschottete Zwischenschicht, die jede Nachricht prüfen und verwerfen kann. Und der Rust-Kern profitiert von der Speichersicherheit der Sprache. Wie Rust Datenwettläufe zwischen Threads schon beim Kompilieren ausschließt, beschreibt der Infothek-Beitrag zu Nebenläufigkeit und Asynchronität in Rust.
Ein Freibrief ist das alles nicht. Wer großzügig fs:default mit weitem Pfadbereich freigibt oder Shell-Befehle erlaubt, hebelt das Modell selbst aus. Auch Signatur der Installationspakete und sichere Updates bleiben Aufgabe des Teams. Tauri bringt dafür ein Updater-Plugin mit, das nur signierte Aktualisierungen annimmt.
Wo Tauri an Grenzen stößt
So überzeugend das Konzept ist, im Alltag zeigen sich einige Schwächen, die Sie vor einer Entscheidung kennen sollten:
- Unterschiedliche Webviews: Die App muss auf allen Zielplattformen getestet werden. Ein Team, das bisher nur für Chrome entwickelt hat, stößt auf WebKit-Eigenheiten, die es aus der Safari-Unterstützung von Websites kennt.
- Linux: WebKitGTK gilt als die schwächste der drei Engines, gerade bei Grafikleistung und neuen Web-APIs. Für Apps mit aufwendigen Animationen oder WebGL kann das relevant sein.
- Rust-Kenntnisse: Für einfache Apps genügen die Plugins. Wer eigene Logik im Kern braucht, muss Rust lernen. Die Sprache gilt als anspruchsvoll, vor allem das Konzept von Besitz und Ausleihe von Daten.
- Build-Zeiten und Werkzeuge: Rust-Projekte übersetzen langsamer als reine JavaScript-Projekte. Für Installer und Signaturen braucht es in der Regel Build-Rechner je Zielsystem, für macOS zusätzlich ein Entwicklerkonto bei Apple.
- Ökosystem: Für Electron gibt es mehr Bibliotheken, Beispiele und erfahrene Entwickler:innen. Bei Tauri fehlt für Spezialfälle eher ein fertiges Plugin.
Node.js-Bibliotheken lassen sich in Tauri nicht direkt im Kern nutzen. Wer auf ein bestimmtes Node-Paket angewiesen ist, kann es als sogenannten Sidecar mitliefern, also als separates Programm, das die App startet und mit dem sie kommuniziert. Das funktioniert, nimmt aber einen Teil des Größenvorteils wieder weg.
Was das für Ihr Projekt bedeutet
Tauri ist inzwischen ein ausgereiftes Werkzeug und keine Wette mehr auf ein junges Projekt. Für interne Werkzeuge, Konfigurationsoberflächen, Hilfsprogramme mit Tray-Symbol und Anwendungen, die auf vielen Rechnern verteilt werden, ist es aus unserer Sicht oft die bessere Wahl als Electron. Kleine Installationspakete, ein strenges Rechtemodell und ein Kern in einer speichersicheren Sprache sind handfeste Vorteile, gerade wenn die App mit sensiblen Daten arbeitet.
Electron bleibt sinnvoll, wenn eine App überall pixelgenau gleich aussehen muss, wenn sie stark auf Node.js-Bibliotheken angewiesen ist oder wenn das Team keine Zeit hat, sich in Rust einzuarbeiten. Auch für große, gewachsene Electron-Anwendungen lohnt eine Migration selten allein wegen der Paketgröße.
Unsere Empfehlung: Bauen Sie vor der Entscheidung einen kleinen Prototyp mit den wichtigsten Funktionen und testen Sie ihn früh auf allen Zielsystemen, auch unter Linux und auf einem Mac. Dann zeigt sich schnell, ob Webview-Unterschiede oder fehlende Plugins ins Gewicht fallen. Wenn Sie dabei Unterstützung beim Rust-Teil suchen, bietet die Seite zu Rust-Entwicklung mit Beratung, Coaching und Seminaren einen Überblick über Schulungen und Begleitung.
Häufige Fragen zu Tauri
Lässt sich eine bestehende Webanwendung mit Tauri zur Desktop-App machen?
In vielen Fällen ja. Voraussetzung ist, dass sich das Frontend als statische Dateien bauen lässt. Single-Page-Anwendungen mit React, Vue oder Svelte sind unproblematisch. Frameworks mit serverseitigem Rendering wie Next.js oder SvelteKit müssen in einen statischen Exportmodus wechseln, weil in der Desktop-App kein Node-Server läuft. Aufrufe an ein eigenes Backend im Netz funktionieren weiter.
Braucht ein Team Rust-Kenntnisse, um Tauri zu nutzen?
Nicht für den Anfang. Fenster lassen sich über die JavaScript-API des Kerns steuern, Dateizugriff, Dialoge, Benachrichtigungen, Zwischenablage und viele weitere Funktionen stehen über offizielle Plugins mit JavaScript-Schnittstelle bereit. Sobald eigene Logik im Kern nötig ist, etwa für Hardware, Datenbanken oder Rechenaufgaben, braucht das Team zumindest eine Person mit Rust-Erfahrung.
Wie aktualisieren sich Tauri-Apps?
Über das offizielle Updater-Plugin. Die App fragt eine konfigurierte Adresse nach einer neuen Version, lädt das Paket und prüft dessen Signatur, bevor sie es installiert. Den Schlüssel dafür erzeugt das Team mit dem Tauri-CLI. Alternativ übernehmen App-Stores oder die Softwareverteilung im Unternehmen die Aktualisierung.
Ist Tauri auch für mobile Apps geeignet?
Seit Version 2 lassen sich mit demselben Projekt auch Apps für iOS und Android bauen. Für reine Mobilprojekte sind etablierte Lösungen wie React Native, Flutter oder native Entwicklung meist ausgereifter. Interessant ist Tauri vor allem, wenn eine Desktop-App zusätzlich eine mobile Variante mit weitgehend gleichem Code bekommen soll.
Kategorien