Fundierte Artikel über Technologien, die das Kommende formen.

CAD-Kernel im Browser mit Rust und WebGPU bauen

Lehren aus KetchUp: Wie Rust und WebGPU einen echten CAD-Kernel im Browser realistisch machen – und welche Fehler frühere Ansätze scheitern ließen.

Eine Werkbank aus Holz, halb echtes Holz und halb leuchtendes Drahtgittermodell, diagonal geteilt.
BenchUp richtet sich zuerst an Holzwerker – an Leute, die ein Regal modellieren wollen, bevor sie es zuschneiden.

Diese Woche ist still und leise etwas Bemerkenswertes passiert: Ein CAD-Kernel im Browser ist kein Witz mehr. KetchUp – inzwischen in BenchUp umbenannt, vermutlich damit die Markenanwälte von Trimble beschäftigt bleiben – ist ein Open-Source-Modeler im Stil von SketchUp, geschrieben in Rust, mit WebGPU gerendert, und er läuft in einem ganz normalen Browser-Tab mit einer Geschwindigkeit und Politur, bei der langjährige SketchUp-Nutzer hörbar neidisch werden. Kein Konto. Keine Cloud. Eine .ketchup-Datei landet direkt auf der Festplatte, und das Ganze steht unter der MIT-Lizenz.

Ich beobachte seit zwei Jahrzehnten Versuche, „CAD im Web“ zu bauen, und fast jeder ist auf dieselbe Weise gescheitert: falsche Laufzeit, falsche Rendering-API, falsche Vorstellung davon, was der schwierige Teil ist. Dieses Projekt trifft genug der richtigen Entscheidungen, dass es sich als Fallstudie lohnt. Also hier die Nachbetrachtung gewissermaßen rückwärts – die Fehler, an denen frühere Browser-Modeler gescheitert sind, und die konkreten Lösungen, durch die sich dieser hier wie eine native App anfühlt.

Lektion 1: Der Browser war nie der Engpass – die Laufzeit schon

Jedes gescheiterte Web-CAD-Projekt, das mir einfällt, hat denselben ersten Schritt gemacht: Sie haben die Geometrie-Engine in JavaScript geschrieben, sind gegen eine Wand gelaufen und kamen zu dem Schluss, dass der Browser das nicht kann. Dieser Schluss war falsch. Der Browser war in Ordnung. Das Problem war die Laufzeit.

Überlegen wir, was interaktives Modellieren eigentlich verlangt. Du ziehst eine Fläche mit Push/Pull, und bei jeder Mausbewegung werden die betroffenen Flächen neu berechnet, Kanten erkannt, jeder nahe Eckpunkt auf Einrastung geprüft und die Vertex-Buffer neu hochgeladen – sechzigmal pro Sekunde. In JavaScript bestimmt der Garbage Collector dein Frame-Budget. Es ist ihm egal, dass du gerade mitten in einem Ziehvorgang bist. Ein paar Millisekunden Aufräumarbeit zum falschen Zeitpunkt wirken für den Nutzer wie Lag, und Lag in einem Modellierwerkzeug ist keine Kleinigkeit; er zerstört die gedankliche Verbindung zwischen Hand und Form. Deshalb fühlte sich die Web-Version von SketchUp laut ihren eigenen Nutzern immer „langsamer und weniger leistungsfähig“ an als die Desktop-Version.

Rust, kompiliert nach WebAssembly, beseitigt diese ganze Fehlerklasse. Du bekommst linearen Speicher, den du selbst kontrollierst, ein deterministisches Layout für deine Geometrie-Buffer und keinen Collector, der zwischen den Frames lauert. Entscheidend: Wasm ist nicht magisch schneller bei allem – wir haben schon einmal darüber geschrieben, dass WebAssembly bei stringlastiger, DOM-naher Arbeit oft gegen gut optimiertes JavaScript verliert. Ein Geometriekern ist aber die Gegenlast: enge Schleifen über große flache Arrays aus f32. Genau dort gewinnt vorhersagbare Speichernutzung, und dort kämpft das Objektmodell von JS am stärksten gegen dich.

Die Lösung ist also nicht, „den Browser schneller zu machen“. Sondern: aufhören, eine Geometrie-Engine auf einer Laufzeit laufen zu lassen, die für Dokumente gebaut wurde. Der Browser ist nur das Auslieferungsmedium. Was darin läuft, darf Systemcode sein.

Lektion 2: WebGPU vs. WebGL für CAD-Rendering – wissen, was man kauft

Der zweite Fehler ist subtiler: Man nimmt an, WebGL reiche aus, weil ein Modeler „nur aus Dreiecken besteht“. Schattierte Dreiecke zu zeichnen ist tatsächlich der leichte Teil. Alles drumherum ist dort, wo WebGL weh tut.

Ein wenig Geschichte, denn sie erklärt die API. WebGL ist ein direkter Nachfahre von OpenGL, das wiederum direkt von SGIs IRIS GL abstammt – einer Zustandsmaschine aus den späten Achtzigern für Hardware, die es längst nicht mehr gibt. Du programmierst sie, indem du globalen Kontextzustand veränderst und hoffst, vor jedem Draw-Call die richtigen Schalter gesetzt zu haben. Für 1992 war das eine ordentliche Abstraktion. Für ein CAD-Viewport brauchst du ständig Dinge, mit denen sie sich schwertut: GPU-seitiges Picking (welche Fläche liegt unter dem Cursor?), Tessellierung von Flächen mit Löchern, Berechnung von Kantenlinienbreiten im Bildschirmraum, Buffer, die sich jedes Frame ändern. All das geht auch mit WebGL2, aber du schraubst compute-artige Arbeit an eine API ohne Compute-Shader und mit überall impliziter Synchronisation.

WebGPU korrigiert das Modell, nicht nur die Geschwindigkeit. Explizite Pipelines statt versteckten globalen Zustands. Storage-Buffer und Compute-Shader, damit Tessellierung und Picking dort laufen können, wo die Daten bereits liegen. Ein Fehlermodell, das dir sagt, was du falsch gemacht hast, statt stillschweigend abzustürzen. Und – das ist der strategisch wichtige Teil – das Rust-Crate wgpu implementiert dieselbe API auf Vulkan, Metal und Direct3D. Schreibst du deinen Renderer einmal gegen wgpu, kompiliert er im Browser zu WebGPU und auf dem Desktop zu nativer Grafik. Diese eine Entscheidung ist der Grund, warum BenchUp Windows-, macOS-, Linux- und Browser-Builds aus einem einzigen Repository ausliefern kann.

Die ehrliche Einschränkung: WebGPU ist nicht überall verfügbar, und ein ernsthaftes Tool braucht einen WebGL2-Fallback – BenchUp verlangt eines von beiden. Aber zuerst für WebGPU zu bauen und dann sauber abzustufen, ist die richtige Reihenfolge. Die umgekehrte Reihenfolge führt dazu, dass man architektonisch im Jahr 1992 festsitzt.

Lektion 3: Der Geometriekern ist nicht der schwierige Teil – die Inferenz schon

Der Fehler, der mich am meisten interessiert, ist einer der Priorisierung, nicht der Technik. Wenn Entwickler einen Modeler nachbauen wollen, fangen sie fast immer beim Geometriekern an: Boundary Representations, Euler-Operatoren, Robustheit bei Booleschen Operationen. Das ist der anspruchsvollste intellektuelle Teil, also muss er zuerst kommen. Oder?

Falsch, und die Geschichte zeigt warum. Volumenmodellierungskerne sind ein gelöstes, kommodisiertes Problem, das Jahrzehnte zurückreicht – BRL-CAD machte Constructive Solid Geometry Ende der Siebziger für die US-Armee, Parasolid und ACIS industrialisierten Boundary Representation in den Achtzigern, und OpenCASCADE ist seit 1999 Open Source. Wäre ein starker Kern das Produkt, hätte einer der vielen OpenCASCADE-basierten Modeler SketchUp längst die Butter vom Brot genommen. Keiner hat das geschafft. Denn SketchUps Genialität lag, als @Last Software es 2000 aus Boulder auslieferte, nicht in der geometrischen Leistung. Sie lag in der Inferenz-Engine: darin, wie der Cursor an Mittelpunkte einrastet, sich an den roten, grünen und blauen Achsen ausrichtet und errät, auf welcher Ebene du gerade zeichnest. Nutzer tippen nie Koordinaten ein. Die Software kommt der Hand dort entgegen, wo sie ist.

SketchUp ist im Kern eine herrlich einfache Flächenmodellierung – Flächen und Kanten, keine Volumenkörper nötig. Push/Pull ist nur das Extrudieren einer Fläche und das Vernähen der Seiten. Die Komplexität steckt in der Interaktionsschicht, und genau dort hat KetchUp offensichtlich seinen Aufwand investiert. Die Einrastlogik sieht ungefähr so aus:

enum Inference {
AtVertex(VertexId),
Midpoint(EdgeId),
OnEdge(EdgeId),
OnAxis(Axis),   // the famous red / green / blue lock
OnFace(FaceId),
None,
}
fn infer(ray: Ray, model: &Model, last_point: Vec3, tol: f32) -> (Vec3, Inference) {
// Priority order matters more than cleverness:
// hard snaps beat soft snaps, every time.
if let Some(v) = model.nearest_vertex(ray, tol) {
return (v.pos, Inference::AtVertex(v.id));
}
if let Some((e, t)) = model.nearest_midpoint(ray, tol) {
return (e.point_at(t), Inference::Midpoint(e.id));
}
if let Some(p) = snap_to_axis(ray, last_point, tol) {
return (p, Inference::OnAxis(p.axis));
}
// Fall through to whatever face or plane the ray hits.
project_onto_surface(ray, model)
}

Mathematisch ist an dieser Funktion nichts tief. Die Tiefe steckt in der Prioritätsreihenfolge, der Toleranzskalierung abhängig vom Zoom und den dreißig Mikroverhalten, die es sich eher hellsichtig statt ruckelig anfühlen lassen. Das sind tausend Stunden Feinabstimmung, nicht tausend Seiten Kerntheorie. Wenn du einen Modeler baust, bau zuerst die Inferenzschicht und halte die Geometrie erschreckend simpel, bis Nutzer mehr verlangen.

Die Inferenz-Engine ist das Produkt. Der Geometriekern ist Rohrleitung. Klone die Rohrleitung zuletzt.

Ein durchscheinender, leuchtender Würfel wird extrudiert, mit roten, grünen und blauen Achsenhilfslinien und einem Einrastpunkt.
Achsensperren und Mittelpunkt-Einrastungen wirken trivial, bis man versucht, sie mühelos wirken zu lassen.

Lektion 4: Baue keine CAD-Oberfläche aus DOM-Knoten

Der vierte Fehler ist der React-typische. Die Standardarchitektur für eine „Web-App mit Canvas“ ist eine DOM-Anwendung, die um ein <canvas>-Element herumgebaut wird: Werkzeugleisten als divs, Panels als Komponenten, Dialoge als Portals. Für eine CRUD-App ist das in Ordnung. Für ein Modellierwerkzeug hast du damit eine Layout-Engine, die Styles ungültig macht und unvorhersehbar umbricht, an die Seite eines Renderers getackert, der jede Mikrosekunde seines Frames braucht. Dann debuggst du, warum der Hover-Zustand deiner Werkzeugleiste beim Orbiting ein Frame verschluckt.

KetchUp geht den umgekehrten Weg: Die gesamte Oberfläche wird auf der GPU gezeichnet, und das DOM reduziert sich auf ein einziges Canvas. Das ist derselbe architektonische Schritt, den GPU-beschleunigte Terminal-Emulatoren gegangen sind – Alacritty und Co. haben aufgehört, das DOM Text Zelle für Zelle rendern zu lassen, und das Fenster stattdessen als Textur behandelt. Wie gut das funktioniert, haben wir bei dem Glyph-Atlas-Ansatz moderner Terminals gesehen. Das Rust-Ökosystem macht es fast kostenlos: Eine Immediate-Mode-GUI wie egui kompiliert nach Wasm, rendert über wgpu und liefert Buttons, Panels und Text ohne einen einzigen DOM-Knoten. Ein Kommentator auf Hacker News, überrascht davon, wie nativ sich das anfühlte, hob ausdrücklich die Textdarstellung hervor. Das ist kein Zufall: Text ist der Bereich, in dem DOM-freie UIs üblicherweise scheitern, und wenn man ihn richtig hinbekommt, ist der Rendering-Stack wirklich solide.

Der Kompromiss ist real, also benennen wir ihn: Immediate-Mode-UIs berechnen das Layout jedes Frame neu, Barrierefreiheits-Werkzeuge setzen ein DOM voraus, und du verzichtest auf alles, was der Browser eingebaut mitbringt. Bei einer Werkzeugoberfläche mit einigen hundert Widgets, die mit 60 fps neu gezeichnet werden, ist der Neuberechnungsaufwand vernachlässigbar. Die Barrierefreiheit ist der Punkt, der dich ehrlich halten sollte – aber es ist eine Kostenstelle, die man abfedern muss, kein Grund, die Reflow-Stürme zurückzuholen.

Lektion 5: Lokal gespeicherte Dateien schlagen Cloud-Lock-in

Jetzt der Fehler, der gar nicht technischer Natur ist. Als Trimble SketchUp 2012 von Google übernahm, nahm das Produkt den bekannten Weg: Die kostenlose Desktop-Version (SketchUp Make) wurde eingestellt, die kostenlose Stufe wurde zur Web-App hinter einem Konto, und unbefristete Lizenzen wurden zugunsten von Abos abgeschafft, die mehrere hundert Dollar pro Jahr kosten. Der Unmut in der Community richtet sich nicht wirklich gegen das Geld – Hobbynutzer sagen immer wieder, sie würden einen fairen Einmalpreis gern zahlen. Es geht um die Bedingungen. Menschen haben Hausmodelle, an denen sie jahrelang gearbeitet haben, gespeichert in einem Format und unter einer Lizenzregelung, die nachträglich beliebig verteuert werden kann. Ein Kommentator betreibt noch immer den kostenlosen Build von 2017 unter WINE, statt den neuen Deal zu akzeptieren. Das ist keine Nostalgie. Das ist eine Geiselverhandlung.

KetchUps Lösung ist fast trotzig altmodisch: Autosave landet im Browserspeicher auf deinem Gerät, File → Save lädt eine portable .ketchup-Projektdatei herunter, SketchUp-.skp-Geometrien werden lokal importiert, und OBJ-Export ist da, wenn du hinaus willst. Es gibt keinen Server. Es gibt kein Konto. Die Dokumentation warnt sogar in klaren Worten, dass das Löschen der Browserdaten deine Autosaves entfernt – der ehrliche Preis lokal gespeicherter Software, offen ausgesprochen.

Das ist der Teil, den ich betonen möchte, weil er die älteste Lektion dieses Textes ist: Das Dateiformat ist die Bindung, und Interoperabilität ist das Brecheisen. Jeder erfolgreiche Herausforderer eines etablierten Werkzeugs hat damit begonnen, die Dateien des Platzhirschs zu lesen. WordPerfect hat nicht wegen seiner Funktionsliste gegen Word verloren, sondern wegen Word-Importfiltern. Der SketchUp-Import ist für KetchUps Verbreitung wichtiger als jedes einzelne Modellierfeature es je sein wird. Dass der OBJ-Export nur Geometrie ohne Materialien enthält, ist ein akzeptabler Schönheitsfehler; er zeigt, dass die Richtung nach außen geht, nicht nach innen.

Lektion 6: In Rust einmal schreiben, nativ und im Web ausführen

Der letzte Fehler ist, „die Web-Version“ als eigenes Produkt zu behandeln. Historisch lief es so: eine native Codebasis in C++ und dazu ein paralleler Web-Ansatz, Jahre hinterher und immer die schwächere Variante. Die Nutzer spürten, welches das eigentliche Produkt war und welches die Demo.

Der Stack, auf dem KetchUp aufsetzt, lässt diese Unterscheidung verschwinden. Rust behandelt Wasm als vollwertiges Zielformat. wgpu spricht im Browser WebGPU und auf dem Desktop Vulkan, Metal und D3D. egui läuft an beiden Orten unverändert. Der Browser-Build und die nativen Builds sind keine Cousins – es ist dasselbe Programm, zweimal kompiliert. Ich kann nicht widerstehen, darauf hinzuweisen, dass dies das Versprechen ist, das Java 1995 gemacht hat und das nun endlich eingelöst wird – von einem Bytecode-Format ohne Garbage Collector und ohne Sprachideologie im Gepäck. WebAssembly ist als Compile-Ziel gerade deshalb erfolgreich, weil es nie versucht hat, eine Plattform zu sein, in der man schreibt. Der Browser ist still und leise zu einem glaubwürdigen Ziel für Code in nativer Qualität geworden – wir haben es bei statisch rekompilierten Konsolenspielen, die in Tabs laufen, gesehen, und CAD ist nur das nächste Genre, das fällt.

Ein drahtgitterartiges 3D-Modell, verbunden durch Lichtfäden mit drei verschiedenen Geräte-Silhouetten.
Eine Rust-Codebasis, kompiliert nach Wasm und zu nativen Binärdateien, ist überall dasselbe Programm.

Es gibt noch eine Feinheit, die es wert ist, bedacht zu werden. Allem Anschein nach wurde dieses Projekt größtenteils mit KI-gestützter Programmierhilfe gebaut – die Community hat das sofort bemerkt, und die Reaktion war überwiegend Achselzucken und Lob. Das passt zu einem Muster, das mehrere Kommentatoren ausdrücklich benannt haben: Wir treten in eine Ära ein, in der das Bauen des eigenen Werkzeugs eine realistische Alternative zum Erlernen des Werkzeugs anderer ist. Eine einzelne motivierte Person kann mit Rust, wgpu und einem KI-Partner nun die Kernabläufe eines Produkts nachbauen, das ein börsennotiertes Unternehmen für mehrere hundert Dollar im Jahr vermietet. Ob dich diese Ära begeistert oder alarmiert, hängt wahrscheinlich davon ab, auf welcher Seite der Rechnung du sitzt.

KetchUp könnte das Projekt sein, das Hobby-Modellierern endlich eine dauerhafte Heimat gibt – oder auch nicht. Es ist jung, der Geometriekern ist simpel, und SketchUp-Hardcore-Nutzer mit riesigen Modellen werden seine Grenzen schnell finden. Aber als Existenzbeweis hat es seinen Zweck bereits erfüllt. Der Browser war nie zu schwach für CAD. Wir haben es nur falsch gebaut: falsche Laufzeit, falsche API, falsche Prioritäten, falsches Geschäftsmodell. Behebt man diese vier Dinge, sieht ein Abo für 300 Dollar im Jahr bald aus wie eine Steuer auf Trägheit.