React-Performance: Warum weniger Optimierung mehr Tempo bringt

React-Performance: Warum weniger Optimierung mehr Tempo bringt

State am richtigen Ort, React Compiler, Transitions, Virtualisierung und Messung: was React-Anwendungen heute wirklich schneller macht

Aktualisiert:

Abstract

React-Performance heute: Wie Sie mit State am richtigen Ort, dem React Compiler, Transitions, Virtualisierung und Messung Ihre Anwendung spürbar beschleunigen.
  • #React
  • #React Performance
  • #React Compiler
  • #useTransition
  • #useDeferredValue
  • #Code-Splitting
  • #Lazy Loading
  • #Virtualisierung

Eine React-App wird selten durch mehr Memoisierung schnell, sondern durch weniger überflüssige Arbeit

Angenommen, in einem Webshop ruckelt das Suchfeld. Jeder Tastendruck erscheint mit einer kleinen Verzögerung, auf älteren Smartphones deutlich spürbar. Der erste Reflex im Team: überall useMemo und useCallback einbauen. Die Lage bessert sich kaum, der Code wird schwerer lesbar. Die eigentliche Ursache liegt woanders: Der Suchbegriff steht ganz oben im Komponentenbaum, und jede Eingabe lässt Kopfzeile, Navigation, Produktraster und Fußzeile neu rendern.

Ein Bild hilft beim Verständnis. Betrachten Sie Ihre Anwendung als Autobahn: Komponenten sind die Autos, jedes Rendern ist eine Fahrt. Schneller wird eine Autobahn nicht durch zusätzliche Mautstationen, sondern dadurch, dass Engpässe verschwinden. Genau so funktioniert moderne React-Performance. Wo Sie ansetzen sollten, welche Arbeit inzwischen der React Compiler übernimmt und wie Sie Engpässe messen statt raten, zeigen die folgenden Abschnitte.

Warum viele Performance-Tipps nicht mehr passen

Lange lautete der Standardrat: Komponenten in React.memo verpacken, Funktionen in useCallback, berechnete Werte in useMemo, und „unnötige Re-Renders“ um jeden Preis vermeiden. Schon früher half das selten so viel wie erhofft. Seit es den React Compiler gibt, der diese Zwischenspeicherung automatisch einfügt, ist manuelle Memoisierung in neuem Code meist überflüssig.

Die wirklichen Bremsen liegen in der Regel an anderer Stelle:

  • State am falschen Ort: Ein Zustand weit oben im Baum zieht ganze Teilbäume in jedes Rendern hinein.
  • Blockierende Aktualisierungen: Aufwendiges Rendern blockiert den Hauptthread, sodass Eingaben verzögert erscheinen.
  • Zu viel auf einmal: Die gesamte Anwendung wird geladen, obwohl Nutzer:innen gerade nur eine Seite sehen, oder eine Liste schreibt zehntausend Zeilen ins DOM.
  • Effektketten: Ein useEffect setzt State, der den nächsten Effekt auslöst, und jede Stufe kostet ein weiteres Rendern.

Keines dieser Probleme löst ein zusätzliches useMemo. Für alle gibt es aber gut etablierte Gegenmittel.

Wenn ein Tastendruck die halbe Seite neu rendert

Auf einer echten Autobahn bremst ein Fahrer kurz ab, der Hintermann bremst stärker, der nächste noch stärker. Wenige Sekunden später steht der Verkehr, obwohl das erste Auto längst weitergefahren ist. In React verbreiten sich Re-Renders ähnlich.

Was bei einem Re-Render passiert

Ändert sich der State einer Komponente, rendert React diese Komponente neu und standardmäßig auch alle Komponenten, die sie in ihrem JSX erzeugt. Rendern heißt dabei zunächst nur: React ruft die Komponentenfunktion auf und vergleicht das Ergebnis mit dem vorherigen. Das DOM, also die tatsächliche Seitenstruktur im Browser, ändert React nur dort, wo sich etwas unterscheidet. Teuer wird es trotzdem, wenn bei jedem Tastendruck Hunderte Komponenten durchlaufen werden, die mit der Eingabe nichts zu tun haben. Diese Komponenten sind die Gaffer auf der Gegenfahrbahn: Sie bremsen mit, ohne beteiligt zu sein.

State dort halten, wo er gebraucht wird

Die wirksamste Gegenmaßnahme ist zugleich die einfachste. Fachleute nennen sie State-Colocation: Der Zustand wandert in die kleinste Komponente, die ihn tatsächlich braucht. Im Beispiel des Webshops bekommt die Suche eine eigene Komponente.

import { useState } from 'react';
import { SearchBar } from './SearchBar';
import { SearchResults } from './SearchResults';

export function SearchSection() {
  const [searchQuery, setSearchQuery] = useState('');

  return (
    <section>
      <SearchBar query={searchQuery} onChange={setSearchQuery} />
      <SearchResults query={searchQuery} />
    </section>
  );
}

Tippt jemand, rendern nur noch SearchSection und ihre Kinder neu. Kopfzeile, Navigation und Produktraster bleiben unberührt, ganz ohne Memoisierung. Für viele Anwendungen ist diese strukturelle Änderung die wirkungsvollste Optimierung überhaupt.

Das Children-Muster für häufig wechselnden State

Manchmal lässt sich der State nicht nach unten verschieben, weil die besitzende Komponente auch umfangreiche Inhalte umschließt. Ein typisches Beispiel ist eine Fortschrittsanzeige, die bei jedem Scrollen aktualisiert wird. Hier hilft es, die schweren Inhalte als children von außen hineinzureichen.

import { useEffect, useState, type ReactNode } from 'react';

export function ScrollTracker({ children }: { children: ReactNode }) {
  const [scrollY, setScrollY] = useState(0);

  useEffect(() => {
    const onScroll = () => setScrollY(window.scrollY);
    window.addEventListener('scroll', onScroll, { passive: true });
    return () => window.removeEventListener('scroll', onScroll);
  }, []);

  return (
    <div>
      <ScrollIndicator position={scrollY} />
      {children}
    </div>
  );
}

function ScrollIndicator({ position }: { position: number }) {
  return <div className="scroll-indicator">{Math.round(position)} px</div>;
}

Die children erzeugt die Elternkomponente, nicht der ScrollTracker. Ändert sich nur scrollY, bleibt das übergebene Element dasselbe Objekt, und React überspringt diesen Teilbaum. Auch das gelingt allein durch die Struktur des Codes.

Was der React Compiler übernimmt und was nicht

Jedes manuelle useMemo und useCallback ist wie eine Mautstation. Es kostet Speicher für den zwischengespeicherten Wert, bei jedem Rendern einen Vergleich der Abhängigkeiten und vor allem Aufmerksamkeit beim Lesen. Bei billigen Operationen, etwa dem Zusammensetzen von Vor- und Nachname, ist diese Maut teurer als die eingesparte Rechenarbeit.

Automatische Memoisierung beim Build

Der React Compiler ist ein Werkzeug, das Komponenten und Hooks beim Build analysiert und die Zwischenspeicherung selbst einfügt, und zwar feiner, als es von Hand praktikabel wäre. Das React-Team hat ihn im Oktober 2025 als stabile Version 1.0 veröffentlicht. Er ist kein fester Bestandteil von React, sondern ein Babel-Plugin (babel-plugin-react-compiler), das Sie im Build einbinden. Laut React-Team funktioniert er mit React 19 direkt und mit React 17 und 18 über ein zusätzliches Laufzeitpaket.

In Next.js lässt er sich ab Version 16 über eine Konfigurationsoption einschalten; das Babel-Plugin muss dafür als Entwicklungsabhängigkeit installiert sein.

// next.config.ts
import type { NextConfig } from 'next';

const nextConfig: NextConfig = {
  reactCompiler: true,
};

export default nextConfig;

Für Vite-Projekte binden Sie den Compiler ab @vitejs/plugin-react 6 über das Paket @rolldown/plugin-babel und das mitgelieferte reactCompilerPreset ein; ältere Versionen des Vite-Plugins nehmen das Babel-Plugin direkt in ihren Babel-Optionen auf. Voraussetzung ist in jedem Fall, dass der Code die Regeln von React einhält: Komponenten müssen rein sein, also bei gleichen Eingaben das Gleiche liefern, und Props oder State dürfen nicht direkt verändert werden. Das ESLint-Plugin eslint-plugin-react-hooks enthält Regeln, die solche Verstöße anzeigen. Wo der Compiler unsicher ist, lässt er eine Komponente unverändert, statt sie falsch zu optimieren. Einzelne problematische Komponenten können Sie mit der Direktive 'use no memo' ausnehmen.

Wo Memoisierung von Hand bleibt

Es gibt weiterhin berechtigte Fälle für gezielte Eingriffe: sehr teure Berechnungen, etwa das Sortieren tausender Einträge bei jedem Rendern, Bibliotheken, die auf stabile Objektreferenzen angewiesen sind, und Effekt-Abhängigkeiten, bei denen eine instabile Referenz den Effekt ständig neu auslöst. In bestehendem Code mit Compiler sollten Sie vorhandenes useMemo nicht pauschal löschen, sondern erst nach Tests, denn manche Logik verlässt sich auf genau diese Stabilität.

Wichtig ist auch, was der Compiler nicht leistet. Er verkleinert kein Bundle, virtualisiert keine Listen und entzerrt keine Datenabfragen, die nacheinander statt parallel laufen. Wie sich Hooks und Memoisierung über die Jahre verändert haben, beschreibt der Beitrag Von React Hooks zu Server Components. Welche Folgen der Compiler für die Struktur größerer Anwendungen hat, ordnet React-Architektur: Komponenten, Zustand und Performance im Großen ein.

Die Überholspur: Transitions und zurückgestellte Werte

React kann Aktualisierungen nach Dringlichkeit sortieren. Diese sogenannten nebenläufigen Funktionen (Concurrent Features) gibt es seit React 18; sie gehören zu den am meisten unterschätzten Werkzeugen für flüssige Oberflächen.

useTransition für Aktualisierungen, die Sie selbst auslösen

Mit useTransition kennzeichnen Sie eine State-Änderung als nicht dringend. React zeigt die Eingabe dann sofort an und rendert die aufwendige Ergebnisliste im Hintergrund. Tippt jemand weiter, bevor die Liste fertig ist, bricht React das veraltete Rendern ab und beginnt mit dem neuen Wert.

import { useState, useTransition, type ChangeEvent } from 'react';
import { ProductList } from './ProductList';

export function ProductSearch() {
  const [input, setInput] = useState('');
  const [filter, setFilter] = useState('');
  const [isPending, startTransition] = useTransition();

  function handleChange(event: ChangeEvent<HTMLInputElement>) {
    const value = event.target.value;
    setInput(value); // dringend: das Eingabefeld reagiert sofort
    startTransition(() => {
      setFilter(value); // nicht dringend: die Liste darf warten
    });
  }

  return (
    <>
      <input value={input} onChange={handleChange} />
      <div style={{ opacity: isPending ? 0.6 : 1 }}>
        <ProductList filter={filter} />
      </div>
    </>
  );
}

Ein Detail entscheidet über den Erfolg: Die teure Arbeit muss im Rendern der Liste stecken, also in ProductList, die mit dem Filter rechnet und viele Einträge darstellt. Eine Berechnung, die Sie selbst in der Callback-Funktion von startTransition ausführen, läuft dagegen synchron und blockiert wie zuvor. Der Wert isPending liefert nebenbei einen Ladezustand, mit dem Sie die Liste während der Aktualisierung dezent abdunkeln können. Seit React 19 darf die Funktion in startTransition auch asynchron sein; React nennt solche Übergänge Actions und nutzt sie etwa für Formulare.

useDeferredValue für Werte, die von außen kommen

useDeferredValue hilft, wenn Sie die Aktualisierung nicht selbst auslösen, etwa weil der Wert als Prop von der Elternkomponente oder aus der URL kommt. React rendert dann zunächst mit dem alten Wert weiter und holt das Rendern mit dem neuen Wert im Hintergrund nach.

import { useDeferredValue } from 'react';
import { ProductList } from './ProductList';

export function Results({ query }: { query: string }) {
  const deferredQuery = useDeferredValue(query);
  const isStale = query !== deferredQuery;

  return (
    <div style={{ opacity: isStale ? 0.6 : 1 }}>
      <ProductList filter={deferredQuery} />
    </div>
  );
}

Damit das wirkt, darf ProductList nicht bei jedem Rendern von Results ohnehin neu rendern. Mit dem React Compiler ist das automatisch gegeben, ohne ihn verpacken Sie die Liste in memo. Die Faustregel: useTransition, wenn Sie die Änderung selbst anstoßen; useDeferredValue, wenn der Wert von außen kommt.

Lange Listen: nur zeichnen, was sichtbar ist

Ein Kundenverzeichnis mit 20.000 Einträgen, ein Protokoll mit Tausenden Zeilen, eine Artikelliste im Shop-Backend: Hier hilft keine Memoisierung, denn schon das erste Rendern erzeugt zu viele DOM-Knoten. Der Browser muss sie anlegen, berechnen und zeichnen, und jede Interaktion wird träge.

Die Lösung heißt Virtualisierung, auch Windowing genannt. Die Liste rendert nur die Zeilen, die gerade im sichtbaren Bereich liegen, plus einen kleinen Puffer. Beim Scrollen tauscht sie die Inhalte aus. Verbreitete Bibliotheken dafür sind TanStack Virtual und react-window. Ein Beispiel mit TanStack Virtual:

import { useRef } from 'react';
import { useVirtualizer } from '@tanstack/react-virtual';

export function CustomerList({ customers }: { customers: string[] }) {
  const parentRef = useRef<HTMLDivElement>(null);

  const virtualizer = useVirtualizer({
    count: customers.length,
    getScrollElement: () => parentRef.current,
    estimateSize: () => 40, // geschätzte Zeilenhöhe in Pixeln
    overscan: 5, // Puffer ober- und unterhalb des sichtbaren Bereichs
  });

  return (
    <div ref={parentRef} style={{ height: 600, overflow: 'auto' }}>
      <div style={{ height: virtualizer.getTotalSize(), position: 'relative' }}>
        {virtualizer.getVirtualItems().map((row) => (
          <div
            key={row.key}
            style={{
              position: 'absolute',
              top: 0,
              left: 0,
              width: '100%',
              height: row.size,
              transform: `translateY(${row.start}px)`,
            }}
          >
            {customers[row.index]}
          </div>
        ))}
      </div>
    </div>
  );
}

Statt 20.000 Zeilen liegen so nur einige Dutzend im DOM. Virtualisierung hat allerdings ihren Preis: Die Suche des Browsers per Tastenkürzel findet nur gerenderte Zeilen, und für Screenreader müssen Sie Rollen und Positionsangaben sorgfältig setzen. Für Listen mit einigen Hundert einfachen Einträgen lohnt sich der Aufwand meist nicht. Eine leichtere Alternative für lange, statische Seiten ist die CSS-Eigenschaft content-visibility: auto, mit der der Browser das Zeichnen von Bereichen außerhalb des sichtbaren Ausschnitts überspringt.

Weniger laden: Code-Splitting und Lazy Loading

Sie würden nicht jede Autobahnabfahrt gleichzeitig ausbauen, wenn die meisten Fahrer nur eine davon nutzen. Ebenso wenig muss der Browser die gesamte Anwendung laden, wenn jemand nur die Startseite aufruft. Code-Splitting teilt das JavaScript in Pakete (Chunks), die erst bei Bedarf nachgeladen werden. In React geht das mit lazy und Suspense:

import { lazy, Suspense } from 'react';

const Dashboard = lazy(() => import('./pages/Dashboard'));

export function App() {
  return (
    <Suspense fallback={<p>Dashboard wird geladen …</p>}>
      <Dashboard />
    </Suspense>
  );
}

Der Code für Dashboard wird erst geladen, wenn die Komponente das erste Mal angezeigt wird. Frameworks wie Next.js teilen den Code automatisch nach Routen auf, sodass der Browser nur den Code für die aufgerufene Route lädt. Server Components gehen einen Schritt weiter: Sie laufen nur auf dem Server und schicken gar kein JavaScript für die betreffenden Bausteine an den Browser. Wie React 19 und Server Components zusammen mit Next.js 15 in die Praxis kamen, beschreibt der Rückblick Next.js 15 und React 19.

Teilen Sie nicht zu kleinteilig auf. Jede lazy-Grenze bedeutet eine zusätzliche Netzwerkanfrage und einen Ladezustand. Sinnvoll sind Routen und schwere Funktionsbereiche wie Diagramme, Editoren oder Kartenansichten, nicht einzelne Schaltflächen.

Erst messen, dann optimieren

Alle genannten Techniken helfen nur, wenn Sie den tatsächlichen Engpass kennen. Wer rät, optimiert häufig die falsche Stelle.

Profiler und Performance-Panel

Der Profiler in den React DevTools zeichnet auf, welche Komponenten bei einer Interaktion rendern, warum sie rendern und wie lange das dauert. Im Flame-Chart stehen die breitesten Balken für die teuersten Komponenten. Komponenten mit Renderzeiten unter einer Millisekunde sind selten das Problem. Interessant wird es, wenn ein einzelnes Rendern in die Nähe von 16 Millisekunden kommt, denn so lang ist bei 60 Bildern pro Sekunde ein ganzes Frame.

Ergänzend zeigt das Performance-Panel der Chrome DevTools sogenannte Long Tasks, also Aufgaben, die den Hauptthread länger als 50 Millisekunden blockieren. Seit React 19.2 erscheinen dort zusätzlich eigene React-Spuren, die zeigen, welche Arbeit React mit welcher Priorität erledigt. Messen Sie möglichst mit einem Produktions-Build und gedrosselter CPU, denn der Entwicklungsmodus ist deutlich langsamer und ein schneller Entwicklerrechner verdeckt Probleme, die auf Mittelklasse-Smartphones auffallen.

Core Web Vitals als Kompass

Für Nutzer:innen und für Google zählen drei Kennzahlen, die Google als Core Web Vitals zusammenfasst:

KennzahlWas sie misstGut ist
LCP (Largest Contentful Paint)wann der größte sichtbare Inhalt erscheinthöchstens 2,5 Sekunden
INP (Interaction to Next Paint)wie schnell die Oberfläche auf Eingaben reagierthöchstens 200 Millisekunden
CLS (Cumulative Layout Shift)wie stark Inhalte beim Laden verrutschenhöchstens 0,1

Google bewertet dabei den Wert, den 75 Prozent der Seitenaufrufe erreichen. INP hat im März 2024 die ältere Kennzahl FID abgelöst und ist für React-Anwendungen besonders aufschlussreich, weil er blockierendes Rendern direkt abbildet. Ist der INP schlecht, helfen State-Colocation, Transitions und Virtualisierung. Ist der LCP schlecht, liegt die Ursache eher beim Laden: zu viel JavaScript, große Bilder, späte Datenabfragen. Labormessungen mit Lighthouse ersetzen dabei keine Felddaten echter Besucher, etwa aus dem Chrome UX Report oder einem eigenen Monitoring.

Fehlerquellen, die kein Compiler behebt

Einige Muster bremsen Anwendungen, unabhängig davon, ob der Compiler aktiv ist:

  1. Komponenten in Komponenten definieren. Steht eine Komponentenfunktion innerhalb einer anderen, entsteht bei jedem Rendern eine neue Funktion. React hält sie für einen anderen Komponententyp, baut den Teilbaum komplett neu auf und verliert dessen State.
  2. Instabile Schlüssel in Listen. Mit Math.random() als key baut React jede Zeile bei jedem Rendern neu auf. Der Array-Index als Schlüssel führt bei sortier- oder filterbaren Listen dazu, dass Zustände wie Eingaben oder Aufklappzustände an der falschen Zeile hängen. Verwenden Sie stabile IDs aus den Daten.
  3. Zu breit gefasster Context. Ändert sich der Wert eines Context-Providers, rendern alle Komponenten neu, die ihn lesen. Trennen Sie häufig wechselnde Werte von selten wechselnden, und legen Sie Werte und Setter-Funktionen in getrennte Contexts.
  4. Effektketten. Werte, die sich aus Props oder State ableiten lassen, berechnen Sie direkt beim Rendern, statt sie in einem Effekt in weiteren State zu kopieren. Für das Laden von Daten eignen sich Framework-Funktionen oder spezialisierte Bibliotheken wie TanStack Query besser als selbst gebaute Effekte.
  5. Wasserfälle beim Datenladen. Lädt jede Komponente ihre Daten erst, nachdem die übergeordnete fertig ist, addieren sich die Wartezeiten. Starten Sie unabhängige Abfragen parallel oder verlagern Sie sie auf den Server.

Was das für Ihr Team bedeutet

React-Performance ist heute weniger eine Frage von Spezialtricks als von Aufräumarbeit. Die größten Gewinne bringen fast immer strukturelle Entscheidungen: State am richtigen Ort, weniger JavaScript im Browser, virtualisierte Listen, parallele Datenabfragen. Der React Compiler nimmt Teams die mühsame Memoisierung weitgehend ab und ist für die meisten Projekte eine lohnende Umstellung, sofern der Code die Regeln von React einhält. Überschätzt wird er dort, wo Erwartungen an ihn als Allheilmittel entstehen: Ein aufgeblähtes Bundle bleibt aufgebläht.

Unsere Empfehlung: Messen Sie zuerst mit Profiler und Felddaten, beheben Sie den größten Engpass und messen Sie erneut. Aktivieren Sie den Compiler schrittweise, nehmen Sie die Lint-Warnungen ernst und entfernen Sie bestehende manuelle Memoisierung erst nach Tests. Wer Ladezeiten und Core Web Vitals systematisch angehen möchte, findet Hintergründe zu Beratung und Seminaren auf der Seite Web Performance optimieren sowie unter Web-Performance und Optimierung.

Häufige Fragen zur React-Performance

Sind useMemo und useCallback mit dem React Compiler noch nötig?

In neuem Code meist nicht. Der Compiler fügt die Memoisierung dort ein, wo sie nützt. Manuell greifen Sie nur ein, wenn eine Messung eine wirklich teure Berechnung zeigt oder eine Bibliothek stabile Referenzen verlangt. In bestehendem Code bleiben vorhandene Aufrufe zunächst stehen, bis Tests zeigen, dass sie entbehrlich sind.

Wann passt useTransition und wann useDeferredValue?

Entscheidend ist, wer die Aktualisierung auslöst. useTransition passt, wenn Sie die State-Änderung selbst anstoßen und als nicht dringend markieren. useDeferredValue passt, wenn der Wert von außen kommt, etwa als Prop, aus einem Context oder aus URL-Parametern, und Sie nur das Rendern mit dem neuen Wert verzögern wollen.

Ab wann lohnt sich Virtualisierung?

Eine feste Grenze gibt es nicht, sie hängt davon ab, wie aufwendig eine Zeile ist und auf welchen Geräten die Anwendung läuft. Ein guter Anhaltspunkt ist die Messung: Wenn das erste Rendern einer Liste spürbar dauert oder das Scrollen ruckelt, ist Virtualisierung der nächste Schritt. Bei wenigen Hundert schlichten Einträgen genügt meist eine normale Liste.

Wie lässt sich herausfinden, welche Komponente eine Anwendung ausbremst?

Zeichnen Sie die langsame Interaktion mit dem Profiler der React DevTools auf. Die breitesten Balken im Flame-Chart zeigen die teuersten Komponenten, ein Klick verrät den Grund für das Rendern. Das Performance-Panel von Chrome ergänzt das um Long Tasks, die den Hauptthread blockieren, und zeigt, ob die Zeit beim Rendern, bei Skripten von Drittanbietern oder beim Zeichnen verloren geht.

Kategorien

Mehr aus „Frontend & UI“

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-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

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

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

JavaScript-Frameworks: Zu viele Frameworks, zu wenige Paradigmen

Viele klagen über zu viele JavaScript-Frameworks. Das eigentliche Problem sind wenige Grundmodelle. Was Signals, Server-first und Webstandards daran ändern.

mehr erfahren

Weitere Blog-Artikel

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

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-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

Spec-Driven Development mit GitHub Spec Kit erklärt

GitHub Spec Kit führt KI-Coding-Agenten von der Spezifikation über Plan und Aufgaben zum Code. Wie Befehle und Dateien zusammenspielen und wo Grenzen liegen.

mehr erfahren

Was dürfen wir für Sie tun?

So sind wir zu erreichen: