SolidJS: Warum Entwickler die feingranulare Reaktivität schätzen

SolidJS: Warum Entwickler die feingranulare Reaktivität schätzen

Signals statt virtuellem DOM: wie SolidJS funktioniert, wo es sich von React unterscheidet und für welche Projekte es sich eignet

Aktualisiert:

Abstract

SolidJS erklärt: Signals, JSX ohne virtuelles DOM und Komponenten, die nur einmal laufen. Was das Framework von React unterscheidet und wann es sich lohnt.
  • #Solid.js
  • #JavaScript Framework
  • #Reaktive Programmierung
  • #Leistung
  • #Reaktivität
  • #Virtueller DOM
  • #Webentwicklung
  • #Signals
  • #SolidStart

Eine Komponente, die nur einmal läuft – was hinter dem Ansatz von SolidJS steckt

Wer zum ersten Mal SolidJS-Code sieht, hält ihn leicht für React: Funktionen als Komponenten, JSX für das Markup, ein Aufruf, der einen Wert und eine Setter-Funktion zurückgibt. Erst beim zweiten Blick fällt auf, dass etwas grundsätzlich anders läuft. Eine Solid-Komponente wird genau einmal ausgeführt. Ändern sich später Daten, läuft nicht die Komponente erneut, sondern nur die eine Stelle im Browser-DOM wird aktualisiert, die von diesen Daten abhängt.

Dieser Unterschied klingt nach einem Detail für Framework-Liebhaber. Er hat aber praktische Folgen für Leistung, für die Art, wie man Code schreibt, und für typische Fehlerquellen. Außerdem ist die Idee längst nicht mehr auf Solid beschränkt: Angular, Vue, Svelte und Preact setzen inzwischen ebenfalls auf sogenannte Signals. Wer Solid versteht, versteht einen großen Teil der aktuellen Frontend-Entwicklung.

Was SolidJS ist und woher es kommt

SolidJS ist eine Open-Source-Bibliothek für Benutzeroberflächen im Browser. Ryan Carniato hat sie entwickelt, die erste stabile Version 1.0 erschien 2021. Solid ist bewusst schlank gehalten: Es liefert Reaktivität, Komponenten und ein paar Hilfskomponenten für Listen und Bedingungen. Routing, Datenladen auf dem Server und Rendering auf dem Server übernehmen ergänzende Pakete, allen voran das Meta-Framework SolidStart.

Eine große Verbreitung wie React, Angular oder Vue hat Solid nicht. Sein Einfluss auf andere Frameworks ist trotzdem beachtlich, weil es das Signal-Konzept populär gemacht hat.

Feingranulare Reaktivität: das Prinzip hinter Solid

Der Kern von Solid ist ein kleines Reaktivitätssystem aus drei Bausteinen:

  • Signal: ein Wert, der seine Leser kennt und nur diese informiert, sobald er sich ändert.
  • Memo: ein abgeleiteter Wert, der aus anderen Signals berechnet und zwischengespeichert wird.
  • Effect: Code, der automatisch erneut läuft, wenn sich ein darin gelesenes Signal ändert.

Ein Vergleich aus dem Büroalltag hilft: Wer in einer Kalkulationstabelle den Einzelpreis anpasst, sieht nur die abhängigen Formeln neu rechnen, das übrige Blatt bleibt unberührt. Fachleute sprechen von feingranularer Reaktivität, weil die Aktualisierung bis auf einzelne Werte und DOM-Knoten heruntergebrochen wird.

React arbeitet anders. Ändert sich dort der Zustand, ruft React die betroffene Komponentenfunktion erneut auf, erzeugt eine neue Beschreibung der Oberfläche (das virtuelle DOM, eine leichtgewichtige Kopie des Seitenbaums im Speicher) und vergleicht sie mit der vorherigen. Erst aus diesem Abgleich ergibt sich, welche echten DOM-Änderungen nötig sind. Das ist robust und gut verstanden, kostet aber Rechenarbeit, die Solid sich spart. Wie verschiedene Frameworks das DOM aktualisieren, vergleicht der Beitrag Rendering in JavaScript-Frameworks ausführlicher.

Ein Beispiel: Warenkorb mit Signals

Angenommen, ein Webshop für Büromöbel zeigt einen kleinen Warenkorb mit Mengen, Gesamtsumme und einer Anzeige, wie lange der Korb schon geöffnet ist. In Solid sieht das so aus:

import {
  createSignal,
  createMemo,
  createEffect,
  onCleanup,
  For,
  Show,
} from 'solid-js';
import { render } from 'solid-js/web';

type Position = { id: number; name: string; preis: number; menge: number };

function Warenkorb() {
  console.log('Komponente läuft genau einmal');

  const [positionen, setPositionen] = createSignal<Position[]>([
    { id: 1, name: 'Bürostuhl', preis: 249, menge: 1 },
    { id: 2, name: 'Monitorarm', preis: 89, menge: 2 },
  ]);

  // Abgeleiteter Wert: wird nur neu berechnet, wenn sich positionen ändert
  const summe = createMemo(() =>
    positionen().reduce((s, p) => s + p.preis * p.menge, 0),
  );

  createEffect(() => {
    console.log('Neue Summe:', summe());
  });

  // Ein Intervall auf oberster Ebene ist unproblematisch, weil die Funktion nicht erneut läuft
  const [sekunden, setSekunden] = createSignal(0);
  const timer = setInterval(() => setSekunden((s) => s + 1), 1000);
  onCleanup(() => clearInterval(timer));

  const erhoehen = (id: number) =>
    setPositionen((liste) =>
      liste.map((p) => (p.id === id ? { ...p, menge: p.menge + 1 } : p)),
    );

  return (
    <section>
      <For each={positionen()}>
        {(p) => (
          <p>
            {p.name}: {p.menge} × {p.preis} €{' '}
            <button onClick={() => erhoehen(p.id)}>+1</button>
          </p>
        )}
      </For>
      <Show when={summe() > 0} fallback={<p>Der Warenkorb ist leer.</p>}>
        <p>Gesamt: {summe()} €</p>
      </Show>
      <small>Seit {sekunden()} Sekunden geöffnet</small>
    </section>
  );
}

render(() => <Warenkorb />, document.getElementById('app')!);

Drei Dinge fallen auf. Erstens ist positionen keine Variable, sondern eine Funktion: Gelesen wird mit positionen(). Über diesen Aufruf merkt sich Solid, wer den Wert benutzt. Zweitens steht setInterval einfach im Funktionsrumpf. In React würde das bei jedem erneuten Rendern ein weiteres Intervall starten, deshalb braucht es dort useEffect mit Aufräumfunktion. In Solid läuft der Rumpf nur einmal, onCleanup räumt beim Entfernen der Komponente auf. Drittens tickt die Sekundenanzeige jede Sekunde, ohne dass die Liste oder die Summe angefasst werden. Aktualisiert wird nur der Textknoten mit der Zahl.

Die Hilfskomponenten For und Show sind kein Zierrat. Sie sorgen dafür, dass bei Listen und Bedingungen nur die betroffenen Teile neu erzeugt werden. Ein schlichtes .map() würde zwar funktionieren, bei jeder Änderung aber alle Listeneinträge neu anlegen.

Kein virtuelles DOM: was der Compiler erledigt

Solid übersetzt JSX beim Build nicht in Funktionsaufrufe wie React, sondern in Code, der echte DOM-Elemente erzeugt. Statische Teile des Markups werden als Vorlage einmal angelegt und dann geklont. Für jede dynamische Stelle, etwa {summe()}, erzeugt der Compiler eine kleine Aktualisierungsfunktion, die genau diesen Knoten ändert. Das JSX-Element ist in Solid deshalb tatsächlich ein DOM-Knoten und keine Beschreibung davon.

Mit Svelte teilt Solid die Idee, dem Browser möglichst wenig Framework-Logik zur Laufzeit zuzumuten. Der Weg ist aber unterschiedlich: Svelte hat eine eigene Template-Sprache und einen umfangreichen Compiler, Solid bleibt bei JSX und TypeScript und stützt sich stärker auf sein Laufzeit-Reaktivitätssystem. Den Ansatz von Svelte beschreibt der Beitrag Svelte und der Compiler-Ansatz.

Für die Leistung bedeutet das: Weniger Arbeit pro Änderung und eine kleine Laufzeitbibliothek. Wie viel davon bei einer konkreten Anwendung ankommt, hängt allerdings stärker von Datenmengen, Netzwerk und Bildern ab als von der Wahl des Frameworks. Pauschale Aussagen, Solid sei um einen bestimmten Faktor schneller als React, sollten Sie deshalb skeptisch sehen und lieber an der eigenen Anwendung messen.

Was im Alltag anders ist als in React

Wer aus React kommt, findet sich schnell zurecht, stolpert aber über ein paar typische Fallen:

  • Props nicht destrukturieren. Schreiben Sie function Karte(props) und lesen Sie props.titel erst im JSX. Wer ({ titel }) destrukturiert, liest den Wert einmal beim Start und verliert die Reaktivität. Für das Aufteilen und Zusammenführen von Props gibt es splitProps und mergeProps.
  • Signals immer aufrufen. summe ist die Funktion, summe() der Wert. Wer im JSX die Klammern vergisst, bekommt eine Funktion statt einer Zahl angezeigt.
  • Keine Abhängigkeitslisten. Effekte und Memos erkennen ihre Abhängigkeiten selbst. Das vermeidet die bekannten Fehler mit unvollständigen Abhängigkeitslisten in React, macht aber auch weniger sichtbar, wovon ein Effekt abhängt.
  • Stores für verschachtelte Daten. Für Objekte und Listen mit vielen Feldern bietet createStore aus solid-js/store Reaktivität auf Feldebene. Ändert sich nur die Menge einer Position, muss nicht die ganze Liste ersetzt werden.

Die wichtigsten Lebenszyklusfunktionen heißen onMount und onCleanup. Mehr braucht es selten, weil die Komponente ohnehin nur einmal läuft und alles Weitere über Signals und Effekte geregelt wird.

SolidStart, Ökosystem und der Stand von Solid 2.0

Für vollständige Webanwendungen mit Routing, Rendering auf dem Server und Serverfunktionen gibt es SolidStart. Es übernimmt eine ähnliche Rolle wie Next.js für React oder Nuxt für Vue und baut auf Vite auf. Für reine Single-Page-Anwendungen genügt ein Vite-Projekt mit der Solid-Vorlage, etwa über npm create vite@latest und die Vorlage solid-ts.

Die stabile Hauptversion ist Solid 1.x. An Solid 2.0 wird seit längerer Zeit gearbeitet, auf npm liegt die neue Version als Vorabversion (Release Candidate). Schwerpunkte sind laut Projekt asynchrone Daten als fester Bestandteil der Reaktivität sowie ein geändertes Modell für Batching und Effekte. Dabei ändern sich auch APIs und Importpfade, etwa entfällt solid-js/store; das Codebeispiel oben bezieht sich auf 1.x. Für Produktivprojekte empfiehlt sich, bis zur stabilen Freigabe bei 1.x zu bleiben und den Umstieg dann anhand der offiziellen Migrationshinweise zu planen.

Beim Ökosystem liegt der deutlichste Unterschied zu React. Für Solid gibt es einen Router, Bibliotheken wie TanStack Query und TanStack Table sowie mehrere UI-Komponentensammlungen. Die Auswahl ist aber kleiner. Auch der Arbeitsmarkt ist überschaubar: Solid-Erfahrung bringen deutlich weniger Entwickler:innen mit als React-Erfahrung.

Wie sich Solid zu React, Vue, Svelte und Angular verhält

Die Frontend-Landschaft hat sich seit dem ersten Erscheinen von Solid spürbar bewegt. Viele Ideen, die damals als Besonderheit galten, sind heute verbreitet:

FrameworkReaktivitätsmodellAktualisierung des DOM
SolidJSSignalsdirekt, ohne virtuelles DOM
ReactZustand löst erneutes Rendern ausvirtuelles DOM mit Abgleich
Vue 3reaktive Refs und Proxysvirtuelles DOM, mit Compiler-Optimierungen
Svelte 5Runes (Signals unter der Haube)Compiler erzeugt direkte DOM-Updates
AngularSignals, ergänzend RxJSÄnderungserkennung, zunehmend signalgesteuert

React hält am virtuellen DOM fest, versucht aber mit dem React Compiler, unnötiges erneutes Rendern automatisch zu vermeiden. Angular hat Signals seit Version 16 eingebaut und kommt inzwischen ohne die Hilfsbibliothek zone.js aus, wie der Beitrag Angular Signals zeigt. Svelte setzt mit Version 5 auf Runes, die intern ebenfalls als Signals arbeiten. Auch das Standardisierungsgremium TC39 berät über einen Vorschlag für Signals als Teil von JavaScript. Bis daraus ein fester Sprachbestandteil wird, dürfte es aber noch dauern.

Für die Einordnung heißt das: Solid ist nicht mehr der Exot mit einem einzigartigen Konzept, sondern die konsequenteste Umsetzung eines Modells, auf das sich die Branche zubewegt.

Für welche Projekte sich SolidJS lohnt

Solid spielt seine Stärken bei Oberflächen aus, die viele kleine, häufige Änderungen verarbeiten: Dashboards mit Live-Daten, Kollaborationswerkzeuge, Konfiguratoren mit vielen voneinander abhängigen Feldern oder eingebettete Widgets, die auf fremden Seiten möglichst wenig Ballast mitbringen sollen. Auch für Teams, die feingranulare Reaktivität grundsätzlich verstehen wollen, ist Solid ein gutes Lernobjekt, weil das Modell dort ohne Zusatzschichten sichtbar ist.

Weniger überzeugend ist Solid, wo ein großes Ökosystem zählt: bei Unternehmensanwendungen mit vielen fertigen Komponenten, bei Teams mit wechselnder Besetzung oder bei Projekten, die auf ein breites Angebot an Fachkräften angewiesen sind. Hier ist React mit seinem Umfeld oder Angular mit seinen festen Strukturen oft die nüchternere Wahl. Wer bereits eine große React-Anwendung betreibt, gewinnt durch einen Wechsel selten genug, um den Aufwand zu rechtfertigen. Oft bringt gezielte Optimierung mehr, etwa mit den Mitteln aus dem Beitrag zu React Hooks und Performance.

Unsere Einschätzung: Solid ist ein ausgereiftes, gut durchdachtes Werkzeug für Teams, die Leistung und Kontrolle schätzen und mit einem kleineren Ökosystem leben können. Für die meisten Unternehmensprojekte bleibt die Frage, welches Framework das Team langfristig sicher beherrscht, wichtiger als die letzte Millisekunde. Wenn eine Webanwendung spürbar langsam ist, lohnt sich zuerst eine Messung, bevor das Framework infrage gestellt wird. Dabei unterstützen wir im Rahmen der Web-Performance-Optimierung. Fragen zur Wahl und Struktur des Frontends behandeln wir in Beratung und Seminaren zur Frontend-Architektur.

Häufige Fragen zu SolidJS

Ist SolidJS für Einsteiger geeignet?

Für Einsteiger mit Grundkenntnissen in JavaScript ja. Die API ist klein und das Verhalten nachvollziehbar, weil Komponenten nur einmal laufen. Ungewohnt ist vor allem, Signals immer als Funktion aufzurufen und Props nicht zu destrukturieren. Wer später auf dem Arbeitsmarkt flexibel sein will, sollte zusätzlich React oder Angular kennen.

Lässt sich eine React-Anwendung auf Solid umstellen?

Nicht automatisch. JSX und Komponentenstruktur ähneln sich, aber Hooks, Zustandsverwaltung und viele Bibliotheken müssen ersetzt werden. Ein Umstieg bedeutet in der Praxis ein Neuschreiben, das sich nur lohnt, wenn es dafür einen konkreten Grund gibt. Für neue, abgegrenzte Teile wie ein eingebettetes Widget ist Solid leichter einzuführen.

Wo gibt es verlässliche Informationen zu Solid 2.0?

Maßgeblich sind die offizielle Dokumentation unter docs.solidjs.com, die eigene Dokumentation zu Solid 2.0 unter v2.solidjs.com und die Release-Hinweise sowie der Migrationsleitfaden im GitHub-Repository des Projekts. Solange Solid 2.0 als Vorabversion erscheint, können sich APIs noch ändern.

Mehr aus „Programmiersprachen“

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

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

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

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

Warum Python, Go und Rust die Zukunft der Softwareentwicklung prägen

Python, Go und Rust teilen sich die Arbeit: Daten und KI, Cloud-Dienste, sichere Systeme. Wo jede Sprache passt, wie sie zusammenwirken und was KI daran ändert.

mehr erfahren

Facebook und PHP: Vom Abschied über HHVM zu Hack

Ein Rückblick von 2025: Wie Facebook PHP mit HipHop, HHVM und Hack umbaute, warum es sich von PHP löste und was davon in PHP selbst ankam.

mehr erfahren

Weitere Blog-Artikel

Tauri und Rust: Desktop-Anwendungen schlank und sicher bauen

Tauri baut Desktop-Apps aus Web-Frontend und Rust-Kern, ohne eigenen Browser im Paket. Wie Tauri 2 funktioniert und für welche Projekte es sich eignet.

mehr erfahren

React und ASP.NET Core Web API: Frontend und Backend verbinden

React mit einer ASP.NET-Core-Web-API verbinden: Vite-Proxy statt CORS, Minimal APIs, Typen aus OpenAPI, Anmeldung per Cookie und gemeinsames Deployment.

mehr erfahren

Perl heute: Was die Schweizer Taschenmesser-Sprache noch kann

Perl gilt als Schweizer Taschenmesser für Textverarbeitung und Systemadministration. Was modernes Perl kann und wann sich die Sprache heute noch lohnt.

mehr erfahren

Redux in der Praxis: State-Management mit Redux Toolkit

Redux mit Redux Toolkit in React einsetzen: Store, Slices, Immer und typisierte Hooks am Beispiel erklärt. Dazu, wann Redux sinnvoll ist und wann nicht.

mehr erfahren

Von Nullen und Einsen zu Assembly: Wie Maschinensprache funktioniert

Maschinensprache und Assembler erklärt: wie ein Prozessor Befehle ausführt, was x86-64, ARM und RISC-V unterscheidet und wo Assembly heute noch zählt.

mehr erfahren

Elixir: Hochperformante und ausfallsichere Anwendungen bauen

Elixir verbindet funktionale Programmierung mit der Erlang-Laufzeit BEAM. Was Prozesse, Supervisor und Phoenix leisten und wofür sich die Sprache eignet.

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: