> Markdown version of [/videos/1747-uncharted-territories-of-web-performance-andrew-burnett-thompson-and-david-burleigh?t=1344](https://www.wearedevelopers.com/videos/1747-uncharted-territories-of-web-performance-andrew-burnett-thompson-and-david-burleigh?t=1344). Every page supports `.md` or `Accept: text/markdown`. Links point to the HTML versions so they work for humans too. Agent guide: [/agents.md](https://www.wearedevelopers.com/agents.md).

---

# Uncharted Territories of Web Performance - Andrew Burnett-Thompson and David Burleigh

Andrew Burnett-Thompson and David Burleigh prove browsers can natively render millions of data points. Discover how to bypass JavaScript memory limits using WebAssembly for industrial-strength charting.

- **Speakers:** Andrew Burnett-Thompson, David Burleigh
- **Event:** Coffee With Developers
- **Published:** October 26, 2025
- **Duration:** 49:57
- **URL:** https://www.wearedevelopers.com/videos/1747-uncharted-territories-of-web-performance-andrew-burnett-thompson-and-david-burleigh

## Summary

High-performance data visualization traditionally relied on thick desktop clients like WPF to handle massive datasets. However, as IoT devices, medical monitors, and telemetry systems generate unprecedented data volumes, developers need to bring industrial-strength charting to the web. By leveraging C++ and Emscripten to compile a lightweight native rendering engine into WebAssembly and WebGL, SciChart bypasses JavaScript's memory boxing limitations. This architecture provides continuous memory blocks and pointer arithmetic, allowing browsers to render millions of data points natively without the performance overhead typical of cross-platform wrappers like React Native.

Pushing browser limits exposes unique bottlenecks, such as garbage collection crashes in long-running applications or sluggish hidden-canvas copying in Firefox. To maintain flat memory growth over days of continuous operation, developers must meticulously proxy native elements and manually track garbage collection. Similarly, scaling to hundreds of synchronized charts requires custom sub-chart APIs and heavily optimized text rendering to bypass the DOM entirely. Embracing experimental features like Wasm SIMD and direct array-view memory access further shrinks Wasm payloads and exponentially accelerates data reshaping.

Beyond raw performance, maintaining an advanced developer library introduces novel challenges in the era of generative tools. AI models often hallucinate API methods based on class names, forcing library maintainers to write AI-ready documentation. By explicitly shaping nomenclature and providing machine-crawlable context, developers can prevent LLMs from generating invalid code while preserving backward compatibility. Ultimately, pushing the boundaries of web performance proves that rendering thousands of deep-zoom charts simultaneously is not a theoretical edge case, but a practical necessity for modern data analytics.

**Keywords:** scichart, webassembly optimization, webgl rendering, emscripten compilation, javascript memory boxing, wasm SIMD, canvas API bottlenecks, browser garbage collection tracking, IoT data visualization, cross-platform mapping overhead, AI-ready documentation, LLM API hallucinations, high-frequency telemetry, WPF to web migration, continuous memory allocation

## Chapters

1. **Exploring the performance frontier of web charting libraries** (00:02) — How handling millions of data points and complex interactions demands new architectural approaches for data visualization.
1. **Managing complexity in multi-chart dashboard interactions** (02:15) — Why scaling front-end performance requires balancing rendering speed with complex features like synchronized zooming and interactive tooltips.
1. **Transitioning from native WPF to modern web assembly** (03:22) — How moving core charting logic into a shared C++ engine enabled high-performance rendering across desktop, mobile, and web platforms.
1. **Bypassing standard cross-platform framework performance limits** (05:41) — Why abandoning traditional cross-platform application wrappers in favor of a direct event source and canvas model yields better low-level performance.
1. **Building a game engine architecture for web charting** (07:38) — How adapting single-canvas game engine patterns provides high-speed native rendering while preserving platform-specific customization hooks.
1. **Optimizing memory management and data processing with WebAssembly** (10:18) — How bypassing JavaScript's boxing overhead and utilizing continuous Wasm memory blocks dramatically accelerates data processing.
1. **Preventing memory leaks in long-running web applications** (13:25) — Why real-time dashboard applications require tracking native memory allocation and strict sandbox management to avoid browser crashes.
1. **Competing for browser resources in multi-tab environments** (17:17) — How resource-intensive applications must balance performance expectations with background tab management and page activity constraints.
1. **Scaling data visualization for extreme industrial constraints** (18:39) — How industries like Formula One and medical monitoring push the boundaries of real-time telemetry processing in the browser.
1. **Architecting sub-chart APIs to bypass WebGL context limits** (22:24) — How drawing multiple logical charts onto a single shared WebGL canvas resolves browser limits and slow texture copy operations.
1. **Caching strategies for high-volume text rendering and labeling** (26:01) — Why overcoming the performance penalties of text rendering requires aggressive layout caching when displaying thousands of axis labels simultaneously.
1. **Accelerating WebAssembly to JavaScript data reads** (29:18) — How using short-lived ArrayBuffer views over native WebAssembly memory bypasses standard Emscripten bottlenecks for massive speed improvements.
1. **Visualizing embedded telemetry and IoT stream processing** (32:00) — How continuous IoT data generation shifts the paradigm from daily batch processing to real-time interactive stream analysis.
1. **Deploying RAG-based support for developer documentation** (36:29) — How integrating custom AI assistants into support pipelines provides developers with contextual first-line resolution for complex library questions.
1. **Modernizing documentation infrastructure for AI consumption** (39:58) — Why structuring technical documentation for both AI parsers and human readers is critical for preventing API hallucinations.
1. **Refining API naming conventions to combat LLM hallucinations** (44:20) — How adapting API nomenclature and documentation phrasing explicitly guides AI code generators away from making incorrect assumptions.
1. **Challenging the performance limits of browser frameworks** (48:00) — Why developers should experiment with high-performance tooling to shift expectations about what large-scale web applications can handle.

## Related Moments

- [Benchmarking WebAssembly rendering speed versus mainstream frameworks](https://www.wearedevelopers.com/videos/1111-rust-beyond-systems-revolutionizing-web-development) (from "Rust Beyond Systems: Revolutionizing Web Development")
- [Boosting Figma rendering performance by targeting direct WebAssembly execution](https://www.wearedevelopers.com/videos/1149-webassembly-revolution-elevating-javascript-s-reach-and-performance) (from "WebAssembly Revolution: Elevating JavaScript's Reach and Performance")
- [Evaluating performance differences between WebAssembly and JavaScript](https://www.wearedevelopers.com/videos/871-wasm-deep-dive-a-glance-behind-the-scenes) (from "Wasm Deep Dive - A Glance Behind the Scenes")
- [Expanding JavaScript horizons with WebAssembly and backend possibilities](https://www.wearedevelopers.com/videos/118-how-to-stop-choosing-javascript-frameworks-and-start-living) (from "How to Stop Choosing JavaScript Frameworks and Start Living")
- [Rendering high-performance data visualizations in web browsers](https://www.wearedevelopers.com/videos/1794-wearedevelopers-live-from-javascript-to-webassembly-high-performance-charting-and-more) (from "WeAreDevelopers LIVE – From JavaScript to WebAssembly, High-Performance Charting and More")
- [Transitioning native desktop graphics implementations to the web](https://www.wearedevelopers.com/videos/1794-wearedevelopers-live-from-javascript-to-webassembly-high-performance-charting-and-more) (from "WeAreDevelopers LIVE – From JavaScript to WebAssembly, High-Performance Charting and More")

## Related Articles

- [The Fastest JavaScript Charts - Built for React and Beyond](https://www.wearedevelopers.com/magazine/636-the-fastest-javascript-charts-built-for-react-and-beyond)
- [Dev Digest 139 - Soft and hard queries](https://www.wearedevelopers.com/magazine/487-dev-digest-139-soft-and-hard-queries)
- [Dev Digest 133 - Back to Front](https://www.wearedevelopers.com/magazine/474-dev-digest-133-back-to-front)
- [Dev Digest 112 - The True Crime of AI Development](https://www.wearedevelopers.com/magazine/421-dev-digest-112-the-true-crime-of-ai-development)

## Related Jobs

- [Software Engineer, Fullstack](https://www.wearedevelopers.com/jobs/48415-software-engineer-fullstack) at **Sciforium**
- [Senior Software Engineer, Angular](https://www.wearedevelopers.com/jobs/ext/2796428-senior-software-engineer-angular) at **Bitpanda**
- [Staff SoC Performance Architect - Next-Generation Server Platforms](https://www.wearedevelopers.com/jobs/ext/1916643-staff-soc-performance-architect-next-generation-server-platforms) at **ARM**
- [Principal Software Engineer, AI Inference Runtime](https://www.wearedevelopers.com/jobs/ext/2854958-principal-software-engineer-ai-inference-runtime) at **ARM**
- [Senior AI Frontend Engineer](https://www.wearedevelopers.com/jobs/ext/2552851-senior-ai-frontend-engineer) at **TeamViewer Germany GmbH,**
- [GPU Cluster Engineer, Systems & Platform](https://www.wearedevelopers.com/jobs/48411-gpu-cluster-engineer-systems-platform) at **Sciforium**