The software on this page

I am an amateur coder, currently working mostly with C++, and making heavy use of the Qt library for GUI functions, interfacing with Sql databases, and drawing graphics (you might say that I code in Qt rather than C++). Occasionally, I also write scripts for R (usually for quick work on data tables or matrices), and I have done very few things in Java (primarily writing plugins for Gephi) and Python.

In the past, I used to share downloads for some of the software that I wrote via my website, but I decided to switch from WordPress to Github Pages (the website you are currently looking at), and to share software directly from the Github repositories.

On this page, I either share links to the downloads attached to my Github repositories, or I share links to project pages for larger projects, such as Q-SoPrA. For the plugins I created for Gephi, you’ll have to use the Plugins menu of Gephi itself.


A note on Q-SoPrA

I am currently working on an integrated software package for Qualitative analysis of Social Processes, called Q-SoPrA (Qualitative Social Process Analysis). This is an open source project, written in C++, making heavy use of the Qt5 library (I won’t actually open the source until I have a more or less fully featured beta version, and when I have got a wiki up and running for Q-SoPrA). Work on Q-SoPrA is still in progress, but I am nearing a releasable version.

Q-SoPrA will hopefully make some of the plugins I wrote for Gephi redundant, in the sense that it has built-in features for visualisation of event graphs (and much more), finding lineages, and so on. I also included options to abstract network data from event data, and visualise the resulting networks. I was also able to include some advantageous options that are currently not (yet) available in Gephi, such as the ability to visualise parallel edges, and to perform advanced multi-mode transformations on the fly (Gephi does have a plugin for multi-mode transformations, but the options built into Q-SoPrA are more advanced).

The initial releases of Q-SoPrA won’t include any possibilities to obtain network metrics, but I do plan to implement such possibilities on the long term. For now, Q-SoPrA simply allows you to export node and edge lists, which can then be imported in other software for quantitative analysis (as the name suggests, the emphasis of Q-SoPrA is on qualitative analysis).

Event Graph Layout

The Event Graph Layout is a layout plugin for Gephi. The layout can be used to lay out any network in which the nodes have some temporal ordering that can be expressed by their position on a horizontal axis. I created the layout plugin primarily to make it easy to create event graphs in Gephi. In event graphs nodes are events and the edges express relationships between events. For example, an event graph could be used to visualise a sequence of social activities, where the edges express which activities occurred in response to which other activities, thus visualising interactions.

Basic instructions

The Event Graph Layout plugin requires you to include an order variable in the node list of your graph (in Gephi’s data laboratory). The order variable should be of a numeric type (e.g., integer, float, double). From the layout’s menu, the order variable should be selected from the corresponding drop-down menu. One can then activate the plugin, which will cause the nodes to be assigned a position on the horizontal axis of the draw screen that corresponds to the value of their order variable. The layout plugin keeps running until you explicitly deactivate it. This allows you to drag around nodes on the vertical axis of the layout without changing their position on the horizontal axis.

The Scale of Order, unsurprisingly, scales the order variable. By default, the order variable is scaled by 10, which means that the value of the order variable of each node is multiplied by 10 before the variable is used to determine the position of nodes on the horizontal axis. Thus, the distance between the nodes in the event graph can be changed by changing the Scale of Order. The appropriate Scale of order depends on the values of your order variable. I suggest changing the value until you find the distance that you like.

The Set Vertical Force option activates a simplified force-based layout algorithm that only affects the position of nodes on the vertical axis of the layout (I based this algorithm on one of Gephi’s Force Atlas algorithms). The effect is that nodes that are more tightly interconnected will remain relatively close to each other on the vertical axis, while nodes that are more loosely connected will drift apart. This makes it easier to have a more organised layout when you have a graph with many nodes.

The Vertical Scale variable determines how strong the force is that pushes unconnected nodes away from each other. The higher the value, the stronger the push. Finding appropriate values for your graphs usually requires you to play around a bit.

The Strong Gravity Mode is a convenience function that sets the attracting forces (gravity) to a very high value. This typically means that all nodes end up on a straight line. This can be a good way to quickly reset your layout if nodes drifted too far apart (for example, after you set an insanely high Vertical Scale).

The Gravity variable can be used to regulate the attracting forces between nodes. It can be useful to prevent your nodes from drifting apart too much. Creating a good looking layout usually requires you to use the Gravity variable in harmony with the Vertical Scale.

Occasionally, you’ll create a graph where nodes are on the same position on the horizontal axis. When the Vertical Force is activated, these nodes may block each other when trying to change position. The Jitter Tolerance basically determines how much nodes are allowed to jump around when they bump into other nodes. By setting an appropriate Jitter Tolerance, you can make it easier for nodes in the same position on the horizontal axis to pass each other. If you set it too high, your graph will go nuts.

The Threads variable sets the number of threads that your processor can use to process the layout (if you have the possibility for multi-threaded processes). This can increase performance for large graphs, although I have never really needed this option myself.

The Center variable tries to keep your graph approximately in the center of the drawspace. In hindsight, I am not sure if this variable is really that useful. I never use it myself.

Download instructions

You can download the Event Graph Layout plugin from Gephi’s plugin menu. The source of the Event Graph Layout was merged into the Gephi Plugins GitHub Repository, in the master-forge branch.

Bi-Dynamic Line Graphs

The idea to use Bi-Dynamic Line Graphs (BDLGs) to study network dynamics was introduced by Chiara Broccatelli, Martin Everett, and Johan Koskinen, in the article Temporal dynamics in covert networks. I think that this idea is very useful, and I wanted to have a more automated way to convert incidence matrices into BDLGs. In addition, I wanted to make it easy to import and visualise these graphs in Gephi, since I already created the Event Graph Layout plugin (see above), which is very suitable for creating layouts for BDLGs.

I thus created a simple tool that converts incidence matrices (imported as csv files) into BDLG matrices, and that also allows one to export the results as edge files and node files that can be imported into Gephi, and that provide everything you need to create a decent layout using the Event Graph Layout plugin. Again, all credits for the idea of BDLGs are for the authors mentioned above. I only wrote this tool.

You can download the program using the following links:

The GitHub repository for the program can be found here.

If you would like to use this software, then please use the following citation:

Spekkink, W. A. H. BLDG Matrix Converter [Computer Software]. DOI: 10.5281/zenodo.1215462.


Multi-dimensional scaling in Gephi

I wrote two plugins for Gephi that introduce the possibility to create layouts using Multi-Dimensional Scaling (MDS) of nodes, based on their path distances. This layout only works well with graphs that form one component, since distances between unconnected nodes are infinite, leading to somewhat awkward results.

MDS metrics

The MDS metrics plugin calculates coordinates for the nodes in a graph based on their path distances, using the Stress Minimization algorithm included in the MDSJ library. The MDSJ library was created by Algorithmics Group of the University of Konstanz (see reference below). The MDSJ library was made available under the Creative Commons License “by-nc-sa” 3.0. The license is available at I had no involvement in creating this library. I simply included it in the MDS metrics plugin to make use of its functionality.

Both plugins discussed below can be downloaded from Gephi’s plugin menu. The source code for the plugins can be found in Gephi’s Github plugin repository.

Basic Instructions

After installing the MDS metrics plugin from the Gephi plugins menu, it will appear in the list of statistics algorithms. Using the plugin will open a dialog where you can:

  1. Select the number of dimensions in which the nodes are allowed to have coordinates (of course, in Gephi you can only actually use two dimensions to create a layout).
  2. Set how edge weights should be treated (whether or not they should be included in the determination of distances, and, if yes, whether they should be interpreted as a degree of closeness, or as a degree of distance). I have to honestly admit that this does not work very well for most graphs.
  3. How the distances should be treated in the calculation of stress values. You can downweight large distances an upweight small ones, or weigh all distances equally. See the reference below for details.

After running the algorithm with the selected settings, a dialog will appear that shows some basic results, the most important one of which is the stress of the MDS configuration (coordinate system) that the plugin converged on. Stress values can be understood to indicate the fit of the resulting configuration with the actual distances that we submitted. We will typically be looking for stress values somewhere below 0.1. Configurations that have stress values above that will not actually reflect the distances between the nodes very well. Of course, this is all a bit arbitrary, and with larger graphs we will usually have to be satisfied with somewhat larger stress values.

The coordinates of the resulting configuration are automatically written to the node list in Gephi’s data laboratory. These coordinates can then be fed into the MDS Layout plugin.


Algorithmics Group. MDSJ: Java Library for Multidimensional Scaling (Version 0.2). Available at University of Konstanz, 2009.

MDS Layout

The MDS Layout plugin is a very simple layout plugin that takes coordinates in two dimensions (e.g., a horizontal dimension and a vertical dimension), and then lays out nodes based on the values of their coordinates in these dimensions. I created the plugin to allow you to create a layout based on coordinates produced by the MDS Metrics plugin, but you can of course also use coordinates that were produced in another way.

Basic instructions

The Dimension 1 and Dimension 2 drop-down menus can be used to select the dimensions of the coordinate system that you want to use for your layout. This assumes that your nodes have coordinate variables (which should be included in the node list of Gephi’s data laboratory). The Network Scale variable can be used to scale the graph, that is, to increase or decrease the overall size of the graph.

Lineage plugin for Gephi

The lineage plugin for Gephi can be used to highlight ancestors and descendants of a single node in a directed network. After downloading the plugin from Gephi’s plugin menu, it will appear in the list of statistics algorithms. When using the plugin, a dialog will appear that requires you to identify a node by typing its id into an entry field (Use the id, not the label!).

The plugin will identify all ancestors and descendants of the selected node (we refer to this node as the origin), as well as the distance of any of these ancestors or descendants from the origin. Several variables are automatically added to the node list in the data laboratory:

  • Lineage: A string variable that indicates for each node whether it is the Origin, an Ancestor, a Descendant or Unrelated. This can be used for easy partition colouring.
  • IsOrigin: A boolean variable that indicates whether a node is the Origin.
  • IsAncestor: A boolean variable that indicates whether a node is an Ancestor of the Origin.
  • DistanceAncestor: An integer variable that indicates the path distance of Ancestor nodes from the Origin node. These distances are always expressed with negative values.
  • IsDescendant: A boolean variable that indicates whether a node is a Descendant of the Origin.
  • DistanceDescendant: An integer variable that indicates the path distance of Descendant nodes from the Origin node. These distances are always expressed with positive values.

The plugin can be downloaded from Gephi’s plugin menu. The source code of the plugin can be found at the Github repository for plugins.

Dynamic Networks

One of my first stand-alone programs. This will be made more or less obsolete with the release of Q-SoPrA, although Q-SoPrA approaches the same problems a bit differently.

Dynamic Networks is intended as a tool to be used alongside Gephi. The tool works with incidence matrices that are saved as csv files. The tool assumes that the columns of the matrix represent events that are put in temporal order. An example is offered below.

  Event1 Event2 Event3 Event4
Actor A 1 0 1 0
Actor B 0 1 0 1
Actor C 1 1 0 0

The tool can be used to convert the incidence matrix into various types of edge lists that can be imported into Gephi. For example, it is possible to take different fragments of the incidence matrix (overlapping or not), and convert this to a dynamic network that can be visualised using Gephi’s dynamic visualisation options.


You can find download links for the binaries here:

See this Github repository for the source code and additional details.

CSV parser for Gephi

I wrote this a while ago, and it will be mostly obsolete as soon as Q-SoPrA is ready. I created this program for personal use, to convert csv-output from event sequence datasets into node and edge files that can be imported into Gephi, and that are more easily parsed by Neo4J csv-import functions.

An appropriate input-file has the following characteristics:

  • It has a header that indicates different types of entities listed in the file. There may be multiple values within a cell, as long as these are separated with an appropriate delimiter. Make sure that this delimiter is different from the one used to separate the columns of the file.
  • The program requires the user to select an input file (csv), as well as the symbol that is used as column delimiter in the file. The user also has the option to select a second delimiter, in case the user has put multiple values in certain columns, and wants to separate these. After importing the file the program can be configured to export a node list and edge list (see basic user instructions included in the Github repository).

The purpose of this program is highly specific, but there may be things in the code that are useful for others.


The download links for the binaries of the csv-parser can be found here:

See this Github Repository for the source code, and for more detailed instructions on how to use the program.

Scripts for R

I wrote several scripts for R, mostly focused on stuff related to directed a-cyclic networks or event graphs. The scripts can be found at this GitHub Repository.