redredred

Evolve The Future is a “proof of concept” evolution simulator inspired by Thomas Ray’s Tierra application, which he always promised would be a networked environment for digital wildlife. I haven’t created that, but hopefully this is a step in that direction. Little animals run around, reproduce and eat each other. Each animal is written in a custom assembly-code language running on a number of virtual machines. and all of this is written in Javascript.

I wrote this application a couple of years ago, and kind of forgot about it. But now I have dusted it off, ported it to the Google App Engine and updated it a little bit here and there. I am continuing to work on it, new features (like the ability to look around) will be added soon.

Because javascript isn’t really fast enough (yet) to get enough generations through for evolution to be a useful force before my attention span wanes, this is possibly more of an environment to test your skills in writing in assembly code, and competing against the rest of the assembly-code writing world for the title of … (I’ll think of something   ).

The instruction set is not documented yet, and the animals structure is not documented yet (but both of these soon will be.

Each animal (process) has the following properties

• Memory: This is both readable and writable memory addresses starting from address 0 for each animal.
• Threads: Each animal can have multiple threads that communicate via it’s memory.
• CpuTime: Each animal is granted cputime by it’s parent when it is born, and after that is given cputime by the environment (like sunshine) each cycle.
• Position: Each animal has a current (xy) position in the grid
• Direction: Each animal is pointing in a certain direction (this is not currently shown in the display.

Each thread in each animal has the following properties:

• Stack: this is essentially current memory. Operations can put information on the stack, manipulate the top item on the stack, or pop information off the stack.
• Execution Pointer: Each thread is executing the same program, but potentially at a different address (different function) in memory.
• Read Pointer and Write Pointer: These are used for copying operations.
• Memory Pointer: This is used for writing operands only.
• Speed: An animal can choose to operate faster, multiple operations per second. This is expensive for the animal.
• SleepCycles: The thread can sleep for a set number of cycles. It will be woken when this counter reaches 0.

There have so far been two Ancestors created:

1. A simple non-mobile vegetable. This has a single thread that is devoted to reproduction.
   Once all 8 slots around the animal are full, it sleeps for a period and then checks again.
2. A simple mobile vegetable (is this a vegetable??). This has two threads: one is devoted to reproduction, the other moves in a straight line forever.
   When it reproduces, it turns right.

Animals reproduce by allocating memory at the end of their memory, then copying code into the new memory, and then dividing the new memory. This creates a new process.
The copying process has a 1 in 1000 random chance of failing to accurately copy the data requested. This results in the child not always being the same as the parent, and the chance for evolution is created.
Successful species (when a species has had enough animals with the same code, occurs at powers of 10) are sent to the server.
When the application starts it requests the 10 best animals from the server.
Things you can do:

• Click on an individual to see information about it on the “Process Details” tab
• View code of species on server to see what has evolved from the “Progenitors”
• Insert new species into the environment
• Examine the code of any running animal
• Send me patches!!