MASON (Multi-Agent Simulator Of Neighborhoods… or Networks… or something…) is a fast discrete-event multiagent simulation library core in Java, designed to be the foundation for large custom-purpose Java simulations, and also to provide more than enough functionality for many lightweight simulation needs.

MASON has execution speed as a high priority. MASON 1-35% faster than Repast.

It has an example of Schelling's model in /home/pedro/codigo/mason/sim/app/schelling/Agent.java. The model is composed by reds, blues, empty sites where the players can move, and non-available sites. Following there is an example of calculating the unsatisfaction and moving to another site:

  // get all the places I can go.  This will be slow as we have to rely on grabbing neighbors.
  sch.neighbors.getNeighborsMaxDistance(loc.x,loc.y,sch.neighborhood,false,neighborsX,neighborsY);
    
  // compute value
  double val = 0;
  int threshold = sch.threshold;  // locals a little faster
  int numObjs = neighborsX.numObjs;
  int[] objsX = neighborsX.objs;
  int[] objsY = neighborsY.objs;
  int myVal = locs[x][y];
      
  for(int i=0;i<numObjs;i++)
  {
      if (locs[objsX[i]][objsY[i]] == myVal // just like me
          && !(objsX[i] == x && objsY[i] == y))  // but it's NOT me
      {
          val += 1.0/Math.sqrt((x-objsX[i])*(x-objsX[i]) + (y-objsY[i])*(y-objsY[i]));
          if (val >= threshold) return;  // we're not moving
      }
  }
      
  // find a new spot to live -- a random jump? Move to a nearby location?  Websites differ
  int newLocIndex = state.random.nextInt(sch.emptySpaces.numObjs);
  Int2D newLoc = (Int2D)(sch.emptySpaces.objs[newLocIndex]);
  sch.emptySpaces.objs[newLocIndex] = loc;
      
  // swap colors
  int swap = locs[newLoc.x][newLoc.y];
  locs[newLoc.x][newLoc.y] = locs[loc.x][loc.y];
  locs[loc.x][loc.y] = swap;
  // adopt new position
  loc = newLoc;

Abstract: We introduce MASON, a fast, easily extendable, discrete-event multi-agent simulation toolkit in Java. MASON was designed to serve as the basis for a wide range of multi-agent simulation tasks ranging from swarm robotics to ma- chine learning to social complexity environments. MASON carefully delineates between model and visualization, al- lowing models to be dynamically detached from or attached to visualizers, and to change platforms mid-run. We de- scribe the MASON system, its motivation, and its basic architectural design. We then discuss five applications of MA- SON we have built over the past year to suggest its breadth of utility.

Agents and the Schedule MASON employs a specific usage of the term agent: a computational entity which may be scheduled to perform some action, and which can manipulate the environment. Note that we do not explicitly state that the agent is physically in the environment, though it may be; in this case we would refer to the agent as an embodied agent. Agents are brains, and do not need to be bodies. MASON does not schedule events on the schedule to send to an agent; rather it schedules the agent itself.

Fields MASON's fields relate arbitrary objects or values with locations in some notional space. Many of these fields are little more than wrappers for simple 2D or 3D arrays. Others provide sparse relationships. An object may exist in multiple fields at one time (and, for some fields, in the same field more than once). The use of fields is entirely optional.

MASON was developed by the Evolutionary Computation Laboratory (ECLab) and the Centre for Social Complexity at George Mason University. At present MASON does not provide functionality for dynamically charting (e.g. histograms, line graphs, pie charts, etc) model output during a simulation, or allow GIS data to be imported / exported (Luke et al., 2004). However, the developers of MASON are continuing to develop further functionality, and they hope users will develop and contribute tools themselves (e.g. GIS integration). Unfortunately there is little technical documentation and a relatively small user group in comparison to some of the other systems identified within this paper. However, how-to documentation, demonstration models (e.g. the seminal heat bugs example, network models, etc), and several publications detailing the implementation and / or application of MASON are available for a prospective modeller to evaluate the system further (MASON, 2006).

Abstract: MASON is a fast, easily extensible, discrete-event multi-agent simulation toolkit in Java, designed to serve as the basis for a wide range of multi-agent simulation tasks ranging from swarm robotics to machine learning to social complexity environments. MASON carefully delineates between model and visualization, allowing models to be dynamically detached from or attached to visualizers, and to change platforms mid-run. This paper describes the MASON system, its motivation, and its basic architectural design. It then compares MASON to related multi-agent libraries in the public domain, and discusses six applications of the system built over the past year which suggest its breadth of utility.

MASON was designed as a smaller and faster alternative to Repast, with a clear focus on computationally demanding models with many agents executed over many iterations. Design appears to have been driven largely by the objectives of maximizing execution speed and assuring complete reproducibility across hardware. The abilities to detach and re-attach graphical interfaces and to stop a simulation and move it among computers are considered a priority for long simulations. MASON’s developers ap- pear intent on including only general, not domain-specific, tools.