Abstract

This work is an audiovisual piece built on an original cellular automaton designed by Kazuhiro Tanimoto to produce complex behavior. By running a cellular automaton program, one of the representative models in ALife (Artificial Life), the work continuously generates visual and audio change in real time as a computational result of ongoing interactions among multiple elements.
In many visual works, including those produced with AI generation, the creator often defines in advance the image they want to show, shapes the output toward that target, and then presents the result as fixed data. In this work, what the artist designs is not a predetermined image, but local rules at the pixel level: an algorithm. The rendering proceeds through the real-time iterative execution of that algorithm, and diverse phenomena not intended in advance by the artist continue to arise from interactions among elements and keep changing over time.
What is attempted here is not to fix a meaning, claim, or interpretation in advance as the work itself. Rather, the work consists in designing computational rules—such as how neighborhoods are defined, how multiple species relate to one another, how vitality operates, and how image and sound are linked—and in presenting a bottom-up, dynamic generative system in which change continues to emerge from their interaction.

ALife and Cellular Automata

ALife (Artificial Life) is a research approach that seeks to understand what life is by actually constructing and running artificial systems. What matters here is not whether something merely looks biological, but how interaction, self-organization, change, persistence, and unexpected behavior can arise.
Cellular automata are one of the representative models in ALife. They are computational systems in which cells arranged on a grid are updated according to the states of neighboring cells. There is no central controller supervising the whole system. Through repeated application of local rules, complex phenomena such as order, collapse, cycles, and growth can appear, and as a result, behavior that seems life-like may emerge.
The best-known cellular automaton is John Conway’s Game of Life (1970). In the Game of Life, each cell has one of two states, alive or dead, and its next state is determined by the number of live cells around it. From these simple conditions, one can observe stable forms, periodically oscillating forms, and forms that move across space.

Today, cellular automata are used in a wide range of technical fields, including fluid simulation, the formation of material microstructures, models of urban growth, traffic-flow analysis, and simulations of wildfire spread. At the same time, they have long been explored as a medium of expression. Their use extends beyond digital works into sculpture, textiles, architecture, and other forms involving physical materials and space. Cellular automata have also been investigated not only as a means of generating visuals, but also as a mechanism for producing sound and music.

About This Work

This work is an audiovisual piece built on an original cellular automaton designed by the artist to produce complex behavior. What is used here is not a reproduction of a classical cellular automaton such as the Game of Life. The main features of its rule system are as follows:
Neighbor cells are not limited to immediate one-cell surroundings such as Moore or von Neumann neighborhoods; instead, they are chosen at the initial parameter-setting stage either randomly or according to a pattern.
Multiple species are defined with different neighborhoods, and relations among species include differences such as attack, assimilation, and indifference.
Each cell has a vitality parameter, and that vitality increases or decreases through behavior, affecting outcomes in conflicts among species.
Through repeated application of these local rules, the work attempts to create a system that shows a greater range and complexity of behavior than conventional cellular automata. As a result, patterns emerged that

include organic, upwelling motion, linear and inorganic motion, and various configurations woven from the interaction of these tendencies. In addition, this work periodically injects simple geometric forms from outside into this system of microscopic behavior, much like dropping paint onto a canvas. The inserted shapes immediately begin to function as part of the cellular automaton itself, and through local interactions with their surroundings, they break apart, proliferate, and transform into other patterns. What the viewer observes, therefore, is not simply the external input itself, but how that input is transformed within the system and unfolds into the overall image.
In the audio, changes in the cells are detected, and sound is generated by varying frequency and other parameters according to hue, brightness, and saturation. In this way, an ambient soundscape corresponding to the visual changes is produced. The changes taking place on screen thus appear not only visually but also aurally, linking image and sound as products of the same generative process.
At the start of each run, the work determines the neighborhood settings and various parameter sets involved in the generation of both image and sound, and the algorithm is then iteratively executed in real time according to those settings. When the work is run again, a different parameter set is selected. Even though the program itself remains the same, generation begins under different conditions and produces different results. Rather than watching a fixed video playback, the viewer encounters a process in which image and sound are updated on site through computation.
In this sense, what is being attempted here is not to fix meaning, claim, or interpretation in advance as the work itself. The aim is to construct and present a bottom-up, dynamic generative system by designing computational rules—how neighborhoods are defined, how multiple species relate, how vitality functions, and how image and sound are linked—from whose interaction change continues to emerge. Through this method, the artist seeks to examine what forms of expression are possible precisely because they are produced by a computer: not forms whose final shape is directly decided by a human, but forms that arise through repeated computation and interaction among elements.

Note: AI and ALife

AI (Artificial Intelligence) and ALife (Artificial Life) can both generate outputs on a computer and may therefore seem similar at first glance, but their methodologies differ substantially.
AI is in fact a very broad research field. However, what is commonly referred to today as “generative AI” often means output systems built with machine learning, especially large deep-learning models trained on large-scale datasets, sometimes with file sizes of several gigabytes. These systems optimize outputs based on given data, objective functions, and evaluation criteria. In that sense, humans specify from above the direction of “what kind of output is desired,” and the generation process itself becomes highly top-down. Moreover, in many cases the internal representations and decision processes of such systems are difficult for humans to interpret, making them effectively black boxes.
By contrast, the classical ALife-like systems discussed here belong to a position that tries to synthesize life-like behavior and self-organization through repeated local interactions. The designer explicitly specifies the states of elements, update rules, and the range of interaction, then observes how the behavior of the whole emerges through iteration of those local rules. Accordingly, from the standpoint of rule description, the degree of black-box opacity is generally very low, and the program code that describes the rules is relatively small, for example on the order of several kilobytes to several tens of kilobytes.
That said, the fact that the rules are explicit does not necessarily mean that the results are predictable. On the contrary, one of the distinctive features of ALife is that the whole behavior arises from the accumulation of local rules rather than being directly imposed from above. In that sense it is profoundly bottom-up. When multiple explicitly designed mechanisms interact, and when probabilistic elements are deliberately introduced into the initial parameter settings, each execution can produce different patterns and dynamics not anticipated by the author. In this sense, unpredictability in ALife arises not primarily because “the internal process is too difficult for humans to interpret,” but because “the process is clear while the overall behavior arises as a result of accumulated local interactions.”
At the same time, it is increasingly difficult today to draw too simple a binary distinction between the two. In recent years, research has progressed on systems such as neural cellular automata, in which the local update rules of a cellular automaton are represented by neural networks and learned through machine learning.

Note: Small Systems

At present, I am drawn to the fact that complex behavior can arise from small systems. Perhaps this is because I find it more surprising when unexpectedly diverse change emerges from a compact description than when complexity comes from a vast system. This is not a claim about correctness or superiority; it is simply a choice in artistic practice about which scale of system to focus on.
To restate the earlier example in terms of file size: a size of several tens of kilobytes roughly corresponds to several tens of thousands of alphabetic characters, whereas a size of several gigabytes corresponds to several billions of characters. A size of several tens of kilobytes is small enough that the program itself can be written directly onto a blockchain.
One point should be noted here. When we create a program to run on a computer, the file size of that program does not contain everything. Beneath it are many large foundational layers such as the browser, graphics drivers, various libraries, and the operating system, so one cannot speak of the size of the entire system solely from the size of the program file. At the same time, one could also say that these lower layers have become large precisely because they contain vast general-purpose functionality.
In fact, the core algorithm of this work can be ported and run on a microcontroller with extremely limited memory and processing capacity, and it has been exhibited as an LED-panel work. By contrast, porting a large deep-learning model to such a microcontroller would not be realistic. This portability indicates, at the very least, that the core computation of this work runs in a small configuration. Of course, questions remain, such as at which layer one judges something to be large or small, or whether a deep-learning model could in principle be implemented on a microcontroller if simplified to an extreme degree. Even so, I believe it is still reasonable to describe this as a relatively small system, at least in the sense that it can be ported as a small mechanism without losing practical functionality.

Note: Extended Cellular Automaton

Cellular automata have a long research history, and many kinds of cellular automata have been proposed and studied. As a result, there are also many possible axes of classification. From several such perspectives, this work can be classified as follows:

• 1D / 2D / 3D: It is a two-dimensional cellular automaton.
• Square lattice / non-square lattice: The cells are arranged on a simple square lattice, not on triangular or hexagonal cells.
• Moore neighborhood / von Neumann neighborhood / extended neighborhood: It does not use a fixed Moore or von Neumann neighborhood. Instead, it uses an extended neighborhood determined at the start of execution. The neighborhood configuration is set initially either randomly or according to a pattern, but once set, the update dynamics themselves are deterministic.
• Totalistic / non-totalistic: Rather than deciding by the sum of neighboring values as in the Game of Life, it is non-totalistic, directly evaluating specific surrounding patterns.
• Synchronous / asynchronous: It is synchronous, updating states simultaneously.
• Binary / multivalued / continuous: Since color and vitality are stored as finite discrete 8-bit values, it is multivalued, or multi-state.
• Deterministic / probabilistic: Probabilistic random numbers are used to determine the initial parameter set, but the update rules themselves contain no probabilistic component and are deterministic.
• Single-layer / multi-layer: It is a single-layer system without multiple layers of state fields.
• Single-species / multi-species: It is a multi-species system in which multiple species coexist and exhibit different behaviors.
• Uniform / non-uniform: Although it contains multiple species whose behaviors differ, the rules do not depend on cell position itself. The same update rule is applied to all cells, with branching inside the rule according to species, so it is uniform.
• Reversible / irreversible: Since the previous state cannot be uniquely reconstructed from the current state, it is irreversible.

Compared with narrowly defined classical cellular automata, this work preserves basic features such as a two-dimensional square lattice, synchronous updating, and uniform rules, while also incorporating an extended neighborhood, multi-species interaction, and non-totalistic evaluation rules. For that reason, it is appropriate to describe it as a generalized or extended cellular automaton.

Note: Cellular Automata, Pixel Sorting, and Distortion

Cellular automata, pixel sorting, and distortion can sometimes look similar at first glance because all of them produce change on a grid of pixels. In particular, when pixels appear to move to neighboring positions, or when patterns seem to proliferate, flow, or collapse on screen, all of them may look like “processes acting on neighboring pixels.” Technically, however, the central computation in each case is different.

• The computational core of a cellular automaton is deciding the next state of each cell from the states of neighboring cells and a rule. It reads the current cell and surrounding cells, then generates the next state from their relation. What matters is not how the pixels look, but that the system is centered on rules of state update.
• The computational core of pixel sorting is reordering pixels using pixel values as keys. It sorts pixels within rows, columns, segments, or masked areas based on brightness, hue, RGB values, or similar criteria. The result may look like flow or dragging, but the core operation is not “generation of the next state” but “rearrangement of existing pixels.”
• The computational core of distortion is shifting UV coordinates or reference coordinates to change from which position a pixel is read. Visually, pixels may appear to move to neighboring positions, but the central operation is not “a rule that decides the next state from neighboring states.” It is resampling through shifted readout positions.

In other words, “moving toward a neighborhood” and “deciding the next state from neighborhood states” are not the same thing. Cellular automata are characterized primarily by temporal state update, pixel sorting by the reordering of sequences of elements, and distortion by resampling based on coordinate mapping. This framework is useful for clarifying the differences in what each of these operations acts upon.
This distinction can also be organized from the standpoint of how patterns are generated. In cellular automata, the overall pattern arises from the accumulation of local neighborhood rules, so they have a strongly bottom-up character. By contrast, pixel sorting rearranges pixels according to a higher-level processing framework such as the processing range, direction, and sorting key, making it relatively more top-down. Distortion can also be described as relatively top-down when it depends strongly on externally given coordinate controls such as noise fields, masks, vector fields, control textures, or time functions. However, when local reference to the previous state and feedback are strong, distortion can also take on bottom-up characteristics.