Electron: Desktop-Anwendungen mit Web-Technologien entwickeln

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 verpackt HTML, CSS und JavaScript als Desktop-App. Sie erfahren, wie die Prozesse zusammenspielen, wie Sie die App absichern und wann sie sich lohnt.
  • #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:

  1. Chromium, der quelloffene Kern von Google Chrome, stellt die Benutzeroberfläche dar. Alles, was in einem modernen Browser funktioniert, funktioniert auch im Electron-Fenster.
  2. 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. exposeInMainWorld sollte fachliche Funktionen wie speichern() anbieten, nicht ipcRenderer als Ganzes oder gar fs.
  • 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.

Mehr aus „Web-Grundlagen“

Moderne CSS-Features: Was Browser heute ohne JavaScript können

Moderne CSS-Features wie Container Queries, Nesting, :has() und Scroll-Animationen ersetzen viel JavaScript. Was Sie heute einsetzen können und was noch wartet.

mehr erfahren

Moderne Web- und App-Entwicklung: Was Unternehmen heute wissen sollten

Moderne Web- und App-Entwicklung erklärt: wann Web-App, PWA oder native App passt und worauf Sie bei Ladezeit, Sicherheit und Barrierefreiheit achten.

mehr erfahren

Barrierefreies Webdesign: Grundlagen und Best Practices nach WCAG 2.2

Barrierefreies Webdesign nach WCAG 2.2: wie Sie Kontraste, Fokus, Zielgrößen, Sprache und Struktur gestalten und was das BFSG seit Juni 2025 verlangt.

mehr erfahren

Webentwicklung im Überblick: von Frontend und Backend bis Betrieb

Webentwicklung im Überblick: welche Bausteine eine Webanwendung braucht, wie Frontend, Backend, Datenbank und Betrieb zusammenspielen und wo Sie weiterlesen.

mehr erfahren

Barrierefreies Web: Praxisleitfaden für Entwicklerinnen und Entwickler

Barrierefreiheit im Code: wie Sie mit semantischem HTML, ARIA-Mustern, Tastaturbedienung und Fokusführung bauen und mit axe-core und Screenreader testen.

mehr erfahren

Barrierefreie Angular-Entwicklung: zugängliche Webanwendungen bauen

Barrierefreiheit in Angular: wie Sie Fokus, dynamische Inhalte und Formulare zugänglich machen, was CDK und Angular Aria beitragen und wie Sie mit axe testen.

mehr erfahren

Weitere Blog-Artikel

Scrum entmystifiziert: Was das Framework leistet und was nicht

Scrum verständlich erklärt: Rollen, Events und Artefakte nach dem Scrum Guide 2020, typische Missverständnisse und wann sich Scrum für Ihr Team lohnt.

mehr erfahren

Prädiktive und präskriptive Analytik: Prognose und Entscheidung

Prädiktive Analytik sagt voraus, präskriptive empfiehlt Maßnahmen. Lesen Sie, wie sich die vier Stufen der Analytik unterscheiden und was sie leisten.

mehr erfahren

Agile Transformation: Wie sich Kultur, Führung und Struktur ändern

Agile Transformation betrifft Führung, Budgets, Strukturen und Kultur. Lesen Sie, was sie von agilen Teams unterscheidet und woran sie oft scheitert.

mehr erfahren

Die vier Säulen der Datenanalyse: von der Beschreibung zur Empfehlung

Deskriptiv, diagnostisch, prädiktiv, präskriptiv: Was die vier Arten der Datenanalyse leisten, welche Daten sie brauchen und wo Machine Learning heute hilft.

mehr erfahren

Von Daten zu Taten: So gelingen datenbasierte Entscheidungen

Datenbasiert entscheiden heißt: erst die Frage, dann die Kennzahl. Lesen Sie, wie Sie Datenqualität prüfen, Zahlen richtig deuten und ihre Grenzen kennen.

mehr erfahren

Projektmanagement-Methoden im Vergleich: Welche passt zu Ihnen?

Wasserfall, Scrum, Kanban, Lean oder hybrid: Sie erfahren, worin sich die wichtigsten Projektmanagement-Methoden unterscheiden und wann welche passt.

mehr erfahren

Aktuelle Blog-Artikel

PHP-Migration nach PHP2Shell: Upgrade oder Sprachwechsel?

PHP2Shell und das Support-Ende von PHP 8.2: Was Sie jetzt patchen sollten, wie ein Upgrade auf 8.4 oder 8.5 gelingt und wann ein Sprachwechsel sinnvoll ist.

mehr erfahren

Jev: Was ein KI-Modell für schnelles Denken anders macht als ChatGPT

Das System-1-KI-Modell Jev schreibt keinen Text, sondern beantwortet Fragen mit kalibrierten Wahrscheinlichkeiten. Wie das funktioniert und wofür es taugt.

mehr erfahren

Node.js ohne Ballast: 12 Bordmittel, die npm-Pakete ersetzen

Von fetch() über node:test bis Type Stripping: zwölf Node.js-Funktionen, die axios, dotenv, Jest und Co. ersetzen, mit Status in Node 24 und 26 und Grenzen.

mehr erfahren

KI-Agenten verstehen: MCP, A2A, AG-UI und A2UI einfach erklärt

MCP, A2A, AG-UI und A2UI verständlich erklärt: Wie KI-Agenten Werkzeuge nutzen, miteinander arbeiten und Oberflächen erzeugen – und wer die Standards betreut.

mehr erfahren

Rusts Lieferkette unter Beschuss: Warum ein Angriff nur der Anfang war

Ein Angriff auf Rust-Pakete war im August 2026 schnell gestoppt, das Grundproblem bleibt. Wie crates.io angreifbar ist und was Sie heute dagegen tun können.

mehr erfahren

Webentwicklung ohne SPA: Eine Web-App mit V, Veb, SQLite und htmx

Am Beispiel der Meetup-Plattform Clash zeigt sich, wie eine Web-App mit V, Veb, SQLite und htmx ohne SPA-Framework entsteht und wo der Ansatz an Grenzen stößt.

mehr erfahren

React-Performance: Warum weniger Optimierung mehr Tempo bringt

React-Performance heute: Wie Sie mit State am richtigen Ort, dem React Compiler, Transitions, Virtualisierung und Messung Ihre Anwendung spürbar beschleunigen.

mehr erfahren

React-Komponenten verbinden: Welcher Weg passt wann?

Props, Context, Zustand, TanStack Query, URL-Parameter oder Ereignisse: So wählen Sie den passenden Weg, damit zwei React-Komponenten Daten austauschen.

mehr erfahren

KI-Agenten in der Schleife: Loops in Claude Code und Codex

Was ein Loop bei KI-Agenten ist, welche Auslöser es gibt und wie Sie geplante Aufgaben in Claude Code und Codex mit Kostenkontrolle einrichten.

mehr erfahren

JavaScript 2026: Bun, Deno und TypeScript 7 läuten eine neue Ära ein

Node.js, Bun und Deno im Wettbewerb, TypeScript 7 mit Compiler in Go, Build-Werkzeuge in Rust: Was sich 2026 bei JavaScript ändert und was Sie davon übernehmen.

mehr erfahren

npm-Pakete sicher prüfen: So bewerten Sie ein Paket vor dem Einbau

npm-Pakete sicher prüfen: wie Sie Name, Wartung, Provenance, Install-Skripte, bekannte Lücken und Lizenz bewerten, bevor ein Paket in Ihr Projekt kommt.

mehr erfahren

npm install unter der Lupe: Wie Angreifer die Lieferkette kapern

Was npm install technisch tut, welche Angriffsmuster von Typosquatting bis Dependency Confusion es ausnutzen und wie Sie das Installieren absichern.

mehr erfahren

Programmiersprachen und KI: Warum Rust für Code-Agenten so gut passt

KI-Agenten schreiben in Rust oft verlässlicheren Code, weil der Compiler viele Fehler sofort meldet. Was dahinter steckt und wo das Argument endet.

mehr erfahren

Pi Agent vs. Claude Code: minimaler Open-Source-Agent im Vergleich

Pi Agent und Claude Code im Vergleich: Architektur, Erweiterungen, Modellwahl, Lizenz, Kosten und Sicherheit. Für wen sich der Open-Source-Agent lohnt.

mehr erfahren

Agentic Engine Optimization: Websites für KI-Agenten lesbar machen

Agentic Engine Optimization: Wie KI-Assistenten Ihre Website abrufen, welche Rolle robots.txt, llms.txt und strukturierte Daten spielen – und was belegt ist.

mehr erfahren

Claude Skills für Einsteiger: eigene KI-Workflows aufbauen

Claude Skills bündeln wiederkehrende Anweisungen in einer SKILL.md-Datei. So bauen Sie Skills auf und installieren sie in Claude und Claude Code.

mehr erfahren

Claude Code richtig nutzen: 15 Funktionen, die Profis kennen sollten

Claude Code kann mehr als chatten: So setzen Sie CLAUDE.md, Subagenten, Hooks, Skills, MCP und den Headless-Modus gezielt im Entwickleralltag ein.

mehr erfahren

Claude Code für Einsteiger: vom Terminal zur fertigen Anwendung

Claude Code arbeitet im Terminal direkt mit Ihren Dateien. So gelingen Installation, erste Aufträge, Planmodus, Skills und MCP auch ohne Programmiererfahrung.

mehr erfahren

OpenClaw im Praxistest: vom Chatbot zum digitalen Assistenten

OpenClaw macht ein Sprachmodell zum selbst gehosteten Agenten mit Zugriff auf Rechner und Messenger. Aufbau, Einrichtung, Skills und Sicherheitsregeln.

mehr erfahren

Das Ende der Menüs: Wie KI die digitale Arbeitsumgebung verändert

Seit Jahrzehnten bedienen wir Computer über Fenster, Menüs und Ordner. KI-Agenten verschieben das zu Aufträgen in Alltagssprache. Was sich ändert und was nicht.

mehr erfahren

Microsoft und Rust: Was hinter dem Ziel „C und C++ bis 2030“ steckt

Microsoft nutzt Rust im Windows-Kernel, der Ersatz von C und C++ bis 2030 ist aber ein Forschungsziel. Was belegt ist und was es für Entwickler bedeutet.

mehr erfahren

TanStack Start: Das React-Framework als Alternative zu Next.js

TanStack Start ist ein Fullstack-Framework für React auf Basis von TanStack Router und Vite. Was es kann und wann es eine Alternative zu Next.js ist.

mehr erfahren

Die Ralph-Wiggum-Technik: KI-Coding-Agenten, die nicht aufgeben

Die Ralph-Wiggum-Technik lässt einen Coding-Agenten denselben Auftrag wiederholen, bis die Tests bestehen. Wie sie funktioniert und worauf Sie achten sollten.

mehr erfahren

Warum KI Entwickler nicht ersetzt, aber ihre Rolle verändert

KI-Assistenten schreiben heute viel Code. Warum Fachwissen trotzdem wichtiger wird und welche Fähigkeiten Entwickler:innen jetzt gezielt ausbauen sollten.

mehr erfahren

Von Node.js zu Bun: Next.js-Projekte schrittweise umstellen

Wie Sie Bun in Next.js einsetzen: von bun install über bun --bun next dev bis zum Deployment. Was dabei schneller wird, was nicht und was Sie vorher prüfen.

mehr erfahren

Bun erklärt: JavaScript-Laufzeit, Paketmanager und Bundler in einem

Bun ist Laufzeitumgebung, Paketmanager, Bundler und Testrunner in einem. Wie es funktioniert, wie kompatibel es zu Node.js ist und für wen es sich lohnt.

mehr erfahren

KI-Agenten richtig anleiten: Spezifikationen, die funktionieren

Spezifikationen für KI-Coding-Agenten wie Claude Code oder GitHub Copilot: welche Angaben hineingehören, wie Sie Aufgaben aufteilen und Grenzen setzen.

mehr erfahren

Was ist .NET? Die Microsoft-Plattform einfach erklärt

.NET ist Microsofts quelloffene Entwicklungsplattform für Web, Cloud, Desktop und Apps. Sie erfahren, wie Laufzeit, SDK und Versionen zusammenhängen.

mehr erfahren

Künstliche Intelligenz 2026: Vom Chatbot zum digitalen Kollegen

Rückblick auf den KI-Ausblick vom Januar 2026: acht erwartete Trends von Multi-Agenten-Systemen über physische KI und EU AI Act bis zu Quanten-Utility.

mehr erfahren

KI-Jahr 2025: Vier Erkenntnisse und ein Ausblick auf 2026

Rückblick vom Januar 2026 auf das KI-Jahr 2025: vier Entwicklungen von unauffälligen Agenten bis zum Chipmangel und was sie damals für 2026 erwarten ließen.

mehr erfahren

REST und Event-Streams: Wann sich ereignisbasierte Backends lohnen

REST oder Event-Streams? Wie sich Request/Response und Publish/Subscribe unterscheiden, wann Kafka, SSE oder WebSockets passen und wo REST richtig bleibt.

mehr erfahren

Shai-Hulud 2.0: Wie sich ein Wurm im November 2025 durch npm fraß

Shai-Hulud 2.0 einfach erklärt: Rückblick auf den npm-Wurm vom November 2025, wie er Zugangsdaten stahl, sich selbst verbreitete und wie Sie sich schützten.

mehr erfahren

HTMX: Moderne Webanwendungen ohne JavaScript-Framework bauen

HTMX lädt Inhalte nach, sendet Formulare und tauscht Seitenteile per HTML-Attribut aus. Die Anleitung zeigt Browser- und Serverseite und den Stand von HTMX 4.

mehr erfahren

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

Electron bringt Chromium und Node.js mit, Tauri nutzt den Webview des Systems und einen Kern in Rust. Der Vergleich zeigt, wann sich welches Framework eignet.

mehr erfahren

Architekturkompetenz im KI-Zeitalter: Was Full-Stack heute heißt

Wenn KI-Werkzeuge Code schreiben, verschiebt sich die Arbeit zu Architekturentscheidungen. Welche Fähigkeiten zählen und wie Sie sie gezielt aufbauen.

mehr erfahren

Omarchy im Test: So macht Linux endlich wieder Spaß

Unser Test von Omarchy aus dem November 2025: Das Linux auf Basis von Arch und Hyprland setzt auf Tastatur, Kachelfenster und abgestimmte Themes.

mehr erfahren

JWT-Probleme: Warum Entwickler vor JSON Web Tokens warnen

JWT-Probleme im Überblick: Warum sich Tokens schwer widerrufen lassen, welche Prüffehler gefährlich sind und wann klassische Sessions die bessere Wahl sind.

mehr erfahren

7 KI-Begriffe erklärt: Von KI-Agenten bis Superintelligenz

Sieben KI-Begriffe von KI-Agenten über RAG und MCP bis Superintelligenz: was sie bedeuten, wie sie zusammenhängen und was davon für Unternehmen zählt.

mehr erfahren

Machine Learning verstehen: von den Grundlagen bis zu moderner KI

Machine Learning verständlich erklärt: welche Lernverfahren es gibt, wie Training mit Daten abläuft und wie Sie prüfen, ob ein Modell wirklich etwas taugt.

mehr erfahren

Scrum-Master-Rolle auf dem Prüfstand: ein Blick aus Architektursicht

Lohnt sich ein Scrum Master noch? Wir betrachten die Rolle aus Sicht der Softwarearchitektur, gleichen sie mit dem Scrum Guide 2020 ab und zeigen Alternativen.

mehr erfahren

Was dürfen wir für Sie tun?

So sind wir zu erreichen: