pith. sign in

arxiv: 2606.26533 · v1 · pith:KMDIVFJBnew · submitted 2026-06-25 · 💻 cs.RO

OSC2Runner: OpenSCENARIO 2.x Compliant High-Fidelity AV Simulation in CARLA

Thoshitha Gamage , Lasanthi Gamage This is my paper

Pith reviewed 2026-06-26 05:36 UTC · model grok-4.3

classification 💻 cs.RO
keywords OpenSCENARIO 2.xCARLA simulatorautonomous vehicle testingbehavior treesscenario-based testingtranspilerdeterministic simulation
0
0 comments X

The pith

OSC2Runner compiles OpenSCENARIO 2.x DSL into deterministic py_trees for native CARLA execution.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper introduces OSC2Runner as the first orchestration framework that maps the OpenSCENARIO v2.x domain-specific language directly onto the CARLA simulator. It achieves the mapping by treating scenario translation as a compilation pipeline that runs through a multi-pass transpiler to produce type-safe abstract syntax trees and then dynamic deterministic behavior trees. These trees connect straight to CARLA's atomic APIs instead of relying on static trajectory playback or legacy interpreters. A sympathetic reader would care because the approach removes spatiotemporal drift, event latencies, and kinematic snapping that previously limited the reliability of scenario-based testing for autonomous vehicles. The result supplies the deterministic execution layer needed for co-simulation, hardware-in-the-loop setups, and automated scenario generation.

Core claim

OSC2Runner formalizes scenario translation as a compilation pipeline through a multi-pass transpiler architecture. The architecture synthesizes type-safe Abstract Syntax Trees directly into dynamic deterministic behavior trees natively mapped to CARLA's atomic APIs. Empirical validation in highly concurrent adversarial case studies demonstrates tick-by-tick determinism, exact spatial trigger evaluation, and 100.0 ms cross-actor blackboard synchronization, while kinematic analysis confirms strict adherence to continuous environmental boundaries.

What carries the argument

The multi-pass transpiler architecture that converts OpenSCENARIO v2.x DSL into type-safe ASTs and then into py_trees behavior trees mapped to CARLA atomic APIs.

If this is right

  • Scenario-Based Testing moves from approximate behavioral interpretation to mathematically rigorous execution.
  • The deterministic backend supports co-simulation and hardware-in-the-loop testing.
  • Automated LLM-driven generation pipelines gain a reliable execution target.
  • Kinematic analysis shows strict adherence to continuous environmental boundaries in all tested cases.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The same transpiler pattern could be adapted to other simulators that expose atomic APIs, extending deterministic execution beyond CARLA.
  • Tick-by-tick determinism may allow testing pipelines to replace statistical sampling with exhaustive replay of critical scenarios.
  • The blackboard synchronization mechanism could serve as a template for multi-agent coordination in other real-time simulation domains.

Load-bearing premise

The multi-pass transpiler correctly synthesizes type-safe ASTs into py_trees that preserve exact OpenSCENARIO v2.x semantics when mapped to CARLA atomic APIs without introducing spatiotemporal drift or asynchronous latencies.

What would settle it

Execute a set of highly concurrent adversarial scenarios and verify whether every spatial trigger evaluates to the exact expected value on each simulation tick and whether any kinematic snapping or timing drift appears in the recorded trajectories.

Figures

Figures reproduced from arXiv: 2606.26533 by Lasanthi Gamage, Thoshitha Gamage.

Figure 1
Figure 1. Figure 1: The 3-stage OSC2Runner Execution Pipeline mapping DSL Definitions to CARLA Behaviors [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Overview of Case Study 1: (a) simulation state following the declarative initialization phase, and (b) both vehicles [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Longitudinal telemetry of the ego vehicle during the baseline scenario, demonstrating the correlation between [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Spatial Trigger Precision: The exact simulation tick where the continuously evaluated longitudinal distance drops [PITH_FULL_IMAGE:figures/full_fig_p008_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Kinematic evaluation of OSC2 semantic rate profiles, contrasting npc’s [PITH_FULL_IMAGE:figures/full_fig_p009_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Blackboard Event Latency: Telemetry isolating the synchronization handoff between the adversarial [PITH_FULL_IMAGE:figures/full_fig_p010_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Side-by-side visualization of the simulated environment for Case Study 2, contrasting baseline (a) and degraded [PITH_FULL_IMAGE:figures/full_fig_p010_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: Longitudinal telemetry for Case Study 2, demonstrating the ego vehicle’s velocity and throttle response across dry/asap [PITH_FULL_IMAGE:figures/full_fig_p011_8.png] view at source ↗
Figure 9
Figure 9. Figure 9: Filtered kinematic adherence analysis for Case Study 2, contrasting the acceleration (blue) and jerk (red) profiles [PITH_FULL_IMAGE:figures/full_fig_p012_9.png] view at source ↗
Figure 10
Figure 10. Figure 10: Braking performance evaluation plotting ego vehicle speed against stopping distance. The graph isolates the spatial [PITH_FULL_IMAGE:figures/full_fig_p013_10.png] view at source ↗
read the original abstract

Scenario-Based Testing predominantly relies on the legacy ASAM OpenSCENARIO 1.x XML standard because existing continuous simulation frameworks lack native execution support for the recently matured v2.x Domain-Specific Language (DSL). Adapting legacy interpreters to evaluate v2.x logic introduces spatiotemporal drift, asynchronous event latencies, and artificial kinematic snapping. Addressing this execution gap, OSC2Runner introduces the first orchestration framework capable of natively mapping the OpenSCENARIO v2.x DSL to CARLA. The framework achieves this by formalizing scenario translation as a compilation pipeline through a multi-pass transpiler architecture. Bypassing static trajectory playback, the architecture synthesizes type-safe Abstract Syntax Trees directly into dynamic deterministic behavior trees (py_trees) natively mapped to CARLA's atomic APIs. Empirical validation in highly concurrent adversarial case studies demonstrates tick-by-tick determinism, exact spatial trigger evaluation, and 100.0 ms cross-actor blackboard synchronization. Kinematic analysis proves the strict adherence to continuous environmental boundaries. This architecture transitions Scenario-Based Testing from approximate behavioral interpretation to mathematically rigorous execution, establishing the deterministic backend required for co-simulation, hardware-in-the-loop testing, and automated LLM-driven generation pipelines.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

1 major / 0 minor

Summary. The manuscript presents OSC2Runner, a framework for natively executing OpenSCENARIO 2.x DSL scenarios in CARLA. It uses a multi-pass transpiler to synthesize type-safe ASTs into dynamic py_trees mapped to CARLA atomic APIs, bypassing static trajectory playback. Empirical validation in concurrent adversarial cases shows tick-by-tick determinism, exact spatial trigger evaluation, 100 ms blackboard synchronization, and kinematic boundary adherence, claiming this establishes mathematically rigorous execution for scenario-based testing, co-simulation, and LLM-driven pipelines.

Significance. If the transpiler preserves exact v2.x semantics without introducing drift or latency, the work would provide a practical deterministic backend that addresses longstanding limitations of 1.x interpreters, enabling more reliable hardware-in-the-loop testing and automated scenario generation in autonomous vehicle research.

major comments (1)
  1. [Abstract] Abstract: The central claim that the architecture transitions Scenario-Based Testing to 'mathematically rigorous execution' and that 'kinematic analysis proves the strict adherence' is not supported by a formal semantic mapping, bisimulation, or equivalence proof between OpenSCENARIO 2.x constructs (including complex event chains and spatial triggers) and the generated py_trees. Only empirical results from selected adversarial cases are described, which cannot rule out untested divergences in timing, state updates, or nondeterministic scheduling as noted in the stress-test concern.

Simulated Author's Rebuttal

1 responses · 0 unresolved

We thank the referee for the detailed feedback. We address the concern regarding the abstract claims below.

read point-by-point responses

  1. Referee: [Abstract] Abstract: The central claim that the architecture transitions Scenario-Based Testing to 'mathematically rigorous execution' and that 'kinematic analysis proves the strict adherence' is not supported by a formal semantic mapping, bisimulation, or equivalence proof between OpenSCENARIO 2.x constructs (including complex event chains and spatial triggers) and the generated py_trees. Only empirical results from selected adversarial cases are described, which cannot rule out untested divergences in timing, state updates, or nondeterministic scheduling as noted in the stress-test concern.

    Authors: We agree that the abstract overstates the contribution by using the phrases 'mathematically rigorous execution' and 'kinematic analysis proves the strict adherence' without providing a formal semantic mapping, bisimulation, or equivalence proof. The validation relies on empirical results from selected adversarial cases, which do not constitute a complete proof against all possible divergences. We will revise the abstract to remove these stronger claims and instead describe the empirical demonstration of tick-by-tick determinism, exact trigger evaluation, and boundary adherence in the evaluated scenarios. revision: yes

Circularity Check

0 steps flagged

No circularity: software architecture paper with empirical validation and no derivations or self-referential fits

full rationale

The manuscript describes an orchestration framework and multi-pass transpiler for mapping OpenSCENARIO v2.x to CARLA behavior trees. It presents empirical results on determinism and synchronization but contains no equations, fitted parameters, predictions derived from subsets of data, or load-bearing self-citations. The central claim of 'mathematically rigorous execution' is supported by tick-by-tick testing rather than any self-definitional reduction or ansatz smuggled via prior work. No step reduces by construction to its own inputs; the architecture is presented as an engineering artifact whose correctness is externally falsifiable via the reported adversarial cases. This matches the default expectation of a non-circular systems paper.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

No mathematical content, free parameters, axioms, or invented entities are present in the abstract; the work is a software engineering contribution.

pith-pipeline@v0.9.1-grok · 5743 in / 1026 out tokens · 17190 ms · 2026-06-26T05:36:15.063386+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

23 extracted references · 3 canonical work pages

  1. [1]

    Driving to Safety: How Many Miles of Driving Would it take to Demonstrate Autonomous Vehicle Reliability?

    N. Kalra and S. M. Paddock, “Driving to Safety: How Many Miles of Driving Would it take to Demonstrate Autonomous Vehicle Reliability?”Transportation Research Part A: Policy and Practice, vol. 94, pp. 182–193, 2016

    2016

  2. [2]

    CARLA: An Open Urban Driving Simulator,

    A. Dosovitskiy, G. Ros, F. Codevilla, A. Lopez, and V . Koltun, “CARLA: An Open Urban Driving Simulator,” in Proceedings of the 1st Annual Conference on Robot Learning, 2017, pp. 1–16

    2017

  3. [3]

    ASAM OpenSCENARIO XML,

    ASAM, “ASAM OpenSCENARIO XML,” 2020. [Online]. Available: https://www.asam.net/standards/detail/ openscenario-xml/

    2020

  4. [4]

    ASAM OpenSCENARIO DSL 2.1.0,

    ——, “ASAM OpenSCENARIO DSL 2.1.0,” 2024. [Online]. Available: https://www.asam.net/standards/detail/ openscenario-dsl/

    2024

  5. [5]

    ScenarioRunner for CARLA,

    CARLA Team, “ScenarioRunner for CARLA,” 2024. [Online]. Available: https://github.com/carla-simulator/scenario_ runner

    2024

  6. [6]

    Parr,The Definitive ANTLR 4 Reference

    T. Parr,The Definitive ANTLR 4 Reference. Raleigh, North Carolina: The Pragmatic Bookshelf, 2013, torrossa Resource ID: 5241753

    2013

  7. [7]

    Colledanchise and P

    M. Colledanchise and P. Ögren,Behavior Trees in Robotics and AI: An Introduction. CRC Press, 2018

    2018

  8. [8]

    Scenic: A Language for Scenario Specification and Scene Generation,

    D. J. Fremont, T. Dreossi, S. Ghosh, X. Yue, A. L. Sangiovanni-Vincentelli, and S. A. Seshia, “Scenic: A Language for Scenario Specification and Scene Generation,” inProceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation, 2019, pp. 63–78

    2019

  9. [9]

    GeoScenario: An Open DSL for Autonomous Driving Scenario Representation,

    R. Queiroz, C. Berger, and K. Czarnecki, “GeoScenario: An Open DSL for Autonomous Driving Scenario Representation,” in2019 IEEE Intelligent Vehicles Symposium (IV). IEEE, 2019, pp. 287–294

    2019

  10. [10]

    Paracosm: A Test Framework for Autonomous Driving Simulations,

    R. Majumdar, A. Mathur, M. Pirron, L. Stegner, and D. Zufferey, “Paracosm: A Test Framework for Autonomous Driving Simulations,” pp. 172–195, 2021

    2021

  11. [11]

    PMSF py-osc2 Framework,

    P. R. Mai, “PMSF py-osc2 Framework,” 2024. [Online]. Available: https://github.com/PMSFIT/py-osc2 15

    2024

  12. [12]

    Declarative Scenario-based Testing with RoadLogic,

    E. Bartocci, A. Gambi, F. Gigler, and D. Nickovic, “Declarative Scenario-based Testing with RoadLogic,”arXiv preprint arXiv:2603.09455, 2026

    work page arXiv 2026

  13. [13]

    The Y ASE Framework: Holistic Scenario Modeling with Behavior Trees,

    M. P. Bauer, A. Ngo, and M. Resch, “The Y ASE Framework: Holistic Scenario Modeling with Behavior Trees,” in2021 IEEE 94th Vehicular Technology Conference (VTC2021-Fall), 2021, pp. 1–7

    2021

  14. [14]

    System-level Simulation-based Verification of Autonomous Driving Systems with the VIV AS Framework and CARLA Simulator,

    S. Goyal, A. Griggio, and S. Tonetta, “System-level Simulation-based Verification of Autonomous Driving Systems with the VIV AS Framework and CARLA Simulator,”Science of Computer Programming, vol. 242, p. 103253, 2025

    2025

  15. [15]

    BeSimulator: A Large Language Model Powered Text-based Behavior Simulator,

    J. Wang, B. Li, J. Qi, X. Wang, F. Li, and H. Li, “BeSimulator: A Large Language Model Powered Text-based Behavior Simulator,”arXiv preprint arXiv:2409.15865, 2024

    work page arXiv 2024

  16. [16]

    Text2Scenario: Text-Driven Scenario Generation for Autonomous Driving Test,

    X. Cai, X. Bai, Z. Cui, D. Xie, D. Fu, H. Yu, and Y . Ren, “Text2Scenario: Text-Driven Scenario Generation for Autonomous Driving Test,” pp. 102—-127, 2026

    2026

  17. [17]

    Language Conditioned Traffic Generation,

    S. Tan, B. Ivanovic, X. Weng, M. Pavone, and P. Kraehenbuehl, “Language Conditioned Traffic Generation,” 2023. [Online]. Available: https://arxiv.org/abs/2307.07947

    work page arXiv 2023

  18. [18]

    Chat2scenario: Scenario Extraction from Dataset through Utilization of Large Language Model,

    Y . Zhao, W. Xiao, T. Mihalj, J. Hu, and A. Eichberger, “Chat2scenario: Scenario Extraction from Dataset through Utilization of Large Language Model,” in2024 IEEE intelligent vehicles symposium (IV). IEEE, 2024, pp. 559–566

    2024

  19. [19]

    LeGEND: A Top-Down Approach to Scenario Generation of Autonomous Driving Systems Assisted by Large Language Models,

    S. Tang, Z. Zhang, J. Zhou, L. Lei, Y . Zhou, and Y . Xue, “LeGEND: A Top-Down Approach to Scenario Generation of Autonomous Driving Systems Assisted by Large Language Models,” inProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering (ASE), 2024, pp. 1497–1508

    2024

  20. [20]

    Rajamani,Vehicle Dynamics and Control, 2nd ed

    R. Rajamani,Vehicle Dynamics and Control, 2nd ed. New York, NY: Springer Science & Business Media, 2011

    2011

  21. [21]

    Autoware on Board: Enabling Autonomous Vehicles with Embedded Systems,

    S. Kato, S. Tokunaga, Y . Maruyama, S. Maeda, M. Hirabayashi, Y . Kitsukawa, A. Monrroy, T. Ando, Y . Fujii, and T. Azumi, “Autoware on Board: Enabling Autonomous Vehicles with Embedded Systems,” in2018 ACM/IEEE 9th International Conference on Cyber-Physical Systems (ICCPS). IEEE, 2018, pp. 287–296

    2018

  22. [22]

    AUTOSAR-Compatible Level-4 Virtual ECU for the Verification of the Target Binary for Cloud-Native Development,

    J. Choiet al., “AUTOSAR-Compatible Level-4 Virtual ECU for the Verification of the Target Binary for Cloud-Native Development,”Electronics, vol. 13, no. 18, p. 3704, 2024

    2024

  23. [23]

    Digital Twin-Based Evaluation of Vehicular Controller Area Network Intrusion Detection Systems,

    S. Ahmedet al., “Digital Twin-Based Evaluation of Vehicular Controller Area Network Intrusion Detection Systems,” International Journal on Perceptive and Cognitive Computing, vol. 11, no. 1, 2025

    2025