WorksComputer Science
DynLimit: A Simulation Benchmark for Dynamics-Critical Planning and Control
Abstract
Experiments near vehicle handling limits must keep three questions apart: what a maneuver requests, what the closed-loop system executes, and whether the task is completed. We present DynLimit, a simulation platform that organizes this process end to end. Scenarios are composed from road, friction, obstacle, and reference objects; planners and controllers attach through a shared observation and control interface; a vehicle adapter runs either a license-free four-wheel model or an external dynamics solver; and synchronized records feed task evaluation, replay, and response inspection. The platform carries a task-oriented evaluation method that pairs a prescribed reference demand with a sampled passing set and event-aligned diagnosis. Across eight task families, three friction environments, and three reference-assisted baseline chains we executed 450 runs: 360 nominal, 18 locally refined, and 72 with prescribed initial offsets. Method differences depend on the task family, equal aggregate pass counts arise from different passing cells, and local refinement narrows two sampled transitions without locating a continuous boundary. Two case comparisons show why sideslip or tire-utilization peaks cannot replace task constraints. The three views therefore stay distinct in every reported run: an outcome can be traced from the prescribed demand, through the executed response, to the task rule that decided it. Code is available at https://github.com/Yang2581/dynlimit
Introduction
Evaluation of planning and control near the vehicle handling limit rests on three kinds of evidence that are easily conflated. First, the prescribed maneuver fixes what the road and the reference demand: a speed profile, a curvature, and the resulting accelerations. Second, the closed loop yields the executed response: the vehicle states and tire forces produced, together with the commands applied to obtain them. Third, the task rule decides the outcome: whether the vehicle met its goal without leaving the road, striking an obstacle, missing a gate, or exceeding its deadline. Because the three are recorded on different objects, none follows from another, so a pass count alone neither explains a failure nor locates the condition at which behavior changes. The two same-scenario pairs in Section V-D show how far the views can diverge: in the first, the chain with the larger peak sideslip completes the task while the other violates a geometric constraint.
Obtaining this evidence repeatedly is a systems-engineering problem as much as a modelling one. Each trial is assembled from road geometry, a friction field, obstacles, an initial state, reference information, and an algorithm. The loop must run at declared rates, with controls and states recorded on a common timeline, and each outcome must be decided by the same task rules online and offline. Simulators supply vehicle models and scenario formats, and planning benchmarks supply scenario sets and metrics [1, 2, 3, 4, 5]. The layer between them, an experiment process that keeps these pieces aligned across tasks and algorithms, is still reassembled for most studies and has only recently begun to be automated in parts [6].
This paper presents DynLimit, a simulation platform for dynamics-critical planning and control experiments, together with the task-oriented evaluation method embedded in it. DynLimit is the platform: it owns the scenario objects, the algorithm and vehicle interfaces, the execution schedule, and the records. DynLimit-Bench is the method embedded in that process: reference demand organizes the test set, goals and constraints decide outcomes, and event-aligned records support diagnosis. The quantitative experiments use reference-assisted control, in which every chain receives the same task description and reference while a shared longitudinal controller supplies speed commands; the platform interface itself is not restricted to this setting.
The contributions are threefold. Platform design for dynamics experiments: one experiment interface connects scenario composition, algorithm attachment, vehicle adaptation, execution scheduling, and record inspection, and we describe the interfaces and trade-offs behind it, including how interactive and scripted operation share scenario, controller, and vehicle components. *A task-oriented evaluation method embedded in
@referencesસ્માત ref-1 | article-journal | | | | | | | | | | raw: ref-2 | article-journal | | | | | | | | | | raw: ref-3 | article-journal | | | | | | | | | | raw: ref-4 | article-journal | | | | | | | | | | raw: ref-5 | article-journal | | | | | | | | | | raw: ref-6 | article-journal | | | | | | | | | | raw: that process: each record is reduced to a demand-indexed passing set and a first-failure diagnosis, with stated sampling and tie-breaking conventions. Systematic experiments and case analyses: eight task families, 360 nominal runs, and 90 supplementary runs show batch comparison, local refinement of sampled transitions, and inspection of failures in the recorded response. All quantitative statements are conditional on the declared model, configurations, and finite samples.
Related Work
Dynamics-Aware Simulation Platforms
Platforms for closed-loop driving research differ chiefly in vehicle-model fidelity and in how much of the evaluation they take on. CARLA provides an urban simulator with configurable sensors and controlled scenarios [1]. F1TENTH combines one-tenth-scale hardware with virtual racing tasks [2], and AssettoCorsaGym exposes a commercial racing simulator to reinforcement learning and model predictive control [3]. R-CARLA couples a learning environment with interchangeable vehicle dynamics [7], while multibody solvers such as CarSim supply detailed tire and suspension models for handling studies [8]. These systems show that closed-loop simulation can be scripted across model fidelities. How a result should be read still depends on that model: simplifications change closed-loop trajectory following at different margins to the acceleration limit when assessed against real driving data [9], so declaring the vehicle, actuator, and simulation settings is part of the measurement.
Scenario Organization and Task Evaluation
Work organized around scenarios differs instead in what it fixes: the problem statement and its metric, or the scene alone. CommonRoad makes motion-planning experiments composable through vehicle models, cost functions, and scenarios with goals and constraints [4]. Scenic describes distributions over scenes with declarative constraints [10], MetaDrive and SMARTS organize traffic interaction for learning and evaluation [11], [12], and nuPlan pairs recorded driving with closed-loop planning assessment that accounts for surrounding traffic [5].
Either way, these works fix the problem and the scene before evaluating planners at scale. The question we pursue is narrower and procedural: for a prescribed maneuver family under a declared vehicle and controller configuration, which tested conditions are completed, where do sampled outcomes change, and what response precedes each failure? Answering it requires the scenario objects, the algorithm interface, the execution schedule, and the task rules to stay consistent from run to run. DynLimit is organized around that requirement, and the method it carries reports finite sampled passing sets rather than a capability score.
The DynLimit Platform
DynLimit organizes a dynamics experiment as a configuration, a closed-loop execution, and a record Figure 1. Both experiment entries, the interactive session and the programmatic batch, call the same scene, controller, and vehicle components.
Figure 1. DynLimit architecture. Interactive setup (road, friction, assets, obstacles, initial states, agent policies) and benchmark specification (task family, demand, goals, constraints) define an experiment. Shared simulation components (ego planner or controller, dynamics adapter, motion update) execute it on a selectable backend, and the resulting records feed task evaluation, response diagnostics, and offline inspection.
Architecture and Experiment Interfaces
An experiment is described by declared items: road geometry, friction field, initial vehicle state, reference information, algorithm identifier, vehicle configuration, and execution settings. A task adds a completion goal, geometric constraints, and a deadline. The platform treats all items as data; nothing about a family or level is hard-coded in the loop, which is what allows one execution path to serve the eight families of Section IV. The two entries serve different purposes: interactive operation lets a scenario be examined while it is built and while it runs, whereas scripted operation executes a task matrix without supervision and without operator-dependent variation (Figure 2). Both produce the same record type, so an interactive result can be re-evaluated by the same rules as a batch result.

Figure 2. Programmatic entry. A specification generates a task matrix over families, levels, and chains; the scheduler executes it headlessly and writes one record per run; evaluation, diagnostics, and replay consume the records, and a revision returns to the matrix. The excerpt at right shows the per-run labels used for the batches of Section V. No operator input enters between runs, so a repeated matrix reproduces the same records from the same declared entries.
The interface admits more than these experiments exercise. This paper quantifies one backend, one entry, and three algorithm chains; the UI session, the HTTP interface, interactive agents, and the external solver integration are capabilities we describe as designed behavior, and Table II marks which the reported runs support.
| Capability | Interface and evidence | Coverage |
| Scenario composition | road, reference, obstacle, and friction objects; eight families over three environments | quantitative |
| Algorithm attachment | shared observation and control plug-in; three chains over 120 tasks | quantitative |
| Vehicle adaptation | adapter with selectable backend; bicycle dynamic model for every reported run | one backend |
| Interactive operation | Edit, Live, and Replay over shared components; one task illustrated (Fig. 3) | qualitative |
| Batch execution and analysis | scheduler and synchronized records; 450 runs with consistent online and offline outcomes | quantitative |
| Interactive agents | pluggable agent policies; no run in the reported matrix | not tested |
Table II. Platform capabilities and the evidence this paper provides. The last column states how far the reported 450 runs support each row.
Scenario Editing and Interactive Operation
Editing is object-based. Road polygons, reference polylines, obstacles, and friction regions are separate entities with independent coordinates, so a lateral avoidance reference does not move the road boundary and a friction boundary may cross a lane at an arbitrary angle. This is the platform-side counterpart of the task design in Section IV-A, where the same constructs become sweep variables and constraints.
Three modes cover the experiment cycle (Figure 3). Edit fixes the task: geometry, friction, initial state, and the reference that defines the demand. Live executes a closed-loop session on the selected backend and streams ego states and controls, obstacle and agent poses, and controller diagnostics. Replay presents recorded trajectories and available dynamics channels on a shared timeline; visualization is decoupled from the update loop, so playback does not alter the record. Interactive agents with pluggable policies extend the same representation to multi-vehicle behavior; no result below uses them.
Figure 3. Interactive interface panels on one task. Setup defines ego, road, and obstacle objects and selects the map and scenario; run control starts and stops a closed-loop session with the selected dynamics model and control strategy; the diagnostics panel plots custom state variables and logged channels for replay. The panels illustrate platform capability; the quantitative results use the scripted entry.
Algorithm and Vehicle Integration
An algorithm receives a shared observation (pose, body-frame velocity, yaw rate, reference geometry, configured obstacles) and returns a road-wheel steering angle with normalized throttle and brake commands, held between updates. Because the observation does not depend on the algorithm, chains can be exchanged within a fixed task without editing the scenario, which is the property the comparison in Section V-B relies on.
The vehicle side is an adapter with initialization, reset, control application, stepping, state retrieval, capability reporting, and shutdown. An external solver attaches through the same adapter, using a session configuration generated from working copies of its parameter and path files; the CarSim integration is documented but not exercised below.
Every reported run uses the same bicycle dynamic model, which carries longitudinal, lateral, and yaw body motion, four wheel-spin states, and a steering-actuator state. Pure-slip tire curves are followed by an isotropic combined-force projection,
and normal loads include quasi-static longitudinal and lateral transfer. The nominal vehicle has 1500 kg mass, 2500 kg m yaw inertia, axle distances of 1.2 m and 1.6 m, a 1.6 m track, and a 0.55 m center-of-mass height; steering has a 0.05 s time constant, a 0.8 rad/s plant rate limit, a 0.6 rad magnitude limit, and a 1 rad/s command rate guard. The model is compact and uncalibrated on purpose: it provides an identical dynamic plant for every chain rather than reproducing a particular car.
Algorithms attach as plug-ins. The three chains used here are Pure Pursuit, Stanley, and a lattice planner with longitudinal PID, all configured before the matrix was run. A sampling-based controller is also available as a plug-in but is not part of the reported results; its presence indicates the interface rather than a tested capability.
Execution, Logging, and Inspection
A scheduler keeps three rates distinct: physics at 1 ms, control at 20 ms, and event and state logging at 10 ms. Commands are held between control updates, states at a control instant are sampled before the new command is applied, and the terminal state is retained, which makes an event time comparable across a command, a state, and a task decision.
Interactive display, batch execution, and offline analysis share the state and control components but carry different responsibilities: the first renders a session, the second schedules many runs with workers using identical numerical settings, and the third reads stored records without re-simulating. A record holds the scenario, backend, and configuration identifiers, the commanded controls, the logged states, and the terminal event, so an analyst can locate one outcome, inspect the first violation, and compare the response preceding it.
Task-Oriented Evaluation
The evaluation method consumes the platform’s records. It defines what a task requests, what counts as completion, and how a failure is examined.
Task Families and Reference Demand
Each task instance specifies the road, obstacles, friction field, initial state, geometric reference, speed schedule, completion goal, and deadline. The eight families cover cornering, braking, combined braking and steering, corner exit, lane change with recovery, slalom, split-friction braking, and a friction transition (Table I, Figure 4). For a controller-independent reference with speed and curvature , let and . On uniform friction the demand coordinates are

Figure 4. Task-family sketches in the order C01–C08 of Table I, taken from one stored definition per family ((M02, L03)): road boundary (gray), reference polyline (blue, dashed), task mark (orange: stop line or ordered gate), obstacle (brown), and the friction divider (thin line) for C07 and C08. Panel scale and orientation follow each family’s geometry, so a level is comparable within a family but not across families; no ego vehicle is drawn.
The joint form combines accelerations at the same reference sample rather than independently attained peaks. These quantities describe the prescribed maneuver; they are neither a measured vehicle capacity nor a lower bound for every strategy, and a value above one does not establish infeasibility.
For C01–C06, environments M01–M03 use uniform friction and five target levels in the family coordinate of Table I. The generator changes speed or maneuver geometry to realize a level and the realized value is recomputed from the sampled reference, so a level is meaningful within its family rather than as a universal difficulty score. C07 varies friction asymmetry about a fixed nominal braking demand as and with and . C08 varies with entry friction . Friction is evaluated at individual wheel positions, so left and right contacts can meet different values.
| Task family | Sweep | Success condition |
| C01 Curve | Reach curve exit | |
| C02 Braking | Stop before line | |
| C03 Brake + steer | Avoid obstacle; reach exit | |
| C04 Corner exit | Reach exit at required speed | |
| C05 Double lane change | Pass gates; recover | |
| C06 Slalom | Pass ordered gates | |
| C07 Split friction | Stop before line | |
| C08 Friction transition | Reach curve exit |
Table 1. TASK FAMILIES AND PRIMARY SWEEP VARIABLES. SUCCESS ALSO REQUIRES NO COLLISION OR OFF-ROAD EVENT AND COMPLETION WITHIN THE TASK LIMIT.
Task Outcomes and Sampled Passing Sets
For a valid run of chain , model , and task , requires the goal by its deadline and compliance with road, obstacle, and task constraints through completion. C01, C03, and C08 require a forward crossing of the oriented exit gate, C04 additionally an exit speed, C02 and C07 a stop before the line below a speed threshold, and C05 and C06 ordered gates with a sustained recovery hold where specified; goal attainment alone is insufficient.
The evaluated footprint is a yaw-rotated 4.5 m by 1.8 m rectangle. Straight-road tasks use the declared road polygon; curved ribbons check the center and four corners against the reference-polyline half-width, with endpoint tangents extended by half the vehicle length. Collisions use vehicle and obstacle polygons with a separating-axis test. Checks occur at event samples and do not implement continuous swept-volume detection.
Numerical or interface faults are labeled Invalid and missing records are listed separately; neither enters the physical-failure count. For a finite task set at fixed family, environment, and configuration, the empirical passing set is
Outcome maps display tested cells. Adjacent changes identify intervals for additional sampling, and nonmonotonic results are retained, because the set is conditional on the model, configuration, and finite sample rather than a continuous stability region.
Event-Aligned Diagnosis
Failures are classified by the first task-violating event as collision, road departure, stop-line violation, recovery timeout, or incomplete task, with that order as a fixed tie-breaker for simultaneous sampled events; all events are retained. Online termination and offline evaluation apply the same rules, including the terminal sample, so re-evaluation tests record consistency rather than independent model validity.
Records retain target and actual longitudinal speed, commanded steering and pedals, yaw rate , body sideslip , and wheel-force utilization
Sideslip summaries use samples with speed at least 1 m/s; tire samples require finite channels, N, and , and missing initial forces are not replaced by zero. For a pass/fail pair, peak summaries share the interval and exclude the first-failure sample, and steering logs contain commands rather than measured actuator angles. These conventions make a comparison reproducible; they do not turn temporal association into a causal mechanism.
Platform Application and Experimental Studies
Experimental Setup
E1 comprises eight families, three environments, five levels, and three chains: 120 nominal tasks and 360 runs, with every chain receiving the same state, road, reference, obstacle, and known-friction information. Pure Pursuit follows the reference with a 12 m lookahead and Stanley uses a lateral-error gain of 2.5, both as implementations of familiar tracking laws [13], [14] rather than reproductions of complete systems. The lattice chain selects a local lateral path around the road spine and tracks it with Pure Pursuit at its defaults. A common longitudinal PID overrides their pedal outputs, reading the reference speed at projected progress, with , throttle feedforward 0.15, and integral bound 2.0; stopping tasks request zero speed immediately.
E2 inserts target demands 0.75, 0.80, and 0.85 for every chain in C01 and C03 at M02, where E1 shows a transition between 0.7 and 0.9, adding 18 runs; C01 changes speed along the existing curve, C03 regenerates maneuver length, braking reference, and obstacle position, and realized demand is recomputed in both. The obstacle at the C03 center level 0.80 is a 4.5 × 2.0 m static rectangle at (47.93, 0.0) m on a braking-and-steering reference in M02, the configuration whose stored record Section V-D re-examines. Before E2/E3 outcomes were observed, E3 fixed target demands 0.5, 0.8, and 1.3 and initial offsets m, translating the starting pose along the initial reference normal with heading, velocity, road, reference, and task unchanged. This adds 72 runs, with zero-offset records reused from E1 or E2. Table II separates the capabilities these runs cover from those they do not.
Batch Evaluation Across Task Families
E1 produced 148 passes and 212 task failures; PP, ST, and LP complete 53, 46, and 49 of 120 tasks, that is 44.2%, 38.3%, and 40.8% of the tested cells. These are finite-grid proportions, not estimated success probabilities. Three observations follow from Figure 5.
Figure 5. E1 outcome map: all 360 measured cells and their first-failure categories. Each family contains 15 task conditions per chain, and environment and level meanings are family-specific.
First, method differences depend on the family: ST completes more C01 tasks than PP (8 versus 6), whereas PP completes more C03 tasks than ST (11 versus 5), and LP completes 13 C04 tasks but no C05 or C06 task, so a single ranking would hide the exchange. Second, equal totals can correspond to different cells: in C07 all three chains complete six tasks, yet for PP and LP in M01, L02 passes, L03 fails, and L04 passes again, and reporting only the largest passing level would conceal the pattern. Third, failure categories separate chains that totals make similar: across E1 they are 96 road departures, 47 stop-line violations, 50 incomplete tasks, 13 collisions, and 6 recovery timeouts, whereas C02 shows identical cells for all chains, consistent with the shared stopping controller. These statements concern the implemented chains and task rules, not the best achievable performance of the methods.
Local Refinement and Initial-State Sensitivity
E2 yields 15 passes and 3 task failures. The C01 PP transition narrows to adjacent realized demands 0.8500 and 0.9000, and the C03 ST transition to 0.7000 and 0.7529; at the inserted C03 level 0.75 ST departs the road, while at 0.80 and 0.85 its first failure is a collision. The other chains show no transition inside the selected intervals, so refinement increases the resolution of two sampled transitions without locating a continuous boundary.
E3 yields 48 passes and 24 failures, and all 72 offset runs retain the decision of the corresponding zero-offset run. At low demand all three chains pass both families; at target 0.8 all pass C01 while ST fails C03; at target 1.3 all fail C01 while LP passes C03. The middle level lies inside the original coarse interval and was not chosen as a subsequently refined boundary; because the offsets are deterministic and few, the unchanged decisions do not establish robustness at the refined endpoints or a random perturbation success rate.

Figure 6. Local refinement (E2) and deterministic initial-position sensitivity (E3), both at M02. Ticks show realized reference demand and asterisks mark reused endpoint or zero-offset records. The two views display 30 and 90 cells drawn from 114 unique records: 90 new runs plus 24 reused E1 runs, with six E2 center records in both views.
Figure 7. Event-aligned records for the two cases. (a), (b) Top view at the first-failure sample; dashed boxes mark the insets and the arrow gives the driving direction. Gray shading is outside the 6 m corridor; the gray rectangle in (b) is the obstacle. Dashed circles mark the annotated event; scale bars: 1 m. (c), (d) Geometry margin on symmetric-log axes. (e)–(h) Signed body sideslip and yaw rate; vertical lines mark the first sampled failure (5.01 s and 3.04 s), gray spans contain only the passing run, and traces end at their own terminal samples.
Event-Aligned Case Analysis
Two same-scenario PP/ST pairs are examined from the stored records: the first M02 C01 level with differing outcomes in E1 (L03), and the fixed center of the C03 refinement at target 0.8. Both were selected using known outcomes, so they illustrate rather than sample the failure population.
In C01, PP first violates the sampled road constraint at 5.01 s while ST completes the exit at 5.15 s. Defining the road margin as half-width minus the largest distance of the center and four corners to the extended reference polyline, PP changes from 0.000495 m at 5.00 s to −0.000091 m at 5.01 s, whereas ST retains 1.570942 m. The 0.09 mm crossing is a discrete geometric-threshold event, not a large physical departure. Over the common interval [0, 5.01), ST shows the larger maximum absolute sideslip ( versus ) and yaw rate (0.5251 versus 0.4310 rad/s) and still passes, so diagnostic amplitude alone does not reproduce the task label. In C03, ST first collides at 3.04 s while PP completes at 5.59 s. At 3.03 s the lateral center positions are nearly equal (2.4557 versus 2.4453 m) but the headings differ (0.4128 versus 0.1849 rad), and the normalized separating-axis gaps are 0.002609 and 0.296052 m. At 3.04 s the ST gap becomes −0.016997 m, consistent with footprint overlap, while PP retains positive separation; the gap is not a Euclidean clearance. ST’s maximum wheel utilization before the event is 0.9233, so the collision label does not require utilization to reach one.
Scope and Limitations
The passing sets are conditional on one uncalibrated bicycle model, finite reference families, declared task thresholds, and fixed controller defaults. No result here validates the model against an external solver or a physical vehicle, and the same implementation decides online and offline outcomes, so agreement tests consistency rather than independent correctness. Sampled corner and polygon checks do not establish continuous collision avoidance, and small margins are sensitive to discretization and threshold choice. Task failures can also reflect the baseline’s task-following behavior: LP’s incomplete C05 and C06 results do not show that those maneuvers are physically impossible. The limited offsets do not test geometric generalization, stochastic robustness, sensor uncertainty, or unrestricted planning.
Conclusion
DynLimit organizes dynamics-critical experiments as one process: scenarios and references are declared as objects, algorithms and vehicles attach through shared interfaces, execution keeps control, state, and event records on a single timeline, and a task-oriented method turns those records into passing sets and event-aligned diagnoses. On this platform, 450 runs across eight families show that method differences depend on the task family, that equal aggregate counts can hide different passing cells, and that local refinement and prescribed offsets change the resolution of a result without establishing a continuous boundary. The case comparisons confirm that geometry and completion rules carry information that response peaks alone do not. Future work will first strengthen perception testing: sensor models, detection latency, and estimator error enter as further declared objects, so that degraded and occluded sensing is swept by the same task matrix that now sweeps demand and initial offset. Beyond that, calibrated vehicle transfer, broader scenario coverage, and continuous-boundary estimation remain open, and the platform is the instrument we expect to use for them.
References
- [1]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, ser. Proceedings of Machine Learning Research, vol. 78. PMLR, 2017, pp. 1–16. [Online]. Available: https://proceedings.mlr.press/v78/dosovitskiy17a.htmlarxiv.org/abs/1711.03938
- [2]M. O’Kelly, H. Zheng, D. Karthik, and R. Mangharam, “FITENTH: An open-source evaluation environment for continuous control and reinforcement learning,” in Proceedings of the NeurIPS 2019 Competition and Demonstration Track, ser. Proceedings of Machine Learning Research, vol. 123. PMLR, 2020, pp. 77–89. [Online]. Available: https://proceedings.mlr.press/v123/o-kelly20a.html
- [3]A. Remonda, N. Hansen, A. Raji, N. Musiu, M. Bertogna, E. E. Veas, and X. Wang, “A simulation benchmark for autonomous racing with large-scale human data,” in Advances in Neural Information Processing Systems, vol. 37, 2024, datasets and Benchmarks Track. [Online]. Available: https://proceedings.neurips.cc/paper_files/paper/2024/hash/b91ea2ba1b6521940e204b7b81d5ef47-Abstract-Datasets_and_Benchmarks_Track.htmlDOI
- [4]M. Althoff, M. Koschi, and S. Manzinger, “CommonRoad: Composable benchmarks for motion planning on roads,” in Proc. IEEE Intell. Vehicles Symp. (IV), 2017, pp. 719–726. [Online]. Available: https://doi.org/10.1109/IVS.2017.7995802
- [5]N. K. Karnanachari, D. Geromichalos, K. S. Tan, N. Li, C. Eriksen, S. Yaghoubi, N. Medhipour, G. Bernasconi, W. K. Fong, Y. Guo, and H. Caesar, “Towards learning-based planning: The nuPlan benchmark for real-world autonomous driving,” in Proc. IEEE Int. Conf. Robot. Autom. (ICRA), 2024. [Online]. Available: https://arxiv.org/abs/2403.04133
- [6]G. Lamberti, M. Pini, E. Mascaro, F. Moretti, A. Raji, and M. Bertogna, “Fast and realistic automated scenario simulations and reporting for an autonomous racing stack,” in Proc. IEEE/SICE Int. Symp. Syst. Integr. (SII), 2026, pp. 1599–1606, DOI: 10.1109/SII64115.2026.11404397. [Online]. Available: https://arxiv.org/abs/2512.24402
- [7]M. Brunner, E. Ghighone, N. Baumann, and M. Magno, “R-CARLA: High-fidelity sensor simulations with interchangeable dynamics for autonomous racing,” 2025, preprint. Code: https://github.com/ForzaETH/rclarla. [Online]. Available: https://arxiv.org/abs/2506.09629
- [8]CarSim / VehicleSim, “CarSim Math Models,” https://www.carsim.com/users/pdf/release_notes/carsim/CarSim_Math_Models.pdf, n.d., official technical note.
- [9]S. Sagmeister, P. Kounatidis, S. Goblirsch, and M. Lienkamp, “Analyzing the impact of simulation fidelity on the evaluation of autonomous driving motion control,” in Proc. IEEE Intell. Vehicles Symp. (IV), 2024, pp. 230–237, DOI: 10.1109/IV55156.2024.10588858. [Online]. Available: https://ieeexplore.ieee.org/document/10588858DOI
- [10]D. J. Fremont, T. Dreossi, S. Ghosh, X. Yue, A. L. Sangiovanni-Vincentelli, and S. A. Seshia, “Scene: A language for scenario specification and scene generation,” in Proc. ACM SIGPLAN Conf. Program. Lang. Design Implement. (PLDI), 2019. [Online]. Available: https://doi.org/10.1145/3314221.3314633
- [11]Q. Li, Z. Peng, L. Feng, Q. Zhang, Z. Xue, and B. Zhou, “MetaDrive: Composing diverse driving scenarios for generalizable reinforcement learning,” IEEE Transactions on Pattern Analysis and Machine Intelligence, 2022. [Online]. Available: https://arxiv.org/abs/2109.12674
- [12]M. Zhou, J. Luo, J. Villella, Y. Yang, D. Rusu, J. Miao, W. Zhang, M. Alban, I. Fadakar, Z. Chen, C. Huang, Y. Wen, K. Hassanzadeh, D. Graves, Z. Zhu, Y. Ni, N. Nguyen, M. Elsayed, H. Ammar, A. Cowen-Rivers, S. Ahilan, Z. Tian, D. Palenicek, K. Rezaee, P. Yadmellat, K. Shao, D. Chen, B. Zhang, H. Zhang, J. Hao, W. Liu, and J. Wang, “SMARTS: An open-source scalable multi-agent RL training school for autonomous driving,” in Proceedings of the 2020 Conference on Robot Learning, ser. Proceedings of Machine Learning Research, vol. 155. PMLR, 2021, pp. 264–285. [Online]. Available: https://proceedings.mlr.press/v155/zhou21a.html
- [13]R. C. Coulter, “Implementation of the pure pursuit path tracking algorithm,” The Robotics Institute, Carnegie Mellon University, Pittsburgh, PA, Tech. Rep. CMU-RI-TR-92-01, Jan. 1992. [Online]. Available: https://publications.ri.cmu.edu/implementation-of-the-pure-pursuit-path-tracking-algorithm
- [14]S. Thrun et al., “Stanley: The robot that won the DARPA grand challenge,” Journal of Field Robotics, vol. 23, no. 9, pp. 661–692, 2006, DOI: 10.1002/rob.20147. [Online]. Available: https://doi.org/10.1002/rob.20147



