Reilly Spitzfaden | Blog

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

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

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

ルビと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

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

IndieWeb Carnival: Take Two

reillypascal@gmail.com (Reilly Spitzfaden) — Mon, 23 Jun 2025 12:16:00 GMT

Nick Simson is hosting this month's IndieWeb Carnival on the theme “take two.” After having needed to pick a new topic, he writes

Ever wish for a do-over? “Take two!” (or three, four, etc.) might be shouted by a film director or audio engineer looking to get a somewhat different outcome from a group of actors or musical performers. Would you like a second shot at something that didn’t land?

I immediately thought of my current experience of composing when I read this. I have a composition that I started back in summer 2023 for which I still haven't written much in the way of notes on the page. I tend to start a composition by working in Max/MSP, usually using some combination of databending and software-defined radio (SDR) samples; sequenced/probabilistic sample/synth patterns; and VST synths/electric pianos, with these different categories assigned to different regions of a MIDI keyboard.

In addition to patching in Max, this process requires composing samples (usually in Logic Pro) to “glitch up” or otherwise manipulate in Max; digging through large collections of “databending” files; sessions of scanning the airwaves on my SDR equipment and recording what I hear; and more recently, coding projects such as my script to glitch up MP3s, my tool to automate the databending process, or my implementation of the VOX ADPCM codec to get more variety in databending.

Nathan Ho describes what he calls “system-building syndrome”. For context,

Synthesizer forums have a long-running joke about “Gear Acquisition Syndrome” that pictures the stereotypical hobbyist with all their Hainbach-endorsed gear, seemingly oblivious to the fact that they’re intended for making music.

In using SuperCollider and C++ to make his own versions of this kind of gear, he comments that

I thought I was being clever circumventing [Gear Acquisition Syndrome (GAS)] by building everything myself, but what really happened is that I had fallen into my own version of GAS: I had System-Building Syndrome.

As I program and patch my own electronic music tools and setups, I find myself in the exact same position of making music tools instead of actually making music. For my “take two” I'm throwing out a bunch of material (or rather putting it in a safe place to draw from later) and restarting this piece with a different approach. I'll discuss how I seem to have ended up here and some recent thoughts about composition that I'm hoping can take me out of this rut.

Why Do I Keep Building Systems?

Two things I like that are challenging to do to my satisfaction are 1) I like to write thin, pointillistic textures, and 2) I like when a composition seems to “float” (rather than drilling a pulse into me) but at the same time has rhythmic energy. For both of these, see the opening of If this reaches you. The bursts of clarinet and sampler float around a rhythmic “backbone” in the flute and sampler. This backbone consists of a clicking tremolo from using an electromagnetic pickup on a wi-fi router, ^[1] and a syncopated, metronome-like pattern of 8th and quarter notes in the flute, sitting on a single pitch for a while.

While I'm happy with If this reaches you, I've struggled for a while to write something else that satisfies me in the same way, and I've particularly struggled with creating the right rhythmic “backbone.” As further examples of what I like, Autechre's Tapr and qplay (among others) have drum machines, but there is enough irregularity in the rhythm that I can relax and let go of pulse, while still enjoying the energy and character of the beat. Despite how much I like Autechre, I have different goals that make things more complicated.

I'm writing something in between the experimentalism that comes out of dance or “popular” music and the experimentalism that comes out of “classical music” circles. ^[2] As I've heard composer peers flippantly joke, in some ways the distinction comes down to “does it have a (drum) beat?” Drum sets/drum machines are very bold musical elements and require careful recording and sound design to sound right, and between that and my desire to work between “popular”/“classical” experimentalism, I have very exacting requirements for how the rhythmic backbone should sound. At the same time, because I want to make something that sounds “fresh” to my ears I don't even fully know what I'd like to hear. ^[3]

Take Two

Because I've tried so many different things, the Max patch and the surrounding file folders for my current project have become unworkable. It took a huge load off my shoulders to make a backup copy of the folder and then throw out most of the files and patching from the working copy. The couple of elements that were already working great stayed, and I got a nice blank slate to start again.

I'm still in the process of selecting samples for my Max patch, but instead of spending so much time designing sequencers and percussion patterns, I've been looking at the simple materials I used for If this reaches you and seeing what I can accomplish if I hold myself to that kind of simplicity this time around too. ^[4]

I've reminded myself that this doesn't mean I've wasted my time. On the contrary, the time I've spent on this project has given me a lot of practice on audio programming, sound design, and Max/MSP drum sequencing. The things I played with in this time haven't gone away either; I can return to the backup folder at any time to borrow bits of what I worked on.

Wrapping Up

Thanks to Nick for hosting this month's carnival! This topic helped me write about and think through something that's been percolating for a while, and I'm hopeful that it will help my composition process moving forward. Until next time!

I've found that many routers make a similar sound, although I'm not sure what feature that is. ↩︎
For experimental music I like from “popular music” circles, see also Fire-Toolz (example tracks: Clear Light or Soaked: Another Name For Everything). From a “classical music” background, I particularly like Kelley Sheehan (Talk Circus), Simon Steen-Andersen (on and off and to and fro), and Alexander Schubert (Serious Smile). ↩︎
To some extent, I'm sure the desire for something new and previously unheard comes from my enjoyment of 20th century modernism, and from absorbing the ideas from those circles. It's a goal I've interrogated for a while, and I may move on from it at some point—at any rate, I realize it's someting worth questioning! ↩︎
In addition to what I described above, this piece was the first one I wrote with significant use of Max/MSP, and all it uses is a sampler of databending/radio sounds on the bottom keys, and an electric piano VST on the upper ones. I'm hoping that sticking to this kind of minimal setup may help focus my work. ↩︎

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

Reverb Part 1—“Freeverb”

reillypascal@gmail.com (Reilly Spitzfaden) — Thu, 05 Jun 2025 15:30:00 GMT

I started work on a reverb plugin in C++/JUCE back in 2023, and I've slowly added to it since. Today, I'm going to discuss how algorithmic (i.e., delay-based) reverbs work using the “Freeverb” algorithm that's available in that plugin. I've included a Max/MSP version of the reverb, and in a later post, I will discuss getting our hands dirty with the code in C++/JUCE, as well as a number of other cool algorithms. Let's get started!

How Reverb Works

There are two main categories of digital reverb—convolution and algorithmic—and today we will be discussing algorithmic reverb. An algorithmic reverb is based on a network of delays or “echoes,” with individual delays roughly corresponding to the sound reflections from individual walls or objects, and the network of connections between them simulating the way a reflection from one surface may bounce off many others.

Sean Costello of Valhalla DSP has a series of posts giving helpful resources on reverb design, including influential papers, online resources, and books, and you can find the type of algorithm we'll discuss today among the papers he mentions.

Feedforward and Feedback Delays

In the most basic form of delay, we take a copy of the incoming audio signal, delay it by a certain amount, and combine it with the original signal, usually with the option to adjust the proportions of original and delayed copies. To contrast with the other types of delay, this is often referred to as a “feedforward” delay—the delayed copy is “fed forward” and recombined with the original without any “feedback,” which we will discuss in the next section.

In the diagram below, $x (n)$ represents the incoming signal; $z^{- M}$ is the delay block (with $M$ representing the amount of delay in samples); ^[1] $b_{0}$ and $b_{M}$ represent the amount of gain applied to the original and delayed copies respectively; ^[2] the $+$ symbol represents summing the two copies; and $y (n)$ is the output signal.

Feedforward delay/comb filter (diagram from Julius O. Smith)

Next, we have a “feedback” delay. Note how in the diagram below, the incoming signal is summed with the fed-back output of the delay before entering the delay; the gain $- a_{M}$ applied to the fed-back output of the delay is negative; and the output of the whole delay $y (n)$ is taken from that sum of the input and feedback before it enters the delay.

Feedback delay/comb filter (diagram from Julius O. Smith)

Allpass Filters

Below I have the amplitude curves from feedforward and feedback delays, caused by constructive and destructive interference. The repeated notches in the feedforward delay frequency plot are caused by destructive interference; adding the delay to the original signal causes certain frequencies to cancel out. In the feedback example, as the sound feeds back on itself, certain frequencies constructively interfere—they reinforce each other and create the “spikes” in the amplitude response. Both of these delay configurations are also referred to as “comb filters,” due to the shape of the spikes and notches.

Feedforward comb filter amplitude plot (diagram from Julius O. Smith)

Negative feedback comb filter amplitude plot (diagram from Julius O. Smith)

Notice how the feedforward and feedback amplitude responses are the inverse of each other. Having a negative gain in the feedback loop of a feedback delay is necessary for the peaks to align with where the troughs would be in a feedforward delay that has the same delay time. As shown here, if the feedback delay's gain were positive, the peaks would be at 0.2, 0.4, etc., instead of 0.1, 0.3, etc.

This alignment is important for our next type of filter: the “allpass” filter. As shown below, we combine a feedforward delay with a feedback delay that has a negative gain on the feedback. As a result, our peaks and troughs in the frequency response cancel out. This kind of delay configuration has a “flat” frequency response; all frequencies pass through at the same loudness.

Allpass filter (diagram from Julius O. Smith)

In contrast to the frequency response, our time response is much more complex. An allpass filter delays the different frequencies in the signal by different amounts. As a result, a single impulse or “click” going through it would become multiplied and “smeared” in time, giving the effect of multiple clicks piling on top of each other, a very useful effect for creating a smooth- and dense-sounding reverb.

Now let's put these all together to make a reverb!

The Classic Schroeder Reverberator

Series Allpasses

Manfred Schroeder has two papers from 1961 that introduce the idea of allpasses and using them for reverberators.

In “Colorless” Artificial Reverberation, ^[3] Schroeder and co-author B.F. Logan note six features that they seek from a delay-based reverberator:

There should be a flat frequency response
Normal modes (i.e., resonant emphases on specific frequencies) “must overlap and cover the entire audio frequency range”
Different frequencies should decay at the same or similar rate
There should be high echo density within a short period after an impulse
Echoes must be non-periodic (i.e., no “flutter echoes”)
“Periodic or comb-like” frequency responses must be avoided

Below, I have an 808 drum machine clap played through a feedback comb filter. The delay is set at successively shorter lengths, from 50ms down to 5ms. Notice how at longer delay times, there is a “fluttering” tremolo effect. This is similar to the echoes with two walls directly facing each other, as in a long, narrow hall. At shorter lengths, there is an audible tone created by the repeated echoes. Both of these features are undesirable in a reverb effect.

In “Colorless” Artificial Reverberation, Schroeder and Logan propose a chain of allpass filters as an answer to this issue. The allpass filter is already better than the feedback comb at creating smooth-sounding results, and to improve on this further, the authors suggest “incommensurate” delay times. In other words, the delay times do not easily divide into each other, preventing the echoes from one allpass from lining up with another. The result of the incommensurate delay times is something more like the random tapping of rain, rather than any periodic rhythm.

On this algorithm, Sean Costello comments that

The resulting reverberator structure is a bit hard to tune, as both the reverb attack and decay are controlled by the feedforward/feedback allpass coefficient, and is less “general purpose” than the structure discussed in Schoeder’s next paper.

As Costello then mentions, some reverbs such as the Eventide Blackhole make artistic use of the weirdness of this structure. However, it would be helpful to have a more general-purpose algorithm.

Below I have a synth riff: first the dry signal, then a mix of the dry signal with a “wet” signal through 8 series allpasses. For the allpass example, I increase the feedforward/feedback parameter from about 0.1 up to 1, then back to 0.1 again.

As mentioned, this doesn't sound as natural as we'd like, as well as not being super flexible. It's a start though, and our next version will sound much nicer.

Parallel Combs into Series Allpasses

In Natural Sounding Artificial Reverberation, ^[4] Schroeder proposes the class of algorithm shown below. Feedback comb filters create a nice exponential amplitude decay (unlike the allpass chain in which, as mentioned above, both attack and decay depend on the same parameter). In response to the problem of “coloration” in the frequency spectrum, Schroeder notes that

extreme response irregularities are imperceptible when the density of peaks and valleys on the frequency scale is high enough

In other words, if we combine several feedback comb filters in parallel, the “comb teeth” in their frequency spectra will tightly “interlock,” creating what sounds like a flat frequency response.

The next problem after the feedback comb's frequency response is the “flutter” effect. Schroeder gives the goal of around 1000 echoes per second to make a “natural”-sounding reverb. Assuming 4 parallel comb filters with delays that don't easily divide into each other, but are in the neighborhood of 40ms (25 echoes per second), we get only about 100 echoes per second. Assuming (as Schroeder does) that a single allpass multiplies the number of echoes by about 3, two series allpasses after 4 parallel combs is enough to meet the minimum requirement.

The “Freeverb” Schroeder reverberator (diagram from Julius O. Smith)

The combination of parallel feedback combs into series allpasses (or sometimes vice versa) is often referred to as a “Schroeder reverb.” The “Freeverb” algorithm shown above is one popular Schroeder reverb. The delays are given in samples, with the floating point values representing the delay feedback coefficients. In the combs, there are two values, and as far as I can tell, the first is the feedback coefficient, and the second is the lowpass filtering (more details in a moment).

Below I have first the dry synth riff, followed by the riff through the “Freeverb” algorithm on my algorithmic reverb plugin. This time it sounds much more natural, and if you play around with the Max patch (see below) or my plugin, there's much more flexibility.

One additional feature of this particular version is that there is a first-order (i.e., 6dB/octave) low-pass filter in the feedback loop of the combs. This causes higher frequencies to decay faster. While Schroeder and Logan seek to make all frequencies decay at an equal rate, the most important aspect seems to be to prevent individual frequency bands from ringing and standing out. Reverberations in the physical world decay more quickly at higher frequencies, due (at least in my understanding) to the sound absorbency of building materials, as well as the fact that the atmosphere can be approximated with a low-pass filter.

Some final design notes: First, we have the stereo spread. The right channel has a slightly longer delay time than the left, with a default value of 23 samples added to each delay value, according to Julius O. Smith. This simulates the effect of different physical environments to the right and left of the listener. Second, in my JUCE implementation I have a low-frequency oscillator (LFO) slowly modulating the first and third allpass filter delay times longer and shorter, giving a chorusing effect and making the sound richer.

If you want to play with this reverb algorithm in Max/MSP, you can use the patch below:

“Freeverb” Max patch. Copy code and select New From Clipboard in Max.

----------begin_max5_patcher----------
8187.3oc6c10baiikF95jeEZzbW2IYv2jb2axdeuaU6bamtbQaQ6vokk7JQm
NYlZ5e6KIAkDoD+.fBVBR5cposCIkLOmC93.f2GR7ud+6ld+xumrd5j+iI+5
j28t+06e26JOUwIdW0wua5ywe+g4wqK+XSeX4yOmrHa5GzWKK46YkmeV5iO9
55zkK1bkWhyd3qoKd5tUIOjouCBE4SjOLgJEE+RFV7SV9ol7aUemEu9b5h4I
Yk2JZ0ISmUdCVd++3ibxzcexkuls4iRJN4+98uu3Ge3Xcj3meI2r6yMHz5tg
xZ2fE916FOLO8geeR1WSWO44j0qieJYR7hYSVG+sjIYKm75KyhyRlrJ4aIqt
ex5jrrbeb8l+JySWj7vxWWT9mh0cjPpJiDBYY7PW5x41DITtKRT4lsTybU1O
lNnSDxKs9x+Mi0kOvZwGDs6CabW8ox9wKI562zoS9sQ3dKR9i761AdWQIboS
krZXejRKcRUP+NYaETr1cRVmN4GJczpKWTsq5B+0+mhK0vrmL8+r3G+0+2he
lrXl9LNHJ8s3UKhet7NO8UFgQHbNO5fXX7qYKyMlr9hf4euxHHQUqQuUQPZ6
QPQ0Y+Z5rYIK5uhyGp8eauwqRVmsbURUPoJpTdWtOO3V9M+nbmgt4J+J82zW
j1x0XUWi7o.5AWju8hxCtln90JuTYAny5bN4g39ZKyEhZcMKFQWymfLLqS+m
I83CrPUcefasOPOAoWlsJ9oxDJyVs7kIwSdLcdxj7FykIWdYduERTc4hN+OM
bDNnCyZ737k4+QZqCipFP8TPwzETg5wAPNnKgGWt543xOrxTOiu69sJ2PxRV
cWxh36mWZRjd6BN+ub5y4tR9o9Xowr0a2b5Zms09VtONebOipa2tpl7b52MH
.pqoyse7fB2UOnizq+2he4SOrZ450r+b3ZzLsiDD1exAYKk68ma3fRq0oOsH
ddQYVO+qQUR10nnV9RReCsmRXkMBDk+hKsdTTT5IYTTyS+VxmdJNcwe1VS9C
uZ2E1BYYGWTt9nfZ9Z9cK+aEuXQx7sihlXXbP0WG.zVCQRapkT7e484k2szG
J720Y6FHwxUo4sgiyJlDWsaVwX2lcWwviRu+0rjc+q06OjiuEO+0jkOt4zaN
eceIuOprzh5lkCKQsc7Cs7YNzua7ox629otK3Z7QeNuJPYuva59auqlV5ueL
fz90WNK++Wde3sb40ec4pLCMjMkMscadM2qWm8CsCKzWWO1owMDpj+4r3GLn
dbUSV8b3DRKZxJcWuuEiXnnxnA1ajdXC5zs75YKdIM+67vxUEekp5vjsYhmO
e4e7z7k2GOOK44WV1YSxM05yRy6ILaUR9expQz1Ls9hr1uS2GuN8gr7ByhTo
4EjBRKKig8I42zFeSMQ88Y5tVtOkl2.edxhmx1XuEwmb23geecsl31kHo3+l
kV5iwq9wt+L+euFOOMeR0cZHaiwT1twbLKNKd+tLdXd5KUq+zwLegNxd+Txh
+bxmyRyc5IOtJobwNFd7H7pQlRGXZxpVxhIrbZxsjztt8om.W8.Vw.syci0M
6j9cSie4kZmtY2uOG+OVV9GJba+N4tg9TpsmZUx2R278kaOa7p7nTVdH5U8T
Lm9ckXWWaEUGWs30zRSYSeVeXaYadwSQOi4yz+A8Wd15W9zSaGHQw8bSrORO
TPRY01HVYnWFwqO2z6ya+9vumLqdOnkiKIcwK4SBtdtqsWdVxiwuNO6tGWtH
qbdWk0I+TqW+wJqr0KtsG9+qUE4u17QdZU5rkKJGbT8RihSu41k2ykd8wZLI
7xOwh3WZ4KmWQJOrzwEWm6jut993UEEVUcYv1bwrkKm27Ra+dySdLq5xujlO
xjlQwrkuz8EyaS+0d9t2uL+hO22e6xqrNOCm9p2UL9n61rjP69b48eU0Nt4e
9uGmOwl3rjhtjKcWx1Kp617qqyGh974M7W8U9VKWYVd87GR9izY5dJI0qLj+
wSeYSknoaKkmk9Tx5rlmKK9o0MOy1r20N0q2W0N9thtDmm6EM+.4sPxS6kOF
h+XyxgsohV8.vtknud655cJ137804XyNHSWLgM4yUydaxWl92mj2V50ruLs9
mt0bw50YgUN1AZ0hTTqmxC6sjT6BsjKr6g926v+qMJoM4KbbHJu6pMoP9xzM
IQl72GLDwBJa0yCzcrc3BK24DCOHDcDwn8swcITZFN5LwRWIW16q2VRlNRzz
cxlgS3zURmFIdLL4ydIfnrpkHWuNubYYJnPVTyRr1SCYPpHSRGMXJICSK0Sp
IyROMPJpASSMXppARWMbJqASaYPpKSReYSJrdRiMXpr9Sm0eJs9Sq0apstRu
0dJtNRyYTpNCS20dJu86sY+90O35C0+dy93+4IL99WrUMfJ6SHhpWjKVa8n2
4LJasmc0zC+ls269fYAajIrY1PuJ5ETIzpChdxaunmpRjcGD8D2dQOovYQO9
MTziFP05aDJcU3icKE9jDgN7obT3icK01kVUsycgO5MUiWRfiq8QukZ7Fp3N
N5QughdJI0sQuaoN9DUDQ3tzF2PAOFywAuqhls+zDtfZ93kC0nrvCN91spqi
vmvlvWfHxUgO40Q3SJUVLW2J4XcP3SbcD9XLoES1kvcU36pX7x0DxId97WJ9
VFjFIpbtGQZbSnDtYASdOASGjEtM6toxNGFq5Ugm9T4ok+Tco1SOJ9zupOlo
7Sep+bfBPVnBTuJAozq1qpXfD6G46VLHCEDxTQgLRXHKDGZ.AhLWjHCDJxHw
hLRvHCDMxLgiLR7HCEPxTQjrUHoADSxHAkFVTogEVZXwkFTfo9DYpagl5QrI
iEbxBQm5V3o15.rsbSs94LIG09o4OXtFcu3DeRVznrriJVmI5GLY+fZCLbdJ
iR7ePx+CG.vINX+yFFoUxhHMORm+Op3.yhzrAhz7akH8OYXjlFETFpoDWGpo
HT2LTGTVolpIp1gQZVD59nstOXUyEygQ5fakH8rj4w+XxmeLIY18wO76Sn10
wst2DJkZdNxgB8pakPe5hIzcPhVBHpcAeUMVQMK1SFnqb4MTrmuK1u8krwjO
mGrlPx+U72KJbpl0WwicsgEMLh9gbP+KNQ5tBmaoFF0nmtpGphBFS6bhJKGq
Sfd8FBHtqL3lIuPtEaYt.QEX1R2Mcovgi1DCBiGtxJEuHVLb9nk9awm2r375
kut5gMkxapxLo8XQ9b6yRWrcAr90cI.y66wM0ONZqWYo0WLE2N9BKWMSuXpz
KTWipKX5y0H9gqIssNWUkT+v5E1Z8Q9TKFtsUqB8oXO0Vqm6Qw9xJBVWu2ar
9fwzgD4RnCI1nRBdQjFgoFSKlqSWqm1eOmN6kkoKxVucIxJFqnlabIsb5r0O
fpYSU+yxCN9p460Lu4m3xS67PZnyzNmBsyg14P6bncNzNGZmCsyg14PPWncN
zNGZmCsyg14P6bncNzNGZmCsyg14P6bncNzNGZmCsyg14P6bncNzNGZmeApc
tR+KmncNAZmCsyg14P6bncNzNGZmCsygftP6bncNzNGZmCsyg14P6bncNzNG
ZmCsyg14P6bncNzNGZmCsyg14P6bncNzN+BT6bYPjqzNmGAsyg14P6bncNzN
GZmCsyg14PPWncNzNGZmCsyg14P6bncNzNGZmCsyg14P6bncNzNGZmCsyg14
P6bncNzNGZmelzN2P0xiphVA5eczaV7GtE0eguYw+X57rjUIytay5XcW9rGu
2fHKUICqEaoQFBhfnmfKGfHbQAhfd0iUBJ.Q.fH.PD.HBdhLhr.srVRliU2h
Rfhs6Ep0BXQUJGGpifNhCfZidnsLmqiXHpi2Zcb22cxMilH+kOZb0ZNUOKMp
tKbkyzD4lQDvulmRe4peXYka8uDBmEuk2lzHrN8oEGNihd6CupKbavkb.0Vo
2nJd+kproEi4+KSsT5a8fF0ReyHB2UXDbaxFx1Qzz.MDS6VhoWMS8jqY7P2U
bDdCUbHpQCR7y4Sr9oQUZTkTdCW2b2wlCMBbgzUdAgNmrC4BgQtB3BwVoJkW
JpFYqiUrZDlIZDKeHFkfUqa+V8TZTbzkfFngVFWLVKsHQo7Y540UgFZ8Cnxp
QAP1dz0X7hQtTZgXqX39DfHpwz51WHrvVrn7IpnnQiv3olz+AmwKWKnpIKzb
pCUGIz5hx2czkPCMqiYpKEfZniIahuzLjNlN.8FiWcA26cOi05XMd+9MSw3A
DQHjtFPDF.DA.h..Q.fH.PD.HB.DA.h..Q.fH.PD.HB.DA.h..Q.fH.PD.HB
.DA.h..Q.fH.PD.HB.DA.h..Q.fH.PD.HB.DA.h..Q7H.QXblqADg..Q.fH.
PD.HB.DA.h..Q.fH.PD.HB.DA.h..Q.fH.PD.HB.DA.h..Q.fH.PD.HB.DA.
h..Q.fH.PD.HB.DA.h..Q.fH.PDOBPDhlR.GBHxASVD.h..Q.fH.PD.HB.DA
.h..Q.fH.PD.HB.DA.h..Q.fH.PD.HB.DA.h..Q.fH.PD.HB.DA.h..Q.fH.
PD.HB.DA.h..Q.fHmQ.QBIJWyGRH3CA7g.9P.eHfODvGB3CA7g.9P.eHfODv
GB3CA7g.9P.eHfODvGB3CA7g.9P.eHfODvGB3CA7g.9P.eHfODvGB3CA7g.9
P7G9PjZhPbIeHAfODvGB3CA7g.9P.eHfODvGB3CA7g.9P.eHfODvGB3CA7g.
9P.eHfODvGB3CA7g.9P.eHfODvGB3CA7g.9P.eHfODvGB3CwM7g7SEBJnLYW
jIfppMkPA0LHPn8.Ah53g.wOBfgglD.kDd8.H63Cfxqj.HWZTMPV0hnVE.4G
e.TbkD.YAAFsQPEHbb.jbkD.ELlIunjTrZizyAwunqgv2eahQc+EPzxNQ1D0
NxXW30PryE3YxCINFOSPmInybuA9B5L0yV.zYB5L2uJAny7cfNSPm4EdjFzY
dgTGGzYN5HMnyDzYdMCAEny7LF7AcldTgAnyzqJN.cldSoAnyzQBkC5LAclC
xSCnyDzYB5LclwC5Laq+CPmIny7zZ7fNSPm4IhLoHpALfnj5903QNhLoqE1L
UTSHiSTstFNK7csPloTZR3iwbb3iC1tZPMmCY6hQAbW.tK.2Ef6BvcA3t.bW
.tK.2Ef6BvcA3t.bW.tK.2Ef6BvcA3t.bW.tK.2Ef6BvcA3t.bW.tK.2Ef6B
vcA3t.bW.tK.2ka3CoXUULGtFpT2GWnYDfP5g.jqB1tZYQm5AfFGF8BtRhdb
y4hSE4pfW3URvSXBSlZ4ZcWvK5JI3IMYOmUU1fUxYNJ5wuJdUE115a0ZRiHM
uTDRX+qtk4HYN.2fjdBNMtosuJVMiYcMPh8hbls3NcM0O5gCdv3B0wZfgVXf
7nyfAFXgAFdFrOkE1m3LXeRKrO1Yv9D1D.4pygEZSHjKOGVnvFK7bTKTvswB
4mCKjYiEdN5pVPsoqlyRaYhMV3YIFZS93fCWFk2bCjayHF1DuOsVnx1pgm7X
nz1pgmbKTXao7I2B41NvvStEZSG1L94vBI11RgcvGt80Q2yLcZ+lN0iMcR+l
NyeM8xFc8X57SqoaSh0yPVKlM4UKR7yO3ytmLfp.Ms.ZM9JVdnMG0cYhxe84
xdHszoogBpAdMwi8Z1H7ZEKz.ul5wdM0dulKMoBdfG6zjQTTKnRC7Zl+50kR
5aqWyHLC7ZtG60g160QgQF3zBO1oGQZqf.kANs7z5zgVlplMjOKDAZzGK0+R
RjaOxaRUGZapZKcZZPH2.ul3wdMaDdsLfXfWS8XulZuWWn01vNcfG6zjQTTy
kAF30L+0qoQivqoBgAdM2i85P685HN0.mV3wN8HRaEPCMvoOwopCrLUMYHel
FTNJLNuj1Bd3ti7lT0A1lp1RmlpTAF30DO1qYivqERgAdM0i8510m6bkvMv1
Dt1VfwzK9y.EXL+0qaG28A7ZhdweFvq4drWGZuWGpWFjAbZgG6ziH4iRuJHC
3zm3Dt1H9pQUuY7.8a1jRh7BCnaOxaJnswmU16yJEw.e1iKmk16yUCsb.eV4
u9L2qx0Zikyj8a5g9qoSsq0ESuvSL41C8lQyZkWKGgWKoLC7ZpG60hQ30L8y
V8.dMyi8ZxH7ZhdoUGvqOwCIzJFnLpcMkTV3FJ0D7KTaOxaZVakSKsvoCXQ0
b5xi7lV0V4zBKbZk90vSkSqnROpQsUNM2BmVDVujt7HuoMsv10f4TS7Fi64O
sFLluafTe2.I9tAZ4RRepaiPi77.HMz2MPe+YBiZ0LYOGOoFTqdrvNGOwPTq
dTMNGOwPTtsqv9IuqFlsqF9I2Bo1tx0mbKzl7czyRaYa0np+PXsKt6Ja+W6b
fsl0dOP46L2AdPxacio4KSebURwtxx8S9kuTeqKn02kF5GCedfpZ0GZ6gJu4
CTdscYkFOL40ewmz8Ch+.a9LsswyTqzquMblt1rYpW32wlLSGavLcu4xL7FK
SWapLM1PYLbyjo1FISjn5c.fFXmvxCCE6uBBctIxXvFHiIadLCtwwX3lFSOa
XLlsYwLvFEyfaRLCtAwLvlCyvaLLCtovXvFBiIaFL1rQvzyl.yfa.L8u4uz+
F+R+a5K8tguz0l8R6azKcrIuXzF7hgatKsuwt7lt0swEl7dBgq2coBzuyR4A
G8qIDwUxFGnvpvmtKVWD9tR13.kRk4gOk9k4nKBehqivGiIMO7IcWsuqs8cw
7LWuT7sL9ElTnNJRIFtQKx6IXxvFs3E0FsHU+RoNTgMZQrQKhMZQrQK1UtoV
+biXmQaxGMdqpP+XCVsyfD3rspBt3VYiA4mMLRWsAETsQK6tcgNNGa3e6sZh
Q5G6BJw0gZJB0MC0UOCxQgNNRyhP2Gs08AqZtXNLRGfcpUi53l57cpUl51bO
VLeBMulYWvuRWHly13x3xayc0uYoO93qESft4FI2jOWMqu7AlKMcO9S+FflV
8hfl3tcUN9M59eYUOTVssWpeX406VMUaIAtoLH.6rec0cjHP53c1Od3UvN6G
21s2lRh98k82Fts6uMs+t+T2Hvu1Nnr20nctGZ4Y6GTba2ZyX9zdaVOUg5v5
8osyp1e0x1W0JeZKghSs054dTrmEMl58di0GLlNjtH1f5XiJI3EQZDlZLsXt
NcMlw6RsUiUTTNzbo9MsQ8Cn5cKZ8OKO33ql6g6IcGi14AUy+2EZmSg14P6b
ncNzNGZmCsyg14P6bHnKzNGZmCsyg14P6bncNzNGZmCsyg14P6bncNzNGZmC
syg14P6bncNzNGZmCsyu.0NWoGosSzNm.syg14P6bncNzNGZmCsyg14PPWnc
NzNGZmCsyg14P6bncNzNGZmCsyg14P6bncNzNGZmCsyg14P6bncNzNGZmeAp
ctjKbk147HncNzNGZmCsyg14P6bncNzNGB5Bsyg14P6bncNzNGZmCsyg14P6
bncNzNGZmCsyg14P6bncNzNGZmCsyg14P67yj14FpVtVrbNgoCZG8lE+gaQ8
W3aV7OlNOKYUxr61rNV2kO6w6MHxRUxvZwVZjgfHH5I3xAHBWTfHnW8XkfBP
D.HB.DA.hfmHiHKPKqkj4X0snDnX6dgZs.VTkxwg5Hni3.n1nGZKy45HFh53
sVG28cmbynIxe4iFWslS0yRip6BW4LMQtYDA7q4ozWt5GVV4V+KgvYwa4sIM
BqSeZwgynn29vq5B2FbIGPsU5Mph2eoJaZwX9+xTKk9VOnQsz2LhvcEFA2lr
grcDMMPCwztkX5UyTO4ZFOzcEGg2PEGhZzfD+b9DqeZTkFUIk2v0M2cr4Pi.
WHckWPnyI6PtPXjq.tPrUpR4khpQ15XEqFgYhFwxGhQIX051uUOkFEGcInAZ
nkwEi0RKRTJelddcUngV+.prZT.jsGcMFuXjKkVH1JFtOAHhZLst8EBKrEKJ
ehJJZzHLdpI8evY7x0BpZxBMm5P0QBstn7cGcIzPy5Xl5RAnF5Xxl3KMCoio
CPuw3UWv8d2yXsNVi2ueyTLd.QDBoqADgA.Q.fH.PD.HB.DA.h..Q.fH.PD.
HB.DA.h..Q.fH.PD.HB.DA.h..Q.fH.PD.HB.DA.h..Q.fH.PD.HB.DA.h..
Q.fH.PDOBPDFm4Z.QH.PD.HB.DA.h..Q.fH.PD.HB.DA.h..Q.fH.PD.HB.D
A.h..Q.fH.PD.HB.DA.h..Q.fH.PD.HB.DA.h..Q.fH.PD.HB.Dwi.DgnoDv
g.hbvjEAfH.PD.HB.DA.h..Q.fH.PD.HB.DA.h..Q.fH.PD.HB.DA.h..Q.f
H.PD.HB.DA.h..Q.fH.PD.HB.DA.h..Q.fH.PD.HxYDPjPhx07gDB9P.eHfO
DvGB3CA7g.9P.eHfODvGB3CA7g.9P.eHfODvGB3CA7g.9P.eHfODvGB3CA7g
.9P.eHfODvGB3CA7g.9P.eHfOD+gODolHDWxGR.3CA7g.9P.eHfODvGB3CA7
g.9P.eHfODvGB3CA7g.9P.eHfODvGB3CA7g.9P.eHfODvGB3CA7g.9P.eHfO
DvGB3CA7g.9PbCeH+TgfBJS1EYBnpZSITPMCBDZOPfnNdHP7i.XXnIAPIgWO
.xN9.n7JI.xkFUCjUsHpUAP9wG.EWIAPVPfQaDTABGG.IWIAPAiYxKJIEq1H
8bP7K5ZH782lXT2eAkZevi1tFWGYrK7ZH14B7L4gDGimInyDzYt2.eAcl5YK
.5LAcl6Wk.zY9NPmIny7BORC5LuPpiC5LGcjFzYB5LulgfBzYdFC9fNSOpv.
zY5UEGfNSuoz.zY5HgxAclfNyA4oAzYB5LAclNy3Acls0+AnyDzYdZMdPmIn
y7DQlTD0.FPTRc+Z7HGQlz0BalJpIjwIpVWCmE9tVHyTJMI7wXNN7wAaWMol
ycrcwn.tK.2Ef6BvcA3t.bW.tK.2Ef6BvcA3t.bW.tK.2Ef6BvcA3t.bW.tK
.2Ef6BvcA3t.bW.tK.2Ef6BvcA3t.bW.tK.2Ef6xM7gTrpJlCWCUp6iKzLBP
H8P.xUAaWsrnS8.PiCidAWIQOt4bwohbUvK7JI3ILgISsbstK3EckD7jlrmy
pzui8BCbTzieU7pJrs02p0jF5WydQZFx5dwsLmHyAvFjzSrowMs8EwpYHqqw
QrWfyr01oqY90xn1LtLcrFXnEFHO5vA27lafAVXfgmA6SYSIbvYnDVZgAdNr
OgMQPA6bXg1DBEzygEJrwBImCKjaaGMmbKjYiEROCc0Hn11R4jagDaaobpsP
djssTN4VHw1RY1Ae31W7MOyzo8a5TO1zI8a5L+0zKq+2ioyOsltEVN6bjXkE
Y4nm3G7Y2S7.UfViQsx.ESpbyQcWnn7Welws2oogBpAdMwi8Z1H7ZEKz.ul5
wdM0dulKMoBdfG6zjQTTKnRC7Zl+50kBAZqWyHLC7ZtG60g160QgQF3zBO1o
GQZqf.kANs7z5zgVlplMjOKDAZfoJW0bIQt8HuIUcnsopszooAgbC7ZhG60r
Q30x.hAdM0i8Zp8dcwJzOrSG3wNMYDE0bYfAdMye8ZZzH7ZpPXfWy8XuNzdu
NhSMvoEdrSOhzVAzPCb5Sbp5.KSUSFxmoA5GOyvRYY4g6NxaRUGXapZKcZpR
EXfWS7XulMBuVHEF30TO1qaeU8OWIbCrMgqsEXL8h+LPAFye851gjc.ulnW7
mA7ZtG60g160g5kAY.mV3wN8HR9nzqBx.N8INgqMZraT0aFWmrgUBxSX.c6Q
dSAsM9rxdeVoHF3ydb4rzdetZnkC3yJ+0m4dUtVarblreSOzeMcpcstzuXAC
XxsG5Mil0JuVNBuVRYF30TO1qEivqY5mHyA7ZlG60jQ30D8RqNfWehGRnUnt
YT6ZJorvMHrb4H3B01i7ll0V4zRKbZkFV7Jmt7HuoUsUNsvBmVFQq4zkG4MM
psxo4V3zhFUuEg9z5px8bDpYLe2.o9tAR7bCjF46FXnuaf99CBAUY6Bbepg4
iJscwnO4Vnv1Ue8jagDaWoz9svZWb2U19u14Aasq8d501YuC7Tq07IVq9i4b
6uJg0q2AummVsNeR0Z7HRV+4xrqmPs2V+McwDUs2GXoO93qEux4a9FAaxmqd
OoOg7I4.AGQj9geToEaiXPzgzdzgx6N5TOf12i93advSNvKSsI6hbCUsRT8x
dT+PPV8HQNtHG6BHxU+0PWxCEutiqE2HeJJ++UudWnXfvGWUozotUIKZ7gO5
EP3iV+Mb4uLIcwKul8koCDizucABpDGkL9HzEP.hW+8u5+Lop50mnLotJV3t
ZWzgpZQBzKEE6XaY58ML2+I1t0WRE5mu8iO+mko+192+vGJ6cQf1F6Rs3vgO
kIGLA3tFQkn43l6sbvZqfYnU7lZDFZCaBYuIFAyFinwajqVVgvyikw51xnuI
VF0pRNwoLnYtow51zdihZVUUieRiZVUWieRiZTahZrSZTiZSTicRiZ1XYs20
Z0I0mo7mZCq71VKwu1LZlv+w4KySuVksc52h2tk9Tj089jU+p321bw1lXhhT
8j4oeTG1Oe+zGWt543rZahYsl8u0Ynje+VkaKYIqtSuuJUavS6MjfpMNihcL
szmy8l56rREt6lSR2dxCGF0GlL893EOUMbJWGE48FEITmGEIWiQQVeQQtd2n
vkQwvqwfHsufHSqGkKChANNHZX7pzhaNc.c3a+NnqBhGNntFKp5.rG2ZAkw2
IpA2olI9m90zYyZr6+sWJz2XigXpwPe6MlPSsE1ausDXpsvOAERbSMFwQYL6
ce5vXzig+ntQMlWWO2msi50UsIL0AYt9F2za5AcJ5QFZaZ88yn0IoLjdXnjd
RJCIt9FaRSUkChrTChrpFelC3QW9Ipp1+SFTrTdZF6BJALr7nizNCMofPnq3
eT2n.SuQri7FoL3FIeKpZY5Ml579kDmpJ0ByqUeb2Hlo0VN15+Tp4UWNtaDw
TWRzxHm2aSLu3lr2lU9daP4Gtoj28FQ99a93ka33ssIiWLWm2+ue++OvNwTW
L
-----------end_max5_patcher-----------

Final Notes

That's all for today! My plan is to do a series of posts, each covering a class of reverb algorithms. For the next one, I'll be writing about rings of allpass filters—this is relevant to, for example, Jon Dattorro's popular 1997 algorithm that appears to be based on a plate reverb from Lexicon's 224 and 480 reverb units. Until next time!

This notation comes from the idea of the Z-transform. ↩︎
Note that the triangle symbol is the standard DSP symbol for amplification/an amplifier. Also note that $b$ and $a$ are often used for feedforward/feedback coefficients, although it seems to be somewhat inconsistent which is which. ↩︎
M. R. Schroeder and B. F. Logan, “‘Colorless’ artificial reverberation,” IRE Transactions on Audio, vol. AU-9, no. 6, pp. 209–214, Nov. 1961, doi: 10.1109/TAU.1961.1166351. ↩︎
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 ↩︎

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

May 2025 IWC—More Easily Joining Small Web Communities

reillypascal@gmail.com (Reilly Spitzfaden) — Wed, 28 May 2025 23:06:00 GMT

Chris chose this month's theme of “small web communities.” I'm writing about making it easier to become part of a small web community on the IndieWeb: some potential inroads, potential problems, and open questions I have.

UPDATE: if you're interested in making your own site, Coyote has a helpful guide here—please check it out!

Barriers to Joining the IndieWeb

Max Böck (writing back in 2022) succinctly captures an issue that's been on my mind lately, observing that

Generally speaking: The more independence a technology gives you, the higher its barrier for adoption.

I love the experience I have on the IndieWeb, using technologies like webmentions and microformats ^[1] to interact with others in a way that's open and modular. I like the IndieWeb principle of “small pieces loosely joined,” and how that allows me to replace any one piece of my IndieWeb infrastructure should what I'm using “enshittify.”

I want to make this independence more accessible—to ease some of the issue Max Böck mentions—but how? I'll use this post to think through some possibilities I've been mulling over (addressing a range of potential levels of tech experience), and I would be very interested to hear other people's thoughts and input on these possibilities!

Ways Around These Barriers

On the IndieWeb Without Your Own Website?

First, Tracy Durnell suggests that

we can help people escape the corporate silos even if they don’t want their own website. […]

The more people who use the independent web—whether creating new work, participating in conversations, curating links, or simply reading—the healthier it becomes.

I like the idea of expanding participation in the IndieWeb beyond just the people who own a website, and including non-site-owning readers. Speaking as someone who maintains my own site on the IndieWeb, I love when I see people interact with my writing on social media sites where I POSSE my posts—no webmentions required.

Comment sections on personal sites can be great as well, ^[2] and can offer further ways to interact. Alex (someone who does have webmentions on their site) writes about preferring when blogs also have a comment section, noting that

I’m just sometimes tired of high quality stuff, you know? Sometimes, all I want is to comment on someone’s post to say « lol » or « nice thanks for sharing » or « saaame! » and that’s not something that warrants a whole blog post and entry in my RSS feed.

Finally, there's email. I have a mailto link at the bottom of every post, and I've had nice experiences sending and receiving emails related to my and others' writing on the IndieWeb. Even outside the practicality of more (and more ubiquitous) ways to talk, I like the personal nature of (non-work) email, and the way it feels kind of like letter-writing.

Website Ownership for the Non-Developer

OK so someone wants to have a personal website, but doesn't know much/anything about programming. What then? Böck mentions Mastodon, Ghost, Tumblr, and micro.blog as contributing to lowering the barrier of owning one's own content, and those certainly are decent options.

Even with the more blog-like Ghost and micro.blog, as well as similar things like Bear, my biggest issues are 1) the editor is coupled to the backend, and 2) the data formats for your pages are less standardized than I would like. To expand on point 1, the tool for creating pages and posts is accessible via a web interface owned by the same people running the hosting servers. For point 2, I would prefer a generic format that has stood the test of time, such as Markdown.

My stance on both of these issues is because at this point, I use technology with the assumption that any tool or platform will enshittify, and I will have to be able to migrate to something else. I see my strategy here as fitting with the IndieWeb approach of “small pieces loosely joined”; I strive to make my workflow “modular,” with individual parts as generic and replaceable as possible.

For example, I use Obsidian for maintaining a personal wiki: Markdown documents, extended with wiki-style link syntax to link between notes. However, I make sure not to use plugins or features that would narrow compatibility of my documents, and I ensure that my notebook is compatible with e.g., Vimwiki, Zettlr, the Foam plugin, etc., so I can switch anytime Obsidian does something I don't like.

In my ideal no- or low-code web publishing tool, authors could use a program on the desktop that takes in a common format (such as Markdown) so that all pages can easily be moved to another CMS/static site generator (SSG). Since the program is not bound to any given hosting service, authors could put the resulting generated HTML on any service; Netlify, Neocities, GitHub Pages, and others are currently decent options, but with this setup, could easily be replaced.

Existing Low- & No-Code Options

One tool that I find to be a promising (but still imperfect) idea is Publii. It's an open-source (GPL-3.0) CMS/SSG that runs as a GUI desktop app. You can use a WYSIWYG, block, or Markdown editor to write pages and posts; create menus, add page tags, add CSS, and many other things; and then generate your site, outputting a folder of static HTML/CSS/JS files that can then be put on a server.

I like that this program is a standalone desktop app that can work with any server, and that it's easy to use. What I don't like:

It doesn't seem to store posts and pages as (e.g.) plain Markdown files that could easily be moved to another similar tool.
- It might be possible to get it to do this, but I wasn't able to figure it out; it doesn't seem to do it by default; and it certainly doesn't point the user toward this kind of workflow.
Design is not very flexible. You can choose from a limited selection of free themes, with paid options, but even the paid options are monolithic, and you can't combine, say, a block layout skeleton with a layout-independent color/font/icon theme.

One idea this gives me, though, is a GUI SSG with Markdown files as input (and maybe with modular layout features), and with community extensibility. I use Eleventy and enjoy it very much. However, requiring the use of the terminal seems to be a big barrier (whether real or psychological) to use by non-developers.

Since writing/note-taking tools that use Markdown (such as Obsidian or iA Writer) seem to be decently usable and liked by non-developers, I could imagine a GUI wrapper around something like Eleventy/Hugo/Jekyll being helpful. Authors could take a folder of Markdown files (perhaps written using one of the aforementioned writing/note-taking tools) and turn them into a website, with the generator handling all code beyond the Markdown itself.

It might even be feasible to make a GUI wrapper that's compatible with multiple SSGs: choose from a menu whether you want to use Eleventy, Hugo, Jekyll, Astro, or another popular option. Because the terminal commands to install and use those are relatively straightforward, the GUI wrapper handles installation and running the SSG for users who might be intimidated by the terminal.

Inspired by Publii's model of themes, I could also imagine a system of modular community HTML templates and CSS themes. Perhaps one set of modules handles a CSS flexbox-based block layout, with just the CSS and the HTML<div>s/classes necessary to do so, and another handles the styling for colors, fonts, icons, etc. It could be an interesting engineering challenge to integrate something like this with e.g., Eleventy's partials and/or shortcodes systems, or similar parts of another SSG.

I haven't attempted any of this, so let me know if there's a roadblock I'm not considering, but I figure that integrating with one or more popular SSGs could further the goal of modularity and flexibility, and make the GUI wrapper easier to create and maintain.

What Makes Coding Intimidating

I have some changes I would like to see in the perception of what a website entails to make things less intimidating if someone does want to get their hands dirty with coding. I think a lot of people's perception of what programming entails makes putting together a basic webpage seem more intimidating than it actually is, especially with the “frameworkism” and emphasis on JavaScript in many frontend spaces. In addition to the obvious hurdle of coding at all, I imagine the complexity of the websites most people see on a daily basis unnecessarily skews the perception of what needs to be done to make a website.

Even if someone knows they can make a simple site, the lack of such sites creates an unfair comparison for people's first projects. ^[3] When I first started coding I was unsure of myself and didn't want to put something online that looked “less than” in comparison to other people's sites. Now that I've had the time and experience to form more thought-out opinions on programming and the web, I look at sites like motherfuckingwebsite.com and bettermotherfuckingwebsite.com with appreciation for their minimalism and focus on content.

I want to see more widespread emphasis that what these sites do is plenty, and that there's nothing shameful or “less than” about putting that online. ^[4] As I wrote about here, the magical thing about the web is hypertext itself: the way hyperlinks connect ideas and create something far bigger than any one person's ideas or writing.

Additionally, I want to emphasize to those potentially interested in the IndieWeb that webmentions/microformats/etc. are nice but by no means essential. As I mentioned above, a simple mailto link on each post—especially combined with POSSE-ing posts—is a fairly decentralized and open way to socialize on the IndieWeb without much technical overhead.

Of course, I should acknowledge that even this requires at least some degree of both technical know-how and comfort with searching/willingness to search for technical answers online. ^[5] Additionally, if only some IndieWeb community members have access to webmentions/etc., while others “only” have email links, I worry that less-technical community members won't be able to feel like full participants. I don't have an answer to this—again, it's that inverse relationship between independence and barrier to entry—but I'm continuing to think about it.

Wrapping Up

This was the first post on this blog for which I made an outline, and I even re-wrote the outline multiple times! This was because I apparently have a huge list of thoughts on this inverse relationship between independence/barrier to adoption, and many of them didn't make it into today's post (in the interest of brevity and clarity).

I plan to continue writing on this topic, and as I continue to think through all this, I welcome input from others with whom any of it resonates. Until next time!

I have a collection of tutorials on webmentions and microformats in my personal wiki, including simple ways to get started that require minimal coding. ↩︎
I made a basic comment section on my site back when I started. I've disabled it from time to time—I've mostly gotten spam—but I recently re-enabled it in the spirit of what I'm discussing here. ↩︎
My HTML looks kind of messy without the CSS on it, and I'm definitely interested in doing some cleanup so I can do things like participate in CSS Naked Day and model how things don't need to be complicated or fancy. I might also do something like Sophie Koonin has, with multiple stylesheet options for the user (try clicking on the one with the lowercase “a” in the upper right of the site). ↩︎
Blake Watson's HTML for People set of tutorials is a great example of materials in this vein. ↩︎
I'm always reminded of the evergreen XKCD #2501 ↩︎

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

I Would Rather Spend an Evening on a Web Scraper than Use Your App

reillypascal@gmail.com (Reilly Spitzfaden) — Fri, 23 May 2025 03:48:09 GMT

I'm an extremely stubborn person, especially when it comes to how I interact with technology. For example, I vastly prefer to listen to audio (music, textbook audio examples, etc.) offline and in my music player, ^[1] and I'm determined to ensure I can do that.

My partner's brother just got married, and since his spouse is Swedish and the U.S. is…*gestures vaguely at everything*, he's moving to Sweden. My partner is learning Swedish, and I think it could be fun to learn some too (I do like languages/linquistics). I have the textbook Complete Swedish: Beginner to Intermediate by Anneli Haake, and it seems great—aimed at self-teaching and includes audio resources. Unfortunately, the audio resources are either available through an online player or in the publisher's app. ^[2]

Since the online audio player embeds MP3s, and the links to the files are visible in the HTML source, I decided to make a web scraper to download the MP3s and use them how I want. Let's have a look at what that entails!

Understanding the Page Structure

First, I looked at the page source to see what I'm dealing with. I found a list of <item> elements, with the MP3s in the url="" field. There were two issues with this, however. First, these <item> elements don't show up until you click on the play button in the web player. This meant I had to do that manually and then download the HTML, rather than directly giving the URL to my scraper.

Second, the MP3 links in the url="" fields were relative links, and they didn't work when I appended them to the page URL. I also wasn't able to find the CDN URL for them by searching the page source. What did turn out to work was using the “Page Info” feature in Firefox. I clicked on the lock icon in the URL bar, followed by the “connection secure” field in the resulting menu…

…I clicked on “more information”…

…and in the resulting “Page Info” popup, I went to the “media” tab and looked for items with the type “Audio.”

By comparing the URL for the resulting media files to the relative URLs in the <item> HTML tags, I was able to get the CDN root URL for the files, which I confirmed to work with the relative URLs.

Parsing the Page with Cheerio

I've played around a bit with the cheerio Node JS library for parsing HTML, and since I wanted some more experience with it for other projects anyway, ^[3] I decided to go with that. My resulting code is below.

index.js

import * as fs from 'fs';
import * as https from 'https';
import * as cheerio from 'cheerio';

const buffer = fs.readFileSync("swedish.html");
const $ = cheerio.loadBuffer(buffer)

const cdn_root = "https://cdn77.papertrell.com/AkplUGiYnqjKEYG4SiU1hQ==,1747972188/Consumers/004/Users/325/Publish/004325173/";

const item_list = $('item');

item_list.each((index, element) => {
    const media_url = $(element).attr('url');
    const file_name = media_url.split('/').pop();
    const file = fs.createWriteStream('output/' + file_name);
    const request = https.get(cdn_root + media_url, (response) => {
        response.pipe(file);
        file.on("finish", () => {
            file.close();
            console.log(`Downloaded ${file_name}`);
        })
    })
})

Cheerio uses a subset of jQuery's syntax. In line 6, I assign a cheerio object to the constant $ with the cheerio.loadBuffer() method. As I mentioned, I'm doing this with an HTML file I manually downloaded since I need to have clicked the play button.

In line 10, the syntax $('item') retrieves all <item> elements, and I can iterate over them with .each(). I get the relative URL with $(element).attr('url'), and I get only the string after the last "/" with media_url.split('/').pop(). fs.createWriteStream() opens the file to be written; https.get() requests the file from the URL I've parsed; response.pipe() writes the response to a file; and on finishing the file, file.close() closes the write stream.

Situated Software and Agency

In this post I quoted Robin Sloan writing about “situated” or “home-cooked” software:

People don’t only learn to cook so they can become chefs. Some do! But many more people learn to cook so they can eat better, or more affordably. Because they want to carry on a tradition. Sometimes they learn because they’re bored! Or even because they enjoy spending time with the person who’s teaching them.

The list of reasons to “learn to cook” overflows, and only a handful have anything to do with the marketplace.

I'm completely self-taught at coding, and in addition to it being fun for me, I'm finding that having coding skills is helpful in working around “enshittification”. It's nice to be able to make small software that gives me agency.

Since I don't have much experience with cheerio/web-scraping, it took a little longer than it absolutely needed to, and I may have been able to manually download the MP3s in a similar amount of time, but I would much rather spend that time on something I value (coding) and come out of it with some additional coding practice, so I consider this a success. Until next time!

For my phone, I use Auxio, which you can get via F-Droid, Obtainium, or Accrescent, among other non-Google sources. ↩︎
Insert GIF of the Earl of Lemongrab screaming “UNACCEPTABLE!” ↩︎
I'm using the Eleventy table of contents plugin to generate a table of contents from the header elements in a post. Since it hasn't been updated since 2021, I've tried directly using cheerio (which the plugin is based on), but wasn't having a lot of success. I figure playing with cheerio some more will help with that. ↩︎

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

Databending Part 5—Listening to Telephone Codecs

reillypascal@gmail.com (Reilly Spitzfaden) — Wed, 07 May 2025 14:16:00 GMT

Today we'll be talking about the VOX or Dialogic ADPCM format—a lossy algorithm from Oki Electric for digital voice telephony—and using it to translate raw data (e.g., program files) into audio. As I mentioned in my first post on the topic, at a certain point,

once you listen to the “sonified” data from enough files, commonalities start to become apparent. Many programs use some of the same [library] files, and…[even] differently-named library files sometimes contain similar elements—likely re-used code patterns, or further library code compiled in.

One way I've found of getting more variety from the data is to change the sample format in which I import it. If I divide or group the raw bytes in different ways, or treat them as coming from audio files with different encodings, I can get different sound results from the exact same data. For example, here is the same data (libicudata.73.1.dylib from the Calibre e-book manager macOS app) imported into Audacity first as 16-bit integer, then as VOX ADPCM:

Both very cool, and both very different, despite coming from the same data! Today, let's talk about how ADPCM and VOX formats work; how to do this yourself in Audacity; and how I incorporated these formats into the Rust tool I made in my last post to automate the process of converting data to audio. Also check out the end of today's post for some fun stuff to look forward to!

Following along in Audacity

While I will be doing this in Rust, you can make the exact same sounds (minus the convenience of automation) in Audacity. See my first post on databending for a discussion of how to find the best files to use. Once you have the file you want to convert to audio,

in Audacity, go to File > Import > Raw Data…, choose your file, and click “Open”
in the settings menu that pops up, set encoding to “VOX ADPCM,” byte order to “default endianness,” channels to “1 channel (mono),” and sample rate to 44100 (or change sample rate to taste)

What is ADPCM?

Tan and Jiang ^[1] have a helpful discussion of the basics of ADPCM, or “adaptive differential pulse-code modulation.” First, with differential pulse-code modulation (the “non-adaptive” flavor),

[the] general idea is to use past recovered values as the basis to predict the current input data and then encode the difference between the current input and the predicted input. (486)

In other words, if we can predict the output to within a decent approximation, all we need to store is the difference between our rough prediction and the actual output. This difference uses less data to store than the original signal, saving bandwidth. The following diagram illustrates the signal flow for the encoder (A) and decoder (B):

DPCM block diagram from Tan and Jiang

Note that while we describe a “predictor,” there isn't anything fancy here—we simply “predict” that the current sample will equal the previous one and take the (quantized) difference between that and the actual current sample.

The next diagram shows the adaptive version of the decoder as shown in the original VOX ADPCM paper from the Dialogic Corporation. ^[2] The primary difference here is the addition of an adaptive scaling factor for the difference between prediction and actual value. This scaling factor is based on the amplitude of the incoming difference, and we will discuss the specifics of the scaling in the next section.

ADPCM decoder block diagram from the Dialogic Corporation

VOX

There are a number of ADPCM algorithms—many different ways to adapt our step size based on the amplitude of the difference and/or prediction—and after testing some out while importing data as audio in Audacity, I decided VOX was by far my favorite. Unfortunately I wasn't able to find anything pre-existing in Rust for VOX—the symphonia crate that was recommended to me only has Microsoft and IMA flavors of ADPCM. Looks like I need to code it myself! You can find the resulting code here.

Here's a snippet of audio databent through my resulting VOX ADPCM implementation:

The file is libQt5Core.5.dylib which I believe I pulled from DaVinci Resolve a week or two ago. Also, just as a check, here's a voice file (8 kHz sample rate) I encoded as VOX ADPCM with Audacity ^[3] and decoded with this Rust tool:

Sounds just as expected—a bit crunchy and lo-fi like a telephone, but clear and comprehensible.

Reading the VOX Spec

First, we need to calculate the step size ss(n) and use that and the 4-bit input sample L(n) to calculate the difference d(n). That difference plus the previous output X(n-1) will give our 12-bit output value. Below is the pseudocode from the Dialogic paper for calculating d(n) given a value of ss(n) and an incoming sample. Note the values B3–B0—these refer to the 4 bits in the incoming sample, with B3 as the sign and the rest as the magnitude.

d(n) = (ss(n)*B2)+(ss(n)/2*B1)+(ss(n)/4*BO)+(ss(n)/8) 
if (B3 = 1)
    then d(n) = d(n) * (-1)
X(n) = X(n-1) + d(n)

To make this calculation, we need to get the step size ss(n). The pseudocode for that is shown below:

ss(n+1) = ss(n) * 1.1M(L(n))

The paper includes a pair of lookup tables to efficiently calculate this value. Here they are as I use them in my Rust code. We use the 4-bit incoming value to look up an “adjustment factor” in the ADPCM_INDEX_TABLE, and we move an index into the VOX_STEP_TABLE table by that adjustment factor. This index is initialized to zero, giving the first value in that table—16.

vox.rs

// duplicate values from spec; can index w/ whole nibble, incl sign bit (4th)
// increment up/down thru this table...
const ADPCM_INDEX_TABLE: [i16; 16] = [
    -1, -1, -1, -1, 2, 4, 6, 8,
    -1, -1, -1, -1, 2, 4, 6, 8,
];
// ...use (clamped) index table to index this array for step size
const VOX_STEP_TABLE: [i16; 49] = [
    16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
    50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130, 143, 
    157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408, 449, 
    494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552,
];

Note that incoming magnitudes (first 3 bits) below 4 cause the step size to decrease, and values 4 or greater cause it to increase. The values in ADPCM_INDEX_TABLE are duplicated so I can use the whole 4-bit value (including bit 4, the sign bit) to index the table.

Implementing VOX in Rust

To start, I have a struct called VoxState that stores the predictor and step index. Note in the diagram above that these two values are fed into single-sample delays (the blocks labeled “Z^-1”), ^[4] so having them stored in a struct allows us to maintain state between calls to the decoder function.

vox.rs

pub struct VoxState {
    predictor: i16,
    step_index: i16,
}

I implement a vox_decode() function for the VoxState struct, as shown below. We get the step size from last time around, then update the step size for next time. The sign is the 4th bit of the incoming nibble, and the magnitude is the lower 3 bits. We get the difference between the current value and the prediction from last time with the line let mut delta = ((2 * (magnitude as i16) + 1) * step_size) >> 3;—we will come back to how this relates to the pseudocode in a bit.

We either add or subtract the predictor and delta, depending on the sign bit, and clamp the predictor to the range of a 12-bit signed integer. When we return this value from the function, we multiply it by 16, scaling it into the range of the 16 bit integer format of the .WAV file we'll write later. Before returning, we'll also update the struct's step index for next time around.

vox.rs

impl VoxState {
    // ...
    pub fn vox_decode(&mut self, in_nibble: &u8) -> i16 {
        // get step size from last time's index before updating
        let step_size = VOX_STEP_TABLE[self.step_index as usize];
        // use in_nibble to index into adpcm step table; add to step
        let mut step_index = self.step_index + ADPCM_INDEX_TABLE[*in_nibble as usize];
        // clamp index to size of step table—for next time
        step_index = i16::clamp(step_index, 0, 48);

        // sign is 4th bit; magnitude is 3 LSBs
        let sign = in_nibble & 0b1000;
        let magnitude = in_nibble & 0b0111;
        // magnitude; after * 2 and >> 3, equivalent to scale of 3 bits in (ss(n)*B2)+(ss(n)/2*B1)+(ss(n)/4*BO) from pseudocode
        // + 1; after >> 3, corresponds to ss(n)/8 from pseudocode—bit always multiplies step, regardless of 3 magnitude bits on/off
        let mut delta = ((2 * (magnitude as i16) + 1) * step_size) >> 3;
        // last time's value
        let mut predictor = self.predictor;
        // if sign bit (4th one) is set, value is negative
        if sign != 0 { delta *= -1; }
        predictor += delta;

        // clamp output between 12-bit signed min/max value
        self.predictor = i16::clamp(predictor, -i16::pow(2, 11), i16::pow(2, 11) - 1);
        // update for next time through; ss(n+1) into z-1 from block diagram
        self.step_index = step_index;
        // return updated predictor, which is also saved for next time; X(n) into z-1
        // scale from 12-bit to 16-bit; 16 = 2^4, or 4 extra bits
        self.predictor * 16
    }
}

Returning to the main code file and picking up from last time, here is how we use our new code. We've opened a file as a Vec<u8>, and we're storing the results of a match expression in a Vec<f64> (since the filtering will work better with floats). In the “arm” of the match expression for the VOX format, we iterate over the imported Vec<u8>, and for each byte, we split the byte into two 4-bit “nibbles,” iterating over [chunk >> 4, chunk & 0b1111].iter() and running vox_state.vox_decode() for each nibble.

In the diagram below from the spec, note that the highest 4 bits in a byte come first, so our first nibble is chunk >> 4, which brings those bits down into the lowest 4 positions. chunk & 0b1111 keeps only the 4 lowest bits, giving us the second nibble in the byte.

VOX byte layout from the Dialogic Corporation

We push the decoded values into our output Vec<f64>, ready for the next stage, which is filtering and writing to .WAV (see previous post for a discussion of that code).

main.rs

// import file as Vec<u8>
let data: Vec<u8> = fs::read(entry.path()).expect("Error reading file");
// need to filter as f64 anyway, so best to do in match arms here for consistency
let converted_data: Vec<f64> = match args.format {
    // ...
    SampleFormat::Vox => {
        let mut output: Vec<f64> = Vec::new();
        let mut vox_state = vox::VoxState::new();
        data
            .iter()
            // using for_each and...
            .for_each(|chunk| {
                // start with highest 4 bits (by right-shifting)
                // then & 0x1111 then selects lowest 4
                for nibble in [chunk >> 4, chunk & 0b1111].iter() {
                    output.push(vox_state.vox_decode(nibble) as f64);
                }
            });
        // ...returning outside of pipeline since we need to handle *two* nibbles per element in iter()
        output
    }
};

Before we discuss the challenges, just for funsies I put the compiled binary for my databending tool back through the tool (using our new VOX codec). Here's a segment of the result:

Challenges

At this point, our code works! There were a few things in the VOX spec that tripped me up though, so let's talk about how I got my code working. First, when my attempt at implementing the spec gave me trouble, I looked at the source for FFmpeg, which Audacity uses—specifically the function adpcm_ima_oki_expand_nibble() in libavcodec/adpcm.c, line 553. ^[5] This is where I got the line let mut delta = ((2 * (magnitude as i16) + 1) * step_size) >> 3; from vox.rs above.

Let's consider the line of pseudocode d(n) = (ss(n)*B2)+(ss(n)/2*B1)+(ss(n)/4*BO)+(ss(n)/8)—this is how we combine the incoming magnitude and the step size to get the difference between the current and previous samples. B2, B1, and B0 are the three magnitude bits from the incoming nibble. If, for example, B1 is zero, ss(n)/2*B1 will divide by zero. Not only will we need to check whether each bit is zero or not, but division is more costly than the other arithmetic operations. However, we can think about this another way.

With (ss(n)*B2)+(ss(n)/2*B1)+(ss(n)/4*BO)+(ss(n)/8), if we leave out the multiplication by ss(n) for the time being, we have 1 or 0 times 1; 1 or 0 times 1/2; 1 or 0 times 1/4; and 1 times 1/8. That's just the ones place and first 3 binary floating point places. If we shift those values 3 places left, we have no more fractions/division, and if we shift the incoming 3 magnitude bits 1 place left (i.e., multiply by 2) and add one, our magnitude and the previous values we shifted line up the same way as before. We can multiply what we have now by the step size, and >> 3 “undoes” the left shift we did to get rid of the fraction. Thus ((2 * (magnitude as i16) + 1) * step_size) >> 3 is equivalent to (ss(n)*B2)+(ss(n)/2*B1)+(ss(n)/4*BO)+(ss(n)/8), but we don't need to work around dividing by zero, and things are a bit faster to boot.

Looking Forward

Lately I've been enjoying windytan (Oona Räisänen)'s blog—a “blog about sound & signals” where she discusses a variety of telecommunications encoding formats, both in terms of their sound and decoding them. I got an RTL-SDR software-defined radio dongle back in 2020, and greatly enjoyed tracking down and decoding interesting signals. Now that I have more programming skills, I think I'll do more discussion of and coding with different telecommunications formats—both for radio, and for telephony, as I did today.

One thing that @EveHasWords mentioned recently and that I also saw on windytan's blog is using cassette tapes to store digital data such as software or games. The general idea is that you modulate a tone to encode digital data, and then record that as audio on a regular cassette tape—this person did it with an Arduino and Python, so that could be a good starting point for a fun project.

You can follow the RSS feeds for this blog to see any future updates on such projects—hope to see you then!

L. Tan and J. Jiang, Digital Signal Processing: Fundamentals and Applications. Academic Press, 2018, pp. 486–496. ↩︎
Dialogic Corporation, Dialogic ADPCM Algorithm, 1988. [Online]. Available: https://people.cs.ksu.edu/~tim/vox/dialogic_adpcm.pdf. ↩︎
Here's a link to the Audacity forum explaining where to find the settings to do this. ↩︎
This notation comes from the idea of the Z-transform. ↩︎
FFmpeg, libavcodec/adpcm.c. [Online]. Available: https://ffmpeg.org/doxygen/7.0/adpcm_8c_source.html#l00553. ↩︎

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

Databending Part 4—Data to Audio with a Rust Tool

reillypascal@gmail.com (Reilly Spitzfaden) — Thu, 01 May 2025 21:24:00 GMT

Earlier this year I wrote about how to import any file into Audacity and convert it to audio. Today I want to make the process less tedious, as well as get some practice with the Rust programming language.

When I first wrote about this process, I mentioned that

once you listen to the “sonified” data from enough files, commonalities start to become apparent…[and] the process of finding these sounds is also fairly slow and painstaking.

In addition to simply speeding up the search for interesting files, automation also makes it more practical to “audition” different ways of importing a given interesting file. I usually convert the data into an audio file in which each “sample” is a 16-bit integer—in many cases, I find I like the sound result of this best. However, treating it as an 8-bit, 24-bit or 32-bit integer (or some of the more unique sample formats available in Audacity, such as ADPCM) can give additional variety and get around the sonic commonalities I mentioned.

The ADPCM input format is still in the works, but just because I like to include audio at the start of things, I want to take a brief sidebar about why ADPCM could be cool. Audacity has the VOX or Dialogic ADPCM flavor as one of its import formats, and I've had some interesting results importing data using it and similar formats.

If my math is correct, the audio examples here should be from the same portion of the source data (the libicudata.73.1 library file from the macOS release of the calibre e-book manager). The first one is imported in Audacity as signed 16-bit integer at 44.1 kHz sampling rate:

The second is imported into Audacity as VOX ADPCM (also at 44.1 kHz):

The VOX ADPCM file is 4x as long (since it only uses 4 bits per sample, instead of 16), and the result is sort of like a time-stretched version of the 16-bit one, but the voice-focused algorithm of the VOX ADPCM format introduces new strange characteristics as well.

Anyway, my Rust tool is still a work in progress, but I thought I'd do a writeup of what I have so far. If you want to use it or just follow along, the code is available here on GitHub—if you're comfortable using Rust's cargo package manager, it should be usable, and I'll look into providing compiled releases at some point! You can hear the result of this tool here:

Importing the Files

As a refresher on the databending process, I wrote in the first post that in digital audio files

we take repeated readings or “samples” of this rising and falling [air] pressure at very rapid intervals in time (the “sample rate”), and represent the height of the rising and falling line at each reading using an integer value.

Since any computer file is just a list of [binary] numbers…we can take the list of numbers from any file and treat them as a list of amplitudes in an audio file.

First, we want to import files as a list of bytes, and we want to be able to traverse through a large folder of files, with possible sub-folders. The walkdir Rust crate is useful for traversing directories, and these examples from the Rust Cookbook are a good model. WalkDir::new() returns a recursive iterator into the directory, and we can check if the metadata is good; check if the metadata says an entry is a file and is bigger than the minimum size we've chosen (0 is the default); and if so, use fs::read() to read in the file. fs::read() returns a Result<Vec<u8>>, so we can use .expect() to get the vector out of the Result<T,E>.

use std::fs;
use walkdir::WalkDir;

fn main() {
  // WalkDir "walks" recursively through a directory and all its subfolders
  // args.input is from CLI arguments via clap
  WalkDir::new(&args.input)
    .into_iter()
    .filter_map(|entry| entry.ok())
    .for_each(|entry| {
      // extract metadata from Result<T,E> for each entry in dir
      if let Ok(metadata) = entry.metadata() {
        // if it's a file and greater/equal to min size (from CLI args via clap)
        if metadata.is_file() && metadata.len() >= args.min {
          // ...read in file as a vector of unsigned 8-bit integers
          let data: Vec<u8> = fs::read(entry.path()).expect("Error reading file");
        }
      }
    });
}

Converting Files to Audio

I'm using the clap crate to handle command-line arguments. I won't get into too much detail here, but just to cover where it shows up, WalkDir::new(&args.input) above is taking an input path from these arguments, but that could be replaced with another source of &str/&String reading e.g., "input"; args.min above is an integer giving the minimum filesize in bytes, and defaulting to 0; and below, the user's choice of sample format is recorded as one of the options in my SampleFormat enum, which derives from clap's ValueEnum.

use clap::{Parser, ValueEnum};

// ...

#[derive(ValueEnum, Clone, Debug)]
enum SampleFormat {
    Uint8,
    Int16,
    Int24,
    Int32,
}

Picking up where we left off when importing the file, I can take that Vec<u8> holding our file data and, depending on the sample format, convert it to appropriately-sized values. If the contents of the “arms” of a Rust match statement are an expression, you can have something like let converted_data: Vec<f64> = match args.format {}, and the variable converted_data will hold the appropriate value, based on the arm chosen. In this case, simply not putting a semicolon after (e.g.) data.chunks_exact(2).map().collect() causes that piece of code to be an expression.

// ...

if metadata.is_file() && metadata.len() >= 1000000 {
  // ...read in file as a vector of unsigned 8-bit integers
  let data: Vec<u8> = fs::read(entry.path()).expect("Error reading file");

  // ---- CONVERT BASED ON SAMPLE FORMAT ----
  // need to filter as f64 anyway, so best to do in match arms here for consistency
  let converted_data: Vec<f64> = match args.format {
    SampleFormat::Uint8 => {
      data
        .iter()
        .map(|chunk| {
            // bit-shift based on using 16-bit wav at output
            // need to do as 16-bit to avoid overflow in shift
            ((*chunk as u16) << 8) as f64
        }).collect()
    }
    SampleFormat::Int16 => {
      data
        .chunks_exact(2)
        .map(|chunks| {
          // from_le_bytes() takes array of bytes and converts to a single little-endian integer
          i16::from_le_bytes(chunks.try_into().expect("Could not import as 16-bit")) as f64
        }).collect()
    }
    SampleFormat::Int24 => {
      data
        .chunks_exact(3)
        .map(|chunks| {
          // get values from chunks_exact(3), put in array
          let low_part: [u8; 3] = chunks.try_into().expect("Could not import as 24-bit");
          // no i24, so we add this 0x00 to fill out hi byte in i32
          let high_part: [u8; 1] = [0x00];
          // copy to "joined" from low/hi parts as slices
          let mut joined: [u8; 4] = [0; 4];
          joined[3..].copy_from_slice(&high_part);
          joined[..3].copy_from_slice(&low_part);

          (i32::from_le_bytes(joined) >> 8) as f64
        }).collect()
    }
    SampleFormat::Int32 => {
      data
        .chunks_exact(4)
        .map(|chunks| {
          // bit-shift based on using 16-bit wav at output
          (i32::from_le_bytes(chunks.try_into().expect("Could not import as 32-bit")) >> 16) as f64
        }).collect()
    }
  };
}

For the 16-, 24-, and 32-bit versions, I need the core::slice::chunks_exact() function, which returns an iterator over a slice of the specified length. The function from_le_bytes() takes in an array of bytes and converts them into a single little-endian number. The type (e.g., in i32::from_le_bytes()) specifies which version of the function to use. For the 24-bit version, there is no 24-bit integer type, so I use a 32-bit integer and fill the upper byte with zeroes. For the 8-bit version, I simply get an iterator over the data Vec<u8>. All of the match “arms” use .map() to process each value in the Vec<u8>, and .collect() collects those processed values into a new Vec<f64> for processing by the audio filter.

Note that all the sample formats except 16-bit integer use the bit-shift operators (<< or >>) to scale the values to the range needed to output a 16-bit WAV file. 16 bits is plenty to get good-quality sound, and the input formats are primarily for the different sound results, so I'm fine with converting everything to 16-bit at the end. I temporarily convert everything to floating point numbers for filtering because the filter math is nicer to work with that way.

Filtering

I wrote the filter I'm using here myself over summer 2024. Filter math gets intense really fast (and I can only barely muddle through it myself!) so I won't go into it here, but I'll put some reading materials/references in the footnotes if you're interested in reading further. ^[1] ^[2] In short, I have a filter module called biquad; biquad::AudioFilter::new() creates a filter; filter.calculate_filter_coeffs() sets it up; and filter.process_sample() takes in the audio, one f64 sample at a time, returning another f64 on each pass. All this ends up cast as 16-bit integers in a Vec<i16> to be written to the WAV file. Note that I multiply each sample by 0.4 before filtering—this is necessary because filtering out sub-audible noise results in higher peaks in the sound, so I need more headroom to compensate.

// make filter
let mut filter = biquad::AudioFilter::new();
filter.calculate_filter_coeffs();
// vec in which to process sound
let mut filtered_vec = Vec::<i16>::new();
// filter audio
for sample in &converted_data {
  let filtered_samp = filter.process_sample(*sample * 0.4);
  filtered_vec.push(filtered_samp as i16);
}

Writing to WAV

I create a PathBuf from the output path selected by the user, which defaults to output/. This uses the clap crate (which again, I'm not covering to save time), but &args.output could be replaced with another source of &str/&String reading e.g., "output". create_dir() uses fs::create_dir_all(), which the documentation says is equivalent to multiple mkdir calls on a Unix-like system. I can then use PathBuf::push() to add the file name (taken from the entry's path), and PathBuf::set_extension() to change the previous file extension to .wav before using my write_file_as_wav() function.

// args.output is from CLI arguments via clap
let mut write_path = PathBuf::from(&args.output);
// create output dir if doesn't exist - create_dir returns Result<T,E>, so match it and print if error
let out_dir = create_dir(&args.output);
match out_dir {
  Ok(()) => {},
  Err(e) => {
    eprintln!("{}", e)
  },
};
// entry.path().file_name() returns an Option, so if let Some() handles/extracts value
if let Some(file_name) = entry.path().file_name() {
  write_path.push(file_name);
  write_path.set_extension("wav");
  write_file_as_wav(filtered_vec, write_path);
}

// ...

fn create_dir(dir: &str) -> std::io::Result<()> {
    // create_dir_all - like multiple mkdir calls
    fs::create_dir_all(dir.to_string())?;
    Ok(())
}

I use the hound crate to handle writing WAV files (see documentation for hound's WavWriter struct). In addition to the filename, hound::WavWriter::create() requires a “spec” giving the number of channels, sample rate, sample bit depth, and the sample format (from the hound::SampleFormat enum). Once I have an appropriate WavWriter made, I write the file one sample at a time with the hound::WavWriter::write_sample() method, after which I need to call hound::WavWriter::finalize() to update the WAVE header with the final file size.

use hound;

// ...

fn write_file_as_wav(data: Vec<i16>, name: path::PathBuf) {
  // write WAV file
  // spec
  let spec = hound::WavSpec {
    channels: 1,
    sample_rate: 44100,
    bits_per_sample: 16,
    sample_format: hound::SampleFormat::Int,
  };

  // writer
  let mut writer = hound::WavWriter::create(name, spec).expect("Could not create writer");
  for t in 0..data.len() {
    writer.write_sample(data[t]).expect("Could not write sample");
  }
  writer.finalize().expect("Could not finalize WAV file");
}

Summary and Future Goals

To review:

We use the walkdir crate and fs::read() to recursively traverse the files in the folder and open each as a Vec<u8>
The clap crate handles CLI arguments, including selecting the input sample format.
We use core::slice::chunks_exact() and (e.g.) i16::from_le_bytes() to convert groupings of bytes into 16-, 24-, or 32-bit samples.
We use a biquad filter I wrote to cut out sub-audible frequencies, casting to/from 64-bit floats for the filtering.
Finally, we use a WavWriter struct from the hound crate to write each WAV file.

I mentioned the ADPCM sample format at the start, and one of my next goals is to include that option when importing files. The symphonia Rust crate has an ADPCM decoder (sadly not the VOX version—symphonia has Microsoft and IMA flavors). I'll need to do some poking around to figure out how to use it, but I definitely plan to do so in the near future.

I hope to see you again soon!

Steven W. Smith, “The Scientist and Engineer’s Guide to Digital Signal Processing,” accessed April 30, 2025, https://www.dspguide.com/. This one is a bit older (and includes some BASIC and FORTRAN examples), but it's freely available online, the math parts are very helpful, and I overall greatly appreciate that it targets those with less math experience, while still being thorough. ↩︎
Will Pirkle, Designing Audio Effect Plugins in C++: For AAX, AU, and VST3 with DSP Theory (Routledge, 2019), https://www.taylorfrancis.com/books/mono/10.4324/9780429490248/designing-audio-effect-plugins-pirkle. Chapters 10–12 in this one have a good discussion of filter math, and I (very loosely) based my filter on some of the examples here. ↩︎

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

IndieWeb Blog Carnival—“Renewal”

reillypascal@gmail.com (Reilly Spitzfaden) — Fri, 18 Apr 2025 04:00:00 GMT

This month's IndieWeb blog carnival topic is “renewal”—here is Jamie Thingelstad's introductory post on the topic.

Initially I wasn't sure if this topic would apply to anything on which I currently had the inspiration to write, but I read Juha-Matti Santala's post for the carnival and something clicked for me. He writes about

the often observed dilemma that (especially) we techies often run into: how to resist the urge to rewrite the website every time you start writing a new blog post.

I have a similar desire to tinker on and “renew” my site, and recently that has interfered not only with sitting down to write for the site, but with my project and leisure time more generally. In addition to my website tinkering, I'm going to discuss my relationship more broadly to leisure and to projects that interest me.

Writing about Projects

I have received positive feedback for some of the writing I've done here, and I find myself chasing the high of having someone else appreciate something I've made. The kind of writing that I most want to do requires an additional step beforehand. I want to do write-ups of interesting code or music projects and that requires me to actually do a code or music project. Because the writing I'm most proud of requires these extra steps, when I contemplate writing for my blog I'm really thinking of two separate things—the project itself and then the writeup.

Since this site is one of the more public-facing expressions of my skills and personality, small changes to it can feel like easy ways to seek validation of those skills. Rather than having to do a whole project and then still know I need to complete a writeup, if I add an interesting feature to the site, I can share about that on Mastodon or Bluesky and the feature is immediately legible to a viewer without needing much of a writeup to communicate it.

A second motivator to endlessly tinker is that my compulsion to stare at and revisit my own site tends to reveal small “flaws” in it, and leaving things the way they are when they aren't “perfect” feels like a little itch in the back of my head. Even if I feel intimidated by the prospect of getting a personal project to the point it can be written up on my blog (and then actually doing the writeup), poring over my existing website and writing can let me revisit nice things that people said about specific aspects of it, but since looking at it naturally reveals any small flaws, I end up with a laundry list of things that could be tweaked, and that I might prefer were a little better.

The Character of My Projects

In addition to the ease of receiving feedback on my site and the list of small flaws I accumulate, most of the other projects I want to do (audio software development, composition, sound design in Max/MSP, etc.) are more complex and/or subjective than site tinkering. My website already exists, and HTML/CSS are a little more forgiving than C++, so (for example) starting a brand new audio plugin or tweaking an existing one both feel more intimidating.

Composing music (and since designing Max/MSP patches is part of composing for me, that too) also feels much more subjective than frontend development. If a new site feature does what it's supposed to and fits my existing visual design, I'm happy with it. With composing, what constitutes “objectively good” music? It's at least my personal value that there is no truly objective measure of “good” and “bad,” “better” and “worse” art—see for example, Philip Ewell's provocatively-titled article on how our exaltation of Beethoven is much more subjective and based on cultural biases than we might like to admit.

Overall, it's much harder to get myself to start these more subjective and intimidating projects, and much easier to perseverate on tweaks to my site.

Instrumentalizing Leisure and Creation

I found an essay by Anne Helen Petersen via Tracy Durnell's blog that was helpful for me in thinking about how I approach all of my projects, both in coding and composing. Petersen writes about the way she notices herself and other millennials approaching hobbies and leisure. This approach is

…big and ambitious. It’s swallowing. It’s barely keeping the impulse to optimize and monetize at bay. It’s not unique to millennials, but it is endemic among us.

She notices she and her peers grew up feeling that

if you’re doing something that’s not directly related to grades, then it should be extremely legible as a line on your college resume.

If you did what we called an extra-curricular, it was less because it was fun, or because you wanted to, but because “it looked good,” or communicated something “interesting” or “well-rounded” about your personality. […]

It makes sense that whatever hobby we find we like doing…we struggle not to turn it into work. I don’t even mean getting paid for doing it, although we’ll get to that later. We make it hard because when something’s hard, and [we] complete it anyway, it feels like we’re “being productive.” And the more productive we are, the better we feel.

This essay resonated deeply with me and my ongoing search to find recreational activities that don't feel like work, and with which I don't feel like I need to prove myself and do the hobby “well enough.”

I first picked up coding in around 2021–2022, first in sparse explorations here and there, and then in mid 2022 (i.e., right after I finished my composition PhD) much more seriously. I had long been interested in pursuing it, but there was an additional thought—that because the market for college music teaching jobs is rough to say the least, having skills in tech would give me more opportunities for employment and stability. Even when I'm explicitly trying to code for my own enjoyment only, it's hard to break away from the feeling that I need to “optimize” the topics I pursue for capitalist market logic.

Composing was not even an “extra-curricular,” it was just a “curricular” for me. Since all my degrees are in music composition, my skill at composition was central to my academic success, and while I greatly appreciate my teachers' pushing me to think more deeply about how to communicate my ideas clearly in music, it's a pretty big transition to go from receiving weekly feedback in private lessons to being completely in charge of evaluating my own music.

This difficulty extricating my favorite activities from ideas about “productivity” and capitalist utility further contributes to the anxiety around pursuing these activities, again, making small tweaks to my site much less intimidating by comparison.

Reconnecting with What Drew Me Here in the First Place

What do I want to do with this information about how I approach the things I enjoy? First, I want to allow myself “mess around“ more. If something doesn't have immediate capitalist utility, that's OK—it's desirable, even! It sounds much more healthy to let myself do things simply because I feel like it. I want to share what I do in smaller, easier-to-create chunks, without worrying whether each chunk is “impressive” enough.

I also want to allow myself to write about exactly what interests me, regardless of how I think it will be received. For example, I've written a few posts about sound design in Max/MSP and they seemed not to get as much attention as some of the other posts I've done. This wasn't a surprise — Max/MSP is a little niche, and in contrast, some of my posts on databending have a lower bar of entry, only requiring basic use of the Audacity sound editor or a hex editor. It may also be that I had fewer people following me at the time that I posted about Max/MSP. Regardless, I don't want to allow chasing “likes” to dictate what I write, and I think it would be nice to write more about what I do with Max/MSP.

Overall, I want to take a step back and reconnect with my interests in a way that affirms what I most enjoy about them and lets go of the need to impress or be “productive”—a renewal of sorts for the spring.

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

IndieWeb Movie Club: “The Castle” (1997)

reillypascal@gmail.com (Reilly Spitzfaden) — Sun, 13 Apr 2025 03:15:00 GMT

This month's IndieWeb Movie Club is The Castle (1997), and Zachary wrote the introduction post here. Spoilers will follow in this post!

The movie is an Australian comedy about the Kerrigan family whose house is set to be seized (along with those of their neighbors) in order to expand an airport. After a long string of legal mishaps, they win their case against the government and the airport's corporate backer, and are able to keep their home.

The Kerrigan family is portrayed as “unsophisticated” and clueless, and their house not particularly “nice,” with the humor often coming from the disconnect between this and how happy they are with their house and lives.

Reactions

I watched this with my partner who works for the courts, and it was fun to see their reaction to the legal proceedings. For example, the incompetent small-time lawyer Dennis Denuto the Kerrigans and their neighbors bring on for the case frantically shuffles through his notes for uncomfortably long stretches; says he never learned Roman numerals (while trying to read the Australian constitution and devise his argument in real time); and repeatedly argues that the eviction goes against “the vibe” of the constitution. My partner commented that there sometimes really are “vibes-based” arguments made, and that they will definitely be using the phrase “do you have any legal precedent to support ‘the vibe’?”

I don't get around to watching a ton of movies, and this was a fun, lighthearted one to help break out of that. I did start to find the humor repetitive and a bit of a bummer for a stretch in the middle, although the ending was uplifting—the family and their neighbors prevail, set a legal precedent, and Lawrence, the retired Queen's Counsel lawyer who ultimately takes and wins their case becomes a family friend.

As a counter-example to illustrate what I think bummed me out, I like Bob's Burgers and the similarly-animated The Great North. Both shows have quirky families whose oddities are a source of comedy, but in these two shows, I feel like I'm laughing with rather than at the families. The funny thing about the families is that they're odd in a way that's just different rather than something I feel like I'm supposed to look down on. They're also self-aware—the Belchers (Bob's Burgers) and the Tobins (The Great North) seem well aware they're odd, and they don't seem to have a problem with that.

The narrative of The Castle ultimately wants me to root for the Kerrigans, but it did get to the point that laughing at them started to feel mean-spirited. As their fortunes improved though, that feeling went away again, and overall I enjoyed the film a lot—just an interesting contrast I noticed with other things I like.

Wrapping Up

I enjoyed participating in a group blogging activity. I haven't done a blog carnival or other such thing before. I'm planning to do more of these—hope to see you then!

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