Last updated: Aug 14, 2012
OpenWorm nervous system 3D rendering
A 3D rendering of the C. elegans nervous system.

OpenWorm is an attempt to build a complete cellular-level simulation of the nematode worm Caenorhabditis elegans. Of the 959 cells in the hermaphrodite, 302 are neurons and 95 are muscle cells. The simulation will model electrical activity in all the muscles and neurons. An integrated soft-body physics simulation will also model body movement and physical forces within the worm and from its environment.

The project started in early 2011 and is being worked on by an international collaboration of scientists and programmers in the US, Europe, and Russia. The effort is being treated as a first step towards simulating larger biological systems including, ultimately, the human brain. Although the worm connectome was mapped in the 1980s, the neural network has never been fully simulated in a biologically realistic way. The philosophy of the project is that only by recreating a living organism can we truly understand it.

Contents    (hide)

Latest news / current status

On March 21, 2012, the OpenWorm browser was announced. This lets everyone explore the worm's cellular anatomy in 3D. Note that this requires a WebGL-enabled browser. The latest versions of Google Chrome, Firefox, and Safari have this by default. It won't work with Internet Explorer.

The simulation framework prototype phase was completed around the end of 2011. The main concepts and technology stack were proven by simulating the parallel firing of 302 Hodgkin-Huxley neurons. Currently in progress is the integration of the physics simulation with the neuronal simulation and to deal with multiple-algorithm synchronization.

Biology of C. elegans

Caenorhabditis elegans, usually abbreviated as C. elegans, is a free-living, transparent nematode (roundworm), about 1 mm in length. It lives in temperate soil environments and feeds on bacteria that develop on decaying vegetable matter. Research into the molecular and developmental biology of C. elegans was begun in 1974 and it has since been used extensively as a model organism.

C. elegans has two sexes: hermaphrodites and males. Individuals are almost all hermaphrodite, with males comprising just 0.05% of the total population. The developmental fate of all somatic cells (959 in the adult hermaphrodite, 1,031 in the adult male) have been mapped out. These patterns of cell lineage are largely invariant between individuals.

C. elegans was the first multicellular organism to have its genome completely sequenced. The entire sequencing was finished by October 2002. The genome has 97 million base pairs. This is about 3% the size of the human genome which has 3 billion base pairs.

Nervous system

C. elegans is one of the simplest organisms with a nervous system. The hermaphrodite has a total of 302 neurons. These can be divided into the the pharyngeal nervous system containing 20 neurons and the somatic nervous system containing 282 neurons. According to a paper published February 2011, the somatic nervous system contains 6,393 chemical synapses, 890 gap junctions, and 1,410 neuromuscular junctions.

The connectome was first mapped in 1986 using electron microscopy. It was shown to be a small-world network. Research has explored the neural mechanisms responsible for several of the more interesting behaviors shown by C. elegans, including chemotaxis, thermotaxis, mechanotransduction, and male mating behavior.

Although the connectome is known, the behaviour of the neurons is not, nor the behaviour of the synapses. This is the subject of much continuing study. It should also be noted that neurons in C. elegans do not display action potentials. That is, the neurons are non-spiking. Instead they transmit information by simple passive propagation of electrotonic potential.

Simulation project

OpenWorm is thought of not simply as a model, but the first artificial life form. The aim is to build a complete, biologically-realistic emulation of the worm, all the way from genes to behaviour.

The motivation behind the project is the idea that only by recreating an organism can it be truly understood. The C. elegans worm was chosen because it is one of the smallest and most-studied animals in biology. If the project is successful, this will set the lower bound of what can be emulated in the future.

The simulation engine is designed to accommodate a variety of complex biological systems and their environment. The worm simulation is only the first such simulation. If it is successful then others could follow.

The first goal is to combine a neuronal model with a physical model. This will take the biophysical realism beyond that which has already been done in previous studies. The physical model will serve as the "read out" to make sure that the neurons are doing appropriate things.

The ultimate goal of the research is to understand how the human brain works. If we can build a true emulation of the worm, with its 302 neurons, this will prove that emulation is possible. This is a prerequisite before more emulations of more complex organisms can be attempted.

See the introductory talk by project coordinator Stephen Larson: Evolving AI: Lt. Data Will Be Born From Artificial Worms

The project is completely open source. All software, data, and documentation is freely available online.

Software stack

A number of different programming languages are used by OpenWorm. The core of the simulation engine, however, is written in Java. The modelling data that is processed by the engine is written in XML.


The first step of the simulation is to prepare the data files that describe the physical shape of all neurons, their positions relative to each other, and their connectivity. These are written in NeuroML (Neuro Markup Language). NeuroML is an XML-based model description language that aims to provide a common data format for defining and exchanging models in computational neuroscience. NeuroML is used to define the worm connectome.

The NeuroML data is sourced from the WormBase database. The WormBase data was originally created in 3D computer graphics software called Blender. So the OpenWorm team have written scripts in Python to convert the data from Blender files to NeuroML.

As the Blender model only describe the location of neurons, not the way they behave and connect, the NeuroML files must be imported into NeuroConstruct. This is software for creating and developing biologically-realistic 3D neural networks. NeuroConstruct is used to define the cell groupings, add the synapses, and set the cell membrane characteristics (ion channels). All neurons are described as multi-compartmental models. The resulting complete model is exported back out in NeuroML format.

Once prepared, the NeuroML data can then be fed into the simulation engine. This, together with the physics simulator, simulates the whole worm.

Simulation engine

The simulation engine, also sometimes called the simulation framework, is the core of the OpenWorm project. It is here that the actual worm simulation happens.

The engine is multi-algorithm (neural simulations, physical simulations) and multi-scale (molecular, cellular, body sections). It is written in Java and uses the OSGi (Open Services Gateway initiative) framework. This framework allows for flexible use of software components that can be remotely installed, started, stopped, updated, and uninstalled without interupting the rest of the simulation.

The two main components are:

  • Neural conductance simulator (Hodgkin-Huxley solver) - written in OpenCL (Open Computing Language) with Java bindings that connect it to the rest of the simulation framework. OpenCL is a language and framework for writing programs that can execute across heterogeneous platforms consisting of CPUs, GPUs, and other processors. Thus the simulation engine can take advantage of parallelism and leverage the higher power of GPUs.
  • PCI-SPH - the algorithm used for soft-body physical simulations. The acronym stands for Predictive-Corrective Incompressible Smoothed-Particle Hydrodynamics. See the Wikipedia article about smoothed-particle hydrodynamics (SPH). The algorithm is written in C++. It simulates the biomechanics of the worm body as it moves across a surface. Generally the worm is held down by capillary forces created by the meniscus of the surface film of water.

Computer hardware

The simulations are carried out on Amazon's cloud computing platform. The mechanical model of the worm requires about 5 teraflops of compute power. The muscle/neuronal conductance model requires about 0.24 teraflops. One Amazon GPU cluster provides about 2 teraflops.

3D model

The web-based 3D model was released in March 2012. View it via your browser here: Note that this requires WebGL (Web Graphics Library), a JavaScript API for rendering interactive 3D graphics. Google Chrome and the newest versions of Firefox and Safari have this, Internet Explorer doesn't.

This model is built on top of the open-3d-viewer software. This was previously known as Google Body but it was dropped by Google and open-sourced in January 2012. The worm browser was made by converting Christian Grove's Virtual Worm modelling files from Blender to WebGL. Blender is a free open-source 3D content creation suite.

Note that the worm browser is only a 3D model, not a simulation. The model doesn't do anything besides provide a visualisation of the worm anatomy. It doesn't visualise neural activity or worm movement.


The OpenWorm project is worked on by volunteers in their spare time. It currently receives no government or industry funding. Donations are accepted via the website. It is possible that some kind of crowd funding, e.g. Kickstarter, will be pursued in the future.

People involved

The OpenWorm project is an international collaboration between scientists and programmers in the US, Europe, and Russia:

Alexander Dibert   Google profile Homepage
  Andrey Palyanov   Google profile Linkedin profile
  Christian Grove   Linkedin profile
David Dalrymple   Google profile Linkedin profile
  Dmitar Shterionov   Google profile Linkedin profile Homepage
  Giovanni Idili   Google profile Linkedin profile
Jay Coggan   Google profile Linkedin profile Homepage
  Marius Buibas   Google profile Linkedin profile
  Matteo Cantarelli   Google profile Linkedin profile
Padraig Gleeson   Google profile Homepage
  Sergey Khayrulin   Google profile Linkedin profile
  Stephen Larson   Google profile Linkedin profile Twitter profile Homepage
Project coordinator 
Timothy Busbice   Google profile Linkedin profile

Other similar projects (past and present)

David Dalrymple at Harvard/MIT (2011 - ongoing)

David Dalrymple is a PhD student at Harvard using optogenetics to determine the function, behaviour, and biophysics of each individual worm neuron with the goal of building a complete simulation of the nervous system. In a November 2011 lecture video he estimated the full analysis and emulation should take three to four years to develop. The goal is then to move on to more complicated organisms. The next step might be the five-day old zebrafish lavae with their ~100,000 neurons. Then the honey bee (960,000 neurons), then mouse (50 million neurons), and ultimately humans (~85 billion neurons). He expects a full cellular level emulation of the human brain within his lifetime. He was born 1991, so by ~2070.

There is limited written material available, but the lecture video linked above is good. His research home page: David Dalrymple at And here's a paper by others at the Samuel Lab at Harvard where he's working. David's research is personally funded by Larry Page, CEO of Google.

David hopes to succeed where others have failed because:

  • he's experimentally studying how the neurons work, rather than just using the connectome
  • he says previous attempts used the connectome without understanding the neurons
  • this was like trying to reverse engineer a radio when all you have is a schematic
  • that shows the wiring diagram without any info on the components that the wires connect
  • we also now have the technology for optogentics
  • so we can read-write to any point in the nervous system in a living organism
  • this can also be done using a high-throughput, automated system

Mailler at Tulsa, US (2010) - A Biologically Accurate 3D Model of the Locomotion of Caenorhabditis Elegans

Jordan Boyle at University of Leeds, UK (2009) - C. elegans locomotion: an integrated approach

Virtual C. Elegans project at Hiroshima University, Japan (~2004)

The aim was to build a worm emulation, simulate poking it on the head, and have it back away from the poke. This was achieved, but not in a biologically realistic way. They simulated the nematode neurons, but the connection weights were unknown. Instead of getting this information experimentally, a machine learning algorithm was used to generate weights. Papers:

Perfect C. elegans Project in Tokyo (~1998) - They released an initial report, but no more.

NemaSys at University of Oregon (~1997) - A full model was planned, including body, every neuron, every synapse, and complete set of sensory modalities. No paper was ever published. Webpage: NemaSys