Fourier Samples

Turn a big, messy sample library into small, well-organized folders for your hardware sampler.

Years of sample packs add up to more files than anyone can browse, and a sampler's screen shows about ten names at a time. Fourier Samples (the fourier command) picks the best of them, sorts them into CATEGORY/family/file.wav folders named for what they sound like, and fixes what would bite on the device (DC offset, phase-flipped stereo, clicks at the end, notes a few cents off). It then renders the result for each sampler, such as the Elektron Digitakt 2 and the Dirtywave M8. Your library is only read, never changed, and once a release is on a device its paths stay put, so the projects you make with it keep working.

New to Terminal? Getting started on a Mac takes you from nothing to sounds on your sampler, one step at a time, with what you should see after each.

What a build makes

A build reads your library (your sample packs) and writes the master, the curated set. A render is the master converted for one device, and a release is a saved copy of the master that never changes: what you load onto a device.

your library                                 the master                 device renders
Acme Drums Vol 3/                            KICKS/                     01_KICKS/
  Kits/Kit 07/BD_Demo_07.wav        --->       tight-punchy/              tight-punchy/
  One Shots/Kick_Soft_A#1.wav                    BD_Demo_07.wav             BD_Demo_07.wav
Northwind Loops/                             DRUMLOOPS/                 08_DRUMLOOPS/
  174/Break 174 dusty.aif                      170-175bpm-dusty/          170-175bpm-dusty/
  ...                                            Break_174_dusty.wav        Break_174_dusty.wav
                                             KITS/  SLICE/              00_KITS/  00_SLICE/
                                             manifest.json  loops.csv

• Nineteen categories in play order (kicks, snares, claps, hats, cymbals, toms, percussion, drum loops, phrases, sub, synth, stabs, pads, piano, acoustic, waves, FX, blips, voices), plus any your own overlay adds.
• Families clustered by sound and named from what they share, using CLAP, an AI model that runs on your computer and listens to each sample; drum loops sorted into 5-BPM tempo folders.
• Drum kits and slice-ready loops built from the picks (KITS, SLICE).
• A manifest recording where every file came from and why it's there (fourier why <name>).
• Device renders at each sampler's format and path rules, and releases that never change.
• A master the size of your library. A large library gets the style's full master (about 11,000 files); a smaller one gets one in proportion, so a few packs still fill every category they have sounds for.

For anyone with a large library of sample packs and a hardware sampler (a Digitakt 2, an M8, or anything that loads WAV folders) who wants several thousand good, consistently named sounds on it, and can paste a few commands into Terminal (the getting-started page shows how). Not for browsing or tagging a library (a sample browser does that), editing samples, or finding new ones; it ships no audio. Tested on macOS with Apple Silicon; Linux is supported; Windows doesn't work yet (#9).

Try it in a minute

curl -LsSf https://astral.sh/uv/install.sh | sh     # uv, which brings its own Python (macOS, Linux)

Then quit Terminal and open it again (so it finds uv), and:

uv tool install fourier-samples
fourier demo

Already have Python 3.11 or later? pipx install fourier-samples works too, as does pip install fourier-samples in a virtual environment; uv tool install "fourier-samples @ git+https://github.com/bvk7787/fourier-samples" installs the latest code. fourier demo needs no library and no model: in ./fourier-demo (or --dir PATH) it generates 280 synthetic samples, builds and verifies a master from them, and renders it for the Digitakt 2 and the M8, in a minute or two. Everything stays in that folder, and it ends by saying what to try next.

Requirements

• macOS (tested on Apple Silicon) or Linux, with Python 3.11 or later (uv brings one). Intel Macs are untested. Windows doesn't work yet (#9).
• For a real build, the CLAP model. fourier setup installs PyTorch and Transformers (about 750 MB with the CPU build of PyTorch, what macOS and Linux without an NVIDIA GPU get; several GB for the CUDA build) and downloads the model once (about 600 MB). The demo needs neither.
• Disk. About 25 GB free for a large library: the master is about 6 to 7 GB (less for a smaller library or with size), plus up to as much again for each device render and release, the downloads and the caches in ~/.fourier.
• Time. The first build listens to every sample, about an hour for each 100,000 files; later builds take minutes.
• Any library size, any layout. The master scales with the library, and any folder layout works: maker/pack folders, folders by sound type, or one flat folder.
• Optional: Sononym and Ableton Live. When their data is there, a build reads Sononym's classification and Live's auto-tags. Without them, built-in classifiers read file names, folders and the audio itself, and on a large enough library a sound model trained on it places what names don't. You can rate files without Live too (fourier review rate).
• Optional: Ollama, for folder descriptions from a local LLM; fourier setup offers it when it's there.

Quick start on your own library

fourier setup                           # your samples, devices and style; installs the CLAP model
fourier build                           # scan, analyze what's new, build and verify (resumable)
fourier open report                     # a page in your web browser: listen, see why, rate
fourier publish --notes "first set"     # save it as releases/v1, which never changes
fourier render digitakt_2 --release v1  # v1 for the Digitakt 2, its paths locked on the device
fourier open renders digitakt_2         # the folders to drag into Elektron Transfer
fourier render m8_tracker --release v1 && fourier sync m8_tracker /Volumes/M8   # or onto the M8's card

fourier setup asks a few questions, one step at a time (each says what it's for and can be skipped; drag your sample folder in from Finder, and pick devices and a style by number), writes ~/.config/fourier/fourier.toml (fourier config edit opens it), installs the CLAP model and checks everything. fourier setup --yes --library ~/Samples --device digitakt_2 answers them up front; run again, it keeps the config it wrote (fourier setup --yes --force --library ... --device ... replaces it). The first fourier build analyzes the whole library, the long part; it says how long first, fourier build --dry-run shows files, disk space and time per category without writing anything, and a build that stops picks up with --resume. Later builds only scan and analyze what's new.

fourier doctor (and setup's last step) marks each line OK, WARN (worth a look), NEXT (what the first build does itself: scan, analyze, index and, if setup didn't, download the model) or FAIL (what would stop a build: no CLAP install, no library, a folder it can't read), and says what to do about each.

Digitakt 2: connect it over USB, open Elektron Transfer and drag the render's category folders into a folder on the +Drive, such as /fourier. Transfer never overwrites a file of the same name (its manual, pp. 10-11), so files already on the device stay as they are. M8: fourier sync copies the render to /Samples/Fourier on the card without the ._ files macOS leaves behind.

A render of a release locks its paths on the device, and later releases keep them, so your projects keep working. fourier render digitakt_2 without --release renders the master itself: a preview to try, whose paths can change with the next build. fourier publish --dry-run says what a new release would change, and fourier render <device> --dry-run what a render would change on the device.

          fourier build: scan, analyze what's new, curate, verify
library ---------------------------------------------------> master --publish--> releases/vN
(read-only)                                                    |                     |
                                                               +------ render -------+--> device folders

New to Terminal: getting started on a Mac. What comes after the first build (adding packs to a release, rating, making it yours, when something goes wrong): the guide. Every command, the words used here, rating files, configuration, and the styles and knobs: docs/usage.md.

Working with a coding assistant? skills/fourier/SKILL.md teaches it Fourier: the safe commands, how to read a build, and the usual fixes. Copy the fourier folder into ~/.claude/skills/ for Claude Code, or point your assistant at the file.

Updating

uv tool upgrade fourier-samples       # keeps your setup: PyTorch, Transformers and their build
fourier doctor                        # then check

An upgrade keeps your settings, your Fourier home, the master and your releases. With pipx: pipx upgrade fourier-samples. How the CLAP software is kept across upgrades, and updating PyTorch: usage.md, "Installing and updating".

Devices

Profile	Device	Renders
digitakt_2	Elektron Digitakt 2	NN_CATEGORY/family, 48 kHz / 16-bit, stereo kept
m8_tracker	Dirtywave M8	/Samples/Fourier/NN_CATEGORY/family, 44.1 kHz / 16-bit, whole path under 128 characters
generic_44k, generic_48k	anything else	NN_CATEGORY/family, 16-bit stereo WAV; no limits claimed
generic_folder	a folder for a DAW or a computer	NN_CATEGORY/family, 44.1 kHz / 24-bit WAV, no folder or name limits
generic_sd_card	a sampler that reads WAV from an SD card	/Fourier/NN_CATEGORY/family, 44.1 kHz / 16-bit, 128 files a folder, plain-ASCII names; no limits claimed

Every value in a profile cites a page of the device's manual or says it's a convention or unverified, and a test checks each quote against its page when the PDF is at hand.

Your device isn't listed? fourier devices new writes a profile for it in a few questions: see your own device.

Safety and trust

Your library is read-only. Fourier Samples reads your sample folders and, when they're there, the Sononym and Live databases (opened read-only; they aren't official APIs, so an app update can break the reading). The only command that writes into a library folder is fourier tools import-folder, which adds copies there. Here is everything else it writes:

What	Where, by default	Moved by
Config	~/.config/fourier/fourier.toml	fourier setup --to
Home: database, CLAP index, caches, ratings, build history	~/.fourier	$FOURIER_HOME
Master, plus <master>.next during a build and <master>.prev after one	~/Music/FourierCurated	[output] master
Renders (each marked with a .fourier-render file)	~/Music/FourierRenders	[output] renders
Releases and device path locks	~/Music/Fourier/releases, ~/Music/Fourier/devices	[output] publish
The CLAP model	~/.cache/huggingface	$HF_HOME
A card's folder, with a .fourier-card marker	/Samples/Fourier on the M8's card	the device profile
Live rating sidecars	inside the master only

• It refuses to overwrite what it didn't make. A build stops if the master holds a file it didn't make (and lists it), and never builds into a library, a release or a non-empty folder of yours. A render only replaces a folder marked as a render; the demo only a demo folder. fourier sync --delete removes only files this tool put on that card, and anything else there stops it.
• Nothing is replaced until it passes. A whole build goes into <master>.next and replaces the master only when every category built and fourier verify (more than 100 checks) passed. If it stops part way, the master is unchanged, and fourier build --resume picks up where it left off. (A one-category build, fourier build KICKS, writes into the master directly; run fourier verify after it.)
• Undo. The previous master stays in <master>.prev until the next build; move it back to undo one. A release never changes: fourier publish never overwrites one without --force, and never one a device uses, so rolling a device back means rendering an earlier release.
• Network. fourier setup installs PyTorch and Transformers (from PyPI, or PyTorch's own index for the CPU-only build) when you say yes, and downloads the CLAP model once from Hugging Face, pinned to one revision (if you skip that, the first build that needs the model downloads it). Once it's downloaded, the model loads from its folder with Hugging Face offline: analysis, builds and search make no request to Hugging Face. A local LLM (Ollama, on localhost, never through a proxy) only if you turn folder descriptions on or run fourier tools audit. Nothing else, and no telemetry.
• Audio and licenses. It reads open formats, doesn't circumvent copy protection and distributes no audio. Your master, renders and releases are copies of your samples, under their licences: they're for your own use, so don't share or upload them. The manifest.json, build logs and fourier doctor output name your folders and packs; check before posting them. The CLAP model was trained on public audio datasets whose terms are summarized in THIRD_PARTY_NOTICES.md.
• How it's tested. The test suite runs in CI on Linux and macOS, Python 3.11 to 3.14, with coverage measured and mypy checking the source, including a first run end to end without Sononym or Live and a synthetic library built and compared against a stored result; each checks the library is unchanged afterwards (CONTRIBUTING.md). Tested on hardware: macOS on Apple Silicon with a Digitakt 2 (OS 1.16) and an M8.
• Provided as is, under Apache-2.0, without warranty. Keep backups of anything you can't replace.

Uninstall

uv tool uninstall fourier-samples (or pipx uninstall fourier-samples, pip uninstall fourier-samples), then delete the folders in the table above that you no longer want (step by step in Finder). The master, renders and releases are yours to keep: they're plain WAV folders.

Compared with

• Sononym (paid) is a sample browser with similarity search and auto-categorization. It helps you find a sound; Fourier Samples builds and maintains the folders on a device, and can read Sononym's analysis.
• SampleStack (macOS) validates, converts and exports samples for many samplers (https://samplestack.app). Fourier Samples picks a set from a whole library and keeps device paths stable across releases.
• DigiChain (web) builds sample chains from files you've already chosen (https://digichain.brianbar.net).

Contributing and license

Issues and pull requests are welcome: see CONTRIBUTING.md, the code of conduct, the security policy and the changelog.

Copyright 2026 the Fourier Samples authors. Apache-2.0 (LICENSE, NOTICE); third-party terms, including the CLAP model's training data, in THIRD_PARTY_NOTICES.md.

Elektron, Digitakt, Dirtywave, M8, Ableton, Live, Sononym, SampleStack, DigiChain and the other product and company names here, including instrument names used to label folders, are trademarks of their owners. Fourier Samples is an independent project, not affiliated with or endorsed by any of them, or by Fourier Audio Ltd.