Back to Artificial Life

Welcome to HELIX!

Download: Helix-1 (helix1.zip) [70k]

(note: Helix-4 is intended as a replacement for Helix-1, so it is recommended that you download it as well).

Helix was my first attempt at creating an artificial life (ALife) experiment. At the time (August 1991), I was fresh out of high-school, enjoying a relaxed summer, when I came across an issue of Science News that had an article about an artificial life program called Tierra, a very interesting program by Thomas Ray. As I was already quite interested in this sort of thing just from my own imagination and curiosity, I was instantly inspired by what I saw.

Right away I began planning my own similar project, one in which self-replicating programs would compete for space in a memory pool (or "soup" as it was called in Tierra). At the time my programming skills weren't fantastic, though I was on the fast track to learning some good techniques (and I even still follow some of the naming conventions I created at the time). I made a few minor adjustments to it here and there, the last of which were after the new year (early '92). To prepare it for release, I recompiled it with the BGI graphics module included inside the EXE file, though I did not bother to fix the bugs (although for some reason the keyboard interface is failing to function properly even though the code appears to be correct, even if sloppy, so I put a "band-aid" fix on that).

Unfortunately, in this particular implementation the programs don't actually self-replicate. That is, they don't copy themselves. They have a single "replicate" instruction that they call to achieve this. The rest of their code are instructions to feed and stave off death. Obviously, because of this the most efficient creature is the shortest creature program, so they all evolve downward towards the minimum length that the system allows.

However, this program was a great learning experience for me, as are all my artificial life experiments. Because they require such large amounts of memory and processing power, they force me to learn new methods of compacting data and performing faster manipulations of the data.

As I've already implied, this is not the only artificial life program I made, but it was the first. At the time I was *VERY* pleased with myself, as it was the first program I made that had such a nice aesthetically pleasing *and* informative graphical display, complete with its own logo. By my own standards it is inefficient, clunky, buggy, and a giant kludge. However, I retain fond memories of it, because it marked the beginning of an intersting time in my life.

Over the next few years I made a few more attempts at ALife. Helix 2 was an attempt to make an eco-system with insects, and it fell flat on its face. I didn't realize at the time how impossible a task it was to make a balanced system with only a half-dozen or so creatures. :-) Interestingly enough, I write this treatise just after completing a new ALife project that does exactly that, maintain a stable system, but with nearly 4000 creatures. This too has it's problems and limitations, and I am still using a few "cheats" to achieve it, but even so the herbivores and the plant-growth combined are self-regulating. But the "Helix" series didn't end with Helix 2. Helix 3 never got completed because the code ended up getting rather convoluted and I found other things to spend my time on. Helix 4, if I remember correctly, was a success, and it more closely matched my original intentions for this program.

But getting back to this program, Helix 1, I must say that unfortunately there is no documentation for it. I tried to write the program well enough that I could distribute it or show it off in one way or another down the road, but I never wrote any instructions for it. I suppose it would be possible to do so, but not practical at this point because I have no notes or anything that I could use to base it off of, short of reverse engineering the program itself. However, you will find just a brief description of how the program works below.

Despite the situation, I have decided to allow this program to be downloaded such that anyone who is interested may get a glimpse into where I've come from. I hope you enjoy it. :-)


- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Helix in a nutshell:

The program starts out by loading an initial organism from a file called BIOINIT.DAT. Each creature program simply tries to make copies of itself. The faster the program executes, the more copies it can make, and therefore the more it will out-compete other strains. When it replicates, it has a chance of making an error, in which case the offspring will get a different color. These offspring may be more or less efficient, and therefore darwinism reigns over which strains survive the best. When the memory pool gets too full, or the population gets too high, the older organisms are killed off (thus they vanish from the screen), and their now vacant spots are usually filled with newborns very quickly.

This process continues ad infinatum until eventually the "ultimate creature" is attained, which if memory serves me is only 4 instructions long.

Welcome to Helix-4!

Download: Helix-4 (helix4b.zip) [57k]

Helix-4 is indeed meant to be a complete replacement for Helix-1. To understand the history behind Helix-4, it is best to first read the text that I wrote for Helix-1 (above).

As with Helix-1, there unfortunately is no documentation for this program, since I never bothered to write any when I created the program since I wasn't distributing it at the time.

However, I can say a few quick things here....

The main window represents the chunk of memory in which the self- replicating programs "live". When they allocate a block of memory to copy themselves into to make a child, that block of memory is shown as dark grey. Once the copy is complete and they turn the child loose, the child gets it's own color. If it was a perfect copy (no mutations) the child gets the color of the parent, otherwise it gets a new color. The colors are rotated on, such that all green organisms either are perfect copies of other greens or are mutant blues. Here's the color cycle:


The program starts out with the auto-updating of the chart data on the left set to "Off", so you have to turn it on to see an update done in real-time. From the menu, you can select all sorts of parameters, and can even enable periodic auto-saves (so if you leave the program running and have a power-out or something sometime later, you only lose 10 minutes or so of time). There is also a "Gene Banker" available on the menu, in which the program saves data about every strain that arises in the simulation. This slows things down a bit and can potentially eat up MASSIVE amounts of diskspace, so use it cautiously. The "LINEAGE" program sorts through all the banked organisms and generates some useful charts based on it, including the lineage tree.

In the organism viewer, you can see the individual programs that are living in your computer. If you have a little knowledge of assembly language, then you can probably determine how they work.

I leave the rest for you to discover...


Back to Artificial Life

= Ed T. Toton III / NecroBones Enterprises / necrobones at necrobones dot com
(Copyright 1998, All Rights Reserved)