Blazor: Webfrontends mit C# statt JavaScript entwickeln

Blazor: Webfrontends mit C# statt JavaScript entwickeln

Render-Modi, WebAssembly und Serverbetrieb: was Blazor seit .NET 8 kann, wo es an Grenzen stößt und für welche Teams es sich lohnt

Aktualisiert:

Abstract

Blazor bringt C# in den Browser, per WebAssembly oder vom Server aus. Wie die Render-Modi funktionieren und für welche Projekte sich das Framework eignet.
  • #Blazor
  • #Webentwicklung
  • #C#
  • #WebAssembly
  • #Frontend
  • #Webanwendungen
  • #ASP.NET Core
  • #.NET

Wann ein .NET-Team seine Weboberfläche in C# schreiben sollte und wann JavaScript die bessere Wahl bleibt

Angenommen, ein mittelständischer Maschinenbauer beschäftigt ein kleines .NET-Team. Es pflegt seit Jahren das ERP-Backend, die Schnittstellen zu den Maschinen und ein paar Desktop-Werkzeuge, alles in C#. Nun soll das Serviceportal für Kunden eine zeitgemäße Weboberfläche bekommen. Der übliche Weg hieße: TypeScript lernen, sich für React oder Angular entscheiden, npm-Pakete und Build-Werkzeuge einrichten und künftig zwei Technikwelten pflegen.

Blazor verspricht eine Abkürzung. Das Framework von Microsoft erlaubt es, interaktive Weboberflächen in C# zu schreiben, mit denselben Datenmodellen, Validierungsregeln und Bibliotheken wie im Backend. Das Versprechen „ohne JavaScript“ stimmt allerdings nur zum Teil, und die Entscheidung für Blazor hat Folgen für Ladezeiten, Serverlast und Personalplanung. Der folgende Überblick zeigt, wie Blazor heute arbeitet, was sich mit .NET 8 grundlegend geändert hat und für welche Projekte es passt.

Was Blazor ist und woher es kommt

Blazor ist Teil von ASP.NET Core, dem quelloffenen Web-Framework von Microsoft. Der Name verbindet „Browser“ und „Razor“, die Vorlagensyntax, mit der in .NET seit Langem HTML und C# gemischt werden. Wie React oder Vue setzt Blazor auf Komponenten: in sich geschlossene Bausteine der Oberfläche, etwa ein Suchfeld, eine Auftragstabelle oder ein ganzes Formular, die sich verschachteln und wiederverwenden lassen.

Den Anstoß gab Steve Sanderson, der damals bei Microsoft arbeitete und zuvor die JavaScript-Bibliothek Knockout.js entwickelt hatte. Aus seinem Experiment wurde 2018 ein offizielles, zunächst experimentelles Projekt. 2019 erschien Blazor Server als stabile Version, 2020 folgte Blazor WebAssembly. Lange musste sich ein Team zu Projektbeginn für eines der beiden Modelle entscheiden.

Mit .NET 8 im November 2023 hat Microsoft dieses Entweder-oder aufgelöst. Die Projektvorlage heißt seitdem „Blazor Web App“, und jede Seite oder Komponente bekommt einen eigenen Render-Modus. Wer ältere Tutorials liest, sollte deshalb auf das Datum achten: Vieles, was dort über Hosting-Modelle steht, beschreibt den Stand vor .NET 8.

Komponenten aus Razor und C#

Eine Blazor-Komponente ist eine Datei mit der Endung .razor. Oben steht HTML mit eingebetteten C#-Ausdrücken, darunter ein @code-Block mit der Logik. Das klassische Einstiegsbeispiel ist ein Zähler:

@page "/zaehler"
@rendermode InteractiveServer

<h1>Zähler</h1>

<p role="status">Aktueller Wert: @aktuellerWert</p>

<button class="btn btn-primary" @onclick="Erhoehen">Erhöhen</button>

@code {
    private int aktuellerWert = 0;

    private void Erhoehen()
    {
        aktuellerWert++;
    }
}

Die Direktive @page macht die Komponente unter der Adresse /zaehler erreichbar. @rendermode InteractiveServer legt fest, dass die Komponente interaktiv ist und ihre Logik auf dem Server ausführt. Fehlt diese Zeile, rendert Blazor die Seite nur einmal als statisches HTML, und der Knopf bliebe ohne Wirkung.

Nach einem Klick ruft Blazor die Methode Erhoehen auf, rendert die Komponente neu und vergleicht das Ergebnis mit dem vorherigen Stand. An den Browser geht nur der Unterschied, in diesem Fall die geänderte Zahl. Dieses Prinzip eines Abgleichs im Speicher kennen Entwickler:innen von React.

Daten erhalten Komponenten über Parameter, also öffentliche Eigenschaften mit dem Attribut [Parameter]. Dienste wie ein Datenbankzugriff oder ein API-Client kommen über Dependency Injection hinein, ein Verfahren, bei dem die Anwendung benötigte Objekte zentral bereitstellt, statt dass jede Komponente sie selbst erzeugt. In der Komponente genügt dafür eine Zeile wie @inject IAuftragsService Auftraege. Das erleichtert Tests, weil sich der echte Dienst durch eine Attrappe ersetzen lässt.

Die vier Render-Modi seit .NET 8

Der Render-Modus entscheidet, wo der C#-Code einer Komponente läuft und wie sie mit dem Browser spricht. Er lässt sich für die ganze Anwendung, für einzelne Seiten oder sogar für einzelne Komponenten festlegen.

Statisches Server-Rendering

Der Server erzeugt HTML und schickt es an den Browser, ähnlich wie klassische Webseiten oder Razor Pages. Es gibt keine dauerhafte Verbindung und keine Ereignisbehandlung im Browser. Formulare funktionieren trotzdem, weil sie wie gewohnt per HTTP abgeschickt werden. Für Inhaltsseiten, Produktlisten oder Anmeldemasken ist das oft völlig ausreichend, und die Seiten laden schnell und sind für Suchmaschinen gut lesbar.

Interaktiv auf dem Server

Der Code bleibt auf dem Server. Der Browser baut über SignalR, eine Bibliothek für Echtzeitverbindungen auf Basis von WebSockets, eine dauerhafte Verbindung auf. Jeder Klick wandert zum Server, die Antwort kommt als kleine Änderung am Seitenaufbau zurück. Der Vorteil: Die erste Anzeige ist schnell, und der Code kann direkt auf Datenbanken und interne Dienste zugreifen, ohne eigene API. Der Nachteil: Jede Interaktion braucht einen Netzwerk-Umlauf, der Server hält für jede offene Sitzung Zustand im Speicher, und bei einer abgerissenen Verbindung muss sich die Seite neu verbinden.

Interaktiv per WebAssembly

Hier lädt der Browser eine .NET-Laufzeitumgebung und die Anwendungsbibliotheken herunter und führt den Code lokal aus. WebAssembly ist ein Binärformat, das alle aktuellen Browser neben JavaScript ausführen können. Nach dem Laden reagiert die Oberfläche ohne Umweg über den Server, und die Anwendung kann teilweise offline arbeiten. Dafür dauert der erste Aufruf spürbar länger, und der Code im Browser darf nur über eine API auf Daten zugreifen, denn alles, was dort läuft, kann ein Nutzer einsehen.

Auto-Modus

Der Modus „Auto“ verbindet beides. Beim ersten Besuch arbeitet die Komponente über die Serververbindung, während im Hintergrund die WebAssembly-Dateien geladen werden. Bei späteren Besuchen läuft sie dann im Browser. Das klingt nach dem Besten aus beiden Welten, verlangt aber, dass der Code in beiden Umgebungen funktioniert, meist mit einer Schnittstelle, die serverseitig direkt und im Browser über HTTP umgesetzt ist.

Render-ModusWo läuft C#?Erste AnzeigeLaufende VerbindungTypischer Einsatz
Statisch (Server)ServerschnellkeineInhaltsseiten, Formulare, Listen
Interaktiv ServerServerschnellSignalRinterne Fachanwendungen
Interaktiv WebAssemblyBrowserlangsamernur API-Aufruferechenintensive, offlinefähige Apps
Autoerst Server, dann Browserschnellwechselndöffentliche Portale mit Interaktion

In der Praxis kombinieren viele Anwendungen die Modi: Die Startseite und die Hilfetexte werden statisch ausgeliefert, nur das Auftragsformular mit Live-Validierung ist interaktiv.

Was WebAssembly leistet und was nicht

Das alte Versprechen „blitzschnell dank WebAssembly“ hält einer nüchternen Betrachtung nur teilweise stand. Standardmäßig übersetzt Blazor WebAssembly den C#-Code nicht in WebAssembly, sondern lädt eine in WebAssembly übersetzte .NET-Laufzeit, die den Zwischencode der Anwendung interpretiert, also Befehl für Befehl ausführt, seit .NET 8 ergänzt um eine teilweise Just-in-time-Übersetzung. Das ist für typische Formulare und Tabellen schnell genug, aber nicht schneller als gut geschriebenes JavaScript.

Für rechenintensive Teile gibt es die AOT-Kompilierung (Ahead of Time): Der Code wird beim Build direkt in WebAssembly übersetzt. Das beschleunigt etwa Berechnungen oder Bildverarbeitung deutlich, macht die herunterzuladenden Dateien aber größer und den Build langsamer. Gegen die Größe hilft das Trimming, bei dem der Build ungenutzten Code aus den Bibliotheken entfernt.

Eine Grenze bleibt: WebAssembly darf das Seitenlayout im Browser, den DOM, nicht direkt verändern. Jede Änderung läuft über eine Brücke in JavaScript. Für Oberflächen mit sehr vielen Elementen, etwa Tabellen mit Tausenden Zeilen, braucht es deshalb Techniken wie Virtualisierung, bei der nur die sichtbaren Zeilen gerendert werden. Blazor bringt dafür die Komponente Virtualize mit. Wie WebAssembly grundsätzlich funktioniert und wo seine Stärken liegen, beschreibt der Beitrag über WebAssembly von C++ bis Rust.

Ganz ohne JavaScript geht es selten

Für viele Fachanwendungen schreibt ein Blazor-Team tatsächlich kaum eine Zeile JavaScript. Ganz verschwindet die Sprache trotzdem nicht. Blazor selbst lädt ein eigenes Skript, das die Verbindung zum Server oder zur WebAssembly-Laufzeit herstellt. Und sobald eine Anwendung Browser-Funktionen braucht, für die .NET keine Schnittstelle hat, oder eine bewährte JavaScript-Bibliothek für Karten oder Diagramme nutzen soll, kommt die JavaScript-Interop ins Spiel.

Über den Dienst IJSRuntime ruft C#-Code JavaScript-Funktionen auf, umgekehrt kann JavaScript mit Methoden zusammenarbeiten, die das Attribut [JSInvokable] tragen. Ein Beispiel ist das Kopieren in die Zwischenablage:

@inject IJSRuntime JS

<button @onclick="Kopieren">Auftragsnummer kopieren</button>

@code {
    [Parameter] public string Auftragsnummer { get; set; } = "";

    private async Task Kopieren()
    {
        // Ruft die Browser-API direkt über ihren Namen auf
        await JS.InvokeVoidAsync("navigator.clipboard.writeText", Auftragsnummer);
    }
}

Die Interop ist bewusst asynchron und sollte sparsam eingesetzt werden, weil jeder Aufruf im Server-Modus über das Netzwerk geht. Details zu Aufrufrichtungen, Fehlerbehandlung und Performance stehen im Beitrag über JavaScript Interop in ASP.NET Core Blazor.

Ein Projekt aufsetzen

Für den Einstieg genügt das .NET SDK. Mit der Kommandozeile entsteht ein neues Projekt, hier mit dem Auto-Modus als Voreinstellung:

dotnet new blazor -o Serviceportal --interactivity Auto
cd Serviceportal
dotnet watch --project Serviceportal

Die Option --interactivity akzeptiert None, Server, WebAssembly und Auto. Bei WebAssembly und Auto legt die Vorlage zwei Projekte an: eines für den Server und eines mit der Endung .Client für alles, was im Browser laufen soll. dotnet watch startet die Anwendung und lädt Änderungen am Code nach Möglichkeit ohne Neustart nach (Hot Reload).

Die Render-Modi werden in der Datei Program.cs registriert. Dort meldet das Team auch eigene Dienste für die Dependency Injection an:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents()
    .AddInteractiveWebAssemblyComponents();

// Eigener Dienst, je Benutzersitzung eine Instanz
builder.Services.AddScoped<IAuftragsService, AuftragsService>();

var app = builder.Build();

app.UseAntiforgery();
app.MapStaticAssets();
app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode()
    .AddInteractiveWebAssemblyRenderMode()
    .AddAdditionalAssemblies(typeof(Serviceportal.Client._Imports).Assembly);

app.Run();

Als Entwicklungsumgebung eignen sich Visual Studio, Visual Studio Code mit der Erweiterung C# Dev Kit oder JetBrains Rider. Für automatisierte Komponententests hat sich die quelloffene Bibliothek bUnit etabliert.

Ökosystem und Blazor Hybrid

Das Ökosystem ist kleiner als das von React oder Angular, aber für Geschäftsanwendungen gut bestückt. Microsoft liefert Grundbausteine wie Formulare mit Validierung, Authentifizierung und das Tabellen-Raster QuickGrid. Dazu kommen Komponentenbibliotheken, quelloffen etwa MudBlazor, Radzen oder die Fluent UI Blazor Components von Microsoft, kommerziell unter anderem Telerik und Syncfusion. Wer dagegen eine bestimmte, nur für React verfügbare Bibliothek braucht, muss sie über die Interop einbinden oder auf sie verzichten.

Blazor-Komponenten laufen nicht nur im Browser. Mit Blazor Hybrid lassen sie sich in Desktop- und Mobil-Apps einbetten, etwa mit .NET MAUI, WPF oder Windows Forms. Die Komponenten werden dabei in einer eingebetteten Browser-Ansicht dargestellt, nicht mit nativen Bedienelementen des Betriebssystems, haben aber vollen Zugriff auf die Geräte-Schnittstellen über .NET. Für ein Team, das dieselbe Oberfläche im Web und als Tablet-App für den Außendienst braucht, ist das ein handfester Vorteil. Wie sich das mit .NET MAUI umsetzen lässt, beschreibt die Themenseite zu .NET MAUI.

Für wen sich Blazor lohnt

Blazor ist kein Ersatz für JavaScript im ganzen Web, aber eine ernsthafte Option für eine klar umrissene Gruppe von Projekten. Am stärksten ist es bei internen Fachanwendungen und Kundenportalen von Organisationen, die ohnehin auf .NET setzen: Verwaltungsoberflächen, Auftragserfassung, Dashboards, Konfiguratoren. Hier zählt, dass Datenmodelle, Validierung und Geschäftslogik nur einmal existieren und ein Team das gesamte System versteht.

Weniger gut passt Blazor, wenn

  • ein Team bereits sicher mit React, Angular oder Vue arbeitet und keinen .NET-Hintergrund hat,
  • eine öffentliche Website vor allem schnell laden und gut gefunden werden muss und kaum Interaktion braucht (hier reichen statisch erzeugte Seiten oder schlanke Ansätze wie HTMX),
  • sehr viele gleichzeitige Nutzer erwartet werden und nur der Server-Modus in Frage käme, weil dann Arbeitsspeicher und Verbindungen zum Engpass werden können.

Zu bedenken ist auch die Bindung an Microsoft und dessen Taktung: Jedes Jahr im November erscheint eine neue .NET-Version, abwechselnd mit drei Jahren Unterstützung (LTS) und kürzerer Unterstützung (STS). Blazor hat sich in dieser Zeit stark verändert, zuletzt vor allem durch die Render-Modi. Wer ein Projekt startet, sollte ein Update im Jahresrhythmus fest einplanen.

Unsere Einschätzung: Für .NET-Teams, die eine Geschäftsanwendung mit Weboberfläche bauen, ist Blazor heute eine solide und ausgereifte Wahl, vor allem in Kombination aus statischem Rendering und gezielt interaktiven Komponenten. Überschätzt wird es als allgemeiner Ersatz für JavaScript-Frameworks und als Garant für hohe Performance.

Häufige Fragen zu Blazor

Ist Blazor schneller als JavaScript?

Nicht grundsätzlich. Im WebAssembly-Modus wird der Code standardmäßig interpretiert, und jeder Zugriff auf die Seite läuft über JavaScript. Für typische Formulare ist der Unterschied kaum spürbar. Bei rechenintensiven Aufgaben kann AOT-kompilierter Code schneller sein, bei sehr dynamischen Oberflächen sind gut optimierte JavaScript-Frameworks oft im Vorteil. Der größte spürbare Unterschied ist die längere erste Ladezeit im WebAssembly-Modus.

Wie gut können Suchmaschinen Blazor-Seiten lesen?

Seit .NET 8 rendert Blazor Seiten standardmäßig auf dem Server vor. Suchmaschinen erhalten also fertiges HTML, auch wenn die Seite später interaktiv wird. Reine WebAssembly-Anwendungen ohne Vorrendern waren in dieser Hinsicht früher ein Problem.

Lässt sich eine bestehende ASP.NET-Anwendung schrittweise umstellen?

Ja. Blazor-Komponenten lassen sich in bestehende Razor Pages und MVC-Ansichten einbetten. So kann ein Team einzelne Bereiche modernisieren, ohne die gesamte Anwendung neu zu schreiben. Ältere Projekte auf Basis von Blazor Server oder Blazor WebAssembly aus der Zeit vor .NET 8 laufen weiter, lassen sich aber auch auf das Modell der Blazor Web App umstellen.

Welche .NET-Version sollte ein neues Projekt nutzen?

Für neue Projekte empfiehlt sich in der Regel die aktuelle LTS-Version, derzeit .NET 10 aus dem November 2025. Sie wird drei Jahre mit Updates versorgt. Kürzer unterstützte Versionen lohnen sich vor allem, wenn ein Team ohnehin jährlich aktualisiert und neue Funktionen früh nutzen möchte.

Wer Blazor für ein konkretes Vorhaben bewerten oder ein Team in das Framework einarbeiten möchte, findet auf der Themenseite zu ASP.NET Core unsere Angebote für Beratung, Coaching und Seminare.

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

Blockchain-Anwendungen: Wo die Technik Unternehmen wirklich nützt

Blockchain jenseits von Bitcoin: wie Lieferketten, Nachweise und Tokenisierung profitieren, was MiCA regelt und wann Sie besser darauf verzichten.

mehr erfahren

Cloud Computing: Wie die Cloud die Zukunft der IT prägt

Cloud Computing ist Alltag. Lesen Sie, was die Cloud von klassischem Hosting unterscheidet, wo ihre Grenzen liegen und wohin sich die IT entwickelt.

mehr erfahren

Cybersicherheit: Wie Unternehmen sich gegen aktuelle Angriffe schützen

Cybersicherheit für Unternehmen: welche Angriffe heute häufig sind, welche Basismaßnahmen wirken und was NIS2 und der Cyber Resilience Act verlangen.

mehr erfahren

Datenbanken verstehen: SQL, NoSQL und NewSQL im Überblick

Relationale Datenbanken, NoSQL und NewSQL verständlich erklärt: Datenmodelle, ACID und BASE, CAP-Theorem und Kriterien für die passende Datenbankwahl.

mehr erfahren

Datengetriebenes Arbeiten: Wie Unternehmen ihre Daten nutzbar machen

Datengetriebenes Arbeiten beginnt nicht mit Technik. Lesen Sie, wie Datenstrategie, Datenqualität, Governance und klare Rollen Daten nutzbar machen.

mehr erfahren

ITIL 4 in der digitalen Transformation: Was das Framework leistet

ITIL 4 verständlich erklärt: Service Value System, Wertschöpfungskette und Praktiken, das Verhältnis zu Agile und DevOps sowie die Zertifizierungswege.

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: