Skip to content

ExportingProjectsAsSimulationLaunchers

rubenanko edited this page Oct 14, 2026 · 1 revision

Exporting Projects As Simulation Launchers

The GAMA Platform is an Integrated Development Editor (IDE), an expert software developed and designed for re-searchers and modelers. Therefore, the use of a GAMA simulation requires some prior knowledge on how to use such a platform before being able to execute a model. This comes as a constraint when the project needs to be shared to people with no background or expertise in computer science or software development (eg. other researchers, stake holders, etc). Gama's export plugin is meant to answer the need of a simple approach for sharing GAMA projects as independent applications that can run simulations without needing the GAMA platform, Java or any prerequisite to be installed on the target machine.

What is exported

The export plugin builds a modified, lighter copy of your own installation of GAMA, which contains the project of your choice. This copy does not contain any editing features and automatically lauches a simulation on startup. This newly created application allows people with no expertise to use your models.

How create an export

Before creating an export, make sure every models you want to export are compiling properly.

Keep in mind that exported applications only work for the operating system they were built on !

Therefore, you need to build the export on Windows if your target platform is Windows, and it's the same for MacOS x86_64, MacOS aarch64/arm and Linux.

User interface

You can export a single model or a whole project. You will be able to select which experiments you want export in your target project or model.

You can open the export configuration menu for a project by performing a right click on the target project in the navigation panel, and left click on export, then export as a simulation launcher :

Export Project Button

You can open the export configuration menu for a single model by clicking on the button located next to the simulation launching button of the model opened in the editor :

Export Model Button

Configuration

Here is a screenshot of the configuration menu for a single model :

Export Model Menu

You can select the experiments you want to keep in the exported application.

When selecting the exported experiments in a projects, the path to the model it is associated with is displayed next to the experiment name :

Export Project Menu

You choose to include your own Java Development Kit (JDK) in the exported application, to remove the need of Java installed for running your export.

The export configuration menus are identical on Windows an Linux. MacoS doesn't feature the single executable file option, as it is not needed.

Models or projects can be exported in two formats :

  • zip archive
  • single file executable

If the export format is a single file executable, the final user just need to double click on the application to start it.

If the export format is a zip archive, the final user must have a zip extraction software installed on his machine, and extract the content of the archive. He must then execute the entrypoint Gama.exe on Windows or Gama on Linux.

If the JDK is not included in the export, the user will need a Java environement to be installed on his machine before starting the application.

If the export format is a single file executable and the zip is included, the final user can start the application without any prerequisites.

Creation

When you click OK, the export will begin and a progress bar will show up. The exporting process should last less than 15 seconds if it doesn't include the JDK. This duration is roughly doubled if you choose to include the JDK :

Export Progress Bar

When the export is done, a information dialog will pop up and give you the possibility to open your file explorer in the directory where the export is located :

Export Ask Open Explorer

How to use the exported application

Starting the application

When starting the application from a single file executable, you may wait a few seconds before any visible loading appears. This time depends on the host computer and is increased if you included the JDK. On modern computers, it is usually very fast, and less than 2 seconds. This loading time only happens for the first startup of the export.

if a single experiment was selected when configuring the export, the application launches the associated simulation immediately. If multiple experiments were made available, a dropdown menu shows up and allows the user to select what experiment he wants to launch :

Select Experiment Startup

MacOS

To execute the exported application, double click on the zip archive to extract its content. An app with the name you defined when configuring the export will appear with the GAMA icon. You can double click on it to start the application.

On another computer than then one which built the export, the MacOS Gatekeeper will prevent the exported application to execute. It can be bypassed by entering the following command in the terminal :

xattr -cr path/to/the/launcher.app

Switching experiments

In the toolbar, a button allows to switch between experiments without leaving the simulation perspective :

Select Experiment Button

When you click on it, a selection menu will appear, featuring a dropdown menu where every available experiments are displayed.

Select Experiment

Saving artifacts

Simulations may produce files. The saving button allows users to save them in the directory of their choice :

Save Artifacts Button

It opens a small configuration menu allowing users to choose where to save the files, and whether they would like to open their file explorer in the target directory :

Save Artifacts Menu

If a user attempts to close the application with unsaved files, a warning menu will pop up and give the opportunity to save them before leaving :

Unsaved Artifacts Warning Message

  1. What's new (Changelog)
  2. Migration Guide (2025-06 → 2026-06)
  1. Installation and Launching
    1. Installation
    2. Launching GAMA
    3. Updating GAMA
    4. Installing Plugins
  2. Workspace, Projects and Models
    1. Navigating in the Workspace
    2. Changing Workspace
    3. Importing Models
  3. Editing Models
    1. GAML Editor (Generalities)
    2. GAML Editor Tools
    3. Validation of Models
  4. Running Experiments
    1. Launching Experiments
    2. Experiments User interface
    3. Controls of experiments
    4. Parameters view
    5. Inspectors and monitors
    6. Displays
    7. Batch Specific UI
    8. Errors View
  5. Running Headless
    1. Getting Started
    2. Headless Legacy
    3. Headless Batch
  6. Exporting Projects As Simulation Launchers
  7. Preferences
  8. Troubleshooting
  1. Introduction
    1. Start with GAML
    2. Organization of a Model
    3. Basic programming concepts in GAML
  2. Manipulate basic Species
  3. Global Species
    1. Regular Species
    2. Defining Actions and Behaviors
    3. Interaction between Agents
    4. Attaching Skills
    5. Inheritance
  4. Defining Advanced Species
    1. Grid Species
    2. Graph Species
    3. Mirror Species
    4. Multi-Level Architecture
  5. Defining GUI Experiment
    1. Defining Parameters
    2. Defining Displays Generalities
    3. Defining 3D Displays
    4. Defining Charts
    5. Defining Monitors and Inspectors
    6. Defining Export files
    7. Defining User Interaction
  6. Classes and Objects
    1. Class Definition and Instantiation
    2. Attributes and Actions
    3. Inheritance
    4. Virtual Classes
    5. Advanced Features
  7. Exploring Models
    1. Run Several Simulations
    2. Batch Experiments
    3. Exploration Methods
  8. Optimizing Models
    1. Runtime Concepts
    2. Analyzing code performance
    3. Optimizing Models
  9. Multi-Paradigm Modeling
    1. Control Architecture
    2. Defining Differential Equations
  1. Manipulate OSM Data
  2. Cleaning OSM Data
  3. Diffusion
  4. Using Database
  5. Using Dataframes
  6. Using FIPA ACL
  7. Using BDI with BEN
  8. Using Driving Skill
  9. Manipulate dates
  10. Manipulate lights
  11. Using comodel
  12. Save and restore Simulations
  13. Using network
  14. Writing Unit Tests
  15. Ensure model's reproducibility
  16. Going further with extensions
    1. Calling R
    2. Using Graphical Editor
    3. Using Git from GAMA
  1. Built-in Species
  2. Built-in Skills
  3. Built-in Architecture
  4. Statements
  5. Data Type
  6. File Type
  7. Stats Extension
  8. Sound Extension
  9. BDI Extension
  10. FIPA Skill
  11. Expressions
    1. Literals
    2. Units and Constants
    3. Pseudo Variables
    4. Variables And Attributes
    5. Operators (Definition)
    6. Operators [A-A]
    7. Operators [B-C]
    8. Operators [D-H]
    9. Operators [I-M]
    10. Operators [N-R]
    11. Operators [S-Z]
  12. Exhaustive list of GAMA Keywords
  1. Installing the development version
    1. Install GAMA source code with Eclipse plugin
  2. Developing Extensions
    1. Developing Plugins
    2. Developing Skills
    3. Developing Statements
    4. Developing Operators
    5. Developing Types
    6. Developing Species
    7. Developing Control Architectures
    8. Index of annotations
  3. Introduction to GAMA Java API
    1. Architecture of GAMA
    2. IScope
  4. Using GAMA flags
  5. Export plugin : Technical Documentation
  6. Creating a release of GAMA
  7. Documentation generation

  1. Predator Prey
  2. Road Traffic
  3. Incremental Model
  4. Luneray's flu
  5. BDI Agents
  6. Forager RL
  7. SIR Analysis
  8. 3D Model

  1. Team
  2. Projects using GAMA
  3. Scientific References
  4. Training Sessions

Resources

  1. Videos
  2. Conferences
  3. Pedagogical materials

Clone this wiki locally