Category: Hardware

PicoWaveTracker is a MIDI step sequencer built around a Raspberry Pi Pico, an OLED screen, a rotary encoder, and an 8×8 NeoPixel matrix standing in for the usual grid of step buttons. Turn the encoder to move between steps, click to edit a note, hold to start or stop playback — the kind of tracker interface I’ve always liked, minus the wall of physical buttons.

What makes it more than “yet another step sequencer” is that half the tracks don’t have to be programmed by hand. Alongside the regular manual track, there’s a set of generative strategies you can hand a track over to instead — Euclidean rhythms, L-systems, cellular automata, Markov chains, arpeggios, call-and-response, drones, even a “lucky” random strategy. Each one turns a track into a little algorithm instead of a fixed pattern, and you can run several tracks at once with different strategies and step counts, which gets you polyrhythms almost for free.

A lot of the later work went into making the generated parts actually sound musical instead of just correct: scale and root-note awareness so the algorithms stay in key, a mutation setting with adjustable intensity so patterns drift instead of jumping randomly, and chord-note support so “harmony” means something beyond a single melodic line. There’s also a dedicated drone strategy for when you just want a track to hang in the background.

The hardware side had its own fights: the NeoPixel matrix draws more current than the Pico can supply on its own, so it needs a separate 5V line, with real warnings about not doing this the lazy way and frying a USB port. I also hit a deadlock where the watchdog would restart the whole device if a MIDI lock got acquired twice in a row — the kind of bug that’s obvious in hindsight and infuriating in the moment.

To make this build extra fun, I repurposed a kids’ toy briefcase and made it a bit punk.

Full wiring diagrams, power options (including a portable LiPo setup), and the code for all the generative strategies are in the PicoWaveTracker repository.

Modular synths are great fun, but they usually mean a rack, a pile of patch cables, and a wallet that’s a lot lighter than it used to be. NoiceSynth is my attempt at getting that same “patch it together yourself” feeling into something that fits in a tin box and runs on a single Raspberry Pi Pico.

Instead of a fixed synth architecture, you get a 12×12 grid. You place modules on it — oscillators, filters, envelopes, and a handful of others — and wire them together however you like. Want a patch that leans into DX7-style FM synthesis? Build it. Want a slow, drifting drone instead? Same grid, different wiring. The “instrument” is whatever you’ve patched together.

Under the hood, it’s an RP2040 doing the DSP work, streaming audio out over I2S for clean output. Controls are kept minimal on purpose: a rotary encoder for navigation, a potentiometer for volume, and a 128×64 OLED for visual feedback on whatever you’re doing to the patch. A 3.5mm TRS-A MIDI input lets it take notes from an external keyboard or sequencer, and the whole thing is designed to run off a LiPo cell and a booster board — small and portable enough to actually carry around.

A fair amount of the actual build time went into things you’d never notice from the outside: getting I2S audio streaming without glitches meant adding proper buffering, and once that was stable, I moved the synthesis math over to fixed-point to keep the Pico’s core from choking under a full patch. Patches themselves get saved to EEPROM, so nothing’s lost when you power it off.

There’s also a desktop simulator included, which turned out to be more useful than I expected — it lets you design and audition a patch at your desk before ever touching the hardware, and you can transfer patches back and forth between the two. It ships with eight demo patches plus a few built-in presets that mimic the DX7.

Full build instructions, wiring diagrams, and the source are all in the NoiceSynth repository.

Every Raspberry Pi I own boots into a whole Linux distro before it does anything, which felt like overkill for the one thing I actually wanted: something that makes a sound the moment it’s powered on. StupidSynth throws out the OS entirely — it runs bare-metal on an original Raspberry Pi 1 (or Zero), boots straight into the synth code in one to two seconds, and starts playing.

Once it boots there’s nothing to configure and nothing to press. It just loops a randomly generated melody as a single-voice sawtooth wave out the 3.5mm jack, while the composite video output draws a bare red bar that pulses with the amplitude. No filesystem, no drivers beyond what the synth itself needs, no input handling at all.

The actual interesting part is everything that has to happen before “Hello, World” even makes sense on hardware like this. There’s no libc, no OS, so kernel.c has to be the entire universe — audio generation, video timing, and a boot stub in assembly that hands control over from the Pi’s own firmware in the first place, all built with a bare gcc-arm-none-eabi cross-compiler and linked against a custom linker script. Getting the deploy loop fast enough to be worth iterating on mattered more here than usual, so there’s a Distrobox-based dev container and a script that finds the SD card, copies the built kernel and firmware onto it, and unmounts it — no manual dd-ing required.

This one’s deliberately small and dumb, hence the name, and it only runs on the original BCM2835-based boards (Pi 1, Zero, Zero W), not anything newer. Full source, the deploy scripts, and manual setup instructions are in the StupidSynth repository.