Soba

Soba is a modular synthesizer you patch on a canvas. You place modules (oscillators, filters, envelopes, effects) as nodes, draw cables between their jacks, and hear the result as you go. Nothing is wired in advance: the patch is the instrument.

The name comes from the cables. Blender, whose node editor Soba takes after, calls the wires between nodes noodles, and soba are long, fine noodles. In Japanese, soba (傍) also means "beside": an instrument whose patches sit by you and explain themselves.

A patch on the canvas. Cables are colored by what they carry, and light up as signal passes through them.

A node graph, not a rack

Most software modulars imitate hardware: rows of panels, screws, and cables that sag in front of everything. Soba borrows instead from node editors like Blender's. Every module is a rounded card with inputs on its left edge, outputs on its right, and knobs along the bottom. You can put modules anywhere, zoom out to see the whole patch, and zoom in to work on one corner of it.

What it keeps from hardware is the feedback. Cables glow with the signal they carry, so a note becomes a pulse of light running down the wire and an LFO draws its waveform along the cable. Knobs under modulation turn on their own. Oscillators, envelopes, filters and LFOs draw what they're doing on the module itself. You can see a patch working as well as hear it.

Signals

Each cable carries one of three kinds of signal, and takes its color from it:

A cable can also carry up to eight voices at once, which is how Soba plays chords. MIDI doesn't travel on cables: Note In listens to the controller you choose in the toolbar and turns what you play into pitch, gate and velocity. Signal Types and Polyphony cover both in depth.

Modules

There are 44 modules in six categories. A module's header takes its category's color:

The Module Overview introduces each one.

Where to start

If you're new to modular synthesis, read the Getting Started pages in order:

1. Installation gets the app running.
2. Interface Overview shows you around the window.
3. Your First Patch builds a playable synthesizer from an empty canvas, one cable at a time.
4. Lessons teach the same ideas inside the app: five short tutorials that show you each move, then wait while you make it.

If you already know your way around a modular, open the 📚 Examples menu, load a patch, and keep the module reference to hand. The recipes explain how each example works, one idea at a time, and the songs are whole pieces that play themselves from the first note to the last.

Under the hood

Soba is written in Rust, with egui for the interface and cpal for audio. The audio engine runs on its own thread and never waits on the interface: edits travel to it over lock-free queues, every buffer is allocated before playback starts, and a test in the build fails if the audio thread ever allocates memory. That is what keeps the sound from glitching while you patch.

The source is on GitHub.

Installation

Soba runs on Windows, macOS and Linux. You can download a prebuilt release or build it from source with Rust. Or, to hear it first, try it in the browser.

Try it in the browser

Open Soba in the browser: the whole app, nothing to install. It opens on the First Sound example. Press ▶ Play, then play the Z to M keys, or hold the keys of Note In's piano with the mouse or a finger.

The browser version runs the same engine and modules, and every example is in its 📚 Examples menu. A few things need the desktop app:

• Audio input. In the browser, the computer keyboard, the on-screen pianos and MIDI devices play the patch. MIDI devices work in Chrome, Edge and Firefox, after 🎹 Connect MIDI (see MIDI); Safari has no MIDI.
• Recording to a WAV, and My Modules, which keep files in a folder.
• The lowest latency. The browser adds its own delay on the way to the speakers, which the desktop app doesn't have. In Chrome, Edge and Firefox the full app renders its sound on the browser's audio thread in small buffers, so heavy patches play steadily and the keys answer as fast as the browser lets them. Safari, and the patches embedded in this manual, play through larger buffers: about a tenth of a second more behind your playing. That's fine for listening and exploring, and loose for playing live.

On a phone or tablet, a patch opens zoomed out to fit the screen: pinch to zoom in, and drag the canvas to move around.

Patches go in and out as files: 💾 Save downloads the patch (as a zip with its samples, if it plays takes or files you've dropped), and 📂 Open picks one to upload. Each recipe in this manual can be played on its page.

Download a release

Each release on GitHub has a download for Windows, macOS (Apple Silicon and Intel) and Linux.

Windows

Download soba-windows-setup.exe and run it. It installs Soba for you alone, in %LOCALAPPDATA%\Programs\Soba, without asking for an administrator. It adds Soba to the Start Menu, and you can remove it from Settings → Apps → Installed apps, like any other app.

For playing live, download soba-windows-asio-setup.exe, the low-latency build, instead. It runs exactly like the standard one, and can also use an audio interface's ASIO driver: see Build with ASIO for what that gives you, and skip the building. Installing either one replaces the other.

The first time, Windows may show "Windows protected your PC": the downloads aren't signed yet. Click More info, then Run anyway.

If you'd rather not install anything, the zips (soba-windows.zip and soba-windows-asio.zip) hold the same app as one file. Unzip it anywhere and run soba.exe.

macOS

Download the disk image for your Mac: soba-macos-apple-silicon.dmg for an M-series Mac, or soba-macos-intel.dmg. Open it and drag Soba to Applications.

The app isn't signed by Apple yet, so the first time, macOS says it can't check it for malicious software. Right-click (or Control-click) Soba in Applications and choose Open, then Open again. After that it opens normally. On recent versions of macOS, if there's no Open button, go to System Settings → Privacy & Security and click Open Anyway beside the message about Soba.

Linux

Download soba-linux.zip, unzip it, and run soba. If it won't start, mark it as a program first: chmod +x soba.

Updates

Once a day, Soba asks GitHub whether a newer release is out. When one is, the dot after the version number in the bottom-right corner lights up blue, and a note says what's new. Click the version number to see the note again.

• What's New shows the release notes for every version since yours.
• Install downloads the new version, checks it against the release's published checksums (SHA256SUMS), puts it in place and restarts. Your patch, including changes you haven't saved, your audio and MIDI devices, and your view of the canvas come back as they were. If the patch has unsaved changes, Soba offers to save them first. Install waits while a recording is running.
• Later puts the note away; the dot stays lit. Skip this version stops offering that version; a newer one is still offered.
• Help → Check for Updates… checks now, and says so if you're up to date.

What the check sends: one request to GitHub's public list of releases, saying it comes from soba and which version. Nothing about you or your computer, and no usage data. A check that doesn't work, when you're offline say, does nothing visible and tries again next time. To stop checking altogether, turn off Help → Check for Updates Automatically; Soba then makes no requests at all.

Rolling back: the version you updated from stays beside the new one, and Help → Roll Back to … swaps back to it and restarts. The version you left is skipped, so it isn't offered again straight away.

Where Soba can't replace itself, Install becomes Download, which opens the release page:

• A copy built from source (cargo run), which only says that an update exists.
• A copy in a folder it can't write to, such as Program Files.
• macOS, until the app is signed: macOS doesn't let a downloaded app replace itself.
• Linux, when a package manager installed it.

Each copy updates to the same kind of download it came from: the low-latency Windows build to the next low-latency build, the standard one to the standard one.

Build from source

Install Rust

Install the Rust toolchain with rustup:

# Windows
winget install Rustlang.Rustup

# macOS and Linux
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Check that it worked:

cargo --version

Install system libraries (Linux only)

Windows and macOS need nothing more: Soba uses WASAPI and CoreAudio, which come with the system. (ASIO on Windows is optional: see Build with ASIO.)

On Linux, install the development packages for ALSA (audio), X11 and keyboard handling. On Debian and Ubuntu:

sudo apt install libasound2-dev libxcb-render0-dev libxcb-shape0-dev \
  libxcb-xfixes0-dev libxkbcommon-dev libssl-dev

On other distributions, install the equivalent ALSA, xcb and xkbcommon development packages (for example alsa-lib-devel on Fedora, alsa-lib on Arch).

Build and run

git clone https://github.com/chrischaps/Soba.git
cd Soba
cargo run --release

The first build takes a few minutes. Always use --release to play: the debug build is much slower and can't keep up with a busy patch, so you'll hear dropouts. The finished binary is target/release/soba.

The app opens on the First Sound example. Press ▶ Play, then play the Z to M keys on your computer keyboard. If you hear a note, everything is working.

Build with ASIO (Windows, optional)

For playing a guitar or singing through Soba, Windows Audio's round trip of 60 ms or so is too slow to play against. An audio interface's ASIO driver talks to the hardware directly and gets it down to 11–20 ms on a Scarlett 2i2.

ASIO is a registered trademark of Steinberg Media Technologies GmbH

The low-latency Windows download (soba-windows-asio.zip, see Download a release) has ASIO built in: install your interface's driver (step 1) and choose ASIO in the Output menu. To build it yourself, it's a build option, off by default:

1. Install your interface's ASIO driver from its maker. For a Focusrite Scarlett, that's the Focusrite USB driver from focusrite.com. Restart, or unplug the interface and plug it back in, once it's installed: until then the driver may not find the interface.

2. Install LLVM, which the build uses to read the ASIO headers:

   winget install LLVM.LLVM
   

   Then point the build at it. In a new terminal:

   setx LIBCLANG_PATH "C:\Program Files\LLVM\bin"
   

3. Build with the asio feature:

   cargo run --release --features asio
   

   The first build downloads Steinberg's ASIO SDK into your temp folder. To use a copy you already have, set CPAL_ASIO_DIR to its folder.

   If the build stops at "Failed to extract ASIO SDK", Windows PowerShell couldn't load its unzip command, which happens when the build runs from PowerShell 7. Build from Git Bash with env -u PSModulePath cargo run --release --features asio, or unzip %TEMP%\asio_sdk.zip yourself and set CPAL_ASIO_DIR to the folder inside.

Then choose ASIO at the top of the Output menu. See Audio Input for choosing a buffer size.

Steinberg licenses the ASIO SDK under the GPLv3 (or its own proprietary terms). Soba's source is MIT, but a binary built with ASIO includes the SDK, so if you share one, the GPLv3 applies to it. The low-latency download is such a binary: it's distributed under the GPLv3, with the GPL, Steinberg's licence for the SDK and a notice in its zip and installer. The exact SDK it was built from (ASIO SDK 2.3.4, pinned by its checksum in release.yml) is attached to the same release as asio-sdk-source.zip. The other downloads leave ASIO out and stay MIT.

Build with Ableton Link (optional)

Ableton Link lets the Clock play in time with other apps on the network: see Playing in a Link session. It's a build option, off by default, because Ableton licenses the Link SDK under the GPLv2 (or its own commercial terms).

1. Install CMake, which builds the Link SDK, and LLVM, which reads its headers (see step 2 above for pointing the build at LLVM). On Windows:

   winget install Kitware.CMake
   winget install LLVM.LLVM
   

   On macOS, brew install cmake llvm. On Linux, your distribution's cmake, clang and libclang-dev packages.

2. Build with the ableton-link feature:

   cargo run --release --features ableton-link
   

   It goes with ASIO too: --features asio,ableton-link.

Soba's source is MIT, but a binary built with Link includes the SDK, so if you share one, the GPL applies to it. Builds without the feature leave Link out and stay MIT. The browser version can't use Link.

The plugin (CLAP and VST3)

Soba also runs inside a DAW, as an instrument on a track. It's a CLAP plugin, for Bitwig Studio, REAPER, FL Studio and Studio One, and it can be built as a VST3 for DAWs without CLAP, such as Ardour and Cubase. The plugin is the whole app: the node graph is its window, and the patch plays whatever the track sends it.

• Notes and CCs from the track reach Note In modules, the MIDI Monitor and MIDI Learn, as a MIDI device's do in the app.
• Tempo and transport. Set a Clock's Source to Host and it plays at the DAW's tempo, on its beat, starting and stopping with it (see Playing in a DAW).
• Macros. The plugin offers the DAW eight parameters, Macro 1 to Macro 8, to automate. Right-click a knob, then Map to Macro, and the knob follows that macro.
• The patch is saved with the project. Samples are kept by path, as in a patch file, so keep them where they are.

The DAW plays the patch, so the plugin has no Play button and no device menus. Open and Save As still read and write patch files, so a patch moves between the plugin and the app.

There's no download of the plugin yet. To build one from source (see Build from source above for Rust):

python tools/plugin_bundle.py            # builds dist/Soba.clap
python tools/plugin_bundle.py --install  # ...and copies it where DAWs look

--install puts it in your own CLAP folder: %LOCALAPPDATA%\Programs\Common\CLAP on Windows, ~/Library/Audio/Plug-Ins/CLAP on macOS, ~/.clap on Linux. Then rescan plugins in the DAW and add Soba to an instrument track.

VST3, for Ardour and other DAWs without CLAP

python tools/plugin_bundle.py --vst3 --install   # dist/Soba.vst3 as well, installed beside the .clap

The VST3 goes in your own VST3 folder: %LOCALAPPDATA%\Programs\Common\VST3 on Windows, ~/Library/Audio/Plug-Ins/VST3 on macOS, ~/.vst3 on Linux. A DAW that only looks in the shared folder won't find it there. In Ardour, add the folder under Edit ▸ Preferences ▸ Plugins ▸ VST, in the VST3 paths, then rescan. Or copy Soba.vst3 into C:\Program Files\Common Files\VST3 (that needs an administrator).

The VST3 is the same plugin: the same editor, Host clock, macros and saved patch.

Its licence differs. Soba's plugin wraps VST3 with nih-plug, whose VST3 support is built on vst3-sys, a GPLv3 library. So a VST3 build of Soba falls under the GPLv3, as the ASIO download does. The .clap is built without it and stays MIT. Steinberg's own VST3 SDK went MIT in 2025, but Soba doesn't use it directly.

Command line

Pass a patch file to open it instead of First Sound:

cargo run --release -- patches/lush-pad.json

The render tool plays a patch into a WAV file without opening the app or using an audio device, then prints each channel's peak, true peak and RMS level, the mix's loudness, and how hard the patch drives the output limiter:

cargo run --release --bin render -- patches/fm-synthesis.json out.wav --seconds 5

A patch that waits for a player renders silence unless something inside it plays notes (a Clock or Step Sequencer, say) or you add --audition. Audio Input modules render silence unless you give them a file with --input. Samplers find their files relative to the patch, as the app does.

Here Lush Pad's filter has been closed from 2500 Hz to 833 Hz since before.wav:

rendered 'Lush Pad' (8.00 s @ 48000 Hz) -> after.wav
  L: peak   -4.8 dBFS   true   -4.7 dBTP   rms  -22.2 dBFS
  R: peak   -4.3 dBFS   true   -4.3 dBTP   rms  -21.4 dBFS
  loudness -17.4 LUFS   range 12.3 LU
  limiter in   -4.3 dBFS   took 0.0 dB at most, 0% of the time over 1 dB
against before.wav:
  L: peak   -1.5 dB     true   -1.5 dB     rms   -1.0 dB
  R: peak   -1.2 dB     true   -1.2 dB     rms   -0.9 dB
  loudness  -1.3 LU     range -0.1 LU

True is the true peak, in dBTP, also after BS.1770-4: how high the waveform goes between the samples, which can be higher than at them. A converter playing the file, or an encoder squeezing it into an MP3 or a video, rebuilds that waveform and clips whatever goes over full scale, so a render whose samples all sit under 0 dBFS can still clip when it's played. A smooth pad reads its sample peak or a tenth above it. Sharp transients go higher: Backbeat's drums read 0.8 dB above their samples. Keep it under −1 dBTP to be safe.

Loudness is integrated loudness after ITU-R BS.1770-4, the measure streaming services normalize to. It weights the mix the way the ear does, so it's the number to compare when you want to know whether a change made a patch sound louder. RMS overweights the bass: above, it says the darker pad lost 1 dB, but the ear hears the treble it lost and puts it at 1.3. Range is the EBU loudness range, the spread between the quiet and loud passages. It reads -- on renders shorter than three seconds.

Limiter is how hard the patch drives the Audio Output's limiter: the highest peak going into it, which can be over 0 dBFS, the most it turned the output down, and for how much of the render it took off more than 1 dB. The limiter is there to catch accidents. A patch whose peaks stay under −1 dBFS leaves it idle, as every example does. The examples also sit within a decibel or so of −16 LUFS, so switching between them doesn't jump in volume; aim there to match them.

Timing a render

--bench measures how heavy a patch is to run. It times only the processing, not loading the patch or measuring the result, and renders three times, keeping the fastest. A busy machine can only slow a run down, never speed it up, so the fastest is the closest to the patch's own cost:

bench: 1.3546 s for 20.00 s of audio, 14.8x realtime (best of 3)
  osc.sine (node 2)                  576.9 ns/sample   41%
  filter.svf (node 3)                347.7 ns/sample   25%
  fx.reverb (node 6)                 291.1 ns/sample   21%
  fx.chorus (node 5)                  66.4 ns/sample    5%
  util.vca (node 4)                   32.4 ns/sample    2%

That is Lush Pad, auditioned. Realtime is how much faster than playback it rendered: below 1x it couldn't keep up live. Below it are the modules that took longest, by their module and their id in the patch file, in nanoseconds per sample and as a share of the whole. Lush Pad's oscillator plays every held voice, so it takes the most. Timing each module costs a little in itself, so the whole runs a few percent slower than it would without --bench.

Microphone access

Soba opens a microphone or other input only when you choose one in the toolbar's Input menu.

• macOS asks for permission the first time. If you run Soba from a terminal (cargo run), macOS asks on behalf of the terminal app, and the permission belongs to it. If you said no, or the input stays silent, turn it on under System Settings → Privacy & Security → Microphone, then quit and reopen the terminal or the app.
• Windows lets desktop apps use the microphone unless it's turned off under Settings → Privacy & security → Microphone (Let desktop apps access your microphone).
• Linux has no permission prompt; the input appears if ALSA (or PipeWire's ALSA support) lists it.

To run the test suite, use cargo test.

Troubleshooting

No sound. Check that ▶ Play is pressed: the app opens stopped. Then check the Output device menu in the toolbar. It lists every output device, with the system default marked (Default); pick the one you're listening on. 🔄 Refresh at the bottom of the menu picks up a device you plugged in after starting. Until you pick one, Soba plays to whatever Windows has as its default, and follows it: plug in headphones and the sound moves to them, with Output moved to … in the status bar. If the default goes away with nothing to take its place, the sound comes back on its own once a device does.

"Audio unavailable" in the toolbar. Soba couldn't open an output device. Make sure one is connected and that no other application holds it exclusively, then restart.

Crackles and dropouts. Make sure you're running the release build. The toolbar's CPU meter, shown while the patch plays, tells you how close the engine is to its limit. If it's near the top, remove modules or lower Voices on Note In and the Oscillator's unison.

My MIDI controller does nothing. Choose it in the toolbar's MIDI In menu: Soba doesn't connect to a controller until you do. In the browser, click 🎹 Connect MIDI there first. A filled dot (●) before the name means it's connected. Connection errors appear in the status bar at the bottom of the window. See MIDI.

Interface Overview

The Soba window has three parts: a toolbar along the top, the canvas where you build patches, and a status bar along the bottom.

The toolbar, the canvas with a patch on it, and the status bar.

The toolbar

From left to right:

At the right end, the toolbar shows a CPU meter while the patch plays, the device's sample rate and channel count, and whether the audio engine is running. While an input is open, In shows how much audio is held between the input and output devices, in milliseconds; it turns amber for a moment after a dropout. Hover it for details.

The status bar

The status bar reports what just happened: a file saved, modules pasted, a cable refused and why. When there's nothing to report, it counts the modules and cables in the patch. On the right it names the open patch, with a dot (●) if it has unsaved changes. At the far right is the version, with a small dot after it that lights up blue when a newer version is out: click it to see what's new, or, while it's dark, to check.

If a patch loads with problems (a module this version doesn't know, a cable to a jack that no longer exists), a ⚠ load warning appears on the right. Hover it to read the warnings; click it to dismiss them.

Moving around the canvas

The background grid moves and zooms with the patch, with a brighter line every five squares.

Adding modules

The add menu

Right-click empty canvas to open the add menu. It lists the six categories in their header colors; hover or click one to see its modules, then click a module to place it where you right-clicked. Hover a module's name to read what it does. Groups you've saved are under My Modules, in rose (see Groups). Below the categories, Frame and Note add a frame or a note.

On a touch screen, hold a finger still on empty canvas for half a second instead. The menu opens with finger-sized rows. Tap a category to see its modules, then tap a module. To read what a module does, rest a finger on it and the footer under the list tells you. If you then lift the finger after a moment, nothing is added. On a phone, a category's modules often have no room beside the menu, so they open in its place, with ‹ Back at the top.

Right-click empty canvas, pick a category, then a module.

Quick add

Press Space or Tab with the mouse over the canvas. A search box opens at the cursor, listing every module by category, with your saved groups first under My Modules and the ready-made groups of the Library last. Type a few letters to narrow the list, then press Enter, and the module appears where the box opened. (With a group selected, Tab opens the group instead.) In the browser, the + button on the toolbar opens it too, in the middle of the view: the way in on a phone, which has neither key.

Type a few letters of a module's name or category, then press Enter.

The search is forgiving. Letters only need to appear in order, so lfo, svf, dly and s&h all find what you'd expect. Typing a category name (effect, mod) lists that category. Move through the list with the arrow keys or Tab, add the highlighted module with Enter, or close the box with Escape.

Anatomy of a module

Every module has the same layout:

• Header. The module's name and category icon, on a bar in the category's color. Hover the header to read what the module does. The × at the right end deletes the module. Filters and effects also have a power switch at the left end: see Bypass.
• Inputs, down the left edge. Each jack is labeled and colored by the signal it expects.
• Outputs, down the right edge, colored by the signal they send. An output lights up while signal is coming out of it.
• Displays. Many modules draw what they're doing: the oscillator its waveform, the envelope its shape, filters their frequency response, the LFO its wave with a dot riding its phase.
• Knobs, along the bottom, with the current value under each.

Hover any jack's name or knob for a tooltip: what it does, its signal type in the cable's color, and for knobs, its range.

Knobs

A knob's ring lights up in its module's header color. Knobs with a range either side of zero, like Semi and Fine, light outward from the top, so you can see at a glance which way they're set. A small mark stands where zero is, so a knob at zero shows a dark ring with its pointer on the mark.

Some knobs move in whole steps, like the Oscillator's Oct and Semi: they click from one value to the next as you drag.

Knobs with a jack

Many parameters have both a knob and an input jack of the same name. Patch a cable into the jack and the knob sets the center while the incoming signal moves the value around it. Each module page gives the scale.

The knob stays live while the cable is patched, so you can keep moving the center as the signal plays. Its pointer stays where you set it. Once signal arrives, an orange bead on the knob's rim shows where the signal has carried the value, joined to the pointer by a thin orange arc. A faint band behind the bead shows the range the signal has covered over the last second or so, so you can see how deep an LFO swings even when it's too fast to follow. The number under the knob turns orange and reads that carried value. Hover over the knob or drag it and the number goes back to white and shows the center you're setting. Unplug the cable and the knob alone sets the value again.

In a busy patch, hover over a patched knob to find the cable carrying its signal: that cable glows and the rest dim, and its route shows through any module it runs under. It works the other way too. Hover over a cable and the bead on the knob it feeds swells and glows.

Until signal arrives, a small green dot above the knob shows that a cable is patched in.

Cables

Drag from an output to an input to patch a cable; a jack turns white when the cable is close enough to land on it. You can also drag from an input to an output. Cables only connect where the signals make sense: audio and control mix freely, and a gate can drive a control input, but a cable between jacks that can't work won't attach, and the status bar says why when it can. Signal Types has the full rules.

• One output can feed many inputs. Each gets the full signal.
• Each input takes one cable. Dropping a new cable onto an occupied input replaces the old one.
• No loops. A cable that would feed a module's output back into its own input, directly or through other modules, is refused, and the status bar names the modules round the loop.
• To remove a cable, drag its end off the input jack and let go over empty canvas.

Cables run behind the modules, and behind frame titles and notes, showing faintly through them so a route can still be followed without covering the controls or the words. 〰 Cables ▸ Under modules and labels sets how faintly.

While the patch plays, cables show what their signal has been doing over the last few seconds. Reading the signal in a cable explains what you're seeing.

Probing a cable

To hear what a cable carries on its own, hold Alt over it while the patch plays. You'll hear the LFO before it reaches the filter, or the dry voice before the reverb. A small scope beside the pointer shows the signal's waveform and names the output it comes from. The probe plays on top of the patch at the same fixed level as a Sampler's ▶. It never comes out louder than that. While you probe, the rest of the patch is turned down beneath it: by 20 dB under an audio cable, which all but solos it, and by 6 dB under a control or gate cable, so you can still hear the music the signal moves. 〰 Cables ▸ Patch under a probe sets each amount, from Off to Solo, and Soba remembers them. Neither the probe nor the ducking goes into a recording. The probe fades in, and when you let go of Alt or move off the cable it fades out and the patch comes back up.

• Audio cables play as they are. On a polyphonic cable, all the voices are summed.
• Control cables play as a quiet sine whose pitch follows the value: A3 at 0, two octaves higher at 1, and two octaves lower at -1. You hear an LFO as a siren and a stepped sequence as a tune.
• Gate cables play a soft click each time the gate opens, with a faint tone while it's held, so you can hear how long each gate lasts as well as when it starts.

Probing works on cables inside groups and on cables into a group's jacks, where you hear the module output the cable carries. MIDI cables have no sound to probe.

Editing modules

The module menu

Right-click a module's header or body (anywhere but a knob) to open its menu. Bypass appears only on filters and effects.

If the module is part of a selection, the item applies to the whole selection.

Copy, paste and duplicate

Duplicate (Ctrl + D) copies the selected modules a little down and to the right. Cables between them are copied too; cables to the rest of the patch aren't. The copies are selected, so pressing Ctrl + D again makes a row of them.

Copy (Ctrl + C) and Cut (Ctrl + X) put the selected modules on the clipboard. Paste (Ctrl + V) drops them at the mouse cursor, keeping their layout, settings and the cables between them. Pasting again without moving the mouse fans the copies out.

The clipboard holds modules as patch text, so you can paste between two Soba windows, or paste the contents of a whole patch file to add its modules to the current patch. MIDI mappings stay with the original modules.

Bypass

Filters and effects can be bypassed: their audio inputs pass straight to their outputs, as if the module weren't there. Click the power switch at the left of the header, choose Bypass from the module menu, or select modules and press Ctrl + B. A bypassed module's header fades to gray and its controls dim. Switching takes a 20 ms crossfade, so it never clicks, and a bypassed module uses no CPU.

Mutate

Select a module or a group and press Ctrl + M. Each of its knobs moves a small random step, and pressing it again wanders further. Hold it, and the knobs glide out further the longer you hold, from a nudge to a big jump; let go when you like what you hear. It's a way to explore by listening: mutate a Library group until it's yours.

• What moves: every knob of the selected modules, and of every module inside a selected group. Ctrl + Alt + M moves their whole-number knobs, switches and dropdowns too.
• What doesn't: a knob a cable drives, the Audio Output, and any knob that sets how loud something is (a level, gain, makeup, drive or feedback), so a variation is never louder than the patch was.
• Keeping one: a strip of chips under the selection holds the knobs as they were and the last eight variations, each drawn as a tick per knob, as high as the knob is turned. Click one to go back to it.
• Undo: each variation, and each click on the strip, is one step.
• Keeping it for good: Ctrl + Shift + M keeps the knobs as they stand in the next free scene of a Scenes module: the one in the selection's group, or the patch's.

Frames and notes

A patch can explain itself. A frame is a titled, tinted backdrop behind a group of modules, like a section printed on a synth's front panel: Voice, Modulation, Echoes. A note is a card of text on the canvas. Neither makes a sound. Every example patch uses them, so you can read how it works while you play it.

Two frames and two notes. Right-click a frame's title to rename or recolor it.

Frames

• To frame some modules, select them and press Ctrl + Shift + F, or right-click empty canvas and choose Frame. The frame is drawn around the selection and takes the color most of its modules share. Type its name and press Enter.
• To add an empty frame, right-click empty canvas with nothing selected and choose Frame.
• To move a frame, drag its title. Every module and note inside it moves with it, along with any smaller frame inside it. Its body lets clicks through to the canvas, so you can still add modules inside it or drag a selection box across it.
• To resize it, drag any edge or corner.
• To rename it, double-click its title.
• To change its color, right-click its title and pick a swatch. The same menu can Select modules inside it, or Delete frame. Deleting a frame leaves its modules where they are.

Notes

• To add a note, right-click empty canvas, choose Note, and type. Click away or press Escape when you're done. A note left empty disappears.
• To edit it, double-click it. Plain text, with **bold** for emphasis.
• To move it, drag it. To change where its lines wrap, drag its right edge.

Selecting, copying and undoing

Click a frame's title or a note to select it, and Shift-click to add to the selection. Delete, Ctrl + C, Ctrl + X, Ctrl + D and Ctrl + V work on selected frames and notes along with any selected modules, so a framed section copies and pastes as a whole. Undo covers adding, moving, resizing, renaming, recoloring, editing and deleting them; typing a frame's name or a note is one step.

Frames and notes are saved with the patch. Versions of Soba from before frames and notes existed open the patch without them.

Groups

A group collapses modules into one node of your own, with jacks where cables crossed into it and the controls you choose on its face. Groups has the whole story; in short:

• Group: select modules and press Ctrl + G, then type a name and press Enter.
• Go inside: double-click the group, select it and press Tab, or click the miniature on its face. A trail at the top of the canvas shows where you are; click it, or press Escape, to go back out.
• Pin a control: inside the group, right-click a knob, dropdown or toggle and choose Show on group.
• Add a jack: inside the group, right-click a port's name and choose Show on group. Right-click a jack to rename it, move it up or down, or remove it.
• Rename: select the group and press F2, or right-click it and choose Rename.
• Ungroup: select the group and press Ctrl + Alt + G.
• Keep it: right-click the group and choose Save to My Modules. It's then in the add menu and quick-add palette of every patch.

A group's right-click menu also has Open, Duplicate, Copy and Delete.

Undo and redo

Undo (Ctrl + Z) and Redo (Ctrl + Shift + Z or Ctrl + Y) cover adding, deleting, moving and bypassing modules, patching and unpatching cables, turning knobs, grouping and ungrouping, adding, renaming, moving and removing a group's jacks, and every change to frames and notes. Hover the toolbar buttons to see which edit is next, such as Move Oscillator, Set SVF Filter Cutoff or Move frame Voice.

A whole drag is one step: turning a knob from 200 Hz to 2 kHz and back undoes in one go. A deleted module comes back with its settings, its cables and its MIDI mappings. Knobs moved by a MIDI controller aren't recorded, and opening a patch starts a fresh history.

Playing

Transport

Nothing sounds until you press ▶ Play (or Shift + Space, which also stops it). ⏹ Stop silences the patch, lets the last of the signal drain out of the cables, and clears echoes and reverb tails, so they don't resume when you play again.

The computer keyboard

The bottom row of letter keys plays like a piano, starting from C4 (middle C), with the sharps on the row above it. The top row and the numbers above it are a second piano, an octave higher, as in a tracker:

The two pianos overlap: , . / play the same notes as Q W E.

The keys play every Note In module in the patch (unless its Source is MIDI), with or without a MIDI controller, in the browser and inside a DAW as well; use its Oct knob to shift it up or down. A Note In with more than one voice plays chords from them. How hard they play is set by its Key Vel knob, MIDI velocity 100 by default. Keys typed into the quick-add box, or held with Ctrl or Alt, don't play notes. While a Chord Sequencer's chord popover is open, the keys write chords into it instead.

MIDI

Choose your controller in the toolbar's MIDI In menu; Soba doesn't connect to one until you do. If the controller isn't listed, plug it in and click 🔄 Refresh at the bottom of the menu. None (Disconnect) lets it go. Disconnecting or switching devices releases any notes that were held. If a controller can't be opened, the reason appears in the status bar.

In the browser, MIDI In starts as a 🎹 Connect MIDI button. A web page may use MIDI only once you allow it, so click it and your browser asks; Firefox first offers a small add-on for the site that allows it. Then the menu lists your controllers, and a controller you plug in later appears by itself, with no Refresh needed. Allowing it lets MIDI Out play your devices too. If you said no, allow MIDI in the site settings (the icon to the left of the address) and click Connect MIDI again. Chrome, Edge and Firefox have MIDI; Safari doesn't, and the button says so.

Two modules listen to the controller: Note In, for one voice or chords, and MIDI Monitor to see what's arriving.

MIDI Learn

Any knob can follow a MIDI controller's knob or fader:

1. Right-click the knob and choose Learn MIDI CC. A purple M badge blinks above it.
2. Move the control on your MIDI controller.

The badge stops blinking and stays, and the knob now follows that control across its full range. Right-click it again to Re-learn MIDI CC or Clear MIDI. Mappings are saved with the patch.

To back out before moving a control, press Escape, or right-click the blinking knob and choose Cancel MIDI Learn. Choosing Learn MIDI CC on a different knob moves learn mode to that knob instead.

Recording

When something good happens (a filter sweep you rode by hand, a lucky generative passage, an improvisation on a MIDI keyboard), press ● Rec or Ctrl + R to keep it. If the patch is stopped, Rec starts it.

While recording, the button turns red, with a slowly pulsing light and the length of the take so far. Press it again, press Ctrl + R, or press ⏹ Stop to end the take. A note pops up in the corner with the take's name and length, and 📂 Show in folder opens it in your file manager.

• What's recorded: exactly what you hear, after the output limiter, sample for sample. It's a 32-bit float WAV at your audio device's sample rate and channel count.
• Where it goes: Music/Soba, named after the patch and the minute you pressed Rec, such as First Sound 2026-10-08 14-03.wav. To use another folder, right-click ● Rec and choose Change…; Open Folder opens it.
• The patch comes too. Every take is saved with the patch beside it, as a .json with the same name, so you can always open the patch that made a recording. It's saved when the take ends, so knobs you rode during the take are saved where you left them.
• Edit freely. Turning knobs, patching cables, even opening another patch: the recording keeps going through all of it.
• Switching the Output device ends the take cleanly. Closing the window while recording asks first, and then saves the take.

Recording runs alongside the audio, never in its way. If your disk ever falls more than two seconds behind, the missing audio is skipped rather than allowed to cause a glitch, and the note tells you how much was lost.

Patches

Patches are saved as .json files holding every module, setting, cable and MIDI mapping.

Examples

The 📚 Examples menu holds ready-made patches on two shelves. Recipes has First Sound, which opens when the app starts, and a patch for each recipe in this manual, each built around one idea. Songs has whole pieces that play themselves from start to end, each with a page of its own. Hover an example to read what it is. Each one is laid out in frames, with notes on how it works and what to try. Saving an example always asks for a file name, so you save a copy and the original stays intact.

Samples

A Sampler keeps the path to its sound file in the patch. A file beside or below the patch is saved by a path relative to it, so the patch's folder can be moved or shared whole. Save As copies samples from anywhere else into a <patch name> samples folder beside the patch, asking first if they come to more than 50 MB. A patch whose sample has gone missing still opens, with the missing file among the load warnings.

A Looper's loop is kept the same way. Saving the patch writes each loop that changed as a WAV into a <patch name> loops folder beside it, asking first if they come to more than 50 MB, and opening the patch brings each loop back, stopped and ready to play. A loop whose file has gone missing is a load warning, and its Looper opens empty. See Keeping the loop.

Sharing a patch by link

🔗 Share copies a link to the patch you have open, short enough for a chat, a slide or a QR code: https://soba.chaps.dev/s/fdb945uF. Whoever opens it gets the patch in their browser, in Soba's web version, with nothing to install: the same modules, cables, knobs, frames and notes, stopped until they press ▶ Play. What they change stays with them.

To keep the link short, the patch is kept on soba.chaps.dev, where anyone with the link can open it. Sharing the same patch again gives the same link. If you'd rather nothing were kept, press Copy the long link instead in the note that says the link was copied. The long link holds the whole patch itself, after the #, so it's never sent to a server, and it works offline. When the link service can't be reached, Share copies the long link anyway, and says so.

A link carries the patch and the samples that come with Soba's examples, and nothing else. If a Sampler plays a file of your own, Share says which files, and offers Save As instead, to send the patch as a folder with its samples (in the browser, Save downloads it as a zip with them).

Long links come to a few thousand characters for most patches. The biggest songs come to 30,000 or so, which some chat apps cut short; email or a document carries them whole. Pasting a Soba link of either kind onto the canvas opens it too, asking first if there are unsaved changes.

Planting it in the garden

The Patch Garden is a page of patches people have planted, each drawn as its own cable diagram, to hear and open. 🌱 Plant, beside Share, puts the patch you have open there. Give it a title (40 characters at most) and, if you like, your name, which is remembered for next time, and press 🌱 Plant or Enter.

Sharing keeps a patch behind a link; planting publishes it. A shared patch can only be found by someone you send its link to. A planted one is listed in the garden for anyone to hear, open and grow their own from. A new plant appears once it's been approved, and the note that says it's planted gives its short link, which plays it right away. Planting the same patch again changes nothing: it keeps its first title.

If you opened the patch from a short link, the garden remembers which, and shows your patch as a branch growing from that one. Change something first: the very patch you were sent is already that link. A patch that plays files of your own can't be planted, as it can't be shared, and Soba offers Save As instead. When the garden is busy or can't be reached, a quiet note says so and goes away by itself; nothing has changed, so plant it again in a while.

Recent patches

🕘 Recent lists the last eight patches you opened or saved, newest first. Hover one to see where it lives. A file that has since been moved or deleted is grayed out. Clear Recent empties the list.

Unsaved changes

While a patch has unsaved changes, the window title starts with a dot (● Lush Pad · Soba), and so does its name in the status bar. Undoing back to the saved state clears the dot. Recording into a Looper counts as a change too.

New, Open, opening an example or a recent file, and closing the window all ask first when there are unsaved changes:

• Save saves the patch (asking where, if it has never been saved), then carries on. Cancelling the save dialog cancels the whole thing.
• Don't Save (Quit Without Saving, when closing) carries on and lets the changes go.
• Cancel, or Escape, goes back to the patch.

Closing the window while a recording is running asks too, even with nothing unsaved, and the prompt shows how long the take is. Quitting stops the take and saves it before the window closes.

Autosave and recovery

Every 30 seconds, a patch with unsaved changes is autosaved alongside the app's settings. Saving the patch, or choosing Quit Without Saving, clears the autosave, so one only survives if Soba closes without asking: after a crash or a forced quit.

The next time the app starts, it offers the patch back. Recover reopens it exactly as it was at the last autosave, still marked unsaved; Discard lets it go. At most, you lose the last 30 seconds of work. An autosave doesn't keep Loopers' loops, though: they come back as last saved with the patch, and the prompt says so.

Recent files, the autosave, your cable style and the window's size and position are kept in the settings file:

• Windows: %APPDATA%\Soba\data\app.ron
• macOS: ~/Library/Application Support/Soba/app.ron
• Linux: ~/.local/share/soba/app.ron

Keyboard shortcuts

Help ▸ Keyboard Shortcuts, or F1, shows these in the app too, with the letter keys drawn as the piano they play.

On a Mac, hold ⌘ Command where these say Ctrl, and Option for Alt. The app writes them that way there.

Canvas

Editing

Knobs

Groups

File

Playing

The letter keys play notes: see The computer keyboard.

Your First Patch

In this tutorial you build a playable synthesizer voice from an empty canvas: an oscillator for the tone, a keyboard to play it, an envelope and a VCA to shape each note, and a filter to color it. It takes about fifteen minutes, and each step adds one idea you'll use in every patch after this one.

Rather learn by doing? The same ground is covered by five short Lessons that run inside Soba (❓ Help › 🎓 Lessons). Each one points at what to do next and waits until you've done it.

Where you'll end up.

Before you start: First Sound

When Soba opens, it loads the First Sound example: a Note In, an Oscillator, an ADSR Envelope and a VCA, already patched to the Audio Output. Press ▶ Play in the toolbar and play the Z to M keys on your computer keyboard. That patch is a smaller version of the one you're about to build, so it's worth a minute of listening first.

To start from scratch, click 📄 New (Ctrl + N). The canvas empties; the status bar says Right-click to add nodes. Make sure ▶ Play is still on (the button reads ⏹ Stop while the patch plays).

Step 1: An oscillator you can hear

Every patch needs a sound source and a way out.

1. Right-click empty canvas and choose Source › Oscillator.
2. Right-click to the right of it and choose Output › Audio Output.
3. Drag from the Oscillator's Out jack (right edge, blue) to the Audio Output's Mono jack. Mono sends the signal to both speakers.

You should hear a steady tone. The Oscillator starts on a sine wave at C4 (261.63 Hz), and its display draws the wave.

If you hear nothing, check that the patch is playing, that the toolbar's Output menu names the device you're listening on, and that the Audio Output's Vol knob isn't at zero.

Now change the Oscillator's Wave menu from Sine to Saw. The tone turns bright and buzzy: a sawtooth contains every harmonic, which gives the filter in Step 5 plenty to work with.

Tip: You can also add modules by pressing Space over the canvas and typing a few letters, such as osc or out, then Enter.

Step 2: Play it from the keyboard

A tone that never changes isn't much of an instrument.

1. Add a Source › Note In to the left of the Oscillator.
2. Patch Note In's Pitch output into the Oscillator's V/Oct input.

Play the bottom row of your computer keyboard: Z is C, X is D, and so on up to M for B, with the sharps on S, D, G, H and J. Note In's piano lights up the notes you hold, and the Oscillator follows.

Pitch is an orange control cable carrying volts per octave: each step of 1.0 is one octave, so the Oscillator stays in tune at every note. But the tone still never stops. For that, you need to shape each note.

Step 3: A VCA to control the level

A VCA (voltage-controlled amplifier) sets the level of whatever passes through it, under the control of another signal.

1. Add a Utility › VCA between the Oscillator and the Audio Output.
2. Patch the Oscillator's Out into the VCA's In.
3. Patch the VCA's Out into the Audio Output's Mono. This replaces the cable that was there, because each input takes one cable.

Nothing changes yet: with nothing patched into its CV input, the VCA lets the sound through at full level. The next step gives it something to listen to.

Step 4: An envelope to shape each note

An envelope draws a shape every time a note is played: it rises when the key goes down and falls when the key comes up.

1. Add a Modulation › ADSR Envelope below the VCA.
2. Patch Note In's Gate output into the envelope's Gate input. Gate is green: it's on while a key is held and off when it's released.
3. Patch the envelope's Out into the VCA's CV input.

Now each key plays a note that starts and stops. The envelope runs through four stages, each with a knob:

• Atk (attack): how long the note takes to reach full level. The default is 10 ms.
• Dec (decay): how long it then takes to fall to the sustain level.
• Sus (sustain): the level held for as long as the key is down.
• Rel (release): how long the note takes to fade after you let go.

Try a pluck: turn Sus all the way down and Dec to about 300 ms, so each note dies away even while you hold the key. Then try a swell: Atk around 1 s, Sus up, Rel around 2 s. The display on the envelope draws each shape as you turn the knobs.

Step 5: A filter to color the tone

A filter removes part of a sound's spectrum. A lowpass filter lets the low frequencies through and cuts the high ones, darkening the tone. This is the heart of subtractive synthesis: start with a bright waveform, then carve it.

1. Add a Filter › SVF Filter between the Oscillator and the VCA.
2. Patch the filter's LowPass output into the VCA's In, replacing the cable from the Oscillator.
3. Patch the Oscillator's Out into the filter's In.

Play a few notes and turn the filter's knobs:

• Cutoff sets where the filter starts cutting. Turn it down and the saw goes dark and muffled; turn it up and the brightness returns. The display draws the filter's response as you turn it.
• Res (resonance) adds a peak at the cutoff, giving the sound a vocal, nasal edge. The default is 0.5. Near the top of its range the filter starts to ring on its own.

Step 6: Let the envelope open the filter

Real instruments are brightest at the start of a note. You can do the same by letting the envelope move the filter's cutoff.

1. Patch the envelope's Out into the filter's Cutoff input. One output can feed any number of inputs, so the envelope keeps driving the VCA too.
2. Turn the Cutoff knob down to about 400 Hz.

Each note now opens the filter and closes it again as the envelope decays. The Cutoff knob stays live and sets where the sweep starts. CV Amt sets how far the envelope carries it: one octave at first. Turn CV Amt up to 3 and each note opens with a squelch. An orange arc on the Cutoff knob's rim shows each sweep, and the number under the knob turns orange to read where the envelope has taken the cutoff.

For a plucky, percussive bass, set Atk to its minimum, Dec to about 200 ms and Sus low. For a slow, brightening pad, lengthen Atk.

The finished patch

[Note In Pitch] ──> [Oscillator V/Oct]
[Note In Gate]  ──> [ADSR Envelope Gate]
[Oscillator Out] ──> [SVF Filter In]
[SVF Filter LowPass] ──> [VCA In]
[ADSR Envelope Out]  ──> [VCA CV]
[ADSR Envelope Out]  ──> [SVF Filter Cutoff]
[VCA Out] ──> [Audio Output Mono]

Save it with 💾 Save (Ctrl + S).

The signal path runs left to right: the oscillator makes the tone, the filter colors it, and the VCA shapes its level. The keyboard and envelope sit off to the side, controlling the others. Nearly every subtractive synthesizer, hardware or software, is built this way.

What you've learned

• Modules are added from the right-click menu or with Space, and connected by dragging from an output to an input.
• Audio (blue) is the sound itself; control (orange) moves things, like pitch and cutoff; gates (green) say when a note is on.
• An envelope through a VCA turns a constant tone into notes.
• One output can drive several inputs, and a cable into a knob's jack moves that knob.

Things to try

• Use separate envelopes. Add a second ADSR Envelope for the filter, also gated by Note In, so brightness and loudness can have different shapes.
• Add velocity. Patch Note In's Velocity into the envelope's Velocity input, then lower its Key Vel knob for quieter notes.
• Add movement. Patch a Modulation › LFO into the filter's Cutoff for a slow sweep. Its Out swings the cutoff CV Amt octaves either way.
• Add space. Put an Effect › Reverb between the VCA and the Audio Output: VCA Out into Reverb In L, then the Reverb's Out L and Out R into the output's Left and Right.
• Watch it. Patch the VCA's Out into a Utility › Oscilloscope as well as the output to see the envelope shape the wave.

Next

• Signal Types explains what each cable color carries and what can connect to what.
• Basic Subtractive Synth takes this patch further, with separate envelopes for brightness and volume. It's in 📚 Examples too.
• The module reference has a page for every module.

Lessons

Lessons are short tutorials that run inside Soba, and you learn by doing each step yourself. A caption sits beside the part of the patch it's about, and that part glows. A ghost pointer shows the move once, then the lesson waits until you've made it. When the patch shows you've done the step, it ticks and moves on to the next one.

A lesson's caption and its ghost pointer, showing the cable to make.

Open them from ❓ Help › 🎓 Lessons. Each lesson starts from its own patch, or from an empty canvas, so if the patch you have open has unsaved changes, Soba first asks whether to save them.

The lessons

Take them in order. Each one builds on the one before, and the five together cover what Your First Patch explains on paper.

Taking a lesson

• Do it your way. A step checks the patch, not how you got there. A cable dragged from either end counts. So does a module added from the right-click menu or from the Space palette, and a knob turned by dragging or by a cable. If you do a step before the lesson asks for it, the lesson ticks it off as soon as it gets there.
• 👁 Show me plays the ghost pointer's move again.
• Lost the part? At the start of a step, the view pans to bring the part it's about into sight. After that, the view is yours to move.
• Leave at any time. Click × on the caption. The lesson goes, and the patch stays exactly as you left it: an ordinary, unsaved patch to keep playing or to save. Opening another patch or example also ends the lesson.
• When you're done, the caption offers the next lesson.

From the command line

soba --lesson first-sound starts a lesson as Soba opens, and in the browser, so does ?lesson=first-sound on the end of the address. The name is the lesson's file in the lessons folder of the source, without its .txt.

Writing a lesson

A lesson is a text file in lessons/. Each line says something, points at something, shows a move or waits for one, and each wait closes a step:

title First Sound
about An oscillator, an output and one cable: a sound from nothing

say Drag from the Oscillator's **Out** jack to the Audio Output's **Mono** jack.
point osc.sine out:Out
point output.audio in:Mono
show drag osc.sine out:Out to output.audio in:Mono
wait connect osc.sine Out -> output.audio Mono

Parts are named the way capture scripts name them. Steps can wait for a module, a cable, a knob's value, the transport, notes played or a cable probed. The whole format is described at the top of src/app/lesson.rs, and the tests check every shipped lesson against the modules it names.

Signal Types

Every jack in Soba has a signal type, and every type has a color. The color of a jack tells you what it sends or expects, and a cable takes the color of the output it comes from, so you can read a patch's signal flow at a glance.

Underneath, audio, control and gate signals are all the same thing: a stream of numbers at the audio sample rate. The type describes what the numbers mean, and it decides which jacks a cable may connect (see Which types connect).

Audio

Audio is the sound itself: a waveform swinging between −1.0 and 1.0, at your audio device's sample rate (typically 44.1 or 48 kHz). Oscillators make it; filters, the VCA, the Mix, the Mixer and the effects shape it; the Audio Output sends it to your speakers.

Keep audio within ±1.0 and it passes through the output untouched. Louder than that and the output stage's limiter, on by default, catches the peaks before they clip. It's a safety net, though, not a mixing tool. When several voices or oscillators add up, bring the level down with a VCA or the Mixer.

Control

Control signals, often called CV (control voltage), move a parameter instead of making a sound. They come from envelopes, LFOs, the sequencer and Note In, and they go into jacks such as a filter's Cutoff or an oscillator's FM.

A control signal is either:

• Unipolar, from 0.0 to 1.0. An envelope is unipolar: it rises from nothing to its peak and falls back.
• Bipolar, from −1.0 to 1.0. An LFO in bipolar mode swings both ways around the center, which suits vibrato or a sweep around a set cutoff.

Most control signals change slowly, but nothing stops them running at audio rate. Patch an oscillator into another oscillator's FM input and you have FM synthesis.

Pitch: 1 per octave

Pitch travels as a control signal on a 1-per-octave scale, the digital version of the 1 V/octave standard in hardware modular. Each 1.0 is an octave:

One semitone is 1/12. The Pitch outputs of Note In and the Step Sequencer both use this scale, so they play an Oscillator in tune with nothing to calibrate. Both filters take their Cutoff CV on the same scale, so a pitch cable patched into Cutoff makes the filter track the keyboard exactly.

Gate

A gate is either on (1.0) or off (0.0). It says when: a key held down, a step in a sequence, a tick of the clock. The ADSR Envelope, for example, starts its attack the moment its Gate goes on (the rising edge) and starts its release the moment it goes off (the falling edge).

A short gate is often called a trigger. Modules that only care about the moment a gate begins, such as the clock input of the Step Sequencer or the Trig input of Sample & Hold, treat both the same way.

Gates come from the Gate outputs of Note In, the Clock and the Step Sequencer (which also has an EOC, end-of-cycle, gate).

MIDI

MIDI is the purple signal type, and today no jack uses it. MIDI from your controller doesn't arrive over a cable. It goes straight into the modules that listen for it: Note In and the MIDI Monitor. Note In turns notes into ordinary Pitch, Gate and Velocity signals that the rest of the patch understands, and does the same for your computer keyboard.

Bus

Bus is the pale steel signal type. One Bus cable carries a Mixer's whole mix and its sends from its Chain Out to the next Mixer's Chain In, so Mixers can be chained for more than four channels. It connects only to another Bus: no audio, control or gate jack takes it, and a Bus jack takes nothing else.

Which types connect

Same-type connections always work. A few cross-type connections work too, and the rest are refused:

Allowed cross-type connections pass the signal through unchanged. An audio cable into a control input is the raw waveform; a gate into a control input is exactly 0.0 or 1.0.

If you drop a cable on a jack that can't take it, Soba removes the cable and the status bar at the bottom of the window explains why, for example Control cannot connect to Gate.

Signal color and category color

Don't confuse the two palettes. Jacks and cables are colored by signal type, as above. The bar across the top of each module is colored by the module's category: blue for Sources, teal for Filters, and so on. See the Module Overview.

See also

• Connections: patching, and reading the signal in a cable
• Polyphony: cables that carry up to eight voices

Connections

A cable carries a signal from one module's output to another module's input. Patching is the whole of Soba: the modules decide what can happen, and the cables decide what does.

Patching a cable

Outputs are on the right edge of a module and inputs are on the left. To connect two modules:

1. Press on an output jack and drag. A cable follows the pointer.
2. Release over an input jack on another module.

You can also start from an empty input and drag back to an output.

To unplug a cable, press on the input end and drag it away. The cable comes off the jack and follows the pointer: drop it on another input to re-patch it, or on empty canvas to remove it. Deleting a module removes all of its cables.

Patching and unpatching are recorded in the undo history, so Ctrl + Z puts back a cable you pulled by mistake.

The rules

• An output can feed any number of inputs. Each one receives the full signal, with no loss of level.
• An input takes one cable. Patching a second cable into an occupied input replaces the first.
• Signal types must be compatible. Audio and control connect to each other freely, and a gate can drive a control input, but a gate input only accepts gates. The full table is on Signal Types. If a cable can't connect, Soba removes it and the status bar explains why.
• A module can't patch into itself, and signals don't loop. Soba processes the patch in one direction, from sources to the output, so a cable that would feed a module's output back into its own input, directly or through other modules, is refused, and the status bar names the modules round the loop. A patch file holding such a cable opens without it and says which. The Mixer's Return jacks and the Clock's Tempo jack are the exceptions: they hear a loop one audio block late. For echoes and feedback, use the Delay's Feedback knob.

Empty jacks

An input with nothing patched in isn't necessarily zero. Each jack has a resting value chosen so the module does something sensible on its own. A VCA with nothing in its CV jack plays at full level, for example, so you can hear its input before you add an envelope.

The stereo effects work the same way. Patch only their left input and they treat the signal as mono, feeding both sides, so a mono voice into the Reverb still gets a stereo tail.

Knobs with jacks

Many parameters have both a knob and an input jack of the same name, such as Cutoff on the filters or Time on the Delay. With nothing patched, the knob sets the value. Patch a cable in and the signal modulates the parameter around the knob: the knob sets the center, and the cable moves the value up and down from there.

How far a cable moves the parameter depends on the parameter, and each module page gives the scale. On both filters, for instance, the Cutoff CV is in octaves: at the default CV Amt of 1, +1.0 doubles the cutoff and −1.0 halves it. With Cutoff at 1 kHz, a bipolar LFO sweeps the filter from 500 Hz to 2 kHz. Some inputs have a knob of their own that sets how far they reach, as CV Amt does here.

A small dot above the knob shows that a cable is patched in: orange once the signal is arriving, green while it's connected but hasn't reported a value yet. You can keep turning the knob to move the center while the cable plays.

A knob mapped to a MIDI controller shows a purple M badge instead of the dot.

Reading the signal in a cable

While the patch plays, each cable shows what its signal has been doing over the last few seconds. The signal travels from the output to the input at a steady pace, so the end of the cable nearest the output is now and points further along are moments ago.

• Brightness is strength. A cable lights up with its signal and goes dark when it's silent. A note becomes a packet of light that runs down the wire. The packet's length is how long the note lasted, and an audio cable's light fades out as the note releases.
• Marks point the way. Chevrons ride the light from output to input, so you can read a patch's direction even in a still frame. Each mark keeps the brightness of the moment it left the output.
• Control cables draw their shape. On orange cables the light swings to one side of the cable or the other with the signal's value. An LFO shows its waveform traveling down the wire, an envelope its rise and fall, a sequencer its steps.
• Gates are on or off. A green cable shows bright packets with hard edges, one per gate.

When you press Stop, the last of the signal drains out of the cables rather than vanishing.

To change the marks, open Cables in the toolbar and choose Chevrons, Dots or Comets. Soba remembers your choice.

Polyphonic cables are drawn as a bundle of strands, one per voice. See Seeing polyphony.

Laying out a patch

A patch is easier to read, and easier to come back to, when it follows a few habits:

• Run the audio path from left to right, ending at the Audio Output.
• Put modulation sources (envelopes, LFOs, the clock) above or below the audio path, so their cables reach across it rather than tangling with it.
• Keep each voice's modules together.

               [LFO] ──┐
                       ▼ Cutoff
[Oscillator] ──> [SVF Filter] ──> [VCA] ──> [Audio Output]
                                    ▲ CV
               [ADSR] ──────────────┘

When there's no sound

Work backward from the output:

1. Is anything patched into the Audio Output? The Mono input is the simplest place to start.
2. Is the transport running? Press Play in the toolbar.
3. Is the VCA opening? If its CV jack is patched to an envelope, the envelope needs a gate. Play a note.
4. Is the envelope getting a gate? Its Gate cable should light green when you play.
5. Follow the light. A cable that stays dark carries silence. The last lit cable before the dark ones points to the module to check.

See also

• Signal Types: what each color carries, and which types connect
• Polyphony: one cable, up to eight voices
• Interface Overview: every editing action and shortcut

Polyphony

A cable in Soba can carry up to eight channels at once, one per voice. Patch a chord through a single chain of modules and every note gets its own oscillator, its own filter and its own envelope. The result is a chord of separate voices, each shaping itself, rather than one voice playing a blend of notes.

This is the approach VCV Rack takes. You don't build eight copies of your voice. You build one, and the cables carry the voices through it.

Where voices come from

The Note In module is where polyphony starts when you play. Its Voices knob (1 to 8) sets how many channels its Pitch, Gate and Velocity cables carry, and each note you play is given a channel of its own. It plays from your computer keyboard as well as from MIDI.

In a patch that plays itself, the Chord Sequencer starts it instead. It sends a progression's chords down the same Pitch, Gate and Velocity cables, one channel per note, so a voice built for Note In plays it unchanged.

Polyphonic modules

These modules run one voice per channel of their widest input:

Their outputs carry as many channels as their widest input. The knobs are shared: turning Cutoff moves every voice's cutoff.

Seeing polyphony

A polyphonic cable is drawn as a bundle of strands, one per channel, in a dark sheath that narrows where it plugs into a jack. The bundle widens as the channel count grows, so you can tell mono from poly at a glance at any zoom.

Each strand lights with its own voice. Hold a chord and light runs along the strands of the notes you're playing while the rest stay dark. When you let go, each note's release fades down its own strand. The glow around the bundle grows with the number of voices playing, so a chord glows brighter than a single note. See Reading the signal in a cable.

Output labels show the channel count too: Out ×8 means that output carries eight channels. The count comes from the running patch, so press Play to see it. Once shown, it stays while the transport is stopped.

Mixing mono and poly

A mono cable into a polyphonic module is shared by every voice. One LFO into a polyphonic filter's Cutoff sweeps all the voices together. To move each voice on its own, use a polyphonic source such as the envelope or Note In's Velocity.

A polyphonic cable into a mono module is folded down to one channel:

• Audio inputs hear every channel summed. That's why a polyphonic voice can go straight into an effect or the Audio Output.

The Mixer is the exception. It hears each voice of a polyphonic cable apart, and its per-channel Width knobs fan them out across the stereo field, so a chord opens up instead of sitting in the middle. With Width at 0% it sums them like any mono module.

• Control and gate inputs take the first channel only, since adding CVs together rarely means anything useful.

Voices add up, so a four-note chord is roughly four times as loud as one note. Leave headroom with the VCA's Level or the Mixer.

A polyphonic voice

[Note In Pitch]      ──> [Oscillator V/Oct]
[Note In Gate]       ──> [ADSR Gate]
[Note In Velocity]   ──> [ADSR Velocity]
[Oscillator Out]     ──> [SVF Filter In]
[ADSR Out]           ──> [SVF Filter Cutoff]
[SVF Filter LowPass] ──> [VCA In]
[ADSR Out]           ──> [VCA CV]
[VCA Out]            ──> [Reverb In L]
[Reverb Out L / R]   ──> [Audio Output Left / Right]

Every module up to the VCA runs one copy per voice. The Reverb hears the voices summed, as a single stereo instrument.

Cost

Each voice is a full copy of the module, so eight voices use about eight times the CPU of one. If a patch strains your computer, turn down Voices on the Note In module. With mono cables, a polyphonic module runs a single voice and costs no more than before.

Tempo and Sync

A patch has one tempo and one beat, and modules that care about time share them. Turn the Clock's BPM and the echoes of a synced Delay move, a synced LFO speeds up, and every sequencer the Clock steps keeps pace. None of them needs a cable from the Clock to know.

The transport

The patch's first Clock is its transport. Before each block of audio, Soba reads three things from it and hands them to every module:

• the tempo, in beats per minute;
• the beat: how many beats have passed since the Clock started, counted from its downbeat;
• whether it's playing: the beat moves while the Clock runs, and holds while it's stopped.

A patch without a Clock has no transport. Synced modules then assume 120 BPM, and a synced LFO keeps its own beat.

If a patch has more than one Clock, the transport is the first one in processing order, which is usually the one nothing else feeds. Other Clocks still pulse at their own settings; they just don't set the patch's tempo.

The tempo doesn't have to stay put. A CV in the Clock's Tempo jack bends it, and everything synced bends with it: an Arranger lane there slows the song into its last chord. See Tempo CV.

For a pulse slower than the beat, such as once every four bars, divide the one Clock with a Clock Divider rather than adding a second, slower Clock. A divider counts the Clock's pulses, so it stays on the beat at any tempo, and it can't become the transport by accident.

Two kinds of sync

Following the tempo. The Delay's Sync turns a note length into a time: a 1/8 at 120 BPM is 250 ms. It needs only the tempo.

Following the beat. A synced LFO reads where the beat is and works out its phase from that. A 1 bar LFO is at the start of its cycle on every downbeat, a quarter of the way through on beat 2, and so on. Because it reads the beat rather than counting its own cycles, it can't drift, however long it plays, and every synced LFO in the patch moves in step. When the Clock starts from the top, they all start from the top with it.

That's the difference from patching a Clock's Gate into an LFO's Sync input. A gate only restarts the cycle at each pulse, and between pulses the LFO runs at its own Rate, which you have to set to match.

Playing in time with other gear

Set the Clock's Source to MIDI and it follows a MIDI clock master: a DAW, a drum machine, a hardware sequencer. The master sends 24 clock ticks per beat, plus Start, Stop and Continue messages for its transport. The Clock:

• counts the ticks, so its beat is exactly the master's, tick by tick;
• measures the tempo from their spacing, averaged over the last two beats, so the knob reads the master's BPM and synced modules follow it;
• starts, stops and continues when the master does. Start fires the Clock's Reset output, so patched sequencers start from step 1 on the downbeat.

The whole patch then plays in the master's time: sequencers step on its grid, LFOs sweep with its bars, and the Delay echoes on its eighth notes. See Following MIDI clock for setting it up.

Set Source to Link instead, and the Clock joins an Ableton Link session on the network. There's no master: Live, Bitwig, phone apps and other copies of Soba all share one tempo and one bar line, and any of them can change the tempo or start and stop the others. The Clock:

• plays at the session's tempo, and its BPM knob turns to match when another app changes it. Turning the knob changes the tempo for everyone;
• lines up its bars with the session's, so beat 1 is everyone's beat 1;
• starts and stops with the session. Ticking its Run starts every app in it, on the next bar if others are already there.

Where MIDI clock carries the master's time down a cable, Link has every app keep the same time from the network's shared clock. Each app allows for its own audio delay, so they agree on when a beat reaches the speakers, not just when it's computed. See Playing in a Link session.

Leading other gear

It works the other way round too. Turn on Clock in a MIDI Out and the patch's Clock becomes the master: a DAW, a drum machine or an arpeggiator set to follow MIDI clock plays in Soba's time. MIDI Out:

• sends Start when the Clock starts from the top, or on the first downbeat after a count-in;
• sends 24 ticks per beat, each placed on the beat to the sample, and sent as the audio beside it reaches your speakers, so the other gear and Soba's own sounds line up;
• sends Stop when the Clock stops, and Continue, after a Song Position saying where, when it plays on from there.

A follower measures the tempo from the ticks' spacing, so change the Clock's BPM and it follows. Don't send clock back to the gear the Clock follows: two clocks can't lead one another. A Clock playing in a Link session can lead MIDI gear, though. The same MIDI Out can also play the device's notes.

Precision

The Clock counts its beat precisely enough that every pulse lands within a sample of where it belongs, even after ten minutes, so a slow phrase clock and a fast sixteenth clock started together stay together.

Modules read the transport once per block of audio (a few milliseconds). Within the block, a synced LFO moves on at the tempo it read. When the beat jumps, as when the Clock restarts or a MIDI master suddenly changes tempo, a synced LFO can be up to one block late in following it. On a steady tempo, and from the next beat on, it's exact.

Groups

A good voice (an oscillator, a filter, a VCA and an envelope) is the same few modules in patch after patch, and three voices side by side turn into a wall of cables. A group collapses modules into one node of your own. It has jacks where cables crossed into and out of the selection, plus any you add, and the controls you choose to keep on its face. Open it to work on what's inside. Save it to My Modules, and it's in the add menu of every patch.

Voice holds an oscillator, an envelope and a VCA. Its face shows them in miniature, with the oscillator's Wave and four knobs pinned.

Making a group

Select some modules and press Ctrl + G, or right-click one of them and choose Group. They collapse into one rose-colored node where the top-left corner of the selection was. Type a name and press Enter.

Every cable that crossed the edge of the selection becomes a jack:

• An input jack for each output outside the group that fed something inside it. If one output fed several modules inside, as a keyboard's Gate might feed two envelopes, that's one jack.
• An output jack for each output inside the group that fed something outside it.

Jacks are named after the port inside, numbered if two names would be the same (In, In 2). They're colored by the signal they carry, like every jack, and ordered top to bottom by where their modules sit. Grouping doesn't change the sound: every module hears exactly what it heard before.

To take a group apart, select it and press Ctrl + Alt + G, or right-click it and choose Ungroup. Its modules come back out where the group was, laid out as they were, and every cable through its jacks becomes a plain cable again.

Inside a group

Double-click a group, select it and press Tab, or click the miniature on its face, to go inside. A trail at the top of the canvas shows where you are, such as First Sound › Voice. Click any name in the trail to go back out to it, or press Escape to go up one level.

Going in, the view zooms into the group's miniature, and the inside grows out of it, each module coming from where the miniature showed it. Going back out with Escape, the inside shrinks back into the miniature on the group's face. Hold Shift as you go in or out to skip the zoom. Clicking the trail always takes you straight there.

Inside Voice. Inputs carries what's plugged into the group's jacks outside; Outputs sends its signals back out.

Inside, two nodes stand for the group's jacks:

• Inputs has an output for each input jack. Whatever is plugged into that jack outside comes out here.
• Outputs has an input for each output jack. Whatever you plug in here comes out of that jack outside.

Everything else works as it does at the top of the patch. Modules you add, paste or drop from the palette land inside the group, and you can group modules inside a group too. The cables from Inputs show the signal arriving from outside. Frames and notes belong to the top level of the patch, so they're hidden while you're inside a group.

Changing a group's jacks

A group starts with the jacks its cables gave it, and you can change them whenever you like. Inside the group, right-click a port's name:

• Show on group, on an output or an unplugged input, gives the group a new jack named after the port, wired to it through Inputs or Outputs. A filter's Cutoff shown this way can be modulated from outside, and a second output can be brought out beside the first. An input that's already plugged in inside the group can't take a jack too, so the item is greyed.
• Hide from group, on a port wired to one of the group's jacks, unplugs it. If that leaves the jack carrying nothing inside, the jack goes, and so does any cable into it outside. If the jack still feeds another module, as a shared Gate might, it stays.

Right-click a jack itself, on the group's node or on Inputs or Outputs inside, for its own menu:

• Name opens with the jack's name selected, so you can type a new one and press Enter. A Gate jack might become Trig, or Out might become Wet. The group's node and its Inputs or Outputs change together, and every cable stays plugged in. If another jack on that side already has the name, the new one is numbered.
• Move up and Move down move the jack one place along the group's jacks, with its cables.
• Remove jack takes the jack away, with its cables inside and out.

New jacks go at the bottom of the group's jacks. Inside a group within a group, an inner group's jacks are ports like any other, so you can show them on the group around it. Undo covers adding, renaming, moving and removing jacks, and a saved patch keeps them.

The face

The group's face shows a miniature of what's inside: each module as a small card in its header color, wired as it is. Hover it to see Open ▸, and click to go inside.

Below the miniature are any controls you've pinned to the group. Inside the group, right-click a knob, a dropdown or a toggle and choose Show on group. It appears on the group's face, in its module's color: dropdowns and toggles in a row of their own, with the knobs under them. It's the module's own control, not a copy:

• Turning or changing either one changes both, and undo takes back either.
• A MIDI Learn mapping on a knob works from either place. Dropdowns and toggles can't learn a CC, inside or on the face.
• If a cable inside the group moves a knob, the face shows it moving. A toggle with a jack, such as the Slope's Cycle, is greyed on the face while a cable sets it.

Controls from modules nearer the face come first, then top to bottom by where the modules sit, then in each module's own order.

Right-click a control on the face and choose Hide from group to take it off. If the group is inside another group, Show on outer group too puts it on that group's face as well.

Naming a face control

A pinned control wears its module's short name, such as FM, CV Amt or 2. That says what the knob is, not what it does for this group. To name it, right-click it on the face. The menu opens on Name with the current name selected: type a new one and press Enter. An electric piano's FM might become Tine, and a mixer's 2 might become 4'.

• The name shows only on the face. Inside the group, the module keeps its own names, so you can still see which knob is which when you open it.
• Hover a named control to see what it drives, such as Tine: Oscillator FM Depth.
• Clear the field and press Enter, or type the module's own name, to go back to it.
• The name goes with the control to an outer group's face, and into a saved patch or My Modules. Undo takes it back.

My Modules

Right-click a group and choose Save to My Modules. The group is saved as a file named after it, in Documents/Soba/My Modules.

Saved groups come first in the quick-add palette (Space), under My Modules, and in the add menu's My Modules submenu. Each one is described by its jacks and size, such as In, Gate, Velocity → Out · 2 modules. Choosing one adds a copy of the whole group at the cursor, with its modules, cables, jacks and pinned controls.

Saving a group under a name that's already there updates it. The folder holds ordinary patch files, so you can copy them to another computer or share them. To find the folder, choose Open folder at the bottom of the add menu's My Modules submenu.

The Library

The Library is a shelf of ready-made groups that ships with Soba. Each one is an ordinary group: add it, play it from the controls on its face, then open it to see how it's made and change anything inside. Find them under Library at the bottom of the add menu, sorted into sections, or type a name or lib into the quick-add palette.

The voices share a shape: plug a Note In into Pitch, Gate and Velocity, and Out into a mixer or the output. They're built from polyphonic modules, so Note In, or a Chord Sequencer, plays chords through any of them. The String Machine's chorus is the one exception: like a real string machine's ensemble, it hears the whole chord at once. They're also levelled to match, so swapping one voice for another doesn't jump in volume.

A Library group you've changed can be saved to My Modules under its own name, like any other group.

Editing and undo

Copy, paste, duplicate and delete treat a group as a whole: deleting one deletes everything inside it. Undo covers grouping, ungrouping, renaming, pinning, naming face controls, changing jacks and every edit you make inside a group. Undoing an edit that was made inside a group shows you that group as it happens.

How the sound works

The audio engine never sees a group. It only hears the modules and the cables between them, followed through any number of jacks. Groups use no CPU, and grouping or ungrouping never interrupts the sound. A grouped patch plays sample for sample what the ungrouped patch plays, and the test suite checks this for every example.

Groups are saved in the patch file, each holding its own modules, cables and groups. A patch with groups needs this version of Soba or later to open. A patch without groups is saved just as before, so older versions still open it.

Module Overview

Soba has 44 modules in six categories. Each category has its own header color, so you can tell what a module is for at a glance across a crowded patch. The categories match the right-click menu and the quick-add palette, and the modules are listed here in the order the menu shows them.

The ID is the name a patch file uses to refer to the module.

Categories

Source

Blue header. Modules that start a sound or a note: the oscillator, the noise source, the drum voice, the resonator, the sampler, the chopper and the cloud, the audio input, and the modules that turn your playing into pitch and gate signals.

Filter

Teal header. Modules that shape a sound's tone by removing or emphasizing frequencies. Both can be bypassed.

Modulation

Orange header. Sources of movement: control signals that change other modules' parameters over time.

Effect

Cyan header. Processors for finished sound. Every effect can be bypassed.

Utility

Gray header. The plumbing of a patch: levels, timing, sequencing, looping, and tools for seeing what a signal is doing.

Output

Purple header. Where the patch leaves Soba: for your speakers, for other instruments, or for Seoul's visuals.

Header colors describe what a module is. The colors of its jacks and cables describe the signals it handles, which is a separate palette: see Signal Types.

Polyphonic modules

The Oscillator, Noise, Drum, Resonator, both filters, the ADSR Envelope, Slope, the VCA, the Attenuverter, Mix, Sample & Hold and the Quantizer run one voice per channel when a polyphonic cable reaches them. Everything else treats a polyphonic cable as one signal. Note In and the Chord Sequencer are where polyphonic cables start. See Polyphony.

Common signal chains

The classic subtractive voice: an oscillator, a filter to shape its tone, and a VCA opened by an envelope.

[Note In Pitch]      ──> [Oscillator V/Oct]
[Oscillator Out]     ──> [SVF Filter In]
[SVF Filter LowPass] ──> [VCA In]
[VCA Out]            ──> [Audio Output Mono]
[Note In Gate]       ──> [ADSR Gate]
[ADSR Out]           ──> [VCA CV]

Add space with effects after the VCA, so they process the shaped note:

[VCA Out]                  ──> [Stereo Delay In L]
[Stereo Delay Out L / R]   ──> [Reverb In L / R]
[Reverb Out L / R]         ──> [Audio Output Left / Right]

Drive a voice from a sequence instead of a keyboard:

[Clock Gate]           ──> [Step Sequencer Clock]
[Step Sequencer Pitch] ──> [Oscillator V/Oct]
[Step Sequencer Gate]  ──> [ADSR Gate]

Choosing a module

Oscillator

Module ID osc.sine · Category Source

Three detuned voices of a square wave, an LFO sweeping its pulse width through PWM: the trace is Out as it plays, and PW follows the CV. Under it, the tune, timbre and ensemble rows.

The Oscillator is the main sound source in Soba. It is a VCO (voltage-controlled oscillator): a tuned waveform whose pitch follows a keyboard, an LFO or another oscillator.

Beyond the four classic waveforms, it has the features that make an oscillator an instrument:

• a tune section in octaves, semitones and cents;
• hard sync to another oscillator;
• through-zero linear FM and exponential FM;
• a sub-oscillator one octave down;
• unison of up to seven voices, with stereo spread. Seven detuned saws is the classic supersaw.

The display draws a cycle of the wave at the Pulse Width, and reads the pitch the tune section sets. With more than one unison voice, the others are drawn faintly over it, sliding along the cycle at the rate each beats against the pitch: a gentle Detune drifts, a wide one shimmers. With Sub patched, two cycles show, with the sub's square under them.

While the patch plays, what Out really carries is drawn over that shape, lit, and the shape steps back to a faint guide. Each trace starts where the cycle does and keeps the time scale of the cycle the knobs set, so a note V/Oct takes an octave up fits two cycles in, and one an octave down shows half a cycle: a melody squeezes and stretches the wave. PWM sweeps the edge, FM wrinkles the wave, Sync cuts each cycle short, and unison voices beat in it as they sound. Older traces fade behind the newest, like a scope's phosphor, so a moving wave leaves a soft trail. With V/Oct or Exp FM patched, the top reads the note being played. When the sound stops, the shape comes back.

Every waveform is band-limited. Each voice runs at twice the sample rate with polyBLEP corrections on its edges and polyBLAMP corrections on its corners, then a halfband filter brings it back down. A 5 kHz saw's aliasing sits around -80 dB, so high notes and sync sweeps stay clean.

Inputs

Outputs

Parameters

The knobs sit in three rows: tune, timbre and ensemble.

With every tune knob at 0, the oscillator plays C4 (261.63 Hz). Note In sends 0.0 for C4, so it plays in tune with nothing else to set. MIDI note 69 plays 440 Hz to within a tenth of a cent.

Pitch is smoothed in octaves, not Hz, so a jump of an octave up takes as long as an octave down.

Waveforms

The preview at the top of the node draws one cycle of the selected waveform, and follows the PW knob on the square.

• Sine is a pure tone with no harmonics: sub-bass, FM carriers and modulators, flute-like tones.
• Saw has every harmonic, falling as 1/n: classic leads and basses, strings, brass. It is the richest source for filtering, and the one to use for a supersaw.
• Square has odd harmonics only, for hollow, woody, clarinet-like tones. Pulse width reshapes it, from the square at 0.5 to thin and nasal near 0.1 or 0.9.
• Tri (triangle) has odd harmonics that fall away fast: softer than the square, brighter than the sine.

Tune section

Oct and Semi set the note; Fine trims it in cents. To tune a second oscillator a fifth up, set Semi to +7. To make it beat slowly against the first, add a few cents of Fine.

Hard sync

Patch another oscillator's Out into Sync:

[Osc 2 Out] ──> [Osc 1 Sync]

Every time Osc 2's waveform rises through zero, Osc 1 starts its cycle again. The result repeats at Osc 2's pitch, but its tone comes from Osc 1's pitch. Tune Osc 1 above Osc 2 and sweep its pitch (a slow LFO or envelope on V/Oct or Exp FM) for the classic tearing sync sweep.

The reset itself is band-limited, so sync sweeps don't fizz with aliasing.

Through-zero FM

The FM input multiplies the pitch by 1 + FM × input, where FM is the knob:

• At an FM of 1, an input of -1 just reaches 0 Hz.
• Past 1, the frequency swings through zero and the waveform runs backward for a moment, instead of stalling at 0 Hz.

That keeps the average pitch where it was, so deep FM stays in tune and keeps the bright, glassy character of DX-style FM. Because the depth is relative to the pitch, the timbre stays the same as you play up the keyboard.

[Osc 2 Out] ──> [Osc 1 FM]
[Osc 1 Out] ──> [VCA In] ──> [Audio Output]

• Sine into sine gives the cleanest FM tones.
• Whole-number pitch ratios (Semi +12, or +19 for 3:1) sound harmonic.
• Other ratios sound bell-like and metallic.
• Shape the modulator's level with an envelope (through a VCA) to make the brightness decay like a struck bell.

The FM Synthesis recipe builds a complete patch around this.

Exponential FM

Exp FM works like a second V/Oct input with its own depth knob. An LFO into it gives a vibrato that's even in pitch: the same width in cents on every note. Keep the depth small (Shift-drag the knob for fine steps): 0.02 octaves is about ±24 cents. At audio rates it gives a rougher, less pitch-stable kind of FM than the linear input.

Sub-oscillator

Sub is a square wave one octave below the tuned pitch. It divides the main oscillator's own cycle, so it follows V/Oct, FM and sync. Mix it in under a saw for weight:

[Oscillator Out] ──> [Mix In 1]
[Oscillator Sub] ──> [Mix In 2]
[Mix Out] ──> [Ladder Filter In]

Unison and supersaw

Voices stacks copies of the oscillator, each slightly detuned:

• Detune sets how far apart they are. Its curve is gentle at the bottom: 20% puts the outer voices about ±4 cents apart, 40% about ±16 cents, and 100% a full ±100 cents.
• The voices bunch toward the middle, close to Roland's JP-8000 supersaw. The spacing is deliberately uneven, so the voices never beat in lockstep.
• Each voice starts at a different point in its cycle, so the stack doesn't open with one loud spike.
• Out sums all the voices at about the loudness of one voice.
• Out L and Out R pan the voices across the stereo field, outer voices widest. Spread sets the width.

For a supersaw: Wave on Saw, Voices at 7, Detune about 40%, and Out L and Out R into the output's Left and Right.

Pulse-width modulation

With the square wave selected, modulate the pulse width with an LFO:

[LFO Out] ──> [Oscillator PWM]

Slow rates give a chorus-like shimmer; fast rates, a more dramatic wobble in the tone.

The PW knob stays where you set it, as the centre of the sweep. An orange arc on its rim runs out to a bead at the width the oscillator is playing, and the number under it reads that width in orange.

Patch examples

Sync lead

[Note In Pitch] ──> [Osc 2 V/Oct]
                ──> [Osc 1 V/Oct]   (Osc 1 Oct +1)
[Osc 2 Out] ──> [Osc 1 Sync]
[ADSR Out] ──> [Osc 1 Exp FM]
[Osc 1 Out] ──> [SVF Filter In]

Each note sweeps Osc 1's pitch up with the envelope, while sync holds it to Osc 2's pitch.

Supersaw pad

[Note In Pitch] ──> [Oscillator V/Oct]   (Saw, 7 voices)
[Oscillator Out L] ──> [Reverb In L]
[Oscillator Out R] ──> [Reverb In R]
[Reverb Out L] ──> [Audio Output Left]
[Reverb Out R] ──> [Audio Output Right]

Polyphony

The Oscillator is polyphonic. Patch a polyphonic Pitch cable from Note In into V/Oct and each note gets its own oscillator, with its own phase, sync and unison stack. The knobs are shared by every voice. Unison multiplies the cost: eight notes of a seven-voice supersaw is 56 oscillators. See Polyphony.

Notes

• Older patches load at the same pitch. Their Frequency setting is split into Oct, Semi and Fine. FM Depth, which used to be in Hz, becomes the matching index at that pitch. A MIDI controller mapped to Frequency moves to Oct over the same range. The old Frequency input jack is gone; a cable into it is skipped with a load warning.
• Band-limited edges overshoot a little. Saw and square peak at about 1.3 for a few samples after each edge. This is ringing near 24 kHz, which is inaudible, and any filter or the output stage takes it away.
• The tune section reaches from about 7.7 Hz to 8.9 kHz. Use V/Oct or Exp FM to go further.

Related modules

• LFO for vibrato and PWM
• SVF Filter to shape the oscillator's harmonics
• Ladder Filter, the fat, saturating 24 dB alternative
• VCA and ADSR Envelope to turn a tone into notes

Noise

Module ID source.noise · Category Source

White and Pink are patched, so their lines are lit; Brown, unpatched, is dimmed.

Noise is a sound with no pitch: every frequency at once, at random. Through a filter and an envelope it becomes a snare, a hi-hat, a breath, wind or surf. Sampled by a clock, it becomes a melody that never repeats.

The module makes three colours of noise, and a fourth output that wanders smoothly at modulation speed:

• White: equal energy at every frequency. Bright, hissing, like steam or an untuned radio.
• Pink: falls 3 dB per octave, so every octave holds the same energy. To the ear it is the most balanced noise: rain, surf, a waterfall.
• Brown: falls 6 dB per octave. A deep, soft rumble, like wind or thunder far away. The name is for Robert Brown, whose random walk of pollen grains it imitates, not the colour.
• Random: a smooth random voltage that glides to a new value Rate times a second.

Noise is polyphonic. Patch a polyphonic cable into Level or Rate and each voice plays noise of its own, so a four-note chord of filtered noise is four different hisses, not one copied four times.

Inputs

Outputs

Parameters

The display

The display draws the three noises the way a spectrum analyzer would read them, on a frequency axis from 20 Hz to 20 kHz. All three start from one point at the low end and fan out: W stays flat, P falls gently and B falls twice as steeply. The lines shimmer as a real reading of noise does, most at the low end, where an analyzer has fewer frequencies to average in each octave.

Patched outputs light up and unpatched ones dim, so you can see at a glance which noise a patch is using. The lines sink as Level comes down.

Levels

White uses the whole ±1 range, so it makes a full-range random source for Sample & Hold. Pink and Brown are set about 7 dB lower, so their rare peaks stay inside ±1. A gentle ceiling holds those peaks in without touching anything below 0.8.

Brown is a leaky random walk: it rises 6 dB per octave as frequency falls, down to about 10 Hz, then levels off. That keeps it from drifting away from zero and pushing your speakers with a slow offset.

Random

Random picks a new value between -1 and 1 Rate times a second, and glides to it along a cosine curve. It arrives at each value at rest and leaves it smoothly, so it has no corners. It sounds less like a stepped sample-and-hold and more like something drifting: a filter that breathes, or a pitch that wavers like an old tape.

At 0.05 Hz it takes twenty seconds to move, which is slow enough to change the character of a whole pad over time. At 10–20 Hz it becomes a fast flutter.

Patches

Random melody

The classic: noise, sampled on every clock pulse, played as pitch.

[Clock Gate] ──> [Sample & Hold Trig]
[Noise White] ──> [Sample & Hold In]
[Sample & Hold Out] ──> [Oscillator V/Oct]
[Clock Gate] ──> [ADSR Gate]

Each pulse catches a new value of the noise and holds it as a note. Level sets the range: at 50%, the notes wander up to half an octave either side of the oscillator's pitch. The pitches are unquantized, so they fall between the keys of a piano; put a Quantizer after the Sample & Hold to keep them in a key. A little Slew on the Sample & Hold turns the jumps into glides.

Hi-hat

[Clock Gate] ──> [ADSR Gate]                    (Atk 1 ms, Dec 45 ms, Sus 0, Rel 40 ms)
[ADSR Out] ──> [Noise Level]                    (Level knob at 0)
[Noise Pink] ──> [SVF Filter In]                (Cutoff 4.5 kHz, take HighPass)

The envelope opens Level for each hit, so no VCA is needed. Only the knob is smoothed; CV at Level is followed sample by sample, so a 1 ms attack stays a 1 ms attack. A short decay gives a closed hat; lengthen Dec to 250 ms for an open one. The Rhythmic Sequence example plays exactly this under its bassline.

Snare

Mix a short burst of noise with a pitched body. Patch Pink through a bandpass around 2 kHz, open it with a 120 ms decay, and add a sine at 180 Hz with a shorter envelope. The noise is the snare wires; the sine is the drum.

Wind and surf

[Noise Pink] ──> [SVF Filter In]                (Res 60%, take BandPass)
[Noise Random] ──> [SVF Filter Cutoff]          (Noise Rate 0.1 Hz)

Random sweeps a resonant band slowly through the noise, so it rises and falls like gusts. Use Brown for a deeper, more distant wind. Put a slow LFO on a VCA after it, at about 0.1 Hz, and the swell of waves comes and goes.

The Shoreline example builds a whole beach this way, using every output of one Noise module: Pink and Brown for the surf, Random to vary the waves, and White, through a Sample & Hold, to play a wind chime.

Related modules

• Sample & Hold: turns noise into stepped random values
• Quantizer: snaps random pitches to a scale
• SVF Filter: shapes noise into drums, wind and breath
• Drum: a finished drum voice, with its noise and filters built in
• ADSR Envelope: gives noise a shape in time
• LFO: regular movement, where Random is irregular

Drum

Module ID source.drum · Category Source

A kick just after a hit. The orange line is its pitch, falling two and a half octaves to 48 Hz in the first few milliseconds. The blue curve is its level, lit up to the playhead.

Drum is one analog drum voice. Its Type turns it into a kick, snare, tom, clap, closed hat, open hat, cymbal, rim, cowbell or shaker, each built the way an 808 or 909 builds that sound: a few oscillators, a noise source, filters and decays. Send it a trigger and it plays one hit.

The same five knobs serve every type, and each means what it would on that drum's own panel. Tune sets the pitch of a kick and the metal of a hat. Snap sets a kick's beater and a snare's wires. The names never change, so a MIDI mapping keeps working when you change the Type.

Drum is polyphonic. A polyphonic gate, from Note In say, plays a new voice for each note, so fast hits ring on over each other instead of cutting each other off.

The types

Each type has its own pitch, its own range of decay, and its own meaning for Tone and Snap. The times are how long a hit takes to fall 60 dB, from Decay at 0 to Decay at 100%.

The hats' six squares run all the time, as the 808's do. They are never caught at the same place twice, so no two hits sound exactly alike.

Every other type starts at full level the instant it's struck. The Shaker's grain swells in, because the beads in a shaker don't all hit the wall at once. Accent shapes that as a wrist does: a full shake swells in over 3 ms, and a soft one over as much as 8 ms, as well as being quieter and darker.

Inputs

Outputs

Parameters

Tune, Decay, Tone and Snap are read when a hit lands, as on a drum machine. A hit keeps its sound however the knobs move while it rings, and the next hit takes the new settings. Level follows the knob at once.

Accent

Accent scales the hit's level, so at 0.4 it plays 8 to 10 dB quieter, and at 0 not at all. A softer hit is also darker and less snappy, as on a real drum: Tone drops by up to a quarter and Snap by up to half, and a soft kick falls a little less far in pitch. A ghost note on a snare is a different sound from a backbeat, not just a quieter one. While Accent is patched, the Tone and Snap knobs show this. An orange arc on each runs out to a bead at what the Accent makes of it, and the number under the knob reads that value in orange.

Choke

A hi-hat is two drums that can't ring at once: closing the pedal stops the open hat. To do this, patch the closed hat's trigger into the open hat's Choke as well as its Trig:

[Closed lane Gate] ──> [Drum (Closed Hat) Trig]
                  └──> [Drum (Open Hat) Choke]
[Open lane Gate]   ──> [Drum (Open Hat) Trig]

The open hat rings until the next closed hat lands, then dies in a few milliseconds, the way a drummer's foot shuts it. Any gate can choke any drum: a kick that chokes a long cymbal makes a cut-off crash.

A voice struck again while it's still ringing starts the new hit at once. It lets go of the old one over a millisecond or two, so a fast roll on a long kick doesn't click.

The display

The display draws the hit the knobs will play next. The blue curve is its level. Time runs on a warped axis that is wide at the start, so a kick's 10 ms drop and a cymbal's five-second wash both fit, with faint marks at 10 ms, 100 ms and each second. The ring time is at the top right.

The orange line is pitch. For a kick, snare, tom or rim it is the fall from the strike to the drum's resting pitch, which is printed at the top left. For the hats, cymbal and cowbell it is one line per square wave, each fading as the ring dies. For a clap or a shaker it marks the band the noise rings in, and the shaker's level curve rises from nothing as its grain swells in.

When the drum is hit, the fill flashes, and a playhead travels along the curve, lighting it as it goes. The lit curve is as tall as the hit's Accent, so ghost notes and backbeats read at a glance. A choked hit drops to nothing where the choke caught it. Hover the display for the numbers.

Patches

A kit in a few modules

The Drum Machine example is a whole kit in 14 modules: a Clock, five sequencer lanes, five Drums, a Mixer, a Reverb and the Output. Each sequencer's Gate goes to its Drum's Trig and its Velocity to Accent.

Tuned toms, or a cowbell melody

[Sequencer Pitch]    ──> [Drum (Tom) Tune]
[Sequencer Gate]     ──> [Drum (Tom) Trig]
[Sequencer Velocity] ──> [Drum (Tom) Accent]

Each step's note sets the tom's pitch, with middle C at the Tune knob's pitch. Set the Type to Cowbell for the classic 808 cowbell line, or to Kick with a long Decay for an 808 bass.

A layered snare

Patch one sequencer's Gate into two Drums, a Snare and a Clap, and mix them. The clap's bursts sit on top of the snare's crack. Turn the clap's Snap down so only its tail comes through, as a short room.

Rolls and flams

From a Note In module with several voices, two notes very close together each get a voice, so a flam rings as two hits rather than one cut short. A Clock at 1/16 with a high Swing into Trig makes a shuffled roll. Patch a falling envelope into Decay and the roll tightens as it goes.

Related modules

• Trigger Sequencer: a whole kit's hits from one module, a lane per Drum, with velocity for Accent
• Step Sequencer: one lane of hits, with velocity for Accent and pitch for Tune
• Clock and Clock Divider: the pulses that play it
• Noise and Oscillator: build your own drum from parts, as the Backbeat example does
• Mixer: pans each drum to its place and shares a reverb among them

Resonator

Module ID source.resonator · Category Source

A bell 0.4 seconds after it was struck. Each mode is a ring on a log-frequency axis. The hum on the left is still ringing wide, and the high partials on the right have already shrunk back to their dots.

Resonator is a physical model. It doesn't make a waveform and then shape it. It works out how a real string or a real bell would move when something plays it, sample by sample. That's why it sounds alive straight away, with no envelope to set. A pluck rings and fades by itself, its top dies before its note does, and no two plucks are quite alike.

Two models share one set of knobs:

• String is a plucked string, built the way Karplus and Strong built theirs in 1983: a burst of noise runs round a loop exactly one period long, and a gentle lowpass in the loop takes a little of the top off on every pass.
• Body is a struck bell, bar, glass or block of wood: twelve tuned modes, each ringing at its own frequency and dying at its own rate.

A Gate plays it, as a finger or a mallet would. So does any sound patched into In. A drum, a voice or a burst of noise makes it ring at its own pitch, the way a shout makes a piano's open strings hum. A Drum into a tuned Resonator is a new instrument in itself.

Resonator is polyphonic. A chord on its V/Oct, from a Chord Sequencer or Note In, is a string or a bell for each note, so a chord rings as a chord. One mono drum into In rings them all at once.

The models

String

A string 80 ms after its pluck, still ragged with the top it's losing. The orange mark on the floor is where Position plucks it.

A gate plucks the string with one period of noise under a smooth swell, as a finger pulls a string aside and lets go. Brightness is the pick: a soft thumb at 0, a plectrum at 100%. Strike is how hard: softer is quieter, and smoother too, with less of the pick's grain in it.

Damping is what the string is made of. At 0 every partial rings as long as the note, like a bright steel wire. Turn it up and the top dies faster than the note, towards nylon or a string under a felt. Damping never changes the pitch: the loop is shortened by exactly the delay its lowpass adds at the note.

Position is where along the string it's played. Near the end (0) the sound is thin and bright with every partial. In the middle (100%) it's hollow and round, because a string plucked in the middle has no even partials: they all have a node there.

Body

A gate strikes the body with a mallet. Brightness is the mallet: felt is wide and dark, steel is narrow and rings every mode. Position is where it lands, from the edge to the middle. A mode with a node where the mallet lands barely sounds.

Material sets where the modes sit and how long they ring:

The lowest mode is always the note you play, so every material is in tune with the keyboard.

Inharm moves the modes. At 0 they sit on the harmonic series (1, 2, 3, 4 …), which turns any material into something string- or pipe-like. In the middle (the default) they're the material's own. At 100% they're stretched further apart, more clangorous and metallic. Damping makes the high modes die faster than the low ones, on top of the material's own.

Inputs

Outputs

Parameters

Changing Mode lets go of whatever the other model was ringing.

Nothing runs away

A string excited from In builds up for as long as the sound goes on, and at the longest Decay each pass round the loop keeps 99.99% of what went in. On an ideal string that would climb without end. This one can only swing so far, as a real one can: a soft ceiling sits inside the loop, so even full-scale noise held into the longest Decay rings loudly but stays inside ±1, with no blow-ups.

The display

For a String, the display is the string itself, between its bridge and its nut. The shape is one period of the loop, read from the voice as it plays, so it moves the way the sound does: ragged just after a pluck, then smoothing to a single arc as the top dies away. The blue haze either side is how far it's swinging. The orange mark on the floor is where Position plucks it.

For a Body, it's the modes: a dot for each across a log-frequency axis, as large as a strike will ring it. Struck, each dot blooms into a ring as wide as the mode is loud, and shrinks as that mode dies. A bell's high partials vanish first and its hum lingers.

The note and its pitch are at the top left. What's ringing, and for how long, is at the top right. Hover the display for the modes' ratios.

Patches

Tuned drums

The Sympathetic Strings example has no oscillators at all. A Rim Drum strikes a Glass tuned to E5, and a Shaker keeps a chord of four strings humming.

[Drum (Rim)]           ──> [Resonator (Body, Glass) In]
[Drum (Shaker)]        ──> [Resonator (String) In]
[Chord Sequencer Pitch] ─> [Resonator (String) V/Oct]

A plucked voice

[Sequencer Pitch]    ──> [Resonator V/Oct]
[Sequencer Gate]     ──> [Resonator Gate]
[Sequencer Velocity] ──> [Resonator Strike]

A koto or a harp with Position low and Brightness high. A muted bass with Damping up and Tune at -24. A music box with Mode on Body, Material on Bar and Inharm at 0.

A singing room

Patch a voice from an Audio Input into In, with Mode on String, a long Decay and Damping low. The string rings along at its pitch with whatever you sing, loudest when you hit its note or one of its partials. A Chord Sequencer on V/Oct makes it a chord of strings that answer you.

Bells on a beat

A Clock or a sequencer's Gate into a Body Bell, with an LFO into Brightness so some strikes are soft and some hard. Turn Inharm up for gamelan-like gongs, or down to 0 for tubular bells.

Related modules

• Drum: the best exciter, and in the Sympathetic Strings example the only one
• Noise: a burst of noise through an envelope into In bows a string that never stops
• Chord Sequencer and Note In: chords of strings or bells
• Reverb: a room for them to ring into

Sampler

Module ID source.sampler · Category Source

A five-note chord on a looped bell, and the file heard from ▶. The orange flags mark the loop and the blue ones what plays. Each white line with a dot is a voice, circling inside the loop at its own speed. The line capped at both ends is ▶'s, out in the bell's tail.

Sampler plays a WAV file. Patch a gate in and it plays one-shots: a kick under a sequencer, a vocal chop, a door slam. Patch in V/Oct as well and a polyphonic gate, and it becomes an instrument: one recorded note spread across the keyboard, each key playing it at its own pitch.

Set Slices and it becomes a chopped break: the recording is cut into equal slices, or at each hit it finds, and each key plays one of them.

Every other sound in Soba is synthesized. The Sampler brings in sound you've recorded, or one Soba rendered itself, and keeps it with the patch. It can make the recording itself, too: patch something into In and press Rec (see Recording into it).

Loading a file

• Click Open… under the waveform, or click an empty Sampler's display, and choose a WAV, MP3, FLAC or Ogg (Vorbis or Opus) file.
• Drag a sound file from your file manager onto a Sampler to replace its file. Drop one on empty canvas and a new Sampler appears there, already playing it. The node lights up under the file while you drag, to show where it will land, and plays the file from Start to End with its waveform on the panel. Over empty canvas, a faint Sampler follows the pointer where the new one would appear, and the whole file plays in its waveform. That way you can audition files from the file manager before you choose one, with or without a Sampler to try them on. It stops when the file leaves the node or you give up the drag, and a file dropped while it plays carries on. (In the browser a file can only be heard once it's dropped.)
• In the browser, drag a file onto the page the same way.

Loading a file is a step you can undo. A file is read and converted once. Samplers that play the same file share it. An MP3 plays without the silence its encoder leaves at the start, so a loop saved as an MP3 still loops cleanly. So does an Ogg file, whether it holds Vorbis or Opus audio (an .ogg, .oga or .opus file). A FLAC file plays exactly as it was recorded.

Opening or dropping a file plays it once, from Start to End, so you hear what you chose. Undoing back to an earlier file doesn't.

Hearing it

You don't have to patch anything to hear what a Sampler holds.

• ▶, beside the file's name, plays it from Start to End and stops there. It plays at the Sampler's Tune and Fine, at a Speed of 1. Press it again (it shows ■ while playing) to stop.
• Alt-click the waveform to play from that point to End. Past End, it plays on to the end of the file. With Alt held, a dashed line follows the pointer to show where it will start. Dragging the markers works as before.
• Sliced, Alt-click a slice to play just that slice, from its start to its end. With Alt held, the slice under the pointer is outlined.
• Let go of a marker with Alt held to hear what it now marks. A slice marker plays the slice it begins, Start the first slice and End the last. Unsliced, Start and End play Start to End. While you drag with Alt held, the slice you'll hear is outlined. You can nudge a marker and hear the result each time you let go, as in ReCycle or Simpler.

This works whether the transport is running or not. What you hear is the file itself, not the patch: it plays dry, beside the patch rather than through it, after the Audio Output's limiter, 6 dB below the file's own level. It isn't in a recording made with Record. It's how a sampler's or a DAW's file preview works.

One file plays at a time. Starting another, from this Sampler or any other, fades the first out over 5 ms. Deleting the Sampler or giving it another file stops it.

While it plays, a white playhead capped at both ends shows where it is, with the part it has played washed faintly behind it. The voices' playheads are lines with a blue dot, so the two never look alike.

Recording into it

Patch something into In L (and In R, for stereo) and press the red Rec button beside Open…. Press it again to stop. There's no file dialog: the take plays at once, and becomes the Sampler's file.

• Anything can be recorded. Patch an Audio Input to record yourself. Patch the patch's own sound, a Vocoder's output or a Mixer's send, to resample it into a new instrument. One side patched records the same on both.
• From a right-click. Right-click an Audio Input and choose Record into a new Sampler. A Sampler appears beside it, already patched, with Thresh at −40 dB and Rec already pressed, so the next thing you say is the take. Any other audio output offers Resample into a new Sampler: on its module's menu (with a submenu where there's more than one, like a Mixer's Out and Send), or on the output's own name. If the patch is stopped, it starts playing. With a Clock in the patch, each of these offers Free, 1 bar, 2 bars or 4 bars: a take in bars sets Take to match and Thresh to −∞, starts on the next bar line instead of the next sound, stops itself, and lands with Loop on Forward, ready to play.
• Start on a sound. Turn Thresh up from −∞ dB and Rec waits until In is that loud before it starts, keeping the 30 ms before. The take starts on your first word, not on reaching for the mouse. While it waits, the panel dims and shows how loud In is against the threshold.
• Takes in bars. Set Take to a number of bars with a Clock running. Rec then starts on the next bar line and stops after exactly that many bars, so the take is already a loop. As it records, the panel counts it in bars and beats, REC 2.3 / 4, not seconds. A press up to 50 ms after a bar line counts as on it.
• Stopping. Rec again, the Rec gate falling, the bars running out, or the room: a take lasts at most a minute. Stopping the transport ends a take there.
• The Rec jack takes over from the button, as Freeze does on the Vocoder: the Sampler records while the gate is high. A sequencer's gate resamples a phrase on cue.
• Tidied as they're kept. Right-click Rec and tick Tidy takes, and each take is trimmed to its sound and set to −16 dBFS RMS as it's kept (see Tidy takes).
• On a footswitch. Right-click Rec to learn a MIDI CC for it.

Live input reaches the patch a round trip after it was played, so the take is written that much earlier, as the Looper's overdubs are. A take in bars begins with what you played on the bar line, within a few milliseconds at the latency your device reports. The patch's own sound has no round trip, and is taken as it comes.

While a take comes in, the panel draws it in red, across a span that doubles whenever the take outgrows it, with the time so far in the corner and Rec showing ■. The Sampler goes on playing its old file until the take is done. Recording needs the patch playing.

Where takes go

When a take ends it's written as a WAV beside the patch, as <patch name> samples/Take 1.wav, Take 2.wav and so on, and the Sampler's file names it. That's a step you can undo: undo gives the Sampler back the file it had before. Saving the patch saves the take with it, and opening the patch plays it again.

A patch that hasn't been saved yet, a new one or an example, keeps its takes in a temporary folder until you save it. Save As then copies them beside the patch with its other samples. In the browser there's no folder beside the patch, so a take lives only in the tab, as a dropped file does. To keep one, save the patch: 💾 Save then downloads a zip of the patch with its takes and dropped files, as WAVs in a <patch> samples folder beside it, the way Save As gathers them on the desktop. Unzipped, it opens whole in Soba on the desktop. To keep just one file, click its name under the waveform and choose Download, which saves it as a WAV. The browser also keeps each one for the page itself, so it's still there after a reload, when an autosave is recovered, or when you open the downloaded patch in the browser again. Once nothing names a file any more, the next visit lets it go.

Takes nobody keeps don't pile up. Saving removes the takes this session wrote that the patch no longer plays and undo can't bring back. Closing the patch (New, Open or Quit) removes those no saved patch names, the temporary folder among them. That covers the files Trim and Normalize write too. A file Soba didn't write is never touched. After a crash, the temporary folder it left behind is tidied too: recovering the patch makes its takes this session's, and choosing Discard removes them.

Room for a take is set aside, a minute of stereo (about 23 MB at 48 kHz), when something is patched into In, so recording never has to find memory mid-take. Unpatch In and it's given back.

Trim and Normalize

A take comes in raw: silence at each end, whatever level the mic gave it, perhaps a bump before the first word. Click the file's name, under the waveform, for two fixes. They work on any file the Sampler plays, not only takes.

• Trim to the sound cuts the recording from where its sound begins to 300 ms after it ends.
• Normalize peak to −1 dBFS turns the whole recording up (or down) until its loudest sample is at −1 dBFS. Its shape is unchanged.
• Normalize RMS to −16 dBFS sets the level of the sound itself, so recordings sit at one level: a quiet take and a loud one come out alike. Up to 6 dB of peaks over −1 dBFS are taken down by a gentle look-ahead limiter. A peak louder than that, such as a popped "p", lowers the whole recording instead, and the status bar says by how much it fell short.

A spoken line with room at both ends, and Trim to the sound under the pointer. The hatched parts would go: 1.12 s from the start, up to the breath before the first word, and 1.42 s from the end. The crop marks frame what stays.

Each item says what it would do before you choose it: how much each end loses, or how many dB the level moves. While the pointer is on an item, the waveform shows it too. A trim veils the parts it would cut and sets crop marks round what it keeps. A level writes its change across the panel, since the waveform is always drawn to fill it.

Neither touches the original. Each writes a new WAV beside the patch, in <patch name> samples, named for what was done (Take 1 trimmed.wav, then Take 1 trimmed normalized.wav), and the Sampler plays it once, as it does a file just opened. It's a step you can undo: undo brings back the untouched file. A trim moves Start, End and the loop's markers with the sound, so they mark the same moments in it. A marker in a part that was cut goes to that end. Sliced, the slices are cut from what's left.

Tidy takes

To have every take come in tidy, right-click Rec and tick Tidy takes. Each take is then trimmed to its sound and normalized to −16 dBFS RMS the moment it's kept, both in one go, into one file: Take 1 tidied.wav. The panel frames the waveform in crop marks for a moment and says what was done, such as Tidied −0.42 s, +5.2 dB, and so does the status bar. While it's on, Rec wears small crop marks of its own. The choice is saved with the patch, Sampler by Sampler.

The take as it came in is still written first, as Take 1.wav, and tidying is its own step after it. One undo brings back the raw take, and a second gives the Sampler back the file it had before.

A take in bars (Take set to a number of bars) is never trimmed, since its length is the loop. It's only normalized. With Thresh turned up, the trim still finds where the sound begins: the 30 ms Thresh keeps before it is there for the trim to walk back into, and it keeps what it finds. A take that's already tidy, its sound filling it and its level on −16 dBFS, is left as it is.

Where the sound begins

The rule is the one the Soba Speaks example's voice was made with (tools/voice/record.py). The recording is measured in 10 ms steps, with any rumble under 70 Hz left out of the measurement. The room's level is that of its quietest tenth.

• The sound begins at the first sustained sound: one that lasts at least 80 ms, within 30 dB of the loudest and at least 10 dB over the room. A lone thump or lip smack is too short to count.
• From there the start walks back while the level keeps falling, to keep the breath before a word or a note's attack. It stops in the dip before anything earlier, such as a bumped stand, or where the level reaches the room, and never walks back more than 300 ms.
• The sound ends 300 ms after the last sustained sound, so a word can breathe out and a note ring.

A cut start fades in over 5 ms, and a cut end fades out over 80 ms. A recording with no quiet room to cut, a drone or a pad, has nothing to trim. Neither does one that's already been trimmed.

Inputs

Outputs

Both outputs carry a channel per voice when the gate is polyphonic.

Parameters

The four region knobs sit in the top row, under the waveform where their markers are. You can drag the markers instead of the knobs. Slices and Root start the second row, since together they say which key plays which slice. Thresh and Sens sit at the foot. Each says how loud something must be to count: In, to start a take, and a hit, to get a slice marker.

Playing it

One-shots

Patch a sequencer's Gate into Gate, and its Velocity into Velocity. Leave V/Oct unpatched and every hit plays at the recording's own pitch. One-Shot mode plays each hit to the end, however short the gate.

Across the keyboard

Patch Note In's Pitch, Gate and Velocity into V/Oct, Gate and Velocity, and set Root to the note the file was recorded at. Each key plays the recording faster or slower: an octave up is twice as fast and half as long, as on tape. Set Mode to Gated so that letting go of a key lets its note go, over Rel.

Pitch and speed

Pitch and speed are one thing here, as on a tape machine. Tune, Fine, Root, V/Oct and Speed all set how fast the recording is read, and so how high it sounds and how long it lasts. A recording made at a different sample rate from your audio device still plays at its own pitch.

At negative Speed a note plays backwards, starting at End and finishing at Start. A Speed that changes sign mid-note turns the note around where it is: an LFO into Speed scratches, and an envelope that falls to zero is a tape stop.

What plays

Start and End set the part of the recording a note plays. The rest of the waveform sinks into the background. A note fades out over its last 3 ms, so a recording cut mid-sound doesn't click at the end.

With Loop on, a note plays from Start to Lp End, then goes round. Forward jumps back to Lp St. Ping-Pong turns around and plays backwards to Lp St, then forwards again. Forward crossfades the jump over 8 ms, blending the end of the loop into the sound just before Lp St, so wherever the points sit the loop goes round without a click. A loop that starts at the very beginning of the recording has nothing before it to blend, so it borrows those 8 ms from its own start and comes round that much sooner. Ping-Pong never jumps.

In Gated mode a looping note keeps looping through its release, then fades. In One-Shot mode a looping note never ends. It plays until a new note takes its voice or the transport stops. That's a drone: a field recording slowed down an octave, looping forever.

Slices

Set Slices to cut the recording into equal parts, and each key plays one part: Root (C4 unless you move it) plays slice 1, C#4 slice 2, D4 slice 3, and so on up the keys. This is how samplers lay a chopped drum break or a set of vocal phrases across the keyboard.

• Each slice plays only itself. A note starts at its slice's start and stops at its end, with the same 3 ms fade as at End. In One-Shot mode a short gate still plays the whole slice. In Gated mode the note stops at the slice's end or when the gate falls, whichever comes first.
• The key picks the slice, not the pitch. V/Oct no longer transposes. Tune, Fine and Speed still do, and a slice played faster goes by sooner. Notes below Root, or past the last slice, play nothing.
• Slices divide Start–End. Move Start past a silence at the head of the file and the slices are cut from there.
• A loop goes round the slice. With Loop on, a held note in Gated mode repeats its slice until it's let go. That's a stutter. The Lp St and Lp End markers step aside while sliced.
• Backwards, at negative Speed, a slice plays from its end to its start.
• Start CV moves where a note starts inside its slice. 0.5 V starts halfway in.

Patch an Arranger lane, a Sample & Hold or an LFO into Slice to pick slices without a keyboard. Its value spreads evenly across them, 0 for the first and 1 for the last, and adds to whatever the note picked. With V/Oct unpatched, Slice alone chooses.

On the display, rules divide the waveform into its slices, numbered while they're wide enough to read. The slice a voice is playing glows. Hover a slice to see which key plays it, and Alt-click it to hear it. Sliced by Onsets, the rules are markers you can drag (see Slicing at the hits).

Slicing at the hits

Equal slices suit a file laid out in slots, a line or a note to each. A drum break or a spoken phrase isn't equal. Its hits and words land where they land, and a hit pushed a little early or dragged a little late is the feel that makes a break worth sampling. Equal sixteenths would cut through those hits.

Turn Slices past 64 to Onsets and the Sampler puts a marker where each hit begins: each drum, each syllable, each plucked note. Slice 1 runs from Start to the first marker, and each marker after that starts a slice of its own, up to End. As before, Root plays slice 1 and each key up plays the next.

Two bars of a swung break, sliced by Onsets at 50%: a marker at every kick, snare and hat, wherever the swing put it. The pointer is on the marker that starts slice 9.

• Sens sets how many hits count. Turned down, only the loudest hits get a marker: the kick and the snare. Turned up, ghost notes, hi-hats and quieter syllables get one too. The markers move as you turn it.
• The markers are where the sound rises. The recording is split into four bands, from the bass up. A hit is a moment when several of them suddenly get louder together: a quiet hi-hat over a ringing kick still counts, in the top band. A marker goes a millisecond before its hit, so the slice keeps the whole attack.
• Drag a marker (the white tabs along the top) to move it. Drag it off the panel, up or down, to take it away, and double-click between markers to add one. Each change is a step you can undo. Let go with Alt held to hear the slice the marker now begins.
• Markers you've moved are kept with the patch. Turning Sens finds them afresh, letting go of what you moved. Undo brings them back.
• A new file finds them afresh too, as does a new take. Trim to the sound moves them with the sound.
• Up to 64 slices. Markers outside Start–End cut nothing and are drawn faint. So are markers past the 63rd, and the last slice runs on to End.

The hits are found once, when the file loads. Turning Sens only chooses among them, so the markers move as soon as it turns. They're found on the file as it was recorded, so they're the same whatever your device's rate, and the render tool hears the same slices.

Voices

Sampler is polyphonic. Each channel of the Gate cable is a voice of its own, with its own pitch, velocity and place in the recording. Note In hands each new note the next voice. When all its voices are busy, it takes the oldest note's voice, which lets go of the old note over 5 ms as the new one starts. Retriggering a note that's still sounding does the same, so fast repeated notes never click.

Loading a new file while notes play fades them out over 5 ms. The next notes play the new file.

The display

The waveform shows the whole recording, scaled to fill the panel. What plays is lit blue, and the loop is washed orange. Start and End have blue flags at the foot, and the loop points orange flags at the head. Drag any of them like a knob. Hover a marker to see what it is, or the waveform to see the file's path, length and format.

Every voice draws a white playhead where it is in the recording, as bright as it is loud. A chord is several lines moving at their own speeds, and a released note fades where it stands.

Under the waveform are ▶ (see Hearing it), the file's name and length, which open Trim and Normalize, and Rec (see Recording into it), dim until something is patched into In and the patch is playing. A file that can't be found shows its name in orange. An empty Sampler asks for a file.

Files and patches

The Sampler plays WAV files: 8-, 16-, 24- or 32-bit integer, or 32-bit float. Mono files play on both sides. Files with more than two channels play their first two. Each file is resampled to your audio device's rate when it loads, and again if the device's rate changes.

A Sampler keeps up to five minutes of audio, about 115 MB of stereo at 48 kHz. A longer file is cut to its first five minutes, and the status bar says so.

A patch saves each Sampler's file as a path:

• Beside or below the patch, the path is relative: samples/kick.wav. Move or zip the patch's folder and it still finds its samples.
• Elsewhere, the path is absolute: C:/Music/choir.wav.

Save As copies samples from outside the patch's folder into a folder beside it named <patch name> samples, and points the patch at the copies. The patch's folder then holds everything it needs to be shared. If the samples come to more than 50 MB, it asks first. Saving an example works the same way, so its samples come with the copy. Save does the same for a sample you've brought in since, from your Downloads say. If those come to more than 50 MB, it leaves them where they are and says so, rather than asking at every save; Save As offers to copy them.

A patch whose sample is missing still opens. The Sampler keeps the path but plays nothing, and the status bar lists the missing file with the other load warnings. Open the file again to fix it.

In the patch file, the path is the module's file field. Slice markers you've moved are its slice_markers, with the Sens they were placed at, as fractions of the recording. Modules without either leave them out, so patches from before the Sampler read and save as they always did:

{
  "id": 2,
  "module_id": "source.sampler",
  "position": [300.0, 74.0],
  "parameters": [{ "name": "Mode", "type": "Select", "value": 1 }],
  "file": "samples/fm-bell-c4.wav"
}

The render tool finds a patch's samples the same way, relative to the patch file.

Sound quality

Voices read between samples on a cubic (Hermite) curve. That's clean at ordinary speeds and pitches. Played more than an octave or so above its root, a bright recording begins to alias: its highest harmonics fold back as a faint metallic edge. Record the sample nearer the range you'll play it in, or filter it after the Sampler.

Patches

Sampled keys

The Sampled Keys example plays a bell across the keyboard: one strike of the FM Synthesis example, rendered by Soba and loaded into a Sampler.

A drum kit from recordings

[Trigger Sequencer Gate 1] ──> [Sampler (kick.wav) Gate]
[Trigger Sequencer Vel 1]  ──> [Sampler (kick.wav) Velocity]
[Trigger Sequencer Gate 2] ──> [Sampler (snare.wav) Gate]
...

One Sampler per sound, each in One-Shot mode, into a Mixer to place them. Mix them with Drum voices for a kit that's part recorded and part synthesized.

A drone from anything

Load a long recording (rain, a room, a held note) and set Speed to 0.5, Loop to Ping-Pong with the loop over a steady stretch, Atk to 2 s and Mode to One-Shot. One gate starts a drone an octave down that never ends. Two Samplers on the same file, one at Speed 0.5 and one at 0.749 (a fifth above it), make a chord.

A chopped break

Load a one-bar drum loop and set Slices to 8 or 16, so each slice is an eighth or a sixteenth note. Or set it to Onsets, so each hit is a slice however it was played, and move any marker that landed somewhere you don't want it. Patch a Step Sequencer's Pitch into V/Oct and its Gate into Gate, clocked at the same division. Steps on C4, C#4, D4… play the break as recorded. Change a step's note and that step plays another hit. Patch a Sample & Hold of noise into Slice instead of V/Oct and the break rearranges itself on every hit.

Many lines in one file

The Clair de Satellite example keeps all eight of its sung lines in one file, a line to a slice. A Step Sequencer that steps every two bars sings line k on note C4 + k.

Scrubbing

Patch a slow LFO into Start, and a Clock into Gate. Each note starts a little further into the recording, so a spoken phrase or a melody comes out in stutters that wander through it.

Related modules

• Note In: plays the Sampler as an instrument, a voice per key
• Trigger Sequencer and Step Sequencer: one-shots in time
• Audio Input: outside sound live, as it happens. Patched into In, the Sampler records it
• Looper: records and layers live loops, where the Sampler records a take to play from a key or a gate
• Drum: synthesized drums to sit beside recorded ones
• Vocoder: a recorded voice that makes a chord speak, as in the Soba Speaks example

Chopper

Module ID source.chopper · Category Source

Two bars of a break in sixteen slices, each in a hue of its own, and the row of steps under them, each tinted like the slice it plays. Step 6 plays slice 2 backwards, step 12 plays its slice a fourth down, step 14 rests and step 16 stutters ×4. The dots in the corners are dice. The tick under the row is where the loop is in time; the white playhead is where it's reading.

Chopper plays a drum break in time with the Clock, and lets you rearrange it step by step.

A Sampler sliced into a break plays a slice for each note: the right tool for playing a break from a keyboard. A break played in a groove asks for more. It has to stay in time, follow the patch's tempo without changing pitch, and be re-sequenced: a snare moved, a kick doubled, a fill stuttered, a hit played backwards. Doing that with a Sampler and a Step Sequencer means a note for every slice of every step, set by hand, and retuning the break whenever the tempo moves. The Chopper does it all in one module.

How it keeps time

The break is cut into slices: equal ones, or one at each hit. Each slice starts on the beat it started on in the break, and plays at its own speed. A file that plays a REX loop works this way, and so did the samplers the breaks of jungle and hip-hop were chopped on.

• Faster than the break was played, each slice starts sooner and cuts the one before it short.
• Slower, each slice ends before the next begins, and a short fade closes the gap.
• At its own tempo, every slice runs on into the next, which fades in over the same 3 ms. The two read the same sound at that moment, so the crossfade is invisible and the break plays back exactly as recorded, round and round.

Either way the pitch never moves, and nor does the groove: a hit pushed late in the break is still late, by the same share of a beat, at any tempo.

Patch the Clock's Gate into Clock, and set Pulse to the Clock's own Div: 1/16 for sixteenths. Then set Beats to how long the break is: 4 for one bar of 4/4, 8 for two. The name under the waveform shows the tempo the break plays at unchanged, as long as Beats says. Patch the Clock's Reset into Reset too, so the loop starts from its top whenever the Clock does.

The steps

Under the waveform is a row of steps, one for each slice. Each step's turn comes where its slice began in the break, and left alone it plays its slice. Unedited, the row runs through the slices' hues in order, a spectrum from end to end, and the break plays as recorded.

Each step can be told to play it differently:

• Another slice. Drag the step up or down, or right-click it and choose one. The step takes on that slice's hue, so a rearranged pattern can be read at a glance: which slices come back, which never play.
• Backwards (Alt+click). It plays its slice from the end, and carries an arrow pointing back.
• Repeat ×2, ×3 or ×4 (Shift+click). It plays its slice from the top that many times, evenly across its turn: a stutter, or a roll at the end of a phrase. The step splits into its hits.
• Pitch, from 12 semitones down to 12 up (right-click). Tape-style: higher plays faster and leaves a gap before the next step, lower plays slower and is cut short by it. The step shows the semitones.
• Rest (click). Nothing plays, and the Gate stays low. The step is an empty outline.
• Chance (Ctrl+click steps through 0, 25, 50 and 100%). How often the step swaps its slice for one at random, so the break varies itself. A dot in the step's corner grows with the chance. A pattern plays its dice the same way each time the transport starts from the top.

A rest remembers what it was, so clicking it again plays it as before. Right-click a step for all of these, Back to slice n, as it was, Shuffle the slices (every step a slice at random, each slice once) and Reset every step. Every edit is a step you can undo.

A pattern longer than the break

A chopped break often runs under a longer pattern: two bars of break, four bars of pattern, the second half a variation on the first. Steps sets how long the row is: 1 per slice (the row as above), or 2, 3 or 4 per slice. Past the first pass the row wraps over the break again, and each extra step starts out playing its slice in the next pass, so left alone it still plays the break as recorded, round and round.

The face shows a line of steps for each pass, each line under the same slices, so a step reads straight down to the same slice's turn in the other passes. Edit any of them on its own. A step past the first pass has two more things on its right-click menu: Same as pass n copies the pass above into its own, to vary from there, and Shuffle the slices in pass n shuffles only its own line. Reset every step resets the whole row.

The row has at most 64 steps, so more slices allow fewer passes: up to 16 slices take all four, up to 21 three, up to 32 two, and more than that one.

Loading a break

Load a file as on the Sampler: click Open…, or the empty panel, or drag a WAV, MP3, FLAC or Ogg file onto the node. While a dragged file is over the node you hear it, so you can audition files before you drop one. It plays once when it loads, so you hear what you chose, and ▶ plays it again at any time, dry, beside the patch. Alt-click a slice to hear just that slice.

The file should be the loop itself, start to end: a break cut on its downbeats, as you'd cut one to loop it in a sampler. The Cut-Up example's break is made by Soba's own Drums (tools/breaks/make_break.py), so it's free to use however you like.

Recording a break

The Chopper can record its own break. Patch something into In L (and In R, for stereo) and press the red Rec button beside Open…. It's the Sampler's recorder: the same button, the same take drawn in red as it comes in, and the same file beside the patch when it's done. Play a phrase into the patch, from a Note In, an Audio Input or the patch's own drums, and chop it up straight away.

Take starts at 1 bar. With a Clock running, Rec then waits for the next bar line, which the panel says, and records exactly that many bars, so the take is already a loop. As it comes in, the panel ticks its beats, each bar more strongly, and counts bar and beat of the bars, REC 2.3 / 4, so you can see how much of the phrase is left to play. When it ends, it's the break: it plays at once, from its top on the bar it ended, and Beats is set to its length, 8 for two bars of 4/4, so it loops in time. Undo brings back the break you had, with its Beats.

Free records until Rec is pressed again. A free take made while a Clock runs is set to as many beats as it nearly is; without a Clock, Beats is left as it was.

Patch a gate into the Rec jack and it takes over from the button: a take starts as it rises (or on the next bar) and ends as it falls. Right-click Rec to learn a MIDI footswitch for it.

Slicing at the hits

Slices cuts the loop into 2 to 64 equal slices. Eighth notes suit a swung break, since swing moves the sixteenths in between, not the eighths. Turn it past 64 to Onsets and the loop is cut at its hits instead, exactly as on the Sampler: Sens chooses how many hits count, and the markers drag, come off the panel and are added by double-click. Let go of a marker with Alt held to hear the slice it now begins.

Cut at the hits, the steps stay evenly spaced under the waveform but the slices don't, so the fan of rules between them leans. Each hit then starts on its own place in the beat, swing and all, and the step row still gives every hit a step.

Inputs

Outputs

Parameters

Tips

• Find the break's tempo. A loop of 2.000 seconds at Beats 4 is 120 BPM, and the name under the waveform says so. If the number looks odd (91.3 BPM), Beats is likely wrong, or the file isn't cut on its downbeats.
• Slow it right down and the gaps between slices become part of the sound: a break at half speed is a sparse, clipped pattern of hits, each followed by silence.
• One break, two Choppers. Patch the same file into a second Chopper with another pattern and pan the two apart, or let one take over from the other by riding the Mixer.
• Resample a groove. Patch the mix of a few drums into In, record four bars, then rearrange what you just played: the drums can keep going beside it, or be muted for the chopped version to take over.
• Follow the chop. The Gate output rises on every slice, so a bass line clocked by it moves with the drums, and an envelope from it pumps a pad in time with each hit.

Cloud

Module ID source.cloud · Category Source

Canopy's twelve sung syllables, played as a cloud of a Dmaj9 chord. The wash is where grains may start: Position, as wide as Spray scatters them. Each spark is a grain, at its place in the file and as high or low as it sits in the stereo field, bright as it swells and fading as it ends

Cloud is a granular source. It plays clouds of small grains read from a recording, each a few milliseconds to two seconds long, faded in and out under a smooth window. Every other sample tool in Soba (Sampler, Chopper, Looper) plays time in order. Granular takes it apart: a sung syllable stretched into a held chord, a drum loop turned into a hiss of sparks, a moment of a voice frozen and played for as long as you like.

It plays a WAV, MP3, FLAC or Ogg file, opened or dragged onto it as for the Sampler, or live audio patched into In: the last six seconds of it, which Freeze holds.

How it works

A grain is a short read of the source:

1. Where. It starts at Position, across the source from its start (left) to its end (right). Spray scatters it either side.
2. How long. It lasts Size, under a Hann window that rises from nothing and falls back to nothing, so no grain clicks, however short.
3. How high. It reads the source faster or slower by Pitch, tape-style, so its pitch and its formants move together. A grain read faster than the recording runs through a steep lowpass of its own first, so nothing folds back down as aliasing, even three octaves up.
4. Where in the field. It sits at a random place across the stereo field, as wide as Spread.

Density says how many grains start each second. With Spray at nothing they start on a regular beat and read the same place, which buzzes at the Density's rate: turn Density into the audio range and Size down and you hear it as a pitch. Spray scatters them in place and in time until they blur into a cloud.

Up to 64 grains play at once. Past that, a new one waits for a free place: a dense, long-grained cloud thins out rather than clicking or overloading. However many overlap, the cloud keeps about the same loudness.

Live audio and Freeze

Patch something into In L (and In R, or leave it and In L plays on both sides) and the Cloud plays the last six seconds of it in place of the file. Position 1 is just now, and 0 six seconds ago. Grains always read audio already recorded, and never the moment being written.

Freeze stops recording, so the six seconds it holds stay to be played. Turn the switch on, or patch a gate: while the gate is high, it's frozen. A Clock Divider's Gate on Freeze catches a new moment every few bars; a footswitch catches whatever you just played.

While it fills, the face shows the part not yet recorded in the dark, and a grain needs a whole Size of audio behind it before it can start.

Polyphony

A polyphonic cable into Pitch grows a cloud for each of its channels, each at its own pitch, out of the one pool of grains. A Chord Sequencer's Pitch into it plays a cloud of each chord: see Choir of One. A chord's clouds add up as a chord's notes do, so a four-note chord is louder than one note.

Patch a polyphonic Gate as well and each channel's cloud grows only while its gate is high. The grains still sounding play out.

Trig

With Trig patched, grains no longer start on their own. Each rising edge starts a burst on every channel: as many grains as Density and Size would overlap, up to eight, scattered by Spray. Patch a Clock for grains in time.

Inputs

Position, Size, Density and Pitch modulate around their knobs: the knob stays live and sets the centre the CV works around.

Outputs

Parameters

A grain's place, size, pitch and pan are set as it starts, and it plays them out. Turning a knob changes the grains to come, never the ones already sounding, so nothing jumps.

The face

The source's waveform, the file's or the live audio's, oldest on the left. A soft wash shows where grains may start, and the line through it is Position. Every grain is a spark at the place it's reading, raised or lowered by where it sits in the stereo field, bright as it swells and fading as its window closes. The header says what it plays (FILE, LIVE or FROZEN, when the waveform turns to ice) and how many grains are sounding.

Click the waveform, or Open…, to open a file, or drag one from your files onto the node.

Sounds to try

• A held vowel. A sung note, Size 200 ms, Density 20, Spray 5%: the syllable it's at goes on as long as you like. Move Position slowly to walk through the word.
• A shimmer. Any file, Size 10–30 ms, Density 100+, Spray 60%, Pitch +12, into a Reverb.
• A pitch from a buzz. Spray 0, Size 5 ms, Density 110: the grains themselves are the note, an A. The file only colours it.
• Freeze a phrase. An Audio Input into In, Position at 95%: sing or play, flip Freeze, and play the cloud of what you just did.
• Grains in time. A Clock at 1/16 into Trig, Size 40 ms, a Sample & Hold on Position: a granular breakbeat.
• A chord of a voice. A Chord Sequencer's Pitch into Pitch: see Choir of One.

Related

• Sampler: plays a recording in order, from a gate or a keyboard.
• Looper: records live audio as a loop, to play back whole.
• Vocoder: another way to make a chord speak with a voice.

Audio Input

Module ID source.audio_input · Category Source

A drum loop coming in on input 1, with Channel on 1 so both meters carry it. Follow scrolls past the Threshold line, turning green wherever the gate opened: the kicks get through, the snares stay under.

Audio Input brings sound from outside into the patch: a microphone, a guitar, a synth on a line input. Put your voice through the reverb, a guitar through the ladder filter and a tape delay, or let a drum loop play a synth.

Choose the device in the toolbar's Input menu. It starts at None, so Soba never opens a microphone you didn't ask it to. Every Audio Input module in the patch hears that one device; until you choose one, they're silent.

Alongside the audio, the module listens to how loud the input is. Follow traces the level as a control signal, and Gate opens when it rises above the Threshold, so a drum hit or a picked note can trigger envelopes.

Outputs

The module has no inputs: its signal comes from the device.

Parameters

Choosing a channel

An audio interface hands its inputs over as a pair: input 1 on the left, input 2 on the right. That's right for a stereo source, like a synth's two outputs, but a guitar or a microphone plugged into input 1 alone would play only in your left ear, and a stereo delay or reverb after it would get a lopsided signal. Channel picks what the module hears:

Follow and Gate hear what the module puts out. On 1 or 2 they follow that input alone. On Stereo they follow whichever side is louder.

Each Audio Input module chooses for itself, so two of them can split an interface: one on 1 for a guitar through a filter and an echo, one on 2 for a voice through a reverb, each in its own chain.

A device that has only one input, like a laptop's built-in microphone or a USB mic, already plays on both sides, whichever Channel you pick.

Only inputs 1 and 2 reach the patch. On an interface with more, like a Scarlett 18i20, plug what you want to play into the first two.

The display

On the left, two slim meters show the input's peaks after Gain, on the same scale as the Audio Output meter. Hover them for the levels in dBFS. Set Gain so your loudest playing stays out of the red.

On the right, the last three seconds of Follow scroll past, newest at the right edge. The Threshold lies across them as a dashed green line, and the trace turns green wherever the gate was open, so you can see which hits got through. Drag the line up or down to move the Threshold; the lamp at its end lights while the gate is open.

The name of the device it's listening to sits faintly in the corner.

Follow and Gate

Follow is an envelope follower: it rises with the input's peaks at the Attack speed and falls back at the Release speed. Its scale is in decibels, not raw level. A whisper and a shout are 40 dB apart, which is a hundredth to one in raw level but 0.3 to 1 in Follow, so quiet and loud playing both move what it's patched to.

Short Attack times catch the front of a drum hit. Longer ones, 20–50 ms, smooth out the fast wiggles of a voice. Release sets how long Follow hangs on after a sound stops: around 100 ms for a tight pumping effect, a second or more for a slow swell.

Gate opens when Follow rises above the Threshold, and closes again only once Follow falls 6 dB below it. That gap stops the gate chattering open and shut when the level hovers right at the threshold. Because the gate follows Follow, a longer Release also holds the gate open longer.

Recording yourself

Right-click the module and choose Record into a new Sampler. A Sampler appears beside it, patched from L and R, listening at −40 dB with Rec already pressed. The take starts on your first word. Press the Sampler's Rec to stop it, and play the take from a key or a gate.

Latency and devices

Live input passes through two devices, each with its own clock and buffer: the input and the output. To keep the sound smooth, Soba holds a little audio between them, about one buffer of each. While an input is open, the status bar shows In and the round trip: how long a sound takes from the input jack to the speakers, often around 60 ms on Windows. Hover it for the parts that add up to it, then the device and any dropouts so far. It turns amber for a few seconds after a dropout, or after a glitch the device itself reports (a lone one when the input first opens is common, and harmless).

Each device's figure comes from the timestamps it puts on its audio. Windows doesn't time captured audio usefully, so there the input is counted as one packet, the least it can be, and the hover marks it with ~. If a device reports nothing at all, the label gets a + (In 22+ ms): the real round trip is longer than the parts Soba can count. Neither figure includes the converters inside the interface, usually another millisecond or two each way.

The Buffer settles on its own. It opens holding enough for the worst timing the two devices could have, then over the first few seconds it watches how much of that they really need, and trims the rest, a frame at a time so you don't hear it. If the two devices' clocks drift apart, as separate devices' do, it eases a block a fraction faster or slower to keep in step rather than letting the audio drop out. After a dropout it holds a little more, then tries the leaner amount again after a quiet half minute. The hover shows how much it has trimmed and stretched.

• Different sample rates are fine. Windows often runs a microphone at 48 kHz and speakers at 44.1 kHz, even on one interface. Soba converts the input to the output's rate on the way in. For the cleanest sound, set both to the same rate in your system's sound settings; the status bar tooltip says when it's converting.
• Changing the Output device reopens the input at the new device's rate.
• If the input device is unplugged, the status bar shows ⚠ Input lost. Choose it again under Input.
• A mono device is heard on both sides. With a two-input interface, set Channel to the input you're using; see Choosing a channel.

Low latency with ASIO (Windows)

ASIO is a registered trademark of Steinberg Media Technologies GmbH

Windows Audio is shared by every app, and each direction passes through the Windows audio engine: fine for a pad or a sampled loop, but a guitarist hears 60 ms as a slap-back echo of their own playing. An audio interface's ASIO driver skips all of that. Input and output come from one driver, on one clock, in buffers a few milliseconds long, and Soba holds nothing between them: each output buffer is computed from the input that arrived moments before.

To use it, download the low-latency Windows build, or build Soba with ASIO yourself (both in Build with ASIO), then open the Output menu and choose ASIO under Audio system. The menu then lists ASIO drivers, and Input offers that driver's inputs. Choose it there to hear your interface.

Buffer sets how many frames the driver hands over at a time, and the closed Output menu shows it beside the driver's name:

Measured on a first-generation Scarlett 2i2 with Focusrite's driver. The round trip is more than one buffer in and one out: each driver keeps a safety margin of its own, Focusrite's about another buffer and a few milliseconds each way, and Soba's limiter adds 1 ms. The status bar's In shows yours. If you hear crackles, or the CPU meter runs high, go up a size. Smaller buffers make Soba answer more often, with less time for each answer.

• ASIO drivers serve one app at a time. If another app (a DAW, say) has the interface, choosing ASIO says so and stays on Windows Audio.
• Changing the buffer from the driver's own control panel restarts audio at the driver's new size, with a note in the status bar.
• Soba remembers the audio system and buffer between sessions.

Feedback

A microphone near speakers hears the speakers. Through a reverb or a delay with feedback, that can build into a howl. The first time you turn on an input while the output is speakers, the status bar says so. Use headphones, or keep the volume low. If it does run away, the Audio Output's limiter keeps it from getting dangerously loud. Press ⏹ Stop to silence it.

Rendering and filming

The render tool has no input device, so Audio Input renders silence. Give it a WAV file to hear instead with --input:

cargo run --release --bin render -- my-patch.json out.wav --input voice.wav

The file plays from the start of the render. It must be at the render's sample rate (48 kHz unless you pass --sample-rate). In a capture script, the cue input voice.wav does the same from the moment it fires.

Patches

Voice in a room

[Audio Input L] ──> [Reverb In L]
[Audio Input R] ──> [Reverb In R]
[Reverb Out L] ──> [Audio Output Left]
[Reverb Out R] ──> [Audio Output Right]

Talk or sing into the microphone. If it's plugged into an interface, set Channel to its input, so it sits in the middle of the room rather than off to one side. Raise the Reverb's Size and Decay for a hall, or a cathedral. Use headphones.

Guitar through a ladder filter and tape echo

[Audio Input L] ──> [Ladder Filter In]
[Audio Input Follow] ──> [Ladder Filter Cutoff]
[Ladder Filter LP24] ──> [Stereo Delay In L]           (Tape on)
[Stereo Delay Out L / Out R] ──> [Audio Output Left / Right]

Set Channel to the input the guitar is plugged into. Follow opens the filter as you dig in, like an auto-wah: each pick attack sweeps it up, and it closes as the note decays. Start with the Ladder's cutoff low and its Resonance around 50%. Attack at 5 ms and Release at 200 ms give a classic quack. The tape echo then repeats each sweep, darker every time.

Drums that play a synth

[Audio Input Gate] ──> [ADSR Gate]                    (Thresh just under the kicks)
[ADSR Out] ──> [VCA CV]
[Oscillator Out] ──> [VCA In]                          (Octave -2)
[VCA Out] ──> [Audio Output Mono]

Play a drum loop, or hit a table near the microphone. Drag the Threshold line until only the hits you want turn green, usually the kicks. Each one fires the envelope, and a sub-bass note follows the drummer. Give the ADSR a fast attack and a short decay for a tight thump, or patch the Gate into a Step Sequencer to step through a bassline in time with the playing.

Ducking a pad

[Audio Input Follow] ──> [Attenuverter In]             (Amount -1, Offset 1)
[Attenuverter Out] ──> [VCA CV]
[Pad] ──> [VCA In]

The louder the input, the quieter the pad: it dips under each word and swells back in the gaps. That's the sidechain pumping of dance music, played by a voice or a drum loop.

Related modules

• Reverb and Stereo Delay: put the input in a space
• Ladder Filter and SVF Filter: shape it, with Follow on the cutoff
• ADSR Envelope: triggered by Gate
• Compressor: evens out a voice or a guitar
• Vocoder: speak or sing into it, and a synth chord speaks with your voice
• Sampler: patched into its In, records a take of you to play from a key or a gate
• Audio Output: its limiter catches feedback

Note In

Module ID input.poly_midi · Category Source

A chord from a MIDI keyboard and a note on the computer keys, lit on its piano.

Note In is how you play a patch. It takes notes from your computer keyboard, from the piano on its face (held with the mouse or a finger), and from a MIDI device: a keyboard, a pad controller, or a DAW or sequencer sending MIDI. It turns them into a V/Oct Pitch, a Gate, a Velocity and an Aftertouch signal that any module can use. It needs no setup and no hardware, which makes it the quickest way to hear a patch: the First Sound example that opens with the app is played from one.

With Voices at 1 it plays one note at a time, as a classic monosynth does: Priority decides which held key sounds. With more voices it plays chords. Every note you play gets a voice of its own, and the Pitch, Gate and Velocity cables carry all the voices at once, one channel per voice. Patch them into the polyphonic modules (Oscillator, SVF and Ladder filters, ADSR, VCA) and each held note plays through its own oscillator, filter and envelope. See Polyphony for how polyphonic cables work.

Every note, from the keys or from MIDI, starts on its exact sample, however short it is.

Outputs

Once the patch is playing, each polyphonic output shows its channel count in a small pill beside its label: ×8 means it carries eight voices. The Gate output lights up while a note is held.

Parameters

Priority and Retrig only do anything with one voice, and Mode only with several, so the ones that don't apply are drawn faded. They can still be set, ready for when Voices changes.

Each voice runs a full copy of every polyphonic module downstream, so eight voices cost about eight times the CPU of one. If a patch is heavy, turn Voices down.

Sources

Both plays from everything: the computer keys, the piano on the face, and MIDI on the chosen Ch. Keys plays only from the computer keys and the piano, so a MIDI controller in the same patch can play something else. MIDI plays only from MIDI, so the computer keys can play something else. Two Note Ins, one on Keys and one on MIDI, give one patch a bass on the computer keys and a lead on a controller.

The piano on the face lights the notes held, from wherever they come.

Key layout

The bottom two letter rows form a piano keyboard starting at C4. The bottom row plays the white keys and the row above it plays the black keys, sitting between them as they would on a piano. The top letter row and the numbers above it are a second piano laid out the same way, an octave higher, as in a tracker:

Black keys:    2   3       5   6   7       9   0
White keys:  Q   W   E   R   T   Y   U   I   O   P
Note:        C5  D   E   F   G   A   B   C6  D   E

Black keys:    S   D       G   H   J       L   ;
White keys:  Z   X   C   V   B   N   M   ,   .   /
Note:        C4  D   E   F   G   A   B   C5  D   E

That's C4 to E6, a little over two octaves. The pianos overlap by a few notes: , . / play the same C, D and E as Q W E, so a run up the bottom row can carry on along the top. Turn Oct to move the whole range.

The piano on the face plays too. Hold a key with the mouse, or a finger on a touch screen, and it plays like a computer key; slide across the keys and the pitch follows. It's how Note In is played on a phone.

Keys don't play notes while you hold Ctrl or Alt (those are shortcuts), while you're typing in a text field, or while the quick-add palette is open. Space and Tab open the palette, so they're never notes. The app has to have keyboard focus: if nothing happens, click the canvas. Switching to another window lets go of every key held.

The keys play every Note In whose Source isn't MIDI, in the browser and inside a DAW as well as in the app, with or without a MIDI device. The MIDI Monitor shows them as Keys.

Choosing a MIDI device

MIDI comes in from the device chosen in MIDI In on the toolbar. The menu lists every MIDI input the system can see. Pick one and the dot beside its name fills in (●) once it's connected. None (Disconnect) lets go of it.

• Plugged in a device after starting Soba? Open the menu and click 🔄 Refresh.
• In the browser, the menu is a 🎹 Connect MIDI button until you allow MIDI, and a device plugged in later appears by itself. See MIDI.
• Connection failed? The reason appears in the status bar at the bottom of the window, and the selection goes back to None. On Windows, a device another app already has open (a DAW, a browser, a controller's editor) can't be opened a second time, so close the other app and pick the device again.
• Switching or disconnecting a device releases any notes still held on it, so nothing sticks.
• Inside a DAW, Soba plays the notes on its track, and there's no MIDI In menu.

The choice isn't saved with the patch or between sessions. One device feeds every Note In and MIDI Monitor module in the patch.

How notes become CV

• Note On raises the voice's gate and moves its Pitch to the note.
• Note Off drops the gate. Pitch stays on the note, so a release tail stays in tune.
• Pitch bend moves Pitch by up to ±Bend semitones. It glides over about 5 ms between the wheel's steps, so bends never zipper.
• Channel pressure appears on Aftertouch.
• The sustain pedal (CC 64) holds notes after their keys come up. Lifting it releases them all.
• All Notes Off (CC 123) and All Sound Off (CC 120) release everything, pedal or not.

Each semitone is 1/12 on Pitch, so MIDI note 72 (C5) is +1.0 and note 48 (C3) is −1.0. With every tune knob at 0, the Oscillator plays C4 at 0.0, so Note In plays it in tune with nothing to set.

Timing

Notes are handled on the audio thread. Each one is stamped the moment it arrives, from a device or from the keys, and placed at the matching sample of the next audio buffer. Every note is delayed by the same amount, one audio buffer (a few milliseconds), so a steady sequence from a DAW plays back steady, with no jitter. Even the shortest note produces a gate.

One voice

With Voices at 1, Note In plays legato. The first key raises the gate, and while any key is held the gate stays up: pressing another key moves Pitch to it without retriggering the envelope, so overlapping your key presses slurs one note into the next. When several keys are held, Priority picks the one that sounds:

Release the sounding key and another held key takes over, so you can trill against a held note.

With Retrig off, playing legato changes the pitch but keeps the gate high, so the envelope carries on, for smooth, connected lines. With Retrig on, each legato note drops the gate for a single sample, so the envelope starts again on every note.

The cables carry one channel, so a monophonic patch hears one note.

Voice allocation

With several voices, Rotate gives each new note the next free voice in turn. A released note keeps ringing through its release while the next note sounds on a different voice, so release tails overlap naturally.

Reuse sends a note played again back to the voice that last played it, the way a piano string is struck again. Any other note takes the voice that has been free the longest, which gives release tails the most time to finish.

In either mode, a note played again while it's still sounding (held by the sustain pedal, say) restarts on its own voice rather than taking a second one.

Voice stealing

When every voice is busy, a new note takes one over. It chooses:

1. a voice the sustain pedal is holding (its key already up), oldest first;
2. otherwise, the oldest note still held.

The taken voice's gate drops for one sample, so its envelope starts again for the new note.

Glide

Glide makes the pitch slide from one note to the next instead of jumping, like the portamento on a classic monosynth. The knob sets how long the slide takes, from Off up to 2 seconds. Most of its travel covers the short times, where glide is most useful: 200 ms is a little past halfway.

• Even across the keyboard. The slide moves evenly in pitch, so it sounds the same low or high.
• The same time for any distance. An octave leap arrives as quickly as a step to the next semitone.
• Eases in. The pitch covers most of the distance early and settles gently onto the note: about two thirds of the way in the first fifth of the time, and within 1% of the note by the end of it.

The Glide dropdown picks which notes slide:

Pitch bend rides on top of the glide: the wheel moves the pitch at once while the note underneath slides. With one voice, Glide and Retrig work together, so with both on, each legato note restarts the envelope and slides into pitch.

With several voices, each voice slides from its own previous note. Change chords with Glide up and every voice takes its own path, crossing and converging, the way the voices of a vintage polysynth do. A stolen voice slides from wherever it was. Mode decides where each slide starts: with Reuse, a note played again returns to the voice that last played it, so it doesn't slide at all; with Rotate, the voices take turns, so each slide starts from a different note of the last chord or two. In Legato mode a chord struck from nothing starts on its own pitches: notes arriving within 30 ms of the first count as part of that chord, since no hand strikes every key at once.

To hear it, open First Sound and turn Glide to about 200 ms. Hold Z (C) and tap B (G): the pitch slides up to G and, when you let go of B, back down to C.

MIDI Learn

Any knob in the patch can follow a MIDI controller (a mod wheel, a fader, a knob on your keyboard). This works with or without a Note In in the patch.

1. Right-click the knob and choose Learn MIDI CC. A purple M badge blinks above it, and the status bar asks you to move a control.
2. Move the knob or fader on your controller. The badge stops blinking: the knob is mapped.

Changed your mind, or no controller to hand? Press Escape, or right-click the blinking knob and choose Cancel MIDI Learn, and nothing is mapped. Starting learn on another knob moves it there instead.

The controller sweeps the knob's whole range, on any MIDI channel. Right-click a mapped knob to see its CC number, to Re-learn MIDI CC, or to Clear MIDI. Mappings are saved with the patch. Moves made by a controller aren't added to the undo history.

Patch examples

The smallest playable voice, as in the First Sound example, with Voices at 1:

[Note In Pitch] ──> [Oscillator V/Oct]
[Note In Gate] ──> [ADSR Gate]
[Oscillator Out] ──> [VCA In]
[ADSR Out] ──> [VCA CV]
[VCA Out] ──> [Audio Output Mono]

Chords, with Voices at 8:

[Note In Pitch] ──> [Oscillator V/Oct]
[Note In Gate] ──> [ADSR Gate]
[Note In Velocity] ──> [ADSR Velocity]
[Oscillator Out] ──> [Ladder Filter In]
[Ladder Filter LP24] ──> [VCA In]
[ADSR Out] ──> [VCA CV]
[VCA Out] ──> [Audio Output Mono]

Hold a chord and each note has its own oscillator, filter and envelope. The Audio Output is a mono module, so it hears the voices summed. Voices add up, so a four-note chord is about four times as loud as one note: leave headroom with the VCA's Level. The Lush Pad example is built this way.

Velocity on the ADSR Envelope makes harder notes louder. Patch Aftertouch into the filter's Cutoff to brighten a note as you press into the key.

Two voices on two channels, for a bass and a lead from one DAW:

[Note In (Ch 1, Voices 1, Priority Low)] ──> [Bass voice]
[Note In (Ch 2, Voices 1, Priority High)] ──> [Lead voice]

Older patches

Note In takes the place of three modules: Keyboard (the computer keys, one voice), MIDI Note (MIDI, one voice) and Poly MIDI (chords). A patch saved with any of them opens with Note In in their places, and plays as it did: a Keyboard becomes a Note In with one voice on Keys, at the Keyboard's velocity; a MIDI Note becomes one with one voice on MIDI; and a Poly MIDI is a Note In already.

Troubleshooting

No sound. Press Play: notes only sound while the patch is playing. Check Source. For MIDI, check that the device is selected in MIDI In and that its dot is filled, and set Ch to Omni in case the device sends on another channel. A MIDI Monitor shows whether anything is arriving at all.

Only one note of a chord sounds. Voices is at 1, or the cables run into a module that isn't polyphonic, which hears one channel.

Wrong pitch. Check Oct, and that the pitch bend wheel is centered.

Stuck note. Send All Notes Off from your controller, or select the device again in MIDI In. Either releases every held note.

Related modules

• MIDI Monitor – see the notes that are arriving
• Oscillator – where Pitch usually goes
• ADSR Envelope – where Gate and Velocity usually go
• Chord Sequencer – plays chords for you

SVF Filter

Module ID filter.svf · Category Filter

The response curve on the node is computed from the filter itself, so it matches what you hear.

The SVF (state variable filter) is the all-purpose filter: one input, four outputs, all running at once. LowPass darkens, HighPass thins, BandPass keeps a band around the cutoff and Notch takes one out. Patch whichever you need, or several at once, without switching modes.

It is a 12 dB/octave filter with an analog-style resonance. Turn the resonance up and the peak grows and saturates rather than getting louder without limit; turn it all the way and the filter sings on its own as a clean sine at the cutoff. Cutoff moves in octaves, so a sweep sounds even from bass to treble, and it stays stable right up to 20 kHz.

The display draws each output's response, the patched ones lit and the rest faint (with nothing patched, LowPass is lit). With CV in Cutoff or Resonance, the curves follow where the CV has taken the filter, a faint copy stays where the knobs put it, and the cutoff's tick on the floor turns orange: an envelope into Cutoff opens and closes the curve with each note. When the resonance is high enough to ring on its own, the peak glows and the display says sings.

Beneath the curves lies the sound itself. What comes into In is a faint blue landscape, and what the lit output lets through is green over it, so the gap between them is what the filter is taking away, and a resonant peak shows where the green rises above the blue. It's scaled to the loudest part of what comes in, so a quiet sound fills the display as well as a loud one, and a polyphonic cable shows all its voices together. When the sound stops, the landscape sinks away and the curve's own glow fills in beneath it.

With CV in Cutoff or Resonance, a thin strip along the floor keeps the last two seconds of what comes out, newest at the top and falling away beneath, brighter where it's louder. As an LFO sweeps the cutoff up and back, each harmonic's column lights as the cutoff passes over it and dims as it moves on, so the sweep leaves its trail through the sound.

For a thicker, steeper lowpass, see the Ladder Filter.

Inputs

Cutoff and Resonance modulate around their knobs. The knob sets the center, and stays live while a cable is patched in.

Outputs

Parameters

The four outputs

LowPass is the classic subtractive synth filter. It rolls off everything above the cutoff at 12 dB per octave, taking the edge off a bright oscillator. Most patches start here.

HighPass is the mirror image: it removes everything below the cutoff. Use it to thin a sound out, clear rumble, or leave room for a bass part.

BandPass keeps a band around the cutoff and rolls off both sides. The band narrows as resonance rises. It gives vocal, nasal and telephone-like tones, and swept by an envelope or LFO it becomes a wah.

Notch removes a band around the cutoff and leaves the rest. The notch is deepest exactly at the cutoff and narrows as resonance rises. It equals LowPass and HighPass added together. Swept slowly, it gives a phaser-like movement that hollows a sound without darkening it.

Resonance and self-oscillation

Resonance feeds part of the filter's output back into itself, which adds a peak at the cutoff. A little (20 to 40%) adds character; a lot (70 to 90%) gives the squelchy, whistling peak of an acid bassline. The feedback runs through a saturator, so a loud input at high resonance pushes back instead of running away.

Above about 97% the filter self-oscillates:

• It produces a sine at the cutoff frequency, with nothing patched into In. The oscillation grows out of a tiny noise floor, like circuit noise in an analog filter.
• The pitch lands within a few cents of the Cutoff knob, so the knob reads as a pitch.
• The saturator holds the level at about -12 dBFS.
• Patch a keyboard's Pitch into Cutoff and it plays in tune.

Feed audio in while it oscillates and the two interact, with the resonance pushing back against loud input.

CV Amt

CV Amt sets how far the Cutoff input reaches: how many octaves one unit of CV moves the cutoff. It runs from -4 to +4 octaves per unit, and starts at 1, the V/Oct scale.

An envelope runs from 0 to 1, so CV Amt is the size of its sweep, the knob a hardware synth calls Env Amount or Contour:

• 1 opens the filter one octave at the envelope's peak. Gentle: a sound that brightens a little at each note.
• 2 to 3 suits a pluck or a brassy swell.
• 3 to 4 is acid: a resonant peak that shoots up from the bass to the treble and falls back.
• Negative values turn the CV upside down. An envelope then closes the filter as the note starts and opens it again as it releases, so set the Cutoff knob high.

With pitch on Cutoff, CV Amt is the keyboard tracking: 1 keeps the filter's brightness the same on every note, 0.5 tracks at half the rate, and 0 ignores the keys.

CV Amt scales whatever is patched into Cutoff before it's added to the Cutoff knob, so the knob still sets where the sweep starts. With a polyphonic envelope, each voice's sweep is scaled the same way.

Drive

Drive raises the level into a soft saturator before the filter. At 1x it is nearly clean. Turning it up thickens the sound and then adds grit, and the louder signal also pushes harder against the resonance.

Patch examples

Basic filtering

[Oscillator Out (Saw)] ──> [SVF Filter In]
[SVF Filter LowPass] ──> [VCA In] ──> [Audio Output]

Start with the cutoff around 1000 Hz and Res at 20 to 40%, then turn the cutoff down for a darker sound.

Filter envelope

[Note In Gate] ──> [ADSR Gate]
[ADSR Out] ──> [SVF Filter Cutoff]

Set the Cutoff knob low (200 to 500 Hz) and CV Amt to 2 or 3. The envelope's 0-to-1 output raises the cutoff by up to CV Amt octaves as it plays, so the knob sets where the sweep starts and CV Amt how far it goes. Add resonance to make the sweep more pronounced. A fast attack and decay gives a pluck; a slow attack, a swell.

Keyboard tracking

[Note In Pitch] ──> [Oscillator V/Oct]
                ──> [SVF Filter Cutoff]

The filter follows the notes you play, so high notes are as bright as low ones. At the default CV Amt of 1 the Cutoff input is on the V/Oct scale, so no scaling is needed. Turn CV Amt down to 0.5 for half tracking, so high notes come out a little darker.

Parallel modes

[Oscillator Out] ──> [SVF Filter In]
[SVF Filter LowPass] ──> [Mix In 1]
[SVF Filter BandPass] ──> [Mix In 2]
[Mix Out] ──> [Audio Output]

Blending lowpass with a little bandpass gives body plus a resonant edge.

Moving notch

[Oscillator Out (Saw)] ──> [SVF Filter In]
[LFO Out (slow)] ──> [SVF Filter Cutoff]
[SVF Filter Notch] ──> [Audio Output]

A slow LFO sweeping the notch gives a phaser-like whoosh.

Polyphony

The SVF Filter is polyphonic. Each voice on a polyphonic cable gets its own filter, with its own resonance, so a chord into In with an envelope on Cutoff opens each note separately. The knobs are shared by every voice. See Polyphony.

Bypass

Click the power switch at the left of the header, choose Bypass from the module's right-click menu, or press Ctrl + B to take the filter out of the signal path. All four outputs then pass In straight through, and the header and controls dim. Switching takes a 20 ms crossfade, so it doesn't click.

Related modules

• Ladder Filter, the steeper, saturating lowpass
• ADSR Envelope to sweep the cutoff with each note
• LFO for wobbles and phaser sweeps
• Attenuverter to offset a cutoff sweep, or to scale one CV for several modules at once

Ladder Filter

Module ID filter.ladder · Category Filter

The ladder's response curve, drawn from the filter's own transfer function.

The Ladder Filter models the transistor ladder Robert Moog patented in 1969: the filter behind the Minimoog, and still the sound most people mean by "analog". It is a 4-pole lowpass, built from four one-pole stages in a row, with the last stage's output fed back to the first to make the resonance.

What gives it its character:

• A steep 24 dB/octave slope that darkens a sound decisively, plus a gentler 12 dB/octave tap from the middle of the ladder.
• Saturation at every stage. Push it with Drive and it rounds off and thickens rather than clipping. The output never goes past full scale, however hard you drive it.
• Bass compensation. The original ladder loses low end as resonance rises. This one adds the lost bass back, so turning up the resonance adds a peak without thinning the sound.
• Self-oscillation over the top fifth of the resonance knob: a sine at the cutoff frequency, in tune to within a cent or two.
• 2x oversampling. The saturators run at twice the sample rate, so a high note driven hard stays clean instead of picking up inharmonic aliasing.

The display draws LP24 and LP12, the patched ones lit, at the cutoff and resonance CV has taken them to, as on the SVF Filter. Past the top fifth of Resonance, where the ladder rings on its own, the peak glows and the display says sings.

Beneath the curves lies the sound itself, as on the SVF: what comes in as a faint blue landscape, and what the lit output lets through in green over it. The green is measured rather than worked out from the curve, so the harmonics Drive adds show up too, as green rising where the blue was low.

With CV in Cutoff or Resonance, the strip along the floor keeps the last two seconds of what comes out, as on the SVF, so an envelope or LFO on the cutoff leaves its trail through the sound.

Inputs

Cutoff and Resonance modulate around their knobs. The knob sets the center, and stays live while a cable is patched in.

Outputs

Parameters

Ladder or SVF?

Both filters cover the musical range, self-oscillate, and take cutoff CV in octaves, scaled by CV Amt. They differ in character:

Reach for the ladder for basses, leads and anything that should sound fat. Reach for the SVF Filter when you want the other modes, or a lighter, more transparent touch.

CV Amt

CV Amt sets how far the Cutoff input reaches: how many octaves one unit of CV moves the cutoff. It runs from -4 to +4 octaves per unit, and starts at 1, the V/Oct scale.

An envelope runs from 0 to 1, so CV Amt is the size of its sweep, the knob a hardware synth calls Env Amount or Contour:

• 1 opens the filter one octave at the envelope's peak. Gentle: a sound that brightens a little at each note.
• 2 to 3 suits a pluck or a brassy swell.
• 3 to 4 is acid: a resonant peak that shoots up from the bass to the treble and falls back.
• Negative values turn the CV upside down. An envelope then closes the filter as the note starts and opens it again as it releases, so set the Cutoff knob high.

With pitch on Cutoff, CV Amt is the keyboard tracking: 1 keeps the filter's brightness the same on every note, 0.5 tracks at half the rate, and 0 ignores the keys.

CV Amt scales whatever is patched into Cutoff before it's added to the Cutoff knob, so the knob still sets where the sweep starts. With a polyphonic envelope, each voice's sweep is scaled the same way.

Drive

At 1x, a full-scale signal is already warmed slightly. Around 2x to 4x the ladder thickens audibly and the resonance takes on a growl. At 10x it is a distortion in its own right. The level stays roughly constant as you turn Drive up, because the saturating stages cap it.

Self-oscillation

Turn Res above about 80%. With nothing patched into In, a sine rises out of a tiny noise floor (like the hiss of real components) within a second or so. Its pitch is the Cutoff knob, accurate to a cent or two from bass to treble, and the same saturators that shape the sound hold it at about -20 dBFS.

Feed audio in while it oscillates and the two fight, with the classic squelch.

Patch examples

Fat bass

[Oscillator Out (Saw)] ──> [Ladder Filter In]
[Ladder Filter LP24] ──> [VCA In] ──> [Audio Output]

A saw through LP24 with the cutoff at a few hundred Hz is the classic fat bass. Switch to LP12 for a brighter, buzzier version of the same sound.

Envelope sweep

[Note In Gate] ──> [ADSR Gate]
[ADSR Out] ──> [Ladder Filter Cutoff]

The envelope's 0-to-1 output raises the cutoff by up to CV Amt octaves above the knob. Set the knob where the sweep should start and CV Amt to how far it should go, then add resonance and a little Drive to make it bite. For a 303-style squelch, try Cutoff 300 Hz, Res 80%, CV Amt 3 and a 300 ms decay.

Keyboard tracking

[Note In Pitch] ──> [Oscillator V/Oct]
                ──> [Ladder Filter Cutoff]

At the default CV Amt of 1, the Cutoff input is 1 per octave, so a pitch CV patched straight in keeps the filter's brightness the same on every note. With the resonance high enough to self-oscillate and nothing patched into In, this turns the ladder into a sine oscillator that plays in tune.

Starting points

Polyphony

The Ladder Filter is polyphonic. Each voice on a polyphonic cable gets its own ladder, with its own resonance and saturation, and the knobs are shared by every voice. See Polyphony.

Bypass

Click the power switch at the left of the header, choose Bypass from the module's right-click menu, or press Ctrl + B. Both outputs then pass In straight through, with a 20 ms crossfade so the switch doesn't click.

Technical notes

• Each stage is a one-pole lowpass with a tanh at its input. The first stage's input is the signal minus the fed-back output, so the same tanh saturates the resonance. The loop is solved with zero delay (TPT), with the saturators linearized around a one-pass estimate of the current sample. That keeps the resonance in tune at high cutoffs.
• The oversampler uses polyphase IIR halfband filters: flat to within 0.01 dB up to 20 kHz, with about 100 dB of stopband. In tests, a 5 kHz tone driven into the filter has 30 to 55 dB less audible aliasing than the same filter run at the base rate. At extreme Drive combined with high resonance the gain is smaller (about 10 dB), because the harmonics reach beyond even twice the sample rate.

Related modules

• SVF Filter, the multi-mode, lighter-touch filter
• Oscillator, the usual thing to filter
• ADSR Envelope to sweep the cutoff with each note
• LFO for wobbles and sweeps
• Library: Acid Bass and Subtractive Voice are ladders with an envelope on Cutoff, and CV Amt on their faces

ADSR Envelope

Module ID mod.adsr · Category Modulation

The display draws the same curve the audio follows. An LFO is patched into Release, so the R is lit and Rel reads the time it has stretched to.

The ADSR Envelope gives each note a shape in time. When a gate goes high (a key goes down), it rises, falls to a held level, and when the gate goes low (the key comes up), it fades away: Attack, Decay, Sustain, Release. Patch it into a VCA to shape a note's loudness, or into a filter's Cutoff to shape its brightness.

Every stage takes exactly the time on its knob: a 100 ms release is silent 100 ms after you let go. Each stage's curve knob sets its shape, from a straight line to a deep analog curve.

While a note plays, the display follows it: the stage it's in lights its letter, a dot rides the curve at the envelope's level, and the glow under the curve swells with it. A soft note's dot rides lower, at the peak its velocity gave it.

Inputs

Outputs

Parameters

The knobs sit in two rows: the times and level on top, and under each time the curve of that stage.

The four stages

Attack begins when the gate goes high. The envelope rises from where it is (0, or wherever a release had got to) to its peak in exactly the attack time. A few milliseconds gives a percussive start; tens of milliseconds, the soft start of strings or a bowed pad; hundreds, a slow swell.

Decay begins the moment the attack reaches the peak. The envelope falls to the sustain level in exactly the decay time. Short decays are plucky; long ones ease gradually into the held note.

Sustain is a level, not a time: what the envelope holds for as long as the gate stays high. At 0% the note dies away even with the key held, like a plucked string. At 100% it holds at full level, like an organ. Turning it while a note is held glides to the new level over a few milliseconds, so it never clicks.

Release begins when the gate goes low. The envelope falls from wherever it is to 0 in exactly the release time, even if the key was let go mid-attack. Short releases stop abruptly; long ones leave a tail that lingers after the key comes up.

Curves

Each stage is an analog-style RC curve aimed past its target, so that it lands on time instead of creeping toward the target forever. The curve knob sets how far past:

• 0%: aimed far past, so the stage is a straight line.
• 20% (the attack default): aimed about 15% past the peak. The rise is nearly straight, which is what makes an analog attack sound punchy.
• 50% (the decay and release default): a classic RC fall. It drops quickly, then eases into its target, which suits how the ear hears loudness.
• 100%: a deep curve. Most of the change happens in the first fifth of the stage, followed by a long tail.

Curves change only the shape of a stage. Its time stays exactly the knob's.

Velocity

Patch a velocity source (the Velocity output of Note In) into Velocity, and the Vel knob sets how much it matters:

• Vel 0%: every note peaks at 1.0.
• Vel 50%: the softest note peaks at 0.5 and the hardest at 1.0.
• Vel 100%: the peak equals the velocity.

Sustain is a fraction of the peak, so a soft note sustains lower too. With velocity patched, the node's display draws a faint second envelope for the softest note. The gap between the two lines is your dynamic range.

With nothing patched into Velocity, every note peaks at 1.0, whatever the knob says.

Stage CV

Each stage has a jack beside its knob. CV there moves the stage around where the knob puts it, so the knob stays the starting point and the cable bends it:

• Attack, Decay and Release count in octaves of time. +1 doubles the knob's time, +2 quadruples it, and −1 halves it. A 500 ms release with +3 patched in rings for 4 s. The time stays within the knob's 1 ms – 10 s.
• Sustain adds to the knob's level, so +0.3 lifts a 40% sustain to 70%.

Most CV swings between −1 and +1, so an LFO patched straight into Attack only halves and doubles the attack. A 10 ms attack moves between 5 and 20 ms, which is hard to hear. To sweep it further, scale the LFO up first through an Attenuverter set to Range ×4. At ±4 octaves a 50 ms attack moves from about 3 ms to 0.8 s, from a snap to a swell.

The envelope reads CV on every sample, not just at each note. A cue that lands while a release is already falling stretches what's left of it, and the curve bends there without a step.

While a stage's jack is patched, its knob shows where the CV has taken it: an orange arc out to a bead on its rim, and the number under the knob in orange. The display draws that stage the way the envelope is running it, with its letter tinted. When a lane ramps the release out, you can watch the tail widen.

Patch examples

Volume envelope

[Note In Gate] ──> [ADSR Gate]
[ADSR Out] ──> [VCA CV]
[Oscillator Out] ──> [VCA In] ──> [Audio Output]

The basic shaped note. Without an envelope, an oscillator plays one endless tone.

Two envelopes: loudness and brightness

[Note In Gate] ──> [ADSR 1 Gate]
               ──> [ADSR 2 Gate]
[ADSR 1 Out] ──> [VCA CV]
[ADSR 2 Out] ──> [SVF Filter Cutoff]

Separate envelopes let the brightness move independently of the volume: a long release on ADSR 1 for sustained notes, and a short decay on ADSR 2 for a bright pluck at the start of each one.

Velocity to brightness

[Note In Velocity] ──> [ADSR 2 Velocity]

Add this to the two-envelope patch and harder notes come out brighter but no louder.

Inverted envelope

[ADSR Out] ──> [Attenuverter In]   (Amount -1)
[Attenuverter Out] ──> [SVF Filter Cutoff]

The filter closes as the note opens and opens again as it releases, for "backwards" sweeps. On a filter you can skip the Attenuverter: patch the envelope straight into Cutoff and turn the filter's CV Amt below zero.

Harder notes ring longer

[Note In Velocity] ──> [ADSR Velocity]
                   ──> [ADSR Decay]

A struck string rings longer when it's struck harder. With a short decay and no sustain, velocity into Decay gives a full-strength note twice the knob's decay and the softest one the knob's own. For a gentler spread, run velocity through an Attenuverter first. Pitch CV into Decay through an Attenuverter turned below zero makes high notes shorter, the way a piano's are.

Afterglow's arpeggio does this, with an Attenuverter's Offset at −0.5 so that only notes played harder than half ring longer. Its gate closes partway through the decay, so velocity goes to Release too.

A last chord that rings

[Arranger Lane 3] ──> [ADSR Release]

The plucks keep their short release all song. In the last section a lane rises from 0 to 1 or 2 and holds, and the final chord rings for a second or more instead of a few hundred milliseconds. Ramp the lane so the tails lengthen as the song slows.

Retriggering a held note

[Clock Gate] ──> [ADSR Retrig]

While the key is held, each clock pulse restarts the attack from the current level, re-articulating the note in rhythm.

Starting points

Polyphony

The ADSR Envelope is polyphonic. Patch a polyphonic gate (from Note In) into Gate and every voice gets its own envelope, with its own stage and level, so each note of a chord attacks and releases on its own. Polyphonic velocity into Decay gives each note its own decay; a mono cable, like an Arranger lane, moves every voice together. The display shows the first voice. See Polyphony.

Related modules

• VCA to shape loudness with the envelope
• SVF Filter and Ladder Filter to shape brightness
• Note In for gates and velocity
• LFO for modulation that repeats instead of following the note
• Slope for an envelope a trigger plays whole, however short the trigger

LFO

Module ID mod.lfo · Category Modulation

Synced to 1/4: the Rate knob reads the division, and the dot rides the waveform in step with the beat.

The LFO (low-frequency oscillator) makes slow, repeating shapes for moving other modules: a filter that breathes, a vibrato, a tremolo, a pulse width that drifts. It runs from one cycle every 100 seconds up to 100 Hz, so it can also be pushed into the audio range for rough, buzzy modulation.

The display on the node draws one cycle of the selected waveform, with a dot that travels along it at the LFO's actual phase, trailing a brighter stretch of the curve behind it. What you see is where the modulation is right now. Bipolar swings about a centre line; with Bipolar off, the wave stands on the floor, since it never goes below 0. A tick on the floor marks where the Phase knob starts the cycle. Across the top it reads the rate, after any Rate CV, or the division and the rate it comes to.

Inputs

Outputs

Parameters

Waveforms

• Sine moves smoothly with no corners. The natural choice for vibrato, tremolo and slow sweeps.
• Triangle rises and falls in straight lines. It sounds steadier than a sine at the turnarounds.
• Square jumps between its two extremes, half the cycle at each. Use it for trills, choppy tremolo and two-step filter jumps.
• Saw ramps steadily up, then drops back. A rising sweep that resets each cycle.

At the start of a cycle the sine and triangle sit at the midpoint, heading up, the square is high, and the saw is at its lowest.

Bipolar and unipolar

With Bipolar on (the default), Out swings evenly around zero. Into a filter's Cutoff or an oscillator's V/Oct, that sweeps both above and below the knob's setting, which is what you want for vibrato.

With Bipolar off, Out stays between 0 and 1: the same shape, lifted and halved. Use it where modulation should only add, as with a VCA's CV, where a bipolar LFO would spend half its cycle silent.

Tempo sync

Set Tempo to a division and the LFO locks to the patch's beat: one cycle per division, in step with the Clock. A 1 bar LFO sweeps once a bar; a 1/8 tremolo pulses on every eighth note. Change the Clock's tempo and the LFO follows, and if the Clock follows a MIDI clock, so does the LFO.

A synced LFO doesn't count its own cycles. It reads where the Clock's beat is, so it can't drift, however long it runs, and every synced LFO in the patch moves in step with the others. The cycles start on the Clock's downbeat: when the Clock starts from the top, so does the LFO.

While synced:

• The Rate knob dims and reads the division. Its pointer shows the rate that comes to at the current tempo.
• Rate CV has no effect.
• Sync still restarts the cycle, and the cycles then run from that moment, at the division's length, until the Clock starts from the top again.
• Phase still shifts the waveform, so a 1 bar LFO at 90° peaks on the downbeat.
• When the Clock stops, the LFO holds where it is, and carries on when the Clock does.
• Without a Clock in the patch, the LFO keeps its own time at 120 BPM.

Set Tempo back to Off and the LFO runs free at Rate, from the point it had reached.

Rate CV

The Rate input works in octaves, like V/Oct. +1 doubles the rate, +2 quadruples it, -1 halves it. The knob stays live while it's patched and sets the base rate the CV works from, so you can keep turning it.

[LFO 2 (slow)] ──Out──> [LFO 1 Rate]

A slow LFO into another's Rate makes modulation that speeds up and slows down on its own.

Sync and phase

Each rising edge at Sync restarts the cycle from the Phase setting. Patch a Clock into it and the LFO starts over on every pulse. To keep an LFO in time with the beat, though, Tempo is simpler and never drifts between pulses.

Phase shifts the starting point. Two LFOs at the same rate, one at 0° and one at 180°, move in opposite directions; at 90° they chase each other.

The Phase output is the LFO's position in its cycle, a 0-to-1 ramp whatever waveform is selected. Use it as an extra rising sawtooth, unipolar, alongside Out.

Patch examples

Vibrato

[LFO Out] ──> [Oscillator Exp FM]

Rate around 5 to 6 Hz, Sine, Bipolar on. Turn the oscillator's Exp FM knob down to about 0.02 octaves (Shift-drag for fine steps) for a gentle ±24 cents.

Tremolo

[Oscillator Out] ──> [VCA In]
[LFO Out] ──> [VCA CV]

Rate 4 to 8 Hz, Sine or Triangle, Bipolar off, so the level dips and returns rather than cutting out for half of each cycle.

Filter sweep

[LFO Out] ──> [SVF Filter Cutoff]

The Cutoff input works in octaves, so a bipolar LFO at full level sweeps the filter's CV Amt octaves either side of the knob: one, at first. A slow Triangle gives a smooth wah; a Square jumps between two brightnesses. Turn CV Amt down to sweep less, or up to sweep more.

A filter that breathes with the bar

[LFO Out] ──> [SVF Filter Cutoff]

Tempo 1 bar, Sine. The filter opens and closes once a bar, wherever the Clock's tempo goes. Try 2 bars for a slower swell, or a Square at 1/8 for a gated rhythm.

Pulse-width modulation

[LFO Out] ──> [Oscillator PWM]

With the oscillator on Square, a slow LFO (0.3 to 2 Hz) makes the tone shimmer and thicken like a chorus.

Stepped random

[LFO Out (fast Triangle)] ──> [Sample & Hold In]
[Clock Gate]              ──> [Sample & Hold Trig]

Each Clock pulse freezes wherever the LFO happens to be, and Sample & Hold holds that value until the next one. Set the LFO's rate so it isn't a simple multiple of the Clock's and the steps take a long time to repeat. (The trigger has to be a gate: an LFO can't patch into Trig.)

Notes

• The LFO is monophonic. One LFO patched into a polyphonic module moves every voice together. See Polyphony.
• The Rate and Phase knobs are smoothed, so turning them while the LFO runs doesn't click or jump.
• Run up into the audio range with Rate CV (it goes to 1 kHz), the LFO still sounds clean: the Square's and Saw's jumps, the Triangle's corners and each Sync restart are smoothed over a few samples, so they don't alias or click. At ordinary rates that touches only the samples right at each edge.
• Pressing Play starts every LFO from the beginning of its cycle.
• See Tempo and Sync for how the patch's tempo and beat reach the LFO.

Related modules

• ADSR Envelope for modulation that follows each note instead of repeating
• Clock, which sets the beat a synced LFO follows
• Attenuverter to scale, invert or offset the LFO
• Sample & Hold for stepped patterns
• Slope for a cycle with its rise and fall set apart, from a ramp through a triangle to a saw

Slope

Module ID mod.slope · Category Modulation · Polyphonic

Cycling, with a 1.2 s rise and a 400 ms fall, Shape 0.5. The dot is on its way down the fall, which is lit, and EOR glows until the fall ends.

A Slope rises and falls at rates you set. That one idea does four everyday jobs. Patch a signal into In and Out follows it, slowly or quickly: slew, glide, portamento, lag. A gate into In makes that an attack-release envelope. A trigger into Trig plays one whole rise and fall, however short the trigger: a function generator. Turn on Cycle and each fall starts the next rise: an LFO whose rising and falling halves you set apart. It is the slope generator from a Make Noise Maths, where all four are one circuit.

The node draws the rise and the fall side by side, each as wide as its share of the time, both bent by Shape. A dot rides the curve where the slope is, the stage it's in lights up, and the glow under the curve swells with Out, so a cycling Slope breathes. Above, the two times, and the rate when it cycles.

Inputs

Outputs

Parameters

How it works

Rates, not times

Rise and Fall are rates: the time to move a whole unit, from 0 to 1. A trigger always runs a whole unit, so its rise takes exactly Rise and its fall exactly Fall. Following In, a smaller move takes less time: half a unit takes half the time. Pitch is in octaves, so with Rise at 60 ms an octave leap glides in 60 ms and a semitone in 5 ms. That's the analog way, and it's different from the Glide on Note In, which takes the same time for any interval.

With the linear Shape, Out moves at a constant rate. When it reaches In it stops on it exactly, to the last bit, and stays there for as long as In holds still.

A trigger, a gate, and In

Trig sends the slope up to 1 and back down to In. It doesn't matter how long the trigger lasts: a single sample plays the whole shape, so a sequencer's gate length no longer shapes the sound. A trigger that arrives mid-fall starts a new rise from where Out is, with no jump.

A gate into In behaves differently. Out rises toward 1 while the gate is high, holds there, and falls when the gate goes low: an attack-release envelope that sustains for as long as you hold the note.

Trig: _|‾|____________________   In:  __|‾‾‾‾‾‾‾‾‾‾|_________
Out:  _/‾‾‾\__________________   Out: __/‾‾‾‾‾‾‾‾‾‾‾‾\_______
EOR:  ____|‾|_________________   EOR: ____|‾‾‾‾‾‾‾‾‾‾‾|______
EOC:  _______|‾|______________   EOC: _________________|‾|___

Shape

Shape bends both stages the same way, without changing how long they take.

• -1, log: the rise shoots up and eases in at the top; the fall eases off the top and drops to the bottom.
• 0, linear: straight lines, at a constant rate.
• 1, exponential: the rise starts slowly and accelerates; the fall drops fast and tails off, the way a struck sound decays. This is the shape for drums and plucks.

Turning Shape while the slope moves never makes Out jump: only the road ahead bends. Outside 0 to 1, where a pitch or a bipolar signal can take Out, the slope is always a straight line.

Cycle

With Cycle on, the end of each fall starts the next rise, so the Slope runs as an LFO at 1 / (Rise + Fall): 2 Hz at the defaults' 100 ms and 300 ms. Each stage ends between samples, and the next starts from exactly there, so the period is exact and doesn't drift, after ten minutes as after ten seconds. Turn Cycle off and the run in progress finishes its fall and stops.

Patches

Glide on a sequence

[Step Sequencer Pitch] ──> [Slope In]          (Rise 60 ms, Fall 60 ms, Shape 0)
[Slope Out] ──> [Oscillator V/Oct]

Every note slides into the next: an octave in 60 ms, a fifth in 35 ms. Set Rise and Fall apart for a line that swoops up and drops down, or the other way round. Rhythmic Sequence has this as a variation. Because it's polyphonic, a chord from Note In glides voice by voice, each at its own pace.

Trigger drums

[Step Sequencer Gate] ──> [Slope Trig]          (Rise 1 ms, Fall 450 ms, Shape 1)
[Slope Out] ──> [VCA CV]

A snap up and an exponential decay, from any length of gate. With an ADSR, a gate that falls during the attack sends it straight to release, so a short trigger can't play a long envelope; a Slope can.

A skewed LFO

Slope: Cycle on, Rise 2 s, Fall 50 ms
[Slope Out] ──> [VCA CV]

A slow swell that drops away, every 2.05 s. Turn Rise and Fall the other way round for a ramp down, or set them equal for a triangle.

A bouncing ball

[Clock Gate] ──> [Slope "Energy" Trig]           (Energy: Rise 1 ms, Fall 2.5 s; Clock 20 BPM, Div 1)
[Energy Out] ──> [Attenuverter In]               (Amount -1, Offset 1)
[Attenuverter Out] ──> [Mix In 1] [Mix In 2]
[Mix Out] ──> [Slope "Bounce" Rise] [Bounce Fall]  (Bounce: Rise 150 ms, Fall 150 ms)
[Energy EOR] ──> [Bounce Cycle]
[Bounce EOC] ──> [Drum Trig]                    (Rim, Tune 7 st)
[Energy Out] ──> [Drum Accent]

One Slope is the ball's energy, draining away over 2.5 s. While it drains, its EOR keeps the second Slope cycling, and the second's EOC taps the drum once a bounce. As the energy falls, the Attenuverter turns it upside down and the Mix doubles it, so the CV into the bounce's times climbs and the bounces close up, from a gap of 240 ms to about 110 ms, while the Accent lets each one land softer. A patch can't feed a module back into itself, so the ball's energy lives in a Slope of its own.

An envelope follower

[Drum Out] ──> [Slope In]                       (Rise 5 ms, Fall 1 s)
[Slope Out] ──> [VCA CV]

Out climbs to each peak of the sound and sinks slowly between them, so a second sound swells and fades with the drum. Fall is the time for a whole unit, so from a peak of 0.3, Out is back to zero in 300 ms. Lengthen Fall for a slower release. For a microphone or guitar, the Audio Input's Follow output does this already.

A delayed trigger, and a delayed gate

[Clock Gate] ──> [Slope Trig]                   (Rise 300 ms, Fall 10 ms, Shape 0)
[Slope Out] ──> [Logic CV]                      (Threshold 0.9)
[Logic Above] ──> [Drum Trig]

Each clock pulse starts a rise, and Logic's Above goes high when it crosses the Threshold, 270 ms later: each hit delayed by Rise × Threshold.

Patch the gate into In instead of Trig, and Out holds at the top for as long as the gate is high. Then Above is the same gate, opening 270 ms late and closing 1 ms after the gate does (the Fall, from the top down to the Threshold). Turn Rise to set the delay.

Related modules

• ADSR Envelope: four stages, following a gate
• LFO: fixed shapes, and tempo sync
• Sample & Hold: its Slew glides between held values
• Logic: turns a slope into a gate
• Clock Divider: longer gaps between triggers

Stereo Delay

Module ID fx.delay · Category Effect

A clap into the left side only, ping-ponged on worn tape: the first echo lights on the left, the second comes back on the right

The Stereo Delay plays back a copy of its input a moment later, then feeds that copy back in to make repeats. Filters in the feedback path darken or thin each repeat, P-P bounces the repeats between left and right, and Sync locks the time to the patch tempo.

Switch on Tape and it becomes a worn tape echo: the repeats waver in pitch, saturate as they build, and get darker each time around. Push the feedback far enough and they run away into the classic dub swell. The Tape module puts the same machine on a whole bus.

How it works

1. Each channel is written into its own delay line.
2. A read head plays the line back Time later. Reads usually fall between two samples, and a cubic (Catmull-Rom) interpolator fills the gap, so time changes and modulation glide smoothly instead of clicking or dulling the highs.
3. The playback runs through HiCut and LoCut, is scaled by FB, and goes back into the line with the input. Each repeat passes through the filters once more than the one before it.
4. Mix blends the dry input with the playback.

The display

The display draws the train of echoes. Time runs to the right from the moment a sound goes in. The first bar is the dry sound, and after it come the echoes, one delay time apart. Each echo is as loud as the feedback leaves it, on a decibel scale so a long tail stays readable. The left channel stands above the centre line and the right hangs below it.

• Filters. Every repeat passes HiCut and LoCut once more, so each bar is a little warmer than the one before and a little thinner. Tape mode adds the tape's own darkening.
• The sound going through. Each echo lights as the sound coming in reaches it, so a hit visibly walks down the train and fades. An echo lit to the top of its bar is as loud as the loudest thing that came in.
• Ping-Pong. With P-P on, the echoes take turns: each side's second echo is the other side's first, come back across. It shows best with something only on one side, or a stereo source.
• Tape. The bars blur and sway with the wow. Past unity, the feedback runs away and the header says so in orange.
• Words. The top left gives the time, with the note length when Sync sets it, in orange while Time CV moves it. The top right gives the feedback and the switches that are on.

Inputs

Outputs

Parameters

Time and FB keep working while their CV inputs are patched: the knob sets the center and the CV moves around it.

Feedback

In normal mode, feedback stops at 95%, and a soft clipper in the loop keeps the echoes from growing out of control. Around 30% gives a few echoes that fade naturally; 60% gives long trails; the top of the knob repeats almost forever.

In Tape mode the knob reaches further. See Runaway.

Tempo sync

Set Sync to a note length and the delay time follows the patch tempo. A Clock anywhere in the patch sets that tempo, so turning the Clock's BPM knob moves the echoes with it; they glide to the new time with a brief bend in pitch. With no Clock in the patch, the delay assumes 120 BPM. If a patch has more than one Clock, only one of them sets the tempo, so keep one Clock as the master.

Synced times can run past the Time knob's 2 seconds, up to 4.5 seconds: long enough for 1/4D at the Clock's slowest 20 BPM, so every division stays on the beat. Time CV still works while synced, swinging the synced time.

Tape mode

Tape models a tape echo: a loop of tape passing a record head and a play head. Switching it crossfades in about 15 ms, so you can flip it while echoes are still sounding.

Wow and flutter. The play head wanders. A slow wow (about 0.5 Hz, plus a slower drift of the reel) and a fast flutter (6 to 10 Hz) bend the pitch of the repeats by a few cents. The four motions run at unrelated rates, so the pattern doesn't loop.

Record-head saturation. The input and the feedback are recorded together through a soft, slightly lopsided curve. Quiet signals pass unchanged; loud ones round off and pick up the even harmonics of magnetized tape. Because the saturation sits inside the loop, a busy echo squashes and thickens as it builds.

Tape loss. Tape loses top end every time it records, so each repeat is darker than the last. Longer delays mean slower tape and darker repeats: the loss starts around 7 kHz at 250 ms and falls to about 3.5 kHz at one second. HiCut still works on top of it.

Motor glide. Time changes glide over about a quarter of a second, like a motor finding its new speed, and the repeats swoop in pitch as they go.

Runaway

In Tape mode, FB above about 90% pushes the loop past unity gain. The echoes grow until the record head's saturation holds them: the dub runaway. The output stays bounded at any setting, so you can ride it. Pull FB back below 90% and the echoes die away again.

Bypass

Click the power switch in the node header, press Ctrl+B with the module selected, or choose Bypass from its right-click menu. In L passes straight to Out L and In R to Out R (In R still copies In L when unpatched). The switch crossfades over 20 ms. A bypassed delay stops running, and it starts from silence when you switch it back in, so old echoes don't come back with it.

Patch ideas

Slapback. Time 80–120 ms, FB 0%, Mix 30%, Tape on. A single, slightly smeared echo, like a 1950s vocal.

Dotted-eighth rhythm. Sync 1/8D, FB 40%, Mix 40%. Turn on P-P with a stereo source and the repeats fall between the beats, alternating sides.

Dub throw. Sync 1/4 or 1/8D, FB 60%, LoCut 150 Hz, Tape on. For a bar, push FB up to the top and let it run away, then pull it back.

Chorus from a delay. A short time with the read head moving bends the copy's pitch:

[LFO Out] ──> [Delay Time CV]      Time 15–30 ms, FB 0–20%, Mix 50%

Ducking feedback. An inverted envelope pulls the feedback down on every hit, so the echoes swell back between them:

[Clock Gate] ──> [ADSR Gate]
[ADSR Out] ──> [Attenuverter In]   (negative Amount)
[Attenuverter Out] ──> [Delay Feedback CV]

Related modules

• Reverb: a diffuse space instead of distinct echoes
• Chorus: thickening without echoes
• Tape: the tape machine of Tape mode, for a whole bus
• Clock: sets the tempo Sync follows
• LFO: modulates the delay time

Reverb

Module ID fx.reverb · Category Effect

A snare into a 3-second room, a second after the hit: the dot has run a third of the way down the slope

The Reverb puts a sound in a space: a dense wash of reflections that builds, blooms and dies away. It reaches from a small, splashy room to a tail that rings for half a minute.

Its knobs sit in two rows. The top row shapes the room and its tail (Size, Decay, Damp, Mod); the bottom row places it in the mix (PreD, Width, Mix).

How it works

The Reverb is an eight-line feedback delay network (FDN).

1. Pre-delay holds the input back before anything else happens.
2. A four-step diffuser spreads the sound across eight channels. Each step delays the channels by different amounts, flips the polarity of some, and mixes them all together, so one click becomes 8 echoes, then 64, then 512, then 4,096. These are the early reflections.
3. Eight delay lines circulate the sound. On every pass the lines are mixed into each other, so each echo spawns eight more and the tail thickens into a smooth, noise-like decay.
4. Each line has its own gain and damping filter, both calculated from that line's length, so the whole tail decays at the rate Decay sets and every line loses its highs at the same rate.
5. The lines drift slowly in length (the Mod knob). This keeps resonances from settling in and adds a gentle chorus to the tail.

Simpler reverbs built from a few fixed comb filters tend to ring at the comb lengths, and sound metallic on snares and claps. The FDN's tail has no repeating period, so sharp transients spread into an even wash.

The display

The display draws the room's decay. Time runs to the right from the moment a sound goes in, stretched so the first few milliseconds have room beside a long tail. Level falls from 0 dB at the top to −60 dB at the bottom.

• Pre-delay. Nothing happens for the PreD time, marked by a faint line.
• Early reflections. The spray of hairlines at the start is every path through the diffuser at this Size, brighter where more of them arrive together. A small room packs them tight; a large one spreads them out before they merge into the tail.
• The tail. Two slopes fall from the top. The darker one is the lows, reaching −60 dB at the Decay time. The brighter one is the highs, dying sooner the more Damp takes them.
• The room ringing. While the tail sounds, a dot rides down the slope at the level it has fallen to, and the tail still to come glows. Each new hit sends the dot back to the top.
• Mod. With Mod up, eight faint motes drift along the top, one per delay line, as their lengths sway.
• Words. The top left gives the pre-delay, or the size when there is none. The top right gives the decay time.

Width and Mix aren't drawn: they place the reverb in the mix rather than shape the room.

Inputs

Outputs

Parameters

The controls

Size

Size sets the dimensions of the room. The shortest delay line runs from 12 ms at 0% to 100 ms at 100%, and the early reflections scale with it. Small settings build up quickly, like a booth or a small room; large settings build slowly, like a hall.

Size and Decay are independent, so a small room can still ring for a long time. Turn Size while a tail is sounding and the lines glide to their new lengths, bending the tail's pitch for a moment instead of clicking.

Decay

Decay is the reverb time (RT60): how long the tail takes to fall by 60 dB. Measured on rendered impulse responses, it lands within about 5% of the knob across the whole Size range.

Damp

Damping models soft surfaces absorbing high frequencies. It sets how fast 4 kHz dies relative to the lows: at 0% it lasts the full Decay time, and at 100% it dies ten times faster. Low frequencies always keep the full Decay. Low settings sound like tile and glass; high settings like carpet and curtains, and a darker reverb is easier to sit in a mix.

Mod

Mod lets each of the eight lines drift slowly in length, each at its own rate between about 0.3 and 1.1 Hz. The early reflections stay still.

At 0% the tail is static, the most literal setting, though long tails can show faint resonances. Around 15–35% (the default is 25%) the movement smooths long tails without drawing attention to itself. From 60% up it becomes an audible chorus in the tail: lush on pads, seasick on piano.

PreD

Pre-delay is the gap between the dry sound and the start of the reverb. Up to about 10 ms the reverb starts at once and the source feels close. At 20–40 ms the attack of each note comes through clearly before the room answers, which keeps vocals and plucks distinct. Toward 100 ms the gap becomes an audible sense of depth.

Width

Width sets how far apart the two sides of the reverb are. At 0% the reverb is mono, centered; at 100% the two sides come from different delay lines and are almost completely uncorrelated, so the tail fills the stereo field. Width affects only the reverb, not the dry signal.

Mix

Mix sets how far away the sound seems. Around 10–20% it sounds close and present, 20–40% places it at a natural distance in the room, and above 50% it recedes into the space. At 100% you hear only the reverb.

Bypass

Click the power switch in the node header, press Ctrl+B with the module selected, or choose Bypass from its right-click menu. In L passes straight to Out L and In R to Out R (In R still copies In L when unpatched). The switch crossfades over 20 ms. A bypassed reverb stops running, and it starts from silence when you switch it back in, so no old tail comes back with it.

Starting points

For a vocal or lead, start from the Chamber with Mix around 20% and Damp near 60%; the pre-delay keeps the words clear and the damping keeps the tail from hissing. For a pad, try the Hall with Mix 50% and Mod 70%: the chorus lives only in the tail, so the dry note stays steady.

Patch ideas

Stereo insert. A stereo source keeps its image through the reverb:

[Oscillator Out L] ──> [Reverb In L]
[Oscillator Out R] ──> [Reverb In R]
[Reverb Out L] ──> [Audio Output Left]
[Reverb Out R] ──> [Audio Output Right]

Shared room. Mix several voices into one reverb so they sound like they're in the same space:

[VCA 1 Out] ──> [Mix In 1]
[VCA 2 Out] ──> [Mix In 2]
[Mix Out] ──> [Reverb In L] ──> [Audio Output]

Echoes of the room. Put a Delay after the reverb and the tail itself repeats in rhythm.

Related modules

• Delay: distinct echoes instead of a diffuse space
• Chorus: width and movement without a room
• EQ: shape the reverb's tone
• Mix: feed several voices into one reverb
• Mixer: send each channel to one shared reverb and bring it back

3-Band EQ

Module ID fx.eq · Category Effect

Pink noise through a warm low shelf, a cut in the middle and an airy top, with the pointer on the mid band

The 3-Band EQ boosts or cuts three regions of the spectrum: a low shelf for the bass, a fully parametric mid band, and a high shelf for the treble. Use it to fit a sound into a patch, take the mud out of a pad, put an edge on a lead, or darken a reverb tail.

Where a filter removes whole parts of the spectrum, an EQ leans on them, up to 15 dB either way. Every knob glides, so you can sweep the mid band while a note plays without zipper noise.

The display

The display draws the curve the three bands add up to, from 20 Hz on the left to 20 kHz on the right, and ±18 dB around the 0 dB line. Each band's own share is a faint tinted fill: the low shelf amber, the mid band violet and the high shelf blue. The bright line is their sum, with Out added. Every curve comes from the band's own filter, so it bends exactly as the sound does.

You can shape the EQ on the curve itself:

• Drag a dot to move its band: across for frequency, up and down for gain. The knobs follow.
• Drag a wing of the mid band (the short ticks either side of its dot, where its width ends) to set MdQ: out to widen it, in to narrow it.
• Double-click a dot to flatten its band back to 0 dB.

Pointing at a dot shows its band's settings at the top left. Out shows at the top right when it isn't 0 dB.

Beneath the curves is the sound itself: what comes into In is a faint blue landscape, and what leaves through Out is a pale line over it. A boost lifts the line above the landscape, and a cut carves a dip into it.

Inputs

Outputs

Parameters

With every gain at 0 dB the EQ is transparent.

The bands

The three bands run in series: low shelf, then mid, then high shelf.

Low and high shelves

A shelf raises or lowers everything beyond its frequency by the same amount, like a bass or treble knob on a stereo. The LoFrq and HiFrq knobs set the shelf's midpoint: the frequency where it has reached half its gain. The shelves are as steep as they can be without overshooting, so a boost rises cleanly to its level with no bump at the corner.

The shelves have no Q of their own. To affect a narrower region at the bottom or top, use the mid band.

Mid band

The mid band is a bell-shaped peak or dip centered on MdFrq. MdQ sets its width:

• 0.1 to 1: broad and gentle, spanning several octaves. Good for tonal shaping.
• 1 to 4: focused but still musical.
• 4 to 10: narrow and surgical, for picking out a single resonance.

A good rule is to cut narrow and boost wide: narrow boosts sound unnatural, while narrow cuts can remove a problem without anyone hearing that it's gone.

Bypass

Click the power switch in the node header, press Ctrl+B with the module selected, or choose Bypass from its right-click menu. In passes straight to Out. The switch crossfades over 20 ms, so you can compare the EQ'd and original sound mid-note.

Finding a problem frequency

1. Set MdQ high, around 5 to 8.
2. Boost MdGn to +10 dB or so.
3. Sweep MdFrq slowly until the ringing or boominess jumps out.
4. Turn MdGn down below 0 dB to cut it.

Where things live