Hey there, great question—this is a common point of confusion for developers getting into Three.js on mobile, so let’s unpack it step by step.

First off, that claim is not entirely accurate—let’s clarify how this works:

• Three.js is built on top of web standards like WebGL (or WebGL2, and now WebGPU). On mobile, whether you’re running it in a standalone browser or a WebView (iOS’s WKWebView, Android’s system WebView/Chrome-based WebView), these web APIs don’t exist in a vacuum.
• Under the hood, WebGL directly maps to native graphics APIs: on iOS, it uses Metal; on Android, it uses OpenGL ES or Vulkan (depending on the device and WebView version). WebGPU, the newer standard, also hooks directly into Metal (iOS) and Vulkan/OpenGL ES (Android) under the hood.
• Three.js doesn’t need to "call native APIs directly" because the web standards layer already handles that bridge. The misconception comes from thinking Three.js is isolated from the native stack, but it’s actually deeply integrated via these standardized APIs.

Let’s break down the performance differences between the two platforms:

iOS Platform #

• Stable, optimized performance: Apple’s WKWebView has excellent WebGL/WebGPU support, especially on modern devices (A14 chip and newer). Complex Three.js scenes—think medium-poly models, real-time shadows, basic post-processing—can easily hit 60fps without breaking a sweat.
• Memory constraints to watch for: iOS enforces stricter limits on WebGL texture sizes and GPU memory usage. If you overload the scene with high-res textures or unoptimized geometry, you might hit frame drops or even crashes. Proper resource management (like texture compression, LOD models, and cleaning up unused assets) goes a long way here.
• WebGPU boost: iOS 15+ supports WebGPU, and Three.js has full support for this backend. WebGPU closes the performance gap even further, bringing Three.js performance very close to native Metal apps for many use cases.

Android Platform #

• Hardware-dependent variability: Android’s ecosystem is much more fragmented, so performance varies wildly across devices:
  • Flagship devices: Phones with top-tier chips (Snapdragon 8 Gen series, Exynos 2400) perform on par with iOS flagships. Modern WebView versions (Chrome 90+) have great WebGL2/WebGPU optimization, so complex scenes run smoothly.
  • Entry-level devices: Lower-end phones with weaker GPUs will struggle with heavy scenes. You’ll need to stick to low-poly models, minimal effects, and reduce draw calls to maintain acceptable frame rates.
  • WebView consistency: Some custom Android skins use modified WebView versions that might have subpar WebGL support. For the most reliable performance, recommend users open your content in the official Chrome browser, or use a Chrome-based WebView (like AndroidX WebView) in your native app.

Short answer: No, absolutely not.

Modern WebViews have come a long way—their WebGL/WebGPU implementations are highly optimized, and on mid-to-high-end mobile devices, Three.js performance is barely distinguishable from native 3D apps for most use cases. Countless production apps (3D product configurators, AR experiences, interactive data visualizations) run Three.js in WebViews with great user experiences.

There is a tiny amount of overhead compared to native, but it’s negligible for all but the most demanding scenarios (like AAA 3D games). For the vast majority of 3D web projects, Three.js in a WebView is more than performant enough.

内容的提问来源于stack exchange，提问作者weijia_yu