libraries.conf

extensions: [
  {
    name: "Arduino"
    codeName: "arduino"
    shortDescription: "Communicate with an Arduino device"
    longDescription: """This extension provides 'no-frills' communication between NetLogo and a connected Arduino."""
    version: "3.1.1"
    homepage: "https://docs.netlogo.org/arduino.html"
  }
  {
    name: "Array"
    codeName: "array"
    shortDescription: "Fixed-size arrays for performance"
    longDescription: """In general, anything you can do with an array in NetLogo, you could also just use a list for. But you may want to consider using an array instead for speed reasons. Lists and arrays have different performance characteristics, so you may be able to make your model run faster by selecting the appropriate data structure.

Arrays are useful when you need a collection of values whose size is fixed. You can quickly access or alter any item in an array if you know its position.

Unlike NetLogo’s lists and strings, arrays are “mutable”. That means that you can actually modify them directly, rather than constructing an altered copy as with lists. If the array is used in more than one place in your code, any changes you make will show up everywhere. It’s tricky to write code involving mutable structures and it’s easy to make subtle errors or get surprising results, so we suggest sticking with lists and strings unless you’re certain you want and need mutability."""
    version: "1.2.1"
    homepage: "https://docs.netlogo.org/array.html"
  }
  {
    name: "Bitmap"
    codeName: "bitmap"
    shortDescription: "Image manipulation and drawing"
    longDescription: """The Bitmap Extension allows you to manipulate and import images into the drawing and patches. It offers features not provided by the NetLogo core primitives, such as: scaling, manipulation of different color channels, and width and height reporters."""
    version: "1.3.1"
    homepage: "https://docs.netlogo.org/bitmap.html"
  }
  {
    name:             "bspace"
    codeName:         "bspace"
    shortDescription: "Create and run BehaviorSpace experiments programmatically"
    longDescription:  """You can use this extension alone or in combination with the GUI BehaviorSpace tool, and you can run experiments created in the GUI tool with the extension. You can copy experiments, and can set any of the parameters in the Experiment dialog or the Run options dialog.

NOTE: This extension is a work in progress.  Please visit the extension's homepage on GitHub and open an 'Issue' with any suggestions you have for fixes or extended functionality."""
    version:          "0.1.1"
    homepage:         "https://github.com/NetLogo/BehaviorSpace-Extension"
  }
  {
    name: "CSV"
    codeName: "csv"
    shortDescription: "Read and write csv files"
    longDescription: """"""
    version: "1.2.1"
    homepage: "https://docs.netlogo.org/csv.html"
  }
  {
    name: "DBSCAN"
    codeName: "dbscan"
    shortDescription: "Perform unsupervised density-based clustering of turtles and patches based on specified turtle/patch variables or by proximity using the DBSCAN algorithm"
    longDescription: """NetLogo extension for DBSCAN clustering algorithm

It allows you to perform unsupervised density-based clustering of turtles and patches based on specified turtle/patch variables or by proximity. The main advantage over supervised algorithms such as K-Means is that it is not necessary to specify the number of resulting clusters in advance. See the homepage for detailed documentation and examples."""
    version: "0.5"
    homepage: "https://github.com/chrfrantz/NetLogo-Extension-DBSCAN#readme"
  }
  {
    name: "Dialog"
    codeName: "dialog"
    shortDescription: "Displays dialog boxes with a NetLogo Web-compatible feature set"
    longDescription: "Displays dialog boxes with a NetLogo Web-compatible feature set"
    version: "1.2.1"
    homepage: "https://github.com/NetLogo/Dialog-Extension#dialog-extension"
  }
  {
    name: "Encode"
    codeName: "encode"
    shortDescription: "Conversions between byte lists, UTF-8 strings, and base64-encoded strings"
    longDescription: "This extension is for converting between lists of bytes and strings of different encodings. This is particularly useful for, say, taking binary data and turning it into a base64 string that can be easily passed around, or reading base64 data, converting it to a list of bytes, and directly manipulating those bytes."
    version: "1.1.0"
    homepage: "https://github.com/NetLogo/Encode-Extension#encode-extension"
  }
  {
    name: "Export-The"
    codeName: "export-the"
    shortDescription: "Exports special values as strings instead of as files"
    longDescription: "Reports special values (such as model file contents, `export-world` results, `export-view` results, `export-output` results, and `export-plot` results) as strings, so they can be used and/or manipulated from directly within NetLogo.  This extension is especially well-suited for use alongside the Import-A extension."
    version: "1.1.1"
    homepage: "https://github.com/NetLogo/ExportThe-Extension#readme"
  }
  {
    name: "Fetch"
    codeName: "fetch"
    shortDescription: "Read files and URLs"
    longDescription: "Primitives for reading files and URLs, with NetLogo Web compatibility"
    version: "1.1.0"
    homepage: "https://github.com/NetLogo/Fetch-Extension#fetch-extension"
  }
  {
    name: "FunctionalProgramming"
    codeName: "fp"
    shortDescription: "Primitives for several higher order operations commonly found in functional programming languages"
    longDescription: """"""
    version: "1.2.0"
    homepage: "https://github.com/NetLogo/FP-Extension/"
  }
  {
    name: "GIS"
    codeName: "gis"
    shortDescription: "Analyse, manipulate and draw GIS data"
    longDescription: """This extension adds GIS (Geographic Information Systems) support to NetLogo. It provides the ability to load vector GIS data (points, lines, and polygons), and raster GIS data (grids) into your model.

The extension supports vector data in the form of ESRI shapefiles. The shapefile (.shp) format is the most common format for storing and exchanging vector GIS data. The extension supports raster data in the form of ESRI ASCII Grid files. The ASCII grid file (.asc or .grd) is not as common as the shapefile, but is supported as an interchange format by most GIS platforms."""
    version: "1.4.1"
    homepage: "https://docs.netlogo.org/gis.html"
  }
  {
    name: "GoGo"
    codeName: "gogo"
    shortDescription: "Interact with HID-based GoGo boards"
    longDescription: """This is the new extension for physical computing, using sensors, motors, etc in NetLogo. It interfaces with GoGo boards running Human Interface Driver (HID) firmware, and it replaces the old GoGo Extension, which used USB-serial communications."""
    version: "2.1.2"
    homepage: "https://docs.netlogo.org/gogo.html"
  }
  {
    name: "Import-A"
    codeName: "import-a"
    shortDescription: "Generalized `import-*` primitives"
    longDescription: "Primitives for running `import-drawing`, `import-pcolors`, and `import-pcolors-rgb` on base64 strings, and `import-world` on plain text strings"
    version: "1.1.0"
    homepage: "https://github.com/NetLogo/ImportA-Extension#import-a"
  }
  {
    name: "Landscapes"
    codeName: "landscapes"
    shortDescription: "For creating continuous function optimization problem landscapes in NetLogo"
    longDescription: """This extension is a thin wrapper around the continuous function optimization problems classes implemented in the Optimization Algorithm Toolkit (OAT).

A continuous function optimization problem is one where you are are trying to find either the global optima or minima of a continuous function. OAT implements many such problems as Java classes. The goal of this extension is to make most of these problems easily usable from NetLogo."""
    version: "1.0.3"
    homepage: "https://github.com/NetLogo/Landscapes-Extension"
  }
  {
    name: "LevelSpace"
    codeName: "ls"
    shortDescription: "LevelSpace allows you to run NetLogo models |: from inside NetLogo models :|"
    longDescription: """LevelSpace is an extension for NetLogo that allows you to run several models concurrently and have them "talk" with each other. LevelSpace models are hierarchical, in that models always belong hierarchically to another model. We will refer to models that have loaded LevelSpace and have opened models as 'parents', and to the models they have opened as 'children' or 'child models'.

Asking and reporting in LevelSpace is conceptually pretty straight forward: You pass blocks of code to child models, and the child models respond as if you had typed that code into their Command Center. LevelSpace allows you to report strings, numbers, and lists from a child to its parent.

In general, the LevelSpace syntax has been designed to align with existing NetLogo primitives whenever possible."""
    version: "2.4.3"
    homepage: "https://docs.netlogo.org/ls.html"
  }
  {
    name: "LinProg"
    codeName: "linprog"
    shortDescription: "A set linear programming routines for NetLogo"
    longDescription: "The LinProg extension contains primitives for solving both primal and dual linear programming problems, with and without non-negativity constraints."
    version: "1.0.0"
    homepage: "https://github.com/cstaelin/LinProg-Extension"
  }
  {
    name: "LLM-Chat"
    codeName: "llm-chat"
    shortDescription: "Simple connection to a large language model (LLM) chat"
    longDescription: "This extension allows you to connect a large language model of type Ollama or OpenAI and then send messages directly from NetLogo."
    version: "1.0.0"
    homepage: "https://github.com/korinek-milan/netlogo-llmChat-extension"
  }
  {
    name: "LPSolver"
    codeName: "lpsolver"
    shortDescription: "A mixed-integer linear programming package for NetLogo"
    longDescription: "The LPSolver extension uses the lpsolve55 linear programming library to solve normal, integer and mixed-integer linear programming problems, returning the optimal solution and the shadow prices of the constraints."
    version: "4.2.2"
    homepage: "https://github.com/cstaelin/LPSolver-Extension/"
  }
  {
    name: "Matrix"
    codeName: "matrix"
    shortDescription: "Matrices support, including manipulation, math operations and some advanced features"
    longDescription: """Although matrices store numbers, much like a list of lists, or an array of arrays, the primary reason to use the matrix data type is to take advantage of special mathematical operations associated with matrices. For instance, matrix multiplication is a convenient way to perform geometric transformations, and the repeated application of matrix multiplication can also be used to simulate other dynamic processes (for instance, processes on graph/network structures).

If you’d like to know more about matrices and how they can be used, you might consider a course on linear algebra, or search the web for tutorials. The matrix extension also allows you to solve linear algebraic equations (specified in a matrix format), and even to identify trends in your data and perform linear (ordinary least squares) regressions on data sets with multiple explanatory variables."""
    version: "1.2.1"
    homepage: "https://docs.netlogo.org/matrix.html"
  }
  {
    name: "Network"
    codeName: "nw"
    shortDescription: "NetWork analysis tools"
    longDescription: """"""
    version: "4.1.1"
    homepage: "https://docs.netlogo.org/nw.html"
  }
  {
    name: "NodeJS"
    codeName: "js"
    shortDescription: "Run JavaScript code from NetLogo"
    longDescription: """This extension allows you to run JavaScript code from within NetLogo. It is built on top of the Node.js runtime, so any Node packages, e.g. from npm, will work as expected."""
    version: "0.3.0"
    homepage: "https://github.com/NetLogo/NodeJS-Extension"
    minNetLogoVersion: "NetLogo 6.3.0"
  }
  {
    name: "NumAnal"
    codeName: "numanal"
    shortDescription: "A set of numerical analysis routines for NetLogo"
    longDescription: "The NumAnal extension contains methods for finding the roots of single equations (Brent) and multivariable systems of equations (Newton and Broyden), for finding the minima of single equations (Brent) and multivariable functions (BOBYQA, CDS, CGS, CMAES, DES and Simplex), for finding fixed points (Scarf), and for evaluating definite integrals (Romberg). Documentation can be found in the folder/directory where the Extension Manager has installed the extension."
    version: "4.0.0"
    homepage: "https://github.com/cstaelin/NumAnal-Extension/releases"
  }
  {
    name: "Palette"
    codeName: "palette"
    shortDescription: "Visualize values in the model as colors"
    longDescription: """The NetLogo palette extension allows to map values to colors. The colors go beyond NetLogo colors, including ColorBrewer color schemes or arbitrary RGB colors. Additionally, it provides a primitive to map to color gradients and a primitive to launch a ColorBrewer dialog for easy scheme selection."""
    version: "2.1.1"
    homepage: "https://docs.netlogo.org/palette.html"
  }
 {
    name: "Pathdir"
    codeName: "pathdir"
    shortDescription: "Some useful operations on files and directories, and primitives for reading environment variables and system properties"
    longDescription: "Pathdir provides tools for finding the name of the current model, the current working, user and model directories; creating, moving, renaming, identifying and deleting directories; and listing the contents of directories. Pathdir also allows one to find the size and modification date of files, and the values of both environment variables and system properties."
    version: "5.2.0"
    homepage: "https://github.com/cstaelin/Pathdir-Extension"
  }
  {
    name: "Physics"
    codeName: "phys"
    shortDescription: "Primitives for motion, collisions, and gravity"
    longDescription: """The NetLogo physics extension provides a simple way to simulate physics on agents and patches within models. Currently, to do physics simulation in a model, a great deal of code is required to handle motion, collisions and gravity. In some cases it is possible to copy this code from model to model to implement physics simulations without having a deep level of understanding of the code itself, but this process can still be fairly complicated. The physics extension allows a modeler to interact with a physics simulation that runs outside of the model with a handful of intuitive NetLogo primitives without having to worry about any complicated physics code."""
    version: "0.4.3"
    homepage: "https://github.com/NetLogo/Physics-Extension/"
  }
  {
    name: "Profiler"
    codeName: "profiler"
    shortDescription: "See how much time operations take"
    longDescription: """If you’d like your model to run faster, the profiler extension may be useful to you. It includes primitives that measure how many times the procedures in your model are called during a run and how long each call takes. You can use this information to where to focus your speedup efforts.

Caution:

The profiler extension is experimental. It is not yet well tested or user friendly. Nonetheless, we think some users will find it useful."""
    version: "1.3.1"
    homepage: "https://docs.netlogo.org/profiler.html"
  }
  {
    name: "Python"
    codeName: "py"
    shortDescription: "Run Python code from NetLogo"
    longDescription: """This NetLogo extension allows you to run Python code from NetLogo. It works with both Python 2 and 3, and should work with almost all Python libraries."""
    version: "1.0.1"
    homepage: "https://docs.netlogo.org/py.html"
  }
  {
    name: "R"
    codeName: "r"
    shortDescription: "Primitives for using the statistical software R"
    longDescription: """The R-Extension of NetLogo provides primitives to use the statistical software R (Gnu S) (see the R Project website) within a NetLogo model. There are primitives to create R-Variables with values from NetLogo variables or agents and others to evaluate commands in R with and without return values."""
    version: "1.2.4"
    homepage: "https://ccl.northwestern.edu/netlogo/7.0.0-beta0/docs/r.html"
  }
  {
    name: "Reflection"
    codeName: "reflection"
    shortDescription: "Access basic information about a model from within the model (breeds, globals, procedures, etc)."
    longDescription: ""
    version: "2.0.0"
    homepage: "https://github.com/NetLogo/Reflection-Extension"
  }
  {
    name: "Resource"
    codeName: "resource"
    shortDescription: "Read bundled resources of model files"
    longDescription: """As of NetLogo 7.0 and the new '.nlogox' file format, resources can be bundled into models using the "File" > "Manage Bundled Resources" option.

This helps with two problems.  First, it makes it a lot easier to load data files seamlessly in both NetLogo and NetLogo Web, since you don't have to deal with `fetch` and their async primitives.

Secondly, it means not having to carry around external files (like CSV or GIS data, or images) when moving your model from one location to another.  Instead, you just bundle content of the file into the '.nlogox' file, and then read it out with this extension."""
    version: "1.1.1"
    homepage: "https://docs.netlogo.org/resource.html"
  }
  {
    name: "Rnd"
    codeName: "rnd"
    shortDescription: "Use random with a non-uniform distribution"
    longDescription: """This extension adds the ability to do roulette wheel selection in NetLogo. It provides a simpler way to accomplish the same thing as the Lottery Example from the NetLogo Models Library."""
    version: "3.1.1"
    homepage: "https://docs.netlogo.org/rnd.html"
  }
  {
    name: "Sample"
    codeName: "sample"
    shortDescription: "An example extension written in Java"
    longDescription: """"""
    version: "1.2.1"
    homepage: "https://github.com/netlogo/sample-extension/#readme"
  }
  {
    name: "Sample-Scala"
    codeName: "sample-scala"
    shortDescription: "An example extension written in Scala"
    longDescription: """"""
    version: "1.2.1"
    homepage: "https://github.com/netlogo/sample-scala-extension/#readme"
  }
  {
    name:             "SendTo"
    codeName:         "send-to"
    shortDescription: "Provides file-saving API that is compatible with both NetLogo and NetLogo Web"
    longDescription:  ""
    version:          "1.1.0"
    homepage:         "https://github.com/NetLogo/SendTo-Extension"
  }
  {
    name:             "Simple R Extension"
    codeName:         "sr"
    shortDescription: "This NetLogo extension allows you to run R code from within NetLogo.  It was built to address technical difficulties that users commonly had with the original R extension."
    longDescription:  ""
    version:          "3.1.3"
    homepage:         "https://docs.netlogo.org/sr.html"
  }
  {
    name: "Sound"
    codeName: "sound"
    shortDescription: "Play notes and sound files"
    longDescription: """"""
    version: "1.2.1"
    homepage: "https://docs.netlogo.org/sound.html"
  }
  {
    name: "Stats"
    codeName: "stats"
    shortDescription: "Facilitates the analysis of collected data and provides some less common probability distributions"
    longDescription: """The stats extension provides basic statistical functions for data generated within NetLogo models. stats maintains an internal data table of observations on an arbitrary number of variables and allows the user to find such statistics for the data as means, medians, quartiles, percentiles, standard deviations, and variance-covariance and correlation matrices; to regress one or more variables on another; and to forecast the value of any variable into the future based on past observations. Regression statistics include R2, Adjusted R2, F and the probability of F, and for each of the coefficients, the standard error, T statistic and probability of the T statistic. stats also provides values of. and the areas under, the normal, log-normal, student, binomial, gamma, beta and Chi-Square distributions, and, for some, their inverses.

Although stats can be used to analyze the overall results of a run of a model, it is intended mostly for the use of smart agents who gather and analyze data in order to make decisions. Agents can maintain their private data tables, use tables shared as globals, or both."""
    version: "3.0.1"
    homepage: "https://github.com/cstaelin/Stats-Extension"
  }
  {
    name: "Store"
    codeName: "store"
    shortDescription: "Persistent key-value pairs"
    longDescription: """This extension provides primitives for writing and reading string values to and from a keyed, persistent data store."""
    version: "1.0.2"
    homepage: "https://github.com/NetLogo/Store-Extension/"
  }
  {
    name: "String"
    codeName: "string"
    shortDescription: "Many additional primitives for working with strings"
    longDescription: ""
    version: "1.2.0"
    homepage: "https://github.com/NetLogo/String-Extension#netlogo-string-extension"
  }
  {
    name: "Table"
    codeName: "table"
    shortDescription: "Store pairs of values, so you can retrieve the second value by knowing the first one"
    longDescription: """Tables are useful when you need to do associate values with other values. For example, you might make a table of words and their definitions. Then you can look up the definition of any word. Here, the words are the "keys". You can easily retrieve the value for any key in the table, but not vice versa."""
    version: "2.1.1"
    homepage: "https://docs.netlogo.org/table.html"
  }
  {
    name: "Time"
    codeName: "time"
    shortDescription: "Date/time utilities, discrete event scheduling and using time-series data"
    longDescription: """The extension provides tools for representing time explicitly, especially by linking NetLogo’s ticks to a specific time interval. It allows users to do things such as starting a simulation on 1 January of 2010 and end on 31 December 2015, have each tick represent 6 hours, and check whether the current simulation date is between 1 and 15 March.

Modelers commonly need to use time series data in NetLogo. The time extension provides convenient primitives for handling time series data. With a single command, you can load an entire time series data set from a text file. The first column in that text file holds dates or datetimes. The remaining columns can be numeric or string values. You then access the data by time and by column heading, akin to saying "get the flow from May 8, 2008".

The time extension enables a different approach to scheduling actions in NetLogo. Traditionally, a NetLogo modeler puts a series of actions or procedure calls into the "go" procedure, which is executed once each tick. Sometimes it is more natural or more efficient to instead say "have agent X execute procedure Y at time Z". This is what discrete event scheduling (also know as "dynamic scheduling") enables. Discrete event simulation has a long history and extensive literature, and this extension makes it much easier to use in NetLogo."""
    version: "3.1.1"
    homepage: "https://docs.netlogo.org/time.html"
  }
  {
    name: "Vid"
    codeName: "vid"
    shortDescription: "Capture videos of the model or from a webcam"
    longDescription: """"""
    version: "1.3.2"
    homepage: "https://docs.netlogo.org/vid.html"
  }
  {
    name: "View2.5d"
    codeName: "view2.5d"
    shortDescription: "Visualize agent properties as height on a 3d surface"
    longDescription: """"""
    version: "1.2.3"
    homepage: "https://docs.netlogo.org/view2.5d.html"
  }
  {
    name: "Web"
    codeName: "web"
    shortDescription: "NetLogo primitives for talking to the web and making HTTP requests"
    longDescription: """Contains numerous primitives for importing data (e.g. `import-world`) from URLs, and well as exporting data (e.g. `export-world`) to URLs, as well as a generalized primitive (`make-request`) for performing plain HTTP requests."""
    version: "2.1.2"
    homepage: "https://github.com/NetLogo/Web-Extension/"
  }
]