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

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

← Home