Sound, Motion, Notation

Quantitative Art and the Work of Channa Horwitz

by D. Schmüdde

Information and Art

Computers are an invention like no other. They compress time and distance and their presence suggests information primacy; data may be more than a collection of facts, it may be the building blocks of the universe itself.

Artists have investigated the post-computer world in a myriad of ways. Some of the most powerful disregard the concept of "computer" and focus on a new digital aesthetic that underlines the essence of the machine. Channa Horwitz's Sonakinatography series (1968-2012) is an exemplar, perhaps because she had no formal training in mathematics or computer science, but her work embodies both.

Sonakinatography I, Composition III (1970)

Enciphering Information

The key to my work is simplicity and complexity. I have been working with the premise that any complexity can be understood in it's simplest form. In my notations I am interested in breaking through the barrier of the different arts, because they all have a common language. In these notations I am searching for some connecting link to establish a clearer reality.

~ Channa Horwitz (1974)

Sonakinatography pieces are generally created on grids that are eight spaces wide. These grids can be of any length, or repeated horizontally as they are in the image above. Note that each grid space is filled with a square or a line:

Although Horwitz was not referencing the binary computer directly, this is analogous to the way in which computers take the simplest form of information, on or off, as the foundation to model the most complex thoughts and events.


Computer instructions aren't written by humans as 1s and 0s, and neither the instructions that generate Sonakinatography. Horwitz used a combination of graphs and natural language to provide the viewer with some insight into the process. I'm going to encode her process in a computer language and ask you to make step-by-step changes. Experiencing Sonakinatography is the best way to understand it.

Don't worry, you won't need any knowledge of programming to read and interact with the rest of this article.

The first step is to recreate the basic elements of Sonakinatography, the square and the line, and display them:

Now I'd like you to change a couple simple parameters in the code below. The parameter names, color and instrument, are lifted directly from Horwitz's nomenclature. They accept values 1 through 8. Adjust each one and press the Run button to see the effects:

draw = simple_shapes({'color': 7, 'instrument': 3}, {'color': 4, 'instrument': 7})

The value of the instrument moves the object horizontally. The color adjusts according to these rules:

1. Green
2. Blue
3. Blue-Violet
4. Red-Violet
5. Red
6. Orange
7. Yellow
8. Yellow-Green

Quantitaive Art

Horwitz practiced minimalist restraint. She felt that a strict set of rules gave her more freedom to explore. A significant part of her oeuvre are permutations on an 8x8 grid. For example, And Then There Were None (1978) is a flip book based on a simple algorithm that moves the leftmost black square to the empty cell just above. It repeats on every column until there are no black squares left.

"And Then There Were None" Channa Horwitz

Quantitative art includes all artwork based on a formal system where all permutations can be exhausted. Much of this art is based on a simple rule-set with few aesthetic embellishments. Complexity is derived from the permutations.

For example, John F. Simon, Jr.'s Every Icon (1997-present) is a variation on the same theme. The version included in this article has been running since January 14, 1997, 9:00:00 pm on a 32x32 grid. Every Icon will make every black and white computer icon possible within the next several trillion years, if run continuously.

Games can also share these characteristics.

Connect Four is an adversarial game between two people who take turns sequentially. Nothing is left to chance and both players have perfect information, meaning that both players know every move that has lead to any point in the game. A player can conceivably project from that point to every possible game in the future, given enough computational resources.

"Connect Four" on the TI 99/4a

Many games featuring perfect information do not allow for a complete quantitative analysis because they are too complex. The version of Connect Four pictured above was built for the Texas Instrument 99/4a home computer in 1979. This computer opponent was one of the most sophisticated of its era and can still pose a challenge for intermediate players.

Today's expert players, however, cannot triumph over a contemporary computer opponent. John Tromp "solved" Connect Four in 1995 when he developed software capable of considering all 4,531,985,219,092 possible states regardless of the starting point, thus sketching a complete quantitative picture of the game.


Beats and Instruments

Horwitz uses musical terms when laying out the grid. In Sonakinatography I, Composition III, instruments 1-8 line the x-axis while beats line the y-axis starting at 1. Beats progress indefinitely in whole number intervals.

With the terminology in hand - beats, instruments, and colors - we can read the key Horwitz provides on the artwork itself:

Each instrument follows the number and color grid in a vertical direction forward & backward repeating for desire time duration

     NUMBER GRID - 2 3 4 5 6 7 8 1                                                                                                                                                            
                   3 4 5 6 7 8 1 2                                                                                                                                                            
                   4 5 6 7 8 1 2 3                                                                                                                                                            
                   5 6 7 8 1 2 3 4                                                                                                                                                            
                   6 7 8 1 2 3 4 5                                                                                                                                                            
                   7 8 1 2 3 4 5 6                                                                                                                                                            
                   8 1 2 3 4 5 6 7                                                                                                                                                            
                   1 2 3 4 5 6 7 8                                                                                                                                                            
                   | | | | | | | |                                                                                                                                                            
    INSTRUMENT # - 1 2 3 4 5 6 7 8                                                                                                                                                            
                   L             H                                                                                                                                                            
                   O <---------> I                                                                                                                                                            
                   W    SCALE    G                                                                                                                                                            

The "number and color grid" is what determines where to place each square and what color it should be. The algorithm starts on the bottom row of the number grid: 1 2 3 4 5 6 7 8.

Reading from left to right on the number grid, 1 - Green is placed in the first beat of Instrument #1. 2 - Blue is placed on the second beat of Instrument #2:

Sonakinatography: The First Two Beats

When an instrument of any row places a color, it moves onto the next color on the number grid. In the case of Instrument #1, the color above 1 on the number grid is 8 - Yellow-Green. In the case of Instrument #2, the color above 2 is 1 - Green. After nine beats, the state of the algorithm looks like this:

     NUMBER GRID - . . . . . . . .                                                                                                                                                            
                   . . . . . . . .                                                                                                                                                            
                   . . . . . . . .                                                                                                                                                            
                   . . . . . . . .                                                                                                                                                            
                   . . . . . . . .                                                                                                                                                            
                   . . 1 2 . . . .                                                                                                                                                            
                   8 1 2 3 4 . . .                                                                                                                                                            
                   1 2 3 4 5 6 7 8                                                                                                                                                            
                   | | | | | | | |                                                                                                                                                            
    INSTRUMENT # - 1 2 3 4 5 6 7 8   

The resulting image:

Sonakinatography: The First Nine Beats

8 - Yellow-Green can be observed at beat nine of Instrument #1. 1 - Green is placed at beat three of Instrument #2.

Horwitz's simple combination of beats, squares, and rests (non-squares) modestly obscures the expressive power held within. Sonakinatography I, Composition III is a form of notation that has been directly expressed in the mediums of dance, installation art, and music. Its flexible design and graph-like layout unintentionally anticipated computer software of the 1980s, further validating Horwitz's approach to making art.

Beats and Instruments in Music

Avid Protools 9

Nearly all new music, from movie soundtracks to popular music, is recorded and arranged in a format similar to the one pictured above. Instruments line the y-axis while beats line the x-axis. Engineers lay the track out by moving colorful squares around a gird.

This way of arranging music arrived in 1989 with the release of Cubase 1.0 by Steinberg Media Technologies GmbH on the Atari ST. The similarities to Sonakinatography are likely incidental, but also undeniable. In the two decades since Horwitz's initial investigation into the visual depictions of algorithms in time, computation moved from research and government institutions and into the home. This created a world where hundreds of millions of people had some experience with a computer and the type of thinking required to operate the machine. Cubase leveraged this conceptual change and the visual power of the Atari ST to drive a new kind of notation that has become the standard for music production.

Horwitz's art is an acknowledgment of how the digital world changes our processes, which in turns changes how we think and what we value. She saw that this notation is more than visual art, but a way of thinking: In my notations I am interested in breaking through the barrier of the different arts, because they all have a common language. The language i use in my notations is applicable to some aspect of each of the arts. In these notations I am searching for some connecting link to establish a clearer reality.

Variations on a Theme

The musicality of Sonakinatography can perhaps best be appreciated when set in motion. Play the animation below and then we will create our own variations on Horwitz's original work:

Shift+Enter to run
<div id="sk-demo">
  <div id="sk-scroll">
    <div id="sk-replay">🔁 Replay</div>
    <div id="sk-wrapper">
      <canvas id="sk" width="160"></canvas>
      <div id="sk-play">▶️</div>
  <div id="sk-legend">
    <ul id="sk-instrument-labels">
      <li class="instrument-label">1</li>
      <li class="instrument-label">2</li>
      <li class="instrument-label">3</li>
      <li class="instrument-label">4</li>
      <li class="instrument-label">5</li>
      <li class="instrument-label">6</li>
      <li class="instrument-label">7</li>
      <li class="instrument-label">8</li>
    <div id="sk-legend-label" class="instrument-label">
  <div id="sk-beats-label">Beats</div>

  const colors = [
    "rgb(0, 204, 0)", // yellow green
    "rgb(0, 102, 0)", // green
    "rgb(0, 0, 255)", // blue
    "rgb(127, 0, 255)", // blue violet
    "rgb(153, 0, 153)", // red violet
    "rgb(204, 0, 0)", // red
    "rgb(255, 128, 0)", // orange
    "rgb(255, 255, 0)" // yellow
  var gridObjects = [0,1,2,3,4,5,6,7].map(function(n) {
    return { countdown: n + 1, color: n, instrument: n }
  const squareSize = 20;
  const lineWidth = 3;
  const maxBeats = 200;
  const visibleBeats = 12;
  var canvas = document.getElementById("sk");
  var ctx = canvas.getContext("2d");
  var beat = 0;
  var scrollEl = document.getElementById("sk-scroll");
  var wrapperEl = document.getElementById("sk-wrapper");

  canvas.setAttribute("height", squareSize * maxBeats);

  while (beat < maxBeats) {
    beat += 1;
    const beatLabel = document.createElement("div");
    beatLabel.className = "beat-label";
    beatLabel.innerHTML = beat; = (beat - 1) * squareSize + "px";
    wrapperEl.appendChild(beatLabel); {
      instrument.countdown -= 1;
      var x = squareSize * instrument.instrument;
      var y = maxBeats * squareSize - beat * squareSize;
      ctx.fillStyle = colors[instrument.color];
      if (instrument.countdown === 0) {
        ctx.fillRect(x, y, squareSize, squareSize);
        if (instrument.color === 0) {
          instrument.color = 7;
        } else {
          instrument.color -= 1;
        instrument.countdown = instrument.color + 1;
      } else {
        x = x + squareSize / 2 - 2;
        ctx.fillRect(x, y, lineWidth, squareSize);

  const easeInOutQuad = function (t, b, c, d) {
    t /= d / 2;
    if (t < 1) return c / 2 * t * t + b;
    return - c / 2 * (t * (t - 2) - 1) + b;

  function scrollTo(el, to, duration) {
    var start = el.scrollTop,
        change = to - start,
        currentTime = 0,
        increment = 20;
    var animateScroll = function() {
      currentTime += increment;
      var val = easeInOutQuad(currentTime, start, change, duration);
      el.scrollTop = val;
      if (currentTime < duration) {
        setTimeout(animateScroll, increment);

  function animate() {
    scrollEl.scrollTop = scrollEl.scrollHeight;
    scrollTo(scrollEl, 0, 10000);
  scrollEl.scrollTop = scrollEl.scrollHeight;
  document.getElementById("sk-play").addEventListener("click", animate);
  document.getElementById("sk-replay").addEventListener("click", animate);
  #sk-demo {
    width: 260px;
    padding-left: 20px;
    position: relative;
  #sk-scroll {
    height: 240px;
    width: 240px;
    overflow: auto;
    padding-bottom: 240px;
    background: white;
    box-sizing: border-box;
    position: relative;
    border: 1px solid #ddd;
  #sk-play {
    font-size: 40px;
    position: absolute;
    bottom: -180px;
    left: 50%;
    cursor: pointer;
    transition: all 0.2s ease;
    transform: translate(-50%, -50%);
  #sk-play:hover {
    transform: translate(-50%, -50%) scale(1.1);
  #sk-wrapper {
    position: relative;
    padding: 0 40px 0 60px;
  #sk-replay {
    font-size: 9px;
    font-family: Menlo, monospace;
    color: #666;
    line-height: 20px;
  .beat-label {
    position: absolute;
    text-align: right;
    width: 30px;
    height: 20px;
    left: 0;
    padding-right: 10px;
    margin-bottom: 4px;
    border-right: 1px solid #ddd;
  #sk-legend {
    align-items: center;
    width: 240px;
  #sk-instrument-labels {
    list-style: none;
    padding: 0 0 0 60px;
    margin: 0 0 0 0;
    display: flex;
    align-items: center;
    border: 1px solid #ddd;
    border-top: none;
  .instrument-label {
    margin: 0;
    height: 20px;
    line-heigiht: 20px;
    width: 20px;
    text-align: center;
  #sk-legend-label {
    width: 100%;
  #sk-beats-label {
    transform-origin: center center;
    transform: rotate(-90deg) translateY(-110%);
    position: absolute;
    top: 50%;
    margin-top: -20px;
  #sk-replay {
    height: 30px;
    line-height: 32px;
    font-size: 13px;
    text-align: center;
    border-bottom: 1px solid #ddd;
    width: 100%;
    cursor: pointer;
    transition: all 0.125s ease;
  #sk-replay:hover {
    font-size: 15px;

Horwitz's algorithm is recreated in this article and easily modified. I'll start by introducing the interface:

code interface - please change x, y, and z

Now we'll expand what's possible:

chage a, b, c

And now the entire piece:

def reset_instrument(instrument):
  if instrument['color'] == 1:
    instrument['color'] = 8
    instrument['color'] -= 1
  instrument['countdown'] = instrument['color']
  return instrument

def build_row(canvas, grid_objects, beat, max_beat):
  for instrument in grid_objects:
    instrument['countdown'] -= 1
    shape = Shape(instrument, beat, max_beat)
    if instrument['countdown'] == 0:
      instrument = reset_instrument(instrument)

def build_columns(canvas, grid_objects, max_beat):
  beat = 0
  while beat < max_beat:
    beat += 1
    build_row(canvas, grid_objects, beat, max_beat)

def build_matrix(max_beat):
  dwg = svgwrite.Drawing('/results/sonakinatography.svg', (300,1700))

  grid_objects = [{'color': 1, 'countdown': 1, 'instrument': 1},
                  {'color': 2, 'countdown': 2, 'instrument': 2},
                  {'color': 3, 'countdown': 3, 'instrument': 3},
                  {'color': 4, 'countdown': 4, 'instrument': 4},
                  {'color': 5, 'countdown': 5, 'instrument': 5},
                  {'color': 6, 'countdown': 6, 'instrument': 6},
                  {'color': 7, 'countdown': 7, 'instrument': 7},
                  {'color': 8, 'countdown': 8, 'instrument': 8}]
  build_columns(dwg, grid_objects, max_beat)
  return dwg
drawing2 = build_matrix(60)


Quantitative art shares important characteristics with computation itself. Even as he was laying the foundations for computer science, Alan Turing noticed the relationship between code and data. Different contexts (data) will yield different results when the machine executes the instruction (code). Simple changes can yield an outsized influence when generating quantitative art. The dozens of variations of Sonakinatography are both familiar and uniquely beautiful:

Not only are Horwitz's notations reflected in contemporary music software, they have been interpreted across other mediums. Sonakinatography I, Composition III was freshly interpreted and performed in 2015 as dance and light by Ellen Davis:

<iframe width="560" height="315" src="" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen></iframe>

Haroon Mirza’s 2015 sound installation, A Chamber for Horwitz: Sonakinatography Transcriptions in Surround Sound, is another recent example:

Horwitz's restraint and commitment to minimalist simplicity has generated work that spans both time and media. It is hard to imagine any present or future artist working without ever having used a computer. Horwitz's organic interpretation of computation predicted a coming age without being directly influenced, which makes Sonakinatography a wholly unique work.

© 2018 Nextjournal GmbH