Grit blog

Introducing Grit

Tue, 29 Sep 2026 12:00:00 GMT

Most DJ software is built around a simple idea: one track follows another. You beatmatch, you blend, you move on. That model has carried dance music for decades, and it is still the right tool for a long night of records.

Grit starts somewhere else. It is built for the moment when the drums from one song sit under the bassline of a second and a vocal from a third. Not one track after another, but several tracks against each other, live.

What Grit is

Grit is a stem performance instrument for Mac. You give it your music, it pulls every track apart, and you play the parts.

Up to eight decks. Load tracks side by side. Every detected section of a track becomes a pad you can fire in any order.
Stems on tap. Switch each deck between Full, a cappella and instrumental with one key, or toggle drums, bass, vocals and other parts one by one.
Launch quantize. Hit a pad early and Grit waits for the next beat, bar, four bars or eight bars before it lands. Free mode fires immediately.
Scenes. Capture the tempo, the playing sections, the stems and the mix of every deck, then recall all of it on the next boundary.
Key Sync. Pick a master key. Connected decks follow it with the smallest possible pitch shift, and a minor track finds its relative minor. Keylock keeps tempo and pitch independent.
A proper mixer. Three-band EQ with full kill, a low- and high-pass filter per deck, a crossfader you assign per deck, and headphone cueing on a separate output.
Keyboard scratching. Eight tempo-synced scratch patterns under Shift, with half and double speed on hold.
Controllers. MIDI Learn for the controller you already own, and a ready-made preset for the Akai APC40 MK1 with pads, LEDs, knobs and faders.

The full list of keys lives in Support.

How it works

Grit has three steps, and only the last one happens on stage.

1. Import

Drop in files or whole folders. Grit reads WAV, AIFF, FLAC, MP3, Ogg Vorbis and M4A, and finds tempo, beat grid, key and phrase-aligned sections. Sections start on a phrase, downbeat or beat, so a pad always lands somewhere musical. If the analysis is unsure, the track is flagged for review instead of guessing quietly.

2. Separate

Every track is split into drums, bass, vocals and other parts. This happens on your Mac, with Apple's MLX on Metal. Your music is not uploaded anywhere.

3. Perform

Load tracks into decks and play. Fire sections, switch stems, bring in a vocal on the next bar, kill the low end of one deck while another takes over. Everything is tied to one session clock, so launches stay in time no matter how many decks are running.

Why it exists

I wanted an instrument, not a playlist. Mashups and live edits usually mean hours of preparation in a DAW, and the result is fixed once you export it. Grit moves that work to the stage: the preparation is automatic, and the decisions happen while the music plays.

That also means Grit is not trying to replace the DJ software you already know. Use it on its own for a stem set, or next to your usual setup when you want to take a few tracks apart.

Where Grit stands

Grit is in final testing and not on sale yet. The app works end to end in development, and the remaining work is the kind that has to be done properly before anyone pays: signed and notarized builds, license activation in the app, testing on more Macs, and a round of listening checks.

Before that comes a private beta. Join the waitlist and we'll invite testers in small batches; downloads, feedback and bug reports run through our Discord.

The plan for the launch:

Two personal Macs per license.
All Grit 1.x updates included.
No subscription and no license key: you sign in with your purchase email. A future major version may be a paid upgrade; the version you buy stays yours.

Grit needs an Apple Silicon Mac with macOS 14 or later. The download page has the details.

Try it now

You do not have to wait for the Mac app to hear what Grit does. The playground on the home page is a simplified browser sketch of the idea, with four Creative Commons house tracks. Launch sections, switch stems, move the crossfader, and the audio follows. It is not the app: it runs on Web Audio, not on Grit's native engine. There is more about how it works in Inside the playground.

Follow along

Development notes go into the changelog, and new posts appear here. Both have RSS feeds if you want to know when Grit is ready.

Why Grit is native

Tue, 29 Sep 2026 10:00:00 GMT

The first version of Grit was a web app in a desktop wrapper: Electron for the window, Svelte for the interface, Tone.js for the audio. It was a good way to find out what the instrument should be. Multi-deck playback, bar-quantized launches, stem switching, EQ, filters and a crossfader all worked, and a simplified version of that prototype now sketches the idea in the playground on the home page.

It was not a good way to play a set. So Grit was rewritten as a native application.

What a performance needs

A DJ tool has one job that outranks everything else: the audio must not stop. Not when you load a track, not when you scroll the library, not when a file turns out to be broken, not when the interface is busy drawing eight waveforms.

In a browser engine, audio shares a process with layout, garbage collection, JavaScript and everything else the page is doing. You can work around that for a demo. You cannot rule it out.

How Grit is built now

Grit is written in Rust. The interface uses GPUI, a GPU-accelerated UI framework, and everything else sits behind a UI-independent application core.

A hard real-time audio callback

The audio callback is the code that fills your sound card's buffer, many times per second. In Grit it has a strict contract. It pops audio that was prepared in advance, mixes it, advances the clock and applies fixed-cost DSP. It never:

allocates memory,
takes a lock or waits on another thread,
decodes a file,
touches the disk,
or runs an unbounded loop.

Decoding, analysis and file work happen on other threads and hand finished audio to the callback through preallocated, lock-free queues. If something upstream is slow, the callback still meets its deadline.

Bounded by design

Memory and CPU use are bounded rather than best-effort. Tracks stream from disk instead of being held in memory, queues have fixed capacities, and background work is admitted in limited slots. A large library or a long session should not slowly change how the app behaves.

This is measured, not assumed. A headless release gate in development runs eight keylocked, phase-bent streams plus a preview stream. On 12 September 2026, a 30-second run passed with zero decoder underruns or callback deadline misses, 6.40% p99 callback CPU load and 34.83 MiB peak resident memory. That is a headless development measurement, not a test on physical audio hardware. Qualification on real hardware is still open, and it is part of the work before launch.

Broken files stay contained

Audio files come from everywhere, and some of them are malformed. Grit never parses foreign media inside the app. Imported audio and cover images go through a separate import helper process, one file per run, with limits on time and memory. If a file crashes the helper, only that import fails. The app and anything playing keep running.

Once imported, a track is stored as a managed FLAC file that Grit wrote itself, so playback only ever reads audio it knows.

Stems on your Mac

Stem separation and analysis run locally with Apple's MLX on Metal. There is no bundled Python interpreter, no Node.js runtime and no browser engine in the app. Your music is not uploaded for processing, and preparing a track does not depend on a service being online.

No server on stage

Nothing in a performance depends on a network connection. There is no cloud library and no streaming step between your files and the decks.

Licensing follows the same rule. It is designed around offline activation proofs: once a Mac is activated, the signed proof is stored locally and checked without contacting a server. An outage on our side should never interrupt your audio.

What you get from it

Most of this is invisible when it works, which is the point. What you should notice is what does not happen: loading a track does not interrupt the decks that are playing, a broken file fails its own import instead of the whole app, and a long set does not slowly change how Grit behaves.

Grit needs an Apple Silicon Mac with macOS 14 or later. It is in final testing and not on sale yet. The changelog follows the remaining work, and the download page has the requirements.

Inside the playground

Tue, 29 Sep 2026 09:00:00 GMT

The first thing on the Grit home page is a playground: a simplified sketch of the app window with four decks, section pads, stem switches, a mixer and a crossfader. Press play and it makes sound, and every control you touch changes what you hear.

It is there to explain the idea, not to stand in for the app. This post explains what is running there, and what it leaves out.

A sketch, not the app

Grit itself is a native application written in Rust around a hard real-time audio engine. None of that runs in your browser.

The playground is built from Grit's first prototype, a web app made with Electron and Tone.js before the native rewrite. It plays through your browser's Web Audio, which shares its time with everything else the page is doing. That is fine for showing how sections, stems and scenes fit together. It is not how Grit sounds or keeps time on stage, and most of the app is missing: preparing your own tracks, eight decks, Key Sync, scratching, MIDI and more.

Four real tracks

The playground plays four house tracks that their artists released under the Creative Commons Attribution licence:

Art Now, AlexBeroza feat. Snowflake, electro house
All I Need, Malk & Starjam feat. DaKooka, house
Runnin', Square a Saw, dance
Preoccupied in Thoughts (Craig Ferrier Remix), DJ DeadSheakerz feat. HunterSynth, house

Grit prepared them the way it prepares your tracks: it split each one into drums, bass, vocals and other stems and found its beat grid, key and sections. The demo plays four four-bar sections of each track, an intro, a groove, a break and a drop, cut on Grit's downbeats. All four are stretched to 125 BPM and sit in C minor, so anything you combine will fit. The credits and licences are listed under the playground.

What you can do

Launch sections. Each deck's pads fire its sections. Launches wait for the next boundary of the selected quantize setting, so they land in time. The default is one bar.
Switch stems. Full, a cappella and instrumental presets, or each of the four stems on its own. Stem changes fade in and out without clicks and survive section changes.
Mix. Each channel has volume, three-band EQ and a filter that sweeps from low-pass to high-pass. The crossfader splits the decks into two groups.
Change the tempo. The session moves between 105 and 135 BPM. Pitch follows tempo, like a record played faster or slower. Tap tempo works too.
Launch scenes. Each of the four scenes launches the same section on every deck at once.

The meters show measured output on a −60 to 0 dB scale, and the waveforms are drawn from minimum, maximum and RMS data of the actual audio files, not from decoration.

Keyboard

The playground listens to the same kind of keys as the app:

Key	Action
Space	Play / stop
1–4	Focus a deck
Q, W, E, R	Launch a section
Z, X, C	Full / Acap / Inst
⌥1–⌥4	Launch a scene

The Mac app has many more. They are listed in Support.

The stem field

Below the playground, the "One track in, four stems out" section draws a field of points with three.js. It is built from the same waveform data as the demo. Scrolled to the top, it shows one merged track in the app's grey waveform ink. As you scroll, it separates into four layers in the stem colours.

While the demo is playing, the field follows it: the session clock, each deck's meter and a frequency analysis of the master output drive what you see. If your browser struggles to keep up, it lowers its own resolution.

What stays in your browser

The playground plays its own included audio. It does not ask for microphone access, and it does not upload anything. The audio code and the visualisation are only loaded when they are needed, and the audio starts after you press play. Leaving the page shuts it down.

On a phone, the playground shows one deck at a time. The other three keep playing in the background, so the mix you hear does not change when you switch.

What the Mac app adds

The playground sketches the idea. The app is what you perform with:

Your own music. Import tracks and folders. Grit detects tempo, beat grid, key and phrase-aligned sections.
Stem separation. Every track is split into drums, bass, vocals and other parts on your Mac.
Eight decks instead of four, each with as many sections as the track has.
Scenes you capture yourself, with tempo, sections, stems and the full mix.
Key Sync, loops, rolls and keyboard scratching.
MIDI Learn and a preset for the Akai APC40 MK1.

Grit needs an Apple Silicon Mac with macOS 14 or later. It is not on sale yet; the download page and the changelog show where things stand.