What format should I export the instrument as?

It depends on where it's going. SFZ is the safe default for broad compatibility, SoundFont 2 is a single portable file, Decent Sampler is best for sharing a finished instrument, Ableton Sampler drops it into Live, and the Disting EX and NT take it to Eurorack hardware. SampleStack builds the instrument once and exports to any of them.

How to sample a synth into a playable instrument

Q: Do I need special hardware to sample a synth?

You need a way to record the synth's audio into your computer: an audio interface for a hardware synth, or just your DAW if the synth is software. Beyond that you need SampleStack to map the recordings into an instrument. There's no dedicated sampling hardware required.

Q: How long should each sampled note be?

Long enough to capture the sound you want to play, including its release tail. For short, plucky sounds a second or two is plenty. For pads and sustained patches, record several seconds so held notes have material to play through, and consider setting a loop so the note can sustain indefinitely.

Q: Should I sample in mono or stereo?

Match the source. If the synth patch has stereo width, movement, or stereo effects you want to keep, sample in stereo. If it's a mono sound, mono is fine and keeps files smaller. All of SampleStack's software export formats preserve stereo samples.

Q: Can I capture velocity or filter movement?

Velocity, yes: record the same note at a few different playing strengths and SampleStack maps them to velocity layers. Ongoing movement like an LFO or a slow filter sweep gets baked into whatever you record, so if you want that motion, record a long enough sample to capture it, or leave it to add back with modulation in the target player.

A synth patch you love is stuck inside the synth. Sampling it turns that patch into an instrument you can play anywhere: in a DAW without the hardware powered up, on stage without carrying the synth, or on a Eurorack module. This walkthrough takes a set of recorded notes and turns them into a playable multisample instrument in SampleStack, then exports it to whatever plays it back.

Multisample support shipped in SampleStack 1.2, so everything here is in the current release.

What you’ll need

The synth, hardware or software, playing the patch you want to capture.
A way to record it. An audio interface for a hardware synth, or your DAW if the synth runs in software.
SampleStack, to map the recordings into an instrument and export it.

That’s the whole rig. The work splits into two halves: recording good source notes, then building the instrument.

Plan what to sample

Before you record anything, decide how much of the keyboard to cover.

How many notes. Each sample gets stretched to cover the notes around it, and the further it stretches, the less natural it sounds. Sampling every note is the most faithful and the most work. Sampling once per octave is quick but stretches each recording too far. A good middle ground is one sample every three semitones (a minor third), which keeps every note within a semitone and a half of something you actually recorded. Sample more densely for exposed, realistic sounds and more sparsely for rough or lo-fi ones.

Velocity layers. If the patch sounds different when played hard versus soft, and most do, plan to record each note at a few strengths: soft, medium, hard. SampleStack maps multiple samples on the same note into velocity ranges, so a light touch and a hard hit use different recordings. If the patch doesn’t change much with velocity, one layer is fine.

Note length. Record long enough to cover how you’ll play the instrument, and always capture the release tail. Plucks and stabs need a second or two. Pads and evolving patches need several seconds, and may want a loop so held notes can sustain indefinitely.

Mono or stereo. Match the source. Keep stereo if the patch has width or movement worth preserving; mono is fine for mono sounds and keeps the files smaller.

Record the notes

Consistency is what makes the next step easy.

Set a clean level and leave it. Record every note at the same gain, peaking healthily but not clipping. Consistent levels mean the instrument plays evenly across the keyboard without you fixing each zone later.
One note per file. Record each pitch as its own file, with a moment of silence before and after so nothing gets clipped.
Capture the whole sound. Let each note ring out through its release. Cutting the tail short is the most common thing people regret.
Name files by pitch. Naming each file with its note (for example C3, D#3, G3) makes the source obvious and gives the pitch detection a clean starting point.

If you’re recording several velocity layers, keep them organized, for instance a filename that includes both the note and the strength, so you can tell them apart when they’re all in one folder.

Trim and clean up

A little cleanup before importing goes a long way:

Trim the leading silence so every note starts at its attack, which keeps timing tight when the instrument is played.
Leave the tail. Trim silence after the release if you like, but don’t cut into the sound’s decay.
Add a short fade at the very end of each file if a recording cuts off abruptly, to avoid a click.
Keep levels matched across the set rather than normalizing each file individually, which would flatten the natural dynamics between notes.

Import and let SampleStack map it

Now the building starts.

Create a new instrument in the sidebar and drop your folder of samples in.
SampleStack detects the pitch of each sample and assigns it a zone across the keyboard automatically. Because you named and recorded cleanly, the notes land where they belong. The more samples you added across the range, the narrower each zone and the more natural the instrument sounds, since every key sits close to something you actually recorded.
Check the map. A visualization shows which sample covers which part of the keyboard. Nudge any zone boundary or root note that the auto-detection didn’t get exactly right.

If a sample lands on the wrong note, it’s usually because its pitch is ambiguous (a noisy or inharmonic sound). Re-checking those few by hand is quick.

Stack velocity layers

If you recorded multiple strengths per note, SampleStack assigns them to velocity ranges so playing softly triggers the soft recording and playing hard triggers the hard one. You can adjust where the ranges split to taste, moving the crossover point until the transition between layers feels natural as you play harder.

Shape the amp envelope

Set the instrument’s amp envelope with the ADSR controls. You have two choices here:

Match the synth. If you sampled short notes and want the instrument to behave like the original patch, dial the envelope to match how the synth responded.
Reshape it. Because the envelope is applied on playback, you can give the sampled instrument a different shape than the source, for instance a slow attack on a patch you recorded as a quick pluck.

Preview the envelope as you set it so you can hear the attack and release land.

Preview before you export

Play the instrument over MIDI, your computer keyboard, or the mouse. Preview is polyphonic with 16 voices, so you can play chords and hear how held notes and releases overlap, and there’s a virtual pitch bend wheel to check bends. This is the moment to catch anything off: a zone that jumps in timbre, a velocity split that feels wrong, an envelope that’s too fast. Fix it here rather than after export.

Export the instrument

When it plays the way you want, export it. SampleStack builds the instrument once and writes it to whatever format you need:

SFZ for broad compatibility and no lock-in.
SoundFont 2 for a single self-contained file.
Decent Sampler for a finished instrument with artwork and controls, on a free player.
Ableton Sampler to drop it straight into Live.
Disting EX and NT to play it from a Eurorack rack.

A built-in matrix shows exactly what each format keeps before you export, so you can confirm your velocity layers, envelope, and loops survive the trip. See the full comparison if you’re deciding.

Tips

Sample more than you think you need. Extra notes across the range are the single biggest thing that makes a sampled synth sound natural instead of stretched.
Record the tail every time. You can always trim a long recording later. You can’t add back a release you didn’t capture.
Keep levels consistent across the set. It saves you balancing every zone by hand and preserves the real dynamics between notes.
Export more than one format. The same instrument can be an SFZ for general use, a Decent Sampler preset to share, and a Disting card for the rack. Building it once and exporting several times costs nothing.

FAQ

How many notes should I sample from a synth? A common approach is one sample every three semitones (a minor third). Every two to four semitones is the usual sweet spot, and more samples always sound better than fewer.

Do I need special hardware to sample a synth? Just a way to record the synth’s audio (an audio interface for hardware, or your DAW for software) and SampleStack to map it. No dedicated sampling hardware.

How long should each sampled note be? Long enough to capture the sound and its release tail. A second or two for plucks; several seconds for pads, with a loop if you want indefinite sustain.

Should I sample in mono or stereo? Match the source. Keep stereo for wide or moving patches; mono is fine for mono sounds. SampleStack’s software formats preserve stereo.

Can I capture velocity or filter movement? Velocity yes, by recording a few strengths per note. Ongoing movement is baked into what you record, so record long enough to capture it or add it back with modulation in the player.

What format should I export as? It depends on the destination: SFZ for compatibility, SoundFont 2 for one file, Decent Sampler to share, Ableton Sampler for Live, Disting for Eurorack. SampleStack exports to any of them from one instrument.