The Electrosmith Daisy Guide
The Electrosmith Daisy Seed is a self-contained embedded audio computer — an ARM Cortex-M7 chip, stereo audio in/out, and exposed control pins on a module the size of a guitar pick. This chapter covers what it actually is, how it differs from an analog pedal circuit, and the libDaisy/DaisySP software framework that turns it into an effect.
The Electrosmith Daisy Seed is a self-contained embedded audio computer on a module roughly the size of a guitar pick: an ARM Cortex-M7 processor running at 480MHz, stereo audio input and output, and a row of exposed pins for potentiometers, switches, and LEDs. Where every circuit in the Effects book manipulates a guitar signal as a continuously varying voltage, the Daisy Seed converts that voltage into numbers, runs code on those numbers, and converts the result back into voltage — a fundamentally different way of building an effect, not just a smaller way of building the same one.
The flip-book mental model for what “digital” actually means
An analog fuzz circuit or op-amp overdrive works directly on the continuous, ever-changing voltage of your guitar signal — at every instant, real, uninterrupted physics is happening to real voltage. A Daisy-based effect instead takes rapid-fire snapshots of that voltage (44,100 or 48,000 times per second, typically), turns each snapshot into a number, and runs a small piece of code on that number before turning it back into voltage on the way out. It’s the same relationship as a movie versus real motion: a flip-book of enough individual still frames, shown fast enough, looks and feels continuous — but underneath, it’s discrete snapshots, not continuous motion. DSP basics for guitarists covers this sampling process in depth; here, the point is just to internalize that a Daisy effect’s “circuit” is code operating on numbers, not components operating on voltage.
What changes between an analog build and a Daisy-based one
| Analog pedal (Effects book) | Daisy-based pedal (this book) | |
|---|---|---|
| What defines the effect | Component values (resistors, capacitors, transistor bias) | Code running on the processor |
| How you change the sound | Swap or adjust physical components | Edit and re-flash the program |
| What a knob controls | Directly varies a voltage or resistance in the signal path | Feeds a numeric value into your code, which decides what to do with it |
| Where the sound is defined | The physical circuit itself | Software — the same Daisy Seed can be a delay, a reverb, or a synthesizer depending only on what’s flashed onto it |
This is the practical reason the Daisy Seed is the site’s differentiation focus (see the analog vs digital overview): a single piece of hardware can become an entirely different effect just by loading different code, something no fixed analog circuit can do without a physical rebuild.
libDaisy and DaisySP: the two-layer software framework
Electrosmith maintains two open-source C++ libraries that do the heavy lifting so you don’t write audio drivers or hardware register code yourself:
- libDaisy — the hardware abstraction layer. It handles reading potentiometers and switches, driving LEDs, and — critically — running the audio callback that feeds your code a fresh block of incoming samples and expects a block of outgoing samples back, continuously, in real time.
- DaisySP — the DSP building-block library. It provides ready-made, pre-tested implementations of common effect components — oscillators, filters, delay lines, reverbs — so you assemble an effect from proven building blocks instead of writing every algorithm’s math from scratch.
Together, these two libraries mean writing your first working effect is closer to assembling a small set of function calls than it is to the from-scratch DSP math covered in DSP basics for guitarists and coding effects with C++ — those chapters explain what’s happening inside the building blocks DaisySP already hands you.
Common mistake: treating a Daisy project like a general-purpose microcontroller project
The Daisy Seed can be programmed with the same broad tooling as an Arduino or STM32 board, and it’s tempting to approach it the same way — write some logic, run it, see what happens. Audio processing doesn’t tolerate that looseness: the audio callback has to return a finished block of samples before the next block is needed, on a strict, unforgiving schedule, or the output audibly glitches, clicks, or drops out. Code that would be perfectly fine in a blinking-LED project — a delay loop, a slow debug print, a dynamic memory allocation — can be exactly what breaks real-time audio. This real-time constraint, more than the C++ syntax itself, is the actual learning curve of Daisy development, and it’s covered directly in coding effects with C++.