https://github.com/musadiqpasha/cellular-automata-visualizer

Cellular-Automata-Visualizer is a collection of four interactive cellular automaton simulations with real-time, color-coded grid visualizations, implemented in Python mode using Processing.
https://github.com/musadiqpasha/cellular-automata-visualizer

automata automata-simulator cellular-automata processing processing3 python3

Last synced: about 1 month ago
JSON representation

Cellular-Automata-Visualizer is a collection of four interactive cellular automaton simulations with real-time, color-coded grid visualizations, implemented in Python mode using Processing.

• Host: GitHub
• URL: https://github.com/musadiqpasha/cellular-automata-visualizer
• Owner: MusadiqPasha
• License: mit
• Created: 2025-01-13T11:07:29.000Z (3 months ago)
• Default Branch: main
• Last Pushed: 2025-01-13T14:54:16.000Z (3 months ago)
• Last Synced: 2025-01-25T16:04:42.016Z (3 months ago)
• Topics: automata, automata-simulator, cellular-automata, processing, processing3, python3
• Language: Python
• Homepage:
• Size: 74.1 MB
• Stars: 1
• Watchers: 1
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# Cellular-Automata-Visualizer

This is a collection of interactive simulations for various cellular automata models, including Amoeba, Game of Life, and more. It provides real-time visualization of the grid evolution, allowing users to explore different patterns and behaviors of these automata.

A collection of cellular automata simulations implemented using [Processing.org](https://processing.org/). To run the project, make sure to use Python mode in Processing for proper execution and visualization of grid evolution.

This project features four unique games: 

- **Amoeba**

- **Brian's Brain**

- **Game of Life**

- **Larger Than Life**

  

each demonstrating distinct rules and behaviors for cellular automata.

## Features

- **Interactive Visualization**: Dynamic, grid-based simulations with color-coded states for easy visualization.

- **Four Cellular Automata Games**:

  1. **Amoeba**: Simulates organic-like growth patterns with unique rules.

  2. **Brian's Brain**: A three-state cellular automaton with "on," "dying," and "off" cells.

  3. **Game of Life**: Conway's famous simulation of life and death based on simple neighbor-count rules.

  4. **Larger Than Life**: A generalized automaton with custom rules for more complex patterns.

## How It Works

- The grid is initialized with random states or a preset configuration.

- Each simulation computes the next generation based on its specific rules.

- Color-coded grids visually represent the changes in real time.

## Color Representation

### Default States:

- Blue: "Off" or inactive.

- White: Neutral or empty state.

  

### Dynamic States:

- Yellow: Cells being compared or in transition.

- Red: Cells marked for change (e.g., "Dying").

- Black: Cells in an active state (e.g., "On").

  

## Cellular Automata Rules

### 1. **Amoeba**

- Generates organic, amoeba-like growths and contractions.

- Simulates dynamic and organic growth patterns.

- Rules are tailored to produce self-sustaining patterns.



### 2. **Brian's Brain**

- Produces glowing wave-like patterns that resemble firing neurons.

- Each cell has three states: **On** (blue), **Dying** (red), and **Off** (white).

- Rules:

  - **Off** → **On** if exactly two neighbors are "On."

  - **On** → **Dying** in the next step.

  - **Dying** → **Off** in the subsequent step.



### 3. **Game of Life**

- A classic cellular automaton invented by John Conway.

- Each cell can be **Alive** (black) or **Dead** (white).

- Rules:

  - **Dead** → **Alive** if it has exactly three live neighbors.

  - **Alive** → **Dead** if it has fewer than two or more than three live neighbors.

  - **Alive** → **Alive** if it has two or three live neighbors.

 

### 4. **Larger Than Life**

- Behavior: Creates large, intricate patterns.

- A generalization of Conway's rules, allowing larger neighborhoods.

- Birth: A dead cell (0) turns "on" (1) if it has 3, 4, 5, 6, 7, or 8 neighbors that are "on."

- Survival: An "on" cell (1) remains "on" if it has 3, 4, 5, 6, 7, or 8 neighbors that are "on."

- Death: All other cells turn "off."

 



## Installation

1. Download and install [Processing](https://processing.org/) [use Python Mode]

2. Clone this repository or download the ZIP file:

   ```bash

   git clone https://github.com/kmusadiqpasha/cellular-automata-visualizer

3. Open the .pde files for each simulation in Processing.

4. Run the sketches and watch the cellular automata come to life!

### License

- This project is licensed under the MIT License - see the LICENSE file for details.

##

## Just follow me and Star ⭐ my repository 

## Thank You!!