Visual Game of Life Synthesis — User Guide

Cellular automata sonification: real-time visualization and audio synthesis from Conway's Game of Life patterns. Watch evolution unfold while hearing it as evolving sound textures.

Author: Shai Cohen Affiliation: Department of Music, Bar-Ilan University, Israel Version: 1.0 (2025) License: MIT License Repo: https://github.com/ShaiCohen-ops/Praat-plugin_AudioTools

Contents:

What this does Quick start Game of Life Theory Sonification Method Pattern Library Applications

What this does

🎮 Conway's Game of Life (1970)

The zero-player game: Created by mathematician John Horton Conway. A cellular automaton that evolves from initial state according to simple rules. Despite simplicity, exhibits emergence, self-organization, and complex behavior. Turing-complete: can simulate any Turing machine. This plugin brings Life to life with synchronized visual and audio representation.

This script implements real-time cellular automata sonification — converting Game of Life patterns into sound while visualizing their evolution. Each generation becomes a musical "phrase" where living cells generate sine tones with frequencies determined by their grid position. The plugin combines visual simulation with audio synthesis, creating a synesthetic experience where you can watch patterns evolve while hearing their sonic representation.

Key Features:

8 Classic Patterns — From simple blinkers to complex glider guns
Real-time Visualization — Watch cellular evolution with color coding
Synchronous Sonification — Each generation creates corresponding sound
Position-based Audio — Cell location determines frequency
Interactive Playback — Hear each generation as it evolves
Toroidal Universe — Wraparound edges for continuous evolution
Spatial Audio — Mono or stereo frequency-based separation
Progress Visualization — Generation counter and active cell display

What is cellular automata sonification? Traditional synthesis: Oscillators, samples, physical models. Cellular automata sonification: Convert state changes in computational systems directly to sound. Game of Life as musical system: Each cell = potential sound source. Birth/death = note on/off. Pattern motion = melodic/harmonic movement. Density = amplitude/texture. Synesthetic approach: Visual patterns have inherent musical qualities when mapped appropriately. Advantages: (1) Emergent complexity: Simple rules generate complex musical structures. (2) Visual-audio connection: Direct correlation between what you see and hear. (3) Generative composition: Infinite variations from initial conditions. (4) Educational: Learn cellular automata through multi-sensory experience. Use cases: Algorithmic music, generative art, educational demonstrations, data sonification, interactive installations, meditation/visualization.

Technical Implementation: (1) Grid initialization: Create N×N grid with pattern. (2) Visualization loop: For each generation: display grid with color coding, count active cells, show progress. (3) Sonification: Convert active cells to sine tones with Hanning envelopes. (4) Frequency mapping: Map cell position (x+y) to frequency range. (5) Amplitude scaling: Scale amplitude inversely with active cell count. (6) Evolution: Apply Conway's B3/S23 rules with toroidal wrap. (7) Audio assembly: Accumulate generations into final sound. (8) Spatial processing: Apply mono or stereo filtering. (9) Final visualization: Display spectrogram of complete sonification.

Quick start

In Praat, ensure no objects are selected (creates from cellular automaton).
Run script… → Visual_Game_of_Life_Synthesis.praat.
Choose Preset pattern or "Random Soup" for unpredictable results.
Set Grid size (resolution) and Number of generations (evolution steps).
Adjust Duration (total audio time) and Visualization delay (animation speed).
Configure Base frequency and Frequency range for audio mapping.
Choose Play during visualization to hear each generation as it evolves.
Select Spatial mode (mono or stereo frequency separation).
Click OK — watch evolution while hearing sonification in real-time.
Final spectrogram displayed; sound named "gol_[pattern]" saved.

Quick tip: Start with Blinker or Glider for simple, predictable evolution. Use Random Soup for complex, unpredictable textures. Adjust visualization delay to control animation speed (0.1-0.3 seconds works well). Enable play during visualization for immediate feedback. For musical results: set base frequency to musical note (e.g., 220 Hz = A3), use frequency range of 1-2 octaves. Larger grid sizes (32+) allow complex patterns but need more generations to evolve. Complex patterns like Glider Gun auto-adjust grid size and generation count. Watch for interesting patterns like oscillators, spaceships, and still lifes. Each run is unique with Random Soup.

Important: REAL-TIME PROCESSING — visualization and sound generation occur simultaneously. Performance varies by grid size × generations — large configurations may run slowly. Auto-adjustment: Some presets override grid size/number of generations for proper display. Toroidal universe: Edges wrap around (top connects to bottom, left to right). Active cell limit: Only first 25 cells per generation contribute to sound (prevents overload). Amplitude scaling: Many active cells = quieter individual tones. Frequency mapping: Cells at same diagonal produce same frequency. Visualization window: Keep Praat Picture window open. Stereo mode applies frequency-based panning (low=left, high=right). Be patient for long generations — each step has visualization delay.

Game of Life Theory

Conway's Rules (B3/S23)

⚙️ The Simple Rules of Complexity

Environment: Infinite 2D grid of cells, each either alive (1) or dead (0).

Neighborhood: Each cell has 8 neighbors (Moore neighborhood).

Rules per generation:

Birth: Dead cell with exactly 3 live neighbors becomes alive
Survival: Live cell with 2 or 3 live neighbors stays alive
Death: Live cell with fewer than 2 (underpopulation) or more than 3 (overpopulation) neighbors dies

Notation: B3/S23 = Born with 3 neighbors, Survives with 2 or 3 neighbors.

Mathematical formulation: Let cell[i,j] ∈ {0,1} at generation t Let neighbors(i,j) = ∑∑ cell[i+di, j+dj] for di,dj ∈ {-1,0,1}, (di,dj)≠(0,0) Evolution to generation t+1: cell_next[i,j] = 1 if (cell[i,j]=0 AND neighbors(i,j)=3) # Birth 1 if (cell[i,j]=1 AND neighbors(i,j)∈{2,3}) # Survival 0 otherwise # Death Toroidal implementation (wraparound edges): If i+di < 1: use grid_size If i+di > grid_size: use 1 Same for j+dj Neighbor counting pseudocode: neighbors = 0 FOR di = -1 TO 1 FOR dj = -1 TO 1 IF NOT (di=0 AND dj=0) ni = i + di nj = j + dj IF ni < 1: ni = grid_size IF ni > grid_size: ni = 1 IF nj < 1: nj = grid_size IF nj > grid_size: nj = 1 neighbors = neighbors + cell[ni, nj] ENDIF ENDFOR ENDFOR

Pattern Classification

🔍 Categories of Life Forms

Still Lifes: Patterns that don't change

Block: 2×2 square
Beehive: hexagonal shape
Loaf: diamond with indent

Oscillators: Repeat after period P

Blinker: period 2 (3 cells in line)
Toad: period 2
Pulsar: period 3 (complex)
Pentadecathlon: period 15

Spaceships: Translate across grid

Glider: smallest, period 4, moves diagonally
Light/Medium/Heavyweight spaceship (LWSS/MWSS/HWSS)

Guns: Produce spaceships periodically

Gosper Glider Gun: most famous, period 30

Methuselahs: Long-lived small patterns

R-pentomino: 5 cells, evolves for 1103 generations
Acorn: 7 cells, evolves for 5206 generations

Computational Significance

🧮 Turing Completeness

Theory proved: Game of Life is Turing complete (can simulate any Turing machine).

Implications: Can perform any computation given enough space and time.

Practical constructions:

Logic gates: AND, OR, NOT from glider streams
Memory: Using blocks and eaters
Counters: Period-multiplying circuits
Universal computer: Has been constructed in Life

For sonification: Patterns represent computational processes — sound reflects computation unfolding.

Visualization System

Four-part visualization during evolution: 1. TITLE AREA (top): "Game of Life: [Pattern Name]" "Generation X/Y | Active: N cells" Font size 14/11, centered 2. GRID VISUALIZATION (main area): Viewport: (0.8, 7.2, 1.2, 5.5) Axes: (0, grid_size, 0, grid_size) Background: light gray (0.95, 0.95, 0.95) Live cells: colored by position Grid lines: gray (0.75, 0.75, 0.75) Border: black, thickness 2 3. CELL COLORING: For cell at (i,j): hue = (i + j) / (2 × grid_size) r = 0.1 + 0.4 × hue g = 0.4 - 0.2 × hue b = 0.7 - 0.4 × hue Creates rainbow gradient across diagonals Helps visualize spatial relationships 4. PROGRESS BAR (bottom): Viewport: (0.8, 7.2, 5.7, 6.0) Axes: (0, 1, 0, 1) Progress = generation / total_generations Bar color: (0.3, 0.6, 0.4) - green 5. FINAL SPECTROGRAM: After evolution complete Shows frequency-time evolution of entire sonification Frequency range: base_freq to base_freq + range×1.3 Time range: 0 to total_duration

Sonification Method

🎵 From Cells to Sound

Mapping philosophy: Each living cell = potential sound source. Birth = note on, death = note off. Pattern evolution = musical development.

Three-level mapping:

Spatial → Frequency: Cell position determines pitch
Density → Amplitude: Cell count determines volume
Temporal → Envelope: Generation timing determines rhythm

Frequency Mapping Algorithm

POSITION TO FREQUENCY: For cell at position (i,j) in grid_size × grid_size: 1. Calculate normalized position: pos_norm = (i + j - 2) / (2 × grid_size - 2) Where: i,j ∈ [1, grid_size] Minimum: i=j=1 → pos_norm = 0 Maximum: i=j=grid_size → pos_norm = 1 Diagonal lines have same frequency: (1,1) = frequency_min (2,1) = (1,2) = same frequency (grid_size, grid_size) = frequency_max 2. Map to frequency range: freq = base_frequency_Hz + pos_norm × frequency_range_Hz 3. Example: grid_size=16, base=200 Hz, range=600 Hz Cell at (1,1): freq = 200 + 0 × 600 = 200 Hz Cell at (8,8): pos_norm = (8+8-2)/(30) = 14/30 ≈ 0.467 freq = 200 + 0.467×600 = 480 Hz Cell at (16,16): pos_norm = (16+16-2)/(30) = 30/30 = 1 freq = 200 + 1×600 = 800 Hz MUSICAL INTERPRETATION: Base frequency = tonic/root note Frequency range = pitch range (typically 1-2 octaves) Diagonal cells = same pitch class (harmonically related) Vertical/horizontal movement = pitch change

Amplitude & Envelope Design

AMPLITUDE SCALING: 1. Per-cell base amplitude: base_amp = 0.4 (maximum for single cell) 2. Density-based scaling: For generation with active_count living cells: amp_scale = 1 / √max(1, active_count) Rationale: Many cells → each quieter to prevent clipping 3. Final cell amplitude: cell_amp = base_amp × amp_scale 4. Example: active_count = 9 amp_scale = 1 / √9 = 1/3 ≈ 0.333 cell_amp = 0.4 × 0.333 ≈ 0.133 ENVELOPE DESIGN (per generation): 1. Generation timing: step_duration = total_duration / number_of_generations step_start = (generation-1) × step_duration step_end = generation × step_duration 2. Hanning window envelope: envelope(t) = [1 - cos(2π × (t - step_start) / step_duration)] / 2 Where t ∈ [step_start, step_end] Properties: - Smooth fade in/out (no clicks) - Integrates to step_duration/2 - Zero at boundaries, maximum at center 3. Complete cell signal formula: signal(t) = cell_amp × sin(2π × freq × t) × envelope(t)

Audio Generation Process

STEP-BY-STEP GENERATION: Initialize: output_sound = CreateSound(duration, samplerate, "0") For generation = 1 to number_of_generations: 1. Count active cells in current generation 2. Build formula string for this generation: formula$ = "0" cell_count = 0 FOR each cell (i,j) in grid: IF cell[i,j] = 1 AND cell_count < 25: # Calculate parameters freq = base_freq + ((i+j-2)/(2*grid_size-2)) × freq_range amp = 0.4 / sqrt(max(1, active_count)) t_start = (generation-1) × step_duration t_end = generation × step_duration # Create cell formula cell_formula$ = " + if x >= " + t_start + " and x < " + t_end + " then " + amp + " * sin(twoPi * " + freq + " * x) * (1 - cos(twoPi * (x - " + t_start + ") / " + step_duration + ")) / 2 else 0 fi" formula$ = formula$ + cell_formula$ cell_count = cell_count + 1 ENDIF ENDFOR 3. Apply to output sound: output_sound.Formula = "self + (" + formula$ + ")" 4. Optional: Play this generation IF play_during_visualization AND active_count > 0: Create temporary sound with formula$ Scale peak to 0.7 Play Remove temporary sound Rationale for 25-cell limit: Prevents formula becoming too large for Praat 25 cells × 8 presets = 200 max simultaneous tones Usually sufficient for musical density

Spatial Audio Processing

TWO SPATIAL MODES: 1. MONO: Single channel output All frequencies mixed together Simple, direct 2. STEREO (POSITION-BASED): Creates frequency-based stereo separation Process: a. Create left channel: Copy original → left_sound Apply low-pass filter: 0 to (base_freq + 0.5×freq_range) Keeps lower half of frequency range b. Create right channel: Copy original → right_sound Apply band-pass filter: base_freq to (base_freq + 1.5×freq_range) Keeps upper half of frequency range c. Combine to stereo: left_sound + right_sound → stereoSound Result: Lower frequencies in left ear, higher in right Filter specifications: Filter type: Hann band Smoothing: 100 Hz transition Creates natural stereo image without abrupt cuts Musical effect: Creates spatial width Helps distinguish dense textures Mimics natural hearing (low frequencies more omnidirectional) Alternative approach (not implemented): Could use actual cell x-position for panning Left-right in grid maps to stereo pan position Current implementation uses frequency separation instead

Complete Sonification Pipeline

OVERVIEW: SETUP: Parse parameters Initialize grid with chosen pattern Auto-adjust grid/generations for certain presets Create output sound buffer MAIN LOOP (per generation): ┌─────────────────────────────────────────────────┐ │ 1. VISUALIZATION │ │ • Display grid with color-coded cells │ │ • Show generation counter │ │ • Show active cell count │ │ • Update progress bar │ └─────────────────────────────────────────────────┘ │ ┌─────────────────────────────────────────────────┐ │ 2. SONIFICATION │ │ • Convert active cells to frequency values │ │ • Calculate amplitudes (density-scaled) │ │ • Build audio formula for generation │ │ • Add to accumulating output sound │ │ • Optionally play generation immediately │ └─────────────────────────────────────────────────┘ │ ┌─────────────────────────────────────────────────┐ │ 3. EVOLUTION │ │ • Apply B3/S23 rules to all cells │ │ • Toroidal edge wrapping │ │ • Update cell states for next generation │ └─────────────────────────────────────────────────┘ │ │ Sleep for visualization_delay seconds └──────┘ POST-PROCESSING: • Apply 20ms fade in/out to entire sound • Apply spatial processing (mono/stereo) • Normalize peak to 0.9 • Display final spectrogram OUTPUT: • Sound object: "gol_[pattern_name]" • Visual record in Praat Picture window • Info window with generation summary

Pattern Library

📚 Classic Game of Life Patterns

Eight carefully selected patterns representing different categories of Life behavior. Each creates distinct sonic character.

Simple Patterns

Pattern	Cells	Behavior	Sonic Character	Auto-adjusted
Random Soup	~35% of grid	Chaotic evolution, eventual stabilization	Dense, noisy, unpredictable	No
Glider	5 cells	Moves diagonally, period 4	Simple repeating motif, moving pitch	No
Blinker	3 cells	Oscillator, period 2	Alternating two-note pattern	No

Complex Oscillators

Pattern	Cells	Behavior	Sonic Character	Auto-adjusted
Pulsar	48 cells	Period 3 oscillator, symmetrical	Three-phase rhythm, harmonic clusters	Grid ≥17
R-pentomino	5 cells	Methuselah, 1103 generations	Evolving texture, gradual complexity	No
Acorn	7 cells	Methuselah, 5206 generations	Slow development, sparse to dense	No

Moving Patterns

Pattern	Cells	Behavior	Sonic Character	Auto-adjusted
Lightweight Spaceship (LWSS)	8 cells	Moves right, period 4	Pitch glide, rhythmic engine	No
Glider Gun (Gosper)	36 initial	Produces gliders every 30 gens	Complex rhythm, glider motifs	Grid ≥38, Gens ≥40

Pattern Details & Setup

R-PENTOMINO (Methuselah): Pattern: Sonic interpretation: ▪▪ Two close pitches (birth) ▪▪▪ Developing cluster Evolution: Creates gliders, blocks, beehives Sonic: Starts sparse, becomes complex texture ACORN (Methuselah): Pattern: Sonic: ▪ ▪ Widely spaced pitches ▪ Central tone emerges ▪ ▪ ▪ Expanding harmony Famous for long, interesting evolution GLIDER GUN (Gosper): Left block: Constant drone (stable) Gun mechanism: Rhythmic engine sound Glider output: Periodic melodic elements Right block: Secondary drone Complete system: Self-sustaining ecosystem AUTO-ADJUSTMENT LOGIC: IF preset = "Pulsar" AND grid_size < 17: grid_size = 17 # Needs space for pattern IF preset = "Glider Gun": grid_size = max(38, grid_size) # Large grid needed number_of_generations = max(40, number_of_generations) # See gliders Other patterns use user settings

Parameter Reference

Parameter	Type	Default	Range	Description
Preset	option	Random Soup	1-8	Initial pattern configuration
Grid_size	integer	16	4-100	Width/height of cellular universe
Number_of_generations	integer	25	1-1000	Evolution steps to simulate
Duration_s	positive	5.0	0.1-60	Total audio duration in seconds
Visualization_delay	positive	0.15	0.01-1.0	Delay between generations (animation speed)
Sample_rate_Hz	integer	44100	8000-192000	Audio sample rate
Base_frequency_Hz	positive	200	20-2000	Lowest frequency for sonification
Frequency_range_Hz	positive	600	50-2000	Pitch range from base frequency
Play_during_visualization	boolean	1	0/1	Hear each generation as it evolves
Play_final_result	boolean	1	0/1	Play complete sonification after visualization
Spatial_mode	option	1	1-2	Mono or stereo frequency separation

Applications

Algorithmic Music Composition

Use case: Generate musical structures from computational processes

Techniques:

Parameter studies: Explore how grid size/frequency mapping affect musical outcome
Hybrid composition: Use Game of Life output as one layer in larger composition
Evolutionary forms: Map generational development to musical development sections
Stochastic control: Use Random Soup as controlled randomness source

Educational Demonstrations

Use case: Teach cellular automata, emergence, complexity

Techniques:

Visual-audio correlation: Students see pattern and hear its sonic representation
Pattern recognition: Learn to identify oscillators, spaceships by sound
Emergence demonstration: Show how simple rules create complex behavior
Computational thinking: Connect abstract computation to sensory experience

Generative Art & Installations

Use case: Create evolving audiovisual installations

Techniques:

Live performance: Adjust parameters in real-time during visualization
Interactive systems: Allow audience to set initial patterns
Projection mapping: Large-scale visualization with spatial audio
Generative video: Record visualization for video art

Data Sonification

Use case: Convert other 2D data into Game of Life for sonification

Techniques:

Image processing: Convert images to initial Life states
Scientific data: Map data matrices to cellular automata
Text encoding: Convert text to binary patterns for Life evolution
Cross-domain mapping: Use Life as intermediary between data types

Practical Workflow Examples

🎵 Minimalist Composition

Goal: Create sparse, meditative piece from simple Life patterns

Settings:

Pattern: Glider (simple, predictable)
Grid: 8×8 (small, intimate)
Generations: 64 (power of 2 for musical structure)
Duration: 32 seconds (0.5s per generation)
Base frequency: 110 Hz (A2, fundamental)
Range: 880 Hz (4 octaves, A2 to A6)
Play during: Yes (hear evolution)
Spatial: Stereo

Result: Slowly moving pitch patterns with clear glider motion

Post-process: Add reverb, layer multiple runs at different speeds

🏫 Classroom Demonstration

Goal: Show emergence and complex systems

Settings:

Pattern: Random Soup (unpredictable)
Grid: 24×24 (visible complexity)
Generations: 100 (show full evolution)
Duration: 30 seconds (fast enough to hold attention)
Visual delay: 0.3s (time to observe)
Play during: Yes (immediate feedback)
Base frequency: 220 Hz (A3, clear pitch)

Educational points:

Watch ordered structures emerge from randomness
Listen to density changes (more cells = denser sound)
Identify oscillators and still lifes by their sonic signatures
Discuss how simple rules create complex behavior

🎨 Generative Sound Design

Goal: Create evolving textures for film/game backgrounds

Settings:

Pattern: Acorn (long, interesting evolution)
Grid: 32×32 (space for development)
Generations: 200 (extended evolution)
Duration: 60 seconds (slow evolution)
Base frequency: 82 Hz (E2, low and atmospheric)
Range: 400 Hz (approx. 2.5 octaves)
Spatial: Stereo (creates width)
Play during: No (process silently)

Result: Evolving atmospheric pad sound

Post-process: Add delay, reverb, subtle modulation

Use: Background for sci-fi, horror, or abstract scenes

Advanced Techniques

Musical parameter mapping strategies:

Scale quantization: Map frequencies to nearest notes in chosen scale
Dynamic range compression: Apply compression to even out density changes
Multi-voice extraction: Extract different pattern elements to separate tracks
Tempo synchronization: Set generation duration to match musical tempo
Pattern layering: Run multiple Life simulations simultaneously with different parameters

Creative pattern design:

Custom initial patterns: Modify script to load custom cell configurations
Asymmetric grids: Use rectangular instead of square grids
Multiple patterns: Initialize with several patterns at different positions
Interactive editing: Pause evolution, edit cells, continue
Rule variations: Experiment with different B/S rules (B36/S23, etc.)

Troubleshooting Common Issues

Problem: Visualization too slow
Causes: Large grid × many generations, short visualization delay
Solutions: Reduce grid size, reduce generations, increase visualization delay

Problem: Sound too sparse/quiet
Causes: Few active cells, small amplitude scaling
Solutions: Use denser pattern, increase base amplitude, reduce frequency range

Problem: Sound too dense/noisy
Causes: Many active cells, too many generations, large frequency range
Solutions: Use sparser pattern, reduce generations, narrow frequency range

Problem: Pattern dies out quickly
Causes: Small grid, isolated pattern, edge effects
Solutions: Increase grid size, use toroidal mode (default), choose robust pattern

Problem: Audio glitches/clicks
Causes: Abrupt envelope changes, too many simultaneous tones
Solutions: Ensure Hanning envelope applied, limit active cells (already limited to 25)

Problem: Praat becomes unresponsive
Causes: Very large grid × generations, complex patterns
Solutions: Use smaller configurations, be patient, check Praat memory settings

Performance Optimization

FOR INTERACTIVE USE: • Grid size: 16-32 (balance detail and speed) • Generations: 25-100 (enough to see evolution) • Visualization delay: 0.1-0.3s (responsive but visible) • Duration: 5-30 seconds (typical attention span) • Active cell limit: 25 (prevents audio overload) FOR RENDERING (BACKGROUND): • Grid size: 32-64 (more detail) • Generations: 100-500 (longer evolution) • Visualization delay: 0.01s (minimum for progress) • Play during: No (silent processing) • Duration: match artistic needs COMPUTATION BREAKDOWN: Per generation: • Cell updates: grid_size² × 8 neighbor checks • Visualization: grid_size² cell draws • Audio: up to 25 sine tone calculations • Progress updates: constant Example (grid=32, generations=100): • Cell updates: 32² × 8 × 100 = 819,200 operations • Visualization: 32² × 100 = 102,400 cell draws • Audio: 25 × 100 = 2,500 tone calculations MEMORY USAGE: • Cell arrays: 2 × grid_size² integers • Output sound: duration × sample_rate samples • Temporary sounds: per generation if playing during Example (grid=32, duration=10s, 44.1kHz): • Cell arrays: 2 × 1024 × 4 bytes ≈ 8KB • Output sound: 10 × 44100 × 4 bytes ≈ 1.76MB

Technical Implementation Details

Cell Data Structures

TWO-ARRAY SYSTEM: 1. Current generation array: cell[i,j] ∈ {0,1} for i,j ∈ [1, grid_size] Represents current state 2. Previous generation array: oldCell[i,j] ∈ {0,1} Used for neighbor counting during evolution Prevents interference from newly updated cells Memory allocation: Dynamic based on grid_size Example: grid_size=32 → 1024 cells per array Each cell: 1 integer (0 or 1) Evolution algorithm: FOR generation = 1 to number_of_generations: # Copy current to old FOR i = 1 to grid_size FOR j = 1 to grid_size oldCell[i,j] = cell[i,j] ENDFOR ENDFOR # Apply rules using old state FOR i = 1 to grid_size FOR j = 1 to grid_size neighbors = count_neighbors(oldCell, i, j) # Apply B3/S23 rules to cell[i,j] ENDFOR ENDFOR Advantage: Clear separation between generations Disadvantage: Doubles memory (acceptable for typical sizes)

Toroidal Edge Handling

WRAPAROUND IMPLEMENTATION: Neighbor counting with toroidal topology: function count_neighbors(grid, i, j): neighbors = 0 FOR di = -1 to 1 FOR dj = -1 to 1 IF NOT (di=0 AND dj=0) ni = i + di nj = j + dj # Wrap around edges IF ni < 1: ni = grid_size ELSIF ni > grid_size: ni = 1 IF nj < 1: nj = grid_size ELSIF nj > grid_size: nj = 1 neighbors = neighbors + grid[ni, nj] ENDIF ENDFOR ENDFOR RETURN neighbors Alternative approaches considered: 1. Fixed boundaries: Cells at edges have fewer neighbors 2. Reflective boundaries: Mirror image at edges 3. Toroidal (implemented): Continuous universe Why toroidal: • More natural for continuous evolution • No edge effects (patterns can cross boundaries) • Consistent neighbor count for all cells • Common in Life implementations Musical implication: • Patterns can reappear from opposite side • Creates longer evolutionary cycles • More sustained sonic development

Formula String Construction

DYNAMIC FORMULA BUILDING: Challenge: Praat's Formula command needs complete expression Solution: Build string incrementally Process: 1. Start with "0" (silence) 2. For each active cell (up to 25): Build cell component: " + if x >= [start] and x < [end] " " then [amp] * sin(twoPi * [freq] * x) " " * (1 - cos(twoPi * (x - [start]) / [duration])) / 2 " " else 0 fi" 3. Result example: "0 + if x >= 0.0 and x < 0.2 then 0.1 * sin(twoPi * 300 * x) * (1 - cos(twoPi * (x - 0.0) / 0.2)) / 2 else 0 fi" " + if x >= 0.0 and x < 0.2 then 0.08 * sin(twoPi * 450 * x) * (1 - cos(twoPi * (x - 0.0) / 0.2)) / 2 else 0 fi" ... 4. Apply to sound: sound.Formula = "self + (" + formula$ + ")" Performance considerations: • String concatenation can be slow for many cells • Limited to 25 cells for practical reasons • Formula evaluation per sample is efficient in Praat Alternative approach: Could use sample-by-sample loop in Praat Current approach leverages Praat's optimized formula evaluation

Visual-Audio Synchronization

REAL-TIME COORDINATION: Three concurrent processes per generation: 1. VISUAL UPDATE: • Clear Picture window • Draw grid with current cell states • Update title with generation info • Draw progress bar • Display to screen 2. AUDIO GENERATION: • Count active cells • Calculate frequencies/amplitudes • Build formula string • Add to accumulating sound • Optionally play generation sound 3. CELL EVOLUTION: • Copy current to old array • Apply B3/S23 rules to all cells • Prepare next generation Timing control: • Generation processing time varies with active cells • Fixed visualization_delay ensures consistent pacing • sleep(visualization_delay) at end of each generation • Total time ≈ generations × (processing_time + delay) Synchronization guarantee: • Audio always matches displayed generation • Evolution occurs after audio generation • No race conditions (sequential processing) User experience: • Watch pattern evolve • Hear corresponding sound • See progress bar advance • Final spectrogram shows complete evolution

Historical & Theoretical Context

John Horton Conway (1937-2020)

🧮 The Mathematician Behind Life

Background: British mathematician active in finite groups, knot theory, game theory, and coding theory. Professor at Princeton University.

Game of Life creation: Developed in 1970 while at Cambridge University. Inspired by John von Neumann's earlier work on self-replicating automata.

Design criteria: Conway wanted rules that were: (1) simple, (2) unpredictable, (3) allowed growth, (4) allowed death, (5) nontrivial patterns possible.

Cultural impact: One of first examples of "emergence" in popular culture. Early computer game (predates Pong). Inspired generations of programmers and mathematicians.

Cellular Automata Theory

🔬 Mathematical Foundations

Definition: Discrete model studied in computability theory, mathematics, physics, complexity science, theoretical biology...

Components:

Grid: Regular lattice of cells
States: Finite set (for Life: {0,1})
Neighborhood: Cells that influence each cell (Life: Moore neighborhood of 8)
Rule: Function from neighborhood states to new state

Wolfram's Classes (1984):

Class 1: Evolve to homogeneous state (still lifes)
Class 2: Evolve to simple separated periodic structures (oscillators)
Class 3: Evolve to chaotic aperiodic patterns (chaotic soups)
Class 4: Evolve to complex localized structures including propagating structures (Life: gliders, guns)

Life is Class 4: Capable of universal computation, most interesting behavior.

Sonification & Audification

👂 Hearing Data

Definition: Use of non-speech audio to convey information or perceptualize data.

Related concepts:

Audification: Direct playback of data as sound (e.g., seismic data)
Parameter mapping sonification: Map data dimensions to sound parameters (Life: position→frequency, density→amplitude)
Model-based sonification: Data drives sound model (Life: cellular automata as sound generator)
Auditory display: Using sound for data representation

Life sonification approaches:

Direct mapping (this plugin): Cells→tones, simple and intuitive
Statistical sonification: Map population statistics to sound parameters
Pattern-based: Recognize patterns, assign musical motifs
Interactive: User explores space, hears corresponding patterns

Benefits for Life: Makes abstract patterns concrete, reveals temporal structures, engages multiple senses.

Related Work & Extensions

OTHER CELLULAR AUTOMATA SONIFICATION PROJECTS: 1. CELLULAR AUTOMATA MUSIC (1980s-): • Yoichiro Kawaguchi: "Growth Model" series • Peter Beyls: CA music composition systems • Eduardo Miranda: "Cellular Automata Music" (2001) 2. GAME OF LIFE SPECIFIC: • "Life Music" projects (various) • MIDI implementations (map cells to notes) • Real-time visual+audio installations 3. EXTENSIONS OF THIS IMPLEMENTATION: Possible enhancements: • Different rulesets (Seeds, HighLife, etc.) • 3D cellular automata (3D visualization+sound) • Continuous cell states (grayscale→amplitude) • Interactive pattern editing during evolution • Networked multiplayer Life with sound • Genetic algorithm evolution of interesting sounds 4. PRAAT-SPECIFIC EXTENSIONS: Could integrate with: • Praat's synthesis capabilities (formants, filters) • Praat's analysis (extract features from evolution) • Praat's scripting for batch generation • Praat's object-oriented programming for modular design PHILOSOPHICAL DIMENSION: Life sonification raises questions about: • Nature of computation and its perception • Relationship between simple rules and complex experience • Cross-modal perception (seeing vs. hearing patterns) • Aesthetics of algorithmic processes

What this does

🎮 Conway's Game of Life (1970)

Quick start

Game of Life Theory

Conway's Rules (B3/S23)

⚙️ The Simple Rules of Complexity

Pattern Classification

🔍 Categories of Life Forms

Computational Significance

🧮 Turing Completeness

Visualization System

Sonification Method

🎵 From Cells to Sound

Frequency Mapping Algorithm

Amplitude & Envelope Design

Audio Generation Process

Spatial Audio Processing

Complete Sonification Pipeline

Pattern Library

📚 Classic Game of Life Patterns

Simple Patterns

Complex Oscillators

Moving Patterns

Pattern Details & Setup

Parameter Reference

Applications

Algorithmic Music Composition

Educational Demonstrations

Generative Art & Installations

Data Sonification

Practical Workflow Examples

🎵 Minimalist Composition

🏫 Classroom Demonstration

🎨 Generative Sound Design

Advanced Techniques

Troubleshooting Common Issues

Performance Optimization

Technical Implementation Details

Cell Data Structures

Toroidal Edge Handling

Formula String Construction

Visual-Audio Synchronization

Historical & Theoretical Context

John Horton Conway (1937-2020)

🧮 The Mathematician Behind Life

Cellular Automata Theory

🔬 Mathematical Foundations

Sonification & Audification

👂 Hearing Data

Related Work & Extensions

Further Reading & Resources