PyLogo: A Python Reimplementation of (Much of) NetLogo

Russ Abbott and Jung Soo Lim

Department of Computer Science, California State University, Los Angeles,

5151 State University Drive, Los Angeles, California, U.S.A.

Keywords:

ABM, Agent-Based Modeling, NetLogo, PyLogo, Python, Simulation.

Abstract:

In the world of Agent-Based Modeling (ABM), NetLogo reigns as the most widely used platform. The NetL-

ogo world of agents interacting in a two-dimensional space seems to provide just the right level of simplicity

and abstraction for a wide range of models. Regrettably, the NetLogo language makes model development

more painful than necessary.

This combination—widespread popularity accompanied by unnecessary coding pain—motivated the develop-

ment of PyLogo, a NetLogo-like modeling and simulation environment in which developers write their models

in Python. Although other NetLogo-like systems exist, as far as we know PyLogo is the only NetLogo-like

system in Python at this level of completeness. This paper examines a number of issues with the NetLogo

language and offers a simple, illustrative PyLogo example model.

PyLogo is open source and is available at this GitHub repository. We welcome collaborators.

1 INTRODUCTION

For a senior-level modeling and simulation class we

developed a pure-Python version of NetLogo.

Why NetLogo?

• Due to its widespread adoption, NetLogo has be-

come the standard platform for communicating

and implementing ABMs (Thiele, 2014).

• NetLogo is recognized as robust and powerful but

nevertheless easy to learn (Badham, 2015).

Why Python?

• The NetLogo language makes the development of

non-trivial models unnecessarily painful.

• Python is one of the most straightforward pro-

gramming languages. It is often used to intro-

duce students to programming and yet has become

the de facto scripting language for many areas of

computer science (Nagpal and Gabrani, 2019).

Our Objectives for This Paper.

• To document some of NetLogo’s awkward fea-

tures. (Section 3).

• To discuss a small PyLogo model. (Section 4).

2 RELATED WORK

There are, of course, many modeling and simulation

systems, both agent-based and non-agent-based. The

following discusses only agent-based systems.

First the classics. Repast (North et al., 2013) and

then MASON (Luke et al., 2005) established agent-

based modeling as a distinct discipline. They re-

main among the most widely-used ABM systems, es-

pecially for complex models or models with many

agents. These were followed by AnyLogic (Grigoryev,

2015). All use Java for model development.

More recent agent-based systems include:

• ABCE (Taghawi-Nejad et al., 2017), a Python-

based platform tailored for economic phenomena;

• Agents.jl (Vahdati, 2019), a Julia-based relative

newcomer; and

• GAMA (Taillandier et al., 2019), which describes

itself as an environment for spatially explicit

agent-based simulations. GAMA models are

written in GAML, a scripting-like language.

NetLogo (Tisue and Wilensky, 2004a; Tisue and

Wilensky, 2004b) teased the possibility of writing

models in pseudo-English.

It stands apart as the best platform for both begin-

ners and serious scientiﬁc modelers. Many if not

most public scientiﬁc ABMs are implemented in

Abbott, R. and Lim, J.

PyLogo: A Python Reimplementation of (Much of) NetLogo.

DOI: 10.5220/0010466401990206

In Proceedings of the 11th International Conference on Simulation and Modeling Methodologies, Technologies and Applications (SIMULTECH 2021), pages 199-206

ISBN: 978-989-758-528-9

199

NetLogo, which has become a standard platform

for agent-based simulation (Railsback et al., 2017).

NetLogo’s popularity triggered work in multiple

directions. For example, mechanisms exist for inter-

acting with NetLogo from other languages.

• NetLogo Mathematica allows Mathematica to

control NetLogo. (Bakshy and Wilensky, 2007).

• NL4Py (Gunaratne and Garibay, 2018) and Pynet-

logo (Jaxa-Rozen and Kwakkel, 2018) offer ac-

cess to and control over NetLogo from Python. A

NetLogo extension allows calls to Python.

• RNetLogo (Thiele, 2014) enables one to write R

code that calls NetLogo. A NetLogo extension

allows one to call R from NetLogo.

Finally, a number of NetLogo-like systems allow

model developers to write in a language other than the

standard NetLogo script.

• ReLogo (Ozik et al., 2013), an offspring of Repast,

allows users to write models in Groovy, a script-

like version of Java.

• Mesa (Masad and Kazil, 2015) comes closest to

PyLogo. Although Mesa less complete (no links),

Mesa models are written in Python. Mesa consists

of a “headless” modeling component along with a

JavaScript visualization component.

NetLogo Critiques. We found no earlier work

critiquing NetLogo as a language.

3 THE NetLogo LANGUAGE

This section discusses the NetLogo language and

some of the issues that motivated PyLogo.

We wish to acknowledge (again) NetLogo’s ex-

traordinary success. Wilensky (Wilensky, 2020) re-

ports that since January 2019 there have been at least

700k unique visitors to the NetLogo website, 130k

NetLogo downloads, 7000 papers that use NetLogo,

and 600 courses that use NetLogo. Wilensky believes

these are signiﬁcant under-estimates.

3.1 A Brief History of NetLogo

Tisue and Wilensky (Tisue and Wilensky, 2004a),

(Tisue and Wilensky, 2004b) discuss NetLogo.

Logo, as originally developed by Seymour Papert

and Wally Feurzeig (Feurzeig and Papert, 1967), is

derived from Lisp but has a syntax that seems to

non-programmers to be similar to English.

Although Logo’s debt to Lisp is clear, see (Harvey,

1982), its commitment to being “English-like” led to

an imperative-style.

Tisue and Wilensky continue:

Logo is best known for its “turtle graphics,” in

which a virtual being or “turtle” moves around the

screen drawing ﬁgures by leaving a trail behind it-

self. NetLogo generalizes Logo’s single turtle to

support hundreds or thousands of turtles all mov-

ing around and interacting.

Different “breeds” of turtle may be deﬁned, and

different variables and behaviors can be associated

with each breed. In effect, NetLogo adds a primi-

tive object-oriented overlay to Logo.

Turtles inhabit a grid of programmable “patches.”

Collectively, the turtles and patches are called

“agents.” Agents can interact with each other.

A collection of agents—e.g., the set of all turtles or

the set of all patches—is known as an agentset. One

can make custom agentsets on the ﬂy: for example

the set of all red turtles or the set of patches with

a given X coordinate. One can ask all agents in an

agentset, to perform a series of operations.

NetLogo is speciﬁed in a clearly-written user

manual (Wilensky, 2019).

The remainder of this section discusses concerns

about the language.

3.2 Keywords

NetLogo is somewhat ambiguous about keywords.

The Programming Guide says,

The only keywords are globals, breed, turtles-

own, patches-own, to, to-report, and end, plus

extensions and the experimental

includes.

But tacking -own onto a breed name makes the

combination a keyword: if cats is a breed, cats-own

functions like turtles-own.

NetLogo has a number of such “keyword-

constructors.” For example, breeds of links are de-

clared using the “keywords” undirected-link-breed

and directed-link-breed.

Furthermore,

Built-in primitive names may not be shadowed or

redeﬁned, so they are effectively a kind of keyword.

Although the NetLogo dictionary lists roughly

500 built-in names, this is less of a problem than one

might imagine. Most built-in names are either con-

stants (like true) or function names (like sin).

More confusingly, control constructs such as if,

ifelse, ifelse-value, and while appear as if they were

keywords. According to the Programming Guide,

Control structures such as if and while are special

forms. You can’t deﬁne your own special forms, so

you can’t deﬁne your own control structures.

Inﬁx operators such as of and with, and identiﬁers

such as self and myself also function like keywords.

SIMULTECH 2021 - 11th International Conference on Simulation and Modeling Methodologies, Technologies and Applications

200

It would appear that and, or, set, let, ﬁlter, map.

and other functions are also deﬁned via special forms.

It adds confusion to deny keyword status to identiﬁers

deﬁned via special forms.

Finally, breed is both a built-in own variable,

which records—and can be set to change—an entity’s

breed, and a keyword used to declare breeds.

3.3 A Primitive Object-oriented

Capability

NetLogo offers a primitive form of object-oriented

programming through its breed mechanism. If one

thinks of NetLogo’s turtle as similar to Python’s ob-

ject, a breed is something like a subclass of turtle.

Both turtles and breeds may have the equivalent of

instance variables—declared through the -own key-

word constructor.

But breeds differ in important ways from classes

in most object-oriented languages.

• one can’t declare a sub-breed of a breed;

• breed methods are not marked as restricted to

breed instances;

• even though patches are agents, one can’t create a

breed of patches; and

• when an entity’s breed variable is changed, say

from breed-1 to breed-2, it loses its breed-1 in-

stance variables and gains those of breed-2.

3.4 Sets and Lists

Sets and lists are treated as unrelated data structures.

This raises a couple of issues.

• Why limit sets to agents? Just as one can have lists

of both agents and numbers, one should be able to

have sets of numbers as well as sets of agents.

• More importantly, given a NetLogo function de-

ﬁned for one, there is generally a similar but

different function deﬁned for the other—creating

confusing redundancy. The following pairs of

functions operate on sets and lists respectively.

– ask and foreach

– with and ﬁlter

– of and map

In each case, the two functions provide very simi-

lar functionality. Replacing each pair with a single

function that operates on both sets and lists would

simplify the language and reduce the memory bur-

den on users. This is straightforward in Python

since sets and lists are both types of collections.

Following are some simple illustrative examples.

3.4.1 ask and foreach

Consider a world of ﬁve turtles and two lists, both or-

dered by who-number: a list of their heading degrees,

and a list of distances to move. We want our turtles

to turn by the indicated number of degrees and then

to move forward the indicated distance. This seems

tailor-made for foreach.

But turtles is an agentset and foreach requires

lists—and the problem requires that they be ordered.

Our solution will be to use sort-on [who] turtles

to convert the turtles agentset into an ordered list of

turtles. Then, since we are requiring the turtles to per-

form turtle methods, we will embed an ask in the fore-

ach anonymous procedure. Not very pretty code.

( f o r e a c h s o r t −on [ who ] t u r t l e s

[ 30 40 120 50 270 ]

[ 40 20 50 10 30 ]

[ [ t deg d i s t ] −>

ask t [ r t deg fd d i s t ] ] )

A Python version is much simpler. (We assume

that turtle(n) retrieves the turtle with who-number n,

that rt() and fd() are turtle methods, and that count()

has been imported from itertools).)

f o r who , deg , d i s t i n

z i p ( co u nt ( ) ,

[ 30 , 40 , 120 , 50 , 270 ] ,

[ 40 , 20 , 50 , 10 , 30 ] ) :

t = t u r t l e ( who )

t . r t ( de g )

t . f d ( d i s t )

3.4.2 with/ﬁlter, of/map, and List

Comprehensions

One of Python’s most powerful and intuitive con-

structs is the list comprehension. Wikipedia lists

nearly three dozen languages that include it. Python

style guides, such as GitHub’s, generally recommend

them over map and ﬁlter. Yet NetLogo does not offer

list comprehensions.

It is possible, if somewhat ugly, to create a simple

NetLogo equivalent using of and with. For example,

assuming t.who retrieves turtle t’s who-number, one

can mimic Python’s

[ t . who ∗ t . who f o r t i n t u r t l e s

i f t . who % 2 == 1 ]

with

[ who ∗ who ] o f t u r t l e s

w i t h [ who mod 2 = 1 ]

PyLogo: A Python Reimplementation of (Much of) NetLogo

201

The Python list comprehension is well-known and

widely used. A general NetLogo list comprehension

would be welcome.

3.5 Reporters

NetLogo uses the term reporter in multiple—and of-

ten confusing—ways.

• Primitive Reporters, such as turtle and list.

• User-deﬁned Procedures created with to-report.

• ask-reporters. Many NetLogo primitives—such

as all? max-n-of (and similar), of, sort-on, while,

and with (and similar)—provide ask-like contexts

for reporters. By that we mean that these reporters

run in the same sort of context in which ask com-

mand blocks run, i.e., as something like “meth-

ods” of the agents running them. In the example

at the end of the previous section, the who in the

reporter [who * who] referred to the who-number

of the then-active turtle.

• Anonymous Reporters. These may or may not

work as one would expect.

Consider the following example. (The parenthe-

ses are required for correct parsing.)

t u r t l e ( [ who ] o f a− t u r t l e + 1 )

Assuming a-turtle refers to a turtle, this reports

the turtle with the successor who-number.

One can deﬁne a reporter, named, say, next-turtle,

to perform this function.

to −r e p o r t next − t u r t l e [ a−t u r t l e ]

r e p o r t t u r t l e ( [ who ] o f a− t u r t l e + 1 )

end

When applied,

next − t u r t l e some−t u r t l e

produces the correct answer. But attempting

[ next − t u r t l e ] o f some− t u r t l e

produces the error message: NEXT-TURTLE expected

1 input. (See Section 3.8 for why.) Furthermore, one

may not wrap next-turtle in an anonymous reporter.

Agent primitives such as of and with don’t accept

anonymous procedures.

The following are all equivalent.

0 . next − t u r t l e some− t u r t l e ; ; a s a b o v e

1 . [ next − t u r t l e s e l f ] o f some− t u r t l e

2 . f i r s t map n e x t − t u r t l e

( l i s t some− t u r t l e )

3 . ( r u n r e s u l t

[ t −> n e xt − t u r t l e t ] some− t u r t l e )

Let’s consider 1 - 3 in order.

1. This illustrates why we call the reporter associ-

ated with of an ask-reporter. That’s how self gets

some-turtle as its value.

2. This illustrates how map is special. Although

its ﬁrst argument plays the same role as the of

reporter, the two reporters take different forms:

[next-turtle self] vs next-turtle.

3. runresult is required because it is not permissi-

ble to apply anonymous procedures to their argu-

ments in the same way that one applies standard

procedures to their arguments. That’s the case

even if the anonymous procedure is given a name.

[ n −> n + n ] k

and

to −r e p o r t t e s t −named−anon [ k ]

l e t d o u b l e [ n −> n + n ]

r e p o r t d o u b l e k

end

both generate the (unhelpful) error message:

Expected command. Also see Section 3.8.

3.6 The if and while Constructs Require

Different Condition Forms

The if family of statements requires a boolean expres-

sion as condition; while requires a reporter block.

i f e l s e 3 > 4 [ show 3 ] [ show 4 ]

parses and produces 4.

w h i l e [ 3 > 4 ] [ show 3 ]

parses and correctly produces nothing. Why require

users to remember which form is required?

3.7 Non-standard Terminology

NetLogo uses the terms reporter and report for con-

cepts for which virtually all other languages use func-

tion and return.

The functions word and sentence are also non-

standard and confusing.

• The function word converts its argument(s) to

strings, which it concatenates.

• The function sentence combines the functionality

of list and what might traditionally be called ﬂat-

ten. Confusingly, sentence has no speciﬁc con-

nection to words or strings.

SIMULTECH 2021 - 11th International Conference on Simulation and Modeling Methodologies, Technologies and Applications

202

3.8 Higher-order Functions

Since almost the very beginning, NetLogo has in-

cluded the standard trio of higher-order functions: ﬁl-

ter, map, and reduce. However, it appears to be quite

awkward for model developers to create and use their

own higher order functions.

Consider an attempted deﬁnition of the trivial

function application-of that expects a reporter proce-

dure as its ﬁrst argument and an argument for that re-

porter procedure as its second. application-of applies

its ﬁrst argument to its second and returns the result.

(One might want this if one wants to select a function

from a list and apply it to some element.)

to −r e p o r t a p p l i c a t i o n −o f [ f n a r g ]

r e p o r t f n a r g

end

The preceding fails to compile. But as we did in

Section 3.5, we can use the map trick.

to −r e p o r t a p p l i c a t i o n −o f [ f n a r g ]

r e p o r t f i r s t map f n ( l i s t a r g )

end

But attempted execution

a p p l i c a t i o n −o f l a s t a− l i s t

produces the error message: APPLICATION-OF ex-

pected 2 inputs. That’s the case even though the body

of the function executes without complaint.

f i r s t map l a s t ( l i s t [ 1 2 3 ] ) ; ; => 3

The problem is that it’s not possible to refer by

name to a function as an object—except as the ﬁrst

argument of map and other special cases.

Making the parentheses explicit, NetLogo parses

a p p l i c a t i o n −o f l a s t a− l i s t

a p p l i c a t i o n −o f ( l a s t ( a− l i s t ) )

So (almost) any time a procedure name appears, the

NetLogo parser takes it as a procedure call.

One work-around is to use anonymous proce-

dures. Suppose we deﬁne double and square.

to −r e p o r t d o u b l e [ n ]

r e p o r t n + n

end

to −r e p o r t s q u a r e [ n ]

r e p o r t n ∗ n

end

For a list containing those function, write

l i s t [ n −> d o u b l e n ] [ n −> s q u a r e n ]

rather than

l i s t d o u b l e s q u a r e

We could test this as follows.

to t e s t −a p p l i c a t i o n −o f [ k ]

l e t l s t l i s t [ n −> d o u b l e n ]

[ n −> s q u a r e n ]

f o r e a c h l s t [ f n −>

show a p p l i c a t i o n −o f f n k ]

end

t e s t −a p p l i c a t i o n −o f 6 ; ; => 12 36

3.9 Identiﬁers and Shadowing

In the following, NetLogo’s shadowing rules disallow

the parameters x (which is global) and dx (which is a

primitive) and the local variables y (which is global)

and z (which is a parameter name).

g l o b a l s [ x y ]

to t e s t −sc o p e [ x dx z ]

l e t y 3

l e t z 4

. . .

end

3.10 Square Brackets and Parentheses

Square brackets are required for the following.

• command block components of higher-order (and

control) constructs such as ask, carefully, crt, cro,

hatch, sprout, if, loop, repeat, while;

• reporter components of functions such as all?, ev-

ery, max-n-of, of, sort-on, with;

• anonymous expressions, which must be sur-

rounded by square brackets;

• “containers” for components of keyword con-

structs such as at-points (two levels), breed, ex-

tensions, globals, histogram, includes, -own;

• lists (but only of literals) in the code or of any

values in the output. The list [1 2] is ok, but the

would-be list [(turtle 0) (turtle 1)] is not.

• parameter lists;

PyLogo: A Python Reimplementation of (Much of) NetLogo

203

Figure 1: Starburst.

That’s too much of a burden for comfort.

Parentheses are required around any construct

that includes a function (such as foreach, ifelse, map,

list, and others) that (a) may take a variable number

of arguments and (b) is given two or more.

Parentheses are not required if only one argument

appears—except for list which requires parentheses

for one argument but not for two.

3.11 Stack Trace for Run-time Errors

NetLogo is inconsistent with respect to run-time

errors—sometimes displaying a stack trace and at

other times only an error notice, with no hint about

how the program got there. If a stack trace can be

provided in some situations, why not in all?

3.12 Dictionaries

Dictionaries are one of Python’s most useful features.

NetLogo’s table extension functions like a Python

dictionary. But table operations must include the pre-

ﬁx table::, which makes for cluttered code.

3.13 Dot Notation for Accessing

Instance Variables and Methods

Most object-oriented languages use dot-notation for

instance variables and methods. NetLogo fore-

goes dot notation: [who] of turtle-x rather than

turtle-x.who. Dot notation is simpler and cleaner.

4 STARBURST: A PyLogo MODEL

This section examines a simple PyLogo model.

Starburst begins with a user-selected number of

agents at the center of the grid. When run, 20% of

the agents move toward each corner. The ﬁnal 20%

remain stationary. Since the agents in each group

have identical coordinates, each group appears to be

a single agent. At a user-selected tick, the agents

“explode”, producing a “starburst“ effect, and start to

move in random directions. From then on the agents

experience a repulsive force from each other, produc-

ing swerving trajectories.

Figure 1 is a screenshot. The bottom two rows

of buttons are standard on all PyLogo models. The

SIMULTECH 2021 - 11th International Conference on Simulation and Modeling Methodologies, Technologies and Applications

204

1 # i m p o r t s not shown . . .

3 c l a s s S t a r b u r s t A g e n t ( Agen t ) :

5 d e f u p d a t e v e l o c i t y ( s e l f ) :

6 v e l o c i t y = s e l f . v e l o c i t y

7 i n f l u e n c e r a d i u s = g u i g e t ( ' I n f l u e n c e r a d i u s ' )

8 n e i g h b o r s = s e l f . a g e n t s i n r a d i u s ( i n f l u e n c e r a d i u s ∗ BLOCK SP A CI NG ( ) )

9 f o r n e i g h b o r i n n e i g h b o r s :

10 f o r c e = Agent . f o r c e s c a c h e . g e t ( ( n e i g h b o r , s e l f ) , None )

11 i f f o r c e i s None :

12 f o r c e = f o r c e a s d x d y ( s e l f . c e n t e r p i x e l , n e i g h b o r . c e n t e r p i x e l )

13 Agent . f o r c e s c a c h e [ ( n e i g h b o r , s e l f ) ] = f o r c e ∗ (−1 )

14 v e l o c i t y = v e l o c i t y + f o r c e

15 s p e e d f a c t o r = g u i g e t ( ' Speed f a c t o r ' )

16 s e l f . s e t v e l o c i t y ( n o r m a l i z e d x d y ( v e l o c i t y , 1 . 5∗ s p e e d f a c t o r / 100 ) )

19 c l a s s S t a r b u r s t W o r l d ( World ) :

21 d e f s e t u p ( s e l f ) :

22 n b r a g e n t s = g u i g e t ( ' n b r a g e n t s ' )

23 f o r i n ran g e ( n b r a g e n t s ) :

24 s e l f . a g e n t c l a s s ( s c a l e=1 )

25 vs = [ V e l o c i t y ((−1 , −1 ) ) , V e l o c i t y (( −1 , 1 ) ) , V e l o c i t y ( ( 0 , 0 ) ) ,

26 V e l o c i t y ( ( 1 , −1 ) ) , V e l o c i t y ( ( 1 , 1 ) ) ]

27 f o r ( agent , v e l ) i n z i p ( World . ag e n t s , c y c l e ( v s ) ) :

28 ag e n t . s e t v e l o c i t y ( v e l )

30 d e f s t e p ( s e l f ) :

31 b u r s t t i c k = g u i g e t ( ' B u r s t t i c k ' )

32 i f World . t i c k s >= b u r s t t i c k :

33 Agent . u p d a t e a g e n t v e l o c i t i e s ( )

35 Agent . u p d a t e a g e n t p o s i t i o n s ( )

38 # PyS imple GUI d e f i n i t i o n s . PyLogo u s e s t h e v e r y s t r a i g h t f o r w a r d

39 # P y Sim p l eG u i ( h t t p s : / / p y s i m p l e g u i . r e a d t h e d o c s . i o / ) a s i t s GUI frame w o r k .

41 # As i n many Python pr ograms , t h e f o l l o w i n g s t a r t s t h e model .

42 i f n a m e == ” m a i n ” :

43 PyLogo ( S t a r b u r s t W o r l d , ' S t a r b u r s t ' , g u i l e f t u p p e r , a g e n t c l a s s=S t a r b u r s t A g e n t ,

44 boun c e =(True , F a l s e ) , p a t c h s i z e=9 , b o a r d r o w s c o l s =(71 , 71 ) )

Listing 1: Starburst model.

penultimate line includes setup, go once, and go but-

tons, similar to NetLogo models. The go button,

initially green, turns red and is renamed stop when

clicked. The exit button terminates the model. The

top ﬁve lines allow the user to set model parameters.

Starburst consists of a Starburst Agent subclass of

the PyLogo Agent class and a Starburst World sub-

class of the PyLogo World class. (See Listing 1.)

• setup() consults the gui to determine the num-

ber of agents. It creates those agents and sets

their velocities as described earlier. PyLogo pro-

vides substantial agent-motion support, including

velocity as an agent attribute.

• step() executes at each tick. If the number of

ticks has exceeded the user-settable “burst tick,”

(not displayed), the static method Agent.update -

agent velocities() is called. That, in turn, calls up-

date velocity() for each Starburst Agent.

update velocity() updates an agent’s velocity as

a function of its distances from its neighbors.

The inﬂuence radius slider determines how close

agents must be to effect each other.

Agent.forces cache stores the inter-agent forces so

that they are computed only once each tick.

Agent.update agent positions() updates agent po-

sitions based on their positions and velocities.

PyLogo: A Python Reimplementation of (Much of) NetLogo

205

5 CONCLUSION

PyLogo has two major weaknesses.

• PyLogo is not optimized. It runs more slowly

than NetLogo, and it can gracefully handle only

a smaller number of agents. Even so, it handles

the standard NetLogo examples quite well.

• PyLogo doesn’t offer graphing.

Notwithstanding these limitations, PyLogo was

more than adequate for teaching an ABM course.

PyLogo’s primary advantage is that model devel-

opers write in Python. For people accustomed to writ-

ing software, writing in Python is much less frustrat-

ing than writing in NetLogo. Experienced program-

mers often feel that they are ﬁghting the language

when writing in NetLogo. The opposite is generally

true when writing in Python.

PyLogo conﬁrms that something as simple and

intuitive as agents interacting on a grid (using tick-

based scheduling) accommodates a very wide range

of models.

The development of PyLogo—a fully operational

core completed in a month, with additional features

plus a range of models added while using the system

for a class—demonstrates that Python enables rapid

development of a fairly sophisticated system.

PyLogo is comparatively small: 10 core ﬁles and

15 models of 2,000 SLOC and 3,000 SLOC respec-

tively. It is open-source and available for download.

REFERENCES

Badham, J. (2015). Review of: Wilensky, An Introduction

to Agent-Based Modeling. Journal of Artiﬁcial Soci-

eties and Social Simulation, 18(4).

Bakshy, E. and Wilensky, U. (2007). Netlogo-mathematica

link. Center for Connected Learning and Computer-

Based Modeling, Northwestern University, Evanston,

IL.

Feurzeig, W. and Papert, S. (1967). The logo programming

language. ODP-Open Directory Project.

Grigoryev, I. (2015). Anylogic 7 in three days. A quick

course in simulation modeling, 2.

Gunaratne, C. and Garibay, I. (2018). Nl4py: Agent-

based modeling in python with parallelizable netlogo

workspaces. arXiv preprint arXiv:1808.03292.

Harvey, B. (1982). Why logo. Byte, 7(8):163–193.

Jaxa-Rozen, M. and Kwakkel, J. H. (2018). Pynetlogo:

Linking netlogo with python. Journal of Artiﬁcial So-

cieties and Social Simulation, 21(2).

Luke, S., Ciofﬁ-Revilla, C., Panait, L., Sullivan, K., and

Balan, G. (2005). Mason: A multiagent simulation

environment. Simulation, 81(7):517–527.

Masad, D. and Kazil, J. (2015). Mesa: an agent-based mod-

eling framework. In 14th PYTHON in Science Confer-

ence, pages 53–60.

Nagpal, A. and Gabrani, G. (2019). Python for data ana-

lytics, scientiﬁc and technical applications. In 2019

Amity International Conference on Artiﬁcial Intelli-

gence (AICAI), pages 140–145. IEEE.

North, M. J., Collier, N. T., Ozik, J., Tatara, E. R., Macal,

C. M., Bragen, M., and Sydelko, P. (2013). Com-

plex adaptive systems modeling with repast simphony.

Complex adaptive systems modeling, 1(1):3.

Ozik, J., Collier, N. T., Murphy, J. T., and North, M. J.

(2013). The relogo agent-based modeling language.

In 2013 Winter Simulations Conference (WSC), pages

1560–1568. IEEE.

Railsback, S., Ayll

on, D., Berger, U., Grimm, V., Lytinen,

S., Sheppard, C., and Thiele, J. (2017). Improving

execution speed of models implemented in netlogo.

Journal of Artiﬁcial Societies and Social Simulation,

20(1).

Taghawi-Nejad, D., Tanin, R. H., Chanona, R. M. D. R.,

Carro, A., Farmer, J. D., Heinrich, T., Sabuco, J., and

Straka, M. J. (2017). Abce: A python library for eco-

nomic agent-based modeling. In International Con-

ference on Social Informatics, pages 17–30. Springer.

Taillandier, P., Gaudou, B., Grignard, A., Huynh, Q.-N.,

Marilleau, N., Caillou, P., Philippon, D., and Dro-

goul, A. (2019). Building, composing and experi-

menting complex spatial models with the gama plat-

form. GeoInformatica, 23(2):299–322.

Thiele, J. C. (2014). R marries netlogo: introduction to

the rnetlogo package. Journal of Statistical Software,

58(2):1–41.

Tisue, S. and Wilensky, U. (2004a). Netlogo: A simple en-

vironment for modeling complexity. In International

conference on complex systems, volume 21, pages 16–

21. Boston, MA.

Tisue, S. and Wilensky, U. (2004b). Netlogo: Design and

implementation of a multi-agent modeling environ-

ment. In Proceedings of agent, volume 2004, pages

7–9.

Vahdati, A. R. (2019). Agents.jl: agent-based modeling

framework in julia. Journal of Open Source Software,

4(42):1611.

Wilensky, U. (2019). Netlogo user manual.

Wilensky, U. (2020). Private communication.

SIMULTECH 2021 - 11th International Conference on Simulation and Modeling Methodologies, Technologies and Applications

206