< BACK

Anatomy of a Glitch: How Machines Break and Why We Keep the Pieces

What a glitch physically is, Cascone, Oval, Yasunao Tone, Error Systematics, and a free in-browser lab where you glitch your own sample loop.

Reading time
15 MIN
Logged
▪ SIGNAL CAPTURE // CER-N018 // November 18, 2026
error.node · Error Systematics 001 · enabl.ed

Every release on this label carries ERR somewhere in its catalog number. Since 2013. As of this month we're past ERR105, and the question I get more than any other is some version of this: so it's glitch music? Is error just your word for glitch?

Yes and no. The gap between those two words is the whole philosophy.

An error is a judgment. It's the name you give an outcome that missed its target: the wrong number, the late sample, the file that came back corrupted. It lives in the space between what a system was supposed to do and what it actually did. A glitch is the evidence. The click, the stutter, the half second of digital shrapnel that reaches your ears when the error surfaces. The error happens inside the machine. The glitch is the part that escapes.

Most people only ever deal with the second one. They buy a plugin that makes things stutter, run a vocal through it and call it glitch. Fine. Clean Error was built around the first one. The conditions that cause the break, the system around it, and the decision to keep what came out. A glitch is a sound. An error is a verdict about what counts as wrong, and once you own that verdict, every failure the machine can produce becomes something you can play.

So this piece goes all the way down. What physically happens in the hardware when sound breaks, with waveforms. The three people who heard music in that wreckage before anyone else: Yasunao Tone taping pinholes onto a Debussy CD, Oval drawing on discs with felt tip markers, and Kim Cascone writing the whole thing down in 2000. Then two ideas I've been running this label on for years without ever putting names to them, Engineered Deviation and Emergent Recursion. Together they make Error Systematics.

Start with the machine. A glitch is a system telling you the truth about itself at the exact moment it fails at its job.

Glitching CD

What a glitch physically is

Every piece of digital audio you've ever heard is a stream of numbers arriving on a deadline. Forty four thousand one hundred of them a second for a CD, sometimes more. The converter wants the next number now. Most glitches come down to the number being late, wrong, missing, or repeated, and each one leaves a fingerprint you can learn to hear.

FIG.01 ANATOMY OF A GLITCH4 FAILURE MODES / SIGNAL VIEWA / BUFFER UNDERRUNBUFFER = 0CPU misses the deadline. Output drops to silence,then snaps back: dropout + click at both edges.B / BAD EDIT POINTDISCONTINUITYΔ amp in 1 sampleCut not at a zero crossing. The jump holdsevery frequency at once: a broadband click.C / ALIASINGTRUE 11 Hz· FS 12 Hz· HEARD 1 HzAbove Nyquist (fs/2) a tone folds back downas a false, lower one. Bitcrush lives here.D / SKIPPING CDSECTOR 418RE-READRE-READRE-READLaser loses track, error correction gives up,the player re-reads one block: the stutter loop.

Fig.01: four ways a signal breaks. Gold is where the failure lives.

BRING YOUR OWN ERRORBreak your own sound

Every module below runs on sound it synthesizes itself, but you can feed it your own. Hit LOAD YOUR SAMPLE in the lab's top bar, or drop a file onto it: a drum loop, a vocal, a field recording, anything under 5 MB (WAV, MP3, AIFF or OGG). It loads straight into Module A and the Module C feedback chamber, so you can starve it of samples, splice it in the wrong place, fold it above Nyquist, scratch it like a wounded CD, then feed it back through itself until it forgets where it came from.

Nothing gets uploaded. Your file is decoded and broken inside your own browser and disappears when you close the tab.

INTERACTIVE // ERROR SYSTEMATICS LAB

Press POWER ON, then play, or load your own sample first. Everything is processed live in your browser. Open the full lab.

The buffer underrun

Your computer doesn't play audio sample by sample. It fills a small bucket, a buffer, and hands the whole bucket to the sound card. If the CPU gets distracted and the bucket isn't refilled in time, the card has nothing to play. You get a gap of silence and two hard edges where the sound drops out and slams back in. Anyone who's run Ableton at 64 samples with too many plugins open knows that crackle. It's the sound of the machine missing a deadline.

The click at a bad edit point

Cut a waveform anywhere other than where it crosses zero and the speaker has to jump from one position to another in a single sample. A perfect jump like that contains every frequency at once, so you hear a tick. Engineers spend careers hiding these with tiny fades. Plenty of the early Mille Plateaux catalog is built from them on purpose. That tick is the most basic glitch there is: two pieces of sound that don't agree on where the speaker cone should be.

Aliasing

Digital audio can only describe frequencies up to half its sample rate, the Nyquist limit. Feed it something higher and it lies. The tone folds back down and shows up as a lower frequency that was never in the original. Crank a bitcrusher's sample rate reduction and those metallic, inharmonic squeals are aliasing doing exactly this. The video below shows it better than I can describe it.

Aliasing demonstrated: what happens when a signal is sampled too slowly.

The skipping CD

A CD player reads pits with a laser, and the disc carries a lot of redundant data so the player can rebuild what a scratch hides. When the damage is bigger than the error correction can handle, the player either mutes, guesses, or loses its place and re-reads the same little block over and over. That stutter loop you remember from a scratched disc in a car is the player failing in real time and trying to recover. Everyone in this story starts right here.

Digital audio spinning disc

Yasunao Tone and the wounded CD

Yasunao Tone got there first, by a long way. He was a Fluxus guy, cofounded Group Ongaku in Tokyo in the early 60s with Takehisa Kosugi and Mieko Shiomi, and by the mid 80s, only a couple of years after the CD came out, he was poking pinholes into strips of Scotch tape and sticking them to the underside of discs. One of the first was a CD of Debussy's Préludes. The tape confused the laser and the error correction, and the player started spitting out fragments, jump cuts and digital shrapnel that no human could have performed.

He called them wounded CDs. I love that word because it puts the damage on the object instead of on the music. The disc is hurt. The player is doing its honest best with what's left. Solo for Wounded CD came out on Tzadik in 1997 and it still sounds hostile today. He'd sometimes knock the player during performances to make it jump further. Tone died in 2025 at 90, and every glitch producer alive owes him something, whether they know his name or not.

Yasunao Tone, Solo for Wounded CD (1997).

Oval and the painted discs

Then Germany, early 90s. Oval was Markus Popp, Sebastian Oschatz and Frank Metzger (plus Holger Lindmüller at the start), and they had a rule against synthesizers. Instead they drew on CDs with felt tip markers, the famous painted CD story, and sampled whatever the confused players gave back. Skips, loops, little shimmering stutters. Then they arranged those fragments into something you could almost call pop music.

Systemisch landed on Mille Plateaux in 1994 and 94 Diskont followed in 1995. "Do While" off 94 Diskont runs for about twenty four minutes and it's the one I'd hand anyone who thinks glitch has to be harsh. It's gorgeous. Soft, warm, endlessly looping, and every sound in it came from a machine reading a disc wrong. Tone made the failure confrontational. Oval made it pretty, and that's the half of the lineage Clean Error grew up on.

Oval, "Do While" from 94 Diskont (1995).

Kim Cascone gives it a name

By 2000 this stuff was everywhere in the underground and nobody had pinned it down. Kim Cascone did it in the Computer Music Journal with an essay called "The Aesthetics of Failure: 'Post-Digital' Tendencies in Contemporary Computer Music." He opens on Nicholas Negroponte's line that the digital revolution is over, and runs with it. Digital tools had gone ordinary. Background furniture. So the interesting move is to listen to where they break.

"glitches, bugs, application errors, system crashes, clipping, aliasing, distortion, quantization noise"Kim Cascone, The Aesthetics of Failure, 2000

That list reads like a mood board for this label. The other line I keep coming back to is that "the medium is no longer the message; rather, specific tools themselves have become the message." Glitch artists use software for things its designers never intended, and the tool's failure modes become the palette. He wrote it the same year Mille Plateaux put out the Clicks & Cuts compilation, which is about as good a snapshot of the moment as exists. If you want to hear him talk through it, there's a great clip from Lovebytes 2000 with him and Terre Thaemlitz.

Terre Thaemlitz and Kim Cascone at Lovebytes, 2000.

FIG.02 SIGNAL HISTORYFAILURE AS MATERIAL / MID 80s → 2026MID 80sYASUNAO TONEwounded CDs: pinholedtape on the disc1994OVALSystemisch on MillePlateaux1997YASUNAO TONESolo for Wounded CD,Tzadik2000KIM CASCONE"The Aesthetics ofFailure", CMJ2010ROSA MENKMANGlitch StudiesManifesto2026CLEAN ERRORERRFRGX002 + ERLV001

Fig.02: from taped discs to this label.

Introducing Error Systematics

Here's my problem with how glitch usually gets talked about. People describe the effect. Bitcrushed snare, stuttered vocal, granular smear. That tells you what's on the surface and nothing about what the producer actually decided. A pop track can run its hi hats through a bitcrusher and keep the exact same arrangement. The error is decoration.

What Tone and Oval did was different. They built situations where a system would fail and then composed with the result. I've started calling that whole approach Error Systematics. It's less a genre and more a way of working: how you set up a system so errors can happen, how those errors push on the music around them, and what comes out the other side. It splits into two ideas.

CONCEPT 01 Engineered Deviation

Deliberately building the conditions for a system to behave wrong, then deciding which wrong to keep.

The paradox is obvious. You're intentionally creating something that's supposed to be unintentional. And the trick is you have to understand what the system was meant to do before you break it. Take a plain drum pattern. Kick holds the pulse, snare marks two and four, hats subdivide. Now pull the second snare a hair early. Chop one kick into a dozen microscopic slices. Delete a couple of hats and double one up into a ratchet. Your ear still finds the groove. It just keeps getting snagged on it.

FIG.03 CONCEPT 01 / ENGINEERED DEVIATIONDELIBERATE MALFUNCTIONA / 16 STEP GRID / CLEAN VS DEVIATEDCLEANHATSNAREKICKDEVIATEDHATSNAREKICK■ held■ displaced early▮▮ ratchet / dup✕ removedǀǀǀ micro fragmentsB / TRANSFORMATION VS INTELLIGIBILITYAMOUNT OF DEVIATION →1000THE ZONEerror reads as a decisionPATTERN STILL READABLESURPRISEMEANING = readable × surprisingtoo cleanjust noise

Fig.03: Engineered Deviation. Top, the same bar before and after. Bottom, where an error starts to read as a choice.

INTERACTIVE // ERROR SYSTEMATICS LAB

Press POWER ON, then play, or load your own sample first. Everything is processed live in your browser. Open the full lab.

That snag only works because something stays recognizable enough to be disrupted. Displace everything randomly and the pattern disappears, and the feeling of wrongness goes with it. It turns to noise. The chart above is the whole game for me. Too little deviation and you've made a normal track with a filter on it. Too much and the listener has nothing to hold. Somewhere in the middle the error starts to read as a decision, and that zone is narrower than people think.

It goes deeper than drums. Take an eight note melody. Stretch one note until its attack disappears, turn another into a repeating fragment a few milliseconds long, flatten a third into a noise burst, then shuffle what's left into a rhythm that fights the original phrase. The melody survives, in pieces, but it's no longer running the show. The manipulation has become the architecture. And you start asking the fun question: when does a transformed sound stop being the thing it came from? A vocal becomes a hi hat. A transient becomes a pad. The source is still in there somewhere.

There's a philosophical catch too. Who gets to say the system failed? Clipping is a failure if you wanted a transparent recording. If you wanted that crunch, the clipper did its job perfectly. The event didn't change. The standard did. Error only exists relative to an expectation, and the second you move the expectation, the malfunction becomes material.

Sine waveform
CONCEPT 02 Emergent Recursion

When a broken process starts feeding on its own output, and the structure grows out of the feedback instead of the arrangement.

Engineered Deviation is about introducing the break. Emergent Recursion is what happens after, when the output of one process becomes the input of the next, sometimes of the same process. Picture a short synth phrase going into a delay that feeds back into itself. Each pass, the signal gets a little darker, a little more saturated, the timing smears. Six generations later you've got something that barely resembles the source, yet every sample of it is causally tied to that first phrase.

FIG.04 CONCEPT 02 / EMERGENT RECURSIONOUTPUT BECOMES INPUTA / 5 / 7 / 9 STEP LOOPS, NOTHING ELSE PROGRAMMEDLOOP 5LOOP 7LOOP 9SUM5×75×9ALLfull realignment at step 315 (5×7×9). the groove never repeats inside a bar.B / FEEDBACK LOOP / ONE PHRASE, SIX PASSESGEN 0GEN 1GEN 2GEN 3GEN 4GEN 5each pass: filter → saturate → shift → re-sample its own outputSOURCE

Fig.04: Emergent Recursion. Top, three tiny loops that never line up the same way twice. Bottom, one phrase fed through itself six times.

INTERACTIVE // ERROR SYSTEMATICS LAB

Load your own loop and pick YOUR SAMPLE as the phrase source to run it through the feedback chamber. Everything is processed live in your browser. Open the full lab.

Recursion and repetition get confused a lot. A loop playing the same drum pattern forever is repetition. A system that records its own output, rearranges it and uses that to shape the next bar is recursion. The difference is memory. Each cycle keeps something from the last one and adds a little more difference, so it can travel a long way while staying inside a tiny set of rules.

The top of Fig.04 is my favorite example because it's so simple. Three loops, five steps, seven steps, nine steps. Nothing else programmed. Because they never line up the same way, the combined rhythm keeps throwing accents you never wrote, and the whole thing doesn't fully realign until step 315. You designed the conditions. You didn't design the groove. The producer stops being only an arranger of sounds and becomes a designer of behavior, which, if you've ever lost an afternoon to a Max patch or a modular case, you already know feels great and slightly out of control.

The machine has zero intention. You pick the processes, set the limits, decide what's worth keeping and when to stop. But the result can surprise the person who built it, and that surprise is where a lot of the best moments on this label came from. Recursive structures can even sound like they remember. A melody comes back with a few notes missing. A rhythm returns slightly off. A texture you heard two minutes ago surfaces through the distortion for a second and sinks again. That's the closest thing electronic music has to nostalgia without a single word being sung.

FIG.05 ERROR SYSTEMATICS / TWO MODESWHERE THEY MEET01 ENGINEERED DEVIATION02 EMERGENT RECURSIONACTS ONthe sound / the patternthe process over timeQUESTIONwhat breaks if I push here?what does the break do next?PRODUCER ROLEsurgeongardenerTOOLSedits, slicing, bitcrush, timingfeedback, resampling, odd loopsRISKsounding like a presetsounding like nothingLISTEN FORa pulse you can still finda phrase you half remember

Fig.05: the two modes side by side.

Short version: one changes how a system behaves, the other follows what those changes turn into next. A hyper edited glitch track can live almost entirely in the first. A slow evolving ambient piece can live almost entirely in the second without a single harsh artifact. Most of what I love sits somewhere in between.

Two transmissions to hear it in

Two recent Clean Error releases make the case better than I can with diagrams.

FRGMNT007: Syncpoint Corrosion (ERRFRGX002, July 2026) is four collaborations recovered from the FRGMNT archive, a session that sat in a residual cache marked incomplete until we decided it was finished. Tess and Sandra open it with "loopitectural_13.7," Memory Leak and Brittle give you "Grieving the edits," Gpakreep and Low Battery Orchestra land "post-WARP fatigue," and the closer, "Syncpoint Corrosion," is mine with rinse.repeat. Every track was built in the dark and ends somewhere different from where it started. That's Engineered Deviation in the plainest terms: four pairs of people taking something stable and deciding exactly where to let it rot. It also ships with a browser visualizer that reacts to the audio in real time.

ERRFRGX002: FRGMNT007: Syncpoint Corrosion. Four collaborations, one corroded sync point.

Dark glitch art

The Soft Architecture of Error by Tenant 7 (ERLV001, September 2026) is the recursion side. One continuous 24 minute mix of unreleased material, recorded in June, every section flowing into the next. Tenant 7 is Matthew Wilson and Jairo Castillo, who's also a quarter of Hasbeen. The idea behind it is a structure with no blueprint that grows through repetition and small private routines, where a fracture can be as quiet as a delayed response or a sound recurring in the wrong place. Around 19:05 Rosa Álvarez, a family member of the duo, comes in singing in Spanish over an old family melody, and the whole mix suddenly sounds like it's remembering something. Quiet fracture still changes the system.

ERLV001: Tenant 7, The Soft Architecture of Error. One track, 24:24. Skip to 19:05.

The danger of making error a formula

Here's the uncomfortable bit. Once a malfunction gets reproduced enough, it stops being a malfunction. The bitcrushed snare, the stutter edit, the buffer repeat plugin with forty presets. They're vocabulary now. Rosa Menkman put her finger on this in her Glitch Studies Manifesto back in 2010: the moment glitch becomes popular it starts building its own conventions, and a convention can't surprise anyone.

Piling on more distortion is a dead end. A subtle timing shift can rattle a listener more than a wall of digital noise. An ambient phrase that changes so slowly you only notice after five minutes can say more about memory than any stutter. For Error Systematics to stay worth anything it has to keep questioning its own methods, and when a technique turns predictable, you go back and break the system instead of the sound.

Black and white vintage machine

Tone taped up a Debussy disc forty years ago to see what the player would do when it couldn't read the music. I think about that every time I open a session. The error is the interruption. The system is what makes it mean something. And the music is whatever happens while the two are still arguing.

EXPLORE MORE

Keep reading

ALL POSTS →