GP Software

The following GP applications and packages are known to be maintained by their developers.

Clojush (Clojure/Java) by Lee Spector, Thomas Helmuth, and additional contributors

Clojush is a version of the Push programming language for evolutionary computation, and the PushGP genetic programming system, implemented in Clojure. Push features a stack-based execution architecture in which there is a separate stack for each data type. PushGP has been used for a variety of applications, ranging from intelligent agent design to automatic quantum computer programming. It has also been used for “meta-genetic-programming” or “autoconstructive evolution” experiments, in which programs and genetic operators co-evolve or in which programs produce their own offspring while also solving problems.

Learn more about genetic programming in Clojure, using either Clojush or a minimalist implementation of tree-based genetic programming, in this YouTube video.

Data Modeler (Mathematica) by Evolved Analytics

The DataModeler package is developed within the context of industrial data analysis with a goal of rapid analysis, interpretation and exploitation of multivariate data sets. Towards this goal, we have developed a system which at its core exploits advanced and powerful nonlinear data modeling techniques.

DEAP (Python) Distributed Evolutionary Algorithms by Félix-Antoine Fortin and François-Michel De Rainville

DEAP is a novel evolutionary computation framework for rapid prototyping and testing of ideas. It seeks to make algorithms explicit and data structures transparent. It works in perfect harmony with parallelisation mechanism such as multiprocessing and SCOOP.

ECJ (Java) by Sean Luke, et al.

ECJ is a research Evolutionary Computation system written in Java. It was designed to be highly flexible, with nearly all classes (and all of their settings) dynamically determined at runtime by a user-provided parameter file. All structures in the system are arranged to be easily modifiable. Even so, the system was designed with an eye toward efficiency.

EllenGP (C++) by William La Cava

EllenGP uses a stack-based, syntax-free, linear genome for constructing candidate equations. It is built to include different evolutionary methods for system identification adapted from literature. The options include normal tournament selection, deterministic crowding, and age-pareto fitness selection. All algorithm choices are mangaged by one parameter file.

Eureqa (web) by Nutonian

Eureqa is a Machine Intelligence™ application that automates much of the heavy lifting inherent in analytics and data science. Leveraging automated evolutionary algorithms, Eureqa churns through your data to create accurate predictive models in minutes rather than months.

FCUBE (Amazon cloud) by ALFA Group, CSAIL, MIT

A platform for collaborative learning supporting and uniting developers of home-brewed classifier algorithms to solve relevant problems of public domain. FCUBE allows users to:

  • Execute classification algorithms with large training data with a preset computational budget on Amazon EC2
  • Retrieve the solutions from the cloud nodes, build a fused model, and compute the testing predictions
  • Easily upload datasets
  • Easily contribute your standalone classifier in executable format (Java, python) or as source code (must compile in Linux: C, C++ etc)

FlexGP (Java) by ALFA Group, CSAIL, MIT

FlexGP centers on scalable machine learning using genetic programming (GP). All code is on github, including examples and tutorials.
GP Learners for symbolic regression applied to supervised machine learning:

GP Learners for classification:

FlexGP System (Amazon cloud) by ALFA Group, CSAIL, MIT

A cloud based platform for generating transparent, non-linear, large scale regression problems. It is composed of a sophisticated learner, a set of launch scripts, and a Java library that provides a TCP/IP communication layer. FlexGP System run on Amazon EC2.

GeneticEngine (Python) by Alcides Fonseca, Guilherme Espada, Leon Ingelse, and others at LASIGE.

GeneticEngine is a grammar-guided genetic programming (GGGP) framework, in which the grammars are defined using Python classes. GeneticEngine supports single- and multi-objective optimization. GeneticEngine implements Grammatical Evolution (GE), Structured GE (SGE), dynamic SGE and the classic tree-based approach, also known as Context-Free Grammars GP. Furthermore, GeneticEngine can evolve the grammar throughout the evolution (as in Probabilistic GE). The GGGP algorithm in GeneticEngine can be completely customized by the user, but GeneticEngine also comes with off-the-shelf regression and classification solutions, and off-the-shelf grammars to implement grammars for standard GP, as well as grammars for other domains.

GenProg, Evolutionary Program Repair (?) by Westley Weimer, Stephanie Forrest, and Claire Le Goues

Software maintenance accounts for over two-thirds of that life cycle cost, and a key aspect of maintenance is fixing bugs in existing programs. Unfortunately, the number of reported bugs far outstrips available development resources. It is common for a popular project to have hundreds of new bug reports filed every day. GenProg reduces software maintenance costs by automatically producing patches (repairs) for program defects. Many bugs can be fixed with just a few changes to a program’s source code. Human repairs often involve inserting new code and deleting or moving existing code. GenProg uses those same building blocks to search for repairs automatically.

GSGP-CUDA by Leonardo Trujillo, Instituto Tecnológico de Tijuana

Geometric Semantic Genetic Programming (GSGP) is a state-of-the-art machine learning method based on evolutionary computation. GSGP performs search operations directly at the level of program semantics, which can be done more efficiently than operating at the syntax level like most GP systems. Efficient implementations of GSGP in C++ exploit this fact, but not to its full potential. This paper presents GSGP-CUDA, the first CUDA implementation of GSGP and the most efficient, which exploits the intrinsic parallelism of GSGP using GPUs. Results show speedups greater than 1, 000 X relative to the state-of-the-art sequential implementation, during the model training process. Additionally, our implementation allows the user to seamlessly make inferences over new data through the best evolved model, opening the possibility of using GSGP on Big Data problems.

The Code is found at: github.com/ElsevierSoftwareX/SOFTX_2020_38
The Open publication is found at: doi.org/10.1016/j.softx.2022.101085

HeuristicLab (Windows) by University of Applied Sciences, Upper Austria

HeuristicLab is a framework for heuristic and evolutionary algorithms that is developed by members of the Heuristic and Evolutionary Algorithms Laboratory (HEAL) since 2002.

  • Graphical User Interface
  • Algorithm Prototyping
  • Evolutionary Algorithms
  • Genetic Programming
  • Data Analysis
  • Simulation-based Optimization
  • Experiment Design and Analysis
  • Plugin-based Architecture

Karoo GP (Python) by Over the Sun, LLC

A Python based genetic programming application suite with support for symbolic regression and classification. Karoo GP is a scalable platform with both CPU and GPU support via Tensorflow. It is a highly scalable platform proved to work with realworld data, from benchmark tests to radio astronomy and gravitational wave datasets. As a teaching tool, it’s relative transparent design enables instructors to share step-by-step how an evolutionary algorithm arrives to its solution. As a hands-on learning tool, Karoo GP supports rapid, repeatable experimentation with a simple, text-based interface and full support for Jupyter notebook.

  • Ready to run, no programming required.
  • CPU and GPU support via TensorFlow.
  • Includes a simple user interface with menu, 5 display modes, and runtime reconfiguration of parameters and full support for Jupyter notebook.
  • Supports preset and/or argument-based scripting.
  • Anticipates datasets as standard .csv files.
  • Auto-records the full population of each generation and runtime configuration.
  • Supports the loading of customized seed populations.
  • Relatively simple framework for preparing custom fitness functions and evaluation routines.
  • Written in Object Oriented Python with a hierarchical naming scheme for all methods, ample in-line comments, and well written User Guide.

Linear Genetic Programming (Kotlin) by Jed Simson

An implementation of Linear Genetic Programming (LGP) as outlined by M. F. Brameier and W. Banzhaf (2007). LGP is a paradigm of genetic programming that employs a representation of linearly sequenced instructions in automatically generated programs. A linear approach lends itself to programs which have two unique attributes: a graph-based functional structure and the existence of structurally non-effective instructions.

This particular implementation is written using the Kotlin programming language and provides:

  • A modern, robust, and easy-to-use API.
  • A modular system design that allows extensibility of entire system components.
  • Numerous built-in components for use in different contexts (e.g. parallelised evolutionary algorithms, fitness functions).
  • Cross-platform support due to being built on a JVM-based language.
  • Extensive API documentation and usage guide.
  • Completely open-source and still in active development.

Operon by Bogdan Burlacu, Gabriel Kronberger, and Michael Kommenda

Operon (C++) is a modern C++ framework for symbolic regression that uses a highly scalable concurrency model. Its features include very fast execution speed, low memory footprint, support for non-linear least squares using numerical or automatic differentiation, and python bindings as well as integration with scikit-learn. The project includes Python bindings.

PyshGP by Eddie Pantridge

PyshGP is a library for Push Genetic Programming in Python. PyshGP aims to bring PushGP to a wider range of users and use cases. Many popular ML/AI frameworks are written in Python, and with PyshGP it is easy to compare PushGP with other methods or build ML pipelines that contain PushGP and other model types together.

Other PushGP implementations are rapidly changing tools meant so support research and publication. PyshGP focuses on offering a slow changing set of highly curated features based on existing results.

Modular Agent Based Evolution Framework (mixed environments and platforms) by Hintzelab

MABE is a digital evolution research tool used to create and manage populations of evolving digital organisms. Mabe is a framework with modular parts which can be combined to create experiments. MABE encourages users to develop new modules if needed, and use existing modules when possible.

The purpose of MABE is threefold:

  • To support and accelerate research into topics related to digital evolution.
  • To provide insight into evolution and evolutionary processes in both digital and biological contexts.
  • To provide a platform which allows for direct comparisons.

Symbiotic Bid-Based GP (Python) by Jessica Pauli de Castro Bonson

Symbiotic Bid-Based GP (SBB) is a framework for coevolving teams of programs that learn how to autonomously decompose a decision task. Solutions therefore always consist of at least two programs. The framework assumes that decisions take the form of a discrete set of actions (as in classification and reinforcement learning with atomic actions).

Behavioural diversity measures are used to mitigate the effect of local minima. Specifically, a genotypic team diversity measure and behavioral diversity measures are available; the latter w.r.t. action and state. Other features include: training against the environment, against custom opponents, and against a hall of fame; detailed customization of the training configuration; training in up to 2 layers; and the resultant agents are stored as .json files, thus can easily be translated to actual code or executed by an application.

To date, examples of the SBB framework have been demonstrated for multi-class classification, and single and multi-agent reinforcement learning in control and computer gaming (e.g. Acrobot, Rubik’s Cube, keepaway soccer, MsPacMan, Poker). However, this implementation of SBB focus on reinforcement learning, and is not recommended for classification.

Tiny Genetic Programming (Python) by Moshe Sipper

Two minimalistic programs implementing Koza-style (tree-based) genetic programming to solve a symbolic regression problem.