ArchEvo is an experiment on evolution of digital lifeforms. It is a simulation of a 2D world, where virtual machines must compete for energy and reproduce. The ArchEvo program has had two distinct versions, and parts of it have been written in C++, Java, React/Javascript, and Python.

A cell is a virtual machine that exists in the Universe.

A cell has eight registers, each of which are eight bits wide. The first cell represent the amount of energy the cell has ¹⁾. When a new cell is created, all of the registers are set to 0, except for the energy register.

Technically, the rest of the cells have no intrinsic meaning separate from the context in which they are run (including ISA, combat handler, reproduction handler, etc) , but generally the cells are given these names:

• 0: Energy
• 1: Logo
• 2: Guess
• 3: Register A
• 4: Register B
• 5: Register C
• 6: Register D
• 7: IPLOC

The names of regs 1 and 2 come from the CaptureTheFlag combat handler, and reg 7 is IPLOC in ASIA.

When energy is 0 (it can't underflow), the cell is dead, and will be garbage collected in the next iteration.

A cell has a set of instructions that is called a Program. Each individual instruction is simply a set of bits. The instructions may be of an arbitrary length depending on the ISA. ASIA's instructions are eleven bits long.

When a new cell is introduced randomly into the Universe, all of the bits of the program will be randomized. However, when a cell is created as a child of another cell, the new cell inherits the parent's program, with some mutated bits.

A cell also has an Instruction Pointer (IP) . This is a number that is between 0 and the length of the program. When a cell is created this is initialized to 0.

Each iteration, the instruction that is pointed at by the IP is translated into an action. The possible actions are:

• RegisterUpdate <register> <value>: Changes the value of a register.
• Attack <x_off> <y_off>: Attacks the cell at the given offset.
• DoNothing ²⁾
• Move <x_off> <y_off>: Moves the cell to the offset.
• MoveInstructionPointer <new_instruction_pointer>: Moves the Instruction Pointer (Jumps) to a new location in the program
• Reproduce <x_off> <y_off>: Creates a new cell at the offset.

This action is then executed.

When the reproduce action is triggered, a new baby cell may be created. However, first the ReproductionHandler is. The ReproductionHandler decides three things:

• Can the parent reproduce?
• What energy cost will the parent need to pay to reproduce?
• What will the baby cell's initial energy be?

If the parent cannot reproduce, no change will occur. If the parent can reproduce, then the energy cost is deducted from the parent, and a new cell is created with the proper amount of initial energy. (Click the flowchart on the right to enlarge it)

Attacking other cells is the only way for a cell to gain more energy. The change in energy for both attacker and (if there is one ³⁾) defender are determined by the CombatHandler.

The Universe is a grid that contains Cells. Although it is a finite grid, the edges wrap around to the opposite side, meaning that Cells can travel in one direction infinitely.

Each iteration, some new cells are spawned with randomized programs.

ArchEvo has been implemented twice.

ArchEvo Classic was the first implementation of ArchEvo. It was written in purely C++, and the graphical component was handled by libtcod , a platform for creating roguelikes. It began development in the summer of 2020, as I had a lot of spare time between my graduation from KU and the beginning of my new job at Cerner.

This version demonstrated that my model, along with the ISA I had created (later known as ASIA ) were capable of demonstrating interesting evolutionary properties.

ArchEvo Classic suffered from a number of problems that crippled it's usage as an experimental tool. Firstly, it had poor separation of concerns, which meant that trying out new concepts like new ISAs would end up touching almost all of the parts of the code. Secondly, there were some logical problems. The Universe was rife with race conditions, including the fact that cells with a lower x and y had priority over other cells. Finally, the Universe's state was tied to the GUI, which led to some awkwardness.

Despite these flaws, ArchEvo Classic is one of the projects that I am most proud of. The entire project is almost 3,500 lines of code, making it the largest personal project I had undertaken at the time.

ArchEvo Pangea was the second implementation of ArchEvo, and the only version that is currently being developed. It was written as an attempt to address some of the problems with ArchEvo Classic. ArchEvo Pangea is actually three components:

• Backend simulation logic (java)
• Webserver run the simulation and serve it's state (java/spring)
• Website to display the state of the simulation (javascript/react)

Some diagnostic tools were also written in Python.

The modular design of the simulation backend makes it much easier to test out new ideas than ArchEvo Classic. Additionally, the whole thing is unit tested, meaning that I know that the simulation works how I think it does.

GitHub reports that there are something like 8,000 lines of code in Pangea. It's hard to gauge how much of that is autogenerated, boilerplate, etc. Regardless, it is a very complex project.

As this is an active project, the “results” of the experiment are still up in the air. However, I can report on whether or not my initial hypotheses were correct. The parameters of the initial experiment were:

• ISA: ASIA
• ReproductionHandler: SetCost
• CombatHander: CaptureTheFlag
• Iteration Execution Mode: Instruction By Instruction

My hypotheses were:

• Replicators can emerge in the ArchEvo model.
• Complex food webs will form (ie, species A is adapted to eat species B, etc)
• Logical structures will emerge to prevent cannibalism.

The first hypothesis was confirmed. Within just 10,000 iterations, at least one species of replicators will generally emerge.

The second hypothesis was disproven. In all of the iterations I have seen past about 10,000 iterations, one species gains hegemonic power. When positive mutations occur in this species, the mutation will quickly take over the gene pool.

The third hypothesis was also disproven. I think the reason that this is is due to the processing overhead of making decisions in ASIA. The cell must make an observation, compute a response, and then execute the response. This overhead makes the cell vulnerable to predators.