QuickLife is a fast, conventional (non-hashing) algorithm for exploring Life and other 2D outer-totalistic rules. Such rules are defined using "B0...8/S0...8" notation, where the digits after B specify the counts of live neighbors necessary for a cell to be born in the next generation, and the digits after S specify the counts of live neighbors necessary for a cell to survive to the next generation. Here are some example rules:

B3/S23 [Life]
John Conway's rule is by far the best known and most explored CA.

B36/S23 [HighLife]
Very similar to Conway's Life but with an interesting replicator.

B3678/S34678 [Day & Night]
Dead cells in a sea of live cells behave the same as live cells in a sea of dead cells.

B35678/S5678 [Diamoeba]
Creates diamond-shaped blobs with unpredictable behavior.

B2 [Seeds]
Every living cell dies every generation, but most patterns still explode.

B234 [Serviettes or Persian Rug]
A single 2x2 block turns into a set of Persian rugs.

B345/S5 [LongLife]
Oscillators with extremely long periods can occur quite naturally.

Emulating B0 rules

Rules containing B0 are tricky to handle in an unbounded universe because every dead cell becomes alive in the next generation. If the rule doesn't contain S8 then the "background" cells alternate from all-alive to all-dead, creating a nasty strobing effect. To avoid these problems, Golly emulates rules with B0 in the following way:

A rule containing B0 and S8 is converted into an equivalent rule (without B0) by inverting the neighbor counts, then using S(8-x) for the B counts and B(8-x) for the S counts. For example, B0123478/S01234678 (AntiLife) is changed to B3/S23 (Life) via these steps: B0123478/S01234678 -> B56/S5 -> B3/S23.

A rule containing B0 but not S8 is converted into a pair of rules (both without B0): one is used for the even generations and the other for the odd generations. The rule for even generations uses inverted neighbor counts. The rule for odd generations uses S(8-x) for the B counts and B(8-x) for the S counts. For example, B03/S23 becomes B1245678/S0145678 (even) and B56/S58 (odd).

In both cases, the replacement rule(s) generate patterns that are equivalent to the requested rule. However, you need to be careful when editing an emulated pattern in a rule that contains B0 but not S8. If you do a cut or copy then you should only paste into a generation with the same parity.

Von Neumann neighborhood

The above rules use the Moore neighborhood, where each cell has 8 neighbors. In the von Neumann neighborhood each cell has only the 4 orthogonal neighbors. To specify this neighborhood just append "V" to the usual "B.../S..." notation and use neighbor counts ranging from 0 to 4 (counts above 4 are silently ignored). For example, try B13/S012V or B2/S013V.

Note that when viewing patterns at scales 1:8 and 1:16, Golly displays diamond-shaped icons for rules using the von Neumann neighborhood and circular dots for rules using the Moore neighborhood.

Hexagonal neighborhood

QuickLife can emulate a hexagonal neighborhood on a square grid by ignoring the NE and SW corners of the Moore neighborhood so that every cell has 6 neighbors:

       NW N NE         NW  N
       W  C  E   ->   W  C  E
       SW S SE         S  SE

To specify a hexagonal neighborhood just append "H" to the usual "B.../S..." notation and use neighbor counts ranging from 0 to 6 (counts above 6 are silently ignored). Here's an example:

    x = 7, y = 6, rule = B245/S3H
    obo$4bo$2bo$bo2bobo$3bo$5bo!

Editing hexagonal patterns in a square grid can be somewhat confusing, so to help make things a bit easier Golly displays slanted hexagons (in icon mode) at scales 1:8 and 1:16.

Wolfram's elementary rules

QuickLife supports Stephen Wolfram's elementary 1D rules. These rules are specified as "Wn" where n is an even number from 0 to 254. For example:

W22
A single live cell creates a beautiful fractal pattern.

W30
Highly chaotic and an excellent random number generator.

W110
Matthew Cook proved that this rule is capable of universal computation.

The binary representation of a particular number specifies the cell states resulting from each of the 8 possible combinations of a cell and its left and right neighbors, where 1 is a live cell and 0 is a dead cell. Here are the state transitions for W30:

       111  110  101  100  011  010  001  000
        |    |    |    |    |    |    |    |
        0    0    0    1    1    1    1    0  = 30 (2^4 + 2^3 + 2^2 + 2^1)

Note that odd-numbered rules have the same problem as B0 rules, but Golly currently makes no attempt to emulate such rules.