RepliCore: Reproducible Parallel Simulation under Asynchronous Browser Runtimes

arXiv:2607.02529 · cs.DC · Submitted 2026-05-28 · Read on arXiv

Listen

Radio episode about this paper

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 >

Anqing Chena

School of Computer Engineering, Chengdu Technological University

cs.DC

Submitted: 2026-05-28

Updated: 2026-07-15

Comments: 14 pages, 2 figures, 5 tables

Journal ref: Simulation Modelling Practice and Theory 154 (2027) 103378

DOI: 10.1016/j.simpat.2026.103378

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 80/100

The gist: Browser-based simulations execute over asynchronous runtime mechanisms including event loops, rendering callbacks, and independently scheduled Web Workers…

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

Summary

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. p. 002529#pg2> The framework prevents rendering callbacks and asynchronous runtime tasks from observing transient intermediate logical states during parallel progression <ref:2607. p. 0 p. 002529#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. p. 002529#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. Reproducible execution: repeated runs initialized from the same state should produce identical committed simulation states <ref:2607. p. 302529#pg2>

  2. Sequential-parallel consistency: parallel execution should preserve the same logical state progression as sequential execution <ref:2607. p. 302529#pg2>

  3. Scheduling tolerance: Worker scheduling and callback timing variations should not alter committed simulation states <ref:2607. p. 302529#pg2>

  4. Rendering separation: rendering stages should observe only completed logical simulation states <ref:2607. p. 302529#pg2>

  5. Parallel scalability: increasing Worker parallelism should not introduce additional state divergence <ref:2607. p. 302529#pg2>

Logical-Time Visibility Boundaries

Simulation progression cannot rely directly on physical execution timing because browser Workers and rendering callbacks advance independently under asynchronous runtime scheduling <ref:2607.02529#pg2> Logical time defines explicit step boundaries shared across Workers, state updates, and rendering stages <ref:2607. p. 402529#pg2> Updated simulation states become externally visible only after logical-state progression reaches a stable boundary at the current logical step <ref:2607. p. 402529#pg2>

Determinism in State Updates

Consistent logical-state progression requires all logical-time updates to derive from the same committed simulation-state snapshot <ref:2607.02529#pg2> Let S k denote the committed simulation state at logical time tk <ref:2607. p. 402529#pg2> At each logical-time advancement, the runtime derives the next committed state through deterministic state propagation over the logical-time interval ∆t <ref:2607. p. 402529#pg2> This update model prevents partially completed updates from becoming externally visible before logical-state progression stabilizes <ref:2607. p. 402529#pg2>

Parallel Partitioned Execution

State coordination under asynchronous runtime execution requires partition-local updates to remain isolated before the next committed state is published <ref:2607.02529#pg2> The global simulation state is divided into disjoint partitions S k = Σ i=1 S (i) k <ref:2607. p. 402529#pg2> Each partition is executed by an independent Worker and performs local state updates on partition-local simulation data during the current logical-time step <ref:2607. p. 402529#pg2> After partition-local updates for the current logical-time step have been collected, the runtime combines these resulting partition states to construct the next global state <ref:2607. p. 402529#pg2>

Rendering Decoupling

Rendering behavior is decoupled from logical simulationstate progression under asynchronous browser runtime execution <ref:2607.02529#pg2> Rendering observes only committed logical-time snapshots produced after coordinated state commitment <ref:2607. p. 702529#pg2> This separation prevents rendering callback timing from influencing inconsistent state sampling and logical-time visibility progression across browser runtime environments <ref:2607. p. 702529#pg2>

Experimental Evidence of Reproducibility

The experiment evaluates whether simulation execution remains reproducible under varying runtime scheduling and rendering conditions <ref:2607.02529#pg2> All evaluated configurations produced identical trajectory hashes and bitwise-identical simulation states across repeated executions <ref:2607. p. 802529#pg2> Across all evaluated configurations, repeated executions produced identical outputs despite variations in Worker scheduling, rendering frequency, and injected timing perturbations <ref:2607. p. 9 p. 902529#pg2>

Trade-offs and Applicability

Maintaining coordinated state publication under asynchronous runtime execution introduces several structural trade-offs <ref:2607.02529#pg2> Coordinated logical-time commitment reduces the ability of Workers to expose intermediate simulation states independently <ref:2607. p. 402529#pg2> RepliCore is most suitable for simulation workloads in which entities can be partitioned into relatively stable execution regions and updated independently during a logical step <ref:2607. p. 802529#pg2> The model becomes less effective when simulation behavior depends heavily on rapidly changing cross-partition interaction or fine-grained shared-state communication <ref:2607. p. 702529#pg2>

Conclusion

The results suggest that reproducible parallel simulation in browser runtime environments can be achieved through controlled state publication under asynchronous Worker execution and rendering activity <ref:2607.02529#pg2> The evaluation shows stable and reproducible execution across varying Worker configurations, rendering frequencies, and injected runtime perturbations within a fixed browser runtime environment <ref:2607. p. 102529#pg2> RepliCore remains practical for large-scale browser-oriented simulation workloads while preserving responsive rendering behavior <ref:2607. p. 902529#pg2>

Acknowledgment

During the preparation of this work the author used ChatGPT in order to improve the clarity and readability of this manuscript <ref:2607.02529#pg2> The author reviewed and edited the content as needed and takes full responsibility for the content of the publication <ref:2607.02529#pg2>

References

[1] WHATWG, Html living standard: Event loop, https://html.spec.whatwg.org/multipage/webappapis.html (Page 1)

[2] L. Gonnord, L. Henrio, L. Morel, G. Radanne, A survey on parallelism and determinism, ACM Computing Surveys 55 (10) (2023) Article 210

[3] R. D. Peng, Reproducible research in computational science, Science 334 (6060) (2011) 1226–1227

[4] C. Collberg, T. Proebsting, Repeatability in computer systems research, Communications of the ACM 59 (3) (2016) 62–69

[5] B. Antunes, D. R. C. Hill, Reproducibility, replicability and repeatability: A survey of reproducible research with a focus on high performance computing, Computer Science Review 53 (2024) 100655

[6] A. J. Bernstein, Analysis of programs for parallel processing, IEEE Transactions on Electronic Computers EC-15 (5) (1966) 757–763

[7] M. Herlihy, N. Shavit, V. Luchangco, M. Spear, The art of multiprocessor programming, 2nd Edition, Morgan Kaufmann, Cambridge, MA (Page 1)

[8] V. Stodden, M. McNutt, D. H. Bailey, E. Deelman, Y. Gil, B. Hanson

[9] J. Dongarra, P. Beckman, T. Moore

[10] K. S. Perumalla, Parallel and distributed simulation: Traditional techniques and recent advances, in: Proceedings of the 2006 Winter Simulation Conference (WSC 2006), 84–95

[11] L. Costa, S. Barbosa, J. Cunha

[13] R. L. Bocchino, V. S. Adve, D. Dig

[14] E. Lee, The problem with threads, Computer 39 (5) (2006) 33–42

[15] A. Aviram, S.-C. Weng, S. Hu, B. Ford

[16] T. J. LeBlanc, J. M. Mellor-Crummey

[17] R. H. B. Netzer, Optimal tracing and replay for debugging shared-memory parallel programs, in: Proceedings of the ACM/ONR Workshop on Parallel and Distributed Debugging, 1993, pp. p. 1 1–11

[18] D. Geels, G. Altekar, P. Maniatis

[19] K. Veeraraghavan, D. Lee, B. Wester

[30] J. B. Dennis, First version of a data flow procedure language, in: Programming Symposium, Proceedings Colloque sur la Programmation, Paris

[31] T. Akidau, R. Bradshaw, C. Chambers

[33] J. Gregory, Game Engine Architecture, 3rd Edition, A K Peters/CRC Press

[34] A. Haas, A. Rossberg, D. L. Schuff

[35] A. Jangda, B. Powers, E. D. Berger

[36] GPU for the Web Working Group, WebGPU, World Wide Web Consortium (W3C), latest version available at https://www.w3.org/TR/webgpu/ (Mar. p. 2 2026)

[1] WHATWG, Html living standard: Event loop, https://html.spec.whatwg.org/multipage/webappapis.html (Page 1)

Pruning redundant reasoning tokens

RepliCore addresses this problem by separating asynchronous runtime progression from externally observable logical-state visibility <ref:2607.02529#pg2> Runtime-visible simulation states are exposed only after logical-state progression becomes externally stable, preventing asynchronous runtime activities from observing partially updated simulation progression <ref:2607. p. 002529#pg2> The framework prevents rendering callbacks and asynchronous runtime tasks from observing transient intermediate logical states during parallel progression <ref:2607.02529#pg2>

How the training signal is built

The model defines simulation progression through logical-time-driven state updates: S k+1 = F(S k, tk) <ref:2607.02529#pg2> State updates are performed only at explicit simulation-step boundaries tk <ref:2607. p. 402529#pg2> All Workers, rendering stages, and subsequent simulation updates therefore observe the same committed logical-time state rather than partially completed intermediate updates <ref:2607. p. 402529#pg2>

Where the gains come from

The evaluation demonstrates reproducible execution behavior across changes in Worker scheduling, rendering frequency, and parallel execution scale while maintaining stable scalability for large simulation workloads <ref:2607.02529#pg2> Across all evaluated configurations, repeated executions produced identical outputs despite variations in Worker scheduling, rendering frequency, and injected timing perturbations <ref:2607.02529#pg2> Relaxing logical-time visibility coordination was associated with measurable execution divergence <ref:2607. p. 902529#pg2> Coordinated step-level state publication preserves reproducible simulation execution across varying Worker and rendering configurations <ref:2607. p. 702529#pg2> Worker-based execution preserves browser responsiveness under increasing simulation scale despite runtime coordination overhead <ref:2607. p. 902529#pg2>

Limitations and Future Work

A central limitation of the proposed execution model is the requirement that state visibility advances only after each logical step reaches a globally consistent state <ref:2607.02529#pg2> As interaction density increases, runtime coordination and communication overhead may grow substantially <ref:2607. p. 902529#pg2> The current implementation targets reproducible execution within a fixed browser engine and numerical runtime environment <ref:2607. p. 502529#pg2> An important next step is exploring whether parts of the visibility-coordination process can be relaxed without reintroducing schedule-dependent divergence <ref:2607. p. 002529#pg2> The current implementation does not attempt to guarantee crossengine equivalence across heterogeneous JavaScript implementations or hardware-dependent floating-point behavior <ref:2607. p. 5

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Control when updated simulation states become externally observable during logical-time progression to prevent asynchronous runtime activities from observing partially updated simulation progression. This prevents transient intermediate logical states from being observed before global progression reaches a stable state, maintaining consistency between parallel and sequential execution.

  2. Implement deterministic partition execution where partition-local updates must operate consistently for the same logical input state. This ensures that Worker scheduling variations do not alter committed simulation states, preserving reproducibility regardless of independent Worker speeds.

  3. Decouple rendering behavior from logical simulation state progression by defining rendering as "Rk = G(S k), G < F where rendering only consumes committed logical-time snapshots produced after coordinated state commitment. This separation prevents rendering stages from sampling partially updated simulation states during logical-step progression," improving stability under varying frame timings.

  4. Utilize a coordination mechanism that delays state publication until all partition-local updates for the current logical step become available, ensuring S k+1 becomes externally visible if and only if all S (i)k+1 are available. This constraint prevents partially updated states from becoming globally visible during parallel execution, safeguarding against divergence caused by asynchronous message delivery timing.

  5. Employ deterministic state construction, using order-independent operations (e.g., commutative and associative reductions) or an explicitly defined merge order, to ensure consistent global-state construction across repeated executions. This stabilizes floating-point accumulation behavior despite asynchronous Worker completion order variations during state merging.

Sources

Related papers