Description

When a map engine renders smoothly, it's rarely by accident. Behind every tile transition and feature layer lies a carefully engineered stack of performance strategies that most developers never see. This session dives into the internals of a map engine to explain why these optimizations exist and what you can learn from them to improve your own visualizations.

Efficient feature rendering — Rendering 10,000 individual features naively means 10,000 draw calls. We'll explore how batching and GPU instancing dramatically reduce this overhead. Styling those batched features by their attributes presents its own challenge — we'll look at how engines evaluate styles against feature attributes ahead of time, pack the results into a texture, and let the GPU look up each feature's style at render time via a per-vertex batch ID, keeping attribute-driven styling fast without breaking the batching model.

Post-processing on the GPU — Once features are rendered, visual effects are often still needed. We'll explore why screen-space post-processing techniques like SMAA and FXAA are significantly faster than per-mesh approaches like MSAA, and how applying effects to the final rendered image rather than to individual geometries keeps the pipeline lean regardless of feature count.

Zero-copy data pipelines — Traversing feature data twice is wasteful. We'll look at how parsing pipelines can be structured to complete as much work as possible in a single pass, and how data structures like flattened 1D polygon arrays enable large geometry transfers to Web Workers without memory copying.

Threading and the main thread — Web Workers are essential for keeping UIs responsive, but they come with constraints. We'll discuss how engines manage worker pools based on navigator.hardwareConcurrency, assign tasks to idle workers, and structure transferable data to avoid serialization overhead.

Network and connection management — Browsers impose hard limits on concurrent HTTP connections. We'll cover strategies for aborting stale requests early, queuing tile fetches intelligently, and preventing connection saturation from blocking critical resources.

Memory and GC pressure — Garbage collection pauses are a silent framerate killer. We'll examine how engines minimize GC exposure, and why languages like Rust compiled to WebAssembly offer structural advantages for memory-safe, GC-free data handling.

Perceived performance through progressive rendering — Actual render time and perceived render time are not the same thing. Map engines exploit this gap by rendering cheaper, lower-fidelity representations first — such as a single parent tile instead of four child tiles — and progressively refining toward full quality.

Improve coordinate precision — When you set the position to the GLB itself or put a model through Three.js, you may notice that the model shakes. This is due to the vertex precision on the GPU. In this case, you must use a technique called RTE or RTC.

Intended Audience

Someone who wants to optimize your visualization from the perspective of a map engine's internal structure.

Takeaways

• Insight of how to optimize your visualization
• Knowledge of various optimizations in a map engine