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.

 
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
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 when in icon mode.

 
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 for Moore neighborhoods — 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.

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.

 
MAP rules

The totalistic and non-totalistic rules above are only a small subset of all possible rules for a 2-state Moore neighborhood. The Moore neighborhood has 9 cells which gives 512 (2^9) possible combinations of cells. For each of these combinations you define whether the output cell is dead or alive, giving a string of 512 digits, each being 0 (dead) or 1 (alive).

   0 1 2
   3 4 5  ->  4'
   6 7 8
The first few entries for Conway's Life (B3/S23) in this format are as follows:
   Cell 0 1 2 3 4 5 6 7 8  ->  4'
   0    0 0 0 0 0 0 0 0 0  ->  0
   1    0 0 0 0 0 0 0 0 1  ->  0
   2    0 0 0 0 0 0 0 1 0  ->  0
   3    0 0 0 0 0 0 0 1 1  ->  0
   4    0 0 0 0 0 0 1 0 0  ->  0
   5    0 0 0 0 0 0 1 0 1  ->  0
   6    0 0 0 0 0 0 1 1 0  ->  0
   7    0 0 0 0 0 0 1 1 1  ->  1   B3
   8    0 0 0 0 0 1 0 0 0  ->  0
   9    0 0 0 0 0 1 0 0 1  ->  0
   10   0 0 0 0 0 1 0 1 0  ->  0
   11   0 0 0 0 0 1 0 1 1  ->  1   B3
   ...
   19   0 0 0 0 1 0 0 1 1  ->  1   S2
   ...
   511  1 1 1 1 1 1 1 1 1  ->  0
This creates a string of 512 binary digits:
   00000001000100000001...0
This binary string is then base64 encoded for brevity giving a string of 86 characters:
   ARYXfhZofugWaH7oaIDogBZofuhogOiAaIDogIAAgAAWaH7oaIDogGiA6ICAAIAAaIDogIAAgACAAIAAAAAAAA
By prefixing this string with "MAP" the syntax of the rule becomes:
   rule = MAP<base64_string>
So, Conway's Life (B3/S23) encoded as a MAP rule is:
   rule = MAPARYXfhZofugWaH7oaIDogBZofuhogOiAaIDogIAAgAAWaH7oaIDogGiA6ICAAIAAaIDogIAAgACAAIAAAAAAAA
Given each MAP rule has 512 bits this leads to 2^512 (roughly 1.34x10^154) unique rules. Totalistic rules are a subset of isotropic non-totalistic rules which are a subset of MAP rules.

MAP rules can also be specified for Hexagonal and von Neumann neighborhoods.

Hexagonal neighborhoods have 7 cells (center plus 6 neighbors) which gives 128 (2^7) possible combinations of cells. These encode into 22 base64 characters.

Von Neumann neighborhoods have 5 cells (center plus 4 neighbors) which gives 32 (2^5) possible combinations of cells. These encode into 6 base 64 characters.

 
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 Smax (where max is the number of neighbors in the neighborhood: 8 for Moore, 6 for Hexagonal or 4 for Von Neumann) 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 totalistic rule containing B0 and Smax is converted into an equivalent rule (without B0) by inverting the neighbor counts, then using S(max-x) for the B counts and B(max-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 non-totalistic rule is converted in a similar way. The isotropic letters are inverted and then S(max-x)(letters) is used for B counts and B(max-x)(letters) is used for the S counts. The 4 neighbor letters are swapped using the following table:

   4c -> 4e
   4e -> 4c
   4k -> 4k
   4a -> 4a
   4i -> 4t
   4n -> 4r
   4y -> 4j
   4q -> 4w
   4j -> 4y
   4r -> 4n
   4t -> 4i
   4w -> 4q
   4z -> 4z
A totalistic rule containing B0 but not Smax 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(max-x) for the B counts and B(max-x) for the S counts. For example, B03/S23 becomes B1245678/S0145678 (even) and B56/S58 (odd).

A non-totalistic rule is converted in a similar way. For even generations invert both B(x)(letter) and S(x)(letter). For odd generations except 4-neighbor letters, use B(x)(letter) if and only if the original rule has S(max-x)(letter) and use S(x)(letter) if and only if the original rule has B(max-x)(letter). For 4-neighbor isotropic letters use the table above. For example, B0124-k/S1c25 becomes B34k5678/S01-c34678 (even) and B367c/S4-k678 (odd).

For a MAP rule B0 is equivalent to the first bit being 0. Smax is equivalent to the 511th bit being 1. For B0 with Smax the rule is converted to NOT(REVERSE(bits)). For B0 with Smax the even rule is NOT(bits) and the odd rule is REVERSE(bits).

In all 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 Smax. If you do a cut or copy then you should only paste into a generation with the same parity.

 
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. Golly currently makes no attempt to emulate such rules, and they are not supported.