I built chopping, then realised I’d missed the point

The code worked. The instrument didn’t—at least not quite.

lq-12 0.3 is about sampling: chop something up, sequence it, process it, resample it and keep going. I had the chopping system working from beginning to end before realising I’d made one important assumption that didn’t make much musical sense.

I could load a drum loop, cut it into slices, audition them and assign them to steps. I had even added a quick way to spread all the chops across the sequencer.

Technically, it did exactly what I had designed it to do.

Then I stopped building and thought about how I would actually use it. That exposed the problem.

Chopping and sequencing are not the same thing

I had started treating the sixteen slices and the sixteen visible sequencer steps as though they naturally belonged together.

That works if all I want to do is reconstruct the loop I just chopped. Once I’ve done that, though, most of my creative options amount to turning parts of the original loop on and off.

That isn’t why I wanted chopping in lq-12.

Take a four-bar drum break. I might cut it into sixteen slices but only want three sounds from it: a kick, a snare and a slightly scruffy hi-hat.

I shouldn’t have to sequence all sixteen slices. I should be able to find those three sounds, ignore everything else and use them to make a completely different rhythm.

It sounds obvious now. It was less obvious while I was busy building all the machinery underneath it.

Thinking more like a classic sampler

The answer came from returning to the way classic hardware samplers treat chopped audio.

When I chop a sample, I’m creating a bank of playable sounds. Those sounds don’t have an inherent position in the sequencer.

A kick might be Slice 1. A snare might be Slice 4. A hat might be Slice 11.

I can play the kick four times, ignore Slice 2 completely, put the snare wherever I want and never touch half of the other slices.

That was the distinction I had blurred.

I’m now separating three parts of the workflow more clearly:

The sixteen keys can represent sixteen slices while I’m working with the sample, without tying those slices to the sixteen visible steps in the sequencer.

A slice answers what should play?

A step answers when should it play?

That small distinction changes the whole instrument.

A four-bar loop shouldn’t become a one-bar pattern

There was another sign that my original approach wasn’t quite right.

Imagine a four-bar loop divided into sixteen equal slices. Each slice might represent roughly one beat.

If the lq-12 pattern contains 64 sixteenth-note steps, placing Slice 1 on Step 1, Slice 2 on Step 2 and so on doesn’t reconstruct the phrase. It squeezes the slices into the beginning of the sequence.

So I’m changing the spread feature as well.

Instead of treating slice number and step number as the same thing, spread will place the slices across the length of the track.

Sixteen slices spread across a 64-step pattern would land on Steps 1, 5, 9, 13 and so on.

That makes spread useful when I do want to reconstruct a chopped phrase. But it remains a convenience, not the main way to work.

The more interesting workflow is still the simple one: audition the slices, find the good bits and make a new rhythm from them.

Working software can still be the wrong instrument

This is one of the useful things about developing lq-12 in small, playable stages.

Some problems aren’t bugs.

The tests can pass. The audio engine can do exactly what it was told. Projects can save correctly. The interface can display the right information.

The workflow can still be wrong.

That only becomes clear when I stop looking at the implementation and ask a much simpler question:

Would I actually want to make music this way?

This time, the answer was: not quite.

Fortunately, I don’t need to throw away the underlying slice system. It already allows any slice to be assigned to any step.

What I’m changing is the instrument built around it.

The result should feel much closer to what I wanted from lq-12 in the first place:

Sample something. Chop it up. Find the good bits. Make something completely different. Resample it. Do it again.

That’s a much better loop.