PureEdgeSim logo

PureEdgeSim

An open-source, discrete-event simulation framework for performance evaluation of cloud, edge, fog, and mist computing environments.

GPL v3 license Maven Central version GitHub Actions build status JaCoCo instruction coverage JaCoCo branch coverage Codacy code quality Javadoc PureEdgeSim for Python

PureEdgeSim is now available in Python. The same simulator, the same five configuration files and the same 56-column output, in a companion repository: CharafeddineMechalikh/PureEdgeSim_Python, with its own manual. Results from the two versions can be placed side by side, so you can run your study in whichever language you work in.

Citation

If you use PureEdgeSim in your research, please cite the following papers. Kindly cite the papers rather than the GitHub repository.

Mechalikh, C., Taktak, H., & Moussa, F. (2021). PureEdgeSim: A simulation framework for performance evaluation of cloud, edge and mist computing environments. Computer Science and Information Systems, 18(1), 43-66. https://doi.org/10.2298/CSIS200301042M

Mechalikh, C., Silem, A. E. H., Safavifar, Z., & Golpayegani, F. (2025). Quality matters: A comprehensive comparative study of edge computing simulators. Simulation Modelling Practice and Theory, 138, 103042. https://doi.org/10.1016/j.simpat.2024.103042

BibTeX:

@article{mechalikh2021pureedgesim,
  title   = {PureEdgeSim: A simulation framework for performance evaluation of cloud, edge and mist computing environments},
  author  = {Mechalikh, Charafeddine and Taktak, Hajer and Moussa, Faouzi},
  journal = {Computer Science and Information Systems},
  volume  = {18},
  number  = {1},
  pages   = {43--66},
  year    = {2021},
  doi     = {10.2298/CSIS200301042M}
}

@article{mechalikh2025quality,
  title   = {Quality matters: A comprehensive comparative study of edge computing simulators},
  author  = {Mechalikh, Charafeddine and Silem, Abd El Heq and Safavifar, Zahra and Golpayegani, Fatemeh},
  journal = {Simulation Modelling Practice and Theory},
  volume  = {138},
  pages   = {103042},
  year    = {2025},
  doi     = {10.1016/j.simpat.2024.103042}
}

PureEdgeSim simulation dashboard showing the simulated edge computing environment

Contents

Why researchers choose it

A 2025 peer-reviewed study compared 24 edge computing simulators on functionality, code quality, maintenance, and runtime, running the same scenario in every tool that could start it. Four of its measurements are the shortest argument for this framework:

Claim Measurement
The fastest tool in the study that could run the scenario 1.81 s on a baseline of 100 mobile AR users over one simulated hour, against 3.53 s for EdgeCloudSim, 49.4 s for LEAF, 259 s for PFogSim, and 42.1 hours for FogNetSim++
The largest usable scenarios about 80,000 devices, against 10,000 for EdgeCloudSim, 7,000 for LEAF, 250 for PFogSim, and 4 for FogNetSim++
The only simulator in the study that reported test coverage 91% then; 98.2% of instructions and 96.2% of branches now, from more than 1,100 automated tests
Still maintained, unlike almost all of the field edge simulators receive updates for 12 months on average, and iFogSim, the most cited of them, has not changed since 2016

The first two lines are the study’s measurements; the last two also include numbers from this repository’s current build. How PureEdgeSim compares separates the two, states what PureEdgeSim does not model, and lists the cases where another simulator is the better fit.

What is PureEdgeSim?

PureEdgeSim is an open-source edge computing simulator written in Java. It models cloud, edge, fog, and mist computing environments at large scale, including the Internet of Things (IoT) devices, the network that connects them, and the applications that run on top of this infrastructure.

Researchers use PureEdgeSim to evaluate task offloading, workload orchestration, resource management, service and application placement, mobility, energy consumption, and network performance across the edge-to-cloud continuum. It is a discrete-event simulator (DES) with realistic infrastructure, network, mobility, and energy models, and a modular design in which each module addresses one aspect of the simulation.

The Datacenters Manager module creates data centers, servers, and heterogeneous end devices. The Location Manager handles their geo-distribution and mobility. The Network module manages bandwidth allocation and data transfer. The Workload Orchestrator module supports online decision making, and the Task Generator produces realistic workloads.

PureEdgeSim combines analytical and numerical modeling techniques. The network, for example, is modeled with adjustable mathematical equations rather than at a low level. This abstraction makes it possible to simulate thousands of edge devices while keeping the simulation state observable at any moment. Because it is a discrete-event simulator, characteristics such as network traffic and resource utilization evolve over time, which enables the evaluation of online decision-making algorithms.

Each module provides a default implementation and a set of adjustable settings. Researchers can therefore prototype and evaluate their approaches without specifying low-level details, and they can extend the framework with custom models without modifying its codebase. See the documentation manual for the full documentation.

Representation of the edge, fog, mist, and cloud computing scenarios supported by PureEdgeSim

A simple representation of the simulation scenarios supported by PureEdgeSim

How it compares

The 2025 comparative study of 24 edge computing simulators ran the same baseline scenario, 100 mobile AR users over one simulated hour, in every tool that could start it. Two measurements decided the ranking:

Shared baseline scenario PureEdgeSim The rest of the field in that study
Execution time 1.81 s 3.53 s EdgeCloudSim, 49.4 s LEAF, 259 s PFogSim, 42.1 h FogNetSim++
Devices before the run stops being usable ≈ 80,000 ≈ 10,000 EdgeCloudSim, ≈ 7,000 LEAF, ≈ 250 PFogSim, ≈ 4 FogNetSim++

That study also places PureEdgeSim with the widest modeling coverage it checked, with LEAF among the best code quality it measured, and as one of only two simulators still under active maintenance. Most edge simulators stop receiving updates within months of release, and iFogSim, the most cited one, has not changed since 2016.

The combination, not the feature

Individual capabilities exist elsewhere. What no other simulator in that study offers is all of them in one run, because a model that is missing one of them silently changes the result of the others:

Capability Why the others cannot substitute
Network delay that follows the load, with asymmetrical up/down links EdgeCloudSim, LEAF and the iFogSim family apply a constant transmission delay or bandwidth, so a scalability study cannot see congestion it creates itself
Mobility that feeds back into placement, routing, and failures Enigma moves devices but ignores the effect of movement on execution and failure rates; FogExplorer has no mobility at all
Energy accounted per node, per radio interface, and per link class, with a battery that dies Most energy models in the study cover data centers or one constrained device class, and stop there
A battery running out as a measured cause of task failure, counted separately from latency and resource shortage A failure cause that is not modeled cannot be attributed, so energy-aware orchestrators are graded on incomplete data
Service graphs: subtasks released by their dependencies, parent results carried as payload, one end-to-end deadline, optional stages Added after the study. FogExplorer schedules interdependent tasks, but without mobility, energy, or load-aware links in the same run
Every numeric scenario parameter declared as a random variable out of sixteen distributions, replayed from one seed Added after the study. A scenario is a distribution, not a table of constants
The same simulator in Java and in Python, producing the same 56-column output Added after the study: PureEdgeSim_Python

What it does not model, stated plainly: there is no pricing or cost model, which the study records as the main gap of PureEdgeSim, and a service graph is acyclic, so conditional branches, loops, and “wait for any parent” joins are out of scope.

How PureEdgeSim compares carries the full version of this comparison: the SonarQube code-quality table, the repository maintenance statistics, the drawbacks the study listed against version 5 and where each one stands now, and a table of the research questions that are better served by EdgeCloudSim, LEAF, YAFS, FogNetSim++, FogExplorer or DISSECT-CF-Fog.

Key features

Live visualization of a running PureEdgeSim simulation

The live visualization of the simulated environment

Application and task-graph shapes

There is no closed list of application types. A workload is defined by its numbers (arrival rate, latency bound, request, result, and container sizes, and task length), and its type label is free text used by the orchestrator. What the framework does constrain is the shape of the workload, and every acyclic shape is accepted:

flowchart LR
    subgraph Monolithic
        direction LR
        M1[request] --> M2[task] --> M3[results]
    end
    subgraph Sequential
        direction LR
        S1[stage 1] --> S2[stage 2] --> S3[stage 3]
    end
    subgraph Parallel
        direction LR
        P1[root] --> P2[worker A]
        P1 --> P3[worker B]
        P2 --> P4[join]
        P3 --> P4
    end
    subgraph Complex
        direction LR
        C1[root A] --> C3[stage]
        C2[root B] --> C3
        C3 --> C4[branch A]
        C3 --> C5[branch B]
        C4 --> C6[merge]
        C5 --> C6
    end

A monolithic application produces one task per request. A service graph produces one task per <subtask>, releases each stage only after the stages listed in its depends_on have returned their results, adds the results of a parent to the request of its children, gives every subtask its own latency bound and sizes, shares the application latency as the end-to-end deadline of the request, skips the stages declared optional="true" when their input fails, and fails the whole required subtree when a required parent fails. Graphs are declared in applications.xml with <subtask name="detect" depends_on="capture" task_length="5000"/>, and both styles can coexist in one scenario.

The model still does not represent conditional branches, loops, or “any parent” joins. See Simulation models for the diagrams and their runtime consequences, and Configuration for the XML attributes.

Quick start

Requirements

Build and run an example

git clone https://github.com/CharafeddineMechalikh/PureEdgeSim.git
cd PureEdgeSim

# Build the project. Skip tests for a faster first build.
mvn clean install -DskipTests

# Run the first example.
mvn exec:java -Dexec.mainClass="examples.Example1"

The examples live in PureEdgeSim/examples, and each one has a README, its sources, and its scenario files in the same folder (examples/README.md). Each example demonstrates a different feature or computing paradigm. To create a new scenario, add a folder under PureEdgeSim/examples with a class in the examples package and configure it as shown below.

You can also import the project as a Maven project in Eclipse, IntelliJ IDEA, or NetBeans, and run any example class directly from the IDE.

Importing the PureEdgeSim Maven project into an IDE

Importing the PureEdgeSim project into an IDE (click to zoom)

Run the tests

mvn test

The test suite contains more than 1100 automated tests. To run only the unit tests, excluding the integration tests:

mvn test -Punit-tests

The JaCoCo HTML report is written to target/site/jacoco/index.html, and the XML report is copied to jacoco.xml by the coverage workflow.

Create a custom scenario

// Create a PureEdgeSim simulation.
Simulation sim = new Simulation();

// Use your own models instead of the default ones.
sim.setCustomMobilityModel(YourCustomMobilityModel.class);
sim.setCustomEdgeOrchestrator(YourCustomOrchestrator.class);
sim.setCustomComputingNode(YourCustomComputingNode.class);
sim.setCustomTaskGenerator(YourCustomTaskGenerator.class);
sim.setCustomNetworkModel(YourCustomNetworkModel.class);
sim.setCustomSimulationManager(YourCustomSimulationManager.class);
sim.setCustomTopologyCreator(YourCustomTopologyCreator.class);

// Use the default models by simply deleting or commenting the corresponding line.

// Launch the simulation.
sim.launchSimulation();

Use PureEdgeSim as a dependency

PureEdgeSim is available on Maven Central. Version 6.0 is the latest published artifact, under the group id io.github.charafeddinemechalikh. Releases up to 5.1.0 stay under the older group id com.mechalikh: that namespace was granted against mechalikh.com in 2021, the domain has since expired, and Central re-verifies a domain namespace only through its DNS records, so new releases use the GitHub one. The Java packages are unchanged, so only the dependency coordinates differ.

Maven:

<dependency>
  <groupId>io.github.charafeddinemechalikh</groupId>
  <artifactId>pureedgesim</artifactId>
  <version>6.0</version>
</dependency>

Gradle:

dependencies {
  implementation 'io.github.charafeddinemechalikh:pureedgesim:6.0'
}

Documentation and examples

Performance and scalability

A system is efficient when it maintains a specified level of proficiency without using an excessive amount of resources, such as execution time and memory. The theoretical time complexity of a simulation is not trivial to determine because the execution time depends on the scenario (device and task counts, mobility model, resource types, and so on) and on the number of events generated during the simulation.

To demonstrate the scalability of PureEdgeSim, the following experiments were conducted on a single Intel Core i7-8550U:

A 10-minute simulation scenario with 10,000 devices (which generated 1,131,000 tasks) took 58 seconds.

A 24-hour simulation scenario with 200 devices (3,221,280 generated tasks) took 51 seconds.

A 60-minute scenario with 100 devices took 1 second.

These times depend on the complexity of the decision-making algorithm and on the number of generated events. Even so, the simulator runs faster than real time and scales to scenarios that CloudSim and CloudSim Plus based simulators often cannot start, either because of the number of devices or because of the number of generated events. Independent multi-threaded execution of simulation runs is also supported.

PureEdgeSim scalability results for large-scale scenarios PureEdgeSim scalability results for large-scale scenarios

PureEdgeSim support for large-scale scenarios

Comparison of simulation duration between PureEdgeSim 5.0 and 5.1

A comparison of simulation duration between PureEdgeSim 5.0 and 5.1

Design goals and validation

Simulation accuracy</summary>

PureEdgeSim provides realistic network, energy, and mobility models. Because it is a discrete-event simulator, the time complexity depends on the number of events generated at runtime. To reduce simulation time, PureEdgeSim exposes a collection of parameters that let users balance simulation precision and duration. The update intervals are the main example: shorter intervals produce more precise and realistic results, but also longer simulations.

</details>

Versatility and wide applicability</summary>

Edge computing and its related paradigms can be classified by their placement in the IoT architecture. Paradigms of the perception layer, such as mist computing, rely on resource-constrained devices that can join or leave the network at any moment. PureEdgeSim dedicates a configuration file to each layer, so the model is versatile enough to support all kinds of resources and topologies. Mobile devices, servers, and data centers are all defined in these files, including their power consumption rates, mobility, and connectivity.

Computing paradigms supported by PureEdgeSim Computing paradigms supported by PureEdgeSim

The computing paradigms supported by PureEdgeSim

<?xml version="1.0"?>
<edge_devices>
  <device arch="x86" os="linux" vmm="kvm"> <!-- this is a smartphone, for example -->
    <!-- Move like a pedestrian: random waypoints, selected by name. -->
    <mobility model="random-waypoint">true</mobility>
    <connectivity>wifi</connectivity>
    <speed>1.4</speed>
    <minPauseDuration>100</minPauseDuration>
    <maxPauseDuration>400</maxPauseDuration>
    <minMobilityDuration>60</minMobilityDuration>
    <maxMobilityDuration>100</maxMobilityDuration>
    <battery>true</battery>
    <percentage>30</percentage>
    <!-- Each instance of this type draws its own capacity, here from a range. -->
    <cores distribution="uniform" min="4" max="8" />
    <mips distribution="normal" mean="25000" std="4000" min="1000" />
    <ram>4096</ram>
    <storage>128000</storage>
    <!-- Start around the town square instead of anywhere on the map. -->
    <location>
      <x_pos distribution="normal" mean="150" std="20" min="0" max="300" />
      <y_pos distribution="normal" mean="150" std="20" min="0" max="300" />
    </location>
    <idleConsumption>0.078</idleConsumption>
    <maxConsumption>3.3</maxConsumption>
    <batteryCapacity>18.75</batteryCapacity>
    <initialBatteryLevel>100</initialBatteryLevel>
    <isOrchestrator>false</isOrchestrator>
    <generateTasks>true</generateTasks>
  </device>
</edge_devices>

How a fleet of smartphones can be modeled in PureEdgeSim

</details>

Ease of use</summary>

A simulator helps identify which factors have the greatest impact on performance by evaluating different configurations, such as the number of entities, resource types, and network settings. Each module ships with a default implementation (the Default Mobility Model, the Default Computing Node class, and so on), and all modules expose adjustable settings. Users can therefore start from a working simulation and change only what their research requires. The examples, the manual, and the Javadoc provide further guidance, and the console reports incorrect input.

</details>

Extensibility</summary>

PureEdgeSim follows software engineering guidelines that favor reusability, accuracy, and extensibility. Users can create and incorporate custom models without changing the PureEdgeSim codebase. The code snippet in Create a custom scenario shows how custom mobility models, orchestrators, computing nodes, task generators, network models, simulation managers, and topology creators are integrated.

</details>

Correctness</summary>

Correctness is verified with an automated test suite. The JaCoCo coverage reports show how much of the codebase the tests exercise; more than 98% of instructions and 96% of branches are covered, measured on the full suite of 1103 tests. The tests focus on the technical feasibility and logical consistency of simulation scenarios, not on validating simulation outcomes. Validation of the models was performed through a case study, as described in the original PureEdgeSim publication.

</details>

Reliability</summary>

PureEdgeSim handles runtime errors with extensive exception handling. Errors do not stop the execution unless they concern critical parameters without which the simulation cannot continue. The models themselves are read-only, and only the output and configuration files can be modified. Continuous integration (GitHub Actions) builds and tests the project on Linux and reports failures promptly.

</details>

Selected publications using PureEdgeSim

PureEdgeSim has been used to evaluate research on task orchestration, reinforcement learning, service placement, satellite edge computing, caching, networking, and energy-aware computing. The following is a selection of published work built on, extending, or independently evaluating the simulator.

  1. Mechalikh, C., Taktak, H., & Moussa, F. (2021). PureEdgeSim: A simulation framework for performance evaluation of cloud, edge and mist computing environments. Computer Science and Information Systems, 18(1), 43-66. doi:10.2298/CSIS200301042M
  2. Mechalikh, C., Silem, A. E. H., Safavifar, Z., & Golpayegani, F. (2025). Quality matters: A comprehensive comparative study of edge computing simulators. Simulation Modelling Practice and Theory, 138, 103042. doi:10.1016/j.simpat.2024.103042
  3. Safavifar, Z., Gyamfi, E., Mangina, E., & Golpayegani, F. (2024). Multi-objective deep reinforcement learning for efficient workload orchestration in extreme edge computing. IEEE Access, 12, 74558-74571. doi:10.1109/ACCESS.2024.3405411
  4. Safavifar, Z., Machalikh, C., Xie, J., & Golpayegani, F. (2025). Sustainable dependent sub-tasks orchestration at extreme edge computing: A partitioning-based deep reinforcement learning approach. ACM Journal on Computing and Sustainable Societies, 3. doi:10.1145/3723037
  5. Briggs, I., Ivy, V., Berdik, D., Wedyan, F., & Jararweh, Y. (2022). Modeling and simulation of 5G-based edge networks for lightweight machine learning applications. 2022 IEEE Symposium on Computers and Communications (ISCC). doi:10.1109/ISCC55528.2022.9912802
  6. Islam, A., & Ghose, M. (2026). MECSim: A comprehensive simulation platform for multi-access edge computing. Journal of Systems Architecture, 173, 103706. doi:10.1016/j.sysarc.2026.103706
  7. Bendaouch, F., Zaydi, H., Merzouk, S., & Assoul, S. (2025). Benchmarking IoT simulation frameworks for edge-fog-cloud architectures: A comparative and experimental study. Future Internet, 17(9), 382. doi:10.3390/fi17090382

More research built on PureEdgeSim</summary>

Reinforcement learning and deep learning scenarios

  1. Mechalikh, C., Taktak, H., & Moussa, F. (2020, April). A fuzzy decision tree based tasks orchestration algorithm for edge computing environments. In International Conference on Advanced Information Networking and Applications (pp. 193-203). Springer, Cham. Algorithm available here.
  2. Safavifar, Z., Ghanadbashi, S., & Golpayegani, F. (2021, November). Adaptive workload orchestration in pure edge computing: A reinforcement-learning model. In 2021 IEEE 33rd International Conference on Tools with Artificial Intelligence (ICTAI) (pp. 856-860). IEEE.
  3. Neelakantam, G., Onthoni, D. D., & Sahoo, P. K. (2020). Reinforcement learning based passengers assistance system for crowded public transportation in fog enabled smart city. Electronics, 9(9), 1501.
  4. Iftikhar, S., Golec, M., Chowdhury, D., Gill, S. S., & Uhlig, S. (2022). FogDLearner: A deep learning-based cardiac health diagnosis framework using fog computing. In Australasian Computer Science Week 2022 (pp. 136-144).

Satellite edge computing

  1. Wei, J., Cao, S., Pan, S., Han, J., Yan, L., & Zhang, L. (2020, June). SatEdgeSim: A toolkit for modeling and simulation of performance evaluation in satellite edge computing environments. In 2020 12th International Conference on Communication Software and Networks (ICCSN) (pp. 307-313). IEEE.
  2. Qin, J., Guo, X., Ma, X., Li, X., & Yang, J. (2022). Application and performance evaluation of resource pool architecture in satellite edge computing. Aerospace, 9(8), 451.

Data caching and placement

  1. Mechalikh, C., Taktak, H., & Moussa, F. (2019, July). Towards a scalable and QoS-aware load balancing platform for edge computing environments. In 2019 International Conference on High Performance Computing & Simulation (HPCS) (pp. 684-691). IEEE.
  2. Epifâneo, L., Correia, C., & Rodrigues, L. (2021, November). Cathode: A consistency-aware data placement algorithm for the edge. In 2021 IEEE 20th International Symposium on Network Computing and Applications (NCA) (pp. 1-10). IEEE.
  3. Khosroabadi, F., Fotouhi-Ghazvini, F., & Fotouhi, H. (2021). SCATTER: Service placement in real-time fog-assisted IoT networks. Journal of Sensor and Actuator Networks, 10(2), 26.
  4. Ferrucci, L., Mordacchini, M., Coppola, M., Carlini, E., Kavalionak, H., & Dazzi, P. (2020, June). Latency preserving self-optimizing placement at the edge. In Proceedings of the 1st Workshop on Flexible Resource and Application Management on the Edge (pp. 3-8).

Self-organized and energy-aware architectures

  1. Mechalikh, C., Taktak, H., & Moussa, F. (2019, June). A scalable and adaptive tasks orchestration platform for IoT. In 2019 15th International Wireless Communications & Mobile Computing Conference (IWCMC) (pp. 1557-1563). IEEE.
  2. Mordacchini, M., Ferrucci, L., Carlini, E., Kavalionak, H., Coppola, M., & Dazzi, P. (2021, September). Self-organizing energy-minimization placement of QoE-constrained services at the edge. In International Conference on the Economics of Grids, Clouds, Systems, and Services (pp. 133-142). Springer, Cham.

Software-defined networking and other use cases

  1. Okwuibe, J., Haavisto, J., Kovacevic, I., Harjula, E., Ahmad, I., Islam, J., & Ylianttila, M. (2021). SDN-enabled resource orchestration for industrial IoT in collaborative edge-cloud networks. IEEE Access, 9, 115839-115854.
  2. Kaneko, Y., Yokoyama, Y., Monma, N., Terashima, Y., Teramoto, K., Kishimoto, T., & Saito, T. (2020, September). A microservice-based industrial control system architecture using cloud and MEC. In International Conference on Edge Computing (pp. 18-32). Springer, Cham.
  3. Javaid, H., Saleem, S., Wajid, B., & Khan, U. G. (2021, May). Diagnose a disease: A fog assisted disease diagnosis framework with bidirectional LSTM. In 2021 International Conference on Digital Futures and Transformative Technologies (ICoDT2) (pp. 1-6). IEEE.
  4. Tiburski, R. T. (2021). Task scheduling and security for edge devices in internet of things applications (Doctoral dissertation).

</details>

If your paper uses PureEdgeSim, feel free to open a pull request and add it to this list.

Version history

The full release notes are maintained in CHANGELOG.md.

  • 6.0: service graphs gain realistic payloads, one end-to-end deadline per request, optional subtasks with SKIPPED, and request-level metrics; all twenty-four examples have a README, and Example24 replans a service graph every 30 seconds.
  • 5.9: nodes keep separate uplink and downlink (issue #47), the wireless energy model charges each direction correctly, the CSV network usage column includes MAN and WAN, tasks of dead devices are counted as not generated, device types are allocated without truncation, settings/ and output/ moved to the repository root, every run writes run.properties with a snapshot of its settings, node-generation errors stop the run with the file and element, and failing tests fail the build.
  • 5.8: the quick start example Example1 is compiled by the default build, and XChart is updated to 3.8.8, clearing four medium advisories.
  • 5.7: probability distributions for every scenario parameter, sixteen distribution types, nine mobility models selectable per device type, placement hotspots, and a random_seed parameter for reproducible runs.
  • 5.6: self-documenting simulation parameter files for the default, example, and test configurations, with corrected guidance for ranges, orchestrators, and registry modes.
  • 5.5: comprehensive JUnit 5 test suite, JaCoCo coverage reporting, and a GitHub Actions coverage workflow.
  • 5.1: faster simulations, batched task scheduling, improved extensibility, and the initial energy model improvements.

Roadmap

Usability work, in the order it is planned. The XML formats and the setter-based extension API stay unchanged, so existing scenarios and published results keep working.

Phase 1: trust and hygiene

  • Make the build fail when a test fails, instead of ignoring test failures.
  • Replace the remaining printStackTrace() calls in node generation with parser-style errors (file, element, value, cause) that stop the run.
  • Move settings/ and output/ to the repository root, update the defaults, and remove the legacy PureEdgeSim/com and PureEdgeSim/examples copies.
  • Write a run.properties file into each output folder with the resolved settings, the seed, the version, and the git commit.

Phase 2: one command to run and inspect

  • Add a single java -jar entry point that runs a settings folder with overrides and prints a compact result table.
  • Add validate, which aggregates all configuration errors, and explain, which prints the resolved scenario.
  • Make charts headless-safe and optional, and write a self-contained report.html per run.
  • Replace the verbose console stream with a progress line and an ETA, moving the event log behind --verbose.

Phase 3: sweeps and reproducibility

  • Add a sweep command that runs a parameter grid, merges the rows into one CSV, and plots the comparison.
  • Ship create scenario scaffolding and a Maven archetype for custom models.
  • Publish a shaded CLI jar as a release artifact.
  • Add a troubleshooting page that maps common exceptions to their causes and fixes.

Phase 4: extensibility

What is already available:

  • Eight setter-based extension points on SimulationAbstract, plus setCustomTaskClass on the task generator: mobility model, computing node, task generator, edge orchestrator, network model, simulation manager, topology creator, and computing nodes generator.
  • A runnable example for every point, so each hook can be copied from working code. Example 23 covers the four that the earlier examples leave at their defaults, and examples/README.md lists them all.
  • Scenario behavior that needs no code: distributions for every numeric parameter, nine mobility models selectable per device type by name, and the architecture and algorithm matrix.
  • The constructor signatures, the event-tag range, and the topology-refresh rule documented in Customizing models, with unit and integration tests for the custom models.
  • Every model replaced by composition: the framework has no compile-time switch, no fork, and no generated code.

What comes next:

  • A model registry so a settings file can name any custom class (task_generator, topology_creator, and the rest) instead of calling a setter.
  • create model scaffolding and a Maven archetype that generate a compilable custom model and its test.
  • A compatibility test that builds and boots every custom model of the examples, catching constructor or API drift before a release.
  • A cookbook page with the smallest working recipe per hook, each one linking to its runnable example.
  • ServiceLoader discovery for third-party model jars, so a custom model needs no edit to the scenario class.
  • A documented extension API policy: which base classes and methods stay compatible across minor releases.

Acceptance: a user picks a hook, generates or copies a model, names it in the settings file, and runs it without editing framework code.

Contributing and support

The development and maintenance of PureEdgeSim require considerable effort, and any form of contribution is encouraged.

  • Do not fork to implement your project. You are not supposed to modify the codebase. Extend it by creating subclasses instead. A fork with personal changes will miss bug fixes and performance improvements from the main project.
  • Report issues and ask questions in the issue tracker.
  • Contribute improvements through a pull request, including a test case when applicable.
  • If PureEdgeSim helps your work, please add a star to the repository and cite the papers above.

License

This project is licensed under the GNU General Public License v3.0.

Keywords

Edge computing simulator, fog computing simulator, mist computing, cloud computing simulation, IoT simulation framework, task offloading, workload orchestration, service placement, resource management, energy-aware computing, discrete-event simulation, Java, Maven, open source.

:arrow_up: Back to top