WebGL erklärt: So funktioniert 3D-Grafik im Browser

Von Shadern bis Three.js: was WebGL leistet, wo es eingesetzt wird und wie sich der Nachfolger WebGPU einordnet
Aktualisiert:
Abstract
- #WebGL
- #WebGPU
- #3D-Grafik
- #Webentwicklung
- #JavaScript
- #Three.js
- #Shader
- #Datenvisualisierung
Warum der Browser heute Grafikkarten direkt ansprechen kann – und wann sich der Aufwand für Unternehmen lohnt
Ein Möbelhändler zeigt im Onlineshop ein Sofa, das sich mit der Maus drehen lässt. Die Kundin wählt einen anderen Bezugsstoff, und das Modell wechselt sofort Farbe und Struktur, samt Faltenwurf und Schatten. Eine App musste sie dafür nicht installieren, ein Plug-in auch nicht. Was dort im Browserfenster läuft, ist in den allermeisten Fällen WebGL.
WebGL ist seit gut einem Jahrzehnt in allen verbreiteten Browsern eingebaut und steckt in Kartendiensten, Produktkonfiguratoren, Browserspielen und Dashboards. Gleichzeitig steht mit WebGPU ein Nachfolger bereit, der die Grafikkarte moderner und effizienter anspricht. Wer heute ein 3D-Projekt im Web plant, sollte deshalb beides verstehen: wie WebGL arbeitet und wann sich der Blick auf WebGPU lohnt.
Was WebGL ist und woher es kommt
WebGL steht für Web Graphics Library. Es handelt sich um eine Programmierschnittstelle in JavaScript, über die eine Webseite die Grafikkarte (GPU, Graphics Processing Unit) des Geräts direkt nutzen kann. Gezeichnet wird in ein canvas-Element, also eine rechteckige Zeichenfläche innerhalb der Seite.
Technisch ist WebGL eine Übertragung von OpenGL ES ins Web. OpenGL ES ist die schlanke Variante des Grafikstandards OpenGL, die für Smartphones und eingebettete Systeme entwickelt wurde. Das Konsortium Khronos Group, das auch OpenGL und Vulkan betreut, veröffentlichte WebGL 1.0 im Jahr 2011 auf Basis von OpenGL ES 2.0. WebGL 2.0 folgte 2017 und orientiert sich an OpenGL ES 3.0. Die zweite Version brachte unter anderem bessere Texturformate, mehrere Renderziele gleichzeitig und das sogenannte Instancing, mit dem sich Tausende gleichartiger Objekte in einem einzigen Zeichenbefehl darstellen lassen.
Lange war Safari der Nachzügler: Apple aktivierte WebGL 2.0 standardmäßig erst 2021. Seitdem können Entwicklerteams WebGL 2.0 in allen großen Browsern voraussetzen.
Warum die Grafikkarte den Unterschied macht
Ein Prozessor (CPU) ist ein Generalist mit wenigen, sehr leistungsfähigen Kernen. Eine Grafikkarte dagegen besitzt Tausende einfache Recheneinheiten, die dieselbe Operation parallel auf viele Daten anwenden. Genau das braucht Grafik: Für jedes Bild müssen Millionen Bildpunkte berechnet werden, und bei flüssiger Darstellung mit 60 Bildern pro Sekunde bleiben für jedes Bild rund 16 Millisekunden.
Ein Vergleich aus dem Alltag: Die CPU ist eine erfahrene Sachbearbeiterin, die komplizierte Fälle nacheinander löst. Die GPU ist ein Großraumbüro voller Hilfskräfte, die alle gleichzeitig dasselbe einfache Formular ausfüllen. Für das Einfärben von Pixeln ist das Großraumbüro unschlagbar.
Wie aus Koordinaten ein Bild wird
Hinter jeder WebGL-Szene steht eine feste Abfolge von Arbeitsschritten, die Grafikpipeline. Wer sie einmal verstanden hat, versteht auch die meisten Fehlermeldungen und Leistungsprobleme.
- Vertices: Ein 3D-Modell besteht aus Eckpunkten, den Vertices. Jeder Vertex hat eine Position mit X-, Y- und Z-Koordinate und oft weitere Angaben wie Farbe, Normale (die Richtung, in die die Oberfläche zeigt) oder Texturkoordinaten.
- Primitive: Je drei Vertices bilden ein Dreieck. Dreiecke sind die Grundbausteine, weil drei Punkte immer in einer Ebene liegen und sich daher eindeutig füllen lassen. Ein detailliertes Sofa-Modell besteht schnell aus Hunderttausenden Dreiecken.
- Vertex-Shader: Ein kleines Programm auf der GPU rechnet für jeden Eckpunkt aus, wo er auf dem Bildschirm landet. Dabei fließen die Position des Objekts, die Kamera und die Perspektive ein.
- Rasterisierung: Die GPU ermittelt, welche Bildpunkte jedes Dreieck bedeckt. Aus der Vektorbeschreibung wird ein Raster aus Fragmenten, also Kandidaten für Pixel.
- Fragment-Shader: Ein zweites Programm bestimmt die Farbe jedes Fragments. Hier entstehen Licht, Schatten, Spiegelungen und Materialeindruck.
Shader: kleine Programme für die Grafikkarte
Shader schreiben Entwicklerinnen und Entwickler in einer eigenen Sprache, der OpenGL ES Shading Language (GLSL ES). Sie ähnelt C und wird zur Laufzeit vom Browser an den Grafiktreiber übergeben und dort kompiliert. Ein Fragment-Shader läuft für jedes Fragment einzeln, bei einem Full-HD-Bild also rund zwei Millionen Mal pro Bild. Deshalb lohnt es sich, Shader knapp zu halten: Jede zusätzliche Rechenoperation multipliziert sich mit der Zahl der Pixel.
Ein minimales Beispiel mit WebGL 2.0
Das folgende Beispiel zeichnet ein farbiges Dreieck. Es zeigt, wie viel Handarbeit reines WebGL verlangt: Shader kompilieren, Daten in einen Puffer der Grafikkarte laden, Attribute verknüpfen und schließlich zeichnen.
<canvas id="szene" width="640" height="480"></canvas>
const canvas = document.getElementById('szene');
const gl = canvas.getContext('webgl2');
if (!gl) {
throw new Error('WebGL 2.0 wird von diesem Browser nicht unterstützt.');
}
// Vertex-Shader: übernimmt Position und Farbe je Eckpunkt
const vertexQuelle = `#version 300 es
in vec2 aPosition;
in vec3 aFarbe;
out vec3 vFarbe;
void main() {
vFarbe = aFarbe;
gl_Position = vec4(aPosition, 0.0, 1.0);
}`;
// Fragment-Shader: färbt jedes Fragment mit der interpolierten Farbe
const fragmentQuelle = `#version 300 es
precision mediump float;
in vec3 vFarbe;
out vec4 farbe;
void main() {
farbe = vec4(vFarbe, 1.0);
}`;
function kompiliere(typ, quelle) {
const shader = gl.createShader(typ);
gl.shaderSource(shader, quelle);
gl.compileShader(shader);
if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
throw new Error(gl.getShaderInfoLog(shader));
}
return shader;
}
const programm = gl.createProgram();
gl.attachShader(programm, kompiliere(gl.VERTEX_SHADER, vertexQuelle));
gl.attachShader(programm, kompiliere(gl.FRAGMENT_SHADER, fragmentQuelle));
gl.linkProgram(programm);
gl.useProgram(programm);
// je Eckpunkt: x, y, r, g, b
// prettier-ignore
const daten = new Float32Array([
0.0, 0.6, 1.0, 0.3, 0.2,
-0.6, -0.5, 0.2, 0.8, 0.4,
0.6, -0.5, 0.2, 0.4, 1.0,
]);
const puffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, puffer);
gl.bufferData(gl.ARRAY_BUFFER, daten, gl.STATIC_DRAW);
const schritt = 5 * Float32Array.BYTES_PER_ELEMENT;
const posOrt = gl.getAttribLocation(programm, 'aPosition');
gl.enableVertexAttribArray(posOrt);
gl.vertexAttribPointer(posOrt, 2, gl.FLOAT, false, schritt, 0);
const farbOrt = gl.getAttribLocation(programm, 'aFarbe');
gl.enableVertexAttribArray(farbOrt);
gl.vertexAttribPointer(farbOrt, 3, gl.FLOAT, false, schritt, 2 * 4);
gl.clearColor(0.1, 0.1, 0.12, 1.0);
gl.clear(gl.COLOR_BUFFER_BIT);
gl.drawArrays(gl.TRIANGLES, 0, 3);
Rund fünfzig Zeilen für ein einziges Dreieck, ohne Kamera, Licht oder Interaktion. Das ist kein Konstruktionsfehler: WebGL ist bewusst eine Schnittstelle auf niedriger Ebene, die volle Kontrolle bietet. Für die meisten Projekte ist sie aber das Fundament, nicht das Werkzeug, mit dem man täglich arbeitet.
Bibliotheken: Three.js, Babylon.js und Co.
In der Praxis greifen die meisten Teams zu einer Bibliothek, die Kamera, Licht, Materialien, das Laden von 3D-Modellen und die Shader-Verwaltung übernimmt.
- Three.js ist die am weitesten verbreitete Bibliothek für 3D im Browser. Sie ist schlank, hat eine große Gemeinschaft und viele Beispiele. Mit React Three Fiber gibt es eine beliebte Anbindung an React.
- Babylon.js wird von Microsoft maßgeblich vorangetrieben und bringt mehr fertige Bausteine mit, etwa Physik, eine grafische Oberfläche für Materialien und eine ausgebaute Unterstützung für Virtual und Augmented Reality.
- Spezialisierte Werkzeuge decken einzelne Einsatzfelder ab: deck.gl und MapLibre für Karten und Geodaten, Plotly oder ECharts mit GPU-Beschleunigung für große Datenmengen, Spline als visuelles Design-Werkzeug für 3D-Elemente auf Websites.
- Spiel-Engines wie Unity oder die Godot Engine können Projekte für das Web exportieren. Dabei wird der Engine-Code meist nach WebAssembly übersetzt und zeichnet über WebGL. Mehr zu dieser Technik lesen Sie in unserem Beitrag über WebAssembly und Sprachen wie C++ und Rust im Browser.
Ein Austauschformat hat sich ebenfalls durchgesetzt: glTF, ebenfalls von der Khronos Group, gilt als eine Art JPEG für 3D-Modelle. Wer Modelle aus CAD- oder Design-Programmen ins Web bringen will, exportiert sie in der Regel als glTF oder in der binären Variante GLB.
Wo WebGL heute eingesetzt wird
Die Einsatzfelder sind breiter, als der Ruf als „Spieletechnik“ vermuten lässt:
- Karten und Geodaten: Moderne Kartendienste zeichnen ihre Vektorkarten mit WebGL, damit sich Karten flüssig drehen, neigen und zoomen lassen.
- Produktkonfiguratoren: Möbel, Fahrzeuge, Maschinen oder Küchen lassen sich in Echtzeit zusammenstellen und von allen Seiten betrachten.
- Datenvisualisierung: Wenn ein Diagramm Hunderttausende Punkte zeigen soll, stößt SVG an Grenzen, weil jeder Punkt ein eigenes Element im DOM ist. WebGL zeichnet solche Mengen ohne Ruckeln. Für kleinere, interaktive Diagramme bleibt SVG oft die bessere Wahl, wie unser Beitrag zu D3.js und interaktiven Datenvisualisierungen zeigt.
- Industrie und Technik: Digitale Zwillinge, Anlagenvisualisierungen und CAD-Viewer im Browser ersparen die Installation spezieller Software auf jedem Arbeitsplatz.
- Lernen und Medizin: Anatomiemodelle, Molekülansichten oder Simulationen machen abstrakte Zusammenhänge sichtbar.
- Spiele und Kunst: Browserspiele und generative Kunstprojekte waren die ersten großen Anwendungen und sind es bis heute.
Angenommen, ein Maschinenbauer möchte seinen Vertrieb mit einem Konfigurator ausstatten: Ein Kunde wählt Optionen, das 3D-Modell passt sich an, und am Ende entsteht ein Angebot. Mit WebGL läuft das auf jedem Laptop und Tablet, ohne dass die IT eine Anwendung verteilen muss.
WebGPU: der Nachfolger steht bereit
WebGL hat ein Grundproblem: Es bildet einen Grafikstandard aus den 2000er-Jahren ab. Moderne Grafikschnittstellen wie Vulkan, Metal von Apple und Direct3D 12 von Microsoft arbeiten anders. Sie verlangen mehr Planung im Voraus, belohnen das aber mit weniger Verwaltungsaufwand pro Zeichenbefehl. Genau diese Lücke schließt WebGPU, ein Standard, den das World Wide Web Consortium (W3C) gemeinsam mit den Browserherstellern entwickelt.
Die wichtigsten Unterschiede:
| Aspekt | WebGL 2.0 | WebGPU |
|---|---|---|
| Vorbild | OpenGL ES 3.0 | Vulkan, Metal, Direct3D 12 |
| Shader-Sprache | GLSL ES | WGSL |
| Allgemeine Berechnungen | nur über Umwege | Compute-Shader eingebaut |
| Verwaltungsaufwand je Zeichenbefehl | eher hoch | geringer |
| Browserunterstützung | praktisch überall | in den großen Browsern, teils noch nicht auf allen Plattformen |
Besonders bedeutsam sind die Compute-Shader. Damit lässt sich die Grafikkarte für allgemeine Rechenaufgaben nutzen, etwa für Physiksimulationen, Bildverarbeitung oder das Ausführen von KI-Modellen direkt im Browser. Bibliotheken für maschinelles Lernen im Web setzen deshalb zunehmend auf WebGPU.
Chrome lieferte WebGPU im Frühjahr 2023 für Windows, macOS und ChromeOS aus, später folgte Android. Apple und Mozilla zogen 2025 mit Safari und Firefox nach, Firefox zunächst unter Windows, seit Anfang 2026 auch auf Macs mit Apple Silicon. Three.js und Babylon.js bieten bereits Renderer für WebGPU an, die bei fehlender Unterstützung auf WebGL zurückfallen können.
Ist WebGL damit veraltet?
Nein, jedenfalls nicht in absehbarer Zeit. WebGL läuft auf praktisch jedem Gerät, auch auf älterer Hardware und in Umgebungen, in denen WebGPU noch fehlt oder abgeschaltet ist. Die Browserhersteller haben keine Abschaltung angekündigt. Für Neuentwicklungen ändert sich vor allem die Strategie: Wer über eine Bibliothek arbeitet, kann WebGPU nutzen, wo es verfügbar ist, und WebGL als Rückfallebene behalten. Wer dagegen direkt gegen die Schnittstelle programmiert, sollte prüfen, ob ein neues Projekt nicht gleich auf WebGPU aufsetzen kann.
Grenzen und Stolperfallen
So leistungsfähig die Technik ist, sie hat Grenzen, die in Projekten regelmäßig unterschätzt werden:
- Ladezeit: 3D-Modelle und Texturen sind groß. Ohne Kompression (etwa Draco für Geometrie oder KTX2 für Texturen) und schrittweises Nachladen wartet der Nutzer lange auf den ersten Eindruck.
- Geräteunterschiede: Ein Modell, das auf dem Entwickler-Laptop flüssig läuft, kann auf einem günstigen Smartphone ruckeln oder den Akku leeren. Tests auf schwacher Hardware gehören deshalb in jedes Projekt.
- Barrierefreiheit: Der Inhalt eines
canvasist für Screenreader unsichtbar. Wichtige Informationen brauchen eine textliche Entsprechung, und die Bedienung sollte auch per Tastatur möglich sein. - Suchmaschinen: Was nur in der 3D-Szene steht, findet Google nicht. Produktdaten und Beschreibungen gehören zusätzlich in den HTML-Text der Seite.
- Sicherheit und Datenschutz: Browser kapseln WebGL stark ab, prüfen Shader und begrenzen den Zugriff auf Treiber. Allerdings lassen sich über Merkmale der Grafikkarte Geräte wiedererkennen, das sogenannte Fingerprinting. Manche Browser geben deshalb nur noch allgemeine Angaben zur GPU heraus.
Was das für Ihr Projekt bedeutet
3D im Browser ist kein Experiment mehr, sondern ausgereifte Technik. Ob sie sich lohnt, entscheidet der Inhalt: Ein drehbares Produkt, das Kunden sonst nur auf Fotos sehen, oder eine Datenmenge, die anders nicht darstellbar ist, rechtfertigen den Aufwand. Ein 3D-Effekt auf der Startseite, der vor allem gut aussieht, kostet dagegen meist mehr Ladezeit, als er bringt.
Unsere Einschätzung: Für die meisten Teams ist eine etablierte Bibliothek wie Three.js oder Babylon.js der richtige Einstieg. Reines WebGL oder WebGPU lohnt sich vor allem für spezialisierte Visualisierungen, eigene Engines oder rechenintensive Aufgaben. Wer heute neu beginnt, sollte eine Bibliothek wählen, die beide Schnittstellen unterstützt. Dann ist der Wechsel zu WebGPU eine Konfigurationsfrage und kein Neubau.
Wenn Sie eine 3D-Anwendung im Web planen oder Ihr Team in moderner Frontend-Entwicklung schulen möchten, finden Sie auf unserer Seite zu Web- und Frontend-Technologien Beratung, Coaching und Seminare von MARTINSFELD.
Häufige Fragen zu WebGL
Brauchen Nutzer spezielle Hardware für WebGL-Inhalte?
Nein. Praktisch alle aktuellen Computer, Tablets und Smartphones unterstützen WebGL in einem aktuellen Browser. Die Leistung hängt allerdings stark von der Grafikeinheit ab. Aufwendige Szenen sollten daher eine reduzierte Qualitätsstufe für schwächere Geräte anbieten.
Ist WebGL sicher?
WebGL läuft in der abgeschotteten Umgebung des Browsers. Shader werden vor der Übergabe an den Treiber geprüft, und Browser blockieren bekannte fehlerhafte Treiber. Sicherheitslücken in Grafiktreibern kommen dennoch vor. Halten Sie Browser und Betriebssystem deshalb aktuell.
Eignet sich WebGL auch für 2D-Grafik?
Ja. Viele 2D-Spiele, Kartendienste und Diagrammbibliotheken nutzen WebGL, weil es große Mengen an Formen und Bildern schneller zeichnet als das klassische Canvas 2D oder SVG. Bibliotheken wie PixiJS sind genau darauf spezialisiert.
Sollte ein neues Projekt direkt mit WebGPU starten?
Das hängt von der Zielgruppe ab. Wenn Sie über Three.js oder Babylon.js arbeiten, nutzen Sie WebGPU dort, wo es verfügbar ist, und behalten WebGL als Rückfallebene. Wer nur WebGPU unterstützt, sollte vorher prüfen, welche Browser und Geräte die eigenen Nutzer tatsächlich verwenden.
Kategorien
Schlagworte