Bitbox mk2 sample management: a complete guide

Guide

The 1010music Bitbox mk2 is a 26 HP touchscreen sampler with a lot of overlap with 1010music’s standalone Blackbox, but with something the Blackbox can’t do at all: dedicated CV inputs that let the rest of your rack control pad selection, pitch, and playback. That modular integration is what makes the Bitbox mk2 an instrument rather than just a utility. The tradeoff is that the Eurorack form factor means less screen space and fewer buttons than the desktop version.

Understanding how the Bitbox mk2 organizes samples, manages presets, and routes CV is what makes it fit into a rack without fighting you. This guide covers the mental model (presets, pads, and sample folders), the microSD card layout, how to assign samples to pads, CV and gate routing, the polyphony budget you’re working within, the preset.xml structure, recording into the module, and the format rules you actually need to know.

The mental model

Three concepts run through everything on the Bitbox mk2: presets, pads, and sample folders.

A preset is the top-level container. Each preset is a folder on the microSD card inside the Presets/ directory at the root. The folder holds a preset.xml file plus any recordings you make directly on the module. The preset is what you save, load, and recall. Everything you’ve configured (which sample is on which pad, pad mode, envelope, effects settings) lives in that XML file.

A pad is one of the 16 sample slots shown on the touchscreen. Each pad holds a reference to a WAV file (or folder) on the card, plus all the playback parameters for that sound: mode, start and end points, tuning, ADSR envelope, effect sends. The pad doesn’t contain audio data. It points to it.

Sample folders are the folders elsewhere on the card that hold your audio files. They sit alongside your Presets directory and can be organized however you like: by instrument type, by genre, by session, by source. Presets reference samples in these folders by their absolute path on the card.

The path-based reference system is the most important thing to understand before you start building presets. If you move a sample file after assigning it to a pad, that pad goes silent on the next reload. The preset.xml still contains the old path; the file is no longer there. Plan your folder structure before building presets, or use Pack Preset (covered below) to make a preset fully self-contained before reorganizing anything.

Card layout

The microSD card has no mandatory structure beyond the Presets/ folder at the root. Everything else is up to you.

A typical card layout:

microSD Root/
├── Presets/
│   ├── DrumKit01/
│   │   ├── preset.xml
│   │   └── RC000001.wav
│   ├── SynthTextures/
│   │   └── preset.xml
│   └── LiveSet01/
│       └── preset.xml
├── Drums/
│   ├── kicks/
│   │   ├── kick_soft.wav
│   │   └── kick_hard.wav
│   ├── snares/
│   └── hats/
├── Synths/
│   ├── pads/
│   └── bass/
└── Loops/
    └── 140bpm/

The card accepts FAT32 or exFAT, and individual sample files can be up to 4 GB. Larger microSD cards give you more capacity, and any current 64 to 256 GB card works fine in practice. The module streams files from the card during playback, so card speed matters: Class 10 / UHS-1 (U1) or faster is recommended for reliable multi-voice streaming.

The Bitbox mk2 doesn’t have naming conventions for sample files or any required structure within your sample folders. Name things however makes sense to how you browse on hardware.

Assigning samples to pads

Assigning a sample to a pad happens entirely from the 3.5-inch touchscreen. Tap and hold a pad until the pad detail panel appears. Tap the sample file field, and the Bitbox mk2’s file browser opens. Navigate through the card’s folder tree to your WAV file, confirm it, and the pad loads immediately.

Each pad has a pad mode that controls playback behavior:

  • One-Shot: plays the sample once on trigger, ignores gate length
  • Gated: plays while the gate or pad is held, stops on release
  • Clip: plays in sync with the internal clock, looping on beat boundaries
  • Granular: uses the granular engine, with grain size, position, scatter, and spray controls
  • Slicer: divides the loaded sample into equal segments and triggers individual slices

Pad mode is the most consequential setting per pad, because it changes what the other parameters do and how CV inputs interact with that pad. Granular mode has entirely different controls than One-Shot mode. Slicer mode responds to CV in ways the other modes don’t.

Beyond mode, each pad has its own ADSR envelope, a filter, and send levels to the module’s internal reverb and delay. All of it gets saved into the preset.xml when you save the preset.

Multi-sample folder loading

Instead of assigning a single WAV file to a pad, you can assign a folder. The Bitbox mk2 reads all the WAV files in that folder, sorts them alphabetically by filename, and maps them to consecutive MIDI notes starting at C2. Send the pad different MIDI notes to play different samples from the set.

If you have a folder like this:

kicks/
├── kick_hard.wav
├── kick_mid.wav
└── kick_soft.wav

Alphabetical sort puts kick_hard.wav at C2, kick_mid.wav at C#2, kick_soft.wav at D2. If you want to control the mapping, prefix filenames to control sort order: 1_kick_soft.wav, 2_kick_mid.wav, 3_kick_hard.wav.

Multi-sample loading is the standard approach for velocity-layered kits (different samples for different MIDI velocity ranges) and for melodic instruments mapped chromatically. A folder of piano notes recorded at different pitches, named in chromatic order, turns into a playable instrument on one pad. Add MIDI control from elsewhere in the rack and it becomes a full keyboard instrument within the Bitbox mk2.

CV and gate inputs

This is what the Bitbox mk2 does that the standalone Blackbox can’t: native CV and gate integration with the rest of a modular rack.

The module supports up to 8 CV modulators, a dedicated gate input for each of the 16 pads, and a clock input. A CV modulator can be routed to control a pad’s pitch, amplitude, sample selection, or other parameters. Gate inputs trigger individual pads directly. The clock input synchronizes the module’s internal transport to your rack’s master clock for Clip mode playback.

A few specific things this enables:

CV-controlled pitch: Assign a CV input to a pad’s pitch parameter and the Bitbox mk2 tracks voltage at 1V/oct. Play the pad from a sequencer, keyboard, or quantizer elsewhere in the rack. One-Shot and Gated modes both respond to pitch CV on the assigned input.

Gate triggering: Every pad has its own dedicated gate input, so a clock divider or trigger sequencer in your rack can drive drum pads directly, without going through MIDI, as if they were ordinary drum modules. This is how the Bitbox mk2 slots into a patch where MIDI isn’t the primary control language.

Sample selection via CV: Assign a CV input to scroll through the samples on a multi-sample pad. Voltage steps through the mapped samples in the folder. Combined with a sample-and-hold or a sequencer outputting stepped voltages, this sequences sample selection with CV rather than MIDI, which opens up things like probabilistic sample switching via noise sources and slew limiters.

Clock sync: The internal transport locks to external clock voltage. Clip mode pads play in sync. If your rack runs a master clock, the Bitbox mk2 follows it. If your rack doesn’t have a master clock, the Bitbox mk2 can generate one.

CV assignments are configured in each pad’s settings panel. Map a modulator to the parameter you want it to drive, and that pad responds to rack voltage directly; pads with no CV assignment stay under MIDI or touchscreen control.

Polyphony budget

The Bitbox mk2 supports up to 24 simultaneous voices loaded in RAM and 8 voices streaming from the microSD card.

The 64 MB of onboard RAM holds samples for direct low-latency playback. Once you exceed 24 simultaneous voices from RAM, additional voices fall back to SD streaming, with a hard limit of 8 concurrent streams. The theoretical ceiling is 32 simultaneous voices total; beyond that, voices will drop.

Most practical use cases stay comfortably inside these limits. A 16-pad drum preset with short one-shot samples is unlikely to approach the 24-voice ceiling under normal conditions. The ceiling becomes a real concern when you’re combining:

  • Long pad sounds in Granular or Gated mode with slow release tails
  • Dense polyphonic parts with many pads held simultaneously
  • Multiple loops in Clip mode running concurrently

If you’re hitting voice ceiling issues in a performance preset, shortening release times, reducing the number of simultaneously active pads, or moving long ambient layers to SD streaming (where they don’t consume RAM) will give you more headroom.

preset.xml structure

Every Bitbox mk2 preset is a folder inside Presets/ containing a preset.xml file. The XML stores the complete state of the preset: all 16 pad configurations, including which sample file or folder is assigned to each pad, the playback mode, envelope parameters, effect settings, and routing.

You won’t normally need to edit preset.xml by hand. The module writes it every time you save. But understanding that the file exists and what it contains explains a few behaviors:

Pads that silently stop playing after you reorganize the card have stale absolute paths in the XML. The file was moved; the XML wasn’t updated. The fix is to reassign the pad to the file’s current location on the device, then save.

Preset sharing works by copying the preset folder. The folder contains the XML and any recordings made on the module. If you haven’t packed the preset first, the audio files it references are elsewhere on your card, and whoever receives the preset folder won’t have those files.

The preset format is shared with the Blackbox and the Bitbox Micro. A packed preset from the Blackbox loads correctly on the Bitbox mk2, and vice versa, because all three use the same preset.xml model with the same path conventions. Packed presets use paths relative to the preset folder, so they resolve correctly wherever the folder lands on the card.

Pack Preset is the command that makes a preset self-contained. On the device, hold the preset name in the browser to access preset options. The module copies all referenced audio files into the preset folder and rewrites the preset.xml paths to point to those local copies. After packing, the preset folder is complete on its own: zip it, copy it, hand it off.

Pack Preset duplicates files rather than moving them. Your originals stay in their source folders; the preset just gets its own copies. If you use the same kick across many presets and pack all of them, you’ll have multiple copies of that file on the card. On a 256 GB card this is rarely a concern, but on smaller cards it’s worth accounting for.

Recording into the module

The Bitbox mk2 records audio from the front-panel audio input directly into the active preset’s folder. Tap the record button on the touchscreen, play your source, and the module saves the result as RC000001.wav in the current preset’s folder. Subsequent recordings increment: RC000002.wav, RC000003.wav.

Presets/
└── DrumKit01/
    ├── preset.xml
    ├── RC000001.wav   ← first recording
    └── RC000002.wav

The recording is automatically assigned to a pad in the current preset after capture. Old takes don’t get overwritten; they accumulate numerically. If you do a lot of in-session recording, the preset folder grows. This doesn’t affect loading or playback, but it’s worth cleaning up before sharing.

Recording into the Bitbox mk2 fits naturally into a modular workflow: run a signal through the rack into the module’s input, capture it, and immediately have it as a sample on a pad. No computer involved.

Format

The Bitbox mk2 accepts WAV at any sample rate, 16/24/32-bit depth, mono or stereo. This is considerably more flexible than most hardware samplers. The Elektron Octatrack MKII accepts only 44.1 kHz, 16 or 24-bit WAV. The Make Noise Morphagene requires 32-bit float, 48 kHz, stereo, with no exceptions. On the Bitbox mk2, format is rarely why a sample doesn’t load.

48 kHz is the preferred sample rate for cleanest internal playback; other rates get resampled on the fly. In practice, most samples from free sample sites and most DAW exports load and sound fine at whatever rate they arrive in.

When format doesn’t matter is a reasonable time to think about consistency: keeping your library at a consistent spec makes it easier to move samples between instruments that are less forgiving. If you’d rather not convert by hand, SampleStack reads WAV, AIFF, and FLAC from your source library, converts to a target spec (48 kHz, 24-bit WAV, for instance), and writes a clean folder you can drop onto the card.

Common gotchas

Pads are silent after reloading. Almost always a path mismatch in preset.xml. The sample was moved or renamed after the preset was built. On the device, tap the affected pad, open the file browser, navigate to the file’s current location, and reassign it. Save the preset.

Preset shared with another user; some pads are empty. Pack Preset wasn’t run before sharing. The preset.xml references paths on your card that don’t exist on theirs. Run Pack Preset on the source device, copy the now-self-contained folder, and share that version.

Multi-sample mapping isn’t what I expected. Files map alphabetically from C2. Check the sort order of filenames in your folder. Mixed case, special characters, and leading numbers vs. letters can sort differently from what you expect. Rename files with numeric prefixes to control the order explicitly.

CV pitch isn’t tracking correctly. The 1V/oct response requires calibration. Access the CV calibration screen in the module’s global settings and run the calibration with a known voltage source, such as a calibrated keyboard output or precision voltage reference, before relying on pitch accuracy for musical parts.

Voices are dropping under load. You’re likely exceeding the 24-voice RAM limit or the 8-voice streaming ceiling. Shorten release times, reduce how many pads are sounding simultaneously, or move long ambient layers to SD streaming mode rather than RAM.

The module isn’t seeing the microSD card. Check that the card is fully seated; the slot needs a firm push to click. Confirm the card is FAT32 or exFAT. NTFS and other formats won’t mount.

Pack Preset ran, but some pads are still empty on the recipient’s device. A pad was pointing to a missing or moved file before packing. Pack Preset copies what it finds at the time it runs; if a pad’s assigned file was already missing, that pad doesn’t get packed. Fix the pad assignment on the source device, then repack.

← Back to News