Reilly Spitzfaden | All

The Antique Telecommunications Museum

reillypascal@gmail.com (Reilly Spitzfaden) — Tue, 17 Mar 2026 16:06:02 GMT

James is hosting this month's IndieWeb blog carnival on the topic “museum memories.”

One of my favorite museum trips was when my spouse took me to see the Antique Wireless Association's Communication Technologies Museum for my birthday a few years ago. I didn't know about this museum before we went — my spouse had come up with the idea to take me there on their own, and the thoughtfulness made it extra nice. It's a small museum, and a tour guide walked us and one other couple through the museum, and for several of the exhibits, showed us the devices in action.

One of my favorite exhibits was a set of teletype machines, all linked together. A teletype is similar to a typewriter, but keypresses can be transmitted and received. Typing on one of these machines sends a code for each character — traditionally the 5-bit Baudot code. When a teletype on the other end of the line receives Baudot code, it types out the same character as the unit sending the code. The museum was kind enough to let visitors type on one of the teletypes, and it was extremely cool to see them communicate with each other, with another unit duplicating what we typed.

I love mechanical keyboards/typewriters and computer history, and teletypes were one of the earliest ways of interacting with computers. As I wrote about previously, the feeling of transmitting information over a distance also has a strange pull for me. I think there are a few reasons why things like teletypes create this feeling so much more than e.g., the internet. First, they aren't nearly as mundane, and the unfamiliarity makes me think more about what's actually happening. Second, the protocol is much simpler, and it's easier to visualize what's happening over the wire and how that connects to what I'm typing. It feels more real and immediate, and more tied to the physical realm.

Another stand-out exhibit was an early arc transmitter that we got to see in action. Kathy Loves Physics has a good video on YouTube explaining these, but in short, high voltage arcs are generated in rapid succession across a small gap, and this creates oscillating radio-frequency emissions. These were some of the earliest wireless devices, and the museum had a working unit on display. The guide demonstrated running the generator for this transmitter, and it was impressive to watch the powerful arc and hear the immense noise it makes.

Other exhibits included replicas of radio broadcast and communications rooms from various eras of civilian and military history, and we got to look up close at all the transmitters, receivers, and audio gear for these studios. The biggest was a control room from a Voice of America station. This exhibit had a large arc of control panels filled with dials, gauges, and screens, and a row of cabinets containing the transmitters and other hardware. Across from this was a section in the back with rows of shelves containing lovingly catalogued receivers and transmitters that hadn't fit elsewhere in the museum.

Postscript

Thanks to James for hosting this month! This was a fun trip to remember, and I appreciated the chance to think over what made it so interesting and enjoyable. Until next time!

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

Tidal Cycles/Neovim: No Plugins, 24 Lines of Lua

reillypascal@gmail.com (Reilly Spitzfaden) — Fri, 06 Mar 2026 17:30:00 GMT

I've been enjoying writing music using code in Neovim — I recently talked about using Lilypond to write sheet music this way, for example. Another way of writing music with code is Tidal Cycles. This is a set of pattern-sequencing tools that talk to the SuperCollider synthesizer. Tidal Cycles allows a highly compact way of notating musical patterns, and one aimed at live-coding or “algorave” events, where performers' screens are projected, showing code being typed in real time.

Today, let's look at how I bypassed the need for plugins when writing Tidal Cycles code, and created something simple and self-sufficient that also gave me more understanding of my tools!

Existing Tidal Cycles Tools

The officially-recommended plugin vim-tidal hasn't been updated since 2020, and whenever I quit the Tidal interpreter in this plugin, I wasn't able to start it again without quitting and re-opening my terminal. tidal.nvim was pretty nice and somewhat newer, but development doesn't seem to be particularly active, and my next experience made me question if I even needed that.

I was playing with the conjure plugin, ^[1] which provides interactive REPL support for many languages, including Scheme, which I've been using with Lilypond. I saw that it was pretty easy to set this up with the lilypond scheme-sandbox command, instead of the suggested MIT Scheme or GNU Guile REPLs — you can see my Neovim configuration for this here.

This got me thinking: how hard could it be to set something like this up myself for Tidal Cycles? It turned out that I only needed a little bit of Lua! I always prefer small, simple scripts that I wrote and understand, since I know I can keep these maintained without relying on someone else to write a plugin (or having to dig through a plugin's worth of code myself in order to fork/maintain it).

Additionally, it's extremely easy to stop/start the Tidal interpreter with this configuration, and even more so than in the more recent tidal.nvim plugin. Tidal Cycles just uses Haskell's GHCi environment started with a custom file titled BootTidal.hs. GHCi is the interactive version of the Glasgow Haskell Compiler (GHC). You can enter Haskell expressions at the prompt, and they will be evaluated on the fly. The standard way to quit GHCi is ctrl + D, and since we will just be running GHCi in a Neovim terminal pane, this works great here.

My Neovim Configuration

First, we want Neovim to recognize “.tidal” as a file type. We can add a tidal.lua file in the ftdetect/ folder with the following code, which lets Neovim know about that file type.

ftdetect/tidal.lua

vim.filetype.add({
	extension = {
		tidal = "tidal",
	},
})

Next, as mentioned previously, Tidal Cycles uses Haskell's GHCi. All we need to do is start GHCi in a Neovim terminal window using the correct boot file, and then enter the code at the prompt, followed by a <CR> character (the “Enter”/“Return” key). We can add keymaps that only apply to a buffer with a .tidal file by putting them in ftplugin/tidal.lua and adding the buffer = true option as shown below.

ftplugin/tidal.lua

-- open GHCi REPL in term split using Tidal boot file
vim.keymap.set(
	"n",
	"<localleader>b",
	"<cmd>10 split term://ghci -ghci-script=$TIDAL_BOOT_PATH/BootTidal.hs %<cr>:startinsert<cr>",
	{ desc = "Boot Tidal interpreter and open in terminal split", noremap = true, buffer = true }
)

Since this keymap is local to the buffer, we use the <localleader> key, which I have mapped to “,“. The command that this keymap runs enters command mode (:); creates a terminal split that's 10 characters high; runs GHCi with the Tidal boot file; and then switches to insert mode (Neovim's terminal defaults to normal mode).

$TIDAL_BOOT_PATH here could be replaced with a hardcoded path to the Tidal boot file, but using an environment variable like this lets me use my configuration on multiple computers/OSes. You can set this variable with the following line in your .bashrc or .zshrc file. Note that this is under ~/.cabal/share/ (at least on my setup), but contains install-specific details, so you will need to locate the BootTidal.hs file for your installation. If you want or need, you can manually copy the code for BootTidal.hs into a file and use the directory where you store that file.

export TIDAL_BOOT_PATH="$HOME/.cabal/share/aarch64-osx-ghc-9.12.2-ea3d/tidal-1.10.1"

Next, I added two keymaps to let me run the current line and the current block. For the first one:

yy “yanks” the current line.
Control-w accesses window-related commands, and from here, j will go down a window.
p pastes the yanked line, a enters insert mode after the line (“append”), and <CR> sends the line to GHCi.
Control-\ and Control-n are needed together to exit insert mode in the terminal.
Control-w p goes to the previous window location.

Running all this from one keymap smoothly takes the current line and runs it in the terminal split.

Next, we want to do a similar thing for a block of text, potentially including line breaks. (Neo)vim has the concept of text objects, and a block of text with blank lines before and after is a “paragraph” object. yip (“yank inner paragraph“) will copy the required type of text block. I precede it with "* to copy to the system clipboard instead of the unnamed register used by default. This makes it easier for me to edit the contents of the register before pasting them.

In order for GCHi/Tidal to accept a block with line breaks, the block needs to be preceded by :{ and followed by :}, both on separate lines from the block. We can assign things to a register with e.g., :let @* =, and I chain the required strings together with the existing contents of the register (represented with @*). Vimscript uses the dot (.) to chain text together. All told, here are the differences:

We use yip instead of yy to yank the paragraph.
We yank it to/paste it from the "* register, rather than the default.
We use :let to edit the contents of the register.

ftplugin/tidal.lua

-- yank current line; move to term; paste, enter append mode, <CR>; back to normal mode; return to previous location
vim.keymap.set(
	"n",
	"<localleader>ee",
	[[ yy<C-w>jpa<CR><C-\><C-n><C-w>p ]],
	{ desc = "Evaluate current line", noremap = true, buffer = true }
)
-- yank current block to "*; wrap in :{/:}; move to term; paste from "*, enter append mode, <CR>; back to normal mode; return to previous location
vim.keymap.set(
	"n",
	"<localleader>er",
	[[ "*yip <cmd>let @* = "\:\{\n" . @* . "\:\}"<cr> <C-w>j"*pa<CR><C-\><C-n><C-w>p ]],
	{ desc = "Evaluate current block", noremap = true, buffer = true }
)

Finally, I add the following line to associate .tidal files with Haskell syntax. This works well, but note that the Haskell Language Server (HLS) may throw a fit on Tidal files — this has been an issue with some Vim/Neovim plugins, but weirdly not others. HLS is not needed for Tidal Cycles itself, but if you also want to write vanilla Haskell, be aware of this. I ended up using this function and this line in my LSP configuration to prevent HLS from loading unless there is at least one Haskell project root marker in the folder. A bit of a hack, but it works for now.

ftplugin/tidal.lua

-- enables highlighting
vim.cmd("set ft=haskell")

Postscript

The tidal.nvim plugin is certainly still quite nice, and may be more your taste. The benefits I found from this project are 1) more flexibility over the default terminal split size, 2) direct access to the GHCi Tidal process in the resulting terminal, 3) a better understanding of my tools in general, and 4) the knowledge that all my setup depends on is the base Tidal code staying maintained. In general, I find it fun and reassuring to make minimalist scripts to accomplish tasks, and this project was similarly satisfying.

I plan to keep tinkering and writing about Tidal Cycles/Neovim, as well as Lilypond (which I mentioned at the beginning). I hope to see you then — until next time!

In addition to the Conjure plugin, iron.nvim is another general-purpose REPL plugin you could try. ↩︎

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

Friendly Lilypond with Neovim & Audacity

reillypascal@gmail.com (Reilly Spitzfaden) — Fri, 27 Feb 2026 17:35:05 GMT

Lilypond is a program and language for writing musical scores using only text. The syntax is similar to LaTeX, and this can be easily converted to nice-looking PDF scores, as well as MIDI files for previewing/making mockups. In addition, there are e.g., Python libraries such as Abjad that allow for algorithmic manipulation of musical notation. ^[1] I've found that I enjoy writing text files more than I enjoy using graphical programs such as Dorico/Sibelius/the late Finale, so I've recently been trying out Lilypond.

Part of what I've been enjoying about text files is that I've gotten my Neovim setup to a place that's very pleasant and smooth to work with. Additionally, I've developed joint issues, and even with a nice vertical mouse, typing exacerbates the joint issues much less.

For writing Lilypond, the IDE-like program Frescobaldi is popular. It bundles a text editor with tools for handling boilerplate code, transposing and other musical tasks, and a MIDI player and score viewer that make it easy to see and hear the results of the code. Since I prefer using my own Neovim setup, I decided to try getting as much of the convenience of Frescobaldi as possible with the tools I prefer. I think it turned out pretty well! Let's have a look at how it works.

Neovim Setup

First (and easiest), there is a nice Neovim plugin nvim-lilypond-suite. This adds syntax highlighting and PDF/playback keyboard shortcuts. I also use the conform.nvim plugin to perform automatic formatting (e.g., line breaks, spacing, etc.). This plugin communicates with existing formatting tools, and here I used the python-ly command-line program. It has indentation/formatting options, and I made conform.nvim aware of these commands using this configuration here.

This covers most of what Frescobaldi does, but for audio playback, there is one wrinkle that's specific to my needs that makes the provided playback not work. The nvim-lilypond-suite plugin uses timidity or fluidsynth to convert MIDI files (which are just instructions to a synthesizer on the notes to play) to audio files. These two programs use a SoundFont — a predetermined collection of synthesizers — to convert the MIDI file to audio. In my compositions, I often like to have a Max/MSP patch being controlled by e.g., a live MIDI keyboardist, and played alongside live instruments. This is unfortunately not compatible with timidity/fluidsynth.

MIDI Playback

macOS provides the IAC virtual MIDI connection, which allows me to send MIDI data between programs, including sending it to Max. ^[2] This means I just needed to find a program that can play the MIDI file that Lilypond generates into the IAC bus in order to hear my Max patches played as the keyboardist would play them.

I looked for a surprisingly long time before realizing that Audacity can load MIDI files and can play them back over IAC. It would work OK to drag and drop the files in, but I would miss the convenience of Frescobaldi automatically updating the MIDI file, and having to manually load the file and delete the previous ones would partly defeat the purpose of using Neovim to get away from the mouse.

Fortunately, it turns out Audacity can be scripted! First, go to Audacity > Preferences > Modules (Mac) or Edit > Preferences > Modules (Win), and make sure that “mod-script-pipe” is set to “Enabled.” The Audacity manual gives an example Python script to confirm that the connection is now working. At the end of this file, note the line do_command('Help: Command=Help'). This sends the message Help: Command=Help to Audacity, and is a good template of how to send commands more generally.

What I wanted to accomplish was have my script select any previously-opened tracks, delete them, and then open the latest version of my MIDI file. From looking at the scripting reference page, I concluded I would need the SelAllTracks:, RemoveTracks:, and Import2: commands. You can see my use of them below:

pipe.py

#!/usr/bin/env python3

import argparse
# ...

parser = argparse.ArgumentParser()
parser.add_argument("input", help=".mid file to open")

args = parser.parse_args()
# ...

def reload_file():
    do_command('SelAllTracks:')
    do_command('RemoveTracks:')
    do_command(f'Import2: Filename={args.input}')

reload_file()

I've excerpted the sections that I needed to change from the example. I used the argparse library to handle command-line arguments — in this case, the MIDI file name — which is stored in args.input. After that, I run the required Audacity scripting commands, and use a format string to send the name of the MIDI file to Audacity. Because of the “shebang” in the first line of the Python file, the script can be run like this: ./pipe.py <my-score>.midi

Automatically Reloading MIDI/PDFs

This is already nice, but I had also seen the utility entr, which will run commands whenever a given file changes. The Bash script below runs two copies of entr to watch the PDF and MIDI files for changes, and then open each file when it changes.

watch

#!/usr/bin/env bash
# run lilypond on score file to ensure MIDI/PDF are made
lilypond "$(realpath "$1")" && {
	# need to run `realpath` *after* MIDI/PDF generated
	midipath="$(realpath "${1%.ly}.midi")"
	pdfpath="$(realpath "${1%.ly}.pdf")"

	# run two separate `entr` processes, one each to watch & open MIDI/PDF
	echo "$midipath" | entr ./pipe.py "$midipath" &
	# different OSes need different actions to open PDF
	if [[ "$OSTYPE" == "linux-gnu"* ]]; then
		echo "$pdfpath" | entr evince "$pdfpath"
	elif [[ "$OSTYPE" == "darwin"* ]]; then
		echo "$pdfpath" | entr open "$pdfpath"
	elif [[ "$OSTYPE" == "cygwin" ]]; then
		# POSIX compatibility layer and Linux environment emulation for Windows
		echo "$pdfpath" | entr start "" /max "$pdfpath"
	elif [[ "$OSTYPE" == "msys" ]]; then
		# Lightweight shell and GNU utilities compiled for Windows (part of MinGW)
		echo "$pdfpath" | entr start "" /max "$pdfpath"
	else
		echo "Unknown OS: PDF not opened"
	fi
}

You can run the script with ./watch <scorename>.ly. First, the script runs lilypond <scorename>.ly to ensure that the required MIDI/PDF exist, even if I haven't remembered to generate them yet. I use realpath to get the full path of the files and avoid any potential issues loading them (Audacity was the main source of trouble with this).

The next block runs two copies of entr. In both cases we use the command format echo <file-to-watch> | entr <run-on-file-change>. For the PDF, we check the $OSTYPE variable, since different operating systems have different PDF viewers. On Linux, Evince is common; macOS provides the open command to open any file in the default program; and the Windows options are based on poking around the internet (note that I don't have a Windows machine to test them, so please check before using!)

Listening in Max

Now that I can send MIDI messages between programs over a virtual MIDI device, it's pretty straightforward to use them in Max. Max has the [notein], [ctlin] and [bendin] objects for note, CC, and pitch bend data respectively. MIDI files generated by Lilypond send MIDI data over different channels for each instrument, and these objects can take arguments to listen to only one specific channel. The MIDI Monitor app is useful to see which channels are which, but Lilypond seems to assign increasing channel numbers from top to bottom in the score.

In addition to running the Max patch for the keyboardist, Max is useful for hosting VST plugins to handle mockups for the other instruments. I found the [midiselect] object useful for handling MIDI input, then send that into [midiformat]. You can connect the right outlet of [midiformat] to the [vst~] object — this will give [vst~] the “midievent” message format it needs. Also note that [vst~] should have the @autosave 1 attribute set — this will ensure your VST settings are saved.

If you don't use Max, note that most DAWs and other programs that can host virtual instruments (e.g., I've tried this with Logic Pro, REAPER, and Mainstage) can also take input over a virtual MIDI bus. You could also connect to SuperCollider, Pure Data, VCV Rack, and many others.

Postscript

I've been having a ton of fun with Lilypond, including microtones, algorithmic composition with Python/Abjad, and more. There's a lot of interesting stuff to discuss there, and I'm planning to write a few more posts about these topics sometime soon. I hope to see you then — until next time!

I use “algorithmic” here in the sense of Iannis Xenakis' Formalized Music — i.e., handwritten algorithms without large, unethical datasets — not in the LLM sense. ↩︎
While I haven't tried this on Linux yet, QJackCtl and JACK should allow routing MIDI between programs. This page section also discusses getting JACK to play nice with PulseAudio. LoopBe1 looks like a possibility for Windows, but I haven't tried it. ↩︎

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

Caw

reillypascal@gmail.com (Reilly Spitzfaden) — Sat, 07 Feb 2026 00:00:00 GMT

Caw

It is a “caw”

Thanks to Sophia for the caw-related art

More caw: Sophia, James, Joe, gRegor, Thomas, Naty

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

IndieWeb Movie Club: “Alien”

reillypascal@gmail.com (Reilly Spitzfaden) — Sat, 31 Jan 2026 23:53:51 GMT

January's IndieWeb movie club is Alien (1979), and it's hosted by Al Abut — here is his introduction post for the month. I've been in the mood to see some space horror lately. I saw a promotion for Ash (2025), which looks like a solid B-movie, and that reminded me to add Sunshine (2007) and Event Horizon to my watch list. I've also been wanting to watch more movies with my husband, so Alien is perfect for all of that. This is a re-watch for both of us — we've seen it (and Aliens) before, and liked them a lot.

Sound Design

A few things stood out to me about the sound design of the film. The first happens a few times throughout. When the initial exploration party leaves the ship, the sound environments inside/outside the vessel have a stark contrast, and the cuts between them are immediate. Later, as the face hugger first attacks Kane, the camera cuts rapidly from attack, only allowing the sudden noise to sound for an instant.

A similar contrast happens when Lambert and Parker are loading coolant into an escape ship while Ripley gets the escape shuttle ready. Ripley's surroundings are well-lit and quiet, while Lambert and Parker work noisily, loading the coolant, with Lambert being audibly agitated as well. Here as well, the cuts between the sound environments are immediate and jarring.

To my ear, these contrasting sound environments emphasize the otherness of the alien, with the suddenness of the cuts exaggerating the difference between the sound environments. This also intensifies the harshness of the environment where the alien will appear, and heightens the sense of impending danger. Especially in the second example above, the time between the cuts speeds up slightly as the alien nears, and finally the loudness of Lambert and Parker's environment intrudes on Ripley's part of the ship as she receives their distress call and runs down the halls to help. In both cases, I got a sense from the cuts and their pacing of two narrative strands converging and joining.

Bartók Reference

Jerry Goldsmith's score includes a passage (from about 1:11:55 to 1:12:30 in the film, or in this clip) that reminds me very strongly of another passage from Béla Bartók's Music for Strings, Percussion and Celesta (1936), movement III.

I initially wondered if this was the actual Bartók piece and had to look up the soundtrack on Wikipedia to confirm that it wasn't. I also remembered that the actual Bartók piece appeared in the score for Stanley Kubrick's The Shining as the boy Danny rides his tricycle through the endless halls of the hotel. While my first thought was that Goldsmith and/or director Ridley Scott were inspired by Kubrick, since The Shining came out a year later (1980), that's of course not possible.

At any rate, the sinuously winding melody in the high strings, and especially the piano octaves ascending and descending chromatically sound similar enough that I imagine Goldsmith was influenced by the earlier piece. It seems that someone else also had the same thought — I was able to find this thread on Reddit, asking if others thought the passages sounded similar.

Interestingly, this music does not appear to have been written for the film. According to this review, Scott and Rawlings borrowed significantly from Goldsmith's earlier score to Freud (1962), and this title from Freud appears to be the same music as the scene in Alien.

Final Thoughts

I appreciated that this month, there was an event where people got together on a call and discussed the movies in real time. This both got me to watch the film earlier in the month than I would have otherwise, and was a fun addition to the written discussions. I liked this film choice a lot, and I'm definitely planning to participate in future movie clubs.

Until next time!

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

Sending Webmentions with a Simple Shell Script

reillypascal@gmail.com (Reilly Spitzfaden) — Wed, 07 Jan 2026 18:25:04 GMT

I came across a convenient way to send webmentions from my terminal using a simple Bash script. This page on the IndieWeb wiki includes a shell script one-liner. It references an older version of the webmention standard, but I was able to figure it out and get it working with my setup. I have the following in a file titled send-wm:

#!/usr/bin/env bash

my_url="$1"
target_url="$2"

curl -i -d "source=$my_url&target=$target_url" $(curl -i -s "$target_url" | grep 'rel="webmention"' | grep -o -E 'https?://[^ ">]+' | sort | uniq)

The example had rel="http://webmention.org/" instead of rel="webmention", which is the current standard. It also included an extra step — sed 's/rel="webmention"//'. I assume this was originally supposed to read something like sed 's/rel="http:\/\/webmention.org\/"//', which would be necessary to make sure there is only one "http(s)" to grep for. At any rate, that part doesn't appear to be currently necessary. (UPDATE: I edited the IndieWeb wiki to reflect the current version of this script!)

This script can be used as follows. Note that to do this, you will first need to run sudo chmod +x send-wm to make the script executable:

./send-wm <your_url> <target_url>

The basic command to send a webmention using cURL looks like this:

curl -i -d "source=$your_url&target=$target_url" $targets_webmention_endpoint

This script inserts the provided source/target URLs into the statement, and the part inside the parentheses evaluates to the webmention endpoint from the target page.

I also added this to my webmentions tutorial — I like to do that so all my webmention info is in one place. I regularly update this, and there's a table of contents to jump to specific sections.

Future Plans

I imagine it's possible to make a version of this that only needs the URL for the post sending the mention, and can parse out a list of URLs linked from that page and try sending webmentions to each, handling any failure gracefully. If I get around to doing that, I'll write another post and add it to the tutorial. Until next time!

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

App Defaults at the End of 2025

reillypascal@gmail.com (Reilly Spitzfaden) — Wed, 07 Jan 2026 15:11:17 GMT

Robb Knight has a page listing people's descriptions of their default app choices, and he just did an update for this year. I thought it sounded fun, so here are some of mine as of the end of 2025:

Adblocker: uBlockOrigin
Browser: Firefox; FFUpdater to keep vanilla Firefox for Android updated without the Play Store
Calendar: Fossify Calendar, DAVx⁵, macOS Calendar.app
Chat: Signal
Cloud File Storage: Mega
Contacts: GrapheneOS Contacts app
E-Books: Readest
File Sharing: LocalSend, OpenMTP, Syncthing
Local Backups: FreeFileSync
Mail Client: Mailspring on desktop, Thunderbird on mobile
Maps: Organic Maps
Music: Auxio, Lollypop, Music.app
Notes: Obsidian and Markdown-Oxide/Neovim
Password Management: Bitwarden
Podcasts: AntennaPod
RSS: NetNewsWire, Capy Reader
To-Do: Same as notes for writing the lists; taskfinder for tracking/organizing
Two-Factor Authentication: Aegis
Weather: Breezy Weather
Word Processing, Presentations, and Spreadsheets: LibreOffice

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

Music Listened in 2025

reillypascal@gmail.com (Reilly Spitzfaden) — Mon, 05 Jan 2026 15:41:00 GMT

Here's some of the music I've listened to in 2025 — things in regular rotation, things from a while ago that I've revisited, and new (or new-to-me) music I've added to my library of digital downloads/CDs.

New Listens

Charli XCX

I've listened to Charli XCX since before Vroom Vroom came out, but as is often the case with artists I like, I've been moving quite slowly through her discography. I hadn't given Number 1 Angel a proper listen, but I currently have “Lipgloss” on repeat. I love the over-the-top, scratchy synth design, and I actually tried my hand at recreating the lead part, to some success. Looks like the key is something that has a bright, buzzy formant — I tried using a kick drum-based wavetable, and some oscillator sync.

Fire-Toolz

Fire-Toolz' first album, Interbeing came out in 2017. I first heard of her with 2018's Skinless X-1, and while I bought Interbeing shortly after, I never really got into it until this year. This is common with me — Autechre, for example is pretty much my favorite group, but it took me a long time to get into albums other than Confield and Draft 7.30. This year I found that I actually really like the first track on Interbeing, “Yellow Rose-Fire.”

She also released a new mini-EP Private Angel Message “to hold us over until the next album.” Track 1 mixes a pounding disco beat, sparkly synths, chugging guitars, and metal screams. Track 2 is a metal-infused cover of a Trammell Starks song originally written for the Weather Channel — I remember reading an article where Angel Marcloid listed some of his work among her favorite music. Track 3 is an ambient electronic collage including acoustic guitar/voice recordings with lyrics no longer remembered by the artist.

William Fields

I got to see William Fields live with Autechre in Philadelphia this October, and this next one is actually a live recording of that concert! It was very cool to see live, and I'm glad he decided to release the set. It's available here on Bandcamp. William Fields uses REAPER's JSFX scripting tools to create custom interfaces for glitchy, rhythmically uneasy algorithmic music. ^[1]

Autechre

At the very end of 2025, I got Autechre's most recent live album, AE_2022–. It's taken me the longest to get into their live albums. The sets tend to be a long, monolithic performance that slowly morphs from one idea to the next over the course of an hour or more. Both in my composition and listening, I tend to prefer short and succinct, but after experiencing such a set live, I have a greater appreciation for the duo's live work — it feels more familiar now, and takes me back to a good experience I had.

Another reason I hadn't gotten this particular album is that (at 19 tracks of around an hour each) it's usually fairly expensive. It turned out that at the end of December/beginning of January, the Bleep listing of the album was on sale for half price, and I ended up buying and enjoying it. It has me interested in re-listening to the Philadelphia set I attended, or hearing some other sets from their 2025 North America tour — would be cool if they release those.

Kelley Sheehan

Kelley Sheehan is a composer whose work I've admired for a while. She pulls from a mix of underground noise music and contemporary classical performance practices, and her music has a wild riot of colors and strange sounds. I actually wrote about her composition “Talk Circus” for no-input mixer and percussion in my composition dissertation, along with a few other pieces that use audio equipment as instruments. I'd been wanting to have a release of hers I could buy from e.g., Bandcamp, so I was excited to see her release new ears with the Hoodwink Duo.

Meljoann

Meljoann describes their music as “hyperjack” — i.e., a hyperpop-like cousin of new jack swing. They released Status early this year, and I've been enjoying it a lot. “Translate Me” has a thick, detuned bass against floating synths and vocals, and a reggaeton-like beat. “Data Ghost” has trap hi-hats, a funky synth bassline, and an 80s power pop-like guitar solo in the middle. It's all very fun and danceable, with a healthy dose of chaos and genre-bending. Note that in addition to more well-known platforms, including Bandcamp, you can buy this album directly from the artist, via their Faircamp page! ^[2]

Regular Rotation

While I did listen to some new music this year, most of my listening has been familiar, comfortable things. Some of those tracks:

Autechre

“Dropp”
“VL AL 5”
“Tapr”
“Gantz Graf”
“qplay”
“Altibzz”
“V-Proc”
“plyPhon”
“Fol3”

Fire-Toolz

“Soaked: Another Name for Everything”
“✓ iNTERBEiNG”
“Experience ☆ Slips ☆ Away”
“Screamography”
“Second Life”
“Response To Subdivisions ☾”
“✓ BEiNG”
“Clear Light”
“觀音 Prayer For The Abuser (abridged)”

William Fields

“Doquado”
“Athal”

A fun note on this list is that my spouse and I used ”Altibzz” as background music in a video we showed at our wedding! My spouse told me they just wanted something that wasn't too cheesy, and I find this track to be hauntingly beautiful, and was happy with how it turned out.

Revisited

Subtle/13 & God

Subtle and 13 & God are both groups I loved in high school, and I've been listening to them again this year. Both groups are related: 13 & God is a collaboration between Doseone and Jel of Themselves and Subtle (and of other groups from the Anticon experimental hip-hop collective), and members of The Notwist. Both Subtle and 13 & God perform a mix of early 2000s alternative hip hop, trip hop, and indie rock, with rapper Doseone performing in a strange, dense style with dreamlike, abstract lyrics. I've been mostly listening to 13 & God's self-titled debut, and Subtle's For Hero: For Fool.

Postscript

Thanks for reading! If you also listen to any of the artists on this list (or similar ones you think I might like) I would love to hear about it — I have comments, email, and a webmention field below. Until next time!

Here, by “algorithmic,” I'm not referring to LLMs or related technology. Rather, as far as I understand, Fields uses probability and more ”classic” algorithms such as Markov chains — algorithms he has set up, rather than tools trained on others' work. ↩︎
Faircamp is a tool for creating a music streaming/download sales page directly on the artist's website, allowing listeners to pay the artist directly. ↩︎

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

On a Knife-Edge

reillypascal@gmail.com (Reilly Spitzfaden) — Tue, 09 Dec 2025 20:13:14 GMT

The clouds cascade above you in incredible detail. In places, their bases form an impenetrable ceiling, but that ceiling is temporary. Wisps of shadow float against glowing shards of the sun, illuminating another layer behind. The effect continues below the clouds. As you move forward, you can see the boundaries between light and dark projected on the ground. The changing brightness pulsates as it sweeps over you.

As you learn the contours above you, the scale of things shifts. The sky is closer now: close enough to visit, it seems, and its vault looks comfortable, as if you could live inside. You are much larger than before. Your body warps — for the moment, more spirit than matter — and your extremities flow up to nestle between the darkened floors, in the space of light between. You feel your heart rate slow, coming to rest after the day.

Remember when you would stir a giant basin of treacle in your mind's eye? Remember how the thoughts would catch on the circling waves, tearing and smearing, disappearing into the uniform surface? This feels kind of like then.

Eyes on the road

The violence of collision drifts into your thoughts. It seems to you now as if even its specter transforms your flesh into something new and strange.

Your flesh remembers the slam of impact, mere inches from your left arm, only the door's thin layer of metal and plastic separating you. It's as if those materials have punched an imprint into your skin and bone, staying there ever since. The acrid smell lingers in your nostrils, a mix of spent propellant and that strange harshness that sprang from within your head.

You've heard it said that if a machine never leaves your side, how different is it from an implant? You wonder where your body ends. You wonder what you would have to remove to become yourself again.

Eyes on the road

You glide along a knife-edge. All around is peaceful. It would be so easy to float into someone else, into something stable and fixed. How can you be flying and yet still at the same time?

***

You return your eyes to the clouds. They have blended together into a murky gray while you weren't looking.

⁂

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

Reverb Part 2—Natural Rooms with Allpass Rings

reillypascal@gmail.com (Reilly Spitzfaden) — Sun, 28 Sep 2025 16:16:34 GMT

Continuing from a previous post, today we'll be looking at another collection of reverb algorithms that I've implemented in my reverb plugin. With only a small increase in complexity over last time, we can get a reverb that grows in density over its duration, much as a real room would, and that sounds smoother and less metallic.

There are two key differences between the designs here and the Schroeder reverb I discussed previously: 1) in this design we will “nest” an allpass filter within another allpass filter, causing the echo density to grow over time, and 2) we will connect the ends of a chain of allpasses into one large “ring,” smoothing out the sound. Let's discuss how this all works!

Nested Allpass Filters

As we previously discussed, an allpass filter is created by a feedforward and feedback delay in series, with the gain of one of them being negative. This lets all frequencies through at equal amplitude, but delays different frequencies by different amounts, “smearing” or “blurring” the rhythmic attacks of an incoming sound, which is excellent for simulating reverberation. For the diagrams below, note that both the feedforward and feedback can use the same delay line — the design we're using is equivalent to two separate delays in series.

Schroeder found that the “smearing” from allpass filters multiplies the number of echoes about threefold. ^[1] However, the number of echoes is roughly constant over the duration of the reverberation. In a real room, echoes continually build up over the course of a reverb tail. To achieve this buildup, Barry Vercoe and Miller Puckette propose replacing the delay in an allpass filter with another allpass filter creating a “nested” structure. ^[2] Since an allpass filter will multiply the echoes that pass through it, taking the output of the inner allpass and feeding it back to the input will cause that multiplication to compound, increasing the number of echoes over time.

Below are diagrams of this design. Note that in addition to using a single allpass filter as the delay, we can use multiple allpasses in series, as well as combining them with simple delays. Gardner uses both options depicted below in the reverb algorithms we'll discuss today. ^[3] In the diagrams, $a i n$ and $a o u t$ are the input and output; the $\oplus$ symbol means the sum of two signals; and $g 1$ , $g 2$ , and $g 3$ are separate gain values, with these values made negative for feedforward signals.

A block diagram of a nested allpass filter ^[4]

A block diagram of a double nested allpass filter ^[4:1]

Allpass Rings

To multiply the echoes even further, Gardner chains a mix of standard and nested allpass filters in series, and then feeds the end of that chain into the chain's input. ^[3:1] Last time, we placed a low-pass filter in the feedback path of individual comb filters. This time, Gardner suggests placing a single low-pass filter in the feedback path for the entire chain. In both contexts, the purpose is to cause higher frequencies to decay faster, similar to the effect of the atmosphere in a real room.

Gardner also suggests taking the output sound from multiple points along the allpass chain. These must be between allpass filters, rather than inside an allpass — taking it from inside an allpass will transform the allpass into a comb, producing an undesirable metallic quality. The output signals can be scaled in different proportions to customize the decay profile of the reverb, and the gain in the global feedback path can be used to scale the decay time overall.

Both the multiple outputs and the ring structure prevent this reverberator from being allpass. The ring structure in particular is a comb filter, which (as we discussed previously) introduces comb tooth-like peaks and valleys in the frequency spectrum. While Gardner does not go into depth about why the comb filtering is acceptable, my best understanding is that it's because the series allpasses add together to create a long delay time.

As I discussed here, and as the audio example below demonstrates, feedback combs with longer delay times create an audible “flutter,” and shorter times create a metallic sound. The long time in the allpass ring means no metallic sounds, and because the chain of nested allpasses multiplies the echo density so much, the flutter isn't meaningfully audible.

Gardner's Reverb Designs

Below are the three designs Gardner gives. The small one is good for decay times between 0.38–0.57 seconds; the medium for 0.58–1.29 seconds; and the large for 1.30 seconds and above. Gardner does not find any particular rule for choosing decay times, noting that the process for designing the three topologies he describes was “purely empirical.” ^[3:2] As with designing Schroeder reverbs, a good starting point seems to be to avoid delay times that easily divide into each other; this ensures the delays do not rhythmically align. The first number next to a delay is the time in milliseconds, and the float value in parentheses is the gain.

Small room reverberator ^[3:3]

Medium room reverberator ^[3:4]

Large room reverberator ^[3:5]

Note that these designs have a mix of delays, allpasses, nested allpasses, and double nested allpasses. The medium reverberator also has two inputs, and applies the gain both in the feedback loop and in the middle of the allpass chain, directly before the second input.

Reverb Characteristics

Gardner describes these as “room” reverbs. While they are synthesized, not real rooms, it's still useful to look at the characteristics of the types of reverbs Gardner is emulating. First off, Sean Costello of Valhalla DSP describes room reverbs as having prominent early reflections.

Early reflections refer to sounds within the first 80 ms or so, followed by late reflections. Summarizing psychoacoustic research on the matter, Rungta et al. note that early reflections positively correlate with “the perception of auditory spaciousness,” are “very important in concert halls,” and can “improve speech clarity in rooms.” ^[5]

Rungta et al. also note that these early reflections help the listener hear the shape of the room. My best guess for why is because these reflections have traveled a short distance to the listener, maybe only reflecting a single time. This implies for “room”-type reverbs that we get a particularly strong sense of the room's dimensions. In my next post, I'll describe Dattorro's 1997 “plate”-style allpass ring, and we'll hear how that reverb sounds more amorphous, with less sense of space.

Direct sound, early reflections, and late reflections/reverberation; horizontal axis is time and vertical is amplitude ^[5:1]

In addition to these early reflections, Costello describes a dense sound and a short decay — these are usually smaller rooms than the reverb chambers in recording studios. Rooms also quickly build up echo density (here accomplished with the nested allpasses) and tend to be “colored,” i.e., they emphasize some frequencies over others. You may want to use an EQ on your reverb send track to reduce low frequencies on these algorithms, depending on your application. Costello suggests these may be useful for adding body to drums and acoustic instruments.

Postscript

These algorithms are all available in my algorithmic reverb plugin via the dropdown menu at the bottom. I also have Max/MSP abstractions of them available on my Codeberg. I would love to hear if you try them out!

As I mentioned, in my next post I'll cover the famous 1997 Dattorro plate algorithm that also uses an allpass ring structure. This is in Max/MSP as the [yafr2] abstraction, and in the Valley Audio “Plateau” module for VCV Rack, among numerous other places, and is likely based on an algorithm from the Lexicon 224/480 reverb units. I hope to see you then!

M. R. Schroeder, “Natural sounding artificial reverberation,” in Audio Engineering Society Convention 13, Audio Engineering Society, 1961. Accessed: Dec. 29, 2024. [Online]. Available: https://www.aes.org/e-lib/download.cfm?ID=343 ↩︎ ↩︎
Unfortunately this paper is unpublished, and I was only able to find William Gardner's description of it, ^[1:1] but here is the citation:

B. Vercoe and M. Puckette, “Synthetic Spaces — Artificial Acoustic Ambiance from Active Boundary Computation,” 1985, Music and Cognition Office at MIT Media Lab, Boston, MA. ↩︎
W. G. Gardner, “A realtime multichannel room simulator,” J. Acoust. Soc. Am, vol. 92, no. 4, p. 2395, 1992. Available: https://pubs.aip.org/asa/jasa/article/92/4_Supplement/2395/646024/A-real-time-multichannel-room-simulator ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎
H. Mikelson, “A Csound Multi-Effects Processor.” Accessed: Sept. 26, 2025. [Online]. Available: https://www.eumus.edu.uy/eme/ensenanza/electivas/csound/materiales/book_chapters/24mikelson/24mikelson.html ↩︎ ↩︎
A. Rungta, N. Rewkowski, R. Klatzky, and D. Manocha, “P-Reverb: Perceptual Characterization of Early and Late Reflections for Auditory Displays,” in 2019 IEEE Conference on Virtual Reality and 3D User Interfaces (VR), Mar. 2019, pp. 455–463. doi: 10.1109/VR.2019.8797914. Available: https://arxiv.org/pdf/1902.06880 ↩︎ ↩︎

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

A Certain Sickness

reillypascal@gmail.com (Reilly Spitzfaden) — Thu, 25 Sep 2025 12:38:00 GMT

You feel that a certain sickness has been pervading your life. It's a dull ache that suffuses subtly through many unrelated things, a background radiation to your everyday. You have tried removing possible sources, one by one, but in the wake of each, there is less to distract you, and the sickness only changes its form.

One day, you are walking back from your lunch and you cast your eyes on the ground. Even amid the concrete, asphalt, and stones stretching on forever, there is life. Shoots of green dart out from cracks. In a few patches the architects have left open, small trees. Further down your walk, someone has kept a small patch of woodchips and soil, holding a collection of flowers and bushes. Even the loose clippings and leaves on the concrete have a depth to them.

You feel the acceleration of the earth below you, its wide surface supporting you, its pull keeping you from falling into space forever. You note that you haven't thought of the sickness in several minutes.

* * *

Late that evening, as you take out the recycling, you hear birds. Their calls trace out the space around you — the city filtering and reverberating the calls more or less, and in different ways, depending on distance and location. You hear them (for once) without the filter of your thoughts overlaid. Their calls do not mean anything in particular, at least to you, and for that, you are grateful.

As your eyes pass over a patch of ground you see every day on returning home, you feel less real for a moment, but the patch is realer than it's been before. There are many others almost (but not quite) like it, and although your view is obstructed, you can sense them faintly beyond it.

On hearing the crickets in the distance, you decide to linger a moment longer. One sound is a continuous wave of trilling, many voices blending into one. In front of that (you can feel the depth of sound now), individual scratches are much clearer, less blurred by the air between you.

You recall that air functions roughly as a low-pass filter. You are at the bottom of a great ocean. It's really not that different from an ocean made of water, is it?

The waters pulsate around you. It feels peaceful though.

You continue back indoors.

Postscript

This was written for the September 2025 IndieWeb blog carnival. Sophia is hosting this month, and the theme is “second-person birds.” On her blog to ground, she writes about nature in the second person.

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

TTRPGs at the Library

reillypascal@gmail.com (Reilly Spitzfaden) — Sun, 31 Aug 2025 00:00:00 GMT

My local library has a TTRPG group (currently playing Pathfinder 2e). I sat in on a campaign today, the group was very welcoming, and I'm excited about it. I've wanted to get into D&D/TTRPGs for a while, but didn't have a group to do it with. While I hear Pathfinder is a bit more involved than some, I was able to get a copy of the rulebook to take home, and I'm invited to give it a go with making my own character and joining the party next weekend. It's especially nice because the library is right at the end of my street!

I enjoyed how it felt like manually stepping through a computer simulation — the whole time I was thinking of Ben Eater's videos about building a 6502 computer on a breadboard, in which he uses a pushbutton for a clock pulse at some points to manually step through things.

Lately I've been looking for 1) more things to do off the internet and 2) ways to make friends in my area. I made a lot of good friends in grad school, but now most of them have moved; the scarcity of academic jobs means a lot of moving around T-T. I've never been great at putting myself out there, so most of my friendships have developed from being in proximity to a lot of people, which doesn't work the same way out of school. This group seems lovely though, and I'm glad I pushed myself to give it a try.

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

Re: Turning towards the positive

reillypascal@gmail.com (Reilly Spitzfaden) — Wed, 27 Aug 2025 18:00:00 GMT

Tracy Durnell's recent post resonates with what I've been doing lately to make my computer usage more pleasant.

I've been in the habit of compulsively checking notifications (Mastodon, RSS, YouTube subscriptions, etc.), and I figured out that staying away from that, and using my computer for local things is much nicer. A few specific local things I've been enjoying:

I've wanted to learn the live-coding tool Tidal Cycles for a while now, and I'm finally doing that. Here's a Tidal Cycles performance by Lil Data, and here's one by Moxus (super glitchy and noisy!). This tool is nice because I can code and have my coding be immediately musical.
I've started knitting, and my goal is that once I'm comfortable with some basic stitches, I can use code to generate patterns. I was inspired to do this by Sophia's project using p5.js to generate knit beanie patterns. This is a nice way to feel connected to my programming/computer interests without actually needing to be online or even use a computer for the full project.

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

ルビとHTML

reillypascal@gmail.com (Reilly Spitzfaden) — Tue, 19 Aug 2025 21:14:00 GMT

最近(さいきん)HTMLでルビを振(ふ)ることのやり方(かた)を知(し)た!

Or in English, “I recently learned how to write ruby characters in HTML!”

Japanese writing uses multiple different sets of characters. Chinese ideographic characters (called “kanji”) encode an idea rather than a sound and can have multiple pronunciations. Kana are phonetic characters that each represent one syllable.

Ruby characters are kana placed above kanji to indicate the pronunciation — these are common in educational materials, children's/YA books, or for kanji outside the list of jōyō (“regular-use”) kanji, among other uses. Because there are many more kanji than kana, and their pronunciation can be complicated to learn, the ruby characters make reading easier.

I took some Japanese classes in undergrad, and while I haven't kept up with it, I recently stumbled across the HTML markup for ruby and thought it was a cool thing to know. The markup for the first word from the above example, “saikin” (“recently”) is shown below. The whole thing is enclosed in <ruby> tags; the <rp> tag surrounds parentheses for the pronunciation; and <rt> surrounds the phonetic gloss. This gives a fallback of placing the pronunciation in parentheses after the kanji — i.e., as 最近 (さいきん) — if a browser doesn't support rendering ruby characters, while allowing the parentheses to be hidden and the phonetic gloss placed above on browsers that do support this.

<ruby>最近<rp>(</rp><rt>さいきん</rt><rp>)</rp></ruby>

This all has gotten me a bit nostalgic for learning Japanese, and I think I'll try tracking down my old textbooks. Because I love typography and web standards in general, it would also give me more typographic practices to try out on my blog — depending on how returning to Japanese goes, it would be cool to try writing some posts in Japanese.

This also might give me the chance to get internet feedback on my Japanese. One of the reasons I never stuck with it is that even when I was decent at it, I had a lot of anxiety seeking out conversation partners with whom to practice. Writing online doesn't feel as intense though, so that could be a good way to get feedback. We'll see how it goes!

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

Location Test

reillypascal@gmail.com (Reilly Spitzfaden) — Tue, 19 Aug 2025 18:45:00 GMT

Jo has been using the code I use to get post locations for my /now page statuslog section to add locations to her notes. I realized it would be nice to add it to the script I use to generate note templates as well!

While most of my blog posts are written from home and not associated with a place, I have a number of notes from trips with my partner that aren't just in Rochester.

I like the “vibe” of connecting things on my site to a physical place, so this should be nice to add.

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

We're Getting Married!

reillypascal@gmail.com (Reilly Spitzfaden) — Sat, 16 Aug 2025 23:18:00 GMT

Eli and I are engaged, and we're getting married later this year! I'm really excited to spend the rest of my life with them. We didn't feel like doing an engagement photoshoot, but here are some nice photos from some of the hikes and other outdoor trips we like to do together.

In front of a marble cave at the Natural Stone Bridge & Caves park in the Adirondacks

This is at Lester Park in Saratoga Springs, NY and the ground below us is a 490 million year-old lake bed covered in stromatolite fossils!

More of the stromatolite fossils. It makes me happy looking at this photo and seeing Eli so excited.

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

IndieWeb Carnival: Tone Colors

reillypascal@gmail.com (Reilly Spitzfaden) — Mon, 11 Aug 2025 22:05:00 GMT

Movement III, “Farben” (“Colors”) from Arnold Schoenberg's Five Pieces for Orchestra, Op. 16 begins very subtly. Two different groups in the orchestra alternate on the same hushed, eerie chord. As this slow, regular pulsation continues, some notes in the chord move up or down very slightly while others remain the same, gradually transforming the harmony.

Throughout the movement, there is almost no melody in the traditional sense. Rather, by keeping the pitch material nearly static while alternating different instruments (or combinations of instruments), Schoenberg foregrounds the timbre or “tone-colors” of the orchestra — the aspects of sound by which we can tell, for example, a trumpet from a violin.

He describes what he is doing as klangfarbenmelodie or “tone-color melody.” By composing this way, he seeks to have the listener perceive this changing of “tone-colors” with “a kind of logic entirely equivalent to that logic which satisfies us in the melody of pitches.” ^[1] In other words, just as a more traditional melody might have a distinctive sequence of pitches (often associated with a similarly distinctive rhythm), we can apply the same type of listening to a sequence of timbres, as well as writing music that encourages this type of listening.

Color in My Earlier Music

In my first year of college, I stumbled across a score page for Anton Webern's Concerto for Nine Instruments, Op. 24 discarded in a practice room — likely homework from some classmate's 20th-century music theory class. Webern was one of Schoenberg's students and someone who also made use of klangfarbenmelodie, and this piece was my entry point to that idea, among many other musical concepts. My Nonet from 2014, and movement III in particular is a good example of my use of this technique.

Where Schoenberg's prototype of klangfarbenmelodie in his “Farben” movement uses slowly morphing chords, the opening of movement III of my Nonet is highly pointillistic — more like how Webern tended to write. In the first two measures, the horn, bass clarinet, and cello each play a short motive, transposing and manipulating it each time, with each instrument just barely overlapping with the end of the previous one. This rapid passing of short ideas between instruments sets the tone for the rest of the composition.

We can listen to this pointillistic call-and-response in a similar way to how we did in the Schoenberg example. While the musical material is much more active in my piece, the shifts in tone color also occur in quicker succession, and are often accompanied by large register jumps. In addition, almost all of the material derives from that 5-note motive from the first measure. While the melody is quite dissonant, angular, and chromatic, deriving most things from this one short motive gives a consistent overall character or “vibe” to the piece.

The combination of a consistent character to the melody with large contrasts in timbre and register encourages the listener to focus on the overall quality and color of the sound, rather than trying to follow the specifics of the melody. When I listen like this, the rapid klangfarbenmelodie shifts in tone color become particularly clear.

This pointillistic approach of rapidly passing ideas between instruments appeared regularly in many other compositions of mine around this time, and as I wrote this way, I took particular interest in the shifting timbres that resulted.

Color in My Recent Composition

Some 13 years after my Nonet, it's interesting to look back on what has changed and what has stayed the same in how I use color in my music. I composed If this reaches you in 2021, and it was recorded in 2024. The details of my approach are very different, but the emphasis on sound and timbre, and the pointillistic, thin textures are still there. This piece is for MIDI keyboard (controlling a custom software setup in Max/MSP), flute, and clarinet. The flutist briefly uses a bass bow on a cardboard box in the middle, as well. The MIDI keyboard plays a combination of electric piano and sampled amateur radio sounds — I wrote about using radio transmissions in my compositions in another post.

Where the things that made the Nonet sound unusual were the choice of pitches and rhythms, in If this reaches you, the focus is a bit more on sound than pitch. In addition to the “non-musical” radio samples, I also use a number of so-called “extended techniques,” particularly in the clarinet. Clarinetist Heather Roche's blog is a great source of information on how these work, and I use various different multiphonics, double trills, and other unusual sounds. At the same time, the way I combine these sounds is still quite pointillistic, and emphasizes rapid shifts between the different kinds of noise.

When I do use clearly pitched material, my more recent compositions tend to be a bit more “tonal” than the Nonet — less chromatic, and leaning more toward “cheesy” 80s pop, lounge music, or electronic dance music sounds. For example, the piano chords — both notes and instrument sound — in If this reaches you starting at around 0:58 sound like lounge/elevator music mixed in amid the noisy samples and flute/clarinet sounds. The synth chords and scooping accents in the sax melody in the opening of Outlive everything you know sound reminiscent of house music, again mixed in with a kaleidoscope of strange glitches and multiphonics.

Someone I admire who manages to pull together “cheesy” synth sounds with experimental electronics (as well as metal and many other things!) is Fire-Toolz. Listen how the opening of Soaked: Another Name for Everything moves from acoustic guitar to 80s power ballad to glitchy sound collage, to some sort of prog-rock/elevator music hybrid at the end. Extremely colorful, and while her music is very different from Schoenberg, the quick movement between different tone colors is an integral part of her work too.

Wrapping Up

Marisabel is hosting this month's IndieWeb carnival on the topic of colors, and this is my contribution. I had been looking forward to writing on this topic since I saw it on the list of upcoming events. I've been enjoying other people's entries, and thanks to Marisabel for hosting! I've particularly enjoyed this exercise of looking at my past work because it has given me some ideas for a current composition project — more info on that as I compose. Until next time!

Schoenberg, Arnold. Theory of Harmony. Translated by Roy E. Carter. University of California Press, 1978. ↩︎

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

Plugins for Everyone! Cross-Platform JUCE with CMake & GitHub Actions

reillypascal@gmail.com (Reilly Spitzfaden) — Fri, 01 Aug 2025 18:31:00 GMT

I have a few C++/JUCE audio plugins I've worked on off and on over the last couple of years. I've wanted them to be available to anyone who's interested, but I previously wasn't able to get them compiled for Windows (and Linux was very inconvenient).

I'm now able to easily compile them for Linux, macOS, and Windows using the JUCE CMake API and GitHub actions. Let's look at how that works!

My Starting Point

The JUCE C++ framework is a popular way to build audio plugins. When you first learn it, the tutorials show how to build projects using the “Projucer” GUI tool. This generates project files for Visual Studio, Xcode, and Linux Makefiles. It's a convenient and well-documented way to work if you're only building for one platform, but if you want to compile for multiple OSes, you need to have each OS available to work with (in order to run the appropriate GUI program for which the Projucer generates files). Since my primary computer is a MacBook, I've only had compiled releases for macOS. This was where I was when I started learning the CMake API.

CMake and JUCE

When I started on the JUCE CMake API, I had next to no experience with CMake. The official website has this nice web book Mastering CMake. Among other things, it has a step-by-step tutorial and documentation for the cmake CLI command, which were particularly helpful. You can also look at the examples in the JUCE examples/CMake folder for reference on the JUCE end of things.

Below is the CMakeLists.txt file for my algorithmic reverb plugin—this goes in the root directory. Let's go through line by line:

The cmake_minimum_required statement should be the first line in any CMakeLists.txt file.
Without set(CMAKE_EXPORT_COMPILE_COMMANDS ON), my text editor (currently using Zed and Neovim) can't find the JUCE imports it needs.
The project statement gives the name/version.
add_subdirectory(JUCE): if you clone the JUCE framework into the working directory (git clone https://github.com/juce-framework/JUCE.git), this statement will make the resulting folder available.
- I've seen the CPM package manager used (e.g., in this video from WolfSound) to bring in these dependencies, but I was having some kind of issue with dependencies being included twice and decided to figure that out later.
The juce_add_plugin line is from the JUCE API. This contains a list of options and metadata for the plugin.
- Note in particular COPY_PLUGIN_AFTER_BUILD TRUE, and the following two lines VST3_COPY_DIR "/Library/Audio/Plug-Ins/VST3" and AU_COPY_DIR "/Library/Audio/Plug-Ins/Components". If you uncomment these, CMake will copy the plugin files to the given directories after building. You don't want this for the GitHub actions,
juce_generate_juce_header generates the JuceHeader.h file. As the link above describes and Sudara demonstrates, if you're not using the Projucer you can include the JUCE module(s) you need directly.
target_sources lists the .cpp that need to be included in the project.
target_compile_definitions adds preprocessor definitions to the target—see the options used below.
target_link_libraries: in the PRIVATE field, we include the JUCE modules we're using in this project. In the PUBLIC field, we include some recommended flags.

cmake_minimum_required(VERSION 3.22)

set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

project(RSAlgorithmicVerb VERSION 0.5.5)

add_subdirectory(JUCE)                    # If you've put JUCE in a subdirectory called JUCE

juce_add_plugin(${PROJECT_NAME}
    # VERSION ...                               # Set this if the plugin version is different to the project version
    # ICON_BIG ...                              # ICON_* arguments specify a path to an image file to use as an icon for the Standalone
    # ICON_SMALL ...
    COMPANY_NAME "Reilly Spitzfaden"                          # Specify the name of the plugin's author
    BUNDLE_ID "com.reillyspitzfaden.RSAlgorithmicVerb"
    IS_SYNTH FALSE                       # Is this a synth or an effect?
    # NEEDS_MIDI_INPUT TRUE/FALSE               # Does the plugin need midi input?
    # NEEDS_MIDI_OUTPUT TRUE/FALSE              # Does the plugin need midi output?
    IS_MIDI_EFFECT FALSE                 # Is this plugin a MIDI effect?
    # EDITOR_WANTS_KEYBOARD_FOCUS TRUE/FALSE    # Does the editor need keyboard focus?
    # Should the plugin be installed to a default location after building?
    # COPY_PLUGIN_AFTER_BUILD TRUE
    # VST3_COPY_DIR "/Library/Audio/Plug-Ins/VST3"
    # AU_COPY_DIR "/Library/Audio/Plug-Ins/Components"
    PLUGIN_MANUFACTURER_CODE Rspi               # A four-character manufacturer id with at least one upper-case character
    PLUGIN_CODE Rsav                            # A unique four-character plugin id with exactly one upper-case character
                                                # GarageBand 10.3 requires the first letter to be upper-case, and the remaining letters to be lower-case
    FORMATS AU VST3                  # The formats to build. Other valid formats are: AAX Unity VST AU AUv3 Standalone
    PRODUCT_NAME "RSAlgorithmicVerb")        # The name of the final executable, which can differ from the target name

juce_generate_juce_header(${PROJECT_NAME})

target_sources(${PROJECT_NAME}
    PRIVATE
        Source/ConcertHallB.cpp
        Source/CustomDelays.cpp
        Source/DattorroVerb.cpp
        Source/EarlyReflections.cpp
        Source/FDNs.cpp
        Source/Freeverb.cpp
        Source/GardnerRooms.cpp
        Source/LFO.cpp
        Source/SpecialFX.cpp
        Source/PluginEditor.cpp
        Source/PluginProcessor.cpp)

target_compile_definitions(${PROJECT_NAME}
    PUBLIC
        # JUCE_WEB_BROWSER and JUCE_USE_CURL would be on by default, but you might not need them.
        JUCE_WEB_BROWSER=0  # If you remove this, add `NEEDS_WEB_BROWSER TRUE` to the `juce_add_plugin` call
        JUCE_USE_CURL=0     # If you remove this, add `NEEDS_CURL TRUE` to the `juce_add_plugin` call
        JUCE_VST3_CAN_REPLACE_VST2=0)

target_link_libraries(${PROJECT_NAME}
    PRIVATE
        # AudioPluginData           # If we'd created a binary data target, we'd link to it here
        # juce::juce_analytics
        juce::juce_audio_basics
        juce::juce_audio_devices
        juce::juce_audio_formats
        juce::juce_audio_processors
        juce::juce_audio_utils
        juce::juce_core
        # juce::juce_cryptography
        juce::juce_data_structures
        juce::juce_dsp
        juce::juce_events
        juce::juce_graphics
        juce::juce_gui_basics
        juce::juce_gui_extra
        # juce::juce_opengl
        # juce::juce_osc
        # juce::juce_video
    PUBLIC
        juce::juce_recommended_config_flags
        juce::juce_recommended_lto_flags
        juce::juce_recommended_warning_flags)

With this CMakeLists.txt, you can run cmake -S . -B build in the root directory to create the build environment. This means the source is the root directory, and build is the build directory. You can add the flags -D CMAKE_BUILD_TYPE=Debug or -D CMAKE_BUILD_TYPE=Release to specify debug/release builds. After that, run cmake --build build to compile. Note that if you have the COPY_PLUGIN_AFTER_BUILD TRUE option in juce_add_plugin, you will likely need to add sudo to both of the build commands since my installation directories above are system ones.

Compiling with GitHub Actions

The nice thing about using CMake is that it doesn't require a desktop GUI program like Xcode or Visual Studio, meaning that it's possible to use something like GitHub actions to compile in the terminal on virtual versions of the target OSes. For my build action, I referenced Sudara's Pamplejuce template. This is the file .github/workflows/cmake.yml. I have this set to manually trigger, and if you go to the “Actions” tab for your project, you can trigger a build using the GUI.

The file is fairly straightforward, but I'll point out some specifics. on: [workflow_dispatch] means that you manually trigger the build. The matrix strategy allows for running multiple copies of the job, in this case, on macOS, Ubuntu, and Windows.

The first two steps, which only run on Linux, are taken directly from Pamplejuce's example .yml file. Note however that the current version of the Linux dependencies is slightly different, and I had to adjust accordingly.

After this, we check out the project repo, clone the JUCE repo, and run (almost) the same CMake commands as above. Note that we specify the Release build when we actually build, rather than when we set up the build, and that the syntax is a bit different: --config Release. -D CMAKE_BUILD_TYPE only seems to work on *nix OSes, not on Windows.

Finally, we archive the build artifacts (i.e., the compiled files). Note that I append ${{ runner.os }} to the end of the artifact name. This is important—without it, the artifacts for each OS will all be named the same thing, and the process will fail due to path conflicts.

name: rsav-compile

on: [workflow_dispatch]

jobs:
  build:
    runs-on: ${{matrix.os}}
    strategy:
      matrix:
        os: [macos-latest, ubuntu-latest, windows-latest]

    steps:
      # Use clang on Linux so we don't introduce a 3rd compiler (Windows and macOS use MSVC and Clang)
      - name: Set up Clang
        if: runner.os == 'Linux'
        uses: egor-tensin/setup-clang@v1

      - name: Install JUCE's Linux Deps
        if: runner.os == 'Linux'
        # Official list of Linux deps: https://github.com/juce-framework/JUCE/blob/develop/docs/Linux%20Dependencies.md
        run: |
          sudo apt-get update && sudo apt install libasound2-dev libjack-jackd2-dev \
              ladspa-sdk \
              libcurl4-openssl-dev  \
              libfreetype-dev libfontconfig1-dev \
              libx11-dev libxcomposite-dev libxcursor-dev libxext-dev libxinerama-dev libxrandr-dev libxrender-dev \
              libwebkit2gtk-4.1-dev \
              libglu1-mesa-dev mesa-common-dev

      - name: "Preparation"
        uses: actions/checkout@v2

      - name: "(JUCE) Clone Repository"
        uses: actions/checkout@v2
        with:
          repository: juce-framework/JUCE
          path: ${{runner.workspace}}/RSAlgorithmicVerb/JUCE

      - name: "Create Build Environment"
        working-directory: ${{runner.workspace}}/RSAlgorithmicVerb
        run: cmake -S . -B build

      - name: "Build"
        working-directory: ${{runner.workspace}}/RSAlgorithmicVerb
        run: cmake --build build --config Release

      - name: Archive build artifacts
        uses: actions/upload-artifact@v4
        with:
          name: "RSAlgorithmicVerb_${{ runner.os }}"
          path: ${{runner.workspace}}/RSAlgorithmicVerb/build/RSAlgorithmicVerb_artefacts/

Linux Build Issues

Frustratingly, this all works perfectly for Mac and Windows, but gives me a perplexing issue on Linux. The GitHub action works without issue on all OSes. However, when I use pluginval to validate the Linux build on Debian 12.11, I get the following error for both the “open plugin (cold)” and “open plugin (warm)” tests:

!!! Test 1 failed: Expected value: , Actual value: Unable to load VST-3 plug-in file
!!! Test 2 failed: Unable to create juce::AudioPluginInstance

When I try to load the plugin in REAPER (same distro/version), the DAW detects that the plugin exists but won't load it. However, if I manually compile on my Debian laptop using CMake, everything works fine! The only other clue I've been able to find is that the VST3 RSAlgorithmicVerb.so file is significantly bigger when I use the GitHub action than when I manually compile it—31.9 MB, instead of 5.1 MB. At this point, I've decided to manually compile the Linux version, although I would very much like to figure this issue out, if anyone has any idea!

Wrapping Up

Please check out the releases for my reverb plugin—it's available for Linux, Mac, and Windows! This is the only one for which I've set up this workflow, but next on my list is my telecom codec plugin—I want to to add a C++ version of the Rust ADPCM codec I wrote about previously, for example.

For the time being, I don't have the full release and validation process automated. I decided to leave it as is since the main reason I want to do this is so I have easy access to Windows/Linux compilers. As a next step, I would like to reference the Pamplejuce workflow file and finish automating that. The example uses the Xcode pkgbuild utility and Tracktion's pluginval validator, and it would be very convenient. Until next time!

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

Powder Mills USGS Gaging Station

reillypascal@gmail.com (Reilly Spitzfaden) — Sun, 20 Jul 2025 19:07:10 GMT

My partner and I took a walk at Powder Mill Park in upstate NY to look at the mushrooms and fish hatchery. While we were there, I came across the transmitter for a United States Geological Survey (USGS) stream gaging station—you can go to the link and see the data from this station.

I've been interested in cataloging the stations I see since I saw Sarah from Signals Everywhere's video on the transmitters for these stations. I previously found one at Ellison Park and got some pictures of both the transmitter and what I believe is the sensor. According to Sarah, the stations uplink the data in the UHF band (~401 MHz) to the GOES weather satellites, which relay the data back down for processing by the National Environmental Satellite, Data, and Information Service (NESDIS). My photos from today are below:

I've long thought it would be cool to connect the data from these to some sort of musical result, but I haven't figured out a satisfying way to do that—a way to both make the data meaningfully present in the music and make interesting music, rather than something blandly demonstrative of the data.

Reply via email :: Subscribe to my other feeds :: Buy me a coffee

Photoblog: Natural Stone Bridge & Caves

reillypascal@gmail.com (Reilly Spitzfaden) — Wed, 02 Jul 2025 02:41:29 GMT

I went with my partner to the Natural Stone Bridge & Caves park in the Adirondacks for their birthday. They love rocks and geology, and really wanted to go here.

From what they told me, this park was originally gifted to a family as thanks for their efforts in the American Revolutionary War, and after a long time as a sawmill, later members of the family converted it to a park.

The cave behind us is made of marble, and was formed from a collapse several decades ago—I think in the 90s.

My partner standing in the aptly-named “Noisy Cave,” which resounded with rushing water.

The view out of “Noisy Cave”

This area was down in a gorge between two banks. Everything around us was rocks.

Reply via email :: Subscribe to my other feeds :: Buy me a coffee