RepliCore: Reproducible Parallel Simulation under Asynchronous Browser Runtimes
summary
The gist
Browser-based simulations execute over asynchronous runtime mechanisms including event loops, rendering callbacks, and independently scheduled Web Workers…
In short
RepliCore addresses reproducibility issues in large-scale browser simulations running over asynchronous runtimes like Web Workers. It achieves this by stabilizing logical-state visibility, ensuring that rendering and workers only observe fully committed simulation states after each logical step. This method guarantees identical simulation results across varied scheduling and timing conditions.
Key concepts
- Logical-Time Visibility Boundaries
- Instead of relying on unpredictable physical execution timing, the system uses 'logical time' to define explicit step boundaries. Simulation updates are only made visible externally once the logical progression reaches a stable boundary at a specific logical step. This decouples state changes from asynchronous runtime scheduling.
- Determinism in State Updates
- Consistent simulation progression requires that every update derives from the same committed snapshot of the simulation state ($S_k$). The runtime ensures that updates only occur deterministically over defined logical-time intervals ($ riangle t$), preventing partially completed updates from becoming visible before stabilization.
- Parallel Partitioned Execution
- The global simulation state is split into independent partitions, each handled by a separate Worker. Workers perform local state updates on their partition during one logical step. Only after these local updates are collected and combined is the next global state constructed, ensuring isolation before publication.
Terminology used across episodes
This episode discusses
- RepliCore: Reproducible Parallel Simulation under Asynchronous Browser Runtimes · Paper Radio
- Distributed Order Recording Techniques for Efficient Record-and-Replay of Multi-threaded Programs
- Engineering Record And Replay For Deployability: Extended Technical Report
- A large-scale distributed parallel discrete event simulation engines based on Warped2 for Wargaming simulation
The paper
RepliCore: Reproducible Parallel Simulation under Asynchronous Browser Runtimes · Read on arXiv
Anqing Chena
School of Computer Engineering, Chengdu Technological University
DOI: 10.1016/j.simpat.2026.103378
Transcript
Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.
Tom: I'm Tom.
Jane: And I'm Jane, here with Lu, Meng and our in-house large language model, Lalam.
Tom: We're looking at the paper: "RepliCore: Reproducible Parallel Simulation under Asynchronous Browser Runtimes".
Jane: Here's the gist of the paper. Browser-based simulations execute over asynchronous runtime mechanisms including event loops, rendering callbacks, and independently scheduled Web Workers, causing simulation progression to depend on runtime timing and callback scheduling behavior <ref:2607.02529#pg2> The framework prevents rendering callbacks and asynchronous runtime tasks from observing transient intermediate logical states during parallel progression <ref:2607.02529#pg2> These results indicate that reproducible asynchronous parallel simulation can be achieved through controlled logical-state visibility stabilization without relying on execution replay or explicit schedule control <ref:2607.02529#pg2> Problem Formulation and Model Large-scale browser-oriented simulations commonly execute over asynchronous runtime environments in which simulation states may become externally visible at different physical times across executions due to independently progressing Workers, rendering callbacks, and event-loop scheduling <ref:2607.02529#pg2> The execution model should satisfy the following requirements: 1.
Tom: Reproducible execution: repeated runs initialized from the same state should produce identical committed simulation states <ref:2607.02529#pg2> 2.
Jane: Sequential-parallel consistency: parallel execution should preserve the same logical state progression as sequential execution <ref:2607.02529#pg2> 3.
Tom: Scheduling tolerance: Worker scheduling and callback timing variations should not alter committed simulation states <ref:2607.02529#pg2> 4.
Paper summary: Tom: So, to recap, RepliCore is proposing this separation between the internal logic progression and external visibility. They are showing that you can achieve reproducible parallel simulation by making sure rendering callbacks and other asynchronous tasks only observe completed logical simulation states, not the messy intermediate stuff happening in parallel >
Jane: That makes sense for a listener who just wants to understand it. If I imagine I'm watching a complex simulation unfold on my screen, I don't want the screen to flicker or show half-baked parts of what's supposed to be the next step, right? RepliCore seems to be building a gate around that visibility >
Lu: They are analyzing how asynchronous browser runtime activities introduce this nondeterministic logical-state visibility during parallel simulation execution, and then they propose a specific model for stabilization. It’s less about controlling the physical timing and more about controlling the logical exposure points >
Meng: I'm curious about how their model handles things that happen in parallel but interact closely. If two workers are updating overlapping parts of the state, how does this logical-state stabilization work without locking everything down so hard that we lose all our parallelism?
Lalam: The paper shows that the global simulation state is divided into disjoint partitions, and each worker updates its local data during a logical-time step, but only after those local updates are collected and combined do you get the next committed global state >
Tom: That sounds like a lot of coordination. So, what's the actual proof they give us that this approach works? What's the evidence for this reproducibility across different scheduling environments?
Jane: They tested it by evaluating varying Worker configurations and asynchronous runtime conditions. The key result is that they demonstrated reproducible execution behavior across changes in Worker scheduling, rendering frequency, and parallel execution scale while maintaining stable scalability for large simulation workloads >
Lu: What really stands out is the experimental evidence showing identical trajectory hashes and bitwise-identical simulation states across repeated executions, even when you mess with the timing perturbations or the specific Worker scheduling used >
Meng: That's strong. So, if I'm shipping this to production, I need to know that this doesn't just work in a perfectly controlled lab setting but holds up when things get messy with real-world traffic and varied scheduling >
Lalam: Exactly. They show that reproducibility depends strongly on controlling externally observable logical-state exposure under asynchronous runtime conditions >
Conclusion: Tom: So, wrapping up this talk on "RepliCore: Reproducible Parallel Simulation under Asynchronous Browser Runtimes." The authors are essentially arguing that you can achieve reproducible parallel simulation in a browser environment by controlling the state publication points based on logical time, rather than trying to perfectly control every single physical timing event >
Jane: It boils down to this: they proved that by making sure rendering and other background tasks only see the fully committed logical states, you get consistent results regardless of how fast or slow those underlying asynchronous parts are running >
Lu: The model they propose is a logical-state visibility stabilization model. It’s a way to enforce determinism where the environment itself introduces variability through things like event loops and independently scheduled workers >
Meng: For me, the implication is that for large simulations, we can build systems that scale by adding more workers without worrying about state divergence caused by those asynchronous runtime factors, as long as we respect this logical time boundary >
Lalam: The main thing to remember is that this works within a fixed browser engine and numerical runtime environment; they don't claim it solves problems across totally different computer architectures or hardware differences yet >
Tom: Right. So the paper shows that controlled state publication under asynchronous Worker execution and rendering activity can lead to stable, reproducible execution, which is practical for large-scale browser simulations >
More episodes
- 2505.16254-Human-AI Writing as Distributed Cognition: Reassessing Collaborative Writing Theories in the Age of LLMs
- 2506.10913-Choreographic Quick Changes: First-Class Location (Set) Polymorphism
- 2507.14812-A Black-Box Approach for Exogenous Replenishment in Online Resource Allocation
- 2507.15448-Frames over finite fields with respect to the Galois inner product and their connections to self-orthogonal and LCD codes
- 2508.21572-NewsReX: An Open-Source Multi-Framework for Neural News Recommendation
- 2509.17028-Impact of Packetization on Network Calculus Analysis
- 2510.17342-AoA Services in 5G Networks: A Framework for Real-World Implementation and Systematic Testing
- 2511.04088-Efficient and rate-optimal list-decoding in the presence of minimal feedback
- 2511.17264-Notes on Stack Machines and Quantum Stack Machines
- 2601.15318-On the closest balanced game