Rust4PM provides an open-source software library for process mining focused on performance. For instance, it supports parsing the most common data formats for standard and object-centric event logs (XES and OCEL 2.0) significantly faster than other available process mining tools. The library is written in the compiled, memory safe, programming language Rust, which focuses on performance and explicit error handling. As such, it is a good match for processing huge event data and other computationally expensive tasks or algorithms. Rust4PM aims to form a solid basis for new process mining software that emphasize execution speed or reliability, written in either Rust or another language (e.g., Python, Java, or JavaScript) via the use of appropriate language bindings.
The main Rust4PM library is available at https://crates.io/crates/process_mining. It currently consists of four main modules, covering diferent functionalities.
• The event_log module contains the data structure definitions for the internal
representation of traditional XES event logs. Additionally, it contains a full parser for the XES
2.0 standard, as well as export functionality for exporting event logs to XES. Moreover,
there are case-streaming versions of the importer and exporter available, which allow
processing cases of huge event logs without loading the full file in memory.
• The ocel module contains data structures for the OCEL 2.0 standard for object-centric
event data, as well as import functionality for OCEL 2.0 files in the XML or JSON format.
• The petri_net module consists of data structures for Petri nets, as well as the ability to
import and export basic Petri nets using the Petri Net Markup Language (PNML).
• The alphappp module implements the Alpha+++ process discovery algorithm, which
was the starting point for the Rust implementation, as introduced in [
Moreover, Rust4PM integrates well with other projects. For example, PM4Py optionally
supports importing XES or OCEL 2.0 files via the Rust4PM-based importer rustxes (see [
In this section, we present evaluation results for the performance of the XES and OCEL 2.0 XML parsers, as implemented in Rust4PM, PM4Py and (if available) ProM. For evaluation, we used a subset of the publicly available BPI Challenge XES event logs (see https://data.4tu.nl/search? search=BPI+Challenge) as well as OCEL 2.0 logs from https://www.ocel-standard.org/.
Speedup: 2.27× – 10.86×
Speedup: 2.47× – 2.47×
Speedup: 2.32× – 12.20×
angular_github_commits_ocel.xml Speedup: 16.48×
Speedup: 32.76× order-management.xml Speedup: 41.94× 35 ]s30 i[n25 o tra20 uD15 rse10 a P 5
0 PM4Py ]s2.5 [ ion 2 t rau1.5 D se 1 raP0.5 0 70 ][s60 ion50 tra40 u D30 e rs20 a P10 0 PM4Py 4 ]s3.5 i[no 3 ta2.5 ru 2 D e1.5 rsa 1 P0.5 0 []s40 n ito30 a rD20 u e s ra10 P 0 PM4Py 14 ][s12 ino10 tra 8 u D 6 rse 4 a P 2 0
Figure 1: The total import durations for diferent XES and OCEL 2.0 files across the tested implementations. All configurations were repeated 5 times and the observed standard deviation is included as an error bar. Missing bars indicate a failed import (e.g., because the program ran out of memory).
The evaluation results are plotted in Figure 1. For all evaluated XES logs, the Rust4PM XES parser is at least two times faster on average than the other tested implementations. In comparison to PM4Py specifically, speedups of at least 10 times were observed for all evaluated XES event logs. For OCEL 2.0 XML, Rust4PM also significantly outperforms the PM4Py implementation by a factor of at least 15 for all evaluated files. As of now, no implementation of the new 2.0 version of the OCEL standard is available in ProM.
In this section, we present four example applications built using the main Rust4PM library as a base. Figure 2 shows screenshots of the tools. Each application is based on a diferent architecture and usage context. Additionally, each application focuses on a specific feature set of the Rust4PM library. Thus, these examples do not follow a common theme, but should instead demonstrate the versatility of using Rust4PM in diferent contexts and architectures. (a) log_strip (b) event_hours_analyzer (c) ocel_graph (d) petri_net_wasm
Next, we will shortly describe each demo application, mentioning the used architecture and
leveraged library features. All examples are also publicly available at https://github.com/aarkue/
rust4pm_demos, together with a demo video on Rust4PM as a whole, as well as these examples.
4.1. CLI for Stripping XES Attributes (log_strip)
The Rust command-line-interface (CLI) program log_strip can strip or modify certain
attributes from an input XES event log, resulting in a stripped output log. A typical application
for such a tool lays in privacy-preserving process mining, as presented in [
The tool uses the XES trace stream importer and exporter from Rust4PM. Thus, the CLI can also be used to modify event logs which are too large to fit in system memory. 4.2. Python Script for Data Visualization (event_hours_analyzer) event_hours_analyzer is a Python Jupyter notebook for visualizing the number of events per hour of the day based on an input event log. The computationally expensive parts, i.e., the import of the XES event log and the computation of the event counts, are implemented in Rust. This functionality is then exposed as a Python library, which is used in the Jupyter notebook.
In this example, the XES importer and the event log data structures provided by the Rust4PM library are used. 4.3. Web Service for Constructing Graphs from OCED (ocel_graph) This demo application is implemented as a web server backend implemented in Rust, which uses Rust4PM, and an interactive web-based frontend. The backend allows loading OCEL 2.0 event data and constructing graphs based on an event or object in the input data. In particular, all event-to-object and object-to-object relationships inside the object-centric event log are recursively expanded, based on specified parameters (e.g., the maximal number of recursion steps). The resulting interactive graph contains the encountered events and objects of the OCEL as nodes and edges between nodes corresponding to the relationships in the OCEL.
The backend utilizes the OCEL 2.0 XML or JSON import functionality of Rust4PM, as well as the OCEL 2.0 data structure representation to construct the graph. 4.4. Petri Net Editor with PNML and Discovery Support via WASM (petri_net_wasm) This example application is a basic client-side Petri net editor. While the main editor is implemented using web technologies, it leverages the PNML import and export functionality from Rust4PM. Additionally, it allows discovering Petri nets from XES event logs based on the implementation of the Alpha+++ process discovery algorithm and the XES parser in Rust4PM. For that, the corresponding functions are exposed via WebAssembly (WASM), which is a possible compilation target for Rust. In contrast to the web server example presented before, WASM runs directly in the web browser of the user. We include this example specifically to demonstrate running Rust4PM in the web browser, which allows users to try out or use a tool simply by visiting a website, without the need to install anything on their machine.
In this paper, we introduced the performance-centric Rust4PM software project. Among other features, the main library supports importing the most common traditional and object-centric event data file formats, XES and OCEL 2.0. Through streaming XES traces, it also supports importing, processing and exporting huge XES event logs that would otherwise not fit into system memory. We evaluated the performance of the XES and OCEL 2.0 XML import parsers between two other popular open-source solutions, ProM and PM4Py, and observed significantly improvements in import speeds for all considered configurations, with speedups factors ranging from 2 to 40. To demonstrate the flexibility of Rust4PM, we presented four example applications, each with an own software architecture and feature focus.
Maturity The main Rust4PM library was first published in December 2023 with rudimentary features, and received more than 25 version updates since then. In this time, it was downloaded more than 10,000 times in total, according to crates.io. There are around 40 software test cases included, which cover a large portion of the implemented features. However, as the project is still rather young, there will likely still be changes to the exposed API surface in the future. Future work There are still plenty of interesting features to be implemented in the library. For example, export support for OCEL 2.0, or the implementation of computationally expensive process mining algorithms, such as the computation of alignments. Furthermore, there are many possible advancements for the example applications presented in Section 4.