Zurück

Bun ist nicht das schnellere Node.js. Es ist eine andere Plattform.

Wie mir Bun 1.4 während des Schreibens den Artikel kaputtmachte – und er damit erst richtig interessant wurde.

Seit Anfang Juli hatte ich ein Problem mit Bun. Eines von der angenehmen Sorte: reproduzierbar, technisch interessant und gerade groß genug, dass man es nicht mit einem Schulterzucken unter „wird schon irgendein Cache sein“ abheften konnte.

Mein eigener Markdown-Parser Markanto trat gegen marked an.

Unter Node.js: ungefähr Faktor 1,8. Schön.
Unter Bun: ungefähr Faktor 50. Sehr schön.

Verdächtig schön.

Natürlich dauerte es einen Moment, bis der innere Entwicklerstolz die Bühne räumte. Mein Parser war schließlich nicht über Nacht zum Ferrari geworden. Also andersherum gefragt:

Was, wenn Markanto unter Bun gar nicht so absurd schnell ist – sondern marked absurd langsam?

Das war die bessere Frage. Sie führte ziemlich schnurstracks zu regulären Ausdrücken, JavaScriptCore und einer Performance-Schwäche, die nicht erst gestern vom Himmel gefallen war. Gut zwei Monate lang hat mich das beschäftigt. Ich sammelte alte Issues, verglich V8 mit JavaScriptCore, stolperte nebenbei über Temporal und hatte irgendwann eine ziemlich runde These:

Bun ist nicht das schnellere Node.js. Es ist eine andere Plattform.

Anfang September wollte ich nur noch die Zahlen sauber nachmessen. Kein „bei mir war das ungefähr fünfzigmal schneller“, sondern Fixture, feste Versionen, Warm-up, mehrere Prozesse, Rohdaten, Profile.

Also alles vorbereitet, Bun 1.4 installiert, Benchmark gestartet.

Und der Artikel war kaputt.

marked war plötzlich nicht mehr absurd langsam. Der Regex-Ausreißer, der mich seit Wochen beschäftigt hatte? Weg.

Na prima.

Aus 171 Millisekunden werden 4

Der Vergleich ist ziemlich hübsch, weil sich rundherum erstaunlich wenig bewegt.

Test Node 24.18 Bun 1.3.14 Node 26.8 Bun 1.4.0
Markanto Parse 1,98 ms 1,64 ms 1,92 ms 2,00 ms
marked.lexer() 1,86 ms 171,17 ms 1,82 ms 4,02 ms
RegExp-Reproducer¹ 30,60 ms 8.037,63 ms 27,86 ms 28,31 ms

Gemessen am 2. September 2026 auf demselben Rechner, Median aus fünf unabhängigen Prozessen. ¹ Der historische isbot-Fall von 2023, hier als begrenzter Lauf über 50.000 Zeilen.

Markanto bleibt ungefähr Markanto, Node bleibt ungefähr Node. Und marked unter Bun fällt von 171 Millisekunden auf 4. Beim historischen RegExp-Reproducer wird es noch etwas unhöflicher: Aus acht Sekunden werden 28 Millisekunden. So viel zum gemütlichen Artikel über Buns Regex-Schwäche.

Zwischen „hier stimmt etwas fundamental nicht“ und „ungefähr auf Augenhöhe“ liegt in diesem Fall: ein Runtime-Update.

Nebenbei hat der saubere Aufbau auch meine Ausgangszahlen zurechtgerückt. Unter Node liegen Markanto und der marked-Lexer praktisch gleichauf, von Faktor 1,8 bleibt nichts übrig. Unter Bun 1.3 trennt die beiden dafür nicht Faktor 50, sondern gut Faktor 100. Meine Juli-Zahlen waren eben genau das: „bei mir ungefähr“.

Mein 50×-Benchmark war also durchaus real. Er beantwortete nur eine andere Frage, als ich dachte: nicht, warum Markanto unter Bun so schnell ist, sondern warum marked unter Bun 1.3 so langsam ist. Kleine Verschiebung. Völlig anderer Artikel.

Was gemessen wurde: vier reale Dokumente von teblo.de als gemeinsames Fixture, 56.448 Byte, geparst mit marked 18.0.11 und Markanto 0.1.0 auf einem Intel Core i7-12700H unter WSL2. Jede Variante lief mit Warm-up, sieben Runden und fünf unabhängigen Prozessen, Node und Bun verschränkt. Das ist ausdrücklich kein Wettbewerb identischer Operationen – marked.lexer() erzeugt Tokens, Markanto einen semantischen AST samt Diagnostik. Interessant ist nicht, wer gewinnt, sondern was mit demselben Code beim Wechsel der Runtime passiert. Fixture, Rohdaten, Profile und Skripte stecken im Evidenzpaket am Ende des Artikels.

Das Problem war real. Und es war hartnäckig.

Man könnte nun denken: Na gut, ein kleiner Performance-Bug in Bun 1.3. Passiert.

Nein. Der erste einschlägige marked-Fall wurde bereits im Juni 2023 gemeldet: rund 1,5 Sekunden unter Bun 0.6.11, etwa 70 Millisekunden unter Node.js – gemessen übrigens ebenfalls unter WSL2. Wenige Monate später folgte ein noch groteskerer Fall. Ein Regex aus isbot benötigte unter Node ungefähr 200 Millisekunden. Unter Bun:

65 Sekunden.

Faktor 300 und ein bisschen Kleingeld. Solche Zahlen sind normalerweise der Punkt, an dem Benchmarkdiskussionen anfangen, leicht nach verbranntem Plastik zu riechen.

Nur ließ sich der Effekt reproduzieren – sogar noch 2026 mit Bun 1.3.14. Auf meinem Rechner braucht der vollständige historische Reproducer mit Node 24 rund 199 Millisekunden, mit Bun 1.3.14 mehr als 55 Sekunden. Faktor 278. Keine 0.x-Kinderkrankheit also, sondern eine Eigenheit, die Bun über drei Jahre begleitet hat.

Die Spur führt eine Schicht tiefer

Node.js verwendet V8 und dessen RegExp-Engine Irregexp. Bun verwendet JavaScriptCore, kurz JSC, die JavaScript-Engine aus WebKit. Dort steckt Yarr.

Beim Profiling meines Bun-1.3-Laufs landeten 97,6 Prozent der Samples in nativen RegExp-Frames, unter Node 24 waren es 57,2 Prozent. Das allein ist noch kein gerichtsfester Beweis für eine einzelne Ursache. Die Release Notes von Bun 1.4 werden dann allerdings deutlich: Die Performance-Lücke zwischen JavaScriptCore und V8 bei regulären Ausdrücken sei behoben, marked.parse() laufe 138-mal, isbot 200-mal schneller. Zwischen Bun 1.3 und 1.4 wurde der WebKit-Stand 39-mal angehoben – laut Bun ungefähr acht Monate Upstream-Arbeit an JavaScriptCore.

Wo diese Arbeit stattfand, lässt sich im WebKit-Bugtracker nachlesen. Ende Juni 2023, parallel zum Bun-Issue, hatte Bun-Gründer Jarred Sumner dort einen Bug eröffnet: „JS markdown parser performs 50x slower in JSC compared to V8, likely due to regex“.

Faktor 50. Kam mir bekannt vor.

WebKit-Entwickler Michael Saboff fand damals zwei Konstrukte, die Yarr nicht JIT-kompilieren konnte. Das erste, Backreferences mit ignore case, bekam schon im März 2024 JIT-Unterstützung. Das zweite steckte gleich in mehreren marked-Mustern: gezählte Gruppen mit einer Mindestanzahl, etwa (?:\*[ \t]*){3,}. Die Unterstützung dafür baute Yusuke Suzuki in den Yarr-JIT ein. Sie landete am 2. Juni 2026 im WebKit-Hauptzweig. Am 11. und 12. August schloss Jarred Sumner die beiden Bun-Issues mit einem knappen „Fixed in Bun v1.4“, am 20. August erschien Bun 1.4.

Zeitleiste mit zwei Spalten, WebKit und Bun. Juni 2023: WebKit-Bug 258706 und Bun-Issue 3464 zu marked. September 2023: Bun-Issue 5197 zu isbot. März 2024: erster Teil-Fix in WebKit. Februar 2026: WebKit-Bug 307145. 2. Juni 2026: der Fix landet in WebKit. Elf Wochen später, am 20. August 2026, erscheint Bun 1.4. Daneben als Nebenstrang Temporal: Issue im Dezember 2024, Aktivierung im August 2026
Der Fix entstand in WebKit – bei Bun-Nutzern kam er elf Wochen später an

Ob genau dieser Commit den Unterschied macht, habe ich nicht isoliert. Er passt aber verdächtig gut ins Bild. Und er zeigt, wo der Fix entstehen musste: nicht im Bun-Repository, sondern eine Schicht darunter.

Warum ein Update 171 Millisekunden in 4 verwandeln kann

Bun ist weitgehend Node-kompatibel. Aber Bun ist nicht Node mit Sportauspuff. Node.js läuft auf V8, Bun auf JavaScriptCore – und darüber baut Bun eine bemerkenswert große eigene Welt.

Zwei Spalten. Node.js: separate Werkzeuge npm, tsc, Bundler und Test Runner, darunter der Node.js-Core, ganz unten die Engine V8 mit JIT, Garbage Collection, Irregexp und Temporal. Bun: eine große eigene Schicht mit Package Manager, Bundler, Test Runner, TypeScript-Ausführung, Runtime-APIs und I/O, darunter JavaScriptCore aus WebKit mit JIT, Garbage Collection, Yarr und Temporal. Die JavaScriptCore-Schicht ist hervorgehoben: Hier lag der Regex-Ausreißer, und hier musste der Fix entstehen
Was Bun selbst baut – und was es von JavaScriptCore erbt

In der Bun-eigenen Schicht kann das Projekt selbst gestalten: bun install, Bundler, Test Runner, Startverhalten, viele I/O-Pfade. Die geerbte Engine-Schicht – Sprachfeatures, JIT, Garbage Collection, RegExp – kann Bun patchen, aktualisieren und upstream verbessern. Zur Bun-eigenen Engine wird JavaScriptCore dadurch nicht. Genau deshalb kann ein Update acht Monate Engine-Entwicklung auf einmal mitbringen. Und deshalb kann aus 171 Millisekunden eben 4 werden, obwohl marked dasselbe marked geblieben ist.

Der naheliegende Einwand: Node.js baut doch genauso auf einer fremden Engine auf. Stimmt. Auch Node bestimmt nicht allein über V8. Der Unterschied liegt nicht in „Kontrolle“ gegen „keine Kontrolle“, sondern darin, welche Teile der Plattform das jeweilige Projekt selbst baut und welche Eigenschaften es von seiner Engine erbt. Bei Bun ist die eigene Schicht ungewöhnlich groß. Und die Engine darunter ist eine andere als die, unter der der Großteil des npm-Ökosystems entsteht und getestet wird.

Für diesen Artikel hatte ich noch ein zweites schönes Beispiel vorbereitet: Temporal, die seit gefühlten Erdzeitaltern erwartete Datums-API. Node.js 26 hatte sie im Mai 2026 standardmäßig aktiviert. Bei Bun war das Feature-Issue seit Dezember 2024 offen und als JavaScriptCore-Thema markiert – Bun musste warten, bis die JSC-Implementierung weit genug war. Sehr schönes Beispiel für meine These.

Dachte ich.

Am 5. August wurde in Bun „Enable Temporal by default“ gemergt. Regex war weg. Temporal jetzt auch. Bun 1.4 ging meinen Artikel offenbar systematisch durch. Der Mechanismus bleibt allerdings derselbe: Bun musste Temporal nicht selbst bauen, sondern freischalten, was JavaScriptCore inzwischen konnte – im Kern vollständig, bei einigen nicht-ISO-Kalendern mit bekannten Upstream-Lücken. Das ist der Sinn einer Engine. Es bedeutet aber auch, dass manche Dinge an einem Takt hängen, den Bun nicht allein bestimmt.

Das ist keine Schwäche dieses Modells. Es ist eine Eigenschaft. Man sollte nur wissen, dass sie existiert.

Das Verfallsdatum von Benchmarks

Das Gemeine an meinem alten Benchmark war: Er war richtig. 2023 stimmte er. Im Sommer 2026 stimmte er mit Bun 1.3 immer noch. Seit dem 20. August stimmt er nicht mehr.

So schnell kann aus einer belastbaren technischen Aussage Folklore werden. Irgendwo steht eine spektakuläre Zahl, jemand zitiert sie, der Nächste zitiert denjenigen, der sie zitiert hat. Zwei Jahre später erscheint dann ein Artikel mit einem Titel wie „Bun vs. Node.js 2026 – The Ultimate Performance Comparison“. Natürlich mit 2026 im Titel. Man will ja aktuell wirken.

Das funktioniert in beide Richtungen. Wenn Bun in einem HTTP-Hello-World-Test doppelt so viele Requests pro Sekunde schafft wie Node, dann wissen wir genau das. Mehr erst einmal nicht. Meine Anwendung wird dadurch nicht doppelt so schnell, mein ORM bekommt keine Flügel, und PostgreSQL dürfte die Nachricht mit professioneller Gleichgültigkeit zur Kenntnis nehmen.

Benchmarks sind deshalb nicht nutzlos. Man sollte ihnen nur gelegentlich zwei unhöfliche Fragen stellen:

Was genau hast du eigentlich gemessen? Und mit welcher Version?

Bun auf der Werkbank, Node im Maschinenraum

Nach all dem könnte man einen hübschen Verriss schreiben. Wäre nur leider ebenfalls falsch. Bun ist an vielen Stellen richtig gut – vor allem dort, wo es selbst das Spielfeld baut. bun install ist schnell genug, dass man den Unterschied nicht in einer Tabelle suchen muss. Kleine TypeScript-Tools starten ohne Build-Gedöns, Test Runner, Package Manager und Bundler kommen aus einer Hand. Buns größte Stärke ist für mich deshalb gar nicht, dass es JavaScript schneller ausführt. Sondern dass vieles, was ich als Entwickler ständig tue, schnell und erfreulich direkt funktioniert.

Daraus ist bei mir eine Faustregel geworden, absichtlich etwas zu grob:

Bun auf der Werkbank. Node im Maschinenraum.

Auf der Werkbank – CLI-Tools, Generatoren, Build-Skripte, Tests, CI – will ich Tempo und nicht erst einen kleinen Familienrat aus tsc, Loader, Runner und drei Konfigurationsdateien einberufen. Auch der Static Site Generator, der diese Seite baut, läuft unter Bun.

Im Maschinenraum werde ich konservativer. Ein Backend-Service, der jahrelang laufen und viele fremde Dependencies einbinden soll, ist eine andere Kategorie. Da hat Node einen Vorteil, der in Benchmarks schlecht aussieht:

Es ist langweilig.

Und langweilig ist bei Infrastruktur ziemlich luxuriös: ein LTS-Modell, das npm-Ökosystem zu Hause, die seltsamen Ecken seit Jahren bekannt, betreten, beschimpft und repariert. Bun holt schnell auf, und seit der Übernahme durch Anthropic im Dezember 2025 ist zumindest die Frage nach der Finanzierung entschärft. An der Engine-Frage ändert das nichts.

Bei einem langlebigen Dienst würde ich deshalb zuerst fragen: Was kaufe ich mir dafür ein, Node LTS zu verlassen? Lautet die Antwort „mehr Requests im Hello-World-Benchmark“, bleibe ich bei Node. Lautet sie „dieser Worker startet hunderttausendfach, und Bun spart uns messbar Geld“, dann reden wir. Und dann messen wir – mit unserem Code, nicht mit einem Balkendiagramm aus dem Internet.

Das ist keine Regel, sondern meine derzeitige Risikoverteilung. Wie langlebig solche Gewissheiten sind, hat dieser Artikel ja gerade gezeigt.

Der Artikel, der sein eigenes Gegenbeispiel bekam

Eigentlich wollte ich erklären, warum Bun bei regulären Ausdrücken so merkwürdig langsam ist. Schlechter Zeitpunkt für diesen Artikel. Ziemlich guter Zeitpunkt für den, der daraus geworden ist.

Die alte These – „Bun ist bei Regex langsam“ – ist weg. Gut so. Die eigentliche steht noch: Bun ist nicht das schnellere Node.js, sondern eine eigene Plattform auf einer anderen Engine. Wo Bun selbst gestaltet, spielt es seine Stärken ziemlich kompromisslos aus. Wo JavaScriptCore darunterliegt, erbt es dessen Grenzen – und gelegentlich acht Monate Fortschritt auf einen Schlag.

Die bessere Frage lautet deshalb nicht „Ist Bun schneller als Node?“, sondern:

Was genau soll bei meinem Programm schneller sein – und wer baut eigentlich die Schicht, in der diese Arbeit passiert?

Mein 50×-Benchmark ist weg. Der interessantere Teil hat überlebt.


Zum Nachmessen

Das Evidenzpaket enthält Fixture, das gepinnte Markanto-Paket, Rohdaten, CPU-Profile und Reproduktionsskripte. Die 33 MB große Datenbasis des historischen Reproducers liegt wegen ungeklärter Lizenz nicht bei; ein separates Skript lädt sie vom ursprünglichen Commit und prüft sie vor der Ausführung.

Evidenzpaket zum Benchmark herunterladen (ZIP)
SHA-256: a522366f95d0126249a297496d51b314b6bd9abe04148c30603f295054f60d41

Quellen

Die beiden Grafiken habe ich mit KI-Unterstützung per Skript erzeugt; alle Daten darin stammen aus den genannten Quellen und der eigenen Messung.

Kommentar schreiben