Research Area "Neurocybernetics"

Research topics

Doctorate Programme
Institute of Cognitive Science
University of Osnabrück

Home - Downloads - Media - Contact - Links


Neurodynamics and Evolutionary Robotics Development Kit

The new official project page of the NERD Toolkit with a download section and tutorials can be found here!


The Neurodynamics and Evolutionary Robotics Development Kit (NERD) is developed as part of the ALEAR project. NERD aims to become a versatile evolutionary robotics environment that is easy to use for different types of robots and neuro-controllers. Including this goal, an easily usable mechanism of defining own motors and sensors is planned. The built-in robot simulator is based on a physical abstraction layer that allows the exchange of the underlying physics engine with little effort (e.g. ODE, IBDS). This offers the possibility of trying new physics engines.




To achieve a high degree of modularity and extendability, NERD uses several mechanisms in addition to common object oriented programming techniques, that proved their usability and their potential to reduce the implementation effort for applications with rapidly changing requirements. These mechanisms facilitate not only the usage of the library in a wide variety of applications, but also provide a simple way to extend existing applications with user specific plug-ins. In the next release users will for instance be able to extend the simulators with own motor models, agents and embedded controllers.
There are two main mechanisms used to enhance modularity and to decouple functional modules from each other: an event processor and a variable repository.

Event Processor

NERD uses an event system for the interaction of functional modules. This system provides a run-time interface for modules, using the classical observer pattern. Modules can create events at a globally available manager instance and trigger these events to signal the occurrence of relevant events, e.g. the start or finalization of a simulation phase or the detection of a collision in the simulator. Other modules interested in such an event can register at the global instance to be notified at its occurrence. In difference to the signal-slot mechanism provided by Qt, NERD events do not require a module to know the owner of an event at compile time. Instead NERD events are identified by simple strings and resolved at run-time. Therefore it is easy to exchange both, owners and event subscribers, with minimal changes at the application. Furthermore highly portable plug-ins and modules can be implemented that allow users to select the required events manually at run-time and therefore can be used in many different contexts.

Blackboard Architecture with a Global Variable Repository (GVR)

Modules in the library can exchange information using a global variable repository. This repository provides access to variables identified by path names, similar to directory names in an operating system. Any module can publish variables in this value repository, and read variables published by other modules. To access a variable a module requires to know the name of the variable, not the owner of the parameter. Therefore modules can easily be exchanged - as previously described for event processing - as long as the replacement of a module provides the same set of variables at the variable repository.

(1) Three components add variables to the global variable repository. (2) Components connect to local variables of other components using the global names of these variables via the global variable repository. (3) Even if components are exchanged with very different other components (A,B replaced by D,E), all dependent components (C) can still work properly, as long as the required variables are available in the global variable repository.

Variables in the repository support a notification mechanism. In case a variable is changed, all modules registered for notification are informed about the change.
All variables encapsulate a specific data type (e.g. bool, int, double, string, color, vector3d) and provide corresponding methods to read and write the variable. Variables in the repository additionally provide a set of methods to read and write the variable by using simple strings. Thus each variable comes with a build-in string parser and string composer, to handle the strings to match the specific encapsulated type. So all variables in the repository can easily be stored to files, displayed in user interfaces, modified with simple text fields or loaded from files, independently of their encapsulated type.
The string interface of variables enables the implementation of general user interfaces allowing the observation and modification of all repository variables in a uniform way. New modules therefore automatically get a simple configuration tool to adjust all of their parameters, if these parameters are published in the repository. The implementation of such a configuration panel then becomes optional.


The NERD simulator is an extensible simulation framework used to simulate arbitrary rigid-body experiments with any number of robots. The underlying physics engine can be replaced so that, in principle, also uncommon experiment become possible, such as with airodynamics or under-water engines (not implemented yet). Simulation environments in an NERD simulator can be defined with simple XML, so that experiments can be set up without programming knowledge. New motor and sensor models can be added via C++ plug-in to adapt a simulation to a physical robot, so that the transfer of evolved neuro-controllers becomes more successful.

Physical Abstraction Layer

NERD currently uses the Open Dynamics Engine (ODE) as primary physics library to simulate the rigid body dynamics. However it was designed to work with a large number of physics engines, such es the promising Impulse-based dynamic simulation engine (IBDS). NERD uses an abstraction layer to describe, configure and manipulate physical objects. Because the physics library is hidden behind this abstraction layer, it can be exchanged with little effort. Other modules, depending only on the physical abstraction layer, remain unaffected by such a change. This enables the NERD library to make use of new upcoming physics simulation technologies and to pursue very different strategies to accurately model motors and sensors of the robots.
Object collisions in the simulation are resolved within the native physics or collision detection library, thus behind the physics abstraction layer. After each simulation step collision information is projected to a physics independent format and can be used by any module without dependencies to a specific physics or collision library.

Neural Network Library

NERD features an extensible neural network library to simulate artificial recurrent neural networks to control agents in the simulations. The default network model is a time-discrete neuron model, that allows the selection of different transfer functions, activation functions and synapse functions for each neuron and synapse. Synapse functions can be used to implement local learning rules or higher order synapses as a simple extension of the model. The network model can be extended or replaced with custom network models, such as radial basis function networks or time-continuous neurons.


In addition the NERD library provides a rich neural network editor to construct neural networks with graphical interaction, to analyze neurons while controlling an agent, or to prepare networks as initial seed for evolutions. Analysis of networks is supported by different kinds of plotters, tools to perform pruning experiments in active networks, visualization of activations of the network, and more.

Evolution Library

NERD provides a set of libraries to use evolutionary algorithms to design suitable controller networks for simulated agents. The graphical user interface is designed to work with any evolutionary algorithm, as long as the implementation of the algorithm follows some simple conventions. This allows users to extend the applications by custom algorithms without the need to implement a user interface for them. Also independent of the algorithms, a set of statistics and logger components simplifiy the observation, intervention and analysis of evolution experiments.


Currently the NERD library supports the following evolution algorithms for neural structure evolution:
  • ENS3 (Evolution of Neural Systems by Stochastic Synthesis)
  • NEAT (Neuro-Evoluton by Augmenting Topologies)
  • INCONE (Interactively Oonstrained Neuro-Evolution)
Fitness functions can be implemented either as C++ plug-in or scripted in a language similar to JavaScript. With both methods the fitness function has access to all variables of the global variable repository and to all event. Therefore it can use all available information about any object, agent or neural network to define the fitness criteria of an experiment.


Christian Rempis

Prof. Frank Pasemann

Institute of Cognitive Science
Universität Osnabrück
Albrechtstrasse 28, D-49076 Osnabrück
Tel.: +49-541 969 3364