Thump One Manual

Thump One is an easy to use music synthesiser plugin with a fun glitchy 'wavetable' engine and a bank of flexible multi-segment envelopes to shape the sound in any direction you desire. Perfect for powerful kick drums, huge club basses and soaring leads

The synth has two engines that can be layered together for a range of complex sounds and textures. The Kick engine is a great sounding wavetable oscillator built from clean and processed analog kick drums, with saturation, filtering and a buzzy 'broken speaker cone' circuit. The Layer engine is an accurate model of the 'supersaw' oscillator from the Roland JP-8000, with a set of modes for retro synth tones, glitches and noise.

Along the bottom of the GUI is the Utility Strip, a fun, expressive playground for jamming with phrases and riffs, combining and reshaping them into new ideas: drop an arpeggiator or note-repeat onto a key and play patterns from a single note, stack up snapshots and flip between sound variations live for round-robin drums, or patch a slow LFO onto any knob so the sound evolves as you play.

Contents

Version 3 Update

Version 3 adds the Utility Strip, a workspace for building your own MIDI setups from a huge library of triggers and panels, and Snapshots, which store complete variations of a sound inside a preset and morph smoothly from one to the next. There's also the Node Editor, a patching workspace where you can wire up your own audio and modulation setups and edit the Utility Strip's Panels and Triggers yourself. The envelopes gain lasso node selection, a right-click menu and a preset menu of their own.

New in Version 3

  • The Utility Strip — a modular workspace for building your own MIDI and modulation setups from a large factory library of Triggers and Panels: arpeggiators, note repeaters, chord generators, LFOs, CC mappers, snapshot switchers and lots more
  • The Node Editor — a patching workspace with a rack of audio rate modules to patch around the synth engine, a place to build and edit your own Utility Strip Panels and Triggers
  • Snapshots — complete variations of a sound stored inside a single preset, with smooth morphing between them and up to 64 slots
  • Per-note expressions — every note carries its own modulation, driven from your controller or from the Utility Strip
  • New envelope editing modes — Smart, Lines and Steps modes, grid snapping and lasso selection, a right-click editing menu and per-envelope presets
  • General GUI improvements and bug fixes

 

Tooltips and Controls

Every control in Thump One has a tooltip explaining what it does. With tooltips enabled, hovering the mouse over any knob, button or menu shows a small pop-up describing that control. Turn tooltips on or off with 'Show Tooltips' in the Settings menu (the icon with three vertical lines at the top right of the GUI).

  • Hold Shift while dragging a knob for fine adjustment.
  • Hold Control while dragging to snap wide-range knobs (like Pitch) to whole numbers.
  • Double-click a knob's value, its label or the area just below it, to type in an exact value.
  • Where a control offers a list of options (like the Layer engine's Mode), the ‹ › arrows step through the choices one at a time.

The window size is set from 'Set Size' in the Settings menu, and 'Set Current Size As Default' remembers your choice for new instances.

Kick Engine

The Kick engine is built around a wavetable oscillator with a separate Buzz oscillator that simulates a torn speaker cone. The two are mixed together, run through an analog Drive stage and then a high quality low-pass filter.

Its five main knobs (the top row) are:

  • Punch — the amount of pitch modulation from the envelope assigned to this control.
  • Wavetable Position — the playback position within the Kick oscillator's wavetable.
  • Drive — the amount of analog saturation. This affects both engines.
  • Buzz — adds a buzzy, grinding sound on top of the kick.
  • Level — the volume of the Kick engine.

Directly below each main knob is its tweak knob, each marked with an icon:

  • Pitch — the pitch of the Kick engine.
  • Select Wavetable — chooses the wavetable for the Kick oscillator. These are derived from recordings of real analog kick drums run through tape, tube and other processing.
  • Drive Filter — the amount of filtering in the Drive stage. This affects both engines.
  • Buzz Tone — the tone of the buzz sound.
  • FM — modulates the Kick oscillator's frequency with a second oscillator for a richer, more complex tone.

The power button to the left of the engine (Bypass Kick) switches the Kick engine off.

Layer Engine

The Layer engine adds two 'supersaw' oscillators, modelled on the supersaw of the Roland JP-8000. Their output is mixed together and fed into the Kick engine's Drive stage, so the two engines share the same saturation and filtering.

Its three main knobs are:

  • Detune — spreads the supersaw voices apart. In Noise mode this sets the amount of static instead, and in FM mode it sets the amount of feedback in the FM algorithm.
  • Filter — the filter amount for the Layer engine.
  • Level — the volume of the Layer engine.

Mode selects one of twelve modes for the Layer engine. The first ten adjust the intervals between the two supersaw notes and add varying amounts of internal FM modulation from the Kick engine, for extra tone and dirt. The last two are Noise, a simple noise oscillator with a static control, and FM, an FM oscillator with feedback whose frequency is modulated by the output of the Kick engine. In FM mode you can bypass the Kick engine to hear only the modulated FM tone.

The power button to the right of the engine (Bypass Layer) switches the Layer engine off.

Global Section

The Global Section is the row of controls across the top of the front panel. These affect the whole instrument rather than one engine:

  • Master Volume — the overall output level (this slider is in the title bar, next to the preset name).
  • Master Pitch — shifts the pitch of the entire sound, moving both engines together.
  • Attack and Release — set the playback speed of the envelopes (see the Envelopes section).
  • Glide — slides notes smoothly from one pitch to the next instead of jumping.
  • Stereo Width — widens the stereo image by subtly chorusing and detuning the left and right channels. Whether the Kick engine is included is set by Stereo Kick Engine in the Options Panel.

Around the Global Section are the plugin's main buttons: the cog (top left) opens the Options Panel, the keyboard icon (top right) shows or hides the Utility Strip, and the dice next to the THUMP ONE logo re-applies the last randomisation you used. The preset arrows, undo/redo and the Settings menu (three vertical lines) are in the title bar.

Envelopes

Thump One has eight multi-segment envelopes (MSEGs), one for each of the eight main knobs across the Kick and Layer engines. Instead of a fixed attack/decay shape, each envelope is a curve you draw yourself from as many segments as you like, so you can shape exactly how its control moves over the course of each note. All eight run at once and are re-triggered by every note, and a small white dot travels along the displayed curve to show the current playback position.

The large display shows one envelope at a time. Click the small triangular button above a knob to show that knob's envelope. Edit the shape straight on the display: double-click to add or delete a node, drag a node to move it, lasso a group to move several at once, and right-click for editing actions like copy, paste, flip and reverse.

The speed of the envelopes is set by the Attack and Release knobs in the Global Section, Attack covering the first 20% of the envelope's path and Release the remaining 80%. Playback isn't linear along the curve, it runs faster at the start and slows towards the end, so you get fine control over the important initial transient while the tail plays out more gradually.

Tip: hold Shift or Control while dragging to snap the nodes to a horizontal or vertical grid.

Envelope Preset Menu

Each envelope has its own preset menu, opened from the small triangle at the bottom left of the envelope display. In addition to the Preset Menu, right-clicking anywhere on the envelope itself opens its Edit Menu. This menu contains specific editing commands, has options to set the vertical and horizontal grid and allows you to select the envelope's Editing Mode (see below). You can also long-press the envelope background to open the menu without right-clicking.

The Edit menu also has a Draw mode which allows you to use the mouse to draw in an envelope curve, Draw mode can also be accessed by holding shift while dragging.

Record mode is similar to Draw mode except the envelope shape is drawn at the current playback position while the mouse button is pressed.

Editing Modes

The 'Mode' submenu in the editor's right-click menu sets how the envelope draws the path between its nodes:

  • Smart: a smooth curve flowing through every node, good for organic shapes and sine-like LFOs
  • Lines: straight lines between the nodes. Drag anywhere on a line to bend it into a curve, from sharp exponential attacks to slow logarithmic tails. With several nodes selected the drag bends all of them together, and holding Command (Ctrl on Windows) mirrors the bend across rising and falling segments
  • Steps: each node holds its value until the next one, for instant jumps, sample-and-hold and rhythmic gating.

The Utility Strip

The Utility Strip is a modular workspace along the bottom of the plugin where you build your own MIDI setups, arpeggiators, note repeaters, chord generators, LFOs, randomisers, CC mappers, snapshot switchers and lots more, by loading small self-contained modules from a big factory library. None of it changes the Thump One sound engine itself, instead it shapes and generates the MIDI going into the engine, so a single preset can play back patterns, respond to your controller in custom ways, or morph between sounds, all without programming a note in your DAW.

Click the keyboard icon in the top right corner of the plugin to show or hide the Utility Strip. It has two views, the Keyboard View, which shows the on-screen keyboard and holds the MIDI Triggers, and the Panels View, which holds the Panels. Switch between them with the small round button near the top right corner of the Strip.

Two libraries, three kinds of module

Modules load from two factory libraries, the Trigger library (via Add Trigger in the Keyboard View) and the Panel library (via Add Panel in the Panels View). Depending on what it does, a module can appear in one view, the other, or both:

  • Panel only — no on-keyboard trigger, just a Panel in the Panels View. Things like Simple Delay or CC Mapper, which run continuously and don't need launching from a key.
  • Trigger only — a Trigger on the keyboard with no Panel, like Undo, which is just an action bound to a key.
  • Both — a Trigger on the keyboard and a Panel in the Panels View, linked together. A lot of the pattern modules work this way, the Panel holds the controls while the Trigger starts and stops it.

When a module has both parts they're treated as one unit, so colouring, deleting or saving either part affects the whole group. Everything you load is saved with the preset, and you can also save the whole setup on its own as a Strip Preset (see below).

How modules connect

Modules pass four kinds of signal, notes, CC, parameters and per-note expressions, and they each travel differently. Notes and CC both flow through the Panels left to right, in the order the Panels sit in the chain, so where you place a module matters, a Transpose before an Arpeggiator isn't the same thing as one after it. Parameters don't run along the chain at all, instead you drag a connection straight from a module's output onto any control you like, a KNOB on another Panel or a knob on the main plugin, and the order of the Panels makes no difference.

That gives you three ways to wire a setup together. The CC path is the simple one, drop your modules in and CC passes from one to the next down the chain, then out to the engine through a mod wheel or CC assignment on the plugin, reach for it when you want the tightest timing or a straightforward in-order chain. The parameter path is the free one, drag from a source like a Parameter LFO onto a KNOB, or onto any control on the main plugin, and they're connected wherever the Panels happen to sit, reach for it when you want to patch things together freely or modulate a control the CC path can't get to. The expression path is the polyphonic one. Where CC and parameters move one value for the whole plugin, an expression is carried by each individual note, so every note gets its own modulation and the notes moving at the same time can all be doing something different.

Toybox plugins with sequencers let you draw expressions onto the notes by hand in the piano roll. Thump One has no sequencer, but the sound engine handles per-note expressions just the same, so the Expression Panels work here exactly as they do in the other plugins, giving each note its own movement whether it comes from your controller or from elsewhere in the Strip.

A panel's name tells you which path it works on. Panels starting with CC feed the CC chain, panels starting with Parameter drive a parameter, and panels starting with Expression write a per-note expression, so CC LFO, Parameter LFO and Expression LFO are the same modulator sending its output three different ways. Panels with 'To' in the middle convert between them: CC To Parameter turns an incoming CC into knob movement, Knob To CC does the reverse. Panels starting with Knob reshape a knob you're already driving on its way to its destination, scaling, clipping, quantising or smoothing it. The Sweeps And Strums panels convert a single continuous control into notes, so a CC sweep or a knob move plays a strum, a gliss or a scale run.

Panels that control a parameter or an expression have a menu to choose what they control, and a target icon next to it. Pick a destination from the menu, or drag the target icon onto the control you want. A Parameter Panel can control any knob or control on the plugin. An Expression Panel can only control a small set of them, so as you drag, only the ones it can control are highlighted.

A Parameter Panel moves the actual knob, so the movement is picked up as automation by your host and stored in presets and Snapshots. An Expression Panel leaves the knobs alone.

Combining More Than One Parameter Source

The parameter path connects a source straight to its destination, so pointing two Parameter Panels at the same control makes them fight over it. To drive one control from more than one source, combine them first with the 'Knob Mixer' module.

Panels View

Each Panel is a single module of MIDI processing, an Arpeggiator, a CC LFO, a Transpose and so on.

Click an empty area of the Panels View, or a Panel's drag bar, to open the panel menu and choose Add Panel. The submenu follows the folder structure of the library (Input, MIDI CCs, MIDI Note Effects, Modulation (CC), Modulation (Expression), Modulation (Parameter), Patterns And Sequences, Routing, Templates, Utilities), and new Panels are given a distinct colour automatically. Panels are laid out left to right in the order they process MIDI, so moving one changes where it sits in the chain, placing a Transpose before or after an Arpeggiator gives very different results. To reorder a Panel, drag its drag bar.

Clicking a Panel's drag bar (or right-clicking it) opens its menu, where you can reset, rename, delete, recolour and add Panels, and pick a preset if the Panel ships with any. Presets can also be cycled by holding Ctrl and clicking the drag bar (add Shift to go backwards), and holding Alt (Option) as you open the menu reveals a hidden Save As… item, which saves the Panel to the library for next time.

Keyboard View — MIDI Triggers

A Trigger is a module bound to a range of keys, play any note in that range and it fires. Triggers cover everything from musical tools like Arpeggiators, Chords and Strum to instant commands like Randomize Preset, Bypass Kick and snapshot selection.

The top strip of the keyboard is the edit zone, where you place and manage Triggers. The rest of each key still plays notes as normal so you can audition sounds while you work, and each Trigger shows up in the edit zone as a coloured, labelled region spanning the keys it responds to.

Click a key in the edit zone (or right-click any key) to open the Trigger menu and choose Add Trigger, whose submenu follows the folder structure of the Trigger library. The key you click becomes the start of the Trigger's range. Once it's placed, drag the body of the region to move it, or either edge to resize the range. The same menu lets you cut, copy, paste, rename, delete and recolour Triggers, and (holding Alt) save them to the library.

Position (Before and After Triggers, or After Sequencers)

Every Panel has a Position, set from the 'Position' submenu in the Panel's menu (click or right-click its drag bar). Where the chain order decides which Panel processes the MIDI first, the Position decides which of three stages it runs in:

  • Before Triggers: the Panel runs before the MIDI Triggers see anything, so the notes it plays can fire Triggers on the keyboard, exactly as if you'd played them yourself
  • After Triggers: the default. The notes the Panel plays reach the sound engines but don't fire Triggers
  • After Sequencers: the Panel runs last, after the sequencers have added their notes, so it can work on those too

Most Panels work wherever you put them, so you'll rarely need to change this. The exception is the panels in the MIDI Triggers folder, which listen for MIDI arriving at the plugin: to drive one of those from another Panel's output instead, set that Panel's Position to 'Before Triggers' so its output reaches the trigger stage.

The Position submenu also has three 'All' items that move every Panel to the chosen stage in one go. The setting stays active, so newly added Panels land in that stage too, though you can still move individual Panels to a different position. Click the ticked 'All' item to switch the mode off, leaving the Panels where they are.

Thump One has no built-in sequencers; instead you add full MIDI sequencers to the Strip as Panels, and they work the same way.

Strip Preset

Everything you've loaded into the Utility Strip, every Panel and every Trigger, can be saved and recalled together as a Strip Preset, so you can build a favourite setup once and drop it onto any plugin preset. The Strips menu is the small downward triangle just above the Utility Strip on the left. It works like the main preset menu, with the usual copy, load and save options plus an Enable item that turns the whole Strip on or off. A Strip is always saved with the preset, but loading an older preset that doesn't contain one leaves your current setup in place, while loading a preset that was saved with a Strip swaps that Strip in.

Snapshots

Snapshots let you store several complete variations of a sound inside a single preset and switch between them instantly, or morph smoothly from one to the next. They're great for keeping a handful of variations of a kick and flipping between them as you play, or for setting up a 'clean' and a 'dirty' version of a bass a key apart.

A Snapshot stores the whole sound: every parameter and every envelope shape.

Creating and recalling Snapshots

Snapshots are managed from the Snapshots submenu in the main Preset menu (opened by clicking the preset name in the middle of the top bar). They work as live variations rather than as separate 'save' and 'recall' steps: select an empty slot and nothing changes, the sound carries on as it was, but as soon as you start turning knobs that slot captures the current sound and stores any further changes you make. Once a slot has something in it, selecting it recalls those settings. The preset name briefly flashes the Snapshot number as you switch, with a dot (•) next to slots that contain a Snapshot.

The first eight slots have keyboard shortcuts, ⌘1 to ⌘8 on macOS (Ctrl 1 to Ctrl 8 on Windows), and you can also step through Snapshots by holding Option (Alt) while clicking the preset ‹ › arrows. The submenu also has functions to set the maximum number of slots (up to 64), set the morph speed, and clear the current or all Snapshots.

Morphing

Set Morph Speed to anything other than Off and switching Snapshots no longer jumps, the sound slides smoothly from wherever it is to the target Snapshot over the time you set. Both the parameters and the envelope shapes are morphed together, so the knobs sweep and the envelope curves reshape in one continuous move. Short times just take the edge off an abrupt switch, longer ones turn a Snapshot change into a slow evolving transition, great for pads, risers and builds.

Selecting Snapshots over MIDI

Snapshots can be driven from the Utility Strip in several ways, from your controller or from inside a preset:

  • The Snapshot key range — a range of eight keys on the keyboard that select Snapshots 1 to 8 as you play them. This is loaded by default when you open the plugin, so it works straight away.
  • Snapshot Triggers from the Trigger library, like Next Snapshot, Select Snapshot and Set Morph Speed, assigned to keys of your choice. For example, store five or six variations of a sound and put a Next Snapshot trigger on a key to cycle round them for a 'round-robin' effect as you play.
  • Snapshot Panels from the Panel library, like CC To Snapshot, Knob To Snapshot and CC To Morph Speed. Since these are full MIDI modules you can feed them from other Panels too: connect a slow LFO to Knob To Snapshot to have the sound drift around your Snapshots by itself, or drive CC To Morph Speed from an LFO or envelope so the morph time changes as the track moves.

Preset Manager

The current preset is shown at the top of the GUI. Click the preset name to open the Preset menu, which holds the list of presets (organised into submenus matching the folders on disk) along with the usual save, load and management commands, the randomisation tools, and the Snapshots submenu (see the Snapshots section). The ‹ › arrows either side of the preset name step through presets one at a time, or through Snapshots if you hold Option (Alt).

Randomize Preset completely randomises all parameters of the current preset (the envelope nodes aren't randomised), and Mutate Preset adjusts them by a small amount for a subtle variation. The dice icon next to the THUMP ONE logo repeats whichever you used last, hold Control while clicking it to include the envelope nodes for more extreme results, or Shift to always mutate.

One item worth pointing out is Clear GUI Patches, which strips any custom GUI overrides stored with the preset, an advanced feature for anyone editing the GUI layout.

MIDI Learn

You can assign incoming MIDI CC (Continuous Controller) messages to any of the instrument's knobs by drag and drop:

  1. Enable MIDI Learn mode from the Settings menu.
  2. Turn a knob on your MIDI controller.
  3. Drag and drop the CC number that appears in the top section of the GUI onto any knob to make the assignment.

MIDI CC assignments are saved automatically for all instances of the plugin, and you can clear them with 'Reset MIDI Learn' in the Settings menu.

Settings Menu

The Settings menu (the icon with three vertical lines at the top right of the GUI) covers MIDI Learn and Reset MIDI Learn (see the MIDI Learn section), Enable OSC for Open Sound Control, the GUI Set Size options, Set Current Size As Default and Show Tooltips, plus Open Manual and Go To Website links.

Options Panel

The Options Panel is opened with the cog icon at the top left of the GUI. It holds some extra parameters and sound settings:

  • MIDI Resets Oscillators — incoming MIDI notes reset the phase of the oscillators.
  • Stereo Kick Engine — includes the Kick engine in the Stereo Width control (with it off, the Kick always stays mono).
  • Legato — when playing monophonically, overlapping notes don't re-trigger the envelopes, so notes glide smoothly between pitches. Its Slide setting limits Glide to overlapping notes.
  • Velocity Modulation Destination — a destination to modulate from note velocity, with a Velocity Depth knob for the amount.
  • Smooth Level — a little smoothing on the Level envelopes to remove clicks at the start of the sound.

It also has Velocity To Volume, Parameter Smoothing and Pitchbend Range controls.

iPad Version

The iPad version is identical to the desktop version, apart from how presets are handled and one extra setting: Dynamic Knobs in the iOS Settings menu, which gives a finer adjustment when you move a finger slowly across a knob, the touch equivalent of holding Shift on the desktop.

On the iPad, presets live in a sandboxed folder shared between the standalone app and the AUv3 plugin, which you can't reach through the Files app. So that you can still share and back them up, the app automatically copies every new preset into a folder you can reach at "On My iPad/Thump One/Exported Presets", backing up on each launch of the standalone app. You can import zip folders of presets with 'Import Zip File...', and save into subfolders by typing a folder name and a slash before the preset name, for example "My Kicks/My Big Kick".

Appendix 1: Utility Strip Panels and Triggers

The Utility Strip module library consists of both 'Panels' (loaded into the Panels View) and 'Triggers' (loaded onto keys or ranges of keys on the keyboard to trigger actions, patterns etc).

Panel Library

Panels are the Strip's processing modules, generating and shaping the notes, CCs, parameters and expressions passing through it.

Input

On-screen controls you can assign to anything, knobs, sliders, buttons, pads and keyboards, plus a follower that tracks the plugin's own internal signals.

  • Button (Momentary): A simple button to assign to controls and parameters, on only while it's held
  • Button (Toggle): A simple button to assign to controls and parameters, latching on and off with each click
  • Drumpad: A simple on-screen MIDI drumpad
  • Follower: Follows an internal signal of the plugin, smooths it with Attack and Decay, and sends it to a parameter or control
  • Keyboard: A handy on-screen keyboard
  • Macro Knob: Drives a parameter or control from a single macro knob
  • Slider: A slider to assign to controls and parameters
  • X-Y Pad: Drives up to three parameters from a single X-Y pad

MIDI CC And Pitchbend

Panels that generate, remap or reshape MIDI CC and pitchbend messages, for driving the plugin's knobs or anything mapped to a CC.

  • Bar Position To CC: Sweeps a MIDI CC across a set number of bars, synced to the host
  • CC Arp: Arpeggiates held notes, with an incoming MIDI CC setting the arp speed
  • CC Mapper: Reshapes an incoming MIDI CC's response curve and remaps its channel
  • CC Note Repeat: Repeats held notes, with an incoming MIDI CC switching it on and setting the repeat rate
  • CC Smoother: Smooths a jumpy MIDI CC into gliding values
  • CC To CC: Remaps one MIDI CC number to another
  • CC To Expression: Routes an incoming MIDI CC to a per-note expression
  • CC To Morph Speed: Sets the snapshot morph speed from an incoming MIDI CC
  • CC To Parameter: Maps an incoming MIDI CC to a synth parameter or control
  • CC To Parameter (Ranged): Maps a MIDI CC to a synth parameter with adjustable input range and depth
  • Follower To CC: Follows an internal signal of the plugin, smooths it with Attack and Decay, and sends it out as a MIDI CC
  • Knob To CC: Sends MIDI CC messages from a knob
  • Knob To CC (No Snapshots): Sends MIDI CC messages from a knob, the knob's position is not recorded in the snapshots
  • Knob To Pitchbend: Sends MIDI pitchbend messages from a knob
  • Mod Wheel Mapper: Reshapes the mod wheel's response across low, mid and high
  • Mod Wheel Vibrato: Adds pitch vibrato with the depth set by the mod wheel
  • Modwheel To 3 Parameters: Drives three synth parameters or controls at once from the mod wheel
  • Velocity Tremolo: Wobbles note velocity up and down with a host-synced LFO for a tremolo effect

MIDI Note Effects

Panels that transform the note stream itself: transposing, delaying, humanising and randomising the notes passing through.

  • Fixed Note: Forces every incoming note to a single fixed pitch
  • Humanize: Adds subtle random timing and velocity variation for a more natural feel
  • Multi-tap Delay: Echoes each note through three taps with independent timing and velocity
  • Multi-tap Delay Advanced: Echoes each note through three taps with per-tap timing, velocity and transpose
  • Random Note Walk: Drifts the pitch of incoming MIDI notes up and down with a random walk within a range
  • Random Velocity Walk: Drifts the velocity of incoming MIDI notes up and down with a random walk within a range
  • Randomize Note: Randomly offsets each incoming MIDI note's pitch by an adjustable amount
  • Randomize Velocity: Randomly offsets each incoming MIDI note's velocity by an adjustable amount
  • Scale: Snaps incoming MIDI notes to a chosen key and scale
  • Simple Delay: Echoes each note once at a set delay time, synchronized to the host
  • Transpose: Transposes MIDI notes by a specific amount
  • Transpose Octave: Transposes MIDI notes up or down in octaves

MIDI Triggers

Panels built on MIDI Triggers, so they respond to MIDI arriving at the plugin. To drive one from another panel's output instead, set that panel's Position to 'Before Triggers' so its output reaches the trigger stage.

  • CC To Command: Fires a chosen command from an incoming MIDI CC
  • CC To Snapshot: Uses an incoming MIDI CC to select the current snapshot
  • Velocity To Snapshot: Selects a snapshot from how hard each note is played

Modulation (MIDI CC)

Modulation sources that send their output down the chain as a MIDI CC.

  • CC Custom Envelope: Shapes a hand-drawn envelope and sends it out as a MIDI CC
  • CC Custom LFO: Sends a hand-drawn LFO shape out as a MIDI CC
  • CC Envelope: Sends an ADSR envelope out as a MIDI CC on each note
  • CC LFO: Sends a free-running or synced LFO out as a MIDI CC
  • CC Random Walk: Drifts a MIDI CC up and down with a random walk between set limits
  • CC Randomize: Sends a fresh random value out as a MIDI CC on each note
  • CC Stepper: Steps a MIDI CC through evenly spaced values, with optional ping-pong
  • Pitchbend Custom Envelope: Shapes a hand-drawn envelope and sends it out as pitchbend
  • Pitchbend Custom LFO: Sends a hand-drawn LFO shape out as pitchbend

Modulation (Expression)

Modulation sources that write to a per-note expression, so every note carries its own movement.

  • Expression Custom Envelope: Shapes a hand-drawn envelope and routes it to a per-note expression
  • Expression Custom LFO: Routes a hand-drawn LFO shape to a per-note expression
  • Expression Custom Shaper: Shapes incoming per-note expression values through a hand-drawn curve
  • Expression Envelope: Routes an ADSR envelope to a per-note expression on each note
  • Expression LFO: Modulates a per-note expression with a free-running or synced LFO
  • Expression Random Walk: Drifts a per-note expression with a random walk on each incoming MIDI note
  • Expression Randomize: Sets a fresh random per-note expression value on each incoming MIDI note
  • Expression Stepper: Each incoming MIDI note steps a per-note expression through evenly spaced values

Modulation (Parameter)

Modulation sources that drive a parameter or control directly, wherever the panel sits in the chain.

  • Parameter Custom Envelope: Shapes a hand-drawn envelope and routes it to a parameter or control
  • Parameter Custom LFO: Routes a hand-drawn LFO shape to a parameter or control
  • Parameter Custom Shaper: Shapes a knob through a hand-drawn curve before it reaches a parameter or control
  • Parameter Envelope: Routes an ADSR envelope to a parameter or control on each note
  • Parameter LFO: Modulates a parameter or control with a free-running or synced LFO
  • Parameter Random Walk: Drifts a parameter or control with a random walk between set limits
  • Parameter Randomize: Sets a fresh random value on a parameter or control on each note
  • Parameter Stepper: Each incoming MIDI note steps a parameter or control through evenly spaced values

Patterns And Sequences

Panels that generate notes, arpeggios, chords, patterns and phrases from what you play.

  • Arpeggiator: Plays held notes as an arpeggiated pattern, synced to host tempo
  • Bass Patterns: Plays built-in bass patterns from held notes, snapped to a key and scale
  • Chords: Turns single notes into chords and chord patterns
  • Euclidean Sequence: Spreads a set number of pulses evenly across the steps for Euclidean rhythms
  • Note Repeat: Repeats held notes polyphonically, synced to host tempo
  • Note Repeat (Polyphonic): Repeats held notes polyphonically, synced to host tempo or free-running
  • Note Stepper: Steps through a note sequence, advancing one step per key-press
  • Random Note: Plays random notes from a chosen scale and range
  • Strum Chords: Builds a chord on each played note and strums it with adjustable style and timing
  • Transpose Stepper: Steps through a sequence of transpose amounts, one step per note
  • Unleash: Fires off a fast, chaotic burst of notes, synced to host tempo

Sweeps And Strums

Panels that play through a set of notes from a single continuous control, so a CC sweep or a knob move becomes a strum, a gliss or a scale run. Each one differs in how its notes are chosen, a pitch range, the degrees of a scale, a chord, or eight notes you pick yourself. Every panel comes in a CC version, swept by an incoming controller, and a Knob version, swept by a knob on the panel that anything on the parameter path can drive.

  • CC To Range Strum: Sweeps a MIDI CC across a note range, with direction, repeats and octave spread
  • CC To Scale Sweep: Sweeps a MIDI CC up and down through the degrees of a scale
  • CC To Chord Strum: Sweeps a MIDI CC through a chord voicing, with repeats and octave spread
  • CC To Custom Strum: Sweeps a MIDI CC through eight freely chosen notes, with repeats and octave spread
  • Knob To Range Strum: Sweeps a knob across a note range, with direction, repeats and octave spread
  • Knob To Scale Sweep: Sweeps a knob up and down through the degrees of a scale
  • Knob To Chord Strum: Sweeps a knob through a chord voicing, with repeats and octave spread
  • Knob To Custom Strum: Sweeps a knob through eight freely chosen notes, with repeats and octave spread

Routing

Panels for splitting the MIDI into parallel chains, processing them separately, then merging them back together.

  • Splitter: Splits the MIDI into five parallel chains, A to E, each processed separately
  • Velocity Splitter: Splits notes into four chains (A-D) by how hard they're played
  • Mirror Splitter: Stacks each incoming note across all of the mirror ranges and routes each range to its own routing chain (A to E), so every stacked voice can be processed separately
  • Round Robin Splitter: Routes each note to the next chain in turn (A, B, C...), cycling through the number of chains set by Steps
  • Start A: Starts chain A - panels after it affect only chain A
  • Start B: Starts chain B - panels after it affect only chain B
  • Start C: Starts chain C - panels after it affect only chain C
  • Start D: Starts chain D - panels after it affect only chain D
  • Start E: Starts chain E - panels after it affect only chain E
  • End A: Ends chain A, ready for Combine
  • End B: Ends chain B, ready for Combine
  • End C: Ends chain C, ready for Combine
  • End D: Ends chain D, ready for Combine
  • End E: Ends chain E, ready for Combine
  • Thru A: Passes chain A straight through, unchanged
  • Thru B: Passes chain B straight through, unchanged
  • Thru C: Passes chain C straight through, unchanged
  • Thru D: Passes chain D straight through, unchanged
  • Thru E: Passes chain E straight through, unchanged
  • Combine: Merges the parallel chains, A to E, back into one

Templates

Ready-made routing setups. Each one loads a complete arrangement of panels in a single step, the splitter, the Start and End panels for chains A to D, and Combine, leaving you to drop your own panels into each chain.

  • Round Robin Splitter: A complete four-chain setup routing each note to the next chain in turn (A, B, C...), cycling through the number of chains set by Steps
  • Routing 4 Chains: A complete four-chain split, the Splitter, Start and End panels for chains A to D, and Combine, ready to fill in
  • Velocity Split: A complete four-chain setup splitting notes into chains A to D by how hard they're played

Utilities

General-purpose helpers: note and velocity ranges, fixed values, knob shapers, labels, and snapshot and channel tools.

  • Bar Position To Parameter: Sweeps a synth parameter or a control across a set number of bars, synced to the host
  • Expression Depth: Sets how far a per-note expression moves from a knob
  • Fixed Velocity: Forces every note to a single fixed velocity
  • Knob Clipper: Clips a knob between a low and high limit before it reaches a parameter or control
  • Knob Mixer: Mixes three knobs together to drive one parameter or control
  • Knob Multiply: Multiplies knobs together to drive one parameter or control
  • Knob Quantizer: Snaps a knob's value into steps before it reaches a parameter or control
  • Knob Ranged: Scales a knob into a set range before it reaches a parameter or control
  • Knob Slew (Exponential): Slews a knob's movement with independent rise and fall times, moving off quickly and easing into the target
  • Knob Slew (Linear): Slews a knob's movement at a constant rate, with independent rise and fall times
  • Knob Smoother: Smooths a knob's movement before it reaches a parameter or control
  • Knob To Expression: Sends a knob's value to a per-note expression
  • Knob To Expression (Continuous): Sends a knob to a per-note expression, updating continuously
  • Knob To Note: Plays a MIDI note while the knob is above the threshold, with the note and velocity set on the panel
  • Knob To Snapshot: Scrubs through snapshots from a knob
  • Labels: A panel of editable text labels for annotating a setup, double-click a label to edit it
  • Mirror: Folds incoming notes into the lowest mirror range and copies them to every active range, so one key plays all the stacked voices at once
  • Note Probability: Passes or mutes each note according to a probability amount
  • Note Range: Only lets through notes inside a set pitch range
  • Parameter Selector: Puts a parameter into a list box, for non-continuous parameters such as menus
  • Pitchbend Depth: Sets how far incoming pitchbend moves the pitch
  • Select Snapshot: Selects snapshots 1 to 8 from a range of eight keys
  • Set Channel: Sets the MIDI output channel for the notes passing through
  • Snapshot Morph Speed: Sets how quickly snapshots morph from one to the next
  • Trigger Random Snapshot: Jumps to a random snapshot when triggered
  • Trigger Randomize Preset: Randomizes the preset by an adjustable depth when triggered
  • Velocity Mapper: Reshapes the velocity response curve of incoming notes
  • Velocity Range: Only lets through notes inside a set velocity range

Trigger Library

Triggers are Utility Strip modules that are assigned to a range of keys; playing a key in the range fires the trigger. Some triggers have a panel associated with it that is displayed in the Panels View.

Patterns And Sequences

The key-range side of the Pattern panels: hold or play notes in the range to drive the arpeggiator, chord or pattern.

  • Advanced Arp: Arpeggiates held notes, with the key played setting the speed
  • Arpeggiator: Plays held notes as an arpeggiated pattern
  • Bass Patterns: Plays bass patterns from held notes
  • Chords: Plays the selected chord from a held note, arpeggiated
  • Euclidean Sequence: Plays a Euclidean pattern from held notes
  • Knob LFO: Modulates a parameter with an LFO, the key played setting the LFO speed
  • Mega Arp: Arpeggiates held notes, with the key played setting the speed
  • Note Repeat: Repeats held notes polyphonically, synced to host tempo
  • Note Repeat (Polyphonic): Repeats held notes polyphonically, synced to host tempo or free-running
  • Note Stepper: Plays back a sequence, each key-press advancing to the next step
  • Random Note: Plays random notes
  • Simple Arp: Arpeggiates the notes held in its range
  • Strum Chords: Plays strummed chords
  • Transpose Stepper: Steps through a sequence of transpose amounts, one step per note
  • Unleash: Plays back a fast, chaotic burst of notes

Modulation (Expression)

The key-range side of the Expression panels: notes played in the range feed into the modulator.

  • Expression Custom Envelope: Modulates the chosen per-note expression of notes in its range with a hand-drawn envelope
  • Expression Custom LFO: Modulates the chosen per-note expression of notes in its range with a hand-drawn LFO
  • Expression Depth: Scales the per-note expression of notes in its range around the Default value, by the Depth knob
  • Expression Envelope: Gates an ADSR envelope from notes in its range to modulate their chosen per-note expression
  • Expression LFO: Modulates the chosen per-note expression of notes in its range with an LFO
  • Expression Random Walk: Steps a random walk on each note in its range, modulating their chosen per-note expression
  • Expression Randomize: Gives each note in its range a new random value of its chosen per-note expression
  • Expression Stepper: Advances a stepped value on each key-press, applied as the chosen per-note expression of notes in its range
  • Knob To Expression: Sets the per-note expression of notes in its range to the panel's Value knob
  • Knob To Expression (Continuous): Continuously drives the chosen per-note expression from the panel's Value knob, independent of notes

Modulation (CC)

The key-range side of the CC modulators: notes played in the range gate, trigger or step the modulator, whose output is sent out as a MIDI CC.

  • CC Custom Envelope: Notes in its range trigger a hand-drawn envelope, sent out as the chosen MIDI CC
  • CC Custom LFO: Notes in its range retrigger a hand-drawn LFO, sent out as the chosen MIDI CC
  • CC Envelope: Notes in its range gate an ADSR envelope, sent out as the chosen MIDI CC
  • CC LFO: Notes in its range trigger an LFO, sent out as the chosen MIDI CC
  • CC Random Walk: Each key-press in its range steps a random walk, sent out as the chosen MIDI CC
  • CC Randomize: Notes in its range send a fresh random value out as the chosen MIDI CC
  • CC Stepper: Each key-press in its range advances the stepper, sent out as the chosen MIDI CC
  • Pitchbend Custom Envelope: Notes in its range trigger a hand-drawn envelope, sent out as pitchbend
  • Pitchbend Custom LFO: Notes in its range retrigger a hand-drawn LFO, sent out as pitchbend

Modulation (Parameter)

The key-range side of the Parameter modulators: notes played in the range gate, trigger or step the modulator, which drives the chosen parameter or control.

  • Parameter Custom Envelope: Notes in its range trigger a hand-drawn envelope, which modulates the chosen parameter
  • Parameter Custom LFO: Notes in its range retrigger a hand-drawn LFO, which modulates the chosen parameter
  • Parameter Envelope: Notes in its range gate an ADSR envelope, which modulates the chosen parameter
  • Parameter LFO: Notes in its range trigger an LFO, which modulates the chosen parameter
  • Parameter Random Walk: Each key-press in its range steps a random walk, which drives the chosen parameter
  • Parameter Randomize: Notes in its range set a fresh random value on the chosen parameter
  • Parameter Stepper: Each key-press in its range advances the stepper, which drives the chosen parameter

Effects

A key-range effect that runs while notes in its range are held.

  • Vibrato: Adds pitch vibrato while a key in its range is held, the key setting the speed

Snapshots

Keys for selecting, stepping and clearing snapshots, and setting the morph speed.

  • Clear Current Snapshot: Clears the currently selected snapshot slot
  • Next Empty Snapshot: Selects the next empty snapshot slot
  • Next Snapshot: Selects the next snapshot
  • Previous Snapshot: Selects the previous snapshot
  • Select Snapshot: Selects snapshots 1 to 8 from a range of eight keys
  • Set Morph Speed: Sets the snapshot morph speed from the key played

Parameters And Values

Keys that set a plugin value directly, either a range of keys stepping through the options or a single key toggling a setting.

  • Bypass Kick: Toggles the Kick engine bypass on and off
  • Bypass Layer: Toggles the Layer engine bypass on and off
  • Layer Mode: Selects the Layer engine's mode from a range of twelve keys
  • Legato Mode: Selects the legato mode (OFF, ON, SLIDE) from a range of three keys
  • MIDI Triggers (Off): Turns MIDI triggers off
  • MIDI Triggers (On): Turns MIDI triggers on
  • MIDI Triggers (Switch): Enables and disables MIDI triggers
  • MIDI Triggers (Toggle): Toggles the MIDI trigger bank on and off

Utilities

Key-range utilities that map a range of keys onto a parameter or expression.

  • CC To Expression (Note Range): Routes an incoming MIDI CC to a per-note expression, only for notes in its key range
  • Note To Parameter: Sets a parameter from which key you play in its range, low key to high
  • Trigger Randomize Preset: Randomizes the preset by an adjustable depth when triggered

Commands (No Panel)

One-shot command keys: press to fire an action such as undo, randomise, or load the next preset, sample or envelope preset.

  • Clear Envelope: Resets the current envelope to its default shape
  • Copy Envelope: Copies the current envelope to the clipboard
  • Flip Envelope: Flips the current envelope vertically (inverts it)
  • Next Envelope Preset: Loads the next envelope preset into the current envelope
  • Next Preset: Loads the next preset
  • Next Sample: Loads the next sample from the Samples folder
  • Paste Envelope: Pastes a copied envelope into the current envelope
  • Previous Envelope Preset: Loads the previous envelope preset into the current envelope
  • Previous Preset: Loads the previous preset
  • Previous Sample: Loads the previous sample from the Samples folder
  • Random Sample: Loads a random sample
  • Randomize All: Randomises all plugin parameters
  • Randomize All Full: Fully randomises the entire plugin: preset, envelopes and samples (100% depth)
  • Randomize All Subtle: Gently mutates the entire plugin: preset, envelopes and samples (3% depth)
  • Randomize Envelopes Full: Fully randomises all envelope shapes (100% depth)
  • Randomize Envelopes Subtle: Gently mutates all envelope shapes (3% depth)
  • Randomize Preset: Randomises the current preset parameters (respects the Logo Mutates preference)
  • Randomize Preset And Samples Full: Fully randomises the preset parameters and loads random samples
  • Randomize Preset And Samples Subtle: Gently mutates the preset parameters and loads random samples
  • Randomize Preset Full: Fully randomises the preset parameters (100% depth)
  • Randomize Preset Subtle: Gently mutates the preset parameters (3% depth)
  • Redo: Redoes the last undone action
  • Reverse Envelope: Reverses the current envelope
  • Undo: Undoes the last action

Appendix 2: The Node Editor

The Node Editor is a patching workspace where you can connect modules together with cables, in a similar way to Reaktor or Max. It has two uses. It gives you a rack of audio rate DSP (digital signal processing) modules, oscillators, filters, envelopes, shapers, logic and lots more, that you can patch around the Thump One engine itself, and it's also the workshop that the Utility Strip is built in, so you can open up any of the factory Panels or Triggers, take them apart, modify them and save them back out as your own.

It's an advanced feature and you don't need to use it, if you never open it the plugin behaves exactly as it always did. Everything you do in it can be undone with Command+Z (Ctrl+Z on Windows).

To open the Node Editor select 'Open Node Editor' from the 'Settings' menu (the icon with 3 vertical lines at the top right corner of the GUI).

Tooltips

Before you start, enable 'Show Tooltips' in the Node Editor's 'View' menu. Almost everything in the Node Editor is documented with tooltips:

  • Hover the mouse over a module's header to see a description of what that module does.
  • Hover over a port (either the dot or its name) to see a description of what that port expects, along with a live readout of the value that's currently on it, which updates as the value moves.
  • Hover over a cable to see the same live readout.
  • Hover over any row in the Inspector (the properties panel) to see a description of that property.

Tip: the live readouts on the ports and cables are the quickest way to find out why a patch isn't doing what you expected, just follow the signal along and see where it stops moving.

The Window

The canvas fills the middle of the window. Down the right hand side is the 'Palette', a list of everything you can add, arranged into collapsible categories with a small coloured swatch showing which family each module belongs to. Press the 'Tab' key to show or hide it.

Down the left hand side is the 'Inspector', which lists every property of whatever is currently selected, including properties that don't have a port on the module box.

Across the top is the menu bar: a padlock icon (see 'Building And Editing Panels' below) followed by the File, Edit, View and Snippets menus. The 'View' menu can add two more panels to the left hand side if you need them, a MIDI Triggers list and a tree view of the whole patch. A small pill at the top left corner of the canvas shows which part of the patch you're currently looking at.

Adding Modules

There are 4 ways to add a module to the patch, they all do the same thing:

  • Press Return with the mouse over the canvas. A search box opens at the mouse position, type a few letters and the matching modules are listed underneath. It matches the module's name, any word in the name, and its short symbol, so typing "+" will find 'Add'. Use the arrow keys to move up and down the list, Return to add the highlighted module at the mouse position and Escape to cancel. This is by far the quickest way to build a patch.
  • Right-click the canvas to open the full 'Add' menu, which is arranged into folders with the most commonly used modules listed at the top.
  • Drag a module from the Palette onto the canvas.
  • Drop a module onto a cable. If you drag a module that has no cables of its own (either a new one from the Palette, or one that's already on the canvas dragged by its header) over an existing cable then the cable will light up. Drop it and the module is inserted into that cable, the cable's source is connected to the module's first suitable input and the module's first suitable output carries on to the cable's original destination. If the cable doesn't light up then there was no compatible pair of ports to connect, so nothing will happen if you drop it. Adding the module and re-routing the cable are undone together in a single step.

Note: modules that have had all of their instances used up are greyed out in the menus and in the quick-add list (see 'The Collection' below).

Selecting And Moving

  • Click a module's header to select it. Shift-click adds or removes modules from the selection, and dragging on an empty part of the canvas lassoes everything inside the rectangle.
  • Dragging any module that's part of a multiple selection moves the whole group together.
  • Modules snap to a fine grid as you drag them, hold the 'Command' key ('Ctrl' on Windows) while dragging to snap to the coarse dot grid on the background instead. The arrow keys nudge the selection by one fine step, hold 'Control' for a coarse step.
  • Hold 'Alt' ('Option' on macOS) while you drag a module to pull off a duplicate of it, or of the whole selection.
  • Drag the bottom right corner of a module to make it wider, handy for modules with long port names.
  • Double-click a module's header to minimise it down to a compact box, and double-click again to expand it. Simple modules with a single input and output arrive minimised already.
  • Press 'F2' (or Shift+Return) to rename the selected module. The name is just for your own reference, it's displayed on the box and in the tree.
  • Right-click a module's header to open its menu, with rename, cut, copy, paste, duplicate, delete and minimise.
  • You can pan around the canvas by dragging with the middle mouse button, or by holding down the space bar and dragging.

Ports And Cables

Inputs run down the left hand edge of a module and outputs down the right hand edge. The colour of the port tells you what kind of signal it carries, there are 4 kinds:

  • Audio (white): A signal that moves every sample. Every output port on a Collection module is an audio port, and so are the plugin's main outputs.
  • Property Value (grey): A single value that only changes when something changes it. These are the same values that the Panels and Triggers pass around, and the same thing that a knob on the GUI holds. Property Values always have a ':' in their name.
  • Audio + Value: Most of the input ports on the Collection modules are this type. They'll take an audio cable if you connect one, and if you don't they'll sit at a fixed number that you type in, or follow a Property Value that you point them at.
  • MIDI (blue): A stream of notes and CC (continuous controller) messages passing between the MIDI modules.
  • Buss: The 'Buss' port on the Send and Receive modules. Instead of a signal this port takes a name (see 'Busses' below).

To connect two ports drag from one port's dot to the other, it works in either direction. Cables can only be connected between compatible ports, so if a connection isn't allowed nothing will happen when you drop it. A Property Value can drive an Audio + Value input, but audio can never drive a plain Property Value input.

An output port can be connected to as many inputs as you like. An input port can only take a single cable, so dropping a second cable onto it will replace the first one, unless you hold down the 'Shift' key.

Connecting Several Cables To One Input

If you hold down 'Shift' as you release a cable onto an input that's already connected then the new cable joins what's already there instead of replacing it, so both connections end up on the same wire.

The easiest way to think about this is that it isn't 2 cables meeting at a point, it's one long wire that all of those ports are connected to, and it doesn't matter where along the wire you touch it. So if you connect one of the outputs that's already on the wire to another module's input, that new module joins the same wire too, along with everything else that's already connected to it. Disconnecting a port just removes that one port from the wire, everything else carries on as before.

This works for Property Value and MIDI connections. It isn't available for audio connections, where each wire can only carry a single source. If an audio wire does end up with 2 sources driving it a red dot is displayed on the ports to warn you. To sum audio signals together use a 'Mixer', an 'Add' or a buss.

Named Connections

You don't have to draw every cable. Click on a port's name (rather than its dot) to open the port menu, select 'Add Value' and type in a name, something like "Main Filter Output". Then do the same on any other port, anywhere in the patch and at any level of nesting, type in the same name and the two ports are connected. No cable is drawn, the name is simply displayed next to each port.

This is the quickest way to get a signal across a busy patch, or into a module that's nested a few Views deep, and it keeps everything tidy. Audio ports take a plain name like the example above. Property Values need a ':' in the name, either one of the plugin's own fixed values like "playhead:bpm", or a name of your own for a particular connection.

The 'Add Value' box is also where you type in a fixed number for an input, an oscillator's frequency or a filter's cutoff for example, for any input that you don't want to patch. The rest of the port menu has 'Clear', an option to hide an unused port, and options to copy a connection from one port and paste it onto another.

Note: some modules keep their less commonly used inputs hidden so that the box stays small. A small '+' appears at the bottom edge of the module to reveal them, click the one on the left for inputs or the one on the right for outputs and choose from the list.

Busses

Busses are handy for mixing several signals together and picking them up somewhere else in the patch.

Add a 'Send To Buss' module, patch a signal into it and give its 'Buss' port a name, either by typing the name into the 'Buss' row in the Inspector or by using 'Add Value' on the port itself. The name can be anything you like: "pitch", "fx", "sub". Then add a 'Receive From Buss' module and give it the same name, and its output will carry that signal. Any Sends that use the same name are summed together, and any number of Receives can pick up the result. Names aren't case sensitive, and there are 8 busses available to share out between the names you use.

Views (Patches Inside Patches)

A View is a container, and on the canvas it behaves like a sub-patch. Double-click a View to go inside it and see its contents, and double-click on an empty part of the canvas to come back out again. You can also select some modules and press Command+G to wrap them up inside a new View, or Shift+Command+G to unwrap one.

When you're inside a View, move the mouse near the left or right hand edge of the canvas and a small round '+' button appears in the corner. Click it to add a port to the View, which opens a strip down that edge listing the View's ports, inputs on the left and outputs on the right. Connect a cable to one of the ports on the strip and the signal is passed out through the View's own box on the canvas outside, where the same port appears as an ordinary port that can be patched like any other module's. Click a port's name on the strip to rename it.

The Collection

The audio modules aren't separate objects that are created and destroyed as you patch. They're a 'Collection', a fixed, curated rack of DSP modules built into the plugin, with a set number of instances of each one already there waiting to be used. Thump One comes with a Collection of around 70 module types, and more Collections may be added in the future, an effects Collection for example, each one a curated rack of modules rather than an open ended library.

Patching doesn't build anything, it simply decides which module listens to which, and because of that the editor behaves quite differently to a patching environment that has to compile its patches:

  • Nothing is ever compiled: There's no build step, no waiting and no progress bar, your changes are live as you make them.
  • Re-patching doesn't interrupt the audio: You can rewire the patch while a note is sounding without any clicks or dropouts.
  • State is always kept: Filters, delays and envelopes carry on running while you change the patch, because they were never torn down and rebuilt.
  • It runs a sample at a time in a fixed order, so a signal can be fed back into itself with a single sample of delay, which is what makes feedback FM, resonators and similar structures possible.
  • Idle modules cost nothing: Any instance that you haven't patched is switched off, and the whole Collection is skipped when nothing is reaching the Output.

Note: each module type has a limit to the number of instances you can use. Once they've all been used up that module is greyed out in the 'Add' menu, in the Palette and in the quick-add list, and duplicating or dropping another one displays a brief message on the canvas. The limits are set generously, and are much higher for the small building blocks than they are for expensive modules like the filters and delays.

The Smallest Patch

There are 3 modules that act as the way in and out of the plugin:

  • MIDI Input: Gives you note pitch, gate, pressure, pitchbend, mod wheel and some CCs as patchable signals
  • Thump One: The synth engine itself as a module, with its knobs as input ports and its engine outputs and 8 envelopes as output ports, so you can take the Kick engine's output off on its own, or drive Punch from something you've built yourself
  • Output: Where the sound leaves the plugin

There's also a 'Per-note Expression' module, which gives you the same per-note expressions that the Utility Strip's Expression Panels write to.

Thump One plays as normal until something reaches the Output module. From that point on the patch is the signal path, so the synth is no longer connected to the output unless you connect it yourself. The smallest patch that gets you back to the normal instrument is 3 modules and 4 cables:

  • MIDI Input 'Pitch' to Thump One 'Pitch'
  • MIDI Input 'Gate' to Thump One 'Gate'
  • Thump One 'Output L' to Output 'L'
  • Thump One 'Output R' to Output 'R'

That's Thump One exactly as it was before you started patching, and it's a good place to start from. From there you can insert a filter between the synth and the output, ring-modulate one engine with the other, or drive the Buzz input from an envelope follower connected to the Layer engine's output!

Building And Editing Panels

The same canvas holds the Utility Strip itself, so the MIDI modules, the on-screen controls and the audio modules all appear side by side and can be patched to each other. There are 2 things worth knowing when you're working on a Panel:

  • Modules that carry a control (a knob, a button or a menu) display the real working control inside the box, so you can set it while you patch.
  • Calculator modules display their expression inside the box, click on it to edit it.

The padlock icon at the top left of the menu bar unlocks the plugin's own GUI so that you can drag and resize the controls on the Panel while the patch is open (Command+E does the same thing), lock it again when you've finished. The 'Align' and 'Distribute' items in the 'Edit' menu work on the GUI controls while the padlock is unlocked, and on the module boxes when it's locked.

Saving Your Work

Everything you patch is saved with the preset, and with the Strip Preset, in exactly the same way as the rest of the Utility Strip. The 'File' menu can also save and load the whole workspace as an XML file, and the 'Snippets' menu saves the current selection as a re-usable snippet and lists any snippets you've already saved, ready to drop into another patch. Snippets are stored in the plugin's own folder, at "~/Library/Application Support/Toybox/Thump One" on macOS and "C:\Users\[your username]\AppData\Roaming\Toybox\Thump One" on Windows.

Keyboard Shortcuts

'Command' is 'Ctrl' on Windows and 'Option' is 'Alt'.

  • Return: Quick add at the mouse position
  • Tab: Show or hide the Palette
  • F2 or Shift+Return: Rename the selection
  • Arrow keys: Nudge the selection, hold 'Control' for a coarse step
  • Delete: Delete the selection ('Command+Delete' deletes a module's contents)
  • Command+Z / Shift+Command+Z: Undo and redo
  • Command+X / C / V: Cut, copy and paste
  • Shift+Command+V: Paste as a fresh copy with new identities
  • Command+D: Duplicate ('Option+Command+D' duplicates with new identities)
  • Command+A: Select all ('Command+P' selects the parent, 'Command+U' deselects)
  • Command+G: Wrap the selection in a View ('Shift+Command+G' unwraps one)
  • Command+E: Unlock or lock GUI editing
  • Command+[ and Command+]: Send backward and bring forward, add 'Shift' to send all the way
  • Command+S / Shift+Command+S / Command+O: Save, save as and load the workspace XML
  • Command+R: Refresh the editor