Scientific Computing is Exploratory

• Scientists and engineers don’t just write software — they explore
• They iterate rapidly: write code, run it, visualize, inspect, repeat

Interpreted Languages Dominate This Space

• Tools like Python and R excel due to their REPL-driven workflows
• C++ is powerful, but its compile-run-debug loop is friction-heavy

C++ in a REPL = The Best of Both Worlds

• Projects like Cling showed that interactive C++ is possible
• C++ in a REPL format opens doors for teaching, rapid prototyping, and scientific computing

• cling — https://github.com/root-project/cling
• xeus-cling — https://github.com/jupyter-xeus/xeus-cling
• Blog — https://blog.jupyter.org/interactive-workflows-for-c-with-jupyter-fe9b54227d92
• The above blog received ~500k views, highlighting the demand for interactive C++

What does Xeus even mean ?

• xeus is a C++ library which simplifies the implementation of kernels for Jupyter
• developers can focus on implementing the interpreter part of the kernel
• Tutorial for creating a kernel based on xeus: https://xeus.readthedocs.io/en/latest/kernel_implementation.html
• xeus is architected in components that can be replaced with ad-hoc implementations

Limitations of Cling

• Based on an outdated version of Clang
• Limited capabilities and compatibility with modern C++ features
• Hard to maintain on all the platforms

xeus-cpp, based on Clang

• Recent versions of Clang incorporated REPL in their codebase
• Extensible architecture based on plugins
• Supports modern versions of C++, and many features (CUDA, python)

Clang-Repl on Native Platforms

• Uses LLVM’s ORC JIT for runtime compilation
• Compiles code & executes directly from memory

Clang-Repl in the Browser

• WebAssembly enforces a strict sandbox model
• Can’t write or modify executable memory at runtime
• Memory is separated into code and data (Harvard architecture)

LLVM 17 introduced a WASM-specific IncrementalExecutor that avoids LLVM's ORC JIT

The new WasmIncrementalExecutor handles the wasm execution as follows:

• Each REPL input is parsed into a Partial Translation Unit (PTU)
• PTU is lowered to LLVM IR, then compiled to a WASM object file
• The object is linked with wasm-ld into a standalone binary (incr_module_x.wasm)
• The side module is dynamically loaded with emscripten’s dlopen, extending the main module

These modules:

• Share the same memory as the main wasm module
• Resolve symbols from earlier cells (cross-cell linking)
• Mimic dynamic linking, even though WASM doesn’t support shared libraries traditionally

🚀 This model effectively turned Clang-Repl into a live REPL for WebAssembly, enabling dynamic incremental C++ in the browser!

• Last Value Printing
• Debugger Support
• CUDA Support
• Python Interoperatability

Compiler Research Group

Google Summer of Code

Scan for slides