Early Preview · Kiwisonic, Kiwisynth and Kiwipulse are free during early preview. The shape of all three is still being figured out, and feedback is what drives them forward.

Drum — one machine, every drum

All docs / Kiwipulse / Drum — one machine, every drum

Kiwipulse manual

Drum — one machine, every drum

A drum is something hitting something that rings. A kick is a beater and a membrane, a snare is a stick, a membrane and wires, a conga is a hand and a membrane, a clap is hands and nothing rings at all. Drum is built that way, so it covers all of them:

  HIT ╌╌╌╌╌╌▶ BODY ╌╌╌╌▶ out
   │                      ▲
   └──────────────────────┘   the direct path (bleed)

You do not pick a machine and then hunt for a kick in it. You pick a hit and a body. That is the whole interface, and it is why one machine covers the whole kit.

The two halves

Every drum has an ATTACK (what hits) and a TONE (what rings). Each is chosen from a library of named halves — Beater, 909 tick, Wires, Clap, 808 hat, Sub body, Snare shell, Cymbal, Pluck, FM tom… — and you hear each one as you land on it.

  • Arrows < > step through the underlying types.
  • The menu opens the half library — the named, pre-dialled halves — and plays what you pick.
  • Each half draws its own one-shot beside its name, so you can see the difference before you hear it.

A half is a type plus its settings: 909 tick and Soft mallet are both the beater click type and sound nothing alike. That is why you browse halves rather than types.

Editing is dragging the picture

There are no faders for sound design here. Each half draws itself, and the drawing is the control — the parameters are the curve:

You see You drag It is
The falling pitch curve its start height / its knee how far the pitch drops, and how fast
A dashed **landing line** up and down where the fall ends up (`tune`)
Two **wires** into the sum their thickness the HIT ↔ BODY balance
A **comb** of partials the top partial how far the partials are stretched apart
A **tilt line** (dark ↔ bright) its bright end brightness / colour
A **band** of noise slide it, pinch it where the noise sits and how tight
A **corner** with everything above it filled slide it a high-pass cutoff
**Three ticks** on the time axis the last one the gap between a clap's hands
A **cluster** of partials the first sideband (FM) the modulator ratio
**One cycle of the wave** along it the scan position
A **recorded waveform** its right edge / **click the waveform** how fast it plays / which *direction* it plays
A **pill** naming a choice click it steps to the next one (`white` → `pink` → `metallic`)

Two modifier gestures work on any handle:

  • Alt-drag — pull an LFO open on the parameter you are touching. A translucent capsule shows how far it will sweep, and a bright dot orbits the handle showing the value being heard right now. A small chip appears beside it: click its left half to step the LFO shape (drawn as one cycle of itself), the right half to step its rate.
  • Shift-drag — give the parameter a breathe: a per-hit random spread that re-rolls every pass. It draws as a faint corridor of many rolls behind the crisp live curve, so "one deliberate value" and "living jitter" look different at a glance. Breathe lives on a step, so it needs a firing hit selected.

The hit — ATTACK types

Each type reinterprets the same four controls — the two recorded types add a fifth, which direction the recording plays — and the Bench labels and scales them per type. The param column is the name to aim an LFO, macro or p-lock at.

Silent — an empty slot. There are two hit slots, so you can stack a beater and a click, or noise and a clap.

Beater click

White noise through a tilt filter — the beater/stick tick.

Control Range Param
`colour` 0 … 1 (dark → bright) `exc1_tone`
`length` 0.0005 … 0.5 s `exc1_decay`

Knock

A pitched sine blip with its own fast pitch drop — the beater's body, not its tick.

Control Range Param
`pitch` 40 … 500 Hz `exc1_tone`
`length` 0.0005 … 0.5 s `exc1_decay`
`drop` 0 … 24 semitones `exc1_aux1`
`drop speed` 1 … 4 × `exc1_aux2`

Noise burst

Band-passed noise — snare wires, shakers, bright percussion.

Control Range Param
`centre` 200 … 12000 Hz `exc1_tone`
`length` 0.0005 … 0.5 s `exc1_decay`
`resonance` 0.5 … 10 Q `exc1_aux1`
`snap` 1 … 3 `exc1_aux2`

Recorded hit

A real recorded transient from the project sample pool (64 slots) — a real stick, hand or beater, hitting a synthesized body.

Control Range Param
`colour` 0 … 1 `exc1_tone`
`length` 0.0005 … 0.5 s `exc1_decay`
`hit` pool slot 0 … 63 `exc1_aux1`
`rate` 0.5 … 2 × `exc1_aux2`
`reverse` 0 … 1 (≥ 0.5 = backwards) `exc1_rev`
`length` defaults to the 3 ms beater value, so a hit switched to **Recorded hit** needs its length opened up before much of the recording survives.

The waveform is the control. A recorded half draws the actual recording, and that drawing is what you grab: drag its right edge to set rate (how fast it plays is how wide the shape is), and click the waveform itself to flip reverse. A reversed half draws mirrored left-to-right with its read head running the other way, so the direction is something you see rather than something you remember. The band brightens and names the click when you hover it.

Clap

Three hands, then a room. A burst train through a band-pass: three sharp bursts spread apart, then a tail. All hit and no body — pair it with No body.

Control Range Param
`centre` 500 … 6000 Hz `exc1_tone`
`tail` 0.0005 … 0.5 s `exc1_decay`
`spread` 5 … 40 ms `exc1_aux1`

Hiss

High-passed coloured noise — the hat. colour is the whole character: the metallic comb is what an 808 hat is actually made of, where white is a plain hiss.

Control Range Param
`cutoff` 200 … 18000 Hz `exc1_tone`
`length` 0.0005 … 0.5 s `exc1_decay`
`colour` white / pink / metallic `exc1_aux1`
`resonance` 0.5 … 10 Q `exc1_aux2`
The three noise hits split the filter between them: **Beater click** is low-passed, **Noise burst** band-passed, **Hiss** high-passed. Pick by the shape you want, not by a mode switch.

The body — TONE types

No body — nothing rings; the hit passes straight through. This is what a hat, clap or shaker is, not a workaround.

Sine body

A sine with an exponential pitch drop and an optional flat top. The kick.

Control Range Param
`hold` 0 … 0.05 s `res_tone`
`decay` 0.02 … 4 s `res_decay`
`drop` 0 … 48 semitones `res_aux1`
`drop time` 0.005 … 0.4 s `res_aux2`

Shell

Two detuned partials plus an onset pitch blip — snare and tom shells. The blip is what gives a snare its snap without a second hit.

Control Range Param
`brightness` 0 … 1 `res_tone`
`decay` 0.012 … 2.4 s `res_decay`
`blip` 0 … 1 `res_aux1`
`blip time` 0.005 … 0.15 s `res_aux2`

Five struck partials with per-mode damping: the upper modes die faster than the fundamental. This is why decay alone walks this body from a rim to a mallet to a tom to a gong — a longer decay does not make the same sound longer, it changes which partials survive, so the tail darkens as it lengthens.

Control Range Param
`brightness` 0 … 1 `res_tone`
`decay` 0.02 … 4 s `res_decay`
`inharmonic` 0 … 1 (harmonic → bell) `res_aux1`

Recorded body

A recorded tail from the sample pool. It rings from the trigger and ignores the hit, like any struck body.

Control Range Param
`brightness` 0 … 1 `res_tone`
`decay` 0.02 … 4 s `res_decay`
`body` pool slot 0 … 63 `res_aux1`
`rate` 0.5 … 2 × `res_aux2`
`reverse` 0 … 1 (≥ 0.5 = backwards) `res_rev`
This is the one body that ignores `tune`: a recording arrives with its own pitch. Use `rate` instead to shift it (and p-lock `rate` for a per-hit pitch move).

reverse works the same way it does on a recorded hit — click the waveform to flip it, and the drawing mirrors — but it does something different to your ear. A recorded body is usually a decaying take, so rung backwards it swells: the tail builds into the next hit instead of falling away from this one. That is the reverse-cymbal riser, except it is one body inside one drum rather than a separate audio clip, so it p-locks and it obeys decay.

Metal

Six hard squares at fixed inharmonic ratios through a high-pass — the 808 metal cluster. The squares are the point: five sines cannot get there however they are detuned. shimmer blends in a noise wash, which is what a long crash decays into.

Control Range Param
`brightness` 2000 … 12000 Hz (the high-pass) `res_tone`
`decay` 0.02 … 4 s `res_decay`
`shimmer` 0 … 1 `res_aux1`

String

A tuned delay line — a plucked string. This is the only body with no voice of its own: it rings purely from what is injected into it, so the hit you choose is the pluck. A beater plucks it one way, a recorded stick another.

Control Range Param
`brightness` 0 … 1 `res_tone`
`decay` 0.02 … 4 s `res_decay`

FM

Two operators: a carrier phase-modulated by one modulator. brightness is the modulation index, and bright time is how fast that index falls — a short bright time is what makes FM read as a drum rather than a bell, because the hit starts complex and settles.

Control Range Param
`brightness` 0 … 1 (the index) `res_tone`
`decay` 0.02 … 4 s `res_decay`
`ratio` 0.5 … 12 × `res_aux1`
`bright time` 0.005 … 3 s `res_aux2`

Wavetable

A band-limited wavetable scanned by position, across three banks. Band-limiting is per octave, so the tone holds together under a pitch drop instead of tearing.

Control Range Param
`position` 0 … 1 (scans the bank's 4 waves) `res_tone`
`decay` 0.02 … 4 s `res_decay`
`bank` classic / harmonic / pulse `res_aux1`
`detune` 0 … 1200 cents `res_aux2`

classic runs sine → triangle → saw → square, harmonic dull → bright, pulse sweeps a duty cycle from narrow to 50%. position is a shape scan, not a brightness — in the pulse bank, narrow is the brighter end.

detune adds a second oscillator, a copy of the same wave tuned sharp. It is drawn as a second trace on the waveform: at a few cents the two drift slowly apart and you hear them beat; wound right up they are a visible interval apart and you hear a chord. At 0 there is no second oscillator at all.

This is the control that makes a Reese, a supersaw or an analog stab out of a drum body — scan position to the saw, open detune a little, and put the voice chain's filter across it. The factory kits' Reese and stab voices are exactly that, and because it is an ordinary body they p-lock, take an LFO and answer to a macro like any other half.

Balance, pitch and level

These mean the same thing for every type, so they are not repeated above.

Param Range Default What it does
`bleed` 0 … 1 1 How much of the hit you hear **directly**, alongside the body
`res_tune` 20 … 400 Hz 55 The body's pitch (ignored by **Recorded body**)
`res_level` 0 … 1 0.9 The body's level
`exc1_level` 0 … 1 0 Hit 1's level *within* the hit
`exc2_level` 0 … 1 0 Hit 2's level
`level` 0 … 1 0.9 Output gain

bleed and res_level are the two wires into the sum on the anatomy view — drag their thickness rather than reading a number. The direct path is not a convenience: a beater click reaches your ear directly, not only through the drum, and without it a kick's tick sounds like it is coming from inside the drum.

Pitched: a tuned body rings at its tune, and — like every parameter — that pitch is p-lockable per hit, so one strike can land an octave up. A drum with No body has no pitch to set, which is correct — a hat rings at nothing.

The moat: p-lock the anatomy itself

exc1_type and res_type are ordinary parameters. Everything that works on a parameter works on them:

  • P-lock the hit type per step — step 13 gets a rod instead of a beater, same drum. The bundled demo does exactly this: step 14 of the hat swaps its hit from noise to a beater tick.
  • LFO, macro or randomize the type the same way.

A sample pack needs a second file to do that. Nothing in a DAW can reach inside the instrument at all.

Design recipes

  • Kick — hit Beater click (length ~3 ms), body Sine body at tune ~55 Hz, drop ~28 st, drop time ~50 ms, decay ~0.35, bleed 1.
  • Punch kick — add a second hit: Knock at pitch ~120 Hz with drop speed ~3, over the same sine body. The knock is the beater's mass, the click its surface.
  • 808 subSine body, tune ~45, decay 1.6, a little hold for the flat top.
  • Snare — hit Noise burst (centre ~2 kHz), body Shell at tune ~180, blip up. Here bleed is the tone/noise balance — the single most useful control on the drum.
  • Closed hat — hit Hiss, colour metallic, cutoff ~11 kHz, length ~0.04, body No body.
  • Open hat — the same drum with a longer length. Where nothing rings, the open/closed distinction lives in the hit, so p-lock exc1_decay.
  • Clap — hit Clap, spread ~11 ms, tail ~0.3, body No body. Widen spread for a roomful of people.
  • Crash — a bright short Beater click into Metal, decay 1.6, shimmer ~0.4.
  • Tom and rim — the same Modal body, walked by decay: ~0.40 is a tom, ~0.06 a rim. Try it with decay and nothing else and you will hear the family move, because a shorter decay does not just shorten the sound, it leaves fewer partials alive. (The factory Tom and Rim halves also retune and re-weight — a real rim is higher and more inharmonic than a real tom — so they are not a decay-only pair, even though decay is the axis that carries them.)
  • Plucked — any hit into String, decay 1.5. Swap the hit to change how it is plucked; that is the control a string wants.
  • FM tomBeater click into FM, ratio ~2, bright time short (~0.05) so it starts clangy and settles into a tom.

Notes & limits

  • Two hit slots, one body. Stacking two hits is how a punch kick (knock + click) or a layered snare (wires + clap) is built.
  • bleed never changes the body's level — that is res_level, for every type including String. Turning bleed up adds the bare hit; it does not take anything away.
  • A String with no hit is silent, by construction. If you pick the Pluck half on a drum whose hit is Silent, choose a hit as well — or load the whole Pluck sound, which brings one with it.
  • Some factory sounds include a drive stage (dist_amt, dist_bias, dist_fold, dist_pos) that saturates the body before its envelope, giving a constant timbre across the hit. It is audibly different from the shared chain's drive, which is post-envelope. Its controls are not on the Bench yet, so it can be loaded from a preset and modulated by name, but not dialled directly.

Plus the shared voice chain, which applies on top of any machine.