SWTPC 6800 Veba

SWTPC VEBA 1.0 

Cybernetic Evolution Game

SWTPC VEBA 1.0 is an experimental cybernetic evolution game for the SWTPC 6800 computer. It was inspired by an undocumented Hungarian game called Véba, originally written for the Primo home computer. 

This SWTPC version is not a direct conversion, but a new reconstruction and reinterpretation: it was designed through an iterative, AI-assisted development process and adapted to the strengths and limitations of the SWTPC 6800, SWTBUG, 8K RAM, MP-C serial interface, and teleprinter-like terminal display. It also uses a deliberately simplified genetic mechanism: while the original concept suggests a richer system of mating and chromosome recombination, this SWTPC version focuses on a clearer and more robust model of selection, reproduction, and mutation suitable for a small 8K machine.

The game models a small population of nine digital organisms called VEBAs. Each VEBA is a tiny artificial creature with a “chromosome”. Biologically, we may imagine them as little evolving beings. Mathematically, each VEBA is a simple finite-state automaton: it has internal states, reads binary signals, produces binary outputs, and changes its internal state according to its chromosome.

The aim is to observe how these small automata perform against a chosen binary signal sequence, how successful ones reproduce, and how occasional mutations change their chromosomes. The game is both a playable experiment and a small educational model of evolution, selection, mutation, and information processing.

Gameplay

At the beginning, the program asks for four parameters:

SIGNAL SEQUENCE?
REPRODUCTION PERCENT?
CYCLES?
PRINT VEBAS? Y/N

Recommended and accepted values in this SWTPC version:

SIGNAL SEQUENCE:       1 to 6 binary digits, using only 0 and 1
REPRODUCTION PERCENT:  0 to 99
CYCLES:                1 to 10
PRINT VEBAS:           Y or N

If the input is left empty, the program uses its built-in defaults:

SIGNAL SEQUENCE:       111111
REPRODUCTION PERCENT:  30
CYCLES:                5
PRINT VEBAS:           Y

SIGNAL SEQUENCE

The signal sequence is a short binary pattern made of 0 and 1 characters, for example:

111111
010101
001100
10101

In this SWTPC version, the signal sequence acts as the environmental task of the VEBAs. During evaluation, each VEBA reads the sequence step by step and tries to produce matching output bits. If its output agrees with the given sequence, it gains points. Therefore, changing the signal sequence changes the selective environment: an easy pattern such as 111111 rewards VEBAs that tend to output 1, while a pattern such as 010101 favours VEBAs that can alternate their outputs in a more structured way.

A VEBA that produces the correct output at every step receives a score of:

100 PERCENT

REPRODUCTION PERCENT

This parameter controls how often successful VEBAs reproduce. For example:

30

means moderate evolutionary pressure. In the SWTPC version this is implemented in a stable, predictable way: over time, the entered percentage determines how often the best VEBA replaces the weakest one.

When reproduction happens, the game prints something like:

REPRODUCTION
VEBA 3 REPLACES VEBA 4

This means that VEBA 3, currently the best-performing organism, copies its chromosome into VEBA 4, replacing a weaker organism.

CYCLES

This is the number of generations to run. For example:

10

runs ten generations. During each generation, the program evaluates the population, may perform reproduction, and performs mutation every third generation.

PRINT VEBAS? Y/N

If you answer:

Y

the program prints the full VEBA chromosome tables during the run. This is slower but more informative.

If you answer:

N

the program prints a shorter evolutionary report. This is faster and better for longer experiments.

How to Read a VEBA

A VEBA is printed like this:

VEBA 1
*0011
A0B0C
B1B1A
C0C1C
SCORE 83 PERCENT

The line: *0011

is a compact header. It should not be read as four independent columns. It represents two input cases:

input 0      input 1

Each row describes what the VEBA does in one internal state: A, B, or C.

For example:

A0B0C

means:

In state A:
if the input is 0 -> output 0 and go to state B
if the input is 1 -> output 0 and go to state C

So the row is really two rule-pairs:

A  0B  0C

A rule such as:

1A

means:

output 1, then go to state A

A rule such as:

0C

means:

output 0, then go to state C

Thus the VEBA’s chromosome is a compact table of six rules:

A0, A1, B0, B1, C0, C1

There are three possible internal states:

A, B, C

There are two possible inputs:

0, 1

And each rule contains:

one output bit + one next state

This is why the VEBAs look like small biological beings but are actually information-processing automata.

Mutation

Every third generation, one VEBA undergoes mutation. The program prints for example:

MUTATION
VEBA 9 CHROMOSOME CHANGES
B0: 1B -> 0C

This means that, in VEBA 9, the rule for state B with input 0 has changed.

Before mutation:

1B

After mutation:

0C

So that rule now produces a different output and moves to a different internal state.

Technically, the machine-code SWTPC version handles mutation in a simple and transparent way. Each VEBA has six rules:

A0, A1, B0, B1, C0, C1

Each rule is stored internally as a small value representing one of these six possible rule-pairs:

0A, 1A, 0B, 1B, 0C, 1C

When mutation occurs, the program selects one VEBA, one of its six rules, and one new rule value. Then it replaces the old rule with the new one.

This is deliberately a very small, point-like mutation. It does not rewrite the whole chromosome; it changes one rule only. Biologically, it resembles a small mutation in a gene. Mathematically, it is a local change in the transition table of a finite-state automaton.

The mutation may improve the VEBA, damage it, or have no visible effect. Sometimes a changed rule is not used by the current signal sequence, so the VEBA may remain 100 percent even after mutation.

What the Game Models

SWTPC VEBA 1.0 models a very small evolutionary system:

• a population of nine digital organisms,
• chromosomes represented as finite-state automata,
• fitness measured against a binary signal sequence,
• reproduction of successful organisms,
• mutation of chromosomes,
• emergence of 100 percent VEBAs.

It can be seen as a tiny artificial life experiment, a cybernetic toy, a genetic algorithm demonstration, and a retrocomputing homage at the same time.

Running the Program

The program is supplied as a Motorola S-record file:

swtpc_veba_final_c.s19

On an SWTPC 6800 with SWTBUG, load it with:

L

Then send the .s19 file from the terminal.

Start the program with:

J0100

Target platform:

SWTPC 6800
SWTBUG monitor
MP-C serial interface
8K RAM
TeraTerm or similar terminal emulator

Credits

Created by: Gábor Képes (Képes Gábor, Hungary)
AI-assisted development with ChatGPT
Platform: SWTPC 6800, SWTBUG monitor, MP-C serial interface, 8K RAM

License

Released as an experimental retrocomputing and computer-art project under:

Creative Commons Attribution-NonCommercial 4.0 International — CC BY-NC 4.0

You may share and adapt it for non-commercial purposes with proper attribution.