Electron vs. Tauri: Desktop-Apps mit Webtechnik im Vergleich

Architektur, Paketgröße, Sicherheitsmodell, Updates und mobile Plattformen: wo sich die beiden Frameworks unterscheiden und was das für Projekte heißt
Aktualisiert:
Abstract
- #Electron
- #Tauri
- #Desktop-Apps
- #Web-Technologien
- #JavaScript
- #Rust
- #Performance
- #App-Größe
- #Next.js
- #React
Eigener Browser im Paket oder Webview des Systems – welches Framework passt zur nächsten Desktop-App?
Angenommen, ein Team hat eine Aufgabenverwaltung mit React oder Next.js gebaut. Sie läuft im Browser, die Kolleginnen im Vertrieb nutzen sie täglich. Dann kommt der Wunsch nach einer Desktop-Fassung: Sie soll offline funktionieren, Dateien lokal ablegen, ein Symbol in der Taskleiste haben und auf Windows-Laptops genauso laufen wie auf den Macs der Grafikabteilung. Die Oberfläche neu zu schreiben, kommt nicht infrage.
Für genau diesen Fall gibt es zwei verbreitete Frameworks: Electron und Tauri. Beide verpacken eine Webanwendung als installierbares Programm, beide laufen auf Windows, macOS und Linux. Unter der Haube unterscheiden sie sich aber grundlegend, und diese Unterschiede wirken sich auf Paketgröße, Sicherheit, Wartungsaufwand und die Zusammensetzung des Teams aus. Der folgende Vergleich geht die wichtigsten Kriterien durch und endet mit einer Entscheidungshilfe.
Die Grundlagen der beiden Frameworks behandeln eigene Beiträge: wie Electron-Apps aufgebaut sind und wie Tauri Web-Frontend und Rust-Kern verbindet. Hier geht es um die Gegenüberstellung.
Zwei Architekturen für dasselbe Problem
Electron: Chromium und Node.js im Paket
Electron liefert mit jeder App eine vollständige Chromium-Engine und eine Node.js-Laufzeit aus. Ein Main-Prozess, der in Node.js läuft, öffnet die Fenster und hat vollen Zugriff auf das Betriebssystem. Die Oberfläche läuft in Renderer-Prozessen, im Grunde Browser-Tabs ohne Adressleiste. Dazwischen vermittelt ein Preload-Skript, das ausgewählte Funktionen des Main-Prozesses für die Oberfläche freigibt.
Der Vorteil dieses Aufbaus liegt auf der Hand: Alles bleibt in der JavaScript-Welt, das gesamte npm-Ökosystem steht zur Verfügung, und die App sieht auf jedem System exakt gleich aus, weil überall dieselbe Engine rendert. Bekannte Programme wie Visual Studio Code, Slack, Discord und Obsidian basieren auf Electron.
Tauri: System-Webview und Kern in Rust
Tauri bringt keine eigene Browser-Engine mit. Es zeigt die Oberfläche im Webview an, den das Betriebssystem ohnehin bereitstellt: WebView2 unter Windows (Chromium-basiert, aus Microsoft Edge), WKWebView unter macOS (WebKit, die Engine von Safari) und WebKitGTK unter Linux. Die Programmlogik steckt in einem Kern, der in Rust geschrieben ist, einer kompilierten Sprache, die Speicherfehler schon beim Übersetzen verhindert. Oberfläche und Kern sprechen über eine Nachrichtenschnittstelle miteinander, die Tauri wie Electron IPC nennt (Inter-Process Communication).
Für viele Aufgaben müssen Teams dabei kein Rust schreiben. Dateizugriff, Dialoge, Benachrichtigungen oder Zwischenablage stellen offizielle Plugins mit JavaScript-Schnittstelle bereit. Eigene Logik im Kern, etwa für Gerätezugriffe oder rechenintensive Aufgaben, entsteht aber in Rust.
Paketgröße und Ressourcenbedarf: was sich belegen lässt
Der Größenunterschied ist das bekannteste Argument für Tauri, und er ist real. Schon die Electron-Laufzeit ohne eine einzige Zeile App-Code ist als ZIP-Archiv je nach Plattform rund 120 bis 160 Megabyte groß, entpackt deutlich mehr: In einer eigenen Messung (Electron 45.2.2, macOS auf einem Mac mit Apple-Chip) belegte eine gepackte Minimal-App rund 250 Megabyte. Eine minimale Tauri-App kann laut Projektdokumentation unter 600 Kilobyte groß sein. In derselben Messung kam die Vorlage von create-tauri-app (Tauri 2.12, Release-Build) als macOS-App auf rund 4 Megabyte.
Wichtig ist, woher der Unterschied kommt: Tauri spart die mitgelieferte Browser-Engine. Wächst das Frontend, wächst es in beiden Frameworks gleich. Eine App mit 40 Megabyte an Grafiken und Videos bleibt auch in Tauri groß.
Beim Arbeitsspeicher ist die Lage weniger eindeutig, als viele Vergleichstabellen suggerieren. Auch ein Tauri-Fenster startet einen Webview-Prozess, und der belegt Speicher. Unter Windows ist WebView2 technisch ebenfalls Chromium, nur eben die systemweit installierte Fassung. Pauschale Faktoren wie „zehnmal weniger RAM“ lassen sich nicht seriös angeben, denn das Ergebnis hängt stark von der App, dem System und der Messmethode ab. Wer den Speicherbedarf als Kriterium braucht, sollte einen Prototyp mit typischen Daten auf den eigenen Firmenrechnern messen.
Gleiche Aufgabe, zwei Wege: Daten lokal speichern
Wie unterschiedlich sich die Frameworks im Code anfühlen, zeigt eine typische Aufgabe: Die Aufgabenliste soll als JSON-Datei im Datenverzeichnis der App gespeichert werden.
Electron: Handler im Main-Prozess, Brücke im Preload
In Electron gehört der Dateizugriff in den Main-Prozess. Er registriert einen Handler, den die Oberfläche über das Preload-Skript aufrufen kann:
// main.js
const { app, BrowserWindow, ipcMain } = require('electron');
const fs = require('node:fs/promises');
const path = require('node:path');
ipcMain.handle('todos:speichern', async (_event, todos) => {
if (!Array.isArray(todos)) throw new Error('Ungültige Daten');
const datei = path.join(app.getPath('userData'), 'todos.json');
await fs.writeFile(datei, JSON.stringify(todos), 'utf8');
});
app.whenReady().then(() => {
const win = new BrowserWindow({
webPreferences: { preload: path.join(__dirname, 'preload.js') },
});
// Build einer Vite-App; zum Next.js-Export siehe den folgenden Abschnitt
win.loadFile(path.join(__dirname, 'dist', 'index.html'));
});
// preload.js
const { contextBridge, ipcRenderer } = require('electron');
// Nur eine fachliche Funktion freigeben, nicht ipcRenderer als Ganzes
contextBridge.exposeInMainWorld('todoApi', {
speichern: (todos) => ipcRenderer.invoke('todos:speichern', todos),
});
In der React-Oberfläche genügt dann await window.todoApi.speichern(todos). Der Main-Prozess kann jedes Node.js-Modul nutzen, also auch eine SQLite-Bibliothek, einen Druckertreiber-Wrapper oder einen lokalen Server.
Tauri: Command im Rust-Kern
In Tauri übernimmt diese Aufgabe ein Command, eine Rust-Funktion, die das Frontend aufrufen darf:
// src-tauri/src/lib.rs
use std::fs;
use tauri::Manager;
#[tauri::command]
fn todos_speichern(app: tauri::AppHandle, json: String) -> Result<(), String> {
let verzeichnis = app.path().app_data_dir().map_err(|e| e.to_string())?;
fs::create_dir_all(&verzeichnis).map_err(|e| e.to_string())?;
fs::write(verzeichnis.join("todos.json"), json).map_err(|e| e.to_string())
}
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
tauri::Builder::default()
.invoke_handler(tauri::generate_handler![todos_speichern])
.run(tauri::generate_context!())
.expect("Fehler beim Start der Anwendung");
}
// Aufruf im Frontend
import { invoke } from '@tauri-apps/api/core';
await invoke('todos_speichern', { json: JSON.stringify(todos) });
Alternativ ließe sich die Datei ohne eigenen Rust-Code über das offizielle Plugin @tauri-apps/plugin-fs schreiben. Dann muss das Team den Schreibzugriff aber ausdrücklich in einer Capability-Datei freigeben, dazu gleich mehr. Ältere Anleitungen, die @tauri-apps/api/fs importieren, stammen aus Tauri 1 und funktionieren mit Version 2 nicht mehr.
Der Vergleich zeigt das Grundmuster: Electron-Code ist für Web-Teams sofort vertraut. Tauri verlangt für eigene Logik etwas Rust, bekommt dafür aber geprüfte Typen an der Schnittstelle. Schickt das Frontend statt eines Strings etwas anderes, lehnt Tauri den Aufruf mit einer Fehlermeldung ab.
Next.js und andere Frameworks mit Server-Rendering
Bei Frameworks wie Next.js liegt ein Unterschied, den viele erst spät bemerken. Tauri liefert nur statische Dateien an den Webview aus, ein Node-Server läuft in der App nicht. Next.js muss deshalb im statischen Exportmodus gebaut werden:
// next.config.ts
import type { NextConfig } from 'next';
const nextConfig: NextConfig = {
output: 'export',
// Die Bildoptimierung braucht einen Server, im Export ist sie abgeschaltet
images: { unoptimized: true },
};
export default nextConfig;
Damit entfallen alle Funktionen, die zur Laufzeit einen Server voraussetzen: API-Routen, die auf die einzelne Anfrage reagieren, Server Actions, Middleware (seit Next.js 16 „Proxy“ genannt) und das inkrementelle Neuerzeugen von Seiten. Was vorher auf dem Server lief, wandert in den Rust-Kern oder in ein Backend im Netz. Welche Rendering-Strategien Next.js kennt und was der statische Export bedeutet, erklärt der Infothek-Beitrag zu SSR, SSG und Client-Rendering in Next.js.
Electron hat hier mehr Spielraum, weil Node.js ohnehin an Bord ist. Ein Team kann denselben statischen Export laden wie bei Tauri, oder es startet im Main-Prozess einen eingebetteten Next.js-Server und lässt die App mit diesem lokalen Server sprechen. Das erhält Server-Funktionen, macht die App aber größer und komplexer. Community-Projekte wie Nextron bündeln Next.js und Electron in einer Vorlage. Bei solchen Vorlagen lohnt vor dem Einsatz ein Blick darauf, wie aktiv sie gepflegt werden und welche Next.js-Version sie unterstützen.
Ein Detail betrifft beide Frameworks: Der statische Export von Next.js verweist auf Dateien mit absoluten Pfaden wie /_next/…. Lädt Electron die Seite direkt über das Dateisystem, laufen diese Pfade ins Leere. Üblich ist deshalb ein eigenes URL-Schema, das Electron über protocol.handle auf den Exportordner abbildet. Tauri löst das intern, weil es die Dateien ohnehin über ein eigenes Schema ausliefert.
Sicherheitsmodell: offen mit Schutzschichten oder zu mit Freigaben
Beide Frameworks lassen sich sicher betreiben. Der Ausgangspunkt ist aber verschieden, und das hat Folgen für die Fehleranfälligkeit.
Electron startet mit vollem Systemzugriff im Main-Prozess. Die Oberfläche ist über mehrere Schutzschichten davon getrennt, die das Projekt über die Jahre zum Standard gemacht hat: Node.js im Renderer ist seit Version 5 abgeschaltet, die Kontext-Isolation seit Version 12 aktiv, die Chromium-Sandbox für Renderer seit Version 20 Standard. Was die Oberfläche darf, entscheidet das Preload-Skript. Gibt es dort zu viel frei, etwa ipcRenderer als Ganzes, hat ein eingeschleustes Skript leichtes Spiel. Die Sicherheitscheckliste des Projekts ist deshalb Pflichtlektüre.
Tauri dreht das Prinzip um. Das Frontend darf zunächst fast nichts. Jede Fähigkeit eines Plugins, etwa Dateien zu schreiben oder Shell-Befehle auszuführen, muss in einer Capability freigegeben werden, einer JSON- oder TOML-Datei, die Berechtigungen einzelnen Fenstern zuordnet und auf Pfade begrenzen kann. Angenommen, eine kompromittierte npm-Abhängigkeit schleust Code in die Oberfläche: Mit sauber gesetzten Capabilities kann er weder die Dokumente der Nutzerin lesen noch Programme starten. Eigene Commands der App sind dagegen standardmäßig aufrufbar und sollten ihre Eingaben selbst prüfen.
Ein Freibrief ist keines der beiden Modelle. Auch in Tauri lässt sich mit großzügigen Freigaben wie weiten Dateipfaden oder erlaubten Shell-Befehlen das Schutzkonzept aushebeln. Code-Signierung, die Beglaubigung bei Apple (Notarisierung) und eine Content Security Policy bleiben in beiden Fällen Aufgabe des Teams.
Updates, Paketformate und Plattformen
Aktualisierungen ausliefern
Electron bringt ein autoUpdater-Modul mit, das unter macOS auf das Squirrel-Framework aufsetzt, unter Windows auf Squirrel.Windows oder bei MSIX-Paketen auf einen eigenen MSIX-Updater. Für quelloffene Apps auf GitHub betreibt das Projekt einen kostenlosen Update-Dienst. Viele Teams nutzen stattdessen electron-updater aus dem Werkzeug electron-builder, das unter anderem Updates aus GitHub Releases oder einem eigenen Server bezieht und für manche Formate nur geänderte Teile herunterlädt.
Tauri bietet ein offizielles Updater-Plugin. Es fragt eine konfigurierte Adresse nach einer neuen Version, lädt das Paket und installiert es nur, wenn die Signatur stimmt. Diese Prüfung lässt sich nicht abschalten. Den Schlüssel erzeugt das Team mit dem Tauri-CLI. Die Updates sind kleiner als bei Electron, weil schon das ganze Paket kleiner ist, nicht weil Tauri nur Änderungen überträgt.
Ein Punkt spricht beim Thema Sicherheit für Tauri, einer für Electron. Electron-Apps bringen ihre eigene Chromium-Version mit. Sicherheitskorrekturen im Browser kommen erst beim Nutzer an, wenn das Team Electron aktualisiert und eine neue App-Version ausliefert. Das Projekt veröffentlicht etwa alle acht Wochen eine neue Hauptversion und unterstützt jeweils die drei jüngsten. Tauri-Apps profitieren dagegen von den Updates des Betriebssystems für den Webview. Umgekehrt kann ein solches Update das Verhalten der App verändern, ohne dass das Team etwas ausgeliefert hat.
Paketformate und Stores
Tauri erzeugt unter Windows MSI- und NSIS-Installer, unter macOS App-Bundles und DMG-Dateien, unter Linux Debian- und RPM-Pakete sowie AppImages. Für Electron übernehmen Electron Forge oder electron-builder die Paketierung und decken zusätzlich Formate wie APPX/MSIX für den Microsoft Store oder Snap ab. Wer eine App zwingend als MSIX-Paket verteilen muss, etwa weil die Softwareverteilung im Unternehmen das verlangt, sollte wissen, dass Tauri laut Dokumentation derzeit nur EXE- und MSI-Installer erzeugt. Ein MSIX-Paket erfordert also einen zusätzlichen Schritt. Ältere Hinweise auf fehlende Universal-Binaries für Apple-Rechner mit Intel- und Apple-Chips sind überholt: Tauri kann solche Pakete bauen.
Mobile Plattformen
Hier liegt ein klarer Unterschied. Seit Version 2.0, die im Oktober 2024 erschien, baut Tauri aus demselben Projekt auch Apps für iOS und Android. Electron unterstützt nur Desktop-Systeme. Für ein reines Mobilprojekt sind React Native, Flutter oder native Entwicklung zwar meist ausgereifter. Soll eine Desktop-App aber zusätzlich eine Tablet-Fassung für den Außendienst bekommen, ist das in Tauri ein naheliegender Weg.
Ökosystem, Team und Wartung
Electron ist seit Jahren im Einsatz, entsprechend groß ist das Angebot an Bibliotheken, Anleitungen und erfahrenen Entwickler:innen. Für fast jedes Problem existiert ein npm-Paket oder eine dokumentierte Lösung. Wer Node-Bibliotheken für Hardware, Datenbanken oder Dateiformate braucht, nutzt sie direkt im Main-Prozess.
Tauri ist jünger und gemessen an Electron kleiner, aber seit Version 2 ein stabiles, aktiv entwickeltes Framework mit offiziellen Plugins für die meisten Alltagsaufgaben. Für Spezialfälle fehlt eher ein fertiges Plugin. Node-Bibliotheken lassen sich nicht direkt im Rust-Kern nutzen. Wer darauf angewiesen ist, liefert ein Node-Programm als Sidecar mit, also als separates Programm, das die App startet und mit dem sie kommuniziert. Das funktioniert, frisst aber einen Teil des Größenvorteils wieder auf, denn das Sidecar bringt seine eigene Laufzeit mit.
Für die Teamplanung zählt vor allem eine Frage: Gibt es jemanden, der Rust beherrscht oder lernen will? Rust gilt als anspruchsvoll, vor allem das Konzept von Besitz und Ausleihe von Daten. Rust-Projekte übersetzen außerdem langsamer als reine JavaScript-Projekte. Dazu kommt bei Tauri der Testaufwand auf drei Webviews: Eine CSS-Eigenschaft, die in Chromium funktioniert, kann in WebKit fehlen, und unter Linux hängt das Verhalten von der WebKitGTK-Version der Distribution ab.
Kriterien im Überblick
| Kriterium | Electron | Tauri |
|---|---|---|
| Browser-Engine | mitgeliefertes Chromium, überall gleich | Webview des Systems, je Plattform verschieden |
| Logik außerhalb der UI | Node.js (JavaScript, TypeScript) | Rust, ergänzt durch Plugins |
| Paketgröße | Laufzeit allein über 100 Megabyte | laut Doku ab unter 1 MB, Vorlage rund 4 MB |
| Rechte der Oberfläche | über Preload-Skript freigegeben | standardmäßig gesperrt, per Capability frei |
| Browser-Updates | mit jeder neuen App-Version | über das Betriebssystem |
| iOS und Android | nicht vorgesehen | seit Version 2 |
| Server-Rendering | möglich über eingebetteten Node-Server | nur statischer Export |
| Ökosystem | groß und lange erprobt | jünger, wächst |
Welches Framework für welches Projekt
Electron ist die sicherere Wahl, wenn die App stark auf Node.js-Bibliotheken angewiesen ist, wenn sie überall pixelgenau gleich aussehen muss oder wenn das Team ausschließlich JavaScript und TypeScript beherrscht und keine Zeit für Rust hat. Auch große, gewachsene Electron-Anwendungen sollte niemand allein wegen der Paketgröße migrieren: Der Aufwand steckt in den IPC-Schnittstellen und allem, was heute im Main-Prozess an Node-Code hängt.
Tauri spielt seine Stärken bei Anwendungen aus, die auf vielen Rechnern verteilt werden, bei internen Werkzeugen, Konfigurationsoberflächen und Hilfsprogrammen mit Tray-Symbol. Auch wenn die App sensible Daten verarbeitet, sind das strenge Rechtemodell und der speichersichere Kern handfeste Argumente. Und wenn neben dem Desktop eine mobile Fassung absehbar ist, kommt Electron gar nicht infrage.
Überschätzt wird in vielen Vergleichen der Speicherunterschied, unterschätzt der Testaufwand auf mehreren Webviews. Unsere Empfehlung: Bauen Sie vor der Entscheidung einen kleinen Prototyp mit den zwei oder drei kritischsten Funktionen, etwa Dateizugriff, Druck oder Gerätezugriff, und testen Sie ihn auf allen Zielsystemen, auch unter Linux und auf einem Mac. Das kostet wenige Tage und beantwortet die Frage verlässlicher als jede Tabelle.
Wer dabei Unterstützung für den Rust-Teil sucht, findet auf der Seite zu Rust-Entwicklung mit Beratung, Coaching und Seminaren Schulungen und Begleitung. Für die Web-Seite der Anwendung gibt es Angebote zu Web- und Frontend-Technologien.
Häufige Fragen zu Electron und Tauri
Kann eine bestehende React-App in Tauri laufen?
In den meisten Fällen ja. Tauri braucht am Ende nur HTML, CSS und JavaScript als fertige Dateien. Bei Single-Page-Anwendungen mit Vite ist das der normale Build. Anpassen müssen Sie alles, was bisher einen Server voraussetzt, und alle Stellen, an denen die App auf lokale Ressourcen zugreifen soll.
Muss das Team für Tauri Rust lernen?
Für einfache Apps nicht, denn die offiziellen Plugins decken Dateien, Dialoge, Benachrichtigungen und vieles mehr mit JavaScript-Schnittstellen ab. Sobald eigene Logik im Kern nötig ist, braucht das Team zumindest eine Person mit Rust-Erfahrung.
Wie aufwendig ist der Wechsel von Electron zu Tauri?
Das hängt fast ausschließlich davon ab, wie viel Code im Main-Prozess steckt. Die Oberfläche lässt sich meist übernehmen. Jeder IPC-Handler muss dagegen als Rust-Command oder über ein Plugin neu entstehen, und jede Node-Bibliothek braucht einen Ersatz oder ein Sidecar. Eine seriöse Schätzung ist erst nach einer Bestandsaufnahme dieser Schnittstellen möglich.
Sieht eine Tauri-App auf allen Systemen gleich aus?
Weitgehend, aber nicht garantiert. Moderne Web-Standards werden von allen drei Engines gut unterstützt. Unterschiede zeigen sich bei neueren CSS-Funktionen und Web-APIs, bei Schriftdarstellung und Grafikleistung, besonders unter Linux. Automatisierte Oberflächentests auf allen Zielplattformen fangen das früh ab.
Kategorien
Schlagworte