Cellular Automata


Well-known member
yes, but I personally enjoy the dynamic of not having to worry about making a post that's open enough to foster a "conversation." i don't know- sometimes I enjoy reading and posting each others half-jumbled thoughts
no, me too, im just bullying, stan knows what i mean


Well-known member
i called it early... but i also am a stan fan. i like picking on him but i also make an effort to understand him and interact. even though he always ignores me or patronises me
The individuation of the cell depends on the immediate environment, such as the molecular signals received from outside a given cell. So as cells propagate across space, across a differential molecular stew, so does their individuation itself differentiate.

I remember seeing this explained in detail regarding the cells that comprise the invaginations along the colon tissue wall, how the cells at the bottom of the invagination/trough are able to replicate because of molecular signals sent by neighboring cells, and as they replicate they get pushed up away from the trough. These signals were less frequently received as the cell is pushed up to the protrusion/crest of the colon wall, and at a certain point it was out of reach of this molecular signal and it would just die and flake off into the colon's lumen, to be dispensed anally I believe.
Last edited:
Contextually differentiated individuation of subsystems, amounting to a heterogenous supersystem like an organ or an organism.
Starts to make a lot more sense, how we can end up with the various magnificently complex organisms throughout nature. And I'm inclined to believe it can all be programmed, eventually.
Simulating this would amount to something akin to "supercellular automata", which is semantically unfortunate because "cellular automata" alone would make better sense applying to cell-like systems, rather than unit-like unitary cells.
Last edited:


Well-known member
What strikes me is the simplicity of going between cell configurations, it always happens one by one, but looking at the current only does not tell you much, compared to patterns that emerge when tracing the past Cs.
Yeah its fascinating. As I understand it, all it takes is a certain molecule to enter the cell, and a whole expressive pathway can be blocked or enabled that wasn't expressed in the previous cells.


Well-known member
Some sonic gestures made by a PQCA Algorithm.
Not the most complex behaviour as it entirely depends on the quantum circuit that updates the cell states - meaning depending on how you set it up it's either very repetitive or very messy.
Honestly non-quantum CA implementations are years ahead in terms of advancement, there's only so much you can do with 12 bits.



Well-known member
As a part of my research I've looked at this guy (who incidentally does quantum computing now):
The fact that they have modelled the CA after chemical processes is especially interesting.
Easier to tie it together in my head than Xenakis' stochastic molecule masses, or perhaps it's the visual representation that makes me think I know what's going on.
Either way it does seem like taking physical modelling into an interesting direction.
@william_kent @wektor I just had ChatGPT write a bunch of Python code trying to create a cellular automata animation which could be parameterized (cell size, grid size, color, rules, etc) and automatically export as a GIF - and it actually worked! I had to splice together some pieces from a few of ChatGPT's attempts, but ultimately it works now:

DevoxCellularAutomataSquareV1 Small.gif
import numpy as np
import pygame
from moviepy.editor import ImageSequenceClip
import os

# define the grid size
grid_size = (100, 100)

# define the colors
bg_color = (230, 230, 250)
dead_color = (0, 0, 0)
alive_color = (230, 180, 230)

# initialize the grid with random values
grid = np.random.randint(2, size=grid_size)

# initialize pygame

# set the window size and caption
window_size = (600, 600)
screen = pygame.display.set_mode(window_size)
pygame.display.set_caption('Conway\'s Game of Life')

# define the cell size
cell_size = (window_size[0] // grid_size[0], window_size[1] // grid_size[1])

# create a list to store the frames
frames = []

# run the game loop
running = True
iteration = 0
while running and iteration < 200:
    # iterate over each cell in the grid
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # update the grid according to the rules of Conway's Game of Life
    new_grid = np.zeros(grid_size, dtype=int)
    for i in range(grid_size[0]):
        for j in range(grid_size[1]):
            # count the number of live neighbors
            neighbors = np.sum(grid[max(0, i-1):min(grid_size[0], i+2), max(0, j-1):min(grid_size[1], j+2)]) - grid[i, j]
            # apply the rules of Conway's Game of Life
            if grid[i, j] == 1 and (neighbors == 2 or neighbors == 3):
                new_grid[i, j] = 1
            elif grid[i, j] == 0 and neighbors == 3:
                new_grid[i, j] = 1

    # update the grid
    grid = new_grid

    # clear the screen

    # draw the cells
    for i in range(grid_size[0]):
        for j in range(grid_size[1]):
            color = alive_color if grid[i, j] else dead_color
            pygame.draw.rect(screen, color, (i*cell_size[0], j*cell_size[1], cell_size[0], cell_size[1]))

    # update the display

    # add the current frame to the list
    surf = pygame.surfarray.make_surface(np.transpose(np.array(pygame.surfarray.array3d(screen)), (1, 0, 2)))
    surf_arr = np.array(pygame.surfarray.array3d(surf))

    # print the current iteration
    print('Iteration:', iteration)

    # increment the iteration counter
    iteration += 1

# Create the GIF
clip = ImageSequenceClip(frames, fps=10)