Changing up the live show.

Sorry for the hiatus! I've been hard at work on some ambitious mechanical and technical projects that are still not quite ready to show (but will be soon <3)

My first foray into preforming my own music, live, was a learning experience to say the least. I don't feel amazing about what I was able to showcase, but I know that people really responded to certain aspects of my setup, and there's a lot of room to grow.

Previously I've had it in my head that in order to play live, I need to make sure EVERY sound that comes from the stage has a presence on that stage. That means either playing simple songs with limited instrumentation, or getting a whole band together who can play everything... But neither of these sound particularly practical or appealing to me as an artist right now. So for a while, I worked on putting together some kind of improvised live show based on my looper, synth and drum machines... but that quickly moved towards a genera that I don't really see myself in. I care a lot about songwriting, unique composition, and experimentation, and I feel like I only got to showcase one of those things if I did everything live/ improvised. I think a good live show (for me) would satisfy three criteria: - Something raw, natural, made live from scratch that shows off musicianship and creativity. - Something flashy that sounds great, shows off interesting compositional and musical ideas. - Something quite, tender, and intimate, that shows artistic intentionality and makes a meaningful connection with people.

Which brings me back to the reluctant answer that's been there all along... MIDI.

You may know midi as the groundbreaking 80s technology that allows a $50 Casio to weigh 3lbs, and come pre-loaded with 127 un-usable voices- but it can do much more than that! Midi can send note on/off and expression messages to and from different devices in real time.

I feel like this could answer several questions for me... but there's a catch. To run midi on stage, I will need a laptop up there with me... which looks kinda terrible. As soon as there's a laptop on stage with you, the sky is the limit. Sceptical artists like myself will see that and say "*pfft*. A laptop? are they even playing live?"... and this is a problem.

But then I remembered something. One of the best live shows I've seen so far was Jungle. One of the things that stuck with me most, was the way they composed the stage- which showed a ton of deliberate attention to detail, expression, and intentionality. (these are the things we need to see to believe that a show is going to be good and worth our attention.) Then the two lead artists stood behind opaque white boxes... And I will never know what was actually behind those boxes... but I suspect it was a synth and a laptop or a drum machine of some kind... I have thought a lot about this, because it geuninely felt like a magic trick. They undoubtably created an experience for the audience, and clearly played something but I can't tell you exactly what or how much they did. Is hiding your laptop behind a box enough to create space for permission to do whatever you want?

I think I can make this work. I think my stage setup with the plants and motors has the potential to capture attention and show thoughtful design like theirs did... so maybe I can get away with a certain amount of opacity too? Up until now, I've been primarily focused on making everything as visible and sympathetic as possible, but what if I do a bit of both? Maybe there's a way that I can hide certain things from you, and show other things off so you don't mind not knowing everything?

I've been exploring a new live show in three parts:

• Something done live on the looper and synths with no daw or pre-planned elements.

  • I do think it's important to make music that comes from you when you're on a stage. that's what makes it special. It's part of the sacred contract of musical performance, and it's why we don't just all walk up there an hit play all the time.

• Something recorded into the looper ahead of time.

  • I also think it's important to sound good. And realistically, what I do as a musician involves A LOT of work in quite spaces where nobody hears what I'm doing.

  • A track separated into parts that are either fully mixed in the daw, or recorded into the looper from a previous live preformance.

  • This way, I can just hit "Play" and sing / improvise over top of without worrying about it falling apart or being impossible to execute everything at once.

  • I do still have some rules for this though. I think it would be inappropriate for the pre-recorded parts to be super-obviously pre-recorded (ie: featuring voices that aren't present on the stage.) So anything with an acoustic guitar is still a no-no (sorry queen of time)

• Something that runs midi from my laptop live on stage to a variety of instruments.

  • This way I still have full analog control over the modulation, without also playing the actual notes.

  • I can use music I've made before and experiment with it in new ways in the moment.

  • Unfortunately, this might necessitate a somewhat sterile performance from the machines themselves... the actual notes will fall exactly on the beat, which is not ideal for every song, though there are ways to midigate it.

  • I also won't be able to play live on top of this because every instrument is already playing something through its sound engine...

After thinking about a show like this, I've started putting things together and realized that I do already have a lot of what I need to make it a reality... so I guess I might as well try it and see how it goes? I expect to find more speed bumps along the way, (notably that it involves A LOT more gear and complicated routing...) but I think there's a lot of potential in this, and I'm excited to see if it works well and feels more satisfying to perform!

Making funky little things ❤️

The last two weeks I've been putting a lot of time into one of my music-related side projects. For a few years on/off I've been building tools and devices that change the way an analog synth presents its sound and its modulation outwardly.

This week I made an Arduino program that operates a row of four LEDs lights that respond to CV and gate signals output from my synthesizer.

I'll share my code and wiring below in case anyone is looking for help with a similar project. (Goodness knows I've found much help from random websites and blogs about other people's programming and hardware projects.)

AI was a valuable resource in writing the code, but it's taken a bit of tinkering to get it working exactly the way I hoped. It works by recording a value from the CV signal if/when it sees the Gate signal cross a certain threshold. It then stores the 4 most recent values in an array, and copies that array into another array sorted by magnitude. It uses that sorted array to determine which LED(s) should receive an output signal, prefering to keep a given signal mapped to whatever LED most recently had a signal closest to it. This is great for arpeggios and patterns. It maps up and downward motion well, too. after playing a sequence of four notes a few times, it will "learn" that pattern and sort it to a sequence of LEDs that track the up/ down movement of those pitches.

The code works well- and it's proven to be surprisingly flexible! I've experimented with changing the input sources from Gate/CV to other patch points on my Moog Grandmother, and each seems to respond in a unique and responsive way- I'm excited to try preforming with this!

Operating LED lights is not my end goal for this project, but it's a good proof of concept, and it's pretty cool in it's own right!

#include "SoftwareSerial.h"
#include "AccelStepper.h"
const int numLights = 4;
const int ledPins[numLights] = {2, 3, 4, 5}; // Digital pins for LEDs
const int analogPin1 = A0; // Analog pin for signal input
const int analogPin2 = A1; // Analog pin for blink control

int signalValuesByAge[numLights] = {0, 0, 0, 0}; // Array to store the signal values by age
int signalValuesByMagnitude[numLights] = {0, 0, 0, 0}; // Array to store the signal values by magnitude
int currentIndex = 0; // Index to keep track of the oldest value
int currentActiveLED = -1; // Variable to store the index of the currently active LED
int previousClosestValue = -1; // Variable to store the previous closest value
const int buffer = 10; // Buffer around each value
bool prevBlinkState = false; // Previous blink state to detect threshold crossing

void readAnalogSignal() {
  delay(2);
  int newValue = analogRead(analogPin1); // Read new signal value
  
  // Check if the new value is within the buffer of any existing value
  for (int i = 0; i < numLights; i++) {
    if (abs(newValue - signalValuesByAge[i]) <= buffer) {
      return; // Do not update the array if within the buffer range
    }
  }

  insertAndSort(newValue); // Insert the new value into both arrays
}


void insertAndSort(int value) {
  // Insert new value into the array sorted by age
  signalValuesByAge[currentIndex] = value;
  currentIndex = (currentIndex + 1) % numLights; // Update the index to the oldest value

  // Copy values from age array to magnitude array
  for (int i = 0; i < numLights; i++) {
    signalValuesByMagnitude[i] = signalValuesByAge[i];
  }

  // Sort the magnitude array
  for (int i = 0; i < numLights - 1; i++) {
    for (int j = i + 1; j < numLights; j++) {
      if (signalValuesByMagnitude[i] < signalValuesByMagnitude[j]) {
        int temp = signalValuesByMagnitude[i];
        signalValuesByMagnitude[i] = signalValuesByMagnitude[j];
        signalValuesByMagnitude[j] = temp;
      } 
    }
  }
  for (int i = 0; i < numLights; i++) {
  Serial.print(signalValuesByMagnitude[i]);// for some reason this shows only three numbers? and when a 4th shows up it breaks...
  Serial.print(" ");
  }
  Serial.println();
}

void updateLEDs() {
  int currentValue = analogRead(analogPin1); // Read the current signal value
  int closestIndex = 0;
  int smallestDifference = abs(currentValue - signalValuesByMagnitude[0]);

  // Find the closest value within the buffer range
  for (int i = 1; i < numLights; i++) {
    int difference = abs(currentValue - signalValuesByMagnitude[i]);
    if (difference < smallestDifference) {
      smallestDifference = difference;
      closestIndex = i;
    }
  }

  // If the closest value within the buffer range is the same as the previous closest value, keep the current active LED
  if (abs(previousClosestValue - signalValuesByMagnitude[closestIndex]) <= buffer) {
    closestIndex = currentActiveLED;
  } else {
    previousClosestValue = signalValuesByMagnitude[closestIndex];
  }

  // Update LEDs to light only the closest one
  for (int i = 0; i < numLights; i++) {
    if (i == closestIndex) {
      digitalWrite(ledPins[i], HIGH); // Turn on the closest matching LED
      currentActiveLED = i; // Update the currently active LED
    } else {
      digitalWrite(ledPins[i], LOW); // Turn off all other LEDs
    }
  }
}

void controlReadingAndBlinking() {
  int blinkSignal = analogRead(analogPin2);
  bool blinkState = (blinkSignal > 512); // Simple threshold for blinking

  // Check for threshold crossing
  if (blinkState && !prevBlinkState) {
    readAnalogSignal(); // Read and add new data only once when crossing the threshold
  }

  prevBlinkState = blinkState; // Update the previous blink state

  // Blink the active LED
  for (int i = 0; i < numLights; i++) {
    if (digitalRead(ledPins[i]) == HIGH) {
      digitalWrite(ledPins[i], blinkState ? HIGH : LOW); // Blink the active LED
    }
  }
}



void setup() {
  Serial.begin(250000);
  for (int i = 0; i < numLights; i++) {
    pinMode(ledPins[i], OUTPUT);
  }
  pinMode(analogPin1, INPUT);
  pinMode(analogPin2, INPUT);
}

void loop() {
  updateLEDs();
  controlReadingAndBlinking();
}

BOSS RC 505

I bought a multichannel looper last week!

It arrived yesterday, and I could not be happier so far. It's rare that a piece of equipment works exactly as you expect and with no curve balls almost as soon as you start using it, but after like 20 minutes of messing with settings, it just does exactly what I expect it to do. I'm so glad I just... got the thing I wanted instead of something cheaper that would work less well 😅

I've had my eyes on something like this for a while- there's an incredible producer and improv songwriter on Twitch named ARIatHOME (https://www.twitch.tv/ariathome) who uses the RC 505 to make extremely impressive mixes from scratch using midi soundbanks and fx controls.

There is a new value in simplicity. I usually think about songs as a line- A path that starts in one place and rises/falls till it arrives at another place. In this framework, it's easy to see the whole picture and think about how ideas and motifs will develop and change throughout the song...

But a looper is different. Suddenly there is a very real limitation to the way parts can change over time. It's easy to make things grow/layer, but impossible to alter the details after it's been added... Obviously there are some songs that just cant work in this format, but there are others that really can!

I got this tool with the idea of using it to play more live shows, and so far it seems like it will work well for that. I have a few songs that have been in the works for a while that I think could lend themselves well to the limitations of the looper. It's interesting how a tool like this challenges my ideas about how I appreciate simple v.s. complex song structure. Songs that are more repetitive/simple have often felt like a chore to practice and make me roll my eyes when I feel like I haven't come up with a more interesting variation- but suddenly the only things that can be played and made whole in this format are simple things!... come to think of it... often in my songwriting at the piano or guitar, I'll reach for a different voicing or a different way to put energy into a repeated section- perhaps there is a way to keep the simplified core in place and overdub the loop to add harmonic complexity. I wouldn't be able to be as precise as I might if I were using a whole instrument, but there might still be a way to make something satisfying.

I imagine this looper being a very good tool for my live sets with the Moog. I've met a lot of amazing musicians and artists recently, and it's made me realize that there is a ton of value in having something like an analogue synthesizer that sets you apart from the other acts who might come before or after you. We are all artist, we are all making really cool music, but having a pallet of sounds to play with that's so different from the typical acoustic guitar + vocal will really stand out! The RC 505 has a lot of built in FX too. I typically ignore this kind of stuff, but I was looking through the options yesterday and it seems surprisingly robust! The 505 has a fairly simple and dedicated interface to access the FX and modulate them live. The tools themselves are very neutral and appreciable too- simple, effective, standard stuff like Low/highpass filters, Delay, Reverb, pitch modulation... Before I had it in my hands I never saw myself using these, but they honestly might be the key to gluing everything together and making the arc of a song feel complete and interesting. I'm excited to experiment with it more!