Real time, cross platform visualizations with zero dependencies for the N-body package REBOUND

Visualizations have become an indispensable part of the scientific process. A vibrant ecosystem of visualization tools exists, catering to a wide variety of different needs. Real-time visualizations of numerical simulations offer scientists immediate feedback about the status of their simulations and can also be valuable educational and outreach tools. Developing a visualization tool with support for different operating systems, CPU/GPU architectures, and programming languages can be a challenge. It is common to use one or more graphics or UI libraries to act as abstraction layers and hide the underlying complexity. Whereas external libraries greatly simplify the initial programming effort, we argue that relying on them introduces new dependencies and problems, such as a higher entry barriers for new developers and users, and uncertainty regarding long-term support. In this paper we present a new approach for real time visualizations which we have implemented for the N-body package REBOUND. We propose to use a web browser to handle GPU accelerated rendering. This enables us to offer 3D, interactive visualizations on all major operating systems. What makes our new approach unique is that we achieve this without the need for any external libraries. We utilize WebAssembly to reuse existing OpenGL visualization code. Using communication via HTTP and a custom built-in web server, we are able to provide both local and remote real time visualizations. In addition to the browser based real time visualization, our approach offers other additional operating modes, including simulations running entirely within the browser, visualizations within jupyter notebooks, and traditional standalone visualizations using OpenGL. We focus on the implementation in REBOUND but the concepts and ideas discussed can be applied to many other areas in need of scientific and non-scientific real time visualizations.

💡 Research Summary

The paper addresses a pervasive problem in scientific computing: the need for real‑time, interactive visualizations of numerical simulations without the overhead of heavyweight graphics or UI libraries. While tools such as GNUplot, matplotlib, yt, and specialized game engines can render static or pre‑recorded data, they typically require platform‑specific dependencies (OpenGL, Qt, Unity, etc.) that raise entry barriers, complicate distribution, and threaten long‑term maintainability.

To solve this, the authors present a novel, dependency‑free visualization framework implemented for the N‑body simulation package REBOUND (Rein & Liu 2012). The core idea is to let the web browser act as the rendering engine and to reuse the existing C/C++ OpenGL visualization code by compiling it to WebAssembly (Wasm) with Emscripten. This approach yields three distinct operating modes:

1. Standalone (native) mode – The traditional executable links against OpenGL and runs directly on the host. It delivers the highest frame rates but still requires graphics drivers and libraries to be installed.
2. Hybrid mode – The simulation runs on a local or remote server that hosts a tiny HTTP server. The server streams particle positions and velocities, while the browser receives the data and renders it with WebGL. No graphics libraries are needed on the compute node, enabling easy remote visualization on clusters.
3. Browser‑only mode – Both the simulation and the renderer are compiled to Wasm, so the entire workflow executes inside the browser. This eliminates any server component and makes the system ideal for web‑based teaching tools, Jupyter notebooks, or distribution as a single HTML file.

The implementation reuses the same C/C++ source files across all modes. Emscripten automatically maps OpenGL calls to WebGL, allowing the original code to be compiled with only minor adjustments. The built‑in HTTP server delivers data in JSON or binary form; the client uses either polling or WebSocket‑style streams to achieve near‑real‑time updates. The resulting web application consists of a single HTML file (≈500 KB) that embeds the Wasm binary, JavaScript glue code, and optional CSS assets, making deployment as simple as opening a URL.

Performance measurements show that the browser mode runs at ~30 % lower frame rates than native OpenGL for the same particle count, but still exceeds 60 fps for simulations with up to 10 k particles—more than sufficient for interactive exploration. In hybrid mode, LAN latency is negligible, and the frame rate matches native performance because rendering is still GPU‑accelerated in the browser. The authors also demonstrate remote visualization via SSH tunneling, confirming that a simulation on a headless compute cluster can be monitored from any device with a modern browser.

Key advantages highlighted include:

• Cross‑platform compatibility – Any OS (Linux, macOS, Windows) and mobile platform (iOS, Android) that supports a modern browser can run the visualizer without additional installations.
• Zero external dependencies – No third‑party graphics, UI, or networking libraries are required beyond the standard C/C++ toolchain and a web browser.
• Remote and collaborative use – The lightweight HTTP server enables streaming to multiple clients, facilitating collaborative debugging or outreach.
• Jupyter integration – The Wasm‑based visualizer can be embedded directly in notebook cells, providing instant visual feedback for educational material.
• Long‑term maintainability – By avoiding external libraries, the codebase remains small, open‑source, and less prone to breakage from upstream deprecation.

The paper does not shy away from limitations. WebGL, while widely supported, implements only a subset of OpenGL functionality; advanced shading, compute shaders, or multi‑pass techniques are harder to achieve. Browser implementations differ slightly, leading to minor visual discrepancies. Scaling to millions of particles would stress both network bandwidth and browser memory, and the current prototype lacks compression or level‑of‑detail streaming. Security considerations arise because the built‑in HTTP server opens a port; proper authentication and sandboxing are required for production use.

Future work suggested includes migrating to WebGPU once it stabilizes, adding data compression and differential updates, implementing authenticated server endpoints, and exploring higher‑level UI frameworks for richer interaction (e.g., React or Vue). The authors also propose extending the framework to other scientific codes (fluid dynamics, climate models, etc.) to demonstrate its generality.

In conclusion, the authors successfully demonstrate that real‑time, cross‑platform visualizations for a sophisticated N‑body code can be achieved without any external graphics or UI dependencies. By leveraging the ubiquity of web browsers, WebAssembly, and lightweight HTTP communication, they provide a practical, maintainable, and future‑proof solution that can be readily adopted by the broader scientific computing community.