2026 visionOS 27 WebXR-Ruckeln: Wie Three.js stabile Bildraten erreicht und Abstürze vermeidet

Die Three.js-Szene läuft in Safari zunächst flüssig, verliert aber beim Eintritt in die Immersion Frames oder endet mit „WebGL Context Lost“.
Gewinner ist die Mess- und Ressourcenstrategie: Erst Texturen und veraltete Ressourcen komprimieren und freigeben, danach Draw Calls, Pixel- und Postprocessing-Kosten senken; erst am Ende WebGL und WebGPU per Feature-Erkennung vergleichen und einen Rückfallpfad behalten.
Diese Anleitung ist für Frontend-Entwickler gedacht, die eine bestehende Three.js-Seite in ein WebXR-Erlebnis für Apple Vision Pro umwandeln. Sie hilft außerdem technischen Leitern, die zwischen Asset-, Render- und Safari/WebKit-Problemen unterscheiden müssen. Remote-Teams ohne dauerhaft verfügbare Mac-, Safari- und visionOS-Testumgebung erhalten eine belastbare Prüfsequenz.
Messmodell für visionOS 27 WebXR-Ruckeln
Ein einzelner Eindruck wie „Safari ist langsam“ reicht für eine technische Entscheidung nicht aus. Ein Projekt sollte drei Baselines anlegen:
- normale Webseite ohne WebXR-Sitzung,
- WebXR-Sitzung ohne Immersion,
- immersive Sitzung auf dem echten Gerät.
Für jede Baseline werden durchschnittliche Frame-Zeit, lange Frames, der Auslöser des Problems und der Zustand von renderer.info protokolliert. Die Frame-Zeit ist dabei aussagekräftiger als eine isolierte Bildratenzahl: Sie zeigt, ob die Renderarbeit dauerhaft zu groß ist oder nur an einzelnen Stellen ausreißt.
Ein reproduzierbarer Eintrag sollte mindestens enthalten:
- URL, Commit und verwendete Three.js-Version,
- Browser- und visionOS-Version,
- Einstieg in die Szene und Beginn der Immersion,
- aktivierte Qualitätsstufe,
- sichtbare Anzahl von Texturen, RenderTargets und Geometrien,
calls,trianglesund Programmwechsel ausrenderer.info,- Zeitpunkt eines möglichen
WebGL Context Lost.
Der Safari Web Inspector für visionOS liefert Hinweise zu JavaScript, Netzwerk, Konsole und WebXR-Inspektion. renderer.info ergänzt diese Sicht um Three.js-interne Zähler. Ein reproduzierbares Video oder ein automatisch gespeichertes Log verbindet beide Ebenen.
Die Fehlerbilder sollten getrennt werden:
- Dauerhaft hohe Frame-Zeit: häufig zu viele Objekte, Animationen, Raycasts oder Pixel.
- Einbruch beim Eintritt in die Immersion: zusätzliche Renderflächen, höhere Auflösung, Schatten oder neue Ressourcen.
- Langsames Speicherwachstum: wahrscheinlicher Lebenszyklusfehler bei Texturen, Materialien, Geometrien, ImageBitmaps oder RenderTargets.
- WebGL Context Lost: Ressourcen- oder Treiberproblem möglich, aber kein Beleg für eine offiziell festgelegte Ein-Tab-Speichergrenze.
Für Safari 27 sind WebXR- und Simulator-Korrekturen dokumentiert. Daraus folgt jedoch nicht, dass jede Three.js-Szene dieselbe Stabilität erreicht. Die Safari- und WebKit-Änderungen sollten bei jeder neuen Browser- oder Betriebssystemversion erneut mit dem konkreten Projekt geprüft werden.
Ressourcenbilanz statt vermuteter Speicherwand
Die häufigste Fehlentscheidung besteht darin, eine nicht bestätigte feste Safari-GPU-Grenze als Ursache festzuschreiben. Offizielle Quellen nennen keine allgemeingültige, für jede Seite und jedes Gerät geltende Ein-Tab-Grenze. Die „Speicherwand“ bleibt daher eine Hypothese, die durch Messung bestätigt oder verworfen werden muss.
Für die Abschätzung zählt nicht nur die Dateigröße eines Bildes. Relevant sind:
- Texturbreite und -höhe,
- Pixel- und Komprimierungsformat,
- Mipmaps,
- Anzahl gleichzeitig residenter Texturen,
- RenderTargets,
- doppelte Materialien,
- temporäre
ImageBitmap-Objekte, - Lebensdauer beim Szenenwechsel.
Eine kleine GLB-Datei kann viele große GPU-Texturen erzeugen. Umgekehrt kann eine größere Geometrie bei wenigen, gut verwalteten Texturen stabiler laufen. Die KTX2Loader-Dokumentation von Three.js beschreibt den vorgesehenen Ladeweg für KTX2 und die Transcoder-Anbindung an Basis Universal.
Ein kompakter Ladepfad sieht beispielsweise so aus:
const ktx2 = new KTX2Loader()
.setTranscoderPath('/basis/')
.detectSupport(renderer);
const texture = await ktx2.loadAsync('/assets/scene-color.ktx2');
material.map = texture;
material.needsUpdate = true;
Entscheidend ist detectSupport(renderer). Die Datei allein beweist noch nicht, dass der gewünschte GPU-Komprimierungspfad verwendet wird. Nach dem Laden sollte das Team die sichtbare Qualität, die Mipmap-Auswahl und das Verhalten beim wiederholten Szenenwechsel prüfen. Ein KTX2-Asset, das nur als unkomprimierte Zwischenressource endet, löst das eigentliche Problem nicht.
Beim Verlassen einer Szene muss der Besitz der Ressourcen klar sein:
function disposeObject(root) {
root.traverse((node) => {
if (!node.isMesh) return;
node.geometry?.dispose();
const materials = Array.isArray(node.material)
? node.material
: [node.material];
for (const material of materials) {
for (const value of Object.values(material)) {
if (value?.isTexture) value.dispose();
}
material.dispose();
}
});
}
RenderTargets, temporäre Texturen und ImageBitmap-Objekte benötigen zusätzliche Pfade. Bei einem ImageBitmap muss der Code auch close() berücksichtigen, sobald keine Referenz mehr gebraucht wird. Die Three.js-Anleitung zur Freigabe von Geometrien, Materialien und Texturen erklärt dabei eine wichtige Grenze: dispose() fordert die Freigabe an, erzwingt aber keine sofortige Anzeige eines sinkenden Betriebssystem-Speicherwertes.
Der richtige Test ist deshalb eine Schleife: Szene laden, anzeigen, verlassen, Ressourcen freigeben und erneut laden. Steigen renderer.info.memory.geometries oder renderer.info.memory.textures bei jedem Durchlauf weiter, liegt ein verdächtiger Lebenszyklus vor. Bleiben die Werte stabil, muss die Ursache eher bei Spitzenlast, Pixelkosten oder Backend-Kompatibilität gesucht werden.
Draw Calls gegen Modellumfang
Ein umfangreiches Modell ist nicht automatisch ein langsames Modell. Viele einzelne Meshes, Materialien und Zustandswechsel belasten dagegen die CPU-Seite des Renderings. renderer.info.render.calls zeigt, wie viele Renderaufrufe Three.js ausführt. triangles zeigt die Geometriearbeit. Die Anzahl der Programme weist auf Shader- und Materialvielfalt hin.
Bei vielen identischen Objekten ist InstancedMesh der erste Kandidat:
const mesh = new THREE.InstancedMesh(
geometry,
material,
instanceCount
);
const matrix = new THREE.Matrix4();
for (let i = 0; i < instanceCount; i++) {
matrix.compose(positions[i], rotations[i], scales[i]);
mesh.setMatrixAt(i, matrix);
}
mesh.instanceMatrix.needsUpdate = true;
scene.add(mesh);
Das Verfahren hilft bei wiederholten Geometrien mit kompatiblem Material. Es ist kein pauschaler Ersatz für jedes Mesh. Stark unterschiedliche Materialien, individuelle Transparenz oder häufig wechselnde Shader können den Vorteil abschwächen.
Statische Assets lassen sich gegebenenfalls batchen oder geometrisch zusammenführen. Dabei müssen Objektselektion, Interaktion, Materialgrenzen und Sichtbarkeit erhalten bleiben. Transparente Flächen verschärfen die Sortier- und Füllkosten. Häufige Materialwechsel verhindern Zustandsbündelung. Dynamische Schatten erzeugen zusätzliche Renderarbeit, besonders wenn mehrere Lichtquellen oder große Schattenkarten aktiv sind.
Die GPU-Optimierung darf die Hauptausführung nicht ausblenden. Pro Frame zu erzeugende Arrays, neue Vektoren, aufwendige Animationen und vollständige Raycast-Suchen können die CPU begrenzen. Bei XR sollte ein Raycast deshalb räumlich und zeitlich eingegrenzt werden, statt jede Szene gegen jedes Objekt zu testen.
Pixelbudget und Qualitätsstufen
Die Auflösung ist in einer stereoskopischen Szene nicht nur eine Frage der Schärfe. Sie beeinflusst die Zahl der zu verarbeitenden Pixel pro Auge, die Kosten von Schatten, Transparenz und jedem nachgelagerten Pass. devicePixelRatio, Antialiasing, Schattenkarten, Bloom, Farbkorrektur und mehrere transparente Ebenen sollten einzeln geprüft werden.
Eine dynamische Qualitätsstufe ist belastbarer als eine dauerhaft schlechte Darstellung:
const quality = {
scale: 1.0,
shadows: true,
postprocessing: true
};
function adaptQuality(frameMs) {
if (frameMs > 25) {
quality.scale = Math.max(0.7, quality.scale - 0.1);
quality.shadows = false;
} else if (frameMs < 16 && quality.scale < 1.0) {
quality.scale = Math.min(1.0, quality.scale + 0.05);
}
renderer.setPixelRatio(
Math.min(window.devicePixelRatio, quality.scale)
);
}
Die Schwellenwerte sind keine universelle Vision-Pro-Spezifikation. Sie sind Projektparameter und müssen mit einem festen Messprotokoll validiert werden. Wichtig ist die Reihenfolge: Erst Schatten deaktivieren, dann Postprocessing reduzieren, anschließend die Renderauflösung absenken. Werden alle Parameter gleichzeitig verändert, bleibt unklar, welcher Schritt tatsächlich geholfen hat.
| Prüfbereich | Primärer Messwert | Wenn der Wert auffällig ist | Gegenmaßnahme |
|---|---|---|---|
| Texturen | residenter Bestand und Speichertrend | Wachstum nach jedem Szenenwechsel | KTX2/BasisU, Mipmaps, Freigabe |
| Geometrie | triangles und Geometrieanzahl |
hohe Last bei statischen Wiederholungen | Instancing oder Batch-Verfahren |
| CPU-Submission | renderer.info.render.calls |
viele unabhängige Meshes | InstancedMesh, Materialbündelung |
| Pixelkosten | Frame-Zeit bei Effekten an/aus | starke Änderung durch Schatten oder Passes | Qualitätsstufen, weniger Transparenz |
| Stabilität | Context-Lost-Log und Reproduktion | Fehler nach wiederholtem Eintritt | Ressourcenlebenszyklus und Backend prüfen |
WebGL, WebGPU und Rückfallpfad
Safari 26.2 hat WebGPU-Unterstützung für WebXR auf visionOS ergänzt. Das ist eine wichtige Plattformänderung, aber kein Leistungsversprechen. Ein Projekt kann mit WebGPU schneller, gleich schnell oder langsamer sein. Shader-Portierung, Pipeline-Erstellung, Postprocessing und die verwendete Three.js-Version beeinflussen das Ergebnis.
Der WebGL- und WebGPU-Pfad sollte nicht anhand des User-Agent-Strings gewählt werden:
async function createRenderer(container) {
if (navigator.gpu) {
try {
const renderer = new THREE.WebGPURenderer({
antialias: true
});
await renderer.init();
container.appendChild(renderer.domElement);
return renderer;
} catch (error) {
console.warn('WebGPU nicht verfügbar:', error);
}
}
const renderer = new THREE.WebGLRenderer({
antialias: true,
alpha: true
});
container.appendChild(renderer.domElement);
return renderer;
}
Die WebGPU-Hinweise von WebKit zu Safari 26.2 und die Three.js-Dokumentation zu WebGPURenderer sollten gemeinsam gelesen werden. Besonders kritisch sind ShaderMaterial, onBeforeCompile, eigene Bindings und Postprocessing-Ketten. Ein bestehendes WebGL-Projekt kann deshalb nicht ohne Anpassung als „automatisch schneller“ behandelt werden.
„Metal-Downgrade“ ist ebenfalls eine missverständliche Beschreibung. Die Zuordnung von WebGL oder WebGPU zu nativen Grafikschichten übernimmt WebKit. Entwickler können nicht einfach einen allgemein verfügbaren Metal-Schalter im WebXR-Code setzen. Steuerbar sind der gewählte Three.js-Renderer, die Qualitätsstufe, die verwendeten Effekte und der Rückfallpfad.
Entscheidungsbaum für die Abnahme
Die folgende Reihenfolge verhindert, dass ein Team zu früh das Backend wechselt:
- Wenn der Speichertrend bei wiederholtem Szeneneintritt wächst, dann zuerst
dispose()-Pfade, RenderTargets, ImageBitmaps und Texturlebensdauer reparieren; sonst weiter zu Draw Calls. - Wenn
callshoch und die Geometrie überwiegend statisch und wiederholt ist, dann Instancing oder Batch-Verfahren testen; sonst CPU-Animationen und Raycasts untersuchen. - Wenn die Frame-Zeit nur bei Schatten, Transparenz oder Postprocessing stark steigt, dann eine gestufte Qualitätsregel einführen; sonst die Baseline mit reduzierter Renderauflösung vergleichen.
- Wenn WebGL stabil, aber WebGPU nicht initialisiert oder visuell abweicht, dann WebGL als Veröffentlichungsweg behalten und WebGPU separat beheben; sonst beide Backends mit demselben Asset- und Qualitätsprofil messen.
- Wenn Simulator und Web Inspector unauffällig sind, dann noch keine Leistungsfreigabe erteilen; erst ein echter Apple-Vision-Pro-Test mit Langzeitsitzung, wiederholtem Eintritt und Context-Lost-Protokoll entscheidet.
FAQ für die Fehlersuche
Plötzlicher Frame-Verlust
Bei einem plötzlichen Einbruch in Safari sollte zunächst der Übergang in die immersive Sitzung verglichen werden. Werden dort RenderTargets, Schatten oder zusätzliche Texturen erzeugt, liegt der Auslöser oft in der Szeneninitialisierung und nicht in einer allgemeinen Browserverlangsamung. Frame-Zeit, calls und Ressourcenbestand müssen im selben Log stehen.
WebGL Context Lost
Nach einem Context Lost sollte das Team nicht sofort eine vermeintliche feste Speichergrenze veröffentlichen. Zuerst gehören wiederholte Szenenwechsel, große RenderTargets, unkomprimierte Texturen, nicht freigegebene Materialien und der Unterschied zwischen Simulator und echter Hardware auf die Prüfliste. Ein minimaler Reproduktionsfall ist wertvoller als ein großer Fehlerbericht ohne Ablauf.
KTX2 und Basis Universal
Komprimierte Texturen sind besonders dann sinnvoll, wenn mehrere große Farb-, Normal- und Maskentexturen gleichzeitig resident bleiben. Der Vorteil muss auf der Zielumgebung kontrolliert werden. Neben dem Ladeformat zählen Mipmaps, Farbprofile, Transcoder-Pfad und die tatsächliche GPU-Ressource. Ein KTX2-Export ersetzt keine Ressourcenverwaltung.
WebGL oder WebGPU
WebGL bleibt der sichere Rückfall, wenn eigene Shader oder etablierte Postprocessing-Pässe noch nicht auf WebGPU abgestimmt sind. WebGPU verdient einen Vergleich, wenn Feature-Erkennung, Initialisierung und Materialpfad funktionieren. Die Entscheidung sollte aus einem identischen Szenenlauf entstehen, nicht aus der Annahme, dass die neuere API automatisch schneller ist.
Testen ohne Vision Pro
Der Simulator ist für Kompatibilität, Navigation, Berechtigungen und grundlegende WebXR-Abläufe nützlich. Für Frame-Zeit, thermische Dauerlast, reale Eingabe und endgültige Stabilität reicht er nicht aus. Ein Remote-Team kann Mac- und Safari-Versionen zentral vorhalten; die finale Performanceabnahme benötigt trotzdem ein echtes Apple-Vision-Pro-Gerät.
Fünf Schritte bis zur Freigabe
-
Testfall einfrieren: Commit, Three.js-Version, Browser, visionOS-Version, Asset-Satz und Qualitätsstufe dokumentieren. Ohne identische Ausgangslage sind WebGL- und WebGPU-Vergleiche wertlos.
-
Drei Baselines messen: Normale Seite, nicht immersive WebXR-Sitzung und immersive Sitzung getrennt aufzeichnen. Frame-Zeit, lange Frames,
renderer.infound reproduzierbare Schritte zusammen speichern. -
Ressourcen bereinigen: KTX2 mit
detectSupport(renderer)einsetzen, unnötige Mipmaps und doppelte Texturen prüfen, anschließend Geometrien, Materialien, RenderTargets und ImageBitmaps beim Szenenwechsel freigeben. -
Submission und Pixelarbeit senken:
calls,triangles, Programme, Schatten, Transparenz, Antialiasing und Postprocessing einzeln verändern. Wiederholte Geometrien mitInstancedMeshvergleichen und Raycasts sowie Animationen aus dem Frame-Pfad prüfen. -
Backend und Gerät abnehmen: WebGPU per Feature-Erkennung versuchen, bei Fehlern auf WebGL zurückfallen, beide Pfade visuell und funktional vergleichen und anschließend eine Langzeitsitzung auf Apple Vision Pro durchführen.
Für Teams, die mehrere Mac- und Safari-Stände benötigen, kann eine zentrale ProxyMac-Testumgebung die Asset-Konvertierung, Simulator-Vorprüfung und Regressionstests bündeln. Dabei sollten Zugriffsrechte, Protokollaufbewahrung und die Datenschutzanforderungen von ProxyMac vor dem Einsatz geprüft werden. Eine permanente Remote-Mac-Umgebung ersetzt jedoch weder die echte Hardware noch die finale WebXR-Abnahme.
Aktueller Ansatz und Mac-Testumgebung
Ein einzelner lokaler Rechner ist für diese Aufgabe oft unpraktisch: Safari-Versionen lassen sich nicht beliebig parallel halten, der visionOS-Simulator benötigt eine passende Xcode-Umgebung, und eine reale Apple-Vision-Pro-Abnahme kann nicht vollständig simuliert werden. Öffentliche Cloud-Instanzen bringen zusätzlich unklare Grafikpfade, schwankende Latenz und eingeschränkte Kontrolle über Browser- oder Simulatorversionen mit.
Für kurzfristige Asset-Konvertierung, Safari-Vergleiche und wiederholbare Simulatorläufe kann die Miete einer ProxyMac-Mac-Umgebung deshalb organisatorisch sauberer sein als die Anschaffung weiterer Geräte. Das Team sollte die Mietumgebung als Vorstufe und Regressionsebene einplanen, nicht als Ersatz für die finale Messung auf Apple Vision Pro. Wer einen stabilen, langfristigen Renderbetrieb mit eigener Hardware, physischen XR-Geräten oder dauerhaft hoher Last braucht, sollte die Anschaffung und den lokalen Betrieb gesondert bewerten.