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
- #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 Sieprops.titelerst 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 essplitPropsundmergeProps. - Signals immer aufrufen.
summeist 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
createStoreaussolid-js/storeReaktivitä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:
| Framework | Reaktivitätsmodell | Aktualisierung des DOM |
|---|---|---|
| SolidJS | Signals | direkt, ohne virtuelles DOM |
| React | Zustand löst erneutes Rendern aus | virtuelles DOM mit Abgleich |
| Vue 3 | reaktive Refs und Proxys | virtuelles DOM, mit Compiler-Optimierungen |
| Svelte 5 | Runes (Signals unter der Haube) | Compiler erzeugt direkte DOM-Updates |
| Angular | Signals, 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.
Kategorien
Schlagworte