LLVM erklärt: Das Baukastensystem hinter modernen Compilern

LLVM erklärt: Das Baukastensystem hinter modernen Compilern

Wie Clang, Rust, Swift und Julia auf einer gemeinsamen Infrastruktur aufbauen und was ein eigener Compiler damit kostet

Aktualisiert:

Abstract

LLVM ist die Compiler-Infrastruktur hinter Clang, Rust und Swift. Wie Frontend, IR und Backend zusammenspielen und wann sich ein eigener Compiler lohnt.
  • #LLVM
  • #Compiler
  • #Programmiersprachen
  • #Clang
  • #Rust
  • #Swift
  • #Julia
  • #Intermediate Representation
  • #Code-Generierung
  • #Backend

Ein Zwischencode, viele Sprachen, viele Prozessoren: Warum fast jede neue Programmiersprache auf LLVM setzt

Wer heute ein Rust-Programm baut, eine iOS-App in Swift kompiliert oder C++ mit Clang übersetzt, benutzt am Ende dasselbe Stück Software, ohne es zu merken. Die letzte Etappe vom Quelltext zur ausführbaren Datei erledigt in allen drei Fällen LLVM. Auch Julia, Kotlin/Native, Zig und viele Werkzeuge für Grafikkarten und WebAssembly greifen darauf zurück.

Dass so unterschiedliche Sprachen sich einen Unterbau teilen, ist kein Zufall, sondern eine Architekturentscheidung. LLVM zerlegt den Compiler in austauschbare Bausteine. Eine neue Sprache muss nur noch ihren eigenen Teil schreiben und erbt Optimierungen und Prozessorunterstützung, an denen Hunderte Entwickler:innen über zwei Jahrzehnte gearbeitet haben. Was das technisch bedeutet, wie der Einstieg aussieht und für wen sich der Aufwand lohnt, zeigt der folgende Überblick.

Woher LLVM kommt und was der Name heute bedeutet

LLVM entstand ab dem Jahr 2000 als Forschungsprojekt an der University of Illinois in Urbana-Champaign. Chris Lattner entwickelte es zusammen mit seinem Betreuer Vikram Adve. Die erste öffentliche Version erschien 2003. Ursprünglich stand das Kürzel für „Low Level Virtual Machine“. Mit einer virtuellen Maschine im Sinne von Java oder .NET hat das Projekt aber wenig zu tun, deshalb verstehen die Entwickler LLVM längst nur noch als Eigennamen.

Den Sprung aus der Forschung schaffte LLVM, als Apple Lattner 2005 einstellte. Apple brauchte einen Compiler, der sich eng mit Xcode verzahnen ließ, und baute auf LLVM das C-Frontend Clang auf. Später entwarf Lattner bei Apple auch Swift. Heute arbeiten Firmen wie Apple, Google, Intel, AMD, Arm und Microsoft sowie viele Freiwillige gemeinsam an dem Projekt. Der Code steht unter der Apache-Lizenz 2.0 mit LLVM-spezifischen Ausnahmen, die das Einbinden in eigene, auch proprietäre Produkte erleichtern.

LLVM ist dabei kein einzelnes Programm, sondern eine Sammlung von Projekten unter einem Dach. Dazu gehören:

  • Clang, der Compiler für C, C++ und Objective-C, samt Werkzeugen wie clang-format und clang-tidy,
  • LLD, ein schneller Linker, der die übersetzten Teile zu einer ausführbaren Datei verbindet,
  • LLDB, ein Debugger, den unter anderem Xcode verwendet,
  • die Sanitizer, Laufzeitprüfungen, die etwa Speicherfehler oder Datenwettläufe in C- und C++-Programmen aufspüren,
  • MLIR, ein Rahmenwerk für Zwischencodes auf höherer Ebene, das unter anderem in vielen Compilern für maschinelles Lernen steckt.

Das Prinzip: Frontend, Zwischencode, Backend

Jeder Compiler übersetzt Text, den Menschen lesen können, in Befehle, die ein Prozessor ausführt. Klassisch geschieht das in drei Stufen.

Das Frontend liest den Quelltext, prüft Syntax und Typen und meldet Fehler. Es ist der Teil, der eine Sprache ausmacht: Die Regeln von Rust unterscheiden sich grundlegend von denen von C. Das Middle-End verbessert das Programm, ohne seine Bedeutung zu ändern. Es entfernt Code, der nie ausgeführt wird, rechnet konstante Ausdrücke vorab aus oder fügt kleine Funktionen direkt an der Aufrufstelle ein. Das Backend schließlich erzeugt Maschinencode für eine bestimmte Architektur, also etwa x86-64 im Rechenzentrum, ARM im Smartphone oder RISC-V in eingebetteten Systemen.

Ohne gemeinsamen Unterbau müsste jede Sprache alle drei Stufen selbst bauen. Bei fünf Sprachen und fünf Prozessorfamilien wären das im ungünstigsten Fall 25 Kombinationen. LLVM schiebt dazwischen eine einheitliche Schnittstelle: Jede Sprache liefert ihr Programm in derselben Zwischendarstellung ab, und jedes Backend versteht genau diese Darstellung. Aus 25 Kombinationen werden fünf Frontends plus fünf Backends.

Ein Vergleich aus der Logistik: Ein Versandhändler, der für jeden Lieferanten und jeden Paketdienst eigene Formulare pflegt, verliert schnell den Überblick. Einigen sich alle auf ein einheitliches Versandetikett, muss jeder nur noch dieses eine Format beherrschen. Die LLVM-Zwischendarstellung ist ein solches Etikett.

Die Intermediate Representation im Detail

Die Zwischendarstellung heißt LLVM IR (Intermediate Representation). Sie liegt in drei gleichwertigen Formen vor: als Datenstruktur im Speicher des Compilers, als kompakte Binärdatei (Bitcode) und als lesbarer Text. Die Textform sieht aus wie eine Assemblersprache, ist aber unabhängig von einem bestimmten Prozessor.

Drei Eigenschaften machen sie für Optimierungen besonders geeignet:

  1. Static Single Assignment (SSA): Jeder Wert wird genau einmal zugewiesen. Statt eine Variable x mehrmals zu überschreiben, entstehen neue Werte wie %x1 und %x2. Dadurch lässt sich leicht verfolgen, woher ein Wert stammt und ob er überhaupt gebraucht wird.
  2. Strenge Typen: Jede Operation kennt den Typ ihrer Operanden, etwa eine 32-Bit-Ganzzahl oder eine Gleitkommazahl doppelter Genauigkeit. Fehler im Frontend fallen so früh auf.
  3. Unbegrenzt viele Register: Die IR tut so, als hätte der Prozessor beliebig viele Speicherplätze. Erst das Backend verteilt die Werte auf die tatsächlich vorhandenen Register.

Wie das in der Praxis aussieht, lässt sich mit Clang selbst ausprobieren. Der folgende Befehl übersetzt eine C-Datei nicht in Maschinencode, sondern gibt die IR als Text aus:

# IR einer C-Datei erzeugen (Textform, Dateiendung .ll)
clang -S -emit-llvm -O2 summe.c -o summe.ll

# Dieselbe IR mit dem Optimierer weiterbearbeiten (neuer Pass-Manager)
opt -passes='default<O3>' summe.ll -S -o summe-o3.ll

# IR in Assemblercode für eine bestimmte Zielarchitektur übersetzen
llc -mtriple=aarch64-linux-gnu summe-o3.ll -o summe.s

Wer die Datei summe.ll öffnet, erkennt schnell die Struktur: Funktionen beginnen mit define, bestehen aus benannten Grundblöcken und enden mit ret. Ein lohnender Lerneffekt entsteht, wenn Sie dieselbe Funktion einmal mit -O0 und einmal mit -O2 übersetzen und die Ergebnisse vergleichen. Aus einer Schleife, die Zahlen aufsummiert, wird bei eingeschalteter Optimierung oft eine geschlossene Rechenformel oder Vektorcode, der mehrere Werte gleichzeitig verarbeitet.

Seit einigen Hauptversionen hat sich die IR spürbar vereinfacht. Zeiger tragen keinen Typ mehr, man schreibt nur noch ptr statt etwa i32*. Diese sogenannten Opaque Pointers sind seit LLVM 15 Standard. Ältere Tutorials und Codebeispiele, die noch typisierte Zeiger verwenden, lassen sich mit aktuellen Versionen nicht mehr ohne Anpassung übersetzen.

Wie eine Sprache IR erzeugt: ein kleines Beispiel

Wer eine eigene Sprache baut, schreibt die IR nicht als Text, sondern erzeugt sie über die C++-Programmierschnittstelle von LLVM. Das zentrale Werkzeug ist der IRBuilder, der Befehle an der aktuellen Position einfügt. Angenommen, eine kleine Fachsprache für Preisregeln soll aus einem Bruttopreis und einem Steuersatz den Nettopreis berechnen. Der Generator dafür könnte so aussehen:

#include <memory>

#include <llvm/IR/IRBuilder.h>
#include <llvm/IR/LLVMContext.h>
#include <llvm/IR/Module.h>
#include <llvm/IR/Verifier.h>
#include <llvm/Support/raw_ostream.h>

int main() {
  llvm::LLVMContext context;
  auto module = std::make_unique<llvm::Module>("preisregeln", context);
  llvm::IRBuilder<> builder(context);

  // Signatur: double netto(double brutto, double satz)
  llvm::Type *dbl = builder.getDoubleTy();
  auto *fnType = llvm::FunctionType::get(dbl, {dbl, dbl}, /*isVarArg=*/false);
  auto *fn = llvm::Function::Create(fnType, llvm::Function::ExternalLinkage,
                                    "netto", module.get());

  llvm::Value *brutto = fn->getArg(0);
  llvm::Value *satz = fn->getArg(1);
  brutto->setName("brutto");
  satz->setName("satz");

  // Rumpf: brutto / (1.0 + satz)
  auto *entry = llvm::BasicBlock::Create(context, "entry", fn);
  builder.SetInsertPoint(entry);
  llvm::Value *eins = llvm::ConstantFP::get(dbl, 1.0);
  llvm::Value *divisor = builder.CreateFAdd(eins, satz, "divisor");
  llvm::Value *ergebnis = builder.CreateFDiv(brutto, divisor, "ergebnis");
  builder.CreateRet(ergebnis);

  // Die Prüfung meldet strukturelle Fehler, bevor sie später Ärger machen
  if (llvm::verifyFunction(*fn, &llvm::errs())) {
    return 1;
  }

  module->print(llvm::outs(), nullptr);
  return 0;
}

Übersetzt wird das Programm gegen die installierten LLVM-Bibliotheken. Das Hilfsprogramm llvm-config liefert die passenden Compiler- und Linker-Optionen:

clang++ generator.cpp $(llvm-config --cxxflags --ldflags --libs core) -o generator
./generator

Die Ausgabe ist gültige IR, die sich direkt an opt und llc weiterreichen lässt:

; ModuleID = 'preisregeln'
source_filename = "preisregeln"

define double @netto(double %brutto, double %satz) {
entry:
  %divisor = fadd double 1.000000e+00, %satz
  %ergebnis = fdiv double %brutto, %divisor
  ret double %ergebnis
}

Für eine echte Sprache kommt natürlich mehr dazu: Variablen, Verzweigungen, Schleifen und Funktionsaufrufe. Das Prinzip bleibt aber gleich. Jeder Knoten im Syntaxbaum erzeugt über den IRBuilder die passenden Befehle, und LLVM übernimmt den Rest bis zur ausführbaren Datei.

Der Weg zur eigenen Sprache: was LLVM abnimmt und was nicht

Die Arbeitsteilung ist klar verteilt. Vor dem Codegenerator stehen zwei Bausteine, die jedes Sprachprojekt selbst schreiben muss. Der Lexer zerlegt den Quelltext in Tokens, also in Schlüsselwörter, Namen, Zahlen und Operatoren. Der Parser setzt diese Tokens nach den Regeln der Grammatik zu einem abstrakten Syntaxbaum (AST) zusammen, einer Baumstruktur, die zeigt, welcher Ausdruck zu welchem gehört. Danach folgen Namensauflösung und Typprüfung. Diese Schritte machen den Charakter einer Sprache aus, und LLVM hilft dabei nicht.

Ein Lexer muss dabei nicht kompliziert sein. Die folgende Skizze in C++20 erkennt Zahlen, Namen und einzelne Operatorzeichen:

#include <cctype>
#include <string>
#include <string_view>
#include <vector>

enum class TokenArt { Zahl, Name, Operator };

struct Token {
  TokenArt art;
  std::string text;
};

std::vector<Token> zerlege(std::string_view quelle) {
  std::vector<Token> tokens;
  std::size_t i = 0;
  while (i < quelle.size()) {
    const unsigned char c = quelle[i];
    if (std::isspace(c)) {
      ++i;
    } else if (std::isdigit(c)) {
      const std::size_t start = i;
      while (i < quelle.size() &&
             (std::isdigit(static_cast<unsigned char>(quelle[i])) || quelle[i] == '.')) {
        ++i;
      }
      tokens.push_back({TokenArt::Zahl, std::string(quelle.substr(start, i - start))});
    } else if (std::isalpha(c)) {
      const std::size_t start = i;
      while (i < quelle.size() && std::isalnum(static_cast<unsigned char>(quelle[i]))) {
        ++i;
      }
      tokens.push_back({TokenArt::Name, std::string(quelle.substr(start, i - start))});
    } else {
      tokens.push_back({TokenArt::Operator, std::string(1, quelle[i])});
      ++i;
    }
  }
  return tokens;
}

Nach dem Codegenerator übernimmt LLVM: Optimierung, Registerverteilung, Befehlsauswahl für die Zielarchitektur und, zusammen mit LLD, das Linken. Zusätzlich bekommt eine neue Sprache Debug-Informationen im Standardformat DWARF, sodass gängige Debugger mit ihr umgehen können. Für interaktive Umgebungen gibt es mit ORC eine Schnittstelle für Just-in-Time-Kompilierung, bei der Code erst zur Laufzeit übersetzt wird. Julia nutzt dieses Prinzip, um numerischen Code beim ersten Aufruf auf die tatsächlichen Datentypen zuzuschneiden.

Der beste Einstieg ist das offizielle Tutorial „Kaleidoscope“ in der LLVM-Dokumentation unter llvm.org/docs/tutorial. Es baut in mehreren Kapiteln eine kleine Sprache mit Lexer, Parser, Codegenerator und JIT auf und wird mit den Versionen gepflegt. Das ist wichtig, denn die C++-Schnittstelle von LLVM gilt ausdrücklich nicht als stabil. Mit jeder Hauptversion können sich Funktionsnamen und Signaturen ändern. Beispiele aus Blogartikeln, die einige Jahre alt sind, kompilieren deshalb häufig nicht mehr. Ein bekanntes Beispiel ist der alte Pass-Manager für Optimierungen, der zugunsten eines neuen Systems entfernt wurde.

Wer LLVM heute nutzt und welche Alternativen es gibt

Die Liste der Sprachen mit LLVM-Unterbau ist lang. Neben Clang für C und C++ gehören Rust, Swift, Julia und Kotlin/Native dazu. Emscripten übersetzt C- und C++-Code über LLVM nach WebAssembly, sodass etwa Bild- oder Videoverarbeitung im Browser laufen kann. Hersteller von Grafikkarten und KI-Beschleunigern nutzen LLVM-Backends für ihre Chips. Auch die Werkzeugketten für Android und für Apple-Plattformen setzen auf Clang. Wie Rust diese Infrastruktur für sichere Systemprogrammierung nutzt, beschreibt unser Beitrag über Rust als Sprache für sichere und schnelle Systeme. Wie C++-Code über LLVM in den Browser gelangt, zeigt der Beitrag zu WebAssembly und JavaScript-Performance.

LLVM ist trotzdem nicht konkurrenzlos. Die GNU Compiler Collection (GCC) bleibt in der Linux-Welt verbreitet und erzeugt bei manchen Programmen schnelleren Code. Microsoft liefert für Windows weiterhin einen eigenen C++-Compiler aus. Einige jüngere Sprachen wollen sich bewusst unabhängiger von LLVM machen: Go hatte schon immer einen eigenen Compiler, Zig arbeitet an eigenen Backends für schnellere Debug-Builds, und für Rust gibt es mit Cranelift ein alternatives Backend, das auf kurze Übersetzungszeiten statt auf maximale Optimierung zielt. Der Hintergrund ist eine bekannte Schwäche von LLVM: Gründliche Optimierung kostet Zeit, und große Projekte warten mitunter lange auf ihre Builds. Mehr zu Zig steht in unserem Beitrag über die Programmiersprache Zig.

Was das für Unternehmen und Entwicklungsteams bedeutet

Für die allermeisten Teams ist LLVM kein Werkzeug, das sie direkt anfassen, sondern eine Grundlage, auf der ihre Sprachen stehen. Trotzdem lohnt es sich, die Architektur zu verstehen. Wer weiß, was zwischen Quelltext und Binärdatei passiert, versteht Fehlermeldungen besser, kann Optimierungsstufen bewusst wählen und Werkzeuge wie die Sanitizer oder clang-tidy gezielt in die Build-Pipeline einbauen. Gerade bei bestehendem C- und C++-Code fängt ein AddressSanitizer im Testlauf Speicherfehler ab, die sonst erst in der Produktion auffallen würden.

Eine eigene Programmiersprache zu entwickeln, ist dagegen selten wirtschaftlich. Der Compiler ist nur ein Teil: Eine Sprache braucht Dokumentation, Editor-Unterstützung, Bibliotheken und Menschen, die sie beherrschen. Sinnvoll ist LLVM für Fachsprachen, die sehr schnell rechnen müssen, etwa für Simulationen, Regelwerke mit Millionen Auswertungen oder Datenpipelines. Auch wer Hardware entwickelt, kommt um ein eigenes Backend kaum herum. Für Konfigurations- oder Abfragesprachen in Fachanwendungen reicht dagegen meist ein Interpreter, der sich in einem Bruchteil der Zeit bauen lässt.

Unsere Einschätzung: Für Entwickler:innen ist LLVM eines der lehrreichsten Open-Source-Projekte überhaupt, und ein Wochenende mit dem Kaleidoscope-Tutorial schärft das Verständnis für jede Sprache, die man täglich benutzt. Für Unternehmen zählt vor allem die indirekte Wirkung: Sprachen wie Rust und Swift sind auch deshalb so schnell erwachsen geworden, weil sie nicht bei null anfangen mussten. Wenn Sie überlegen, Teile einer C- oder C++-Codebasis auf Rust umzustellen, unterstützen wir Sie mit Beratung und Seminaren zur Rust-Entwicklung.

Häufige Fragen zu LLVM

Muss LLVM separat installiert sein, um Rust oder Swift zu verwenden?

Nein, nicht als separate Installation. Die Compiler bringen ihre eigene, passende LLVM-Version mit. Eine eigene LLVM-Installation brauchen Sie nur, wenn Sie direkt mit Clang arbeiten oder selbst Werkzeuge auf Basis der LLVM-Bibliotheken entwickeln.

Ist Clang ein vollständiger Ersatz für GCC?

Für die meisten C- und C++-Projekte ja. Clang unterstützt die aktuellen Sprachstandards weitgehend und ist zu vielen GCC-Optionen kompatibel. Unterschiede gibt es bei einigen GCC-spezifischen Erweiterungen und bei der Leistung des erzeugten Codes, die je nach Programm in die eine oder andere Richtung ausfällt. Ein Vergleich mit der eigenen Codebasis ist aussagekräftiger als jeder allgemeine Benchmark.

Wie aufwendig ist eine eigene kleine Sprache mit LLVM?

Ein Prototyp mit Zahlen, Funktionen und Verzweigungen ist nach dem Kaleidoscope-Tutorial in einigen Tagen machbar, wenn solide C++-Kenntnisse vorhanden sind. Eine Sprache für den produktiven Einsatz mit Fehlermeldungen, Standardbibliothek und Werkzeugen ist dagegen ein Projekt über Monate oder Jahre.

Lässt sich LLVM auch aus anderen Sprachen als C++ ansteuern?

Ja. LLVM bietet eine C-Schnittstelle, die stabiler ist als die C++-API. Darauf bauen Anbindungen für Python, Rust, OCaml und andere Sprachen auf. Für Experimente mit Python ist etwa die Bibliothek llvmlite verbreitet, die auch der Numba-Compiler verwendet.

Schlagworte

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

React 18 in der Praxis: Was beim Umstieg wirklich zählte

Rückblick auf den Umstieg auf React 18 im Mai 2022: was sich mit createRoot, Strict Mode und Batching änderte und wann Transitions und Suspense halfen.

mehr erfahren

Julia: Die Zukunft der wissenschaftlichen Programmierung?

Julia verbindet die Bequemlichkeit von Python mit der Geschwindigkeit von C. Wie die Sprache funktioniert und wann sie sich für Ihre Projekte lohnt.

mehr erfahren

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

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.

mehr erfahren

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

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: