2024...

It's been a year!

I've been through a lot in 2024. Some of it great, some of it not-so-great, but I've grown and learned a lot from it.

I have mixed and produced fewer tracks this year, but I've been writing almost as much as ever. And, I've been working on performing and presenting my music a lot more. I knew that the album would open doors for me, and it has- I couldn't have dreamed of getting into any kind of show before I had something publicly released to show. I've met so many amazing people through this experience, and I'm truly grateful for everyone that this project has brought into my life. I'm nowhere close the musician I hope to be someday, but you must start somewhere and grow from there.

A large portion of my efforts in music this year have gone toward figuring out how to put together a live show. I've worked through a few types of live-show with varying success and varying levels of live-ness... Through it all, I've had some moments that felt rough, and a few moments that felt pretty good. I still have much to learn, and I expect to spend more time and energy moving in that direction in 2025. I think I'm learning a lot from each experience, and someday, I know, I'll look back at these early (sometimes objectively awful) shows and have stories to tell about them.

I spent a lot of time working on little gadgets and interesting modular synth tools this past year (with the intent to someday bring these things to a live show). Progress has been slow and updates have been sparse, but when you're in the creative thick of it- you often don't know when something is complete enough to show. I aim to try to be better about updates in 2025, especially with those sorts of things.

I recently acquired several pieces of new gear that I've incorporated into my workflow at home. It's nice to have a place where everything is always set up and hooked up so I don't have to re-learn and re-connect everything each time I want to use my drum machine.

The tarot deck is also coming along quite well, too! I have more than 2/3rds of the cards finished on for an initial draft, and I think some of them are among the most thoughtful and successful compositions I've ever made. That project continues to challenge me as an artist in a very good way.

This have been happening! I know I've been neglecting social media posts and blog updates for the last few months, but rest assured progress has been made in the mean time. <3

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();
}