Distributed GLC

This is the tutorial page for distributed computing with GLC actors. This page is preserved for reference. 

To read:


The logo of distributed GLC, chemlambda and graphic lambda calculus (GLC) is this:




TL;DR  description of the model.


  • decentralized and asynchronous
  • based on artificial life
  • and actor style, not process calculi style interactions


  • to unite the real and the virtual worlds into one, moved by the same real/virtual chemistry, into an ecology where humans bring the meaning by communication.


  • with individual molecules from an  artificial chemistry, chemlambda,
  • each molecule managed by an actor
  • interactions between actors like signal transduction, not like the usual  sender-channel-receiver.


This computation model has two stages:

  • preparation
  • and computation.

In the preparation  stage we define the actors, then in the second stage, the actors interact according to 5 rules of behaviour, performing an asynchronous distributed computation.

Principles of distributed GLC: [source]

  • distributed
  • asynchronous
  • done by processing structure to structure (via graph rewrites)
  • purely local
  • uses an analogy with molecules and chemical reactions, but the spatial relations between the interacting molecules are replaced by actors interactions in a variant of the Actor Model.

What is not:

  • the model is not sequential, although it may do sequential computation, if constrained; however, the model does not need the idea of a sequential computation,
  •  synchronization is not needed for the model, in fact any synchronization hypothesis would only cripple the power of the model,
  • this model of computation does not need or use any  evaluation procedure, nor in particular evaluation strategies. No names of variables, no values are used.
  • the model does not rely on signals passing through gates, nor on the sender-receiver setting of Information Theory.
  •  Because the eta reduction is not part of the model,  no functions are used, needed, or make sense.
  • this model of computation is not based on a  global picture. There is no global state, no global space,  no global time,
  • no semantics.


GLC actors and their behaviours.    A GLC actor it’s an entity which has some data and 5 possible behaviours. See section 3 from GLC actors, artificial chemical connectomes, topological issues and knots for details and examples.

Data.  Every actor has a name. The notation used is that the actor :a is the name of the actor a.  Every actor has also, as data, a GLC graph which has some of his half-arrows decorated with names of other actors.

You can use these decorations in order to assembly a big GLC graph from the pieces which reside in all actors data, by gluing the half arrows along the given decorations.

But mind you that the behaviours of actors are not a consequence of the existence of this global object, the big GLC graph.

Behaviours. The main idea is that the graph rewrites of the big GLC graph can be done asynchronously, by purely local interactions between the actors which have the small pieces of the big GLC graph.

There are two types of graph rewrites, which are treated differently. They appear as  behaviours 1 and 3.

Behaviour 1: the graphic beta move (and the FAN-IN move if we use chemlambda instead of GLC)  is performed between two actors, as a form of interaction between those.

Behaviour 2: name change. An actor can pass one node to another actor. It has to be an actor which he knows, i.e. one which has an address which appears on one of the half-arrows of the mentioned node.

Behaviour 3: FAN-OUT and pruning moves, which are performed internally in one actor.

Behaviour 4: creation of new actors. An actor can split into two, thus he can create a new actor, provided it’s piece of GLC graph has two disconnected parts.

Behaviour 5: interaction with cores. Suppose you use external IT constructs, like databases, counters or other. Call this  “cores”.  You make an actor from such a core by connecting it to a “mask” (which is  GLC graph) and by defining moves which are performed between the mask and the core. Basically such a move means a translation from external format into GLC graphs. This can be always done, because GLC is Turing universal. In the paper is given the example of a counter as a core.


41 thoughts on “Distributed GLC”

  1. “this model of computation does not need or use any evaluation procedure, nor in particular evaluation strategies” : IFF one does not need to connect the results to and interface with non-GLS systems of computation ??

    1. This has nothing to do with evaluation during, or for computation. Interaction with the exterior is mediated by a GLC actor, called “mask”, which interacts with a “core” (other, external, data), according to specific, but arbitrary moves.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

computing with space | open notebook


Change, when it comes, cracks everything open. - Dorothy Allison


computing with space | open notebook

Research Practices and Tools

computing with space | open notebook


News from coreboot world


computing with space | open notebook

Random thoughts and fancy math

computing with space | open notebook


The Decentralised Internet is Here


computing with space | open notebook

Low Dimensional Topology

Recent Progress and Open Problems


An experimental 3d voxel rendering algorithm

DIANABUJA'S BLOG: Africa, The Middle East, Agriculture, History and Culture

Ambling through the present and past with thoughts about the future

Retraction Watch

Tracking retractions as a window into the scientific process

Gödel's Lost Letter and P=NP

a personal view of the theory of computation

%d bloggers like this: