pyjevsim 2.2.0 Unifies Python Simulation with Distributed HLA Backends

The latest release of pyjevsim, version 2.2.0, marks a significant advancement in the field of discrete event simulation by integrating multiple High Level Architecture (HLA) backends into a unified Python environment. Developed by researchers including Dohyung Kim and Changbeom Choi, this update addresses the longstanding complexity of connecting discrete event models with distributed simulation infrastructures. By introducing connectors for Pitch pRTI, Portico, and the experimental gorti runtime, the software allows developers to manage complex federated simulations without the overhead of external adaptor processes. This architectural shift simplifies the workflow for researchers who rely on Python for both modeling and simulation execution, reducing the technical barriers to entry for distributed system studies.

At its core, pyjevsim is built upon the Discrete Event System Specification (DEVS) formalism, which provides a rigorous mathematical foundation for modeling dynamic systems. The previous version, 2.1.2, established the initial HLA integration, but 2.2.0 expands this capability by offering reproducible comparisons between standalone and federated simulation trajectories. The software utilizes JPype for Python-to-Java interactions with Pitch pRTI and Portico, while the gorti connector leverages a separate Python SDK to interface with an rtid service. This multi-backend approach ensures that users can select the most appropriate runtime infrastructure for their specific simulation requirements, whether they prioritize performance, compatibility, or experimental flexibility.

The architectural design of pyjevsim 2.2.0 emphasizes the separation of concerns between model behavior and runtime infrastructure. StructuralModel groups child models and defines their port couplings, while BehaviorModel defines the atomic behavior of individual components. The SysExecutor coordinates the scheduling of events, and the BehaviorExecutor reports the next event time and invokes model output and transition functions. For HLA-controlled execution, the HLAExecutor extends the BehaviorExecutor to connect bound model ports to the RTIConnector. External bindings use HLAInteraction and HLAAttribute descriptors to associate ports with Federation Object Model (FOM) defined interactions and object attributes, specifying inbound, outbound, or bidirectional exchange. This design keeps RTI-specific calls outside the model classes, ensuring that the simulation logic remains independent of the underlying distributed infrastructure.

One of the most notable features of this release is the in-process execution of RTI connectors. Unlike previous tools such as DEVSim++ ME, which required a separate KHLA Adaptor process to access RTI services, pyjevsim runs its connectors within the Python simulation process. This eliminates the need for inter-process communication overhead and simplifies the deployment of federated simulations. The create_rti function selects the RTI backend based on user configuration, and the connectors handle the encoding of outgoing payloads and the decoding of incoming data. This streamlined approach allows for more efficient data exchange between federates, which is critical for simulations involving high-frequency interactions or large-scale data sets.

To validate the effectiveness of the new connectors, the research team conducted functional tests using two deterministic anti-torpedo simulation (atsim) scenarios. These scenarios involved one surface ship, one torpedo, and four decoys, with each scenario running for 30 logical ticks. The standalone reference execution used a single SysExecutor, while the federated configuration utilized ship-side and torpedo-side HLA_TIME federates running in separate threads within a single Python process. The atsim driver exchanged platform object attributes through publication and reflection between simulation steps, ensuring that the state of each object was accurately synchronized across the federation. The tests were designed to verify that the federated execution could reproduce the application-state traces of the standalone execution with high precision.

The validation process required exact agreement between the sorted records of logical tick, object identifier, and position, with coordinates formatted to ten significant digits. Each of the six objects in the simulation contributed one position record per tick, yielding 180 records per scenario. Pitch pRTI, Portico, and experimental gorti were each invoked five times, and all 180 records per scenario matched the standalone reference in every invocation across all three backends. This level of reproducibility demonstrates the robustness of the pyjevsim 2.2.0 architecture and its ability to maintain simulation integrity even when distributed across multiple runtime environments. The versioned source release includes the complete atsim launchers, port-binding configuration guide, and reference traces, allowing other researchers to repeat these comparisons and verify the results independently.

The software also supports various execution modes, including virtual-time, real-time, and HLA-controlled execution. In HLA-controlled execution, the Federate.run_until method requests time advances through the RTIConnector and passes each granted time to the step method of the SysExecutor. The positive lookahead argument sets the increment between requested times, which is distinct from the backend’s HLA regulating lookahead. The execution core processes events up to each granted time, including zero-time cascades, and simultaneous internal and external events invoke the model’s confluent transition. This mechanism ensures that the simulation progresses in a controlled manner, respecting the time constraints imposed by the HLA infrastructure while maintaining the logical consistency of the discrete event model.

From a technical perspective, pyjevsim 2.2.0 requires Python 3.10 or higher and the dill library for serialization. Additional runtime requirements depend on the selected RTI implementation, version, and connector. The version-pinned validation documentation provides backend-specific requirements and tested configurations, ensuring that users can set up their environments with confidence. The software is released under the MIT License, which encourages its use in both academic and commercial settings. The developer documentation, available on Read the Docs, provides detailed guidance on model composition, execution, and HLA integration, making it accessible to a wide range of users with varying levels of expertise in discrete event simulation.

The implications of pyjevsim 2.2.0 extend beyond the immediate benefits of simplified HLA integration. By providing a Python-based environment for DEVS simulation and state journaling, the software opens new possibilities for research in distributed systems, cyber-physical systems, and complex adaptive systems. The ability to compare standalone and federated trajectories allows researchers to study the impact of distribution on simulation outcomes, which is crucial for understanding the scalability and performance of large-scale simulations. Furthermore, the inclusion of the experimental gorti connector, an open-source IEEE 1516-2010 Run-Time Infrastructure written in Go, demonstrates the software’s commitment to exploring new technologies and maintaining compatibility with emerging standards in the simulation community.

As the field of discrete event simulation continues to evolve, tools like pyjevsim play a critical role in bridging the gap between theoretical models and practical applications. The release of version 2.2.0 represents a significant step forward in this effort, providing researchers with a powerful and flexible platform for conducting distributed simulations. By streamlining simulation workflows and ensuring reproducibility, pyjevsim 2.2.0 sets a new standard for software tools in the field, encouraging further innovation and collaboration among researchers worldwide. The ongoing development of the software, including plans to extend FOM datatype coverage and evaluate communication performance across physical hosts, promises to further enhance its capabilities and relevance in the coming years.

Subject of Research: Python-based discrete event simulation with High Level Architecture integration

Article Title: Version 2.2.0 – pyjevsim: Streamlining simulation workflows using journaling in python-based discrete event simulation environments

Article References: Kim, D., Yang, S., Jang, S., & Choi, C. (2026). Version 2.2.0 – pyjevsim: Streamlining simulation workflows using journaling in python-based discrete event simulation environments. SoftwareX, 36, Article 103047. https://doi.org/10.1016/j.softx.2026.103047

Image Credits: AI Generated

DOI: 10.1016/j.softx.2026.103047

Keywords: discrete event simulation, High Level Architecture, Python, DEVS, federated simulation, software release, RTI connectors, simulation reproducibility, JPype, gorti, Portico, Pitch pRTI