More selected projects

Cellular Orchestra

Cellular Orchestra is a coming together of sound and light making creatures, communicating with each other and responding to their own portion of communally generated patterns.

by Harry Morley

Overview & Concept

I was initially inspired by the work of Till Bovermann of TAI Studio, particularly his work "Fielding" which explores the idea of interspecies music, and nonhuman performers. Aesthetically, I liked Till's simple wooden box designs, particularly how they seem to fit in amongst the trees and nature. This, coupled with Jane Bennett’s writings on “thing power” and “vibrant matter” inspired me to create a work consisting of nonhuman performers, a happening of things which come together to interact, but not with humans.

I also have a fascination with cellular automata, and how the simplest of rules can form chaotic and complex structures. So, for this project I decided to stay simple and constrained and use just a 1D automaton, running on Arduino Nanos, visualised using LED matrixes and sonified.

At the start of the summer, I began experimenting with making sound on the Arduino, using the Mozzi library. This allows you to generate sound on a per-sample basis, and utilise different waveforms, envelopes and filters. The audio is outputted from pin 9, at a sample rate of 32kHz and bit depth of 12.


Each box contains:

  • Arduino Nano
  • 8Ω speaker driver
  • PAM8403 audio amplifier circuit board
  • 32x8 LED matrix driven by MAX7219 chips
  • 220Ω resistor and 100nF capcitor as a low-pass filter, to improve audio quality
  • 2 capacitors (220uF and 100uF) in parallel, across 5V and GND of the LED matrixes, to filter out the interference.


I aimed to use as little and as cheaply available parts as possible for the technical setup, which worked very well, however I did face the following challenges:

  • Noise interference from the LED matrixes - causing a noticeable whine to come out of the speakers. This was improved by placing capacitors in parallel across the 5V and GND of the LED matrixes, to filter the noise.
  • Audible PWM carrier frequency - another whining noise - this however was easily fixed by making a simple low-pass filter with a resistor and capacitor, as per Tim Barrass's tutorial on the Mozzi website.
  • 2kb RAM limitation of the Arduino Nano - I was limited with the amount of wavetables I could store on the Nano, so the sound was fairly restricted. Also, originally I was storing the cell states as booleans, but each boolean on an Arduino by default takes up one byte of storage, which is inefficient since a boolean is 1 bit of data. To improve this, I stored 8 booleans in 1 byte using the bitWrite() and bitRead() functions. For example, 11010011 in binary is 211 in decimal, but is also 8 boolean states.


  • gallery-image
  • gallery-image
  • gallery-image
  • gallery-image


The creatures of the Cellular Orchestra each generate a 32 pixel wide portion of the same elementary cellular automaton. It is 1-dimensional, so 1 line of cells is generated at a time (every second, in fact). The creatures store 8 previously generated lines, so we can observe the 2D patterns unfolding or the stories being told. 

An elementary cellular automaton works by reading from left to right the current state each cell and its left and right neighbours. This pattern of 3 cells is checked against the rule of the automaton - in the case of Cellular Orchestra, rule 30. The rule corresponds to the binary representation of it, i.e. 00011110. The following table shows how the state of each new cell is generated, based on the 3 cells above it:

There are different rulesets, each one producing different kinds of patterns, but rule 30 is known for its chaotic properties. Triangular shapes and line streaks appear in an unpredictable yet organic fashion. In nature, surprisingly or unsurprisingly, similar textures can be observed, for example on certain types of cone snails.


To make the boxes generate a continuous pattern, after every generation each box pushes their leftmost and rightmost state onto the network. For example, if each creature outputted 8 cells at a time (rather than the actual 32 used in my project), 1 possible generation might look like this.

Creature number:       0               1                 2                3

Pattern:               [10010111][00011011][10111010][01010001]

For creature 1 to get the left neighbour of its first (leftmost) cell, it requires the rightmost cell of creature 0. Therefore every generation each creature sends its leftmost and rightmost cells onto the network. The messages are sent in the form [ID number] + [leftmost cell] + [rightmost cell], encoded as a byte. For example, the message 00100011 means that device with ID 0010 (i.e. 2) has a 1 for both its leftmost and rightmost cells.

The Arduinos are connected in a serial ring network as per the diagram below. If an Arduino receive a message, it uses the data if it has come from a neighbouring creature, then sends it on in case any other creature requires it. If it receives its own message, then that means the message has come full circle, so the message is ignored and not sent on.


The edge-jointed boxes were designed using and Adobe Illustrator, and laser-cut in the HatchLab. I ‘finished’ the pieces of wood by sanding them using a relatively fine-grit paper. This was to remove the burn marks and prepare the surface for staining. I then stained the pieces using just one coat of light wood stain. I wanted the boxes to look as natural as possible, with visible grain, but still with an element of neatness about them. The desire for a natural finish was to emphasise the “coming together” and “happening” nature of the creatures, how they were assembled with fairly minimal though still thoughtful human design work, ran low level code and played raw sounds. The shells were added to the piece to reflect the shell-like textures displayed on the LEDs, to question the in/animacy of things and to play with scale.

  • gallery-image
  • gallery-image
  • gallery-image

Loosely inspired by Luigi Russolo's Intonarumoris, from the Italian futurist movement, I tried to categorise and characterise the boxes to give them individual voices. The result hopefully would then be a nonhuman symphony, or speculative soundscape.

  • Creature 1 "crackle" - low frequency sawtooth wave, with its pitch mapped to the population of its live cells. Creates a continuous popping sound.
  • Creature 2 "wash" - slow modulating filtered noise, to provide sea-like ambience. Also emits sine wave "bloop" sounds when a large triangle is present.
  • Creature 3 "brash" - emits ringing noise bursts when a large triangle is presents.
  • Creature 4 "quiet one" - plays a glitchy, gated sine wave tone, also mapped to population. This creature is quiet because its amplifier failed on the day before the exhibition, therefore the output from the Arduino is wired directly to the speaker. It could be heard, but only when the other 3 were not sounding.
Evaluation & future

Overall, I was pleased with how my piece functioned and looked. The modular nature means that more boxes can be added in the future, as they join up to make the same automaton. I was less happy with the sound, and I think I should have spent more time on the sonification process. I spent too much time obsessing over the functioning of the system and worrying about the physical form of the project, meaning the actual sounds of the creatures were left to the last couple of days. I felt like I wanted the system to be complete before starting on the output, but I should have been experimenting with making more complex, interesting sounds from day one. That being said, the sound is interesting if you listen deeply, and I did not really know what I wanted to make until the last moment - it really was a sudden happening of things.

To develop the work further, there is the question of adding interactivity. Firstly, interactivity can be extended amongst the creatures themselves; they could send different kinds of messages to each other depending on their state. It might also be interesting to try running different cellular automata with different rules on each creature, and think of ways the automata can collide and affect one another.

Once my boxes were constructed, updating the code on the Arduinos was a painstaking process - I had to disconnect the entire network so that the serial TX/RX ports would not interfere with the USB. I would also like to try using WiFi-enabled boards, such as an ESP32, to be able to program the creatures remotely so I can place them apart in space and modify the sonification on-the-fly. Not a Raspberry Pi though - I like the simplicity (or rather, enough complexity) of using a small chip at the heart of the creature, and it also keeps the cost down.

Source Code

Available at


The Force of Things: A Step Toward An Ecology of Matter by Jane Bennett

MAX7219LedMatrix library by Daniel Eichhorn (simplified and adapted to suit the rotation of my matrixes)

Mozzi library by Tim Barrass

Rule 30, Wikipedia entry, the work of Till Bovermann


Special thanks to all of my wonderful friends for the encouragement and the good times, and all of the inspirational lecturers on the course. Thanks to Irini for being my neighbour!

  • gallery-image
  • gallery-image
  • gallery-image