Supported CA Families
The following CA families are supported by MCell for Web:
Family of rules | Type |
1-D totalistic | 1D, totalistic or outer totalistic with decay |
1-D binary | 1D, binary, with optional decay |
Cyclic CA | 2D, cyclic totalistic |
General binary | 2D, binary, in Moore and von Neumann neighborhood, with optional decay |
Generations | 2D, outer totalistic with decay |
Larger than Life | 2D, totalistic or outer totalistic with or without decay, in extended neighborhood |
Life | 2D, outer totalistic |
Margolus | 2D, binary, in Margolus neighborhood |
Neumann binary | 2D, binary, in von Neumann neighborhood |
Rules tables | 2D, totalistic or outer totalistic rules table |
Vote for Life | 2D, totalistic |
Weighted Generations | 2D, totalistic or outer totalistic parameterization with optional decay |
Weighted Life | 2D, totalistic or outer totalistic parameterization with optional decay |
1-D totalistic
Type: totalistic or outer totalistic with optional decay
This family allows exploring a wide range of one-dimensional totalistic Cellular Automata. The initial configuration is displayed in the top line. Each successive line reading down the screen is calculated from the line immediately above it, so Rudy Rucker's comments on CelLab apply also to MCell: "Unlike in many other programs, one-dimensional Cellular Automata implemented in MCell grow downward. If this bothers you a lot, you can turn your monitor over, although you shouldn't leave it that way for too long as it might overheat."
The syntax of the family definition allows specifying rules for calculating next rows of cells. The neighborhood can be specified in a range 1-10, allowing up to 21 cells to be considered. One can specify independently the totals of alive neighbors for cells to survive and to be born, in a similar to "Life" S/B manner. It's also possible to specify if the center cell should be taken into account or ignored.
The unique feature of MCell's implementation of one-dimensional totalistic CA is History. Like in "Generations" family, when history in on, cells that would simply die are getting older, up to the maximum specified state. Such cells cannot give birth to new cells, but they occupy the space of the lattice, thus changing the rules radically.
The lattice can be treated as a ring. When board wrapping is on, active cells that leave at the right edge enter again on the left edge and vice versa.
One-dimensional totalistic CA notation
The notation of one-dimensional totalistic CA rules has the R,C,M,S,B form, where:
- R - specifies the range 1..10
- C - specifies the count of states, 0..256. A value smaller than 3 means the history is not active. Values greater than 2 activate the history, with the given count of states.
- M - specifies activity of the center (middle) cell. 1 is on, 0 is off.
- S - specifies a single total of neighbors allowing the cell to survive. 'S' can appear any times in the rule. Example: S2,S3,S8.
- B - specifies a single total of neighbors allowing the cell to be born. 'B' can appear any times in the rule. Example: B0,B3,B4,B17
Note that randomizing the board fills only the top row of one-dimensional universe. All patterns are loaded at the top of the lattice, too. One can use all drawing tools available in the program, but only cells in the active row are taken into account. At the beginning the active row is the top row. After animating the rule the active top moves down.
Examples of 1-D totalistic rules:
- Champagne: R3,C0,M1,S3,S6,S7,B0,B1
- Pascal's Triangle: R1,C0,M1,B1
MCell is able to run all rules from this family.
1-D binary
Type: 1-D binary with optional decay
This family allows exploring a very wide range of popular one-dimensional binary Cellular Automata. Most of included rules come from an excellent collection of Martin Schaller. You should also check Martin's 1-D binary rules browser.
The unique feature of MCell's implementation of one-dimensional binary CA is History. Like in "Generations" family, when history in on, cells that would otherwise die are rather getting older, up to the maximum specified state. Such cells cannot give birth to new cells, but they occupy the space of the lattice, thus changing the rules radically.
The syntax of the family definition allows specifying rules for calculating next rows of cells. The neighborhood can be defined in a range 1-4, allowing up to 9 cells to be considered. Rules specify the state of new cells for each possible configuration of existing cells found in the defined neighborhood.
The lattice can be treated as a ring. When board wrapping is on, active cells that leave at the right edge enter again on the left edge and vice versa. Note that randomizing the board fills only the top row of one-dimensional universe. All patterns are loaded at the top of the lattice, too. One can use all drawing tools available in the program, but only cells in the active row are taken into account. At the beginning the active row is the top row. After animating the rule the active top moves down.
One-dimensional binary CA notation
The notation of one-dimensional totalistic CA rules has the R,W,H form,
where:
- R specifies the range (1..4) of the neighborhood.
- W specifies the Wolfram's code of the rule, expressed as a hexadecimal value. Wolfram's code is a compact way of specifying the complete 1-D binary rules table.
- H specifies the count of states, 0..25. Parameter 'H' is optional. No parameter or a value smaller than 3 means the history is not active. Values greater than 2 activate the history, with the given count of states.
Sample rule in R1 neighborhood (3 cells: left, center, and right):
111 | 110 | 101 | 100 | 011 | 010 | 001 | 000 | <= all configurations |
0 | 1 | 1 | 0 | 1 | 1 | 1 | 0 | <= the rule |
The rule can be expressed as a binary number 01101110, what is 6E in hexadecimal notation. Finally the rule in MCell's notation has the form "R1,W6E"
Examples of 1-D binary rules:
- Kites: R2,WBF8A5CD8
- Solitons A: R2,WBF8A18C8
MCell is able to run all rules from this family.
Cyclic CA
Type: cyclic totalistic
Cyclic Cellular Automata (CCA) exhibit complex self-organization by iteration of an extremely simple update rule. A specified # of Colors are arranged cyclically in a "color wheel." Each color can only advance to the next, the last cycling to 0. Each update a cell's color advances by 1 if there are at least Threshold cells of the next color within its neighbour set of size Range in extended Moore or von Neumann neighbourhood. These simple dynamics exhibit complex self-organization starting from randomness. This class of CAs was discovered and explored by David Griffeath (http://psoup.math.wisc.edu/kitchen.html).
The MCell's implementation of CCA features also a special case of CCA - the Greenberg-Hastings (GH) Model, perhaps the simplest CA prototype for an excitable medium. A prescribed number of colors N are arranged cyclically in a "color wheel." Each color can only advance to the next, the last cycling to 0. Every update, cells change from color 0 (resting) to 1 (excited) if they have at least Threshold 1's in their neighbor set. All other colors (refractory) advance automatically. Starting from a uniform random soup of the available colors, the excitation dies out if the threshold is too large compared to the size of the neighbor set, while a disordered soup virtually indistinguishable from noise results if the threshold is too low. For intermediate thresholds, however, waves of excitation self-organize into large-scale spiral pairs that stabilize in a locally periodic state.
Cyclic CA rules notation
The notation of Cyclic Cellular Automata has the R/T/C/N form, where:
- R - specifies the neighbourhood range (1..10).
- T - specifies the threshold - minimal count of cells in the neighbourhood having the next color, necessary for the cell to advance to the next state.
- C - specifies the count of states in the rule (0..C-1).
- N - specifies the neighbourhood type: NM stands for extended Moore, NN for extended von Neumann.
In general Cyclic CA rules should be started from uniformly randomized boards.
Examples of Cyclic CA rules:
- 3-color bootstrap: R2/T11/C3/NM
- Stripes: R3/T4/C5/NN
MCell is able to run all rules from this family.
General binary
Type: 2D, binary, in Moore and von Neumann neighborhood, with optional decay
General binary family allows defining a wide range of rules in both Moore and von Neumann neighborhood. In contrast to totalistic CA, General binary rules distinguish not only the count of neighboring cells, but also their location, thus allowing for defining anisotropic (configuration-specific) rules.
General binary rules notation
The notation of General binary rules has the C/N/S/B form, where:
- C - specifies the count of states in the rule (0..C-1).
- N - specifies the neighborhood type: NM stands for Moore, NN for von Neumann.
- S - specifies the compressed string defining the configurations where a cell survives.
- B - specifies the compressed string defining the configurations where a cell is born.
Strings defining S and B parts specify the 0/1 state for every possible configuration. For enumerating all possible neighborhood configurations the "N,NE,E,SE,S,SW,W,NW" order is used. For example S010000...0 means "Survival on an alive N neighbor", B1100...0 means "Birth on no neighbors or on a single N neighbor". To make the S/B strings shorter a simple compression is used. 0s are represented as "a", 1s as "b". 3 and more occurrences of the same character are shortened by specifying the count of occurrences and a character.
Example
"Fallski" rule is defined as follows: "C48,NM,Sb255a,Babb189ab63a".
It has 48 states (0..37) and uses the Moore neighborhood. "Sb255a"
means 1 and 255 0s (survival only on no alive neighbors).
"Babb189ab63a" means 0,1,1, 189 0s, 1, 63 0s (birth on a single N
or NE neighbor, or on W and NW neighbors).
Note!
All rules from Life, Generations,
Vote, and Weighted
Life families can be also represented as General binary rules.
Examples of General binary rules:
- Banks: C0,NN,S3babbabbabba3b,B7ab3aba3b
- Springski: C78,NM,S256a,B8ab23ab223a
MCell is able to run all rules from this family.
Generations
Type: outer totalistic with decay
"Generations" is perhaps the most beautiful family in MCell. Its rules produce delightful colorful patterns. My favorite ones are "Brian's Brain" by Brian Silverman and my own "Star Wars".
The "Generations" family rules are very close to those from Life, with one addition: the cells' history. Cells that would simply die in "Life" are only getting older in "Generations". They cannot give birth to new cells, but they occupy the space of the lattice, thus changing the rules radically.
Generations rules notation
The notation of rules in "Generations" is simple. To S/B part of Life additional /C is added, where C means the count of states cells can have (including 0 state).
Examples of Generations rules:
- Brian's Brain: /2/3
- StarWars: 345/2/4
MCell is able to run all rules from this family.
Larger than Life
Type: totalistic or outer totalistic with or without decay, in extended neighborhood
This family extends Conway's Game of Life to larger neighborhoods given by Range and one of two available neighborhoods. A birth occurs at x if the population within its neighborhood (x included or not) lies in the interval [BMin, BMax]. Site x stays occupied if the count is in [SMin, SMax]. Thus Conway's Game is range 1 Box with values [3,3], [3,4], respectively. Additionally the history known from the Generations family can be defined.
Larger than Life rules notation
The notation of Larger than Life rules has the R,C,M,S,B,N form, where:
- R - specifies the range (1..10)
- C - specifies the count of states, 0..25. A value smaller than 3 means the history is not active. Values greater than 2 activate the history, with the given count of states.
- M - specifies activity of the center (middle) cell. 1 is on, 0 is off.
- S - specifies a range of firing neighbors necessary for the cell to survive. Example: S2..15.
- B - specifies a range of firing neighbors necessary for the cell to be born. Example: B7..11.
- N - specifies the neighborhood type: NM stands for extended Moore (box), NN for extended von Neumann.
Examples of Larger than Life rules:
- Bugs: R5,C0,M1,S34..58,B34..45,NM
- Gnarl: R1,C0,M1,S1..1,B1..1,NN
MCell is able to run all rules from this family.
Life
Type: outer totalistic, 1 bit
"Life" rules family allows to play the widest-known Cellular Automata, including the mythical Conway's Life.
MCell contains many built-in "Life" rules. A big number of them come from an
excellent 32-bit Windows Life program - Life32 by Johan Bontes. They were collected and
described by Alan Hensel, an author of the fastest Java applet running Conway's Life
patterns.
Note that the count of colors (states) has no influence on next generations, because Life
is a one-bit family of rules.
Life rules notation
Life rules are defined in the "S/B" form, where:
- S - defines counts of alive neighbors necessary for a cell to survive,
- B - defines counts of alive neighbors necessary for a cell to be born.
Note that some resources define Life rules with the 'S' and 'B' prefixes. In this case the order of the two sections is interchangeable: "23/3" == "S23/B3" == "B3/S23".
Examples of Life rules:
- Conway's Life: 23/3
- Maze: 12345/3
MCell is able to run all rules from this family.
Margolus
Type: 2D, binary, in Margolus neighborhood
"Margolus neighborhood" CA family uses the simplest partitioning scheme where the lattice is divided in isolated blocks of size 2x2. Each block moves down and to the right with the next generation, and then moves back:
![]() |
![]() |
![]() |
cycle 1 | cycle 2 | cycle 3 |
Margolus neighborhood rules define transitions applied to cells found in 2x2 blocks. This simple partitioning scheme turned out to be very useful for modeling physical systems. Another important property of Margolus neighborhood is that it allows for a very easy creation of reversible rules.
Margolus CA notation
The notation of Margolus automata has the Mx,Dn1;n2;n3;..;n16 form, where:
- Mx - subtype specification. Currently only one subtype is supported - "MS" (Simple, 1bit).
- D - specifies transitions of all possible neighborhood configurations. There
exist 16 different 1-bit Margolus neighborhood configurations, numbered from 0
to 15:
0:
, 1:
, 2:
, 3:
, 4:
, 5:
, 6:
, 7:
, 8:
, 9:
, 10:
, 11:
, 12:
, 13:
, 14:
, 15:
The "D" keyword accepts 16 values, separated with semicolons, that describe into which neighborhood (ngh) the given neighborhood should be changed.
Example:
Billiard Ball Machine is defined as follows: MS,D0;8;4;3;2;5;9;7;1;6;10;11;12;13;14;15
ngh 0 remains unchanged,
ngh 1 turns to 8 - the ball travels diagonally,
ngh 2 turns to 4,
ngh 3 remains unchanged,
ngh 4 turns to 2,
...
ngh 15 remains unchanged.
Examples of Margolus rules:
- BBM: MS,D0;8;4;3;2;5;9;7;1;6;10;11;12;13;14;15
- Rotations: MS,D0;2;8;12;1;10;9;11;4;6;5;14;3;7;13;15
MCell is able to run all rules from this family.
Neumann binary
Type: binary, 2 bit, in von Neumann neighborhood
Neumann binary family of rules allows defining binary (configuration-specific) rules in Neumann neighborhood. MCell's implementation allows defining rules with up to 4 states of cells.
Neumann binary rules notation
Neumann binary rules are represented as a string of digits. The first digit specifies the count of states: 2, 3, or 4; the rest of digits define the transition table - the state a cell will have in every possible configuration. For enumerating all possible neighborhood configurations the "ME,N,E,S,W" order is used.
Example:
Fredkin2 rule has the following definition: 201101001100101101001011001101001
The first digit, '2', tells the rule has 2 states (it's a 1 bit rule).
The second digit, '0', tells a cell in a configuration ME=0,N=0,E=0,S=0,W=0 will
get the state 0.
The third digit, '1', tells a cell in a configuration ME=0,N=0,E=0,S=0,W=1 will
get the state 1.
The fourth digit, '1', tells a cell in a configuration ME=0,N=0,E=0,S=1,W=0 will
get the state 1.
The fifth digit, '0', tells a cell in a configuration ME=0,N=0,E=0,S=1,W=1 will
get the state 0.
. . .
Note!
Neumann totalistic rules are much easier to define in "Weighted
Life" family.
Examples of Neumann binary rules:
- Crystal2: 201101101101101101111101011001000
- Pond: 3010112020112112222020222020112112222112102220222220202020222020222220202020202020110102020102010202020202020102010202010112020202020200020202020202020200020200000020220000220222020000020000220222020222222222020222020000020000020222020000020000
MCell is able to run all rules from this family.
Rules tables
Type: totalistic or outer totalistic rules table
"Rules tables" family allows defining totalistic rules by creating the transitions tables. Rules tables remove all limits from totalistic rules, allowing defining any rules, where states of cells can advance, but can also jump, both forward and back.
The idea of the rules table is very simple. The table describes what new state should get the cell in state S, providing it has N firing neighbors.
Rules table notation
The notation of Rules table has the N,M,F,S form, where:
- N - specifies the neighborhood type: 1 stands for Moore, 2 for von Neumann neighborhood.
- M - specifies activity of the center (middle) cell. 1 is on, 0 is off.
- F - specifies if the full 1st bitplane (all odd states) is considered to be firing (can give birth). This flag was introduced in order to provide compatibility with CelLab by Rudy Rucker and John Walker.
- S - specifies the whole table, row by row, as one string. Trailing 0s can be removed.
Examples:
The Conway's Life: (1,0,0,) 0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
explanation |
|
0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | dead cells with 3 alive neighbors turn alive |
1 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | alive cells with 2 and 3 neighbors survive |
The Brian's Brain: (1,0,0,) 0,0,1,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,0,0,0,0,0,0,0,0,0
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
explanation |
|
0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | dead cells with 2 firing neighbors turn alive |
1 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | all cells in state 1 get older |
2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | all cells in state 2 must die |
Examples of Rules table rules:
- Busy Brain: 1,0,0,0,0,1,2,0,2,2,2,2,0,2,2,2,1,0,2,2,2,2,0,0,0,0,0,1,2,2,1,2
- WireWorld: 1,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,0,3,3,3,3,3,3,3,3,3,0,3,1,1,3,3,3,3,3,3
MCell is able to run all rules from this family.
Vote for Life
Type: totalistic, 1 bit
"Vote for Life" family is by far the simplest family of rules in MCell. Its rules specify only how many alive neighbors (including the cell itself) must exist that the cell is "on". Since cells consider their own state, the total number of neighbors can be 9 (not 8 like in "Life" rules). Every rule in this family can be also represented in "Life" syntax. For example Vote 46789 is equivalent to Life S35678/B4678.
Note that the count of colors has no influence on next generations, as Vote is a one-bit rule.
Examples of Vote for Life rules:
- Fredkin: 13579
- Vote 4-5: 46789
MCell is able to run all rules from this family.
Weighted Generations
Type: totalistic or outer totalistic parameterization with optional decay
Weighted Generations family, defined and explored in 2001 by Brian Prentice, is a natural extension of the Generations family. The extension simply permits any state to contribute to the neighbor count using weights associated with each state. If a weight is n, and the corresponding state occurs m times in a cells neighborhood then the neighbor count is incremented by n*m. If a state's weight is 0, then that state does not contribute to the neighbor count. Position weights identical to those used in the Weighted Life family are also supported.
Note. Weighted Generations family was implemented in MCell for Windows as a configurable user DLL, supported by MCell starting with version 4.20. The rule setup was controlled by an input dialog window. This window is shown below with the parameters set for Conway's Life.
The weights of neighbors and state weights can be set within a range [0..10].
Rule Notation
The notation of rules in "Weighted Generations" consists of 5 different keywords, specified in any order: C, SW, PW, RS, and RB.
- C - specifies the count of states, 2..16.
- SW - specifies the ordered, semicolon-separated list of weights of states 0..C-1.
- PW - specifies the semicolon-separated list of position weights, in the following order: NW, N, NE, W, E, SW, S, SE.
- RS - specifies the semicolon-separated list of totals allowing cells to survive.
- RB - specifies the semicolon-separated list of totals allowing cells to be born.
Examples of Weighted Generations rules:
- WG Rule004: WeightedGen,C4,SW0;2;0;1,PW1;1;1;1;1;1;1;1,RS6;7;8;9;10;11,RB4
- WG Rule072: WeightedGen,C6,SW0;3;0;1;1;2,PW1;1;1;1;1;1;1;1,RS8;9;10;11;12;13;14;15;16,RB6
MCell is able to run all rules from this family.
Weighted Life
Type: totalistic or outer totalistic parameterization with optional decay
"Weighted Life" allows applying different weights to particular neighbors, including the cell itself. The weight of neighbors can be set within a range [-256..256]. When calculating the count of neighbors the sum of weights of alive neighbors is taken in account. The sum should be within a range [-2048..2048]. Another extension of Weighted Life is the History, known already from the "Generations" family.
Weighted Life rules notation
The notation of rules in "Weighted Life" is more complex. It consists of 12
different keywords, specified in any order:
NW NN NE WW EE SW SS SE ME HI RS RB.
The first 8 keywords NW..SE specify weights of appropriate 8 neighbors. The "ME" keyword specifies the weight of the center cell. The "HI" keyword is a History flag. If non-zero, it tells how many states cells can have (including 0 state). The "RS" and "RB" keywords specify Rules for Survival and Rules for Birth, respectively. They can appear any number of times in the string.
Note
"Weighted Life" is one of the most complex families of rules in MCell. The rules
of many other families (Life,
"Generations", Vote for Life,
General binary) can be defined in it.
For example in order to implement Life rules it's enough to assign 1 to all neighbors, 0 to the
center cell and to switch off the History. One can also define hexagonal rules by defining NE and SW
neighbors as 0.
Examples of Weighted Life rules:
- Frost M: NW1,NN1,NE1,WW1,ME0,EE1,SW1,SS1,SE1,HI25,RB1
- Nocturne: NW1,NN1,NE0,WW1,ME0,EE1,SW0,SS1,SE1,HI4,RS1,RS6,RB2,RB3,RB4
MCell is able to run all rules from this family.