Programming Guide

NetLogo 2.1.0 User Manual   

The following material explains some important features of programming in NetLogo.

(Note: If you are already familiar with StarLogo or StarLogoT, then the material in the first four sections may already be familiar to you.)

The Code Example models mentioned throughout can be found in the Code Examples section of the Models Library.


The NetLogo world is made up of agents. Agents are beings that can follow instructions. Each agent can carry out its own activity, all simultaneously.

In NetLogo, there are three types of agents: turtles, patches, and the observer. Turtles are agents that move around in the world. The world is two dimensional and is divided up into a grid of patches. Each patch is a square piece of "ground" over which turtles can move. The observer doesn't have a location -- you can imagine it as looking out over the world of turtles and patches.

When NetLogo starts up, there are no turtles yet. The observer can make new turtles. Patches can make new turtles too. (Patches can't move, but otherwise they're just as "alive" as turtles and the observer are.)

Patches have coordinates. The patch in the center of the world has coordinates (0, 0). We call the patch's coordinates pxcor and pycor. Just like in the standard mathematical coordinate plane, pxcor increases as you move to the right and pycor increases as you move up.

The total number of patches is determined by the settings screen-edge-x and screen-edge-y. When NetLogo starts up, both screen-edge-x and screen-edge-y are 17. This means that pxcor and pycor both range from -17 to 17, so there are 35 times 35, or 1225 patches total. (You can change the number of patches by editing NetLogo's Graphics window.)

Turtles have coordinates too: xcor and ycor. A patch's coordinates are always integers, but a turtle's coordinates can have decimals. This means that a turtle can be positioned at any point within its patch; it doesn't have to be in the center of the patch.

The world of patches isn't bounded, but "wraps" -- so when a turtle moves past the edge of the world, it disappears and reappears on the opposite edge. Every patch has the same number of "neighbor" patches -- if you're a patch on the edge of the world, some of your "neighbors" are on the opposite edge.


In NetLogo, commands and reporters tell agents what to do. Commands are actions for the agents to carry out. Reporters carry out some operation and report a result either to a command or another reporter.

Commands and reporters built into NetLogo are called primitives. The Primitives Dictionary has a complete list of built-in commands and reporters.

Commands and reporters you define yourself are called procedures. Each procedure has a name, preceded by the keyword to. The keyword end marks the end of the commands in the procedure. Once you define a procedure, you can use it elsewhere in your program.

Many commands and reporters take inputs -- values that the command or reporter uses in carrying out its actions.

Examples: Here are two command procedures:

to setup
  ca             ;; clear the screen
  crt 10         ;; make 10 new turtles

to go
  ask turtles
    [ fd 1             ;; all turtles move forward one step
      rt random 10     ;; ...and turn a random amount
      lt random 10 ]
Note the use of semicolons to add "comments" to the program. Comments make your program easier to read and understand.

In this program,

setup and go can be called by other procedures or by buttons. Many NetLogo models have a once-button that calls a procedure called setup, and a forever-button that calls a procedure called go.

In NetLogo, you must specify which agents -- turtles, patches, or the observer -- are to run each command. (If you don't specify, the code is run by the observer.) In the code above, the observer uses ask to make the set of all turtles run the commands between the square brackets.

ca and crt can only be run by the observer. fd, on the other hand, can only be run by turtles. Some other commands and reporters, such as set, can be run by different agent types.

Here are some more advanced features you can take advantage of when defining your own procedures.

Procedures with inputs

Your own procedures can take inputs, just like primitives do. To create a procedure that accepts inputs, include a list of input names in square brackets after the procedure name. For example:

to draw-polygon [num-sides size]
   repeat num-sides
     [ fd size
       rt (360 / num-sides) ]

Elsewhere in the program, you could ask turtles to each draw an octagon with a side length equal to its ID-number:

ask turtles [ draw-polygon 8 who ]

Reporter procedures

Just like you can define your own commands, you can define your own reporters. You must do two special things. First, use to-report instead of to to begin your procedure. Then, in the body of the procedure, use report to report the value you want to report.

to-report absolute-value [number]
  ifelse number >= 0
    [ report number ]
    [ report 0 - number ]


Variables are places to store values (such as numbers). A variable can be a global variable, a turtle variable, or a patch variable.

If a variable is a global variable, there is only one value for the variable, and every agent can access it. But each turtle has its own value for every turtle variable, and each patch has its own value for every patch variable.

Some variables are built into NetLogo. For example, all turtles have a color variable, and all patches have a pcolor variable. (The patch variable begins with "p" so it doesn't get confused with the turtle variable.) If you set the variable, the turtle or patch changes color. (See next section for details.)

Other built-in turtle variables including xcor, ycor, and heading. Other built-in patch variables include pxcor and pycor. (There is a complete list here.)

You can also define your own variables. You can make a global variable by adding a switch or a slider to your model, or by using the globals keyword at the beginning of your code, like this:

globals [ clock ]

You can also define new turtle and patch variables using the turtles-own and patches-own keywords, like this:

turtles-own [ energy speed ]
patches-own [ friction ]

These variables can then be used freely in your model. Use the set command to set them. (If you don't set them, they'll start out storing a value of zero.)

Global variables can by read and set at any time by any agent. As well, a turtle can read and set patch variables of the patch it is standing on. For example, this code:

ask turtles [ set pcolor red ]

causes every turtle to make the patch it is standing on red. (Because patch variables are shared by turtles in this way, you can't have a turtle variable and a patch variable with the same name.)

In other situations where you want an agent to read or set a different agent's variable, you put -of after the variable name and then specify which agent you mean. Examples:

set color-of turtle 5 red
;; turtle with ID number 5 turns red
set pcolor-of patch 2 3 green
;; patch with pxcor of 2 and pycor of 3 turns green
ask turtles [ set pcolor-of patch-at 1 0 blue ]
;; every turtle turns the patch to its east blue
ask patches with [any? turtles-here]
  [ set color-of random-one-of turtles-here yellow ]
;; on every patch, a random turtle turns yellow

Local variables

A local variable is defined and used only in the context of a particular procedure or part of a procedure. To create a local variable, use the let command. You can use this command anywhere. If you use it at the top of a procedure, the variable will exist throughout the procedure. If you use it inside a set of square brackets, for example inside an "ask", then it will exist only inside those brackets.

to swap-colors [turtle1 turtle2]
   let temp color-of turtle1
   set (color-of turtle1) (color-of turtle2)
   set (color-of turtle2) temp


NetLogo represents colors as numbers in the range 0 to 140, with the exception of 140 itself. Below is a chart showing the range of colors you can use in NetLogo.

[color chart]

The chart shows that:

Code Example: The color chart was made in NetLogo with the Color Chart Example model.

Note: If you use a number outside the 0 to 140 range, NetLogo will repeatedly add or subtract 140 from the number until it is in the 0 to 140 range. For example, 25 is orange, so 165, 305, 445, and so on are orange too, and so are -115, -255, -395, etc. This calculation is done automatically whenever you set the turtle variable color or the patch variable pcolor. Should you need to perform this calculation in some other context, use the wrap-color primitive.

If you want a color that's not on the chart, more can be found between the integers. For example, 26.5 is a shade of orange halfway between 26 and 27. This doesn't mean you can make any color in NetLogo; the NetLogo color space is only a subset of all possible colors. A fixed set of discrete hues is available, and you can either decrease the brightness (darken) or decrease the saturation (lighten) of those hues to get your desired color, but you cannot decrease both the brightness and saturation.

There are a few primitives that are helpful for working with color shades. The scale-color primitive is useful for converting numeric data into colors. And shade-of? will tell you if two colors are "shades" of the same basic hue. For example, shade-of? orange 27 is true, because 27 is a lighter shade of orange.

Code Example: Scale-color Example shows you how to use the scale-color reporter.

For many models, the NetLogo color system is a convenient way of expressing colors. But sometimes you'd like to be able to specify colors the conventional way, by specifying HSB (hue/saturation/brightness) or RGB (red/green/blue) values. The hsb and rgb primitives let you do this. extract-hsb and extract-hsb let you convert colors in the other direction.

Since the NetLogo color space doesn't include all hues, hsb and rgb can't always give you the exact color you ask for, but they try to come as close as possible.

Code Example: You can use the HSB and RGB Example model to experiment with the HSB and RGB color systems.


NetLogo uses the ask command to specify commands that are to be run by turtles or patches. All code to be run by turtles must be located in a turtle "context". You can establish a turtle context in any of three ways:

The same goes for patches and the observer, except that code to be run by the observer must not be inside any ask.

Here's an example of the use of ask syntax in a NetLogo procedure:

to setup
  crt 100              ;; create 100 turtles
  ask turtles
    [ set color red    ;; turn them red
      rt random-float 360    ;; give them random headings
      fd 50 ]          ;; spread them around
  ask patches
    [ if (pxcor > 0)         ;; patches on the right side
        [ set pcolor green ] ]  ;; of the screen turn green

The models in the Models Library are full of other examples. A good place to start looking is in the Code Examples section.

Usually, the observer uses ask to ask all turtles or all patches to run commands. You can also use ask to have an individual turtle or patch run commands. The reporters turtle, patch, and patch-at are useful for this technique. For example:

to setup
  crt 3                  ;; make 3 turtles
  ask turtle 0           ;; tell the first one...
    [ fd 1 ]             ;; go forward
  ask turtle 1           ;; tell the second one...
    [ set color green ]  ;; become green
  ask turtle 2           ;; tell the third one...
    [ rt 90 ]            ;; turn right
  ask patch 2 -2         ;; ask the patch at (2,-2)
    [ set pcolor blue ]  ;; become blue
  ask turtle 0           ;; ask the first turtle
    [ ask patch-at 1 0   ;; ask patch to the east
      [ set pcolor red ] ;; become red

Every turtle created has an ID number. The first turtle created has ID 0, the second turtle ID 1, and so forth. The turtle primitive reporter takes an ID number as an input, and reports the turtle with that ID number. The patch primitive reporter takes values for pxcor and pycor and reports the patch with those coordinates. And the patch-at primitive reporter takes offsets: distances, in the x and y directions, from the first agent. In the example above, the turtle with ID number 0 is asked to get the patch east (and no patches north) of itself.

You can also select a subset of turtles, or a subset of patches, and ask them to do something. This involves a concept called "agentsets". The next section explains this concept in detail.


An agentset is exactly what its name implies, a set of agents. An agentset can contain either turtles or patches, but not both at once.

You've seen the turtles primitive, which reports the agentset of all turtles, and the patches primitive, which reports the agentset of all patches.

But what's powerful about the agentset concept is that you can construct agentsets that contain only some turtles or some patches. For example, all the red turtles, or the patches with pxcor evenly divisible by five, or the turtles in the first quadrant that are on a green patch. These agentsets can then be used by ask or by various reporters that take agentsets as inputs.

One way is to use turtles-here or turtles-at, to make an agentset containing only the turtles on my patch, or only the turtles on some other particular patch. There's also turtles-on so you can get the set of turtles standing on a given patch or set of patches, or the set of turtles standing on the same patch as a given turtle or set of turtles.

Here are some more examples of how to make agentsets:

;; all red turtles:
turtles with [color = red]
;; all red turtles on my patch
turtles-here with [color = red]
;; patches on right side of screen
patches with [pxcor > 0]
;; all turtles less than 3 patches away
turtles in-radius 3
;; the four patches to the east, north, west, and south
patches at-points [[1 0] [0 1] [-1 0] [0 -1]]
;; shorthand for those four patches
;; turtles in the first quadrant that are on a green patch
turtles with [(xcor > 0) and (ycor > 0)
              and (pcolor = green)]
;; turtles standing on my neighboring four patches
turtles-on neighbors4

Once you have created an agentset, here are some simple things you can do:

And here are some more complex things you can do:

This only scratches the surface -- see the Models Library for many more examples, and consult the Primitives Guide and Primitives Dictionary for more information about all of the agentset primitives.

More examples of using agentsets are provided in the individual entries for these primitives in the NetLogo Dictionary. In developing familiarity with programming in NetLogo, it is important to begin to think of compound commands in terms of how each element passes information to the next one. Agentsets are an important part of this conceptual scheme and provide the NetLogo developer with a lot of power and flexibility, as well as being more similar to natural language.

Code Example: Ask Agentset Example


NetLogo allows you to define different "breeds" of turtles. Once you have defined breeds, you can go on and make the different breeds behave differently. For example, you could have breeds called sheep and wolves, and have the wolves try to eat the sheep.

You define breeds using the breeds keyword, at the top of your model, before any procedures:

breeds [wolves sheep]

The order in which breeds are declared is also the order in which they are drawn in the graphics window. So breeds defined later will appear on top of breeds defined earlier; in this example, sheep will be drawn over wolves.

When you define a breed such as sheep, an agentset for that breed is automatically created, so that all of the agentset capabilities described above are immediately available with the sheep agentset.

The following new primitives are also automatically available once you define a breed: create-sheep, create-custom-sheep (cct-sheep for short), hatch-sheep, sprout-sheep, sheep-here, and sheep-at.

Also, you can use sheep-own to define new turtle variables that only turtles of the given breed have.

A turtle's breed agentset is stored in the breed turtle variable. So you can test a turtle's breed, like this:

if breed = wolves [ ... ]

Note also that turtles can change breeds. A wolf doesn't have to remain a wolf its whole life. Let's change a random wolf into a sheep:

ask random-one-of wolves [ set breed sheep ]

The set-default-shape primitive is useful for associating certain turtle shapes with certain breeds. See the section on shapes below.

Here is a quick example of using breeds:

breeds [mice frogs]
mice-own [cheese]
to setup
  create-custom-mice 50
    [ set color white
      set cheese random 10 ]
  create-custom-frogs 50
    [ set color green ]
Code Example: Breeds and Shapes Example


Buttons in the interface tab provide an easy way to control the model. Typically a model will have at least a "setup" button, to set up the initial state of the world, and a "go" button to make the model run continuously. Some models will have additional buttons that perform other actions.

A button contains some NetLogo code. That code is run when you press the button.

A button may be either a "once-button", or a "forever-button". You can control this by editing the button and checking or unchecking the "Forever" checkbox. Once-buttons run their code once, then stop and pop back up. Forever-buttons keep running their code over and over again, until either the code hits the stop command, or you press the button again to stop it. If you stop the button, the code doesn't get interrupted. The button waits until the code has finished, then pops up.

Normally, a button is labeled with the code that it runs. For example, a button that says "go" on it usually contains the code "go", which means "run the go procedure". (Procedures are defined in the Procedures tab; see below.) But you can also edit a button and enter a "display name" for the button, which is a text that appears on the button instead of the code. You might use this feature if you think the actual code would be confusing to your users.

When you put code in a button, you must also specify which agents you want to run that code. You can choose to have the observer run the code, or all turtles, or all patches. (If you want the code to be run by only some turtles or some patches, you could make an observer button, and then have the observer use the ask command to ask only some of the turtles or patches to do something.)

When you edit a button, you have the option to assign an "action key". This makes that key on the keyboard behave just like a button press. If the button is a forever button, it will stay down until the key is pressed again (or the button is clicked). Action keys are particularly useful for games or any model where rapid triggering of buttons is needed.

Buttons and display updates

When you edit a button, there is a checkbox called "Force display update after each run". Below the checkbox is a note that reads "Checking this box produces smoother animation, but may make the button run more slowly."

Most of the time, it's enough to know that if you prefer smooth animation check the box and if you prefer speed uncheck it. In some models, the difference is dramatic; in others, it's hardly noticeable. It depends on the model.

What follows is a more detailed explanation of what's really going on with this checkbox.

To understand why this option is offered, you need to understand a little about how NetLogo updates the graphics window. When something changes in the world, for example if a turtle moves or a patch changes color, the change does not always immediately become visible. NetLogo would run too slowly if changes always immediately became visible. So NetLogo waits until a certain amount of time has passed, usually about 1/20 of a second, and then redraws the world, so that all the changes that have happened so far become visible. This is sometimes called "skipping frames", by analogy with movies.

Skipping frames is good because each frame takes NetLogo time to draw, so your model runs faster if NetLogo can skip some of them. But skipping frames may be bad if the frames skipped contained information that you wanted to see. Sometimes the way a model looks when frames are being skipped can be misleading.

Even when the checkbox is on for a button, NetLogo will still skip frames while the code in the button is running. Checking the box only ensures that NetLogo will draw a frame when the code is done.

In some contexts, you may want to force NetLogo to draw a frame even in the middle of button code. To do that, use the display command; that forces NetLogo to refresh the screen immediately.

In other contexts, you may want to force NetLogo never to draw a frame in the middle of button code, only at the end. To ensure that, put no-display at the beginning of the code and display at the end. Note also that NetLogo will never draw on-screen when inside a without-interruption block.

Turtle and patch forever-buttons

There is a subtle difference between putting commands in a turtle or patch forever-button, and putting the same commands in an observer button that does ask turtles or ask patches. An "ask" doesn't complete until all of the agents have finished running all of the commands in the "ask". So the agents, as they all run the commands concurrently, can be out of sync with each other, but they all sync up again at the end of the ask. The same isn't true of turtle and patch forever-buttons. Since ask was not used, each turtle or patch runs the given code over and over again, so they can become (and remain) out of sync with each other.

At present, this capability is very rarely used in the models in our Models Library. A model that does use the capability is the Termites model, in the Biology section of Sample Models. The "go" button is a turtle forever-button, so each termite proceeds independently of every other termite, and the observer is not involved at all. This means that if, for example, you wanted to add a plot to the model, you would need to add a second forever-button (an observer forever-button), and run both forever-buttons at the same time.

At present, NetLogo has no way for one forever-button to start another. Buttons are only started when you press them.


In both StarLogoT and NetLogo, commands are executed asynchronously; each turtle or patch does its list of commands as fast as it can. In StarLogoT, one could make the turtles "line up" by putting in a comma (,). At that point, the turtles would wait until all were finished before any went on.

The equivalent in NetLogo is to come to the end of an ask block. If you write it this way, the two steps are not synced:

ask turtles
  [ fd random 10
    do-calculation ]

Since the turtles will take varying amounts of time to move, they'll begin "do-calculation" at different times.

But if you write it this way, they are:

ask turtles [ fd random 10 ]
ask turtles [ do-calculation ]

Here, some of the turtles will have to wait after moving until all the other turtles are done moving. Then the turtles all begin "do-calculation" at the same time.

This latter form is equivalent to this use of the comma in StarLogoT:

fd random 10 ,
do-calculation ,


In the simplest models, each variable holds only one piece of information, usually a number or a string. The list feature lets you store multiple pieces of information in a single variable by collecting those pieces of information in a list. Each value in the list can be any type of value: a number, or a string, an agent or agentset, or even another list.

Lists allow for the convenient packaging of information in NetLogo. If your agents carry out a repetitive calculation on multiple variables, it might be easier to have a list variable, instead of multiple number variables. Several primitives simplify the process of performing the same computation on each value in a list.

The Primitives Dictionary has a section that lists all of the list-related primitives.

Constant Lists

You can make a list by simply putting the values you want in the list between brackets, like this: set mylist [2 4 6 8]. Note that the individual values are separated by spaces. You can make lists that contains numbers and strings this way, as well as lists within lists, for example [[2 4] [3 5]].

The empty list is written by putting nothing between the brackets, like this: [].

Building Lists on the Fly

If you want to make a list in which the values are determined by reporters, as opposed to being a series of constants, use the list reporter. The list reporter accepts two other reporters, runs them, and reports the results as a list.

If I wanted a list to contain two random values, I might use the following code:

set random-list list (random 10) (random 20)
This will set random-list to a new list of two random integers each time it runs.

To make longer lists, you can use the list reporter with more than two inputs, but in order to do so, you must enclose the entire call in parentheses, like this:

(list 1 2 3 4 5)
For more information, see Varying Numbers of Inputs.

Some kinds of lists are most easily built using the n-values reporter, which allows you to construct a list of a specific length by repeatedly running a given reporter. You can make a list of the same value repeated, or all the numbers in a range, or a lot of random numbers, or many other possibilities. See dictionary entry for details and examples.

The values-from primitive lets you construct a list from an agentset. It reports a list containing each agent's value for the given reporter. (The reporter could be a simple variable name, or a more complex expression -- even a call to a procedure defined using to-report.) A common idiom is

max values-from turtles [...]
sum values-from turtles [...]
and so on.

You can combine two or more lists using the sentence reporter, which concatenates lists by combining their contents into a single, larger list. Like list, sentence normally takes two inputs, but can accept any number of inputs if the call is surrounded by parentheses.

Changing List Items

Technically, only one command changes a list -- set. This is used in conjunction with reporters. For example, to change the third item of a list to 10, you could use the following code:

set mylist [2 7 5 Bob [3 0 -2]]
; mylist is now [2 7 5 Bob [3 0 -2]]
set mylist replace-item 2 mylist 10
; mylist is now [2 7 10 Bob [3 0 -2]]

The replace-item reporter takes three inputs. The first input specifies which item in the list is to be changed. 0 means the first item, 1 means the second item, and so forth.

To add an item, say 42, to the end of a list, use the lput reporter. (fput adds an item to the beginning of a list.)

set mylist lput 42 mylist
; mylist is now [2 7 10 Bob [3 0 -2] 42]

But what if you changed your mind? The but-last (bl for short) reporter reports all the list items but the last.

set mylist but-last mylist
; mylist is now [2 7 10 Bob [3 0 -2]]

Suppose you want to get rid of item 0, the 2 at the beginning of the list.

set mylist but-first mylist
; mylist is now [7 10 Bob [3 0 -2]]

Suppose you wanted to change the third item that's nested inside item 3 from -2 to 9? The key is to realize that the name that can be used to call the nested list [3 0 -2] is item 3 mylist. Then the replace-item reporter can be nested to change the list-within-a-list. The parentheses are added for clarity.

set mylist (replace-item 3 mylist
                  (replace-item 2 (item 3 mylist) 9))
; mylist is now [7 10 Bob [3 0 9]]

Iterating Over Lists

If you want to do some operation on each item in a list in turn, the foreach command and the map reporter may be helpful.

foreach is used to run a command or commands on each item in a list. It takes an input list and a block of commands, like this:

foreach [2 4 6]
  [ crt ?
    show "created " + ? + " turtles" ]
=> created 2 turtles
=> created 4 turtles
=> created 6 turtles
In the block, the variable ? holds the current value from the input list.

Here are some more examples of foreach:

foreach [1 2 3] [ ask turtles [ fd ? ] ]
;; turtles move forward 6 patches
foreach [true false true true] [ ask turtles [ if ? [ fd 1 ] ] ]
;; turtles move forward 3 patches

map is similar to foreach, but it is a reporter. It takes an input list and another reporter. Note that unlike foreach, the reporter comes first, like this:

show map [round ?] [1.2 2.2 2.7]
;; prints [1 2 3]
map reports a list containing the results of applying the reporter to each item in the input list. Again, use ? to refer to the current item in the list.

Here is another example of map:

show map [? < 0] [1 -1 3 4 -2 -10]
;; prints [false true false false true true]

foreach and map won't necessarily be useful in every situation in which you want to operate on an entire list. In some situations, you may need to use some other technique such as a loop using repeat or while, or a recursive procedure.

The sort-by primitive uses a similar syntax to map and foreach, except that since the reporter needs to compare two objects, the two special variables ?1 and ?2 are used in place of ?.

Here is an example of sort-by:

show sort-by [?1 < ?2] [4 1 3 2]
;; prints [1 2 3 4]

Varying Numbers of Inputs

Some commands and reporters involving lists and strings may take a varying number of inputs. In these cases, in order to pass them a number of inputs other than their default, the primitive and its inputs must be surrounded by parentheses. Here are some examples:

show list 1 2
=> [1 2]
show (list 1 2 3 4)
=> [1 2 3 4]
show (list)
=> []
Note that each of these special commands has a default number of inputs for which no parentheses are required. The primitives which have this capability are list, word, sentence, map, and foreach.


NetLogo supports two different kinds of math, integer and floating point.

Integers have no fractional part and may range from -2147483648 to 2147483647 (-2^31 to 2^31-1). Integer operations that exceed this range will not cause runtime errors, but will produce incorrect answers.

Floating point numbers are numbers containing a decimal point. In NetLogo, they operate according to the IEEE 754 standard for double precision floating point numbers. These are 64 bit numbers consisting of one sign bit, an 11-bit exponent, and a 52-bit mantissa. See the IEEE 754 standard for details. Any operation which produces the special quantities "infinity" or "not a number" will cause a runtime error.

In NetLogo, integers and floating point numbers are interchangeable, in the sense that as long as you stay within legal ranges, it is never an error to supply 3 when 3.0 is expected, or 3.0 when 3 is expected. In fact, 3 and 3.0 are considered equal, according to the = (equals) operator. If a floating point number is supplied in a context where an integer is expected, the fractional part is simply discarded. So for example, crt 3.5 creates three turtles; the extra 0.5 is ignored.

Scientific notation

Very large or very small floating point numbers are displayed by NetLogo using "scientific notation". Examples:

O> show 0.000000000001
observer: 1.0E-12
O> show 50000000000000000000.0
observer: 5.0E19

Numbers in scientific notation are distinguished by the presence of the letter E (for "exponent"). It means "times ten to the power of", so for example, 1.0E-12 means 1.0 times 10 to the -12 power:

O> show 1.0 * 10 ^ -12
observer: 1.0E-12

You can also use scientific notation yourself in NetLogo code:

O> show 3.0E6
observer: 3000000.0
O> show 3.0E7
observer: 3.0E7
O> show 8.0E-3
observer: 0.0080
O> show 8.0E-4
observer: 8.0E-4

These examples show that numbers are displayed using scientific notation if the exponent is less than -3 or greater than 6.

When entering a number using scientific notation, you must include the decimal point. For example, 1E8 will not be accepted. Instead you must write 1.0E8 or 1.E8:

O> show 1.0E8
observer: 1.0E8
O> show 1.E8
observer: 1.0E8
O> show 1E8
ERROR: Illegal number format

When entering a number, the letter E may be either upper or lowercase. When printing a number, NetLogo always uses an uppercase E:

O> show 4.5e10
observer: 4.5E10

Floating point accuracy

When using floating point numbers, you should be aware that due to the limitations of the binary representation for floating point numbers, you may get answers that are slightly inaccurate. For example:

O> show 0.1 + 0.1 + 0.1
observer: 0.30000000000000004
O> show cos 90
observer: 6.123233995736766E-17

This is an inherent issue with floating point arithmetic; it occurs in all programming languages that support floating point.

If you are dealing with fixed precision quantities, for example dollars and cents, a common technique is to use only integers (cents) internally, then divide by 100 to get a result in dollars for display.

If you must use floating point numbers, then in some situations you may need to replace a straightforward equality test such as if x = 1 [ ... ] with a test that tolerates slight imprecision, for example if abs (x - 1) < 0.0001 [ ... ].

Also, the precision primitive is handy for rounding off numbers for display purposes. NetLogo monitors round the numbers they display to a configurable number of decimal places, too.

Random Numbers

The random numbers used by NetLogo are what is called "pseudo-random". (This is typical in computer programming.) That means they appear random, but are in fact generated by a deterministic process. "Deterministic" means that you get the same results every time, if you start with the same random "seed". We'll explain in a minute what we mean by "seed".

In the context of scientific modeling, pseudo-random numbers are actually desirable. That's because it's important that a scientific experiment be reproducible -- so anyone can try it themselves and get the same result that you got. Since NetLogo uses pseudo-random numbers, the "experiments" that you do with it can be reproduced by others.

Here's how it works. NetLogo's random number generator can be started with a certain seed value, which can be any integer. Once the generator has been "seeded" with the random-seed command, it always generates the same sequence of random numbers from then on. For example, if you run these commands:

random-seed 137
show random 100
show random 100
show random 100

You will always get the numbers 95, 7, and 54.

Code Example: Random Seed Example

Note however that you're only guaranteed to get those same numbers if you're using the same version of NetLogo. Sometimes when we make a new version of NetLogo we change the random number generator. For example, NetLogo 2.0 has a different generator than NetLogo 1.3 did. 2.0's generator (which is known as the "Mersenne Twister") is faster and generates numbers that are statistically more "random" than 1.3's (Java's built-in "linear congruential" generator).

If you don't set the random seed yourself, NetLogo sets it to a value based on the current date and time. There is no way to find out what random seed it chose, so if you want your model run to be reproducible, you must set the random seed yourself ahead of time.

The NetLogo primitives with "random" in their names (random, random-float, random-one-of, and so on) aren't the only ones that use pseudo-random numbers. Some other primitives also make random choices. For example, the sprout command creates turtles with random colors and headings, and the downhill reporter chooses a random patch when there's a tie. These random choices are governed by the random seed as well, so model runs can be reproducible.

Turtle shapes

In StarLogoT, turtle shapes were bitmaps. They all had a single fixed size and could only rotate in 45 degree increments.

In NetLogo, turtle shapes are vector shapes. They are built up from basic geometric shapes; squares, circles, and lines, rather than a grid of pixels. Vector shapes are fully scalable and rotatable.

A turtle's shape is stored in its shape variable and can be set using the set command.

New turtles have a shape of "default". The set-default-shape primitive is useful for changing the default turtle shape to a different shape, or having a different default turtle shape for each breed of turtle.

The shapes primitive reports a list of currently available turtle shapes in the model. This is useful if, for example, you want to assign a random shape to a turtle:

ask turtles [ set shape random-one-of shapes ]

Use the Shapes Editor to create your own turtle shapes, or to add shapes to your model from our shapes library, or to transfer shapes between models. For more information, see the Shapes Editor section of this manual.

Code Examples: Breeds and Shapes Example, Shape Animation Example


NetLogo's plotting features let you create plots to help you understand what's going on in your model.

Before you can plot, you need to create one or more plots in the Interface tab. Each plot should have a unique name. You'll be using its name to refer to it in your code in the Procedures tab.

Specifying a plot

If you only have one plot in your model, then you can start plotting to it right away. But if you have more than one plot, you have to specify which one you want to plot to. To do this, use the set-current-plot command with the name of the plot enclosed in double quotes, like this:

set-current-plot "Distance vs. Time"

You must supply the name of the plot exactly as you typed it when you created the plot. Note that later if you change the name of the plot, you'll also have to update the set-current-plot calls in your model to use the new name. (Copy and paste can be helpful here.)

Specifying a pen

When you make a new plot, it just has one pen it. If the current plot only has one plot pen, then you can start plotting to it right away.

But you can also have multiple pens in a plot. You can create additional pens by editing the plot and using the controls in the "Plot Pens" section at the bottom of the edit dialog. Each pen should have a unique name. You'll be using its name to refer to it in your code in the Procedures tab.

For a plot with multiple pens, you have to specify which pen you want to plot with. If you don't specify a pen, plotting will take place with the first pen in the plot. To plot with a different pen, use the set-current-plot-pen command with the name of the pen enclosed in double quotes, like this:

set-current-plot-pen "distance"

Plotting points

The two basic commands for actually plotting things are plot and plotxy.

With plot you need only specify the y value you want plotted. The x value will automatically be 0 for the first point you plot, 1 for the second, and so on. (That's if the plot pen's "interval" is the default value of 1.0; you can change the interval.)

The plot command is especially handy when you want your model to plot a new point at every time step. Example:

to setup
  plot count turtles

to go
  plot count turtles

Note that in this example we plot from both the "setup" and "go" procedures. That's because we want our plot to include the initial state of the system. We plot at the end of the "go" procedure, not the beginning, because we want the plot always to be up to date after the go button stops.

If you need to specify both the x and y values of the point you want plotted, then use plotxy instead.

Code Example: Plotting Example

Other kinds of plots

By default, NetLogo plot pens plot in line mode, so that the points you plot are connected by a line.

If you want to move the pen without plotting, you can use the plot-pen-up command (ppu for short). After this command is issued, the plot and plotxy commands move the pen but do not actually draw anything. Once the pen is where you want it, use plot-pen-down to put the pen back down (ppd for short).

If you want to plot individual points instead of lines, or you want to draw bars instead of lines of or points, you need to change the plot pen's "mode". Three modes are available: line, bar, and point. Line is the default mode.

Normally, you change a pen's mode by editing the plot. This changes the pen's default mode. It's also possible to change the pen's mode temporarily using the set-plot-pen-mode command. That command takes a number as input: 0 for line, 1 for bar, 2 for point.


A histogram is a special kind of plot that measures how frequently certain values, or values in certain ranges, occur in a collection of numbers that arise in your model.

For example, suppose the turtles in your model have an age variable. You could create a histogram of the distribution of ages among your turtles with the histogram-from command, like this:

histogram-from turtles [age]

If the data you want to histogram don't come from an agentset but from a list of numbers, use the histogram-list command instead.

Note that using the histogram commands doesn't automatically switch the current plot pen to bar mode. If you want bars, you have to set the plot pen to bar mode yourself. (As we said before, you can change a pen's default mode by editing the plot in the Interface tab.)

The width of the bars in a histogram is controlled by the plot pen's interval. You can set a plot pen's default interval by editing the plot in the Interface tab. You can also change the interval temporarily with the set-plot-pen-interval command or the set-histogram-num-bars. If you use the latter command, NetLogo will set the interval appropriately so as to fit the specified number of bars within the plot's current x range.

Code Example: Histogram Example

Clearing and resetting

You can clear the current plot with the clear-plot command, or clear every plot in your model with clear-all-plots. The clear-all command also clears all plots, in addition to clearing everything else in your model.

If you only want to remove only the points that the current plot pen has drawn, use plot-pen-reset.

When a whole plot is cleared, or when a pen is reset, that doesn't just remove the data that has been plotted. It also restores the plot or pen to its default settings, as they were specified in the Interface tab when the plot was created or last edited. Therefore, the effects of such commands as set-plot-x-range and set-plot-pen-color are only temporary.


By default, all NetLogo plots have the "autoplotting" feature enabled. This means that if the model tries to plot a point which is outside the current displayed range, the range of the plot will grow along one or both axes so that the new point is visible.

In the hope that the ranges won't have to change every time a new point is added, when the ranges grow they leave some extra room: 25% if growing horizontally, 10% if growing vertically.

If you want to turn off this feature, edit the plot and uncheck the Autoplot checkbox. At present, it is not possible to enable or disable this feature only on one axis; it always applies to both axes.

Temporary plot pens

Most plots can get along with a fixed number of pens. But some plots have more complex needs; they may need to have the number of pens vary depending on conditions. In such cases, you can make "temporary" plot pens from code and then plot with them. These pens are called "temporary" because they vanish when the plot is cleared (by the clear-plot, clear-all-plots, or clear-all commands).

To create a temporary plot pen, use the create-temporary-plot-pen command. Once the pen has been created, you can use it like any ordinary pen. By default, the new pen is down, is black in color, has an interval of 1.0, and plots in line mode. Commands are available to change all of these settings; see the Plotting section of the Primitives Dictionary.


Not every aspect of NetLogo's plotting system has been explained here. See the Plotting section of the Primitives Dictionary for information on additional commands and reporters related to plotting.

Many of the Sample Models in the Models Library illustrate various advanced plotting techniques. Also check out the following code examples:

Code Examples: Plot Axis Example, Plot Smoothing Example


To input a constant string in NetLogo, surround it with double quotes.

The empty string is written by putting nothing between the quotes, like this: "".

Most of the list primitives work on strings as well:

butfirst "string" => "tring"
butlast "string" => "strin"
empty? "" => true
empty? "string" => false
first "string" => "s"
item 2 "string" => "r"
last "string" => "g"
length "string" => 6
member? "s" "string" => true
member? "rin" "string" => true
member? "ron" "string" => false
position "s" "string" => 0
position "rin" "string" => 2
position "ron" "string" => false
remove "r" "string" => "sting"
remove "s" "strings" => "tring"
replace-item 3 "string" "o" => "strong"
reverse "string" => "gnirts"
A few primitives are specific to strings, such as is-string?, substring, and word:
is-string? "string" => true
is-string? 37 => false
substring "string" 2 5 => "rin"
word "tur" "tle" => "turtle"

Strings can be compared using the =, !=, <, >, <=, and >= operators.

To concatenate strings, that is, combine them into a single string, you can also use the + (plus) operator, like this:

"tur" + "tle" => "turtle"

If you need to embed a special character in a string, use the following escape sequences:


This section is about output to the screen. Output to the screen can also be later saved to a file using the export-output command. If you need a more flexible method of writing data to external files, see the next section, File I/O.

The basic commands for generating output to the screen in NetLogo are print, show, type, and write. These commands send their output to the Command Center.

For full details on these four commands, see their entries in the Primitives Dictionary. Here is how they are typically used:

A NetLogo model may optionally have an "output area" in its Interface tab, separate from the Command Center. To send output there instead of the Command Center, use the output-print, output-show, output-type, and output-write commands.

The output area can be cleared with the clear-output command and saved to a file with export-output.

If you use output-print, output-show, output-type, output-write, clear-output, or export-output in a model which does not have a separate output area, then the commands apply to the output portion of the Command Center.

File I/O

In NetLogo, there is a set of primitives that give you the power to interact with outside files. They all begin with the prefix file-.

There are two main modes when dealing with files: reading and writing. The difference is the direction of the flow of data. When you are reading in information from a file, data that is stored in the file flows into your model. On the other hand, writing allows data to flow out of your model and into a file.

When a NetLogo model runs as an applet within a web browser, it will only be able to read data from files which are in the same directory on the server as the model file. Applets cannot write to any files.

When working with files, always begin by using the primitive file-open. This specifies which file you will be interacting with. None of the other primitives work unless you open a file first.

The next file- primitive you use dictates which mode the file will be in until the file is closed, reading or writing. To switch modes, close and then reopen the file.

The reading primitives include file-read, file-read-line, file-read-characters, and file-at-end? Note that the file must exist already before you can open it for reading.

The primitives for writing are similar to the primitives that print things in the Command Center, except that the output gets saved to a file. They include file-print, file-show, file-type, and file-write. Note that you can never "overwrite" data. In other words, if you attempt to write to a file with existing data, all new data will be appended to the end of the file. (If you want to overwrite a file, use file-delete to delete it, then open it for writing.)

When you are finished using a file, you can use the command file-close to end your session with the file. If you wish to remove the file afterwards, use the primitive file-delete to delete it. To close multiple opened files, one needs to first select the file by using file-open before closing it.

;; Open 3 files
file-open "myfile1.txt"
file-open "myfile2.txt"
file-open "myfile3.txt"

;; Now close the 3 files
file-open "myfile2.txt"
file-open "myfile1.txt"

Or, if you know you just want to close every file, you can use file-close-all.

Two primitives worth noting are file-write and file-read . These primitives are designed to easily save and retrieve NetLogo constants such as numbers, lists, booleans, and strings. file-write will always output the variable in such a manner that file-read will be able to interpret it correctly.

file-open "myfile.txt"	;; Opening file for writing
ask turtles
  [ file-write xcor file-write ycor ]

file-open "myfile.txt"	;; Opening file for reading
ask turtles
  [ setxy file-read file-read ]

Letting the user choose

The user-choose-directory, user-choose-file, and user-choose-new-file primitives are useful when you want the user to choose a file or directory for your code to operate on.


This section describes how to capture a QuickTime movie of a NetLogo model.

First, use the movie-start command to start a new movie. The filename you provide should end with .mov, the extension for QuickTime movies.

To add a frame to your movie, use either movie-grab-graphics or movie-grab-interface, depending on whether you want the movie to show just the graphics window, or the entire Interface tab. In a single movie, you must use only one movie-grab- primitive or the other; you can't mix them.

When you're done adding frames, use movie-close.

;; export a 30 frame movie of the graphics window
movie-start ""
movie-grab-graphics ;; show the initial state
repeat 30 
[ go 
  movie-grab-graphics ]

By default, a movie will play back at 15 frames per second. To make a movie with a different frame rate, call movie-set-frame-rate after movie-start but before grabbing any frames.

To check the frame rate of your movie, or to see how many frames you've grabbed, call movie-status, which reports a string that describes the state of the current movie.

To throw away a movie and delete the movie file, call movie-cancel.

NetLogo movies are exported as uncompressed QuickTime files. To play a QuickTime movie, you can use QuickTime Player, a free download from Apple.

Since the movies are not compressed, they can take up a lot of disk space. You will probably want to compress your movies with third-party software. The software may give you a choice of different kinds of compression. Some kinds of compression are lossless, while others are lossy. "Lossy" means that in order to make the files smaller, some of the detail in the movie is lost. Depending on the nature of your model, you may want to avoid using lossy compression, for example if your graphics window contains fine pixel-level detail.

Code Example: Movie Example