A simulation of the brain activity of an electric sheep: it dynamically combines some of the best paintings ever created.

The memory evolves and the combinations are endless and unique. With a little bit of patience, weird artistic “anachronisms” can arise: an old japanese boat sailing in Venice, a sleeping hawaiian in front of Plato and Aristotle, a clock near the animals in a prehistoric cave …

The animation was exhibited at PDC@Coimbra 2021 a Processing Community Day initiative supported by the Processing Foundation with the goal of celebrating art, code and diversity while promoting creative coding and computational thinking as tools for creative students, researchers and professionals. The theme of the exhibition was “Anachronism”.

The soundscape is purely generative (made in VCV Rack).

Asemic Writing is a wordless open semantic form of writing. The word asemic means “having no specific semantic content”, or “without the smallest unit of meaning”. With the non-specificity of asemic writing there comes a vacuum of meaning, which is left for the reader to fill in and interpret. …. Asemic writing is a hybrid art form that fuses text and image into a unity, and then sets it free to arbitrary subjective interpretations. …

Inspired by a challenge launched by Robert Boran on the Facebook group Creative Coding with Processing and P5.js I created a Processing sketch that simulates an Asemic Writing. The technique is based on a sequence of eight random “words” that alternates randomly; each “word” is a combination of “elliptic oscillators” that follows the rectlinear movement of the (hidden) pen on the page.

The animation is accompained by a simple purely generative soundscape made with VCV Rack and Native Instruments Absynth VST.

This is the final result.

As soon as I clean-up a little bit the code (actually a mess) I’ll publish it here and add more details.

In a previous post (see here) I talked about “The world’s ugliest music”, a composition made by Scott Rickard using some math techniques in order to minimize the repetitions and the predictability of the sequence of notes. I also made my personal interpretation of the piece using a synthesizer and VCV Rack.

Then I launched a “challenge” on the VCV Community site asking VCV users to give their own interpretation of the ugliest music in an “sci-fi alien context” starting from the MIDI file or a small VCV template with the sequence. Many users accepted the challenge and created very interesting patches (and accompaining videos) … surely if put together they well represent THE UGLIEST ALBUM: The Alien Ping.

Recently I saw a TEDx video by Scott Rickard about “The world’s ugliest music”; and I suggest you to watch it.
Usually good music is characterized by a balance between repetition and variation, applied to one or many of the components of the music itself: melody, texture, rhythm, form, and harmony. So what happens if we try to completely remove the repetitions?

In Scott’s music a math formula is used to generate all the 88 notes of a piano and their duration: starting from value 1, the next value is generated multiplying by 3 the previous one. If the value exceeds 88 then 89 is repeatedly subtracted until the value falls back in the 1-88 range:

1, 3, 9, 27, 81, 243–>154–>65, 195–>106–>17, … and so on

The duration of the notes are calculated using a Golomb ruler : each note is placed on the timeline in a special position (“mark”) in order to avoid any recognizable rythmic pattern. Indeed in a Golomb ruler the positions of the marks are such that all distances between them are distinct. The sequence of 88 note durations (expressed in 1/16th) used in the ugliest music is the following:

You can listen to the music played on piano in the last part of the TEDx video; the title of the piece is “Costas Golomb N.1: The Perfect Ping” … and it is quite ugly. But I like creating “bleeps and bloops” on a modular synthesizer (actually I’m using VCV-Rack and a semimodular Behringer Neutron), and sometimes the results are often not really melodic … so I tried to make a patch and play the ugliest music on it.

I also made a simple sketch in Processing 3 in which the 88×88 grid (notes are from left-to-right, top-to-bottom) are displayed and a “sonar ping” is generated when each note is played.

If you want to experiment yourself you can download:

A Processing 3 sketch of four slowly evolving polygons and a meditative soundscape created by a few Tibetan Singing Bowls.

The algorithm is very simple:

place each vertex of each polygon in a random position

assign to each vertex a random direction (all polygons have the same scalar velocity)

at every frame move each vertex, if the new position is outside a border, simply make it bounce (reverse the velocity component orthogonal to the border)

assign a different color to each polygon and draw only its outer border (no fill)

This is the first post about “artisanal” sound synthesis techniques that can be used to imitate (try-to imitate 😉 ) the wonderful sounds of nature. I tried to replicate the chirping of cuckoos that in this period can be heard near my house (North Italy).

I started with a raw and noisy recording of one of them, made with the nice Tascam DR-40 recorder:

Note that the cuckoo is far away and it is barely audible in the recording.

I ampified the wav file using the free (and powerful) tool Audacity: CTRL+A to select all the sound; Effect→ Amplify , set new peak to -3dB. Then the cuckoo is audible (five chirps), though there are another bird chirping, a dog is barking and there are some noises from the road:

This is a three-part post about Conway’s Game of Life and some easy-to-implement variations that can lead to interesting visual results.

Part 1: adding colors

Part 2: extending the neighbourhood [… coming soon …]

Part 3: moving to the third dimension [… coming soon …]

Part 1: adding colors

The Conway’s Game of Life is a cellular automaton created by the British mathematician John Horton Conway in 1970. It is a theoretically infinite grid of cells; each cell can be in two states: dead ($0$) or alive ($1$). Initially the grid has a particular initial configuration (for example a percentage of the cells are set to alive). Then the cells evolve, and the state of cell $(x,y)$ at generation $N+1$ depends only on its state and the state of its eight neighbours at generation $N$. The rules are simple:

if a dead cell at generation $N$ is surrounded exactly by 3 alive cells then it willl be alive at generation $N+1$

if an alive cell at generation $N$ is surrounded by 2 or 3 alive cells, then it will stay alive, otherwise it will become a dead cell at generation $N+1$

Despite the simple rules, the Conway’s Game of Life is a Turing Complete model of computation (i.e. it can simulate any computer).

The visual configurations and the animations are also visually interesting.

A first variant can be obtained in the following way:

overlap three independent cell grids (one for each component Red-Green-Blue)

animate each grid using the standard rules, but for each cell $(x,y)$ in each grid also keep a fractional (float) value $C(x,y)$ in the range (0,1) ($C_r$ for the red grid, $C_g$ for the green grid, $C_b$ for the blue grid) and update it using the following rules:

if a cell becomes alive then add a fixed constant $v_1$ to it: $$C(x,y) = C(x,y)+v_1$$

if a cell becomes dead then subtract a fixed constant $v_0$ to it: $$C(x,y) = C(x,y) – v_0$$

render each cell $(x,y)$ with a square (or pixel) and color it according to the three RGB components values $C_r, C_g, C_b$ that it has in the three independent grids: $Red = C_r(x,y)*255$, $Green=C_g(x,y)*255$ , $Blue=C_b(x,y)*255$

This is a video that shows the resulting animation made with Processing 3 using $v_1=0.3$, $v_0=0.04$, starting from an initial random configuration:

The Processing source code can be downloaded here:

A cyclic cellular automaton (CCA) is defined as an automaton where each cell takes one of N states 0, 1,…, N-1 and a cell in state i changes to state i+1 mod N at the next time step if it has a neighbor that is in state i+1 mod N, otherwise it remains in state i at the next time step. Classically CCA are applied on the 2-dimensional integer lattice with Von Neumann neighborhoods (nearest 4 neighbors): if cell is at coordinate (x,y), the four neighbours are those at coordinates (x+1,y), (x-1,y), (x,y+1), (x,y-1).

The cells are arranged in a bidimensional grid and initially they are in a random state. At each generation a cell in state i evolves to state i+1 mod N if at least one of its neighbors is in state i+1. The color of each cell is determined by its state.

The following image is generated using Von Neumann neighborhood:

[click to enlarge]

But very interesting behaviors can also be obtained if we pick irregular/random neighborhoods.

I just bought a Behringer Neutron, a semi-modular synthesizer …

I spent more than one hour before even hearing a sound from it :-);

then I spent another hour to update its firmware;

then I started noodling with the cables without any external MIDI input …

I built my first (auto playing) patch … which – honestly – doesn’t sound too good 🙂

[click to enlarge]

Nevertheless, I decided to record it (with a poor quality smartphone) to document my first step (also the last one?!?) into real modular and this the one minute video excerpt of those bleeps and blops …

I’ll play more with the Neutron during Christmas holidays; then I’ll write my impressions on it.

The MusiFrog is a simple deterministic algorithm that can be used to produce nice pseudo-random melodies that I discovered while experimenting with generative-music (but perhaps someone else has already found it).

It is based on a frog that jumps over a sequence of stones. Each stone has a jump value and is associated with a musical note. Initially the frog is on stone 1 and suppose it has jump value X. The note associated with stone 1 is played, and the frog jumps forward X steps on stone N=1+X; the jump value of stone 1 is increased by 1. Then the note associated with stone N is played, the frog jump forward according to the jump value of the stone which is then incremented by one. The process is repeated and when the frog jumps off the last stone it “wraps-up” and return to the beginning of the sequence.