Electron: Desktop-Anwendungen mit Web-Technologien entwickeln

Wie Main- und Renderer-Prozess zusammenarbeiten, wie Sie Electron-Apps absichern und wann sich das Framework lohnt
Aktualisiert:
Abstract
- #Electron
- #Desktop-Entwicklung
- #Web-Technologien
- #Cross-Plattform
- #HTML
- #CSS
- #JavaScript
- #Chromium
- #Node.js
Eine Codebasis für Windows, macOS und Linux: Was Electron leistet und was es kostet
Wer morgens Visual Studio Code öffnet, mittags in Slack schreibt und abends bei Discord vorbeischaut, hat dreimal dieselbe Technik benutzt: Electron. Die drei Programme sehen aus und verhalten sich wie gewöhnliche Desktop-Anwendungen. Unter der Oberfläche steckt jedoch jeweils ein Browser, der eine Webanwendung anzeigt, ergänzt um eine JavaScript-Laufzeit mit Zugriff auf das Betriebssystem.
Für Unternehmen ist das ein verlockendes Angebot. Ein Team, das bereits Webanwendungen baut, kann mit denselben Werkzeugen ein Programm für Windows, macOS und Linux ausliefern. Der Preis dafür sind Speicherbedarf, Downloadgröße und eine Sicherheitsarchitektur, die man verstanden haben muss. Beides gehört zur ehrlichen Beschreibung von Electron.
Was Electron ist und woher es kommt
Electron ist ein Open-Source-Framework, also ein quelloffenes Grundgerüst, für Desktop-Anwendungen. GitHub entwickelte es ursprünglich unter dem Namen „Atom Shell“ für den Texteditor Atom. Heute liegt das Projekt bei der OpenJS Foundation, die auch Node.js betreut. Atom selbst hat GitHub Ende 2022 eingestellt, Electron dagegen wird weiter aktiv gepflegt.
Das Prinzip besteht aus zwei Bausteinen:
- Chromium, der quelloffene Kern von Google Chrome, stellt die Benutzeroberfläche dar. Alles, was in einem modernen Browser funktioniert, funktioniert auch im Electron-Fenster.
- Node.js, die JavaScript-Laufzeit für Server und Werkzeuge, liefert den Zugriff auf Dateisystem, Netzwerk und Betriebssystem.
Electron bündelt beides zu einer ausführbaren Datei und ergänzt Programmierschnittstellen (APIs) für typische Desktop-Aufgaben: Fenster, Menüs, Benachrichtigungen, Symbole im Infobereich der Taskleiste, Dateidialoge oder automatische Updates.
Jede App bringt ihre eigene Chromium-Version mit. Das ist zugleich Stärke und Schwäche: Die Darstellung ist auf allen Rechnern identisch, unabhängig davon, welcher Browser installiert ist. Dafür wird jedes Installationspaket schnell mehr als hundert Megabyte groß, und jede laufende App belegt spürbar Arbeitsspeicher.
Main- und Renderer-Prozess: die Architektur im Kern
Wer Electron verstehen will, muss das Prozessmodell kennen. Es ist von Chromium übernommen und trennt Aufgaben strikt.
Der Main-Prozess
Jede Electron-App hat genau einen Main-Prozess. Er läuft in einer Node.js-Umgebung, startet die Anwendung, öffnet Fenster und reagiert auf Ereignisse des Betriebssystems, etwa wenn das letzte Fenster geschlossen wird. Nur hier stehen alle Node.js- und Electron-APIs uneingeschränkt zur Verfügung.
Renderer-Prozesse
Jedes Fenster zeigt seine Inhalte in einem eigenen Renderer-Prozess an. Dort läuft der Code der Oberfläche, also HTML, CSS und JavaScript, wahlweise mit React, Vue, Angular oder Svelte. Der Renderer verhält sich wie ein Browser-Tab und hat in aktuellen Electron-Versionen standardmäßig keinen Zugriff auf Node.js.
Preload-Skripte als kontrollierte Brücke
Zwischen beiden Welten vermittelt das Preload-Skript. Es wird vor der eigentlichen Webseite im Renderer geladen und darf über die Schnittstelle contextBridge gezielt einzelne Funktionen an die Oberfläche weiterreichen. Die eigentliche Arbeit erledigt der Main-Prozess, mit dem der Renderer über Interprozesskommunikation (IPC) Nachrichten austauscht.
Angenommen, ein Mitarbeiter soll in einer internen Erfassungs-App eine Textdatei speichern. Die Oberfläche ruft eine freigegebene Funktion speichern() auf, das Preload-Skript leitet den Wunsch per IPC weiter, und der Main-Prozess öffnet den Speichern-Dialog und schreibt die Datei. Die Webseite selbst kommt nie direkt an das Dateisystem.
Eine erste Electron-App in vier Dateien
Das Electron-Projekt empfiehlt für neue Anwendungen Electron Forge, ein Werkzeug, das Projektgerüst, Build und Installationspakete übernimmt. Mit npx create-electron-app@latest meine-app entsteht ein lauffähiges Projekt, auf Wunsch mit Vite und TypeScript (die Vite-Unterstützung von Forge gilt noch als experimentell). Um das Prinzip zu zeigen, genügt aber ein minimales Projekt von Hand:
mkdir meine-electron-app
cd meine-electron-app
npm init -y
npm install --save-dev electron
In der package.json verweist main auf die Startdatei, und ein Skript startet die App:
{
"name": "meine-electron-app",
"version": "1.0.0",
"main": "main.js",
"scripts": {
"start": "electron ."
}
}
Der Main-Prozess erzeugt das Fenster, bindet das Preload-Skript ein und beantwortet die Anfrage zum Speichern:
// main.js
const { app, BrowserWindow, ipcMain, dialog } = require('electron');
const path = require('node:path');
const fs = require('node:fs/promises');
function createWindow() {
const win = new BrowserWindow({
width: 900,
height: 650,
webPreferences: {
preload: path.join(__dirname, 'preload.js'),
// Diese Werte sind in aktuellen Versionen ohnehin Standard,
// hier stehen sie zur Verdeutlichung.
contextIsolation: true,
nodeIntegration: false,
sandbox: true,
},
});
win.loadFile('index.html');
}
ipcMain.handle('datei:speichern', async (_event, inhalt) => {
const { canceled, filePath } = await dialog.showSaveDialog({
defaultPath: 'notiz.txt',
});
if (canceled || !filePath) return false;
await fs.writeFile(filePath, String(inhalt), 'utf8');
return true;
});
app.whenReady().then(() => {
createWindow();
// macOS: Fenster neu öffnen, wenn das Dock-Symbol angeklickt wird
app.on('activate', () => {
if (BrowserWindow.getAllWindows().length === 0) createWindow();
});
});
// Unter Windows und Linux endet die App mit dem letzten Fenster
app.on('window-all-closed', () => {
if (process.platform !== 'darwin') app.quit();
});
Das Preload-Skript gibt genau eine Funktion frei, nicht mehr:
// preload.js
const { contextBridge, ipcRenderer } = require('electron');
contextBridge.exposeInMainWorld('notizApi', {
speichern: (inhalt) => ipcRenderer.invoke('datei:speichern', inhalt),
});
Die Oberfläche bleibt eine gewöhnliche Webseite mit einer Content Security Policy, die nur eigene Skripte zulässt:
<!doctype html>
<html lang="de">
<head>
<meta charset="utf-8" />
<meta
http-equiv="Content-Security-Policy"
content="default-src 'self'; script-src 'self'"
/>
<title>Notizen</title>
</head>
<body>
<textarea id="text" rows="10" cols="60"></textarea>
<button id="speichern">Speichern</button>
<script src="renderer.js"></script>
</body>
</html>
// renderer.js
document.getElementById('speichern').addEventListener('click', async () => {
const text = document.getElementById('text').value;
const ok = await window.notizApi.speichern(text);
if (ok) document.title = 'Notizen (gespeichert)';
});
Mit npm start öffnet sich das Fenster. Der frühere Ansatz, im Renderer direkt require('fs') aufzurufen, funktioniert in aktuellen Versionen absichtlich nicht mehr, und das ist gut so.
Sicherheit: contextIsolation, Sandbox und schmale Schnittstellen
Electron-Apps laufen mit den Rechten des angemeldeten Benutzers. Eine Sicherheitslücke in der Oberfläche ist deshalb gefährlicher als im Browser: Gelingt einem Angreifer eine Script-Injection, also das Einschleusen von fremdem JavaScript, und hat der Renderer Zugriff auf Node.js, kann er beliebige Programme starten.
In den ersten Jahren war genau das die Standardeinstellung. Inzwischen hat Electron die Voreinstellungen schrittweise verschärft: nodeIntegration ist seit Version 5 aus, contextIsolation seit Version 12 an, und seit Version 20 laufen Renderer standardmäßig in der Chromium-Sandbox. Wer ein älteres Projekt übernimmt, sollte prüfen, ob dort diese Schutzmechanismen von Hand wieder abgeschaltet wurden.
Die wichtigsten Regeln aus der Sicherheitscheckliste des Electron-Projekts:
- contextIsolation aktiv lassen. Sie trennt den JavaScript-Kontext des Preload-Skripts von dem der Webseite, sodass fremder Code die Brücke nicht manipulieren kann.
- Schmale APIs freigeben.
exposeInMainWorldsollte fachliche Funktionen wiespeichern()anbieten, nichtipcRendererals Ganzes oder garfs. - Absender prüfen. IPC-Handler im Main-Prozess sollten Eingaben validieren und bei Bedarf kontrollieren, aus welchem Fenster eine Nachricht kommt.
- Keine fremden Inhalte mit Rechten. Externe Webseiten nicht im App-Fenster laden, Navigation und neue Fenster einschränken, Links im Standardbrowser öffnen.
- Content Security Policy setzen und Electron regelmäßig aktualisieren, denn jede Version bringt Chromium-Sicherheitskorrekturen mit.
Dazu kommen Themen, die jede Desktop-Software betreffen: Code-Signierung unter Windows und macOS, die Beglaubigung (Notarisierung) bei Apple und ein Update-Mechanismus, damit Korrekturen tatsächlich bei den Nutzern ankommen.
Updates und Versionen: ein eigener Takt
Electron folgt dem Rhythmus von Chromium. Laut Projekt erscheint etwa alle acht Wochen eine neue Hauptversion, unterstützt werden jeweils die drei jüngsten. Für ein Team bedeutet das: Wer eine App ein Jahr lang nicht anfasst, liefert eine Version ohne Sicherheitsupdates aus.
Das ist kein Grund gegen Electron, aber ein Posten in der Planung. Sinnvoll ist ein fester Termin im Quartal, an dem Electron und die übrigen Abhängigkeiten aktualisiert und die App auf allen drei Plattformen getestet wird. Automatisierte Builds in einer CI-Pipeline erleichtern das erheblich.
Wo Electron stark ist und wo nicht
Die Stärken
- Wiederverwendung: Vorhandenes Web-Know-how, Komponentenbibliotheken und oft große Teile einer bestehenden Webanwendung lassen sich übernehmen.
- Gleiche Darstellung überall: Weil Chromium mitgeliefert wird, gibt es keine Unterschiede zwischen den Browser-Engines der Betriebssysteme.
- Ausgereiftes Ökosystem: Das npm-Ökosystem, Electron Forge, Auto-Update-Lösungen und eine große Zahl produktiver Anwendungen von VS Code bis Obsidian zeigen, dass das Modell trägt.
Die Schwächen
- Ressourcenbedarf: Jede App startet ihren eigenen Browser. Auf älteren Firmen-Notebooks mit wenig Arbeitsspeicher merkt man das.
- Paketgröße: Installationspakete sind deutlich größer als bei nativen Programmen oder Frameworks, die die Web-Engine des Betriebssystems nutzen.
- Native Haptik: Electron-Apps sehen auf allen Systemen gleich aus. Wer erwartet, dass sich ein Programm exakt wie eine macOS- oder Windows-Anwendung anfühlt, muss nacharbeiten.
Die Debatte darüber ist alt. Microsoft etwa hat den Teams-Client 2023 auf eine neue Architektur mit der systemeigenen WebView2-Komponente umgestellt und dabei Electron hinter sich gelassen. Das zeigt weniger ein Scheitern von Electron als die Abwägung, die jedes Team bei großen Nutzerzahlen trifft.
Electron oder Tauri: die Kurzfassung
Die bekannteste Alternative ist Tauri. Es setzt auf die Web-Engine, die das Betriebssystem ohnehin mitbringt, und schreibt die Backend-Logik in Rust statt in Node.js. Das Ergebnis sind deutlich kleinere Pakete. Dafür kann die Darstellung je nach System leicht abweichen, und für eigene Backend-Logik braucht das Team Rust-Kenntnisse.
Den ausführlichen Vergleich mit Kriterien für die Auswahl finden Sie im Beitrag Electron vs. Tauri für Desktop-Apps. Wie Tauri-Anwendungen aufgebaut sind, beschreibt der Beitrag Desktop-Anwendungen mit Tauri und Rust.
Was das für Ihr Team bedeutet
Electron ist keine Zukunftsvision mehr, sondern seit Jahren bewährte Technik. Für die meisten Unternehmen lohnt es sich, wenn bereits eine Webanwendung existiert und eine Desktop-Fassung zusätzliche Fähigkeiten bringen soll: Offline-Betrieb, Zugriff auf lokale Dateien, Integration in die Taskleiste oder Anbindung an Geräte im Firmennetz. Auch für interne Werkzeuge, die auf mehreren Betriebssystemen laufen müssen, ist Electron eine pragmatische Wahl.
Weniger geeignet ist es für kleine Hilfsprogramme, bei denen hundert Megabyte Download unverhältnismäßig wirken, und für Software, die auf schwacher Hardware laufen muss. Überschätzt wird oft der Aufwand, eine Webanwendung „einfach einzupacken“: Sicherheitskonzept, Signierung, Updates und Tests auf drei Plattformen sind echte Projektarbeit.
Unsere Empfehlung: Planen Sie die Trennung von Main- und Renderer-Prozess von Anfang an sauber, geben Sie über das Preload-Skript nur fachliche Funktionen frei und legen Sie einen festen Aktualisierungsrhythmus fest. Wer die Grundlagen im Team auffrischen möchte, findet auf unserer Seite zu Web- und Frontend-Technologien Beratung und Seminare zu den Technologien, auf denen Electron aufbaut.
Häufige Fragen zu Electron
Eignet sich Electron auch für große, komplexe Anwendungen?
Ja. Visual Studio Code, Slack und Discord gehören zu den bekanntesten Beispielen. Entscheidend ist weniger das Framework als die Architektur der App: aufwendige Berechnungen gehören nicht in den Renderer, und die Oberfläche sollte so sparsam gebaut sein wie eine gute Webanwendung.
Wie schnell sind Electron-Apps im Vergleich zu nativen Programmen?
Bei der Bedienung sind gut gebaute Electron-Apps kaum von nativen Anwendungen zu unterscheiden. Unterschiede zeigen sich beim Start, beim Arbeitsspeicher und bei der Paketgröße. Für rechenintensive Aufgaben lassen sich native Module oder separate Hintergrundprozesse einbinden.
Lässt sich eine bestehende Webanwendung in eine Electron-App umwandeln?
Meist ja, die Oberfläche lässt sich weitgehend übernehmen. Anpassen müssen Sie alles, was mit lokalen Ressourcen zu tun hat: Dateizugriffe, Anmeldung, Offline-Fähigkeit und Updates. Diese Funktionen gehören in den Main-Prozess und werden über das Preload-Skript angebunden.
Ist TypeScript für Electron nötig?
Nein, aber es hilft. Gerade an der Grenze zwischen Preload-Skript und Oberfläche verhindern gemeinsame Typdefinitionen Fehler, die sonst erst zur Laufzeit auffallen. Die Vorlagen von Electron Forge bieten TypeScript bereits an.
Kategorien
Schlagworte