SwarmFabSim: A Simulation Framework for Bottom-up Optimization
in Flexible Job-Shop Scheduling using NetLogo
M. Umlauft
1 a
, M. Schranz
1 b
and W. Elmenreich
2 c
Lakeside Labs GmbH, Klagenfurt, Austria
Institute of Networked and Embedded Systems, University of Klagenfurt, Klagenfurt, Austria
Swarm Intelligence, Flexible Job-Shop Scheduling, Agent-based Modeling.
This paper models and simulates a semiconductor production plant organized by the job-shop principle as a
self-organizing system using swarm intelligence algorithms in an agent-based simulation tool. We model a
set of agents, including machines, workcenters, lots and processes. To simulate our model, we use NetLogo,
one of the most widely used agent-based simulation platforms. The framework for the simulation was built
as a structured system of code modules using a callback architecture that allows to exchange the used swarm
algorithm easily. The user can configure their own fab model and simulations via the user interface and
configuration files. The resulting log files include several key performance indicators: makespan, average
flow factor, and lot tardiness. We offer the framework including sample swarm algorithms running on NetLogo
version 6.1 and later as open source on GitHub.
The factory-wide scheduling of a production plant or-
ganized by the flexible job-shop principle is an NP-
hard challenging problem (Garey et al., 1976). A typ-
ical example for such a highly dynamic process or-
ganized by the job-shop principle is the production
of integrated circuits (ICs) in the semiconductor in-
dustry (Geng, 2018). For our use case, we consider
the so-called front end of line processing, where the
structures of the ICs are created on silicon wafers.
Our implementation is inspired by the real-world re-
quirements of the semiconductor manufacturer Infi-
neon Technologies
. In a fab, they need to sched-
ule between 400 and 1200 different stations in their
production plant. Typically, they produce more than
1500 different products in around 300 different pro-
cess steps, including lithography, doping, oxidation,
etching, and measuring (Geng, 2018).
As traditional optimization methods like linear op-
timization reach their limits in these settings due to
excessive computation time (Garey et al., 1976), we
propose this industrial setting as a novel field of ap-
plication for swarm intelligence. Swarm intelligence
algorithms use local rules and interactions and can be
simulated with agent-based modeling. Swarms in na-
ture typically solve complex problems using compa-
rably simple rules for their swarm agents. One ex-
ample is the foraging strategies of ants, which need
to solve the problem of coordinating exploration, i.e.,
searching for new, unknown food sources and ex-
ploitation, i.e., establishing transport routes to carry
the food into the nest (Dorigo and Stützle, 2004). Pre-
vious work has shown that such swarm algorithms
can be successfully adapted to technical applications
where a problem has to be solved in a complex
(technical) environment; for an overview, see e.g.,
(Schranz et al., 2020). Such swarm-based solutions
are of great interest because of their simple imple-
mentation and features of scalability, robustness, and
adaptivity (Prehofer and Bettstetter, 2005). However,
while a final swarm algorithm has a small compu-
tational footprint, defining a swarm algorithm for a
given problem is a non-trivial task (Elmenreich and
de Meer, 2008), which typically involves extensive
evaluations using a simulation of the target system
(Elmenreich et al., 2009). In many cases, the target
system contains a highly dynamic process that cannot
be optimized using analytical methods.
Therefore, in Section 2 we apply an agent-based
modeling and simulation approach for this industrial
Umlauft, M., Schranz, M. and Elmenreich, W.
SwarmFabSim: A Simulation Framework for Bottom-up Optimization in Flexible Job-Shop Scheduling using NetLogo.
DOI: 10.5220/0011274700003274
In Proceedings of the 12th International Conference on Simulation and Modeling Methodologies, Technologies and Applications (SIMULTECH 2022), pages 271-279
ISBN: 978-989-758-578-4; ISSN: 2184-2841
2022 by SCITEPRESS Science and Technology Publications, Lda. All rights reserved
setting using the agent-based simulation tool Net-
Logo (Section 2.1). In Section 2.2 we introduce
a modeling concept using different types of agents,
including workcenters, machines, and lots. These
agents are then implemented in the main contribu-
tion of this paper, the SwarmFabSim framework us-
ing NetLogo (Section 3), a system consisting of sev-
eral structured code modules that interact using a call-
back architecture. The user interface, Section 3.1,
and configuration files, Section 3.2, allow the user
to interact and configure the SwarmFabSim frame-
work according to the requirements of their own fab
model. Note that despite taking inspiration from
semiconductor manufacturing, our approach is ap-
plicable to other industries using flexible job-shop
scheduling by simply changing the configuration files
describing the concrete setting. We offer implemen-
tation insights on the architecture in Section 3.3, de-
scribe the base algorithms included with the frame-
work in Section 3.4, and explain the log files with
the implemented key performance indicators used for
evaluation in Section 3.5. After describing the func-
tionality, we present an example of a specific swarm
algorithm implemented on the basis of the Swarm-
FabSim framework in Section 3.6, namely a hormone
algorithm and the results from applying it to several
simulation scenarios. Finally, Section 4 shows the
related work on agent-based modeling environments
and other job-shop simulation environments, and Sec-
tion 5 concludes the paper.
Scheduling is one of the most studied combinatorial
problems typically addressed with linear optimiza-
tion. Nevertheless, these methods can only cope with
a subset of the plant and do not exploit the full opti-
mization potential (Lawler et al., 1993). So far, no op-
timal solution for job-shop scheduling has been devel-
oped using linear optimization that can be computed
in polynomial time (Zhang et al., 2009).
Therefore, we apply a novel approach, namely
swarm intelligence algorithms, which we simulate us-
ing agent-based modeling (ABM). We model the pro-
duction plant as a self-organizing system of homoge-
neous or heterogeneous agents inspired by fish, ants,
or birds’ natural swarm behavior. This approach al-
lows us to optimize the production plant from the
bottom-up instead of calculating a global optimiza-
tion solution. The benefits are low calculatory over-
head and high adaptability to local changing environ-
mental conditions (Heylighen, 2001), such as starva-
tion or machine downs. This is because the agents fol-
low their own rules and make decisions based on lo-
cal information instead of trying to calculate an over-
all solution. Applying ABM transforms the problem
from finding an overall solution to defining a dis-
tributed algorithm that finds the solution from the bot-
tom up.
ABM simulation is better suited to implementing
swarm algorithms than system-dynamics (stock and
flow) simulation or continuous simulation using dif-
ferential equations. In agent-based simulation, swarm
members can be modeled as agents who follow local
rules and typically interact/communicate with other,
nearby agents, the local environment, or information.
(Wilensky and Rand, 2015) give the following
guidelines when to use ABM:
Medium numbers: several dozen up to about
100000 agents. Our modeling problem consists of
up to several thousand agents (products and ma-
Heterogeneity: in ABM, agents can be as hetero-
geneous as necessary. ABM, therefore, lends it-
self well to modeling different product and ma-
chine types.
Complex but local interactions, as used in swarm
algorithms, are typical for ABM.
ABM allows for rich environments, which can
have agent-like rules. This can be used to, e.g.,
model complex machine queue manipulations in
our case.
Time: ABM is a model of process, which is a per-
fect fit to our problem domain.
Adaptation: almost no other simulation method
can model adaptation well. In ABM, agents’ ac-
tions are typically contingent on past history; i.e.,
agents can learn. This fits the swarm model very
2.1 NetLogo for ABM Simulation
NetLogo (Wilensky, 1999) is one of the most widely
used agent-based simulation platforms worldwide, is
free, well documented, actively maintained with a
mature code base, and offers many extensions. While
NetLogo is well known for its usage in education (esp.
about agent-based modeling and complex systems), it
has also been shown to be a mature platform able to
perform simulations of several thousand agents in fea-
sible computing time (Railsback and Grimm, 2019;
Railsback et al., 2017). For our own performance re-
sults, see Section 3 below. The NetLogo homepage
SIMULTECH 2022 - 12th International Conference on Simulation and Modeling Methodologies, Technologies and Applications
lists 3000+ research papers that have used NetLogo
as the simulation platform in the last 10 years.
NetLogo offers an interactive user interface and
easy visualization for rapid prototyping and an eas-
ily configurable batch mode (called BehaviorSpace)
to perform mass simulations with multiple parameter
settings and the desired number of replications where
it logs results to files. These resulting log files can
then be post-processed with any tool of choice (R,
Excel, etc.) to be statistically evaluated. In addi-
tion, NetLogo can be directly interfaced with other
programming languages such as Python (Gunaratne
and Garibay, 2021) or R (Thiele, 2014), supporting
co-simulation approaches.
Simulation in NetLogo is time-based on a discrete
scale using ticks. Different types of agents can be im-
plemented using so-called “breeds” and can interact
with each other either directly, based on proximity on
a plane of patches, based on their connection via a
network topology, or indirectly by leaving stigmergic
information in the environment.
2.2 Modeling Job-Shop Scheduling
From the considered production plant described in
Section 1, we identified machines, workcenters, pro-
cesses, lots and recipes as possible agents (find
more details on challenges in agent identification
in (Schranz et al., 2021)).
The semiconductor production plant can be rep-
resented with a directed graph G = (V, E), where the
nodes V consist of all machines M
, where m is the
machine type, and the edges E are defined between
two machines M
and M
if there exists a lot l
type t with a recipe R
that contains the processes P
and P
that can be executed at machine M
and ma-
chine M
, respectively, in direct succession. Addi-
tionally to this consideration, the edges E define the
neighborhood of each machine M
. The machines
can be single lot oriented (processing one lot after
the other), or batch-oriented (processing several lots
at once, such as a furnace). They know which pro-
cesses they can perform and what their current utiliza-
tion is. Furthermore, they can make local decisions,
e.g., re-ordering their queues.
A set of machines that can run the same or similar
processes P form a workcenter W M. The modeled
production plant contains several sets or workcenters
of machines W
= {M
, M
, . . . }.
In the semiconductor industry, the standard unit
of production is a lot that consists of 25 wafers, each
equipped with a transponder with a unique identifier.
In our model, we do therefore not consider single
wafers, but only lots
. Each product type t is defined
by a recipe R
which prescribes the processing steps
in the order necessary to manufacture this product. As
there typically are multiple machines that can perform
the same process, a lot l
can choose which of the suit-
able machines M
to use for each necessary process
step P
Historically, semiconductor manufacturing used
dispatching to assign lots to machines. In dispatching,
all machines M
that can perform a certain process
step P
share one queue Q
and lots are assigned to
machines by changing their position in the queue via
priority levels so that the next free machine will take
the lot with the highest urgency.
As fabs are being modernized, producers switch
to scheduling, where each machine M
has its own
queue Q
and use schedulers to optimize the assign-
ments of lots to queues for a whole workcenter of ma-
chines. Lots still get assigned priority levels that can
change their position in their assigned queue.
Therefore, in our model, as each lot is produced
step by step according to its recipe, there are two de-
cisions to be made at each step:
1. The position of the lot in the queue. In our im-
plementation, the queue can be re-ordered every
time a machine becomes free and wants to take a
lot from the queue.
2. If the model is run in scheduling mode, whenever
a lot needs to move to the next machine, it has to
choose the respective queue Q
of machine M
from all machines M
that can perform the next
process step P
These decision points are reflected in the call-
back API in our simulator implementation (see Sec-
tion 3.3).
We implemented the SwarmFabSim simulation
framework in NetLogo (compatible from version
6.1 up). Our framework supports dispatching and
scheduling modes, single lot oriented and batch ma-
chines, and an arbitrary number of machine and lot
types (only limited by available memory and CPU
power). In a performance test of a configuration of
10 000 lots being processed in SwarmFabSim, a Win-
dows 11 system with an AMD Ryzen Threadripper
3960X 24-Core Processor with 128 GB RAM run-
ning NetLogo 6.2.0 takes 24 hours and 52 minutes
If applied to other industries, the industry-specific unit
of production would be used in the model.
SwarmFabSim: A Simulation Framework for Bottom-up Optimization in Flexible Job-Shop Scheduling using NetLogo
to compute 30 simulation runs being scheduled with
the baseline algorithm (described in Section 3.4).
For prototyping and demonstrations, SwarmFab-
Sim can be started from the user interface (see Sec-
tion 3.1). The actual scenario to be simulated is de-
fined in a set of config files (Section 3.2). To run mass
simulations for simulation studies, we use the built-in
BehaviorSpace configuration tool where you can set
multiple parameter settings and the desired number
of replications. The resulting log files (Section 3.5)
can then be post-processed with any tool of choice
(R, Excel, etc.) to be statistically evaluated.
The NetLogo source code of SwarmFabSim plus
several configuration files are available as open-
source in a GitHub repository: https://swarmfabsim.
3.1 The User Interface
Figure 1: SwarmFab Simulation User Interface.
The simulation can be run in interactive mode from
the user interface shown in Figure 1. The user must
first choose several settings, such as which config file,
algorithm, and scheduling mode to use and can then
start the simulation by first pressing “Setup” and then
either run the simulation with “Go” or single-step
through the simulation with the “Step” button. The
“world” on the right then shows the machines and the
lots as they move through the fab.
3.2 Config Files
The simulation scenario is defined via a set of plain
text config files:
META: the meta config file contains the file names
of the MFILE, RFILE, and LFILE config files.
MFILE: contains the machine definitions. For each
machine type m, it defines the process id of the
process P
the machine can perform, the number
of machines, the processing time, the batch size
(a batch size of one defines a single lot oriented
machine), and, in case of a batch machine, a max-
imum waiting time W T that this machine will wait
for a batch to fill up before it starts processing.
RFILE: contains all recipes R
used for production
of the different lot types t. The recipes are sim-
ple lists of the necessary process steps P
in the
required order.
LFILE: defines how many lots should be produced
for each lot of type t according to the respective
recipe R
3.3 Architecture and Implementation
As shown in Figure 2, the main simulation loop
is contained in the file SwarmFab-Simulation.nlogo.
Besides the main code entry point and the general
declarations, this file also describes the UI, the Info
tab (for documentation) and the BehaviorSpace set-
tings. Auxiliary framework code is contained in the
following files: config-reader.nls, lots+products.nls,
machines.nls, vizualizations.nls.
Figure 2: Simulation Framework Architecture.
The callback architecture is realized via the API
(application programming interface) defined in file
hooks.nls: whenever an algorithm can possibly take
an action, the main code calls a hook function con-
tained in hooks.nls from which the respective algo-
rithm function is then called. To install an algorithm,
a file with the name algorithm-name.nls that imple-
ments the algorithm according to the hook API has
SIMULTECH 2022 - 12th International Conference on Simulation and Modeling Methodologies, Technologies and Applications
to be provided, the algorithm has to be added to the
UI chooser “algorithm” and the algorithm functions
have to be added to the respective hook functions in
hooks.nls for callback. Algorithms can use helper
functions that are provided in the file helper-api.nls.
Due to this decoupling, the algorithm implementer
never has to touch or even read the actual framework
code. The hook API contains the following functions:
init called upon startup (mandatory).
choose-queue(lot): is called for the algorithm to
choose which machine a given lot shall go to next.
When the simulation is in dispatching mode, this
function is not called, and the lot is automatically
put into the common queue that serves all ma-
chines capable of the necessary next process step.
take-from-queue(machine): after a machine has
finished a process and has become free again, it
takes a new lot from its queue. This callback pro-
vides the algorithm a chance to re-prioritize lots
in the queue (mandatory).
move-out: this function is called just as a lot is about
to leave a machine at the end of processing. At
this point, an algorithm can collect data or update
data at the machine (mandatory).
tick-start, tick-end: are called at the start and end of
every tick respectively. Can be used to update
data, such as evaporating pheromones (manda-
tory, but can be empty).
do-plotting: allows the algorithm to update the plot
window on the UI (optional).
3.4 Base Algorithms
The framework provides the following three base al-
gorithms as demo code for algorithm implementers
and as a baseline for performance comparisons.
Demo, Basic these algorithms are provided mainly
as demonstration for algorithm implementers.
They demonstrate different approaches to select-
ing a queue, how to make algorithm data persis-
tent between callbacks and how to use the plot
window from an algorithm.
Baseline is a memoryless/stateless algorithm pro-
vided as a reference for performance compar-
isons. For the choose-queue callback it differen-
tiates between single lot oriented and batch ma-
chines. For the former, it chooses the shortest
queue, while for the latter it looks for the queue
where the least amount of lots of the current type
is missing to fill an already waiting, semi-filled
batch. If there are no partially filled batches in
any of the potential queues, it chooses the queue
with the least overall queue length (considering
all batches of all other lot types) to start a new
batch of the current type. For the take-from-queue
callback, it differentiates between single lot ori-
ented machines where it uses a FIFO approach
and batch machines, where, if a full batch is avail-
able, that batch is chosen. If several full batches
exist, one is chosen at random. If no full batch
exists, the machine waits up to a maximum wait-
ing time W T (as specified in the MFILE config
file, see Section 3.2). After the W T timeout, the
largest batch is chosen (in case of contention, one
is chosen at random). If a batch fills up during
W T , it is chosen immediately.
3.5 Log File Output
When the SwarmFab simulation is run from Behav-
iorSpace (the standard method to run multiple simu-
lations for a study in NetLogo), it produces two types
of result log files: a *-kpi.csv file and a *-table.csv
file. Both files use a plain text, comma-separated
value format which can be post-processed with any
tool of choice for handling tabular data, such as R,
Excel, etc. Further values of interest can be logged by
adding them to the settings in BehaviorSpace.
3.6 Case Study: The Hormone
Algorithm for Fab Optimization
Artificial hormone algorithms are inspired by the bi-
ological endocrine system adjusting the metabolism
of tissue cells in our body (Turing, 1952; Sobe et al.,
2015). In our case study, we use artificial hormones
to express the urgency of a lot and the need for at-
tracting incoming lots by the machines. Artificial hor-
mone is produced by the machines in the production
process and can diffuse through the production sys-
tem along with the lot processing steps. Lots, being
swarm members, are attracted by the hormone level of
a machine. For each processing step, a corresponding
hormone type exists. Hormones can be at any ma-
chine, and different hormone types can be at the same
machine. Every simulation tick hormone degrades
exponentially at a given rate α. Machines produce
hormone to attract lots. The hormone production is
guided by the queue length of the incoming lots. The
more lots are already waiting at a machine, the less
hormone is produced. In contrast, a machine that is
about to run out of lots to be processed will produce
more hormone. Machines are linked via recipes. If
a recipe has a process of two machines in subsequent
steps, the downstream machine (that will process the
SwarmFabSim: A Simulation Framework for Bottom-up Optimization in Flexible Job-Shop Scheduling using NetLogo
lot later) is linked to the upstream machine (that pro-
cesses the machine before).
Table 1: Parameter settings for the artificial hormone algo-
rithm (Elmenreich et al., 2021).
Parameter Value
Evaporation α .3
Pull factor smoothing β 1
Upstream diffusion γ .5
Downstream diffusion δ .2
Attraction ε .8
The algorithm is based on five parameters that al-
low fine-tuning the respective mechanisms; the used
parameters are depicted in Table 1. A more detailed
description of the algorithm and its parameters can be
found in (Elmenreich et al., 2021).
We evaluated the artificial hormone algorithm in
three scenarios modeled after processes in a typical
semiconductor fab. Each scenario differs significantly
by the number of machines, with scenario SFAB be-
ing the smallest and scenario LFAB being the largest
setup. The LFAB scenario also has a higher num-
ber of product types and lots per type than the SFAB
and MEDIUM scenarios. The parameters for the three
scenarios are depicted in Table 2.
Table 3 depicts the distribution parameters used
to create machines for a simulation, where N(µ,σ
depicts a Normal Distribution and U(a, b) a uniform
distribution. Negative values from the normal distri-
bution have been capped for parameters that cannot
be negative, like process time.
For the evaluation, each scenario setting has been
run 30 times, and the average value is compared to the
performance of the baseline and the basic algorithms.
Processing 30 runs on a Windows 11 system with an
AMD Ryzen Threadripper 3960X 24-Core Processor
with 128 GB RAM running NetLogo 6.2.0 takes 0.35
hours for the SFAB scenario and 424 hours for the
LFAB scenario. The algorithm is evaluated according
to three performance metrics: Average flow factor, av-
erage tardiness, and average uptime utilization. Tardi-
ness describes how much additional time (due to lots
waiting in a queue) has been accumulated until pro-
duction of the lot. Flow factor describes the relation
between the actual production time and the minimum
production time. Uptime utilization represents how
much time a machine has been in operation.
Tables 4, 5, and 6 depict a comparison between
the performance of the reference algorithms basic and
baseline and the artificial hormone algorithm. All
three scenarios depict promising improvements for
average flow factor (FF), average tardiness (TARD),
and average uptime utilization (UTIL).
In most cases, factory simulation is done using dis-
crete event process flow simulation with simulators
specific to the respective application domain. For
semiconductor manufacturing, examples include Au-
toMod / AutoSched AP
or D-Simlab/D-Simcon
For our research, the level of detail supported in these
types of simulators is usually too high. Also, as they
do not support agent-based modeling, they do not lend
themselves to modeling swarm algorithms.
A simulation language that is not specific to a cer-
tain application domain is GPSS (General Purpose
Simulation System), a discrete time simulation lan-
guage originally developed by IBM. It is used pri-
marily as a process flow-oriented simulation language
which is particularly well-suited for problems such as
modeling factory operations. While its popularity has
declined over the years, several implementations still
exist, such as GPSS World by Minuteman
by the Polytechnic University of Catalonia. A ranked
list of the most popular discrete simulation software
platforms in commercial use is given in (Dias et al.,
An example of using NetLogo to simulate a pro-
duction process with a multiple ant colony approach
is shown in (Gwiazda et al., 2020). The authors show
how NetLogo can be used to model the production
process and how a swarm intelligence algorithm
such as an ant algorithm can be implemented in an
agent-based modelling simulator and used to solve the
job shop problem.
Zahmani and Atmani use a Netlogo simulation
to create job shop problems with a given value for
jobs and machines. The NetLogo simuation is cou-
pled with a genetic algorithm for discovering well-
working allocations of dispatching rules. (Habib Zah-
mani and Atmani, 2021) Pulikottil et al. review the
various frameworks and different technologies that
support multi-agent system use in manufacturing, the
various applications of multi-agent systems in this do-
main, and the current challenges in the development
of multi-agent systems in smart manufacturing. (Pu-
likottil et al., 2021) Alves et al. address the job shop
scheduling problem with a hybrid approach including
optimization and agents negotiating dynamically. The
agent-based model implemented in NetLogo is con-
nected with Matlab to exchange optimized schedul-
ing solutions. (Alves et al., 2018) Bagheri et al. de-
scribe the promising application of an artificial im-
SIMULTECH 2022 - 12th International Conference on Simulation and Modeling Methodologies, Technologies and Applications
Table 2: Parameters used to create the three evaluation scenarios.
Number of machine types 25 50 100
Number of machines per type U(2, 5) U(2, 10) U(2, 10)
Number of products 50 50 100
Recipe length U(90, 110) U(90, 110) U (90, 110)
Number of lots per type U(1, 10) U(1, 10) U(2, 10)
Table 3: Machine parameters used in the simulation.
Machine Parameter Value
Raw process time N(µ,σ
) with µ =
1.16, σ
= 0.32
Probability batch machine 50%
Batch size batch machines U(2, 8)
Waiting time batch machines U (1, 2)
Table 4: Evaluation of Artificial Hormone Algorithm in
large scenario (LFAB).
Basic Baseline Hormone
over Baseline
FF 3.60 3.47 3.03 12.29%
TARD 3287.3 3126.8 2566.4 17.05%
UTIL 24.33 22.71 21.91 3.28%
Table 5: Evaluation of Artificial Hormone Algorithm in
medium scenario (MEDIUM).
Basic Baseline Hormone
over Baseline
FF 3.46 3.21 2.87 9.64%
TARD 2757.8 2481.8 2081.4 14.52%
UTIL 21.42 23.87 23.53 1.60%
Table 6: Evaluation of Artificial Hormone Algorithm in
small scenario (SFAB).
Basic Baseline Hormone
over Baseline
FF 6.64 6.51 5.84 10.12%
TARD 7118.3 6971.1 6077.2 12.56%
UTIL 34.95 35.90 34.49 4.40%
mune algorithm for the flexible job-shop scheduling
problem. The flexible job-shop scheduling problem
has high relevance to the problem described in this
paper but does not have batch machines, which are
typical for semiconductor fabs. The artificial immune
algorithm is implemented in C++ and evaluated with
a set of tests based on reference data sets. (Bagheri
et al., 2010) Zhang et al. show how agent-based mod-
eling can be applied to job-shop production simu-
lation conceptually. (Zhang et al., 2019) Shukla re-
views multi-agent systems for production scheduling
problems in manufacturing systems. They show how
multi-agent systems can provide advantages over tra-
ditional approaches and present a conceptual frame-
work for implementing production scheduling sys-
tems using multi-agent systems. (Shukla, 2018)
There are many ABM simulation platforms that
can be used to implement a job-shop production simu-
lation. For a comprehensive overview see e.g., CoM-
SES Net / OpenABM
. In the following we list the
most well-known ones besides NetLogo:
Mason is a joint effort between George Mason Uni-
versity’s Evolutionary Computation Laboratory
and the GMU Center for Social Complexity. It is
a discrete-event multi-agent simulator core writ-
ten in Java as a basis for custom-written simula-
tions. It has been in development since 2003. At
the time of writing, it is actively supported
Repast The Repast Suite is a family of advanced,
free, and open source agent-based modeling
toolkits that have been under development for
over 15 years. There are different versions of the
toolkit based on Java, C++, and Python
Mesa is an open source ABM framework written in
Python. Its goal is to be the Python 3-based alter-
native to NetLogo, Repast, or MASON allowing
for easy integration with Python’s data analysis
tools. The tool has been developed since 2015
Anylogic is a commercial platform that supports
System Dynamics, Process-centric discrete event
modeling, and Agent Based Modeling. It is used
in several industries, including manufacturing,
supply chain, transportation and logistics, etc
MARS (Multi-Agent Research and Simulation) runs
on .NET Core. It is developed at the Department
of Computer Science at Hamburg University of
Applied Sciences
SwarmFabSim: A Simulation Framework for Bottom-up Optimization in Flexible Job-Shop Scheduling using NetLogo
This paper has depicted the use of NetLogo to
model and simulate a factory producing according
to the job-shop manufacturing principle. We con-
tributed SwarmFabSim, a modular simulation frame-
work written in NetLogo that can apply various al-
gorithms to optimize a make-to-order manufacturing
system and supports multiple configurable scenarios.
The evaluation framework was used to assess the ef-
fectiveness of an artificial hormone algorithm com-
pared to a naïve basic implementation and a reference
baseline algorithm. The evaluation was based on three
key performance indicators: Flow factor, delay, and
utilization. The simulations show promising results
of the artificial hormone algorithm in three reference
scenarios with significant improvements over the ref-
erence algorithms. The implementation of the simula-
tion environment is published as open source in a Git
. Readers are welcome to contribute with
their ideas and developments.
This work was performed in the course of project
ML&Swarms supported by KWF-React EU under
contract number KWF-20214|34789|50819.
Alves, F., Varela, M. L. R., Rocha, A. M. A., Pereira, A. I.,
Barbosa, J., and Leitão, P. (2018). Hybrid system
for simultaneous job shop scheduling and layout opti-
mization based on multi-agents and genetic algorithm.
In International Conference on Hybrid Intelligent Sys-
tems, pages 387–397. Springer.
Bagheri, A., Zandieh, M., Mahdavi, I., and Yazdani, M.
(2010). An artificial immune algorithm for the flex-
ible job-shop scheduling problem. Future Generation
Computer Systems, 26(4):533–541.
Dias, L. M., Vieira, A. A., Pereira, G. A., and Oliveira,
J. A. (2016). Discrete simulation software ranking—a
top list of the worldwide most popular and used tools.
In 2016 Winter Simulation Conference, pages 1060–
1071. IEEE.
Dorigo, M. and Stützle, T. (2004). Ant Colony Optimiza-
tion. A Bradford Book, The MIT Press.
Elmenreich, W. and de Meer, H. (2008). Self-organizing
networked systems for technical applications: A dis-
cussion on open issues. In K.A. Hummel, J. S., editor,
Proceedings of the Third International Workshop on
Self-Organizing Systems, pages 1–9. Springer Verlag.
Elmenreich, W., D’Souza, R., Bettstetter, C., and de Meer,
H. (2009). A survey of models and design methods for
self-organizing networked systems. In Proceedings of
the Fourth International Workshop on Self-Organizing
Systems, volume LNCS 5918, pages 37–49. Springer
Elmenreich, W., Schnabl, A., and Schranz, M. (2021).
An artificial hormone-based algorithm for production
scheduling from the bottom-up. In Proceedings of the
13th International Conference on Agents and Artifi-
cial Intelligence. SciTePress.
Garey, M. R., Johnson, D. S., and Sethi, R. (1976).
The complexity of flowshop and jobshop scheduling.
Mathematics of Operations Research, 1(2):117–129.
Geng, H., editor (2018). Semiconductor Manufacturing
Handbook. McGraw-Hill Education.
Gunaratne, C. and Garibay, I. (2021). NL4Py: Agent-
based modeling in Python with parallelizable NetL-
ogo workspaces. SoftwareX, 16:100801.
Gwiazda, A., Bana
s, W., S˛ekala, A., Topolska, S., and
Hryniewicz, P. (2020). Modelling of production pro-
cess using multiple ant colony approach. Interna-
tional Journal of Modern Manufacturing Technolo-
gies, XII(1):201–213.
Habib Zahmani, M. and Atmani, B. (2021). Multiple dis-
patching rules allocation in real time using data min-
ing, genetic algorithms, and simulation. Journal of
Scheduling, 24(2):175–196.
Heylighen, F. (2001). The science of self-organization and
adaptivity. The Encyclopedia of Life Support Systems,
Lawler, E. L., Lenstra, J. K., Kan, A. H. R., and Shmoys,
D. B. (1993). Sequencing and scheduling: Algorithms
and complexity. Handbooks in Operations Research
and Management Science, 4:445–522.
Prehofer, C. and Bettstetter, C. (2005). Self-organization
in communication networks: Principles and design
paradigms. IEEE Communications Magazine, pages
Pulikottil, T., Estrada-Jimenez, L. A., Rehman, H. U.,
Barata, J., Nikghadam-Hojjati, S., and Zarzycki, L.
(2021). Multi-agent based manufacturing: current
trends and challenges. In 2021 26th IEEE Interna-
tional Conference on Emerging Technologies and Fac-
tory Automation (ETFA), pages 1–7. IEEE.
Railsback, S., Ayllón, D., Berger, U., Grimm, V., Lytinen,
S., Sheppard, C., and Thiele, J. C. (2017). Improving
execution speed of models implemented in netlogo.
Journal of Artificial Societies and Social Simulation.
Railsback, S. F. and Grimm, V. (2019). Agent-based and
individual-based modeling: a practical introduction.
Princeton university press, "2nd" edition.
Schranz, M., Umlauft, M., and Elmenreich, W. (2021).
Bottom-up job shop scheduling with swarm intelli-
gence in large production plants. In Proceedings of
the 11th International Conference on Simulation and
Modeling Methodologies, Technologies and Applica-
tions, pages 327–334.
Schranz, M., Umlauft, M., Sende, M., and Elmenreich, W.
(2020). Swarm robotic behaviors and current applica-
tions. Frontiers in Robotics and AI, 7:36.
SIMULTECH 2022 - 12th International Conference on Simulation and Modeling Methodologies, Technologies and Applications
Shukla, O. J. (2018). Agent Based Production Scheduling
in Job Shop Manufacturing System. . . . PhD thesis,
MNIT Jaipur.
Sobe, A., Elmenreich, W., Szkaliczki, T., and Böszörmenyi,
L. (2015). SEAHORSE: Generalizing an artificial hor-
mone system algorithm to a middleware for search and
delivery of information units. Computer Networks,
Thiele, J. C. (2014). R marries NetLogo: introduction to the
RNetLogo package. Journal of Statistical Software,
Turing, A. M. (1952). The chemical basis of morphogene-
sis. Philosophical Transactions of the Royal Society of
London. Series B, Biological Sciences, 237(641):37–
Wilensky, U. (1999). Netlogo. http://ccl.northwestern.edu/
Wilensky, U. and Rand, W. (2015). An Introduction to
Agent-Based Modeling: Modeling Natural, Social,
and Engineered Complex Systems with NetLogo. MIT
Zhang, G., Shao, X., Li, P., and Gao, L. (2009). An effec-
tive hybrid particle swarm optimization algorithm for
multi-objective flexible job-shop scheduling problem.
Computers & Industrial Engineering, 56(4):1309–
Zhang, T., Xie, S., and Rose, O. (2019). Agent-based sim-
ulation of job shop production. Simul. Notes Eur.,
SwarmFabSim: A Simulation Framework for Bottom-up Optimization in Flexible Job-Shop Scheduling using NetLogo