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/S [Seeds]
Every living cell dies every generation, but most patterns still explode.

B234/S [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. For example, try B13/S012V or B2/S013V.

Note that when viewing patterns at scales 1:8 or 1:16 or 1:32, 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. Here's an example:
x = 7, y = 6, rule = B245/S3H
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 or 1:16 or 1:32.

Non-totalistic rules

All of the above rules are classified as "totalistic" because the outcome depends only on the total number of neighbors. Golly also supports non-totalistic rules — such rules depend on the configuration of the neighbors, not just their counts.

The syntax used to specify a non-totalistic rule is based on a notation developed by Alan Hensel. It's very similar to the above "B.../S..." notation but uses various lowercase letters to represent unique neighborhoods. One or more of these letters can appear after an appropriate digit (which must be from 1 to 7, depending on the letters). The usual counts of 0 and 8 can still be used without letters since there is no way to constrain 0 or 8 neighbors. B0 is not allowed.

For example, B3/2a34 means birth on 3 neighbors and survival on 2 adjacent neighbors (a corner and an edge), or 3 or 4 neighbors.

Letter strings can get quite long, so it's possible to specify their inverse using a "-" between the digit and the letters. For example, B2cekin/S12 is equivalent to B2-a/S12 and means birth on 2 non-adjacent neighbors, and survival on 1 or 2 neighbors. (This is David Bell's "Just Friends" rule.)

The following table shows which letters correspond to which neighborhoods. The central cell in each neighborhood is colored red, corner neighbors are green, edge neighbors are yellow and ignored neighbors are black:

The table makes it clear which digits are allowed before which letters. For example, B1a/S and B5z/S are both invalid rules.

Golly uses the following steps to convert a given non-totalistic rule into its canonical version:

  1. An underscore can be used instead of a slash, but the canonical version always uses a slash.
  2. The lowercase letters are listed in alphabetical order. For example, B2nic/S will become B2cin/S.
  3. A given rule is converted to its shortest equivalent version. For example, B2ceikn/S will become B2-a/S. If equivalent rules have the same length then the version without the minus sign is preferred. For example, B4-qjrtwz/S will become B4aceikny/S.
  4. It's possible for a non-totalistic rule to be converted to a totalistic rule. If you supply all the letters for a specific neighbor count then the canonical version removes the letters. For example, B2aceikn3/S will become B23/S. (Note that B2-3/S is equivalent to B2aceikn3/S so will also become B23/S.)
  5. If you supply a minus sign and all the letters for a specific neighbor count then the letters and the neighbor count are removed. For example, B2-aceikn3/S will become B3/S.

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:

A single live cell creates a beautiful fractal pattern.

Highly chaotic and an excellent random number generator.

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.