GrooveGrid started because no single tool did everything right.
The problem
Every piece of hardware and software in my setup does a lot of things well — but each one misses the mark somewhere or leaves out something I need. The Octatrack has the best sample mangling workflow in existence — one voice, a handful of slots, slot and slice automation, retriggers, conditional triggers, and you’re forced to be creative with constraints. But its screen is tiny and its interface is slow. Ableton is powerful but indirect — you can hack together Octatrack-style slot switching with sample layers and macro knobs, but it never feels as immediate. And it doesn’t ship with a sample editor. You assign an external one.
I use SoundForge for chopping and exporting samples, which is overkill for what I actually need — markers, normalization, bulk export. But try exporting a sample pack from a variable-BPM recording in Ableton. You can’t. You have to change the project tempo for every loop before bouncing. Ableton has a great interface for organizing sample states in scenes, but it falls apart when you need to get those samples out of the project and into a reusable pack.
Ableton’s sample browser is organized by directory structure, favorites, or preconfigured Drum Racks. Compare that to Maschine, which lets you tag and search properly. I wanted something more centralized — a librarian built around finding samples and creating packs from long recordings, not just navigating folders.
I have an NDLR, which is great for music theory assistance — set a scale and chord, and it generates parts. But it gets repetitive fast. It has a sequencer and a song mode, but both are painful to use.
FL Studio has the step sequencer interface I actually like — it mirrors a drum machine, and the piano roll had a few generative tricks. But they were half-baked novelties, and I hate FL’s routing and basically everything else about it.
I wanted euclidean rhythm generators and Mutable Instruments Grids-style pattern generation built into the sequencer — not as external plugins or Max for Live patches, but as first-class tools that feed directly into the step grid.
The solution
GrooveGrid is the tool I built because it didn’t exist.
Octatrack-style sample control — per-step slot locks, slice sequencing, conditional triggers — but in software with a visual grid where you can see everything at once. Retriggers that work at the MIDI level, so they apply to synths and external gear too. Polyphonic voices defined as offsets from the root note — move the root and the chord shape follows, borrowed straight from the Octatrack. Samples as 0-velocity triggers with configurable gate modes, the way hardware does it.
A built-in sample editor where you chop recordings, bookmark regions, and export slices without leaving the app. Bookmarks travel with the audio file and live in a real relational database — not buried in a project file. Every sample is tracked by UUID and checksum, so references don’t break when you move or rename files. Locating samples is automatic — no filename guessing, no previewing candidates to figure out which one is right. The checksum match is definitive.
A library browser with tagging, full-text search, and collections. Not just a file tree.
Music theory baked into the sequencer — not an external MIDI device you plug in. Set a key, scale, chord quality, and chord degree per scene — or automate the degree per step from the emphasis track. Lock tracks to scale or chord quantization independently, so your bass holds the root while everything else follows the progression.
Euclidean generators and Grids-style pattern generation as first-class citizens, not plugins. They generate steps directly on the grid. Stamp them into regular steps when you like what you hear.
Probability-based step triggers so the pattern evolves on every pass. Happy accidents by design.
One app. Standalone or plugin. No routing nightmares. No external editors. No hacking together workarounds for things that should just work.
How it started
Before GrooveGrid existed, I was writing Node.js scripts to batch-export 128-sample packs for Ableton Drum Racks — creating redundant copies of samples everywhere — and generating random MIDI files to get procedural patterns into my sessions. It worked, but it was clunky and indirect. The tools I wanted didn’t exist, so I started building them.
GrooveGrid started in March 2025 as an Electron/React app. My background is in web development, so that was the fastest way to get the idea out of my head and into something I could use. It worked — until it didn’t. Audio latency, thread limitations, and the overhead of shipping a browser as a desktop app all caught up fast.
I tried Tauri next — Rust backend with a web frontend — but that had its own set of problems. So I went full native with C++ and JUCE. The UI, the audio engine, the sample editor — all rewritten. The concepts survived. The stacks didn’t.