Guru Sampler was purpose-built to support the PlugInGuru approach to sound-design, and as a result, it has several important limitations when compared with expensive, mature third-party sampler plug-ins such as Kontakt 6 by Native Instruments, or Falcon 2 by UVI.

To understand how best to use Guru Sampler, it's important to understand its limitations, and how it differs from more sophisticated sampler plug-ins.

The key limitations of Guru Sampler are:

1. No support for streaming: All samples are loaded entirely into RAM.
2. No round-robins: Multiple samples assigned to the same MIDI notes are selected randomly, not systematically.
3. No independent control of playback speed.
4. Limited support for importing your own samples.

The first limitation is by far the most important. Guru Sampler is ONLY useful for sample-sets whose total size is smaller than about 1 Gigabyte, and preferably much smaller. This typically means at most a few dozen samples mapped across the playable range of the keyboard.

Any sampler works by playing back samples, which are audio files on disk, in response to MIDI events. A separate sample-map file defines which sample(s) should be played for each note. Think of the sample-map as a table of sample files, indexed by MIDI note-numbers. When a sampler receives a MIDI note-on event, it looks up which sample to use for that note, and plays back the sample, usually adjusting the volume according to MIDI key-velocity.

It is not strictly necessary to have a separate sample file for every distinct MIDI note. For some kinds of sounds, even a single sample, mapped across the entire MIDI range, can yield musically-useful results, but between one and four samples per octave is usually enough. The sample-map must therefore contain information about each sample's “natural pitch” (how it sounds when played back at the same speed as it was recorded), and the sampler must be able to adjust the pitch in some way, to match what is expected for the note played.

However, playing back the same sample every time a note is played tends to be musically unsatisfactory, so a sampler should ideally be able to handle maps in which multiple, similar samples are mapped to each note (or group of adjacent notes), and offer ways to control which is chosen for each note-event. Options include:

• Velocity switching: High key velocities trigger different samples than lower velocities.
• Articulation switching: The user may be able to select one of several sample-sets dynamically.
• Round robin: The sampler may cycle through several samples mapped to a given note (or note-group).
• Random select: The sampler may randomly choose one of several samples mapped to a note (or note-group).
• Various combinations of the above.

All of these considerations (and many others, such as how individual samples are looped) affect the design choices made for any given sampler, resulting in a balance of advantages and limitations.

The preceding section said “when a sampler receives a MIDI note-on event, it looks up which sample to use for that note, and plays back the sample.”

A very simple sampler could be made based entirely on this simple description. The sample-map (which is typically quite small) could be read entirely into RAM memory, making the look-up process very quick. Actually playing a note would require opening the appropriate sample file and reading its contents, perhaps one small chunk at a time—a process called streaming.

Such a “pure streaming” sampler would be able to work with even gigantic sample-sets, but would not be able to begin playback instantly, every time. Opening and reading disk files takes time, and the time required can vary tremendously. High-end samplers address this problem by pre-loading the initial (attack) chunks of every sample file into memory, which makes them very complicated.

Guru Sampler takes the opposite approach, and simply pre-loads every sample entirely into RAM—it does not do streaming at all. This allows it to be simple and highly responsive, but imposes strict limitations on the number and length of samples in each map. On modern computers, sample-sets in the 1 to 2 Gigabyte range are manageable.

Guru Sampler does allow more than one sample to be mapped to the same note-group, and chooses randomly among them for each note-event. This is partly to avoid the complexity of implementing “round-robins”, but mostly because the need for all samples to be fully loaded into RAM means this multi-sample approach should be used very sparingly.

Guru Sampler uses the simplest possible technique to adjust the playback-pitch of samples—changing the speed of playback. This works well when the difference between a sample's natural pitch (the pitch of the note as it was recorded) and the playback pitch is small, but can result in an unnatural sound when it is large. The effects are more noticeable for some sounds (e.g. human voice) than others (e.g. simple synth waveforms).

All of the above considerations mean that sample-maps need to contain quite a bit of information, so preparing them is fundamentally complicated. Mature sampler products like Kontakt include powerful interactive software tools for creating sample maps. We have only recently introduced the [sample-mapper|SampleMapper utility]], a simple but useful tool for this purpose.

Sample-map files must also be encoded into a representation suitable for quick reconstruction of the in-memory sample map. Unify uses a simplified variant of the SFZ format for this purpose, described in detail in Manual creation of SFZ files for Guru Sampler.

Note we do NOT provide any tools to assist with important sample-preparation steps such as looping.

If all you want is a SoundFont player, get Sforzando by Plogue Art et Technologie. It's excellent, and FREE for both Mac and Windows.

Another excellent choice is Zampler/RX, which is also free for both Mac and Windows, but is not as compatible with random SFZ files as Sforzando.

For larger sample-sets requiring streaming, round-robins, etc., it's hard to beat Decent Sampler, which is free AND supports importing user samples using a custom XML-based text-file format instead of SFZ.