Half-Life: Fuzzifying Conway's Game of Life

My master’s thesis, Half-Life, is about a simple question that becomes surprisingly deep:

What happens if Conway’s Game of Life is no longer strictly binary?

In the classical Game of Life, every cell is either alive or dead. This sharp separation is part of the model’s beauty: the rules are small enough to remember, but the global behavior is rich enough to produce still lifes, oscillators, spaceships, glider guns, logic gates, and even universal computation.

At the same time, the binary state space is also a limitation. Real systems often do not move instantly between two extreme states. They decay, grow, fade, recover, or remain in intermediate states. My thesis explores this idea through a new three-state cellular automaton called Half-Life.

The model can be understood as a discrete approximation of a fuzzy version of Conway’s Game of Life. It keeps the familiar grid, local neighborhood, and simultaneous updates, but extends the state space from two values to three:

$0$ for a dead cell,
$0.5$ for a half-alive cell,
$1$ for a live cell.

The name Half-Life refers to this middle state. A cell does not have to appear or disappear in one step. Birth can happen as $0 \to 0.5 \to 1$ , and death can happen as $1 \to 0.5 \to 0$ .

The goal of the thesis was not only to define the model, but also to investigate whether this small extension can produce meaningful new behavior. To do that, I combined mathematical definitions, automated search, experimental analysis, and a web simulator.

Overview

The thesis had four main goals:

design a fuzzification of Conway’s Game of Life,
prepare software for editing configurations and observing the dynamics,
find meaningful sets of fuzzification parameters,
search for configurations with predefined behavior, especially oscillation and movement.

The resulting work is divided into five main parts:

a theoretical overview of Conway’s Game of Life,
a survey of existing generalizations,
the formal definition of the Half-Life automaton,
the implementation and results of the analytical search tool,
the Fuzzy Life web application for simulation and visualization.

Short Context

Conway’s Game of Life

The thesis uses Conway’s Game of Life mainly as the formal reference model: a grid, a finite neighborhood, local transition rules, global synchronous evolution, and pattern classes such as stable patterns, oscillators, and spaceships. Those concepts are reused in Half-Life, but the thesis contribution begins when the binary state space is replaced by a three-state one.

Existing Generalizations

The literature review exists to position Half-Life, not to claim those older ideas as mine. The most relevant influences are multi-state automata, finite-temperature Life, SmoothLife, Lenia, and fuzzy cellular automata. The one-dimensional Life model of Millen is also important because its survival set $S=\{2,4\}$ is discontinuous; this later motivated my split-survival experiments.

Half-Life takes a conservative path through this space: it keeps the square grid, Moore neighborhood, and deterministic synchronous update, but adds one controlled intermediate state and a gradual transition rule.

The Half-Life Model

The grid is:

\mathbb{Z}^2

The state space is:

\mathcal{S} = \{0, 0.5, 1\}

In visualizations:

$1$ is drawn as a live cell,
$0.5$ is drawn as a half-live or gray cell,
$0$ is drawn as a dead cell.

A configuration is a function that assigns a state to every cell in the grid:

h: \mathbb{Z}^2 \to \mathcal{S}

The set of all configurations is denoted by $\mathcal{C}$ . A pattern is a configuration with finite support:

\{x\in\mathbb{Z}^2 : h(x)\ne 0\}

is finite.

The set of neighbor offsets is:

\mathcal{N} = \{-1,0,1\}^2\setminus\{\langle 0,0\rangle\}.

The neighborhood is the same eight-cell Moore neighborhood used in the classical Game of Life. The difference is that the neighbor sum is no longer just an integer from $0$ to $8$ . Since every neighbor can contribute $0$ , $0.5$ , or $1$ , the possible sums are:

\mathcal{V}=\left\{\frac{k}{2}:k\in\{0,1,\dots,16\}\right\}.

For configuration $h$ and cell $x$ , the Half-Life neighbor sum is:

\operatorname{NeighborSum}_{HL}(h,x)=\sum_{n\in\mathcal{N}} h(x+n).

Rules and Notation

A Half-Life rule is described by two parts:

B, the interval or intervals for birth,
S, the interval or intervals for survival.

The thesis writes rules in a form such as:

B3-7/S2-3,5-8

This means:

birth is targeted when the neighbor sum is between 3 and 7,
survival is targeted when the neighbor sum is between 2 and 3, or between 5 and 8.

In rule strings I use a decimal point for non-integer values, for example B1/S1.5-2. Commas are reserved for separating intervals, as in S2-3,5-8.

The target of a cell is either $1$ or $0$ . This is captured by the target function:

\operatorname{Target}(s,q)= \begin{cases} 1, & q=0 \textrm{ and } s\in B,\\ 1, & q\in\{0.5,1\} \textrm{ and } s\in S,\\ 0, & \textrm{otherwise.} \end{cases}

It decides whether a cell is moving toward the fully alive state or toward the dead state.

The local transition function is:

f_{B,S}(q,s)=q+0.5\cdot\operatorname{sgn}(\operatorname{Target}(s,q)-q).

This is the part I do not want to hide: the model does not simply overwrite a cell with the target. It moves the current state by one half-step toward that target.

So instead of directly flipping state, Half-Life uses gradual transitions:

\textrm{birth: } 0 \to 0.5 \to 1

\textrm{death: } 1 \to 0.5 \to 0

The global transition function applies the local rule simultaneously to every cell:

(F_{B,S}(h))(x)=f_{B,S}(h(x),\operatorname{NeighborSum}_{HL}(h,x)).

The evolution of a starting configuration $h_0$ is the sequence:

h_{t+1}=F_{B,S}(h_t).

This target/local/global split is the formal core of Half-Life.

Why the Rule Space Is Large

In the classical Game of Life, the neighbor count has 9 possible values: $0$ through $8$ . For Life-like rules, birth and survival can each be any subset of these values, so there are:

2^9 \cdot 2^9 = 2^{18} = 262\,144

possible Life-like binary rules.

Half-Life has 17 possible neighbor-sum values because of the $0.5$ state. If arbitrary birth and survival subsets were allowed, the rule space would grow to:

2^{17} \cdot 2^{17} = 2^{34} \approx 17\,000\,000\,000

That is far too large for manual exploration.

Even when restricted to simple continuous intervals for birth and survival, the search still contains more than 23,000 combinations. This is why the thesis required an automated analytical tool.

The thesis also gives two explicit theoretical examples for the rule B1/S1.5-2.

First, it proves the movement of a simple Half-Life glider. Let $F$ be the global transition function for B1/S1.5-2, and let $\mathrm{H}_0$ be a finite pattern containing four half-alive cells:

\mathrm{H}_0(\langle x,y\rangle)= \begin{cases} 0.5, & \langle x,y\rangle\in\{\langle 3,4\rangle,\langle 2,3\rangle,\langle 2,2\rangle,\langle 3,1\rangle\},\\ 0, & \textrm{otherwise.} \end{cases}

Using translation invariance of the global rule, the thesis proves that for every $t\ge 0$ :

F^t(\mathrm{H}_0)=T_{\langle -t,0\rangle}\mathrm{H}_0.

In plain language: after every generation, the pattern has the same shape and is shifted one cell to the left. It is therefore a period-1 spaceship with speed $c$ .

Evolution of $\mathrm{H}_0$ under B1/S1.5-2. The figure is exported from the same cell data as the TikZ drawing in the thesis; selecting it opens the pattern in the simulator.

Second, the thesis proves that Half-Life also has Gardens of Eden under the same rule. The proof uses the Moore-Myhill theorem. Two different local patterns in a $5\times 5$ region are shown to be mutually erasable: one fully dead pattern, and one pattern with only the center cell in state $0.5$ . After one step they lead to the same result under the same outer context. Therefore the global map is not pre-injective, and configurations without predecessors exist.

These proofs matter because they show that Half-Life is not only an experimental simulator. It remains connected to the standard theory of cellular automata.

Automated Exploration

To search the rule space, I implemented Half-Life Explorer, a parallel analysis tool written in Rust.

The tool was designed for:

massive simulation of many rules,
efficient representation of grids and states,
parallel execution of many independent runs,
automatic detection of interesting behavior,
classification and deduplication of discovered patterns.

Manual experimentation is useful for intuition, but it is not enough. The search space is too large, and interesting rules can be rare. Half-Life Explorer makes the process systematic.

The basic workflow is:

choose a family of rules,
generate many random initial configurations,
simulate each rule for a fixed number of steps,
detect whether the resulting behavior is stable, oscillating, moving, growing, or dying,
store unique patterns and associate them with their generating rule.

The implementation is modular. grid.rs and rule.rs define the grid representation and rule evaluation. Fractional states are mapped to integer internal values to avoid floating-point errors. explorer_2d.rs and explorer_1d.rs implement the search infrastructure. analysis.rs and glider.rs classify behavior and verify candidate moving patterns.

In the main 2D experiments, each rule was tested on 3,000 random soups on a $48\times 48$ grid. The initial active block had random size chosen from $\{3,4,5,6,7,8\}$ and density $d\in[0.15,0.45)$ . Each generated cell became $1$ with probability $d/2$ , $0.5$ with probability $d/2$ , and $0$ otherwise. This means the search did not start from purely binary inputs; it explored true Half-Life initial states.

The simulations used periodic boundary conditions internally, but the detector stopped or reclassified runs when a pattern hit the edge. This avoids mistaking toroidal wraparound artifacts for genuine spaceships. The experiments were parallelized with Rayon, and the default setup used 12 worker threads on a 12-vCPU, 32-GB cloud machine.

Pattern Classification

The thesis focuses especially on structures with repeated behavior:

oscillators, which return to the same shape after a period,
spaceships or gliders, which return to the same shape shifted by some vector,
stable patterns, which do not change after reaching a fixed point.

For a moving pattern, the important properties are:

period,
displacement,
velocity,
bounding box,
shape,
rule under which the pattern exists.

In multi-state automata, classification is more complicated than in the classical Game of Life. A pattern can contain half-live cells, can have longer internal decay cycles, and can move while leaving transient traces. The detector therefore has to compare configurations across time and space, not only check whether a grid is unchanged.

The detector uses five working categories:

Dead, when the population drops to zero,
Explode, when the population grows beyond the configured threshold or hits the boundary without being verified as a spaceship,
Oscillator, when a previous cropped state repeats without translation,
Spaceship, when the same component repeats shifted in space,
Chaos, a residual category for runs that do not fit the previous classes within the configured limits.

This classification is heuristic, not a proof of long-term behavior. A run is observed after a 30-step warm-up for at most another 120 steps. Oscillator detection stores a history of 60 states, so the default setting reliably detects only periods up to 60. Candidate spaceships are verified separately on a $64\times 64$ grid for at most 500 steps, with a component-size limit of 100 cells.

To keep the output useful, Half-Life Explorer stores unique patterns after canonicalization. Rotations, reflections, translations, and phase shifts are filtered so that the final catalog contains representative patterns rather than thousands of trivial duplicates.

The tool does not currently store deterministic random seeds for every generated soup, so the exact random sequence is not bit-for-bit reproducible. The experiment parameters and discovered JSONL outputs are reproducible, but exact worker-local random generation would require explicit seed archival.

The thesis also compares the tool with existing Life software. Golly is excellent for large simulations and uses HashLife, while apgsearch is built around automated pattern discovery and Catagolue. However, most established tools are optimized for binary Life-like or Generations rules. Half-Life needs custom state representation, fractional-state semantics, and custom heuristics, so a dedicated Rust implementation was the practical choice.

Experimental Results

Interval Rules

One major experiment tested all combinations with one birth interval and one survival interval.

The experiment covered:

153 possible birth intervals,
153 possible survival intervals,
23,409 unique rules,
3,000 random simulations per rule,
70,227,000 total simulation runs.

This experiment identified:

243 rules that generated at least one spaceship or glider-like pattern.

The strongest rule in this run was B1/S1.5-2, with 20 unique gliders and 3 unique oscillators. Other productive rules behaved quite differently. For example, B1.5-2/S2.5-4.5 produced 14 unique gliders and 130 oscillators, while B1.5/S2-3 produced 8 gliders and 129 oscillators. This is important because the search did not only find “good” or “bad” rules; it revealed that different parameter regions favor different pattern classes.

Rule	Dead	Exploded	Chaos	Gliders	Oscillators
`B1/S1.5-2`	119	2,340	25	20	3
`B1.5-2/S2.5-4.5`	1,337	686	167	14	130
`B1.5-2/S2.5-4`	1,410	645	170	14	100
`B1.5/S1`	879	0	30	14	29
`B2-3/S0.5-1`	620	1,728	342	10	33
`B1.5-2.5/S2.5-3`	868	1,433	204	10	19
`B1/S1.5`	152	1,879	11	9	2
`B1.5/S2-3`	1,633	454	402	8	129
`B1/S1.5-2.5`	115	2,625	95	8	1
`B2.5-5.5/S2-2.5`	1,981	26	494	7	29

Top 10 rules by number of unique ships. Dead, Exploded, and Chaos are detector classifications; Gliders and Oscillators are deduplicated discovered pattern counts.

For B1/S1.5-2, the detector classified 119 runs as dead, 2,340 as exploded, and 25 as chaos. The remaining runs were candidates for repeated behavior and collapsed after deduplication to 20 glider types and 3 oscillator types. This distinction matters: raw simulation outcomes and unique discovered pattern types are not the same quantity.

This confirmed that Half-Life is not just a visual modification of Life. It has a substantial set of rules capable of producing moving structures.

Split-Survival Rules

The second experiment investigated rules with discontinuous survival intervals, called split-survival rules.

An example is:

B3-7/S2-3,5-8

Here the cell can survive in a low-density neighborhood or in a high-density neighborhood, but not in the middle. That gap can change the dynamics significantly. In the observed simulations, this kind of rule often prevented the formation of large stable blobs and instead encouraged cycles of growth and breakdown.

For this experiment, the search was restricted to integer interval boundaries, reducing the tested family to:

11\,475 \textrm{ rules}

The results were especially interesting:

309 rules produced gliders,
266 of those used split-survival intervals,
43 used one continuous survival interval.

That means 86% of the glider-producing rules in this experiment used discontinuous survival intervals.

This does not prove that split-survival rules are generally better. The thesis treats it carefully as an empirical observation from the chosen search space and detector settings. But it suggests that discontinuous survival intervals are a promising direction for future research.

One rule, B3-7/S2-3,5-8, generated 624 unique oscillators in the tested setting.

Other high-scoring split-survival rules included B3-8/S2-3,5-8, which generated 588 oscillators, and B3-7/S2-3,5-7, which generated 225 oscillators. These results support the working hypothesis that a “gap” in the survival interval can prevent large stable blobs and instead encourage cycles of growth and breakdown.

Rule	Dead	Exploded	Chaos	Gliders	Oscillators
`B3-7/S2-3,5-8`	1,644	0	8	9	624
`B3-8/S2-3,5-7`	1,602	0	570	9	141
`B2/S2-3,5`	1,316	1,385	71	8	7
`B2/S2-3,5-6`	1,312	1,377	92	8	7
`B3-8/S2-3,5-8`	1,679	0	8	7	588
`B3-7/S2-3,5-7`	1,670	0	452	7	225
`B2-8/S0-1,5`	123	2,134	386	7	58
`B2-3/S0-1,7`	144	1,594	875	6	56
`B2-4/S0-1`	123	2,183	326	6	55
`B2-4/S0-1,5`	116	2,193	326	6	49

Most successful rules from the split-survival experiment, using the same detector categories as the first table. Continuous-survival rules may still appear if they ranked among the best in this run.

Final Catalog

The two experiments overlapped, so their results cannot be added directly. After merging and deduplicating the outputs, the final catalog contains:

514 unique rules that support moving structures,
3,381 discovered patterns,
gliders and spaceship-like objects,
oscillators with a wide range of periods,
representative patterns integrated into the Fuzzy Life simulator.

This catalog is one of the main outputs of the thesis. It turns the abstract rule space into a concrete library of examples that can be inspected and reused.

The gallery of discovered patterns adds more detail than the headline counts:

the slowest discovered glider has speed $c/26$ and appears in B3-6/S2-3 and B3-6/S2-3,7-8,
the rule B1/S1.5-2 supports speed- $c$ ships with period 1,
B2.5-8/S1.5-2 contains an unusual glider with speed $3c/37$ and period 37,
the catalog contains speeds such as $c$ , $2c/3$ , $c/2$ , $c/3$ , $c/4$ , $2c/5$ , $c/5$ , $c/6$ , $c/7$ , $c/8$ , $c/9$ , $c/12$ , $c/13$ , $c/15$ , $c/16$ , $c/18$ , $c/20$ , $c/24$ , $c/26$ , $2c/31$ , and $3c/37$ .

The slowest discovered glider, with speed $c/26$ .

Examples of period-1 ships with speed $c$ in B1/S1.5-2.

A $3c/37$ glider changing from a larger phase to a compact phase and back.

For oscillators, the main catalog contains 44 unique periods from 1 to 60. The upper bound is not a mathematical limit of Half-Life; it comes from the detector history length. The rule B1.5/S1 contains an oscillator of period 60. In a separate deeper search, the rule B4-6/S1-3,4-6 produced oscillators for 180 out of 185 periods in the range 16 to 200. The only missing periods in that experiment were 163, 179, 191, 193, and 197, which makes the rule a plausible candidate for omniperiodic behavior.

A period-60 oscillator in B1.5/S1, including the sparse intermediate phase from the thesis.

The gallery of discovered patterns shows that Half-Life objects can have a visual character different from classical Game of Life spaceships.

Because cells decay through the $0.5$ state, many moving objects appear to have a front and a tail. The front creates or preserves live cells, while the back gradually fades through the half-live state. This does not mean the automaton has physical aerodynamics, but visually the local rule often shapes moving patterns into forms that look directional.

Periodicity is also richer than in the simplest classical examples. In the Game of Life, common introductory oscillators have period 2, such as the blinker, toad, or beacon. In Half-Life, the additional state can create longer internal cycles because a cell may need multiple steps to appear or disappear completely.

Several visually interesting patterns are highlighted in the thesis: a $c/2$ glider in B2.5-3/S3-4.5 with a V-shaped outline, a compact “beetle-like” glider in B1.5-2/S2, a multi-component glider in B1.5-2/S2.5-4.5, and symmetric oscillators such as a period-32 pattern in B3-8/S2-3,5-6. These examples are not just illustrations; they show that the discovered catalog contains different movement speeds, internal periods, symmetries, and morphologies.

A V-shaped $c/2$ glider in B2.5-3/S3-4.5.

A compact beetle-like glider in B1.5-2/S2.

A multi-component $c/2$ glider in B1.5-2/S2.5-4.5.

A symmetric period-32 oscillator in several phases.

A compact period-16 oscillator in two morphologically different phases.

Fuzzy Life Simulator

To make the results easier to explore, I also built an interactive web application called Fuzzy Life. It visualizes several classes of cellular automata in real time, including the Half-Life model, the classic Conway Game of Life, continuous fuzzy variants, one-dimensional automata, and quartile-based extensions.

Interactive simulator

Try the Half-Life rules and discovered patterns directly in Fuzzy Life.

Open Fuzzy Life ->

The simulator is important because many cellular automata results are much easier to understand visually than textually. A rule may be defined by a short string, but its behavior only becomes clear after watching it evolve.

Fuzzy Life is a single-page web application built with React. The simulation is rendered with the HTML5 Canvas API, which is suitable for continuously drawing grid-based systems in the browser.

The main architectural parts are:

simulation core, which applies the transition function for the currently selected mode,
state management, built around React state and Zustand,
event handling, where RxJS helps with asynchronous user interactions such as drawing,
data layer, which loads discovered rules and patterns from generated static data,
visualization layer, where each mode defines how its cells are rendered,
internationalization, with the user interface localized into English and Slovak.

The application is built around a common abstraction for simulation modes. Each mode provides behavior such as:

computeNextState(grid, x, y)
renderCell(ctx, x, y, value)
serialize / deserialize pattern data

This makes it possible to add new automata without rewriting the whole simulation loop.

The application includes several modes:

Mode	Description
Half-Life	The main three-state model from the thesis.
Classic	Conway’s original Game of Life with rule `B3/S23`.
Continuous	A fuzzy-inspired mode with continuous values and fading behavior.
1D	A one-dimensional automaton visualized as a spacetime diagram.
Quartiles	A five-state extension using $0$ , $0.25$ , $0.5$ , $0.75$ , and $1$ .
Additional variants	Experimental modes for comparing different rule families.

The Half-Life mode includes presets for discovered rules and patterns. This connects the Rust-based offline search with the browser-based visual environment.

The 1D mode is visualized as a spacetime diagram. The implementation is intentionally parameterized: users can change the neighborhood radius, birth and survival intervals, and weighted left/right neighbor contributions.

Although the main large-scale search is done by the Rust tool, Fuzzy Life also includes a browser-based pattern finder.

It allows a user to configure:

starting cluster size,
maximum number of generations,
density range,
generation strategy,
target pattern types such as gliders or oscillators.

The browser search is not meant to replace the native tool. Its purpose is interactive exploration: trying a rule, launching a local search, and immediately inspecting any discovered structures.

Conclusions

The thesis combines three parts:

a theoretical overview of Conway’s Game of Life and related cellular automata,
the definition and analysis of the Half-Life three-state model,
a practical Rust tool and React web application for search and visualization.

The concrete contributions are:

a formal definition of the Half-Life automaton,
a rule notation for interval and split-interval birth/survival rules,
an automated search pipeline for large rule families,
an empirical catalog of 514 rules and 3,381 patterns,
evidence that split-survival intervals are worth further investigation,
an interactive simulator that exposes the discovered patterns to users.

Limitations

The experiments are empirical. They show what was found under specific search settings, random generation strategies, limits on simulation time, and detection rules. They do not fully characterize the entire Half-Life rule space.

The split-survival result is especially promising, but it should not be overinterpreted. A stronger claim would require normalized comparison across rule families, careful control for search-space size, and probably more specialized mathematical analysis.

Future Work

Several directions remain open:

deeper mathematical analysis of Half-Life rules,
classification of stable patterns and moving structures,
systematic comparison with other fuzzy and multi-state automata,
larger searches over less restricted rule spaces,
better detection of complex long-period behavior,
further generalization from three states to more states or continuous values.

The Quartiles mode in Fuzzy Life already points in this direction. It extends Half-Life from three states to five fixed levels and gives a possible bridge toward richer fuzzy models.

The main result of the thesis is that a very small change to the Game of Life can create a large and interesting design space.

Adding a single intermediate state changes how cells are born, survive, decay, and move. It keeps the model simple enough to search, but rich enough to produce thousands of patterns across hundreds of rules.

Half-Life is not intended to replace Conway’s Game of Life. It is a nearby model that asks what happens when binary life is allowed to become half-alive first.