XLife updated

[litwr]

Version 6.0 of old XLife is released... It is based on 5.0.8 Debian Linux version and lesser on 5.3 OpenBSD version. It doesn't support all features of v5.3 (see MISSED). However it runs at modern systems (several Linux 32/64-bits distributions were tested) and provides a lot of features (see CHANGES).

It is situated now at

http://litwr2.atspace.eu/xlife.php

or

http://94.143.43.217/LW/xlife.php

These are several pieces of "historical data".

I tried xlife v5.0 at 2000 first time. I was astonished by its speed. However I rapidly understood that it was with many bugs. The absence of comfortable way to load files looked also a bit sad. So I fixed a lot of bugs and added a widget to select a filename to load. It was 2001. I was busy and had limited access to the net these days. I also thought that somebody more experienced will do all fixes and improvements. 10 years have just passed. I see that nobody makes thing that may cover all my work...

Xlife still has some good points:

1) truly Spartan style -- very fast interface;
2) integration with Lloyd's variant of Prisoner's Dilemma mode;
3) fast for 2-states automata;
4) interesting formats for patterns -- #I format is very intellectual and can be used as base for the ideal format (even its present form after compression maybe shorter that compessed RLE for the big files). #I may be combined with #M (RLE).
5) r-format for rules is more compact than table-format with variables or trees
6) structured editing: load scripts, W/D commands

I've made TODO file. Does anybody have suggestions for TODO list?

I can't find patch level 3 for the version 5.3 for OpenBSD. So I'll be a bit happy if somebody will show me a link. I can't also find v3.6 of Xlife.

BTW So I have assigned myself as XLife maintainer. Is it ok?

[litwr]

I've added some new features so XLife 6.1 is released.

I consider my work as digital restoration. It keeps spirit of original code, fixes a lot of bugs, added several improvements (commands, new types of automata, formats, etc).

The novice users may find this program a bit unfriendly but little experience gives friendly speed of interface. Xlife is driven mostly via accelerators keys. Most important ones are l (load), o (one step), g (go), C (clear), +/- (zoom in/out), ? (help), cursor keys, 5 (center on pattern), Q (quit).

An expert from Debian team has helped me to find patch level 3 for the version 5.3 for OpenBSD and version 3.6 of Xlife. It is odd that Conway's Life wikipage still has only links to very old version 3.5 and unsupported Open/FreeBSD releases.

BTW Did anybody try updated Xlife with Apple OS X? Did it work? Sorry I tried it only with several Linux distributions.

http://litwr2.atspace.eu/xlife.php

http://94.143.43.217/LW/xlife.php

[litwr]

Version 6.2 of XLife is released... It is slightly accelerated so it can handle the big patterns now, e.g., `golly-constructor' (Codd rules), Universal Turing Machine, or even `caterpillar'. Lifesrc is removed. Added support for the format signature line (##XLife) in the output files.

Xlife is fastest cellular automata emulator in the step-by-step mode for not very big patterns. See table. Tested patternts are Turing Machine (TM, 36549 cells), Universal TM (UTM, 692633 cells), Golly constructor
(GC, 659459 cells, Codd), Primes (62037 cells, Wireworld), Giles Butterly Gun (GBG, 376 cells, Brian's Brain -- /2/3).

XLife DBLife Golly
6.2 8.3 2.2
-----------------------------------
TM 2240 640 730
UTM 110 80 160
GC 450 n/a 2130
Primes 3640 n/a 2110
GBG 24220 n/a 3100

This table shows number of first generations for 10 seconds of evolution. So bigger number means better speed. 3.2GHz AMD CPU was used for the tests.

Some mystery surrounds XLife project... Could anybody help me with several questions?

1. Why development of XLife was stopped at 1997? Are there any links to its developers interviews or other resources?

2. Why did versions 5.1--5.3 begin new branch and were ignored by many distributors, e.g., all Linux teams? Any info?

3. Why does wikipage
http://en.wikipedia.org/wiki/Conway%27s ... e_programs
contain a link to so old version of this program? Why the maintainer of this page (David Eppstein) forces the unalterability of this link?

4. It is obvious that XLife r-format for rules is better (shorter) than table-format. Why it is not supported by other programs?

So the situation around this program is very odd. It looks like some kind of conspiracy against XLife. The formats for patterns of XLife show the great richness of different features but they are also not supported by Golly, etc. DBlife supports XLife v5.0 format but it missed v5.3 features.

I have a blur plan for the creation of the better interface but it will require several months...

[litwr]

Version 6.4 of XLife is released. It is still with Spartan style Xlib interface and doesn't support hashlife. However it begins to support torus and plain topology, the history for any 2-state automata, pseudocolor modes, ...

The history mode maybe toggled by @ keypress. Will Golly team add this feature to the next release?

[Andrew]

The history mode maybe toggled by @ keypress. Will Golly team add this feature to the next release?

If by history you mean the ability to show all cells that were alive, then Golly already supports this via the LifeHistory rule, or for all other rules you can use envelope.py. Although this script is somewhat slow, it does have the advantage of working with *any* rule/algo, and it also shows the starting pattern.

I don't think there's any conspiracy against xlife -- more likely people simply stopped using it once something better came along.

[litwr]

Thank you! I'm a bit obsessed by Xlife so several interesting features of Golly missed me. I'm curious. May Golly use pseudocolor modes? I've made a demo page (http://litwr2.atspace.eu/demo/demo.html or http://94.143.43.217/LW/demo/demo.html) for Xlife. May Golly cover all listed features?
The conspiracy against XLife is only my joke. However there are several odd things around this project. It was broken without reason, its distribution was splitted (v3.5, v3.6, v5.0, v5.3), the wiki page was destroyed. I plan to create new wikipage for Xlife but I can't find information about the history of its development. IMHO This famous program deserves this page.

[litwr]

I've just performed several experiments. It is surprize that Jon Bennet 1989 code only slightly modified shows the best speed for the exploding and chaotic patterns. All tests use only two adjacent cells (brick) at state 1. XLife shows the speed of the evolution about 100% and 50% faster than Golly for /2/3 (brian's brain) and 345/2/4 (star wars) rules. Xlife is much faster with bounded grids for such kind of patterns. It shows approximately 1200%, 600%, 110%, 1200% of Golly speed for /2/3, 1/1, 8/0, 345/2/4 rules. I've added the picture of one of the speed test to the Xlife demo page.

[Andrew]

I've just performed several experiments. It is surprize that Jon Bennet 1989 code only slightly modified shows the best speed for the exploding and chaotic patterns. All tests use only two adjacent cells (brick) at state 1. XLife shows the speed of the evolution about 100% and 50% faster than Golly for /2/3 (brian's brain) and 345/2/4 (star wars) rules.

This is not really surprising. The Generations algorithm uses hashlife which is notoriously slow with chaotic patterns.

You were wise to choose rules from Generations. If you'd chosen chaotic patterns from a Life-like rule then you would have seen that Golly's QuickLife algorithm is much faster than xlife. I did some timing tests on this pattern:

Code: Select all

# stairstep hexomino in 3-4 Life
x = 4, y = 3, rule = B34/S34
2o$b2o$2b2o!

The results for jumping to gen 10,000 were:

xlife: 72.4 secs
QuickLife: 11.9 secs (HashLife took 429 secs!)

The timings for xlife were done using its Benchmark mode. The timings for Golly were done using this Python script:

Code: Select all

# A script for doing timing tests.
# Author: Andrew Trevorrow, Oct 2011.

from time import time
import golly as g

# set step size to 10^4 (10,000 gens)
g.setbase(10)
g.setstep(4)

g.show("Hit escape to abort...")
startgen = int(g.getgen())
startsecs = time()

g.step()

t = time() - startsecs
gens = float(int(g.getgen()) - startgen)
g.show("Time = %.2f secs (%.2f gens per sec)" % (t, gens/t))

Xlife is much faster with bounded grids for such kind of patterns.

This is also not surprising. All the current algorithms are designed to handle unbounded grids, so the GUI code is doing a lot of ugly work behind the scenes to create the illusion of bounded grids. Hopefully one day somebody will modify Generations to improve the handling of bounded grids, perhaps by merging xlife's code into Golly (hint, hint!).

[litwr]

Thank you very much! IMHO this timing script should be published.

[litwr]

Version 6.5 is released. It supports up to 256 states now. So it is possible to use such a beauty as the snowflakes world by /1/256 rules--it is very impressive with bounded grid--try
/1/256:T1000x800 with one alive cell. Golly is a bit slow for this task. BTW surprizingly Xlife shows the better speed even in some n-state cases like HPP rules (+50%).

Added oscillator detection feature.

Added new pseudocolor mode to show removed cells.

Added support for the pallettes.

The '/' command shows complete cells statistics.

#CXRLE directive is recognized now.

Added many other improvements and fixes.

Xlife dependencies became very limited--they are only glibc and xlib now. Xlife began to use friendly xlib based io widget instead of the optional Tcl/Tk widget or the keybord console input.

Xlife is successfully tested with Microsoft Windows with freely available Cygwin system. It is also tested with many Unix like OS: Linux, FreeBSD, OpenBSD, NetBSD, and Minix.

[litwr]

Xlife 6.7 is just released -- http://freecode.com/projects/xlife.