Music on Signals & Pixels

Hexadecimal Drum Loops

aa.zuspan@gmail.com (Aaron Zuspan) — Fri, 05 Jun 2026 09:49:07 +0000

When you program a drum machine, you’re encoding a binary state (play or don’t play) for each drum (kick, snare, hi-hat, etc) at each time step. The obvious, intuitive interface – the one used by pretty much every sequencer and DAW – is a 2D grid of cells, with sounds on the Y-axis and time on the X-axis.

A drum loop displayed on a classic ‘piano roll’ MIDI interface.

Building Arpeggio Pt. 4: The Parser & Interpreter

aa.zuspan@gmail.com (Aaron Zuspan) — Sun, 26 Jan 2025 00:00:00 +0000

I’m building a domain-specific language called Arpeggio that compiles code into songs. I outlined a tentative syntax for the language in Part 1, explored the musical theory behind it in Part 2, and implemented a Python music engine to power it in Part 3. Now it’s time to finally connect those components together by writing a parser and interpreter that turns our custom language into playable music.

Syntax and Semantics

The language design was detailed in Part 1, but here’s a quick recap of the core concepts:

Replacing My Guitar Amp with a Neural Net

aa.zuspan@gmail.com (Aaron Zuspan) — Mon, 28 Oct 2024 00:00:00 +0000

Vacuum tubes are an expensive, inefficient, and unreliable relic of early 1900s technology. So why are guitarists (and me) still lugging around old tube amps 80 years after the transistor made them obsolete? The short answer is that tube amps sound good when you overload their input signal, and transistor amps don’t¹.

So, I can’t just swap my tubes for transistors one-to-one and get the same tone in an amp. But could I replace my tubes with a few billion transistors in a GPU running an open-source neural network trained to sound like my amp?

Building Arpeggio Pt. 3: The Engine

aa.zuspan@gmail.com (Aaron Zuspan) — Sat, 21 Sep 2024 00:00:00 +0000

I’m building a domain-specific language called Arpeggio that compiles¹ code into songs. When an Arpeggio program is run, the compiler will need a way to turn parsed instructions (e.g. play a C major chord for 1/4 of a measure) into playable audio. This post goes over the process of designing and building that backend API.

Building a Song in Code

In Part 2, I outlined how we can represent musical concepts like keys, modes, notes, and chords in Python. For a quick recap, here’s the basic structure of those classes:

Building Arpeggio Pt. 2: Music Theory for Programmers

aa.zuspan@gmail.com (Aaron Zuspan) — Wed, 04 Sep 2024 00:00:00 +0000

I’m building a domain-specific language called Arpeggio that compiles code into music. In Part 1, I outlined the basic language design and syntax. Here, I’m going to do a very shallow dive into music theory from a programmer’s perspective, focusing on the terms and concepts needed to build the music backend that powers Arpeggio.

Disclaimer: Music theory is a huge field of study that’s filled with complexity and ambiguity, which I’m going to vastly oversimplify down to the basic math and patterns that I can understand. Apologies to any real musicians who stumble onto this.

Building Arpeggio Pt. 1: Language Design

aa.zuspan@gmail.com (Aaron Zuspan) — Tue, 03 Sep 2024 00:00:00 +0000

I’ve tinkered with parsers for a few small side projects like building a language server and parsing blog post metadata, but I wanted to tackle a bigger parsing project. I’ve also been trying to learn some music theory in my spare time, so why not combine the two ideas by building a domain-specific language (DSL) for notating and generating music?

I’m (tentatively) calling it Arpeggio.

The Concept

This is going to take a few blog posts to get through, so let’s just start at the beginning with what our language is going to look like and how we’re going to use it, so we can build our parser around that.

Guitars, Microchips, and Assembly

aa.zuspan@gmail.com (Aaron Zuspan) — Sat, 18 Mar 2023 00:00:00 +0000

My first attempts at programming were writing hacky embedded C++ to run Arduino microcontrollers, brute forcing my way through compiler errors to try to make LEDs blink and motors spin. These days I write most of my code in high-level, dynamically-typed languages, but there’s still something alluring about that intersection of software and hardware - about watching your code run in the physical world.

So, leaving behind the comfort of high-level abstractions and garbage-collected memory management, I spent a few days diving back into the world of low-level embedded code by building a guitar effects pedal around the FV-1 chip. Because what’s lower level than Assembly?