Polarity - Music Producer & Teacher

Polarity-Recorder Plugin: Capture Ideas and Make Loops

polarity — Fri, 28 Aug 2026 02:00:00 GMT

Tutorial | Aug 28, 2026

Learn how Polarity-Recorder captures background audio in a DAW to recover ideas, snap loop exports to bars, and build searchable samples fast.

You can watch the Video on Youtube
Download Polarity-Recorder for Windows, macOS, and Linux from the official download and install page.
Support me on Patreon if you like what you hear.
Download Presets, Tools and Projects on my Dispenser

Quick Answer

Polarity-Recorder is a free background audio ring recorder plug-in for Windows, macOS, and Linux, available as CLAP, VST3, LV2, and standalone, plus AUv2 on macOS, with no account, telemetry, or login required.
It continuously captures the last 2 minutes by default with selectable 1, 2, 5, 10, or 20 minute history lengths, then overwrites the oldest audio. This makes it useful for recovering ideas or happy accidents that were not actively recorded.
A key feature is host-synced timing markers: transport start points, bar/beat guides, and snapping make it easy to extract loops, one-shots, stems, and samples at exact musical positions instead of trimming by eye.
The built-in editor supports quick waveform actions such as crop, normalize, LUFS normalization, clip, fade in/out, silence, reverse, undo, and loop preview, plus special rotate/wrap crossfade tools for creating seamless loops from recordings with reverb tails or imperfect lengths.
Exported clips are saved into a searchable history/library. On Windows and macOS they can be dragged directly into a DAW or sampler; Linux exports through SAVE. Metadata like name, type, loop flag, key, and BPM is stored in the filename for easy organization and text search.

Short Overview

Polarity-Recorder is a free cross-platform background audio recorder plugin for Windows, macOS, and Linux, available in CLAP, VST3, LV2, and standalone formats, plus AUv2 on macOS. It continuously captures incoming audio in a rolling buffer, making it easy to recover ideas, performances, and sound design accidents that would otherwise be lost.

In practice, it speeds up sampling and loop creation by combining transport-aware timing markers, bar snapping, quick waveform editing, and direct export. Features like normalization, fades, reverse, and seamless loop wrapping make it useful for extracting stems, one-shots, and loops directly from a DAW workflow without account requirements, telemetry, or extra bounce steps.

Key Takeaways

Continuous background ring recording: The plug-in constantly records incoming audio into a rolling buffer, with selectable lengths such as 2, 5, 10, or 20 minutes; once full, it overwrites the oldest audio so the most recent material is always available.
Host-synced timeline markers for easier extraction: Inside a DAW, the waveform shows transport-based markers tied to the project tempo (for example, play/start positions and bar divisions), making it easier to identify and snap selections to musical timing instead of trimming by eye alone.
Snap-based loop and one-shot selection: Selections can snap to bars, quarter notes, or host timing positions, which is useful for quickly cropping loops, drum hits, pads, or stems without manually finding exact boundaries.
Built-in mini wave editor for quick cleanup: Extracted audio can be edited directly with functions like peak normalization, LUFS normalization, clipping, fade in/out, silence insertion, reverse, undo, zoom, and loop preview before exporting.
Loop repair with rotate/wrap tools: For recordings that do not loop cleanly, the editor can move tail audio to the front and crossfade it to create more seamless loops, including a mode that preserves the original start point while wrapping excess end material forward.
Direct export into a DAW or sampler: On Windows and macOS, edited audio can be dragged directly into an arrangement, clip slot, or sampler. On Linux, use SAVE to export the WAV.
Filename-based metadata and searchable history: Exported files can be labeled with metadata such as name, type, loop flag, key, scale, and BPM, and this data is stored in the filename, enabling plain-text search in the plug-in’s built-in history browser.
Platform and compatibility caveats: The plug-in is offered for Windows, macOS, and Linux in formats including CLAP, VST3, LV2, and standalone, plus AUv2 on macOS. macOS may show a security warning; follow the current installation guide. Linux support was mentioned as less thoroughly tested.

Polarity-Recorder: a free background audio ring recorder for Windows, macOS, and Linux

Polarity-Recorder is a free audio plug-in and standalone tool that continuously records audio in the background. It is available for Windows, macOS, and Linux, with CLAP, VST3, LV2, and standalone builds, plus AUv2 on macOS.

No account is required. The project is described as having no telemetry and no login.

At its core, Polarity-Recorder works as a ring recorder: it always keeps the most recent audio in memory for a defined period, then overwrites the oldest material as the buffer fills. That makes it useful for capturing musical ideas, accidental performances, loops, and sound design moments that were not explicitly recorded.

What It Does

Polarity-Recorder continuously captures incoming audio and stores the last portion of it in a rolling buffer. The default buffer length is two minutes, with selectable lengths of one, two, five, ten, or twenty minutes.

A two-minute setting is presented as a practical middle ground: long enough to recover recent ideas, short enough to stay focused.

Unlike many simple rolling recorders, the plug-in also tries to preserve a sense of musical timing. When used inside a DAW, it can display visual timing references tied to the host tempo and transport. These markers make it easier to find loop boundaries, transients, and phrase starts without relying only on the waveform shape.

How It Works

When inserted on a track or on the master bus, the plug-in immediately begins recording incoming audio in the background.

Inside the waveform display, several visual markers appear:

Green line: indicates where playback started in the host transport
Purple and yellow lines: indicate musical positions within the project grid
Host BPM display: shows the current tempo, such as 85 BPM

These markers are intended to solve a common problem in ring recorders: waveform displays alone often provide poor timing context. Here, the timing references help identify bars, beats, and loop boundaries more reliably.

Selections can snap to these timing positions, which is especially useful for extracting loops or one-shot samples that need clean musical alignment.

Editing and Extraction Workflow

Once a useful region has been found in the rolling recording, it can be selected and opened in a built-in editor.

The editor provides lightweight waveform editing for common tasks:

zoom in and out
snap selections to musical markers
preview the selected audio
undo changes
normalize by peak
loudness normalization
clipping
fade in
fade out
insert silence
reverse audio

This is not presented as a full audio editor, but as a compact tool for the most common cleanup and preparation steps before export.

After editing, the audio can be:

dragged directly into the DAW as a waveform on Windows and macOS
dragged into a sampler on Windows and macOS
exported through SAVE on Linux
saved into the plug-in’s history browser

File Naming and Searchable Metadata

The editor allows optional labeling of exports with descriptive information such as:

name
type, for example full mix
loop status
key, such as E-flat minor

This metadata is not stored in embedded file metadata. Instead, it is written into the filename, making the exported files easy to search in the built-in browser or from the file system.

Because of that approach, searches can be simple text queries, including terms like BPM values or names.

History Browser

Saved exports appear in a browser panel on the right side of the interface. This functions as a lightweight sample history and library for recently exported material.

From there, files can be:

auditioned
searched by filename text
reloaded into the editor
renamed
dragged back into the DAW or a sampler

This makes it possible to build an ad hoc sample library while working, especially during sound design sessions or sketch-based production.

Practical Uses

Capturing missed performances

The most obvious use is recovering a good take, improvisation, or happy accident that was never formally recorded. Because the plug-in is always listening, the last few minutes remain available.

Extracting loops from the master bus

Placed on the master, Polarity-Recorder can capture complete musical ideas and quickly turn them into loops. The host-synced visual markers make it easier to cut exact bars or phrases.

Recording stems and one-shots

Placed on an individual track, the plug-in can be used to capture drums, snares, pads, or other isolated material. The timing lines make it easier to identify where a sound begins, even when the waveform itself is not visually obvious.

Building sample libraries during production

Instead of going through a traditional bounce-export-locate-reimport workflow, usable moments can be selected, lightly edited, saved, and dragged out immediately.

Loop Repair and Seamless Looping Tools

One of the more distinctive features is a pair of tools intended to fix loops that do not close cleanly.

A common example is a phrase that technically repeats, but whose tail contains reverb or delay that overlaps the start point. In such cases, the loop boundary clicks or feels abrupt.

Two operations are described for addressing this:

Rotate

This function takes a selected tail section from the end of the audio, moves it to the front, and crossfades it into the original beginning. The result is intended to create a smoother, seamless loop when the loop tail should lead into the start.

This is especially relevant for ambient material, pads, or any source with long decays.

Wrap

This function is similar in intent but behaves differently. Instead of offsetting the original beginning, it keeps the beginning in place and moves the excess tail material to the front while crossfading it into the start. This is useful when the total recording is slightly too long for an exact musical loop length, such as a phrase that should be 12 bars but runs over.

In that case, the overflow can be wrapped to the front so the result matches the intended bar count while remaining smooth at the seam.

DAW Integration Notes

The plug-in is shown working inside Bitwig and was also tested by the developer in Reaper and Ableton Live.

A limitation is noted around plug-in formats such as VST3 or CLAP: some DAW-side settings are not readable from the host in a way that would allow automatic filling of all descriptive fields. Ableton Live is mentioned as having related functionality, but not in a form that is currently accessible here.

The tool can also be used outside a DAW as a standalone application, though the host timing markers are most useful when running as a plug-in inside a DAW.

Why This Workflow Matters

The design addresses a common modern production pattern: experimenting with sound, instruments, and processing chains until something interesting happens, then wanting to keep just that fragment as reusable audio.

Traditional workflows often require multiple manual steps:

bounce or record the part
locate the exported file
rename it
import it back into the DAW
edit it again if needed

Polarity-Recorder reduces that friction by combining background capture, timing-aware selection, lightweight editing, and direct export.

Limits and Compatibility Notes

A few limitations and caveats are mentioned:

macOS users may encounter a security warning; follow the current installation guide when that happens
Linux support exists, but was not extensively tested
testing was limited, primarily on a Mac and Windows PC in a small number of hosts
some looping results may still produce minor clicks depending on material and context

Feedback and bug reports are explicitly requested, especially for larger compatibility issues or feature requests.

Summary

Polarity-Recorder is a free cross-platform ring recorder designed for music production and sound design. Its main strengths are:

continuous background recording
host-aware timing markers
snapping to musical positions
lightweight waveform editing
drag-and-drop export on Windows and macOS, with SAVE export on Linux
searchable history of rendered audio
tools for creating cleaner seamless loops

For producers who frequently capture unexpected ideas, build sample libraries from live experimentation, or extract loops from ongoing sessions, it offers a faster alternative to manual bounce-and-reimport workflows.

Transcript

This is the transcript of the video. The text was generated automatically and may contain small mistakes. The timestamps jump to the matching part of the video.

Click to expand transcript

[00:00:00] Yo, welcome back today. I want to share with you a new plug-in called polarity recorder and it records audio
[00:00:06] Continuously in the background again. This plug-in is completely free to use available for all platforms windows mac and linux
[00:00:14] Also all kinds of formats a you
[00:00:17] clap vst3
[00:00:19] Lv2
[00:00:21] Standalone and so on again. You don't need an account. There's no telemetry. There is no
[00:00:29] Description or anything like this. No. I log completely free to use just head over here to this download section and download this for windows
[00:00:36] Mac also linux and
[00:00:38] Yeah, in this video, I want to show you what it is and how it works. So in bitwig here. I
[00:00:44] Have a track and I want to maybe use this plug-in. So I just load it in here as a clap
[00:00:50] Instrument and let us run
[00:00:56] You can see it just starts to record stuff in the background. So this is a ring recorder
[00:01:01] so
[00:01:02] When these two minutes are full it just deletes the oldest stuff and you know
[00:01:07] You never get lost of the last two minutes
[00:01:10] We can also change this here to five minutes ten minutes twenty minutes and so on what I think two minutes here is a
[00:01:16] Perfect middle ground
[00:01:20] So we can also see here some special features for instance most of these ring recorders
[00:01:26] my opinion have this problem that you
[00:01:29] have no sense of
[00:01:31] Timing so here you can see we have a green line here and some purple lines and some yellow lines
[00:01:39] And these kind of represent the positions inside of your project. We have here 85 bpm
[00:01:46] So the green line is basically where we hit play on the
[00:01:51] On the transport here, right? So when I hit play and I put this here exactly on this
[00:01:56] 33 marker play
[00:02:00] You can see we get now here some kind of green line inside of the recording and these
[00:02:06] Purple lines are basically one bar or two bars
[00:02:10] I'm not really sure at the moment and what you can do with this is you can just head over here to this green line and
[00:02:16] Just select this and say I want to have I don't know
[00:02:20] Two bars or one bar here. All right. These are quarter notes. You can see it also snaps to this position
[00:02:27] This was also pretty important to me because I always want to have some kind of loops
[00:02:33] Extracted and we have the timing here from the host, right? We have 85 bpm. So why not?
[00:02:39] Let me just snap to these bars or to these timing positions, right?
[00:02:45] so
[00:02:47] Because we have selected this here, you can see a preview down here, but it's actually
[00:02:51] Not in the editor. We can say edit selection
[00:02:55] So now we have this here in the editor and we can do some things with that. So first up we have here the bpm setting
[00:03:02] So we have also in here some markers where we can snap the selection to it so you can
[00:03:09] Do different things or edits to this waveform if you want to right?
[00:03:14] We can also give it here a name for instance
[00:03:17] Call it master and then we can select here
[00:03:21] Type I don't know what it is full mix probably and it's a loop right and we can also say here
[00:03:29] It's E flat or the sharp
[00:03:31] Minor and this is nothing here you need to do but you can do it and it's actually
[00:03:37] stored inside of the
[00:03:40] File name so you can always extract
[00:03:44] Important metadata from the wave file. So it's not like it's stored inside of the file. It's just stored in the file name
[00:03:52] Okay, what you can do now is you can just drag this out here and put it into
[00:03:58] Bitwig as a waveform or you can
[00:04:00] I don't know drag it here into a sampler for instance
[00:04:06] Doesn't matter what you want to do and also when you drag it out for the first time you can see it's stored here inside of the
[00:04:12] history so there's some kind of browser on the right side and
[00:04:15] Can hit play
[00:04:20] And you can listen to all things you just you know recently
[00:04:28] exported from the plug-in
[00:04:32] We can also do some different things here for instance
[00:04:36] Like I said, we can zoom in zoom out. We can also zoom in here if you want to do that
[00:04:41] So we can select everything we can say we want to peak normalize this right just hit peak here
[00:04:49] So it's normalized to minus zero dot three DB. We can use love loves
[00:04:55] Normalization we can also clip it
[00:04:58] They're awesome
[00:05:03] What's the name pop ups help menus here. So what it does we also have fade in so you can say here
[00:05:09] We want to fade this in right? We want to have a fade out here
[00:05:13] Something like that. You can also let this play and in a loop
[00:05:18] We can also do here some undo also possible we can say we want to
[00:05:31] Have here some silence
[00:05:33] Something like that
[00:05:35] Undo we can reverse this part so you can make some edits to these
[00:05:42] Extractions here from the ring recorder. So I have a small little wave editor for the most important parts or
[00:05:50] You know most important actions you want to do on a wave file
[00:05:53] You can do this here
[00:05:57] Then there are some special things here. I want to show you in a minute. So anyway, so you can drag this out here
[00:06:02] You can also just hit save and it's just
[00:06:05] moved here into this history and this is also just a
[00:06:10] Kind of a directory on your on your hard drive, right?
[00:06:15] You can refresh it here. You can search also for certain things
[00:06:22] You have to kick nothing in here, but you can search also here for BPM and
[00:06:27] 73 yeah, so it's just a
[00:06:32] normal
[00:06:34] Text search here for the names for the file names and because all the metadata is stored inside of the file name
[00:06:40] You can find anything
[00:06:43] So this is pretty cool here on the master
[00:06:46] But it's also very cool if you just want to record some single stems, right?
[00:06:51] So if you have your only the drums for instance, and you hit your record
[00:06:56] Right and you want to go to this to this I don't know to the snare
[00:07:06] You can more or less say here here. This is that's probably a snare because they are snapping
[00:07:13] You can say oh, this is this is a snare. Let's crop this
[00:07:22] And you can extract because of the snapping can extract much faster instead of you know
[00:07:28] Finding the right place
[00:07:32] Inside of the recording my opinion. It's much much better also when you work with loops or you want to export loops or you want to export
[00:07:38] Pet sounds where you don't see exactly where the pet starts, but you see
[00:07:44] Because of these lines here. Oh
[00:07:46] It should be here, right?
[00:07:50] So maybe I'll do this here. Is there something like this here lay
[00:07:56] So it's very clear because of these lines where something starts
[00:08:03] And say this is exactly one bar
[00:08:21] So
[00:08:23] My opinion it's much much easier
[00:08:28] Okay, so that's that so let's do something different here. Let's use here maybe
[00:08:35] Tutorial I
[00:08:41] Think this is pretty okay
[00:08:48] So let's say you record some kind of
[00:08:50] Random or that's on there. Let's put this on there. I record something here
[00:08:59] You can see because I don't press play here there are no markers in here, so it's completely free
[00:09:18] I play some notes and random notes in a scale
[00:09:24] And I want to have this let's say this part here
[00:09:34] That's okay, so we have this patio is actually clipping
[00:09:48] So
[00:09:50] The problem is when you use a loop here looping is active
[00:10:04] Right you can hear here is the transitioning phase so it there's still a reverb not ringing out
[00:10:14] And then you start here and it's not really looping. So what you can do now is you can just select here
[00:10:22] maybe the last part and
[00:10:24] then say
[00:10:26] Is this the rotate I don't know I renamed this multiple times
[00:10:32] Yeah, move the selected terminal tail to the front and crossfade its second half into the old beginning
[00:10:40] So when you use this here this button, it just takes this part here cuts it out and puts it in the front
[00:10:47] And then crossfades 50% from here to 50% from here. So
[00:10:53] Let's use this so now we start here, let's hit play
[00:11:11] So you can hear that's basically no transitioning anymore. It's it's a seamless loop
[00:11:16] That's way too loud doesn't matter
[00:11:37] Right so it loops seamlessly and you can't hear any transitioning at all and when I do ambient
[00:11:44] I need this all the time and I wished Bitwig had this natively inside of the
[00:11:49] Clip launcher, but it's yeah, we don't get it for some it's too it's too to niche probably
[00:11:57] so let's undo this
[00:12:00] another way of
[00:12:02] Doing this is for instance here. You can see we have here one two three four a lot of different
[00:12:09] Bars and here this one here is a bit, you know, it doesn't fit. So we want to have maybe let's say
[00:12:18] 12 bars and the rest here is too much so we can do a wrap wrap means
[00:12:26] It just doesn't offset the beginning here with the rotate with the rotate that was just offsets this here by
[00:12:33] Whatever we selected here at the back end. So it wrap it just leaves the beginning exactly where it is and
[00:12:39] Just moves this part in front and then do a crossfade
[00:12:44] Right looks like this
[00:12:48] So now we have exactly 12 bars
[00:12:54] Right, so we removed here this part with exactly 12 bars now and the end part is now the beginning part and
[00:13:01] Overlays with the beginning here without offsetting the old beginning. It sounds like this
[00:13:08] And it should also just a seamless loop
[00:13:25] So with this feature you can make and recording that's not really fitting
[00:13:34] inside of
[00:13:37] In in loop range, let's say 12 12 bars and it's like 13 bars and a half and you can just take the rest
[00:13:46] That's over and put it in front crossfade it in and then you have exactly 12 bars and it's a seamless loop
[00:13:54] So this this was the idea behind this
[00:13:56] And then of course, yeah, you can just put this here inside of the
[00:14:02] Can we say this is a loop here and maybe pads
[00:14:10] Test we have here also
[00:14:19] Sadly with the VST 3 or clap you can't read here the settings on the doors
[00:14:25] I think Ableton Live has also something like this, but you can't access it
[00:14:29] I would be nice to have so I could fill fill this in here automatically maybe in the future
[00:14:35] So we can track this out here
[00:14:37] And I don't know if this works in between here
[00:14:41] But you can just hit play and say this is a loop
[00:14:47] And then technically it should loop also seamless. There's probably a small
[00:14:53] Small gap or small little click
[00:14:57] Let's try it out. I can see it's exactly 12 bars long
[00:15:02] 11 bars long, sorry
[00:15:18] Yeah, this is small little click
[00:15:21] But you get the idea
[00:15:27] So, yeah, this is this is my idea here for the polarity recorder you can also
[00:15:35] resize it of course
[00:15:37] and then for me, it's really really nice to have here this history of
[00:15:43] Exporter things because you can build up a nice sample library or if you do some sound experiments all the time
[00:15:50] And you need to bounce certain small parts of your song or
[00:15:54] You know what I mean, you can just build some kind of library and you can always
[00:16:01] Refer to that you can load it back into it into the editor here make some adjustments
[00:16:08] Or you just drag it out into your door or into your sampler from this
[00:16:14] Explorer here on the right side. You can also rename it. It's probably not perfect, but I try to implement
[00:16:21] Many features I really wanted to have in such an editor and in my opinion stuff like this should be part of
[00:16:30] the door itself
[00:16:34] Because nowadays a lot of people do a lot of sound
[00:16:39] Experiments and they want to keep their sound experiments and bring them back in as a sample
[00:16:44] And this old kind of workflow of bouncing and right-clicking bouncing and then you know and like to find it in the Explorer
[00:16:51] Drag it back in and so on. It's a bit, you know, come for some and sometimes you just play on your instruments
[00:16:58] Play around and you get a nice little accident and it's not recorded, right?
[00:17:05] So with this week at least you need to put it on the master or if you don't need to have here these lines
[00:17:12] Then you can put it into the door
[00:17:17] Or if you don't need the lines you can use it as a standalone outside of the door
[00:17:23] But it's better probably inside of a door as a plug-in
[00:17:26] So yeah, let me know what you think about it. Give me feedback. I
[00:17:31] Try to walk it in fix some bugs. Maybe there are some some bigger issues
[00:17:36] I just tested this only on my Mac and my Windows PC
[00:17:41] On rebar and able to live and it worked for me. I know a lot of people have problems with the plug-ins on
[00:17:48] Mac OS because I it's not signed by Apple itself and it cost me 100 bucks a year just to make this
[00:17:58] Assignage
[00:18:00] Assigned
[00:18:02] Assigned download. I don't know if you want to do this, but probably in the future. I need to do it
[00:18:07] And yeah, it also works on Linux, but I haven't tested this just too much on links
[00:18:15] So keep please give me feedback if there are some bigger problems in there or if you have some feature requests
[00:18:20] Let me know. Okay. So the link to this website here is in the description below
[00:18:25] Like I said, you don't need to log in or anything
[00:18:29] You can maybe donate something to me if you want to or subscribe on patreon for some
[00:18:35] updates so you get emails when something is updated and
[00:18:39] Yeah, I think that's it. Let me know what you think. Have a good weekend. See you next time. Bye

Soft Orbit (Ambient Tales)

polarity — Thu, 27 Aug 2026 02:00:00 GMT

Release | Aug 27, 2026

Polarity's Soft Orbit (Ambient Tales) turns one generative Bitwig Grid patch into four 10-minute ambient drone versions.

I get requests almost daily from people listening on YouTube, asking if I could bring these generative ambient tracks to Bandcamp, Spotify, and other platforms. Of course, I want to make that happen.

This is the first test run for the format: four versions of one generative patch, each presented as a ten-minute drone. Some of you might find that too short, while others might think it is too long. Let me know what works for you, and I can adjust future releases.

The cover is the Grid patch itself, so you can see how the music was created while listening to the result. I hope you like it, and please let me know what you think. Thanks!

Soft Orbit (Ambient Tales) by Polarity

From the Original Bitwig Patch

This release is based on the Soft Orbit preset and the generative performance We Can Sleep in Orbit.

Tracks:

Listen, Stream and Buy

Soft Orbit (Ambient Tales) on Bandcamp

The release is also being delivered to streaming services through DistroKid. It may take a few days to appear on the artist profiles:

We Can Sleep in Orbit

polarity — Sun, 23 Aug 2026 02:00:00 GMT

Music-Video | Aug 23, 2026

A warm generative Bitwig Poly Grid drone where randomized Sine voices move through the circle of fifths while filtered Noise adds an airy, shifting top layer.

You can watch the Video on Youtube.
Buy or stream four 10-minute versions on Soft Orbit (Ambient Tales).
Support me on Patreon if you like what you hear.
Download the Soft Orbit preset from my Dispenser.

About This Soundscape

The preset behind this soundscape is called Soft Orbit. It is a warmer and more positive continuation of the harmonic idea behind My Soundscape for Sleeping in a Slowly Turning World, but the patch itself is smaller and more compact. The result is still deep and slow, with a softer, airier top end and more light in the overall atmosphere.

Inside the Patch

Several Sine oscillators move through the circle of fifths in randomized steps. The harmony does not remain inside one scale, because each movement changes the tonal center instead of resolving inside a fixed diatonic progression. Robert describes the result as a modal chord progression: related harmonic areas remain connected, but the patch can keep circling without settling into one key. For more background on this approach, see Circle of Fifths in Bitwig.

The tonal material is deliberately simple. Sine voices feed the reverb while a Noise layer fills the top end. That Noise also modulates low-pass and high-pass filtering, so the airy layer changes over time instead of remaining as one static wash.

The preset graph confirms a compact multi-voice structure with randomized pitch and trigger paths, octave and pitch processing, filters, chorus, modulated delays, and a large all-pass diffusion network. The 23 All-pass Delay modules spread the otherwise simple Sine material into a wide field. A focused explanation of this technique is available in All-Pass Reverb in Bitwig Grid That Sounds Diffused.

Technical Snapshot

Created in Bitwig Studio 6.0.6
Device: Poly Grid
Preset: Soft Orbit
Harmonic movement: randomized steps through the circle of fifths rather than one fixed scale
145 parsed modules
164 detected connections
3 Sine oscillators and 2 Noise sources
10 Dice modules
23 All-pass Delay modules
3 Mod Delay modules
3 Chorus+ modules
3 Audio Out modules
Duration: 59:11
Preset: download Soft Orbit from the Dispenser
Release: buy or stream Soft Orbit (Ambient Tales)

My Soundscape for Sleeping in a Slowly Turning World

polarity — Sun, 16 Aug 2026 02:00:00 GMT

Music-Video | Aug 16, 2026

A generative Bitwig Poly Grid soundscape where modal harmony moves upward in perfect fourths while randomized tonal and noise layers drift through delay, chorus, filtering, and diffusion.

You can watch the Video on Youtube.
Support me on Patreon if you like what you hear.
Download Presets, Tools and Projects on my Dispenser

About This Soundscape

The preset behind this soundscape is called Slow Refraction. It is deliberately more minimal than some of my larger Grid patches, but it still creates a full hour of slow harmonic motion and changing atmosphere. The reduced structure leaves space for the central idea to remain audible instead of filling every moment with new events.

The harmony starts from a defined tonal area but does not remain inside one scale. Each new root moves upward by a perfect fourth, or five semitones, so the progression keeps rotating around the circle of fifths. Because the tonal center moves with it, the result feels modal and non-resolving rather than like a conventional chord progression in one key.

Watch the Patch Being Built

This soundscape has a matching start-to-finish build. See the full patch-building article and video, or watch the build directly on YouTube.

Inside the Patch

The pitch system combines constrained random notes with fixed interval movement and octave wrapping. Root, fourth, fifth, and second relationships keep the voicing open while avoiding a strong major or minor resolution. Pitch changes are conditioned around the amplitude envelopes so voices can retune between events instead of clicking in the middle of a note. A related bass branch follows the harmonic motion and fades around note changes.

Several oscillator and noise paths turn that shared pitch logic into separate layers. Random pitch and trigger streams feed probability-based events, filters, frequency shifting, modulated delays, and smoothed modulation. The analyzer found six Audio Out modules, indicating several independently assembled branches rather than one single signal chain.

Spatial processing is distributed across the patch. The graph contains 25 All-pass Delay modules and six Chorus+ modules alongside other delays and filters. Those diffusion and modulation stages smear the tonal voices and noise details into one slowly moving field while the harmony continues its rotation.

For a focused explanation of the diffusion technique, see All-Pass Reverb in Bitwig Grid That Sounds Diffused.

Technical Snapshot

Created in Bitwig Studio 6.0.6
Device: Poly Grid
Preset: Slow Refraction
Harmonic movement: roots rise by a perfect fourth (five semitones) and wrap by octave
186 parsed modules
187 detected connections
6 Audio Out modules
27 Dice modules
25 All-pass Delay modules
6 Chorus+ modules
Duration: 59:29
Preset: free download from the Dispenser

Bitwig Grid Generative Harmony with Fifths and Octave Wrapping

polarity — Sun, 16 Aug 2026 02:00:00 GMT

Tutorial | Aug 16, 2026

Build a generative ambient Bitwig Grid patch with fifth-based pitch motion, all-pass delays, bass ducking, and noise layers, learning trigger-safe note changes.

You can watch the Video on Youtube
Support me on Patreon if you like what you hear.
Download Presets, Tools and Projects on my Dispenser

Quick Answer

Patch type: Generative ambient Grid patch built around randomized note triggers, long envelopes, and self-running pitch logic.
Main sound-design direction: Floating, non-resolving harmony that circles by fourths/fifths instead of staying strictly diatonic, creating an eerie modal drift around E♭ minor without using strong thirds.
Key modules/devices: Random values every 16 steps, chance/probability triggering, envelope-gated note changes to avoid clicks, sine + saw layers, pitch wrapping by octave, chorus, all-pass/delay smearing, low-pass filtering, lag/slew smoothing, and added noise/FX textures.
Practical result: A compact but rich patch that generates ambient pads, bass movement, shimmer, and occasional weird FX sounds with very little manual input.
Who it’s useful for: Best for readers/watchers wanting Bitwig Grid techniques for generative harmony, click-free pitch changes, and fast ambient patch construction rather than a traditional melody or beat workflow.

Listen to the Finished Soundscape

This build has a matching one-hour performance. Open the finished soundscape page, or listen directly on YouTube.

Build Overview

The patch starts from a simple generative pitch source: bipolar random values sampled at a fixed rhythmic interval, range-limited and offset into an E♭-minor-centered register. Instead of building strict tonal harmony from a conventional scale, the note material is shaped around fourths and fifths, then later loosened further by cycling pitch in fixed semitone jumps and wrapping it back inside an octave. That produces a suspended, non-resolving harmonic field where the root area is recognizable, but the voicing stays modal and ambiguous because thirds are mostly avoided.

From there the build moves toward an ambient texture engine. Short all-pass delay structures, chorus, envelope scaling by pitch, and trigger logic are combined so new notes arrive only when amplitude returns to zero, reducing clicks and making the motion feel intentional. A bass layer is added from the same pitch logic, but ducked and faded around harmonic changes so it supports rather than dominates. Additional noise, sine, and FX layers fill the stereo field, with random modulation, lag smoothing, filtering, and occasional chance-based events creating movement without losing coherence.

The session is useful for modular learners because it shows patching as system design rather than preset assembly. Core ideas, shared pitch buses, event conditioning, octave wrapping, modulation smoothing, probabilistic triggers, and layered time-based processing, are developed in context and adjusted by ear as the musical behavior emerges. That makes the patch a strong example of how a small set of modular techniques can be extended into a complete self-generating instrument with harmony, texture, and macro-level motion.

Patch Decisions

A 16-step random pitch source drives the main notes: random values are generated every 16th note, kept bipolar, range-limited, then offset into the current E♭/D♯ minor area and passed through a scale-quantizing stage early on.
The harmonic core is intentionally sparse: the pitch set starts from root / fourth / fifth relationships, later adds the second instead of the third to avoid strong major/minor resolution and keep the harmony floating and ambiguous.
The main voice is built around a sine oscillator, with an amplitude rule where higher notes get shorter envelopes and lower notes ring longer, creating natural variation without extra sequencing lanes.
A compact diffusion network is created with an all-pass delay line using six stages (described as plate/shimmer-ish and diffuse), with short delay times derived from a roughly 500 ms maximum, to smear the tones before layering more elements.
To avoid clicks from pitch changes during active notes, the patch adds trigger gating logic: new note triggers are allowed only when the amplitude envelope has reached zero, so pitch updates happen between notes rather than mid-envelope.
The patch uses light randomization per trigger on parameters like stereo/tuning offsets, plus chorus as the simplest pitch-motion source; chorus is added to both the main tonal layer and other voices to widen and destabilize the sound slightly.
A transposition system shifts everything by fixed semitone jumps, especially +7 semitones (and later experimenting with 5), then wraps the result back inside a single octave instead of letting notes climb upward indefinitely. This keeps the chord motion cohesive while making it modal rather than strictly in-key.
The bass layer uses the root note as a saw-based foundation, stereo spread, and a ducking/fade logic where a detected note change briefly mutes the bass and slowly fades it back in, so the bass doesn’t collide with new chord arrivals.
Additional FX/noise layers are filled in with noise, sine tones, chorus, all-pass smearing, lag smoothing, and random-step modulation; for some modulation he prefers triggered random values smoothed by lag instead of a continuous random LFO.
Final mixing choices include turning down the FX layers, keeping some ducking below 100% so the bass never fully disappears, using SC Dark / equal-loudness style tonal shaping, and a Matcher only to bring the spectrum into a similar range as other videos rather than forcing an exact match.

Interesting Moments

00:00:23 - Random 16-step pitch source into Eb minor
00:02:26 - Building the first short all-pass shimmer delay
00:08:35 - Envelope-zero retrigger trick to avoid pitch-change clicks
00:17:53 - Bass layer added with octave-wrapped fifth transposition
00:24:15 - Fixing wrap range so the generated notes sit lower
00:32:33 - Detecting note changes to duck and fade the bass back in
00:50:04 - Adding random noise/FX textures with delay and smear
01:16:01 - Final EQ, matcher, bass/noise balance, and record pass

YouTube Description Timestamps

00:00:23 - Random 16-step pitch source into Eb minor
00:02:26 - Building the first short all-pass shimmer delay
00:08:35 - Envelope-zero retrigger trick to avoid pitch-change clicks
00:17:53 - Bass layer added with octave-wrapped fifth transposition
00:24:15 - Fixing wrap range so the generated notes sit lower
00:32:33 - Detecting note changes to duck and fade the bass back in
00:50:04 - Adding random noise/FX textures with delay and smear
01:16:01 - Final EQ, matcher, bass/noise balance, and record pass

What This Build Is Useful For

This Bitwig Grid build is useful as a generative ambient and texture-design patch: slow chord movement, non-resolving harmony, smeared delays, drifting bass, noise layers, and occasional FX details. It suits ambient, drone, experimental, soundtrack, and downtempo producers, as well as Grid users interested in self-running patches rather than fixed melodic sequencing.

Patch builders can reuse several techniques: random pitch generation constrained by intervals, octave wrapping, trigger gating so notes only retune when envelopes return to zero, envelope-length-dependent event density, layered chorus and all-pass diffusion, slow random modulation with lag smoothing, and ducked bass that fades around note changes. The patch also shows how to keep harmonic material ambiguous by avoiding thirds and moving in fourths or fifths.

This kind of long-form process is more useful than a short tutorial when the goal is understanding decision-making, debugging, balance, and gradual refinement. It helps when learning how complex generative patches evolve through listening and small corrections.

Transcript

This is the transcript of the video. The text was generated automatically and may contain small mistakes. The timestamps jump to the matching part of the video.

Click to expand transcript

[00:00:00] okay so let's try something slightly different today or maybe not I have no
[00:00:06] idea start simple
[00:00:11] you put the peak limit on here just in case
[00:00:18] okay
[00:00:23] we generate random values on 16 every 16 node
[00:00:34] bipolar of course so plus minus values maybe we limit the range
[00:00:53] just in case and then we want to have a scale
[00:00:59] maybe instead of a scale
[00:01:04] I'm using this
[00:01:09] fundamental of fourth and fifth and then we bring this into our current
[00:01:23] world which is eb or e flat minor I always say eb minor but someone in the
[00:01:32] comments was kind of annoyed because I'm saying eb because it's e flat
[00:01:40] and so we offset this and we just make sure we are in the scale with this one
[00:01:52] okay and here this
[00:01:59] we go down to 85
[00:02:11] okay nice
[00:02:22] it was a chance module here
[00:02:26] then we probably already start by creating here some kind of our past
[00:02:37] delay line maybe a short one so plate shimmer very diffuse yeah something like
[00:02:46] this but maybe not nine we go for six let's start with a with a short one and
[00:02:53] is maybe 500 milliseconds start is three okay so we have three we have 277
[00:03:17] so this work yeah
[00:03:25] then we have 83 then we have 418
[00:03:46] I think we can work with that 169
[00:04:01] and the last one is 500 of course makes sense
[00:04:14] let's see how this sounds
[00:04:44] so we take the note
[00:04:54] the higher the note is the shorter the envelope is
[00:05:10] so lower notes are longer
[00:05:15] and we need to have some kind of pitch modulation in there so I'm going for just
[00:05:33] the chorus just the easiest way
[00:05:41] and sounds sounds already so good just with six modules
[00:06:08] okay let's bring the volume down here a bit more
[00:06:15] so you can make this your saw right then we can make this stereo here
[00:06:38] and you make this one on here
[00:06:45] are you just this one now
[00:07:08] so we randomize this on each on each trigger just a tad
[00:07:29] also this one here the tuning
[00:07:38] that's a bit boring because we just used the root and the fifth and the fourth
[00:07:54] here with one two three four five six seven there maybe the third in there
[00:08:10] no we don't want to have the third use the second
[00:08:35] okay so now we do this trick where we wait
[00:08:40] and see here it triggers sometimes a new note when we are currently inside or in
[00:08:47] the middle of an amplitude envelope movement but that's not what we want so
[00:08:57] we wait until this is zero right so here this value goes down and then we have a
[00:09:04] zero and then zero matches with zero input and then we get a trigger only then
[00:09:17] only then does it make sense
[00:09:48] all right this doesn't work okay it's a long delay
[00:09:55] so the trigger is randomized and it only triggers when the envelope is on zero so
[00:10:11] not in the middle of a movement
[00:10:18] which prevents hopefully some clicks because we change the pitch why we are
[00:10:23] playing this the the sign oscillator
[00:10:47] yeah we could also add here the chorus to that
[00:10:51] yeah nice
[00:10:59] so now the problem here is it triggers even less because
[00:11:07] yeah because we wait at least until this whole envelope is complete
[00:11:17] so
[00:11:26] let's go to 24
[00:11:57] and because we are doing this here we probably need a low pass
[00:12:02] mg
[00:12:05] we can take the pitch here
[00:12:11] and go to c4 which is in twice the frequency here
[00:12:26] so
[00:12:56] so
[00:12:59] how does it sound when you just double this at the end
[00:13:09] like that
[00:13:26] so
[00:13:57] okay let's try out when we just transpose here just for a moment
[00:14:05] maybe uh transpose this down maybe
[00:14:09] live
[00:14:15] does it make any difference
[00:14:27] so
[00:14:29] maybe i've removed the chance here
[00:14:56] so
[00:15:26] so
[00:15:57] so
[00:15:59] maybe we should vary the loudness
[00:16:14] a little bit
[00:16:26] so
[00:16:57] or let's make this range shorter
[00:17:01] use a saw for a base
[00:17:20] yeah you can use the root note that's the root yeah
[00:17:27] take this and go to zero
[00:17:31] and make the stereo with a nice hover
[00:17:51] so
[00:17:53] and then we take the pitch pitch bus
[00:17:59] we use a constant
[00:18:04] so this is seven semitones
[00:18:09] we have to use at least 12 maybe
[00:18:18] when we attenuate this we get float numbers
[00:18:21] which is not what we want
[00:18:25] we want to have integers so we use a seal
[00:18:30] we have 10 9 8 7 and so on
[00:18:36] nice
[00:18:48] so
[00:18:50] we get pitch pitch out
[00:18:58] pitch values out which is what we used to
[00:19:18] so
[00:19:20] we add to in this tool
[00:19:24] then we blow the wrapper
[00:19:34] so we don't get too high
[00:19:38] all right this is too high so we want to wrap this inside of an octave
[00:19:46] multiply
[00:19:49] divide there's another constant needs to be 10 because we have 10 octaves in bitwig
[00:19:58] take this just does instead
[00:20:12] right so we pitch up we go always seven semitones up with everything but
[00:20:17] we wrap it inside an octave so when we exceed the octave we wrap to the lowest
[00:20:25] point in the current octave instead of going to the next upper octave
[00:20:30] so we can use this then here also
[00:20:43] at this here right
[00:21:13] yeah we could also use a scale
[00:21:22] so we make sure it's inside of the scale not that it's important we could also just
[00:21:32] remove this and let's keep it completely free maybe it's better so we are not in a scale
[00:21:43] so
[00:21:43] the overtones and the bass always fits together
[00:22:12] so
[00:22:43] so
[00:22:43] so we could use a random random lfo make this one really slow
[00:23:00] then use this
[00:23:13] that's too fast
[00:23:42] so
[00:24:13] so
[00:24:15] so okay some of the notes are still too high because i wrap between c3 and
[00:24:33] c4 so some of the notes inside of c3 are too too high for my taste
[00:24:42] so i can offset this
[00:24:45] by going three up or maybe four semitones up and here we go four semitones down so the
[00:24:56] wrapping is in a different place it's still an octave but it's maybe from uh what is this
[00:25:06] four semitones down i don't know it's maybe a as a day no it's a sharp a sharp until a sharp one
[00:25:21] octave higher a sharp two and a sharp three
[00:25:36] so we mutilate this of course because it sounds nice
[00:25:49] not too much
[00:25:52] oh yeah we can use the pitch here and put this on c4
[00:26:19] we mutilate this also slightly
[00:26:30] and see it down here
[00:26:49] so nice we have now something in e flat minor but it's not really e flat minor because we
[00:27:06] circle around the circle of fifth here in seven semitone steps and we don't make sure it's in
[00:27:17] the scale so it's really a modal chord progression that's not inside of a scale but it sounds nice
[00:27:26] because we just go seven semitones up and down with the whole chords
[00:27:40] seven eight nine ten this is here a minor seventh and minor second in there which makes it a bit
[00:27:51] vague and never uses a third so we want to have this floating effect we don't want to have a
[00:27:59] resolution or anything like that so maybe we can instead of using seven here maybe using five
[00:28:06] it sounds probably more ominous
[00:28:10] try this one out
[00:28:36] so
[00:29:07] and when we want to have the overtones a bit more drawn out we can just make the attack and decay
[00:29:12] longer because we have this logic here the longer the note lasts
[00:29:20] the longer it takes to trigger the next note so the overtones become less busy
[00:29:36] so
[00:30:07] so
[00:30:10] this is modulating what oh here i don't know progression
[00:30:36] so
[00:31:06] so
[00:31:36] so
[00:31:40] sounds already like 90 percent of the ambient stuff
[00:32:07] so
[00:32:33] yeah let's create here some kind of logic
[00:32:39] oh it's here okay we compare it
[00:32:44] so if the note is different then the note
[00:32:57] 10 milliseconds in the future then something changed
[00:33:27] so
[00:33:58] so
[00:34:01] hello does something change
[00:34:13] oh now we have we have a trigger
[00:34:27] so
[00:34:31] so when we have a trigger what do we do
[00:34:37] we use an ad but we don't use the ad to play the sound we use the ad to mute the sound
[00:34:54] like here
[00:34:58] or maybe we can just pull this down and continue it make it easy
[00:35:07] right so when we trigger here a new sound comes in
[00:35:10] we quickly mute and then we slowly fade the bass in
[00:35:19] so the attack is actually the release and the release is the attack
[00:35:50] so
[00:35:55] this will be three seconds because the lag is three seconds
[00:36:20] so
[00:36:23] this will be slower this was okay how it was in the beginning i just want to make sure this works
[00:36:50] so
[00:36:53] maybe make this longer five seconds
[00:37:19] so
[00:37:31] okay so we have almost here some kind of square
[00:37:45] almost
[00:37:49] so
[00:38:03] what's that here we can put this down
[00:38:17] maybe put another LFO in there
[00:38:29] don't want to have here this restart button
[00:38:34] it doesn't matter actually because we don't press a note but when you press a
[00:38:38] note you can restart this accidentally
[00:38:44] we modulate this here by pull up by
[00:38:48] 18
[00:38:52] it's like pitch wobbling here on the oscillator always nice
[00:39:14] we give this here distinct color
[00:39:18] this is actually the pitch generation we use to offset everything
[00:39:35] let's put this down here
[00:39:53] okay nice
[00:39:57] maybe create some noise sounds or some
[00:40:03] what's the name poles
[00:40:07] also if you want to have this also stereo tuned
[00:40:17] you see here just there we all this
[00:40:41] and then we also do here some kind of
[00:40:48] pitch generation
[00:40:52] so this time
[00:40:58] let's down here
[00:41:03] use a different trigger
[00:41:16] like that
[00:41:18] chance module but at the moment it's 100 percent
[00:41:24] and then we use here the third
[00:41:28] the third
[00:41:32] maybe this one
[00:41:42] seventh and root i don't know maybe it's maybe a use of a different later on
[00:41:51] so then we trigger here the thing
[00:42:02] what else uh we use
[00:42:12] alpast battery
[00:42:19] so chorus
[00:42:23] we go into this and then
[00:42:37] there's another amp at the end
[00:42:54] octave
[00:43:08] how we use this
[00:43:15] then we need to modulate this
[00:43:37] so
[00:43:41] oh yeah and we need to push this here on the right
[00:44:08] in the right position and we also need to have this here right
[00:44:16] and this yeah this is the offset nice
[00:44:38] so
[00:44:41] now this this the right position i need to have what do i
[00:44:49] oh no it's the right one okay
[00:45:07] so
[00:45:37] so
[00:45:41] and the chorus
[00:46:08] so
[00:46:11] and i probably want to have
[00:46:20] a leg in there
[00:46:38] so
[00:46:41] maybe i made a mistake here
[00:47:06] but it sounds kind of right yeah probably because i use here the
[00:47:13] this one
[00:47:43] so
[00:48:05] maybe it does no delay
[00:48:35] so
[00:48:48] nice
[00:49:00] let's see what do we have here
[00:49:05] maybe don't make make something that's not too big this time
[00:49:11] that's enough i just fill in here the space
[00:49:20] display
[00:49:50] so
[00:50:04] so we create some noise sounds
[00:50:12] some random crap
[00:50:20] so
[00:50:50] so
[00:50:54] yeah go into that
[00:51:04] maybe another octave
[00:51:20] so
[00:51:24] yeah that's okay
[00:51:28] so maybe we do some multilations
[00:51:50] so
[00:52:21] so
[00:52:24] okay wonderful
[00:52:34] there we get chance
[00:52:50] so
[00:52:54] nice then lots of delay and smearing
[00:53:17] maybe do all pass but without the calculator
[00:53:29] yeah very much like this randomly
[00:53:47] so
[00:54:17] okay let's try this
[00:54:47] so
[00:54:56] i think it's better to have to see
[00:55:18] so
[00:55:20] and then we pitch this up maybe
[00:55:47] so
[00:55:56] okay that's not if he had
[00:56:17] so
[00:56:42] interesting
[00:56:47] i put the delay on that
[00:57:12] so
[00:57:21] and a leg so we don't
[00:57:27] randomize here over the smoothing of the glide
[00:57:31] see how this sounds
[00:57:42] so
[00:58:13] so
[00:58:15] okay some weird sounds
[00:58:31] love it
[00:58:42] so
[00:59:06] we should use another i'll just use all person
[00:59:36] so
[01:00:06] so
[01:00:09] and the chorus
[01:00:13] nice
[01:00:36] so
[01:01:06] so
[01:01:15] occasionally okay
[01:01:36] let's fill up the rest with a bit of noise
[01:01:45] uh low pass
[01:02:04] um output
[01:02:11] make it a bit airy
[01:02:20] there we could also kind of modulate this a little bit
[01:02:37] so instead of an lfo on random lfo i just do here
[01:02:44] triggers
[01:02:49] and generate random values and then
[01:02:54] just smooth them out with black
[01:03:01] so
[01:03:19] so
[01:03:49] yeah we could take this and
[01:03:53] no we just put it in there
[01:04:19] so
[01:04:23] use another sign in here oh yeah it fits nice
[01:04:42] it's an lfo do we have a place for an lfo
[01:04:51] let's put it here
[01:04:55] uh let's generate a random or a dies here
[01:05:04] it hurts let's see how it looks like
[01:05:35] okay
[01:05:40] for amplitude
[01:05:44] let's get an output here let's get this in here
[01:06:04] so
[01:06:08] i'm gonna need a bit of a fast up trick on here
[01:06:34] so
[01:07:03] yeah
[01:07:33] so
[01:08:03] so
[01:08:06] i put too much
[01:08:33] so
[01:08:36] and
[01:08:38] this
[01:08:42] this and
[01:08:46] another one
[01:09:03] so this time without a filter just to the pure
[01:09:10] sine wave
[01:09:33] so
[01:09:36] uh it's a bit annoying maybe i just put it in the background
[01:10:04] so
[01:10:06] we can take the noise here
[01:10:14] and put it in here
[01:10:20] let's see
[01:10:33] so
[01:10:36] nice okay let's see
[01:10:46] at this time not too too complex but it's still okay
[01:11:03] so
[01:11:33] so
[01:11:36] oh yeah the modulator stuff here also
[01:11:46] this is good
[01:11:59] nice yeah this spring stuff
[01:12:29] so
[01:12:59] so
[01:13:29] so
[01:13:59] so
[01:14:29] so
[01:14:32] a bit better
[01:14:46] yeah i think that's it
[01:14:50] kind of like it not too complex produces a lot of nice fx sounds
[01:14:59] circles around the circle of fifth so it's not in a scale
[01:15:05] it's not really resolving
[01:15:11] dope
[01:15:27] and i put this down to 80 percent let's say 75
[01:15:57] so
[01:16:01] i probably need to put here my sc dark on it
[01:16:12] and i just used the equal loudness curve
[01:16:16] there's a slight reduction here not too much
[01:16:28] so
[01:16:31] maybe bring the bass a bit more up where's the bass
[01:16:49] and there's a noise
[01:16:54] i lost my last control
[01:17:01] it's here somewhere
[01:17:24] so
[01:17:54] and the bass is a bit too static
[01:18:05] that's better
[01:18:15] okay so i put also here the matcher on it
[01:18:23] so we have a kind of similar
[01:18:27] kind of similar frequency loudness like all the other videos
[01:18:40] we can make this even
[01:18:43] more in the background
[01:18:48] let's go for 40
[01:18:53] i don't want to have this fx sound you're overpowering everything
[01:19:01] and the ducking here is also not 100 percent so the bass
[01:19:12] never goes 100 percent away and maybe make this longer
[01:19:19] maybe 400
[01:19:22] let's see how this sounds
[01:19:42] so it's on 50 percent here it's not matching completely
[01:19:55] exactly it's just you know bringing everything in a
[01:19:59] similar space
[01:20:01] yeah just record this and call it a day
[01:20:07] yes i'll probably need to save it
[01:20:14] generative
[01:20:23] it's a day at 16
[01:20:38] i have to write something like on some thoughts
[01:20:52] and i need the name damn it
[01:21:20] anyway i hope you enjoyed this how long was it
[01:21:24] one hour 20 minutes so it's not two hours
[01:21:27] so it's a pretty short video actually usually i take three hours sometimes four
[01:21:32] hours sometimes i just take one day off so i start on one day make
[01:21:39] or create for two hours and then i listen to it the next day for two hours and
[01:21:43] tweak and add something or remove stuff but this
[01:21:47] today it was but it was a quick quick one okay
[01:21:51] anyway if you have some questions let me know in the comments down below
[01:21:55] thanks for watching see you next video bye and also yeah
[01:21:59] make sure you watch the music video on my music channel
[01:22:02] link is also in the description below bye

Polarity Res Spectral Resonator Free Plugin Update Guide

polarity — Fri, 14 Aug 2026 02:00:00 GMT

Tutorial | Aug 14, 2026

Learn how to use Polarity Res, the free spectral resonator, to build resonant drums, drones and playable synth tones with MIDI, MPE and noise.

You can watch the Video on Youtube
Support me on Patreon if you like what you hear.
Download Presets, Tools and Projects on my Dispenser

Quick Answer

Polarity Res is a free spectral resonator plugin/instrument for Mac, Windows, and Linux, available as CLAP, VST3, AU, and standalone, with no payment, no email signup, no telemetry, and no locked features.
The main new feature set adds MIDI playability: mono/poly key tracking, assignable base note, attack/release, and MPE support, so the resonator can be played like a synth using its internal noise generator or an external audio source.
New resonance creation tools include spectrum hold + learn to detect prominent frequencies from input audio, plus note-scale overlays and harmonic/subharmonic overlays that snap nodes to musical scales or overtone relationships.
Each resonant node now supports individual per-note controls such as frequency offset, stereo offset, gain, steepness, resonance, and even per-note modulation like random smoothing for animated movement.
Additional workflow upgrades include a random overtone generator, presets, mix/frequency/resonance/spread/tilt/stereo controls, and the ability to turn learned or drawn resonances into drones, pads, tuned percussion, or sample-driven resonator sounds.

Short Overview

Polarity Res is a free spectral resonator plugin for macOS, Windows, and Linux, available in CLAP, VST3, AU, and standalone formats. It turns spectral peaks into playable resonances, making it useful for extracting tonal material from drums, building tuned drones, and shaping harmonic textures from either external audio or its internal noise source.

Recent updates add MIDI and MPE control, polyphonic and monophonic key tracking, per-note parameter editing, harmonic and scale-based note overlays, and a random overtone generator. In practice, this makes Polarity Res work as both an audio effect and a resonator-based instrument for sound design, microtonal experiments, pads, and playable synthetic percussion.

Key Takeaways

Free, cross-platform release with no signup or telemetry: available for macOS, Windows, and Linux in CLAP, VST3, AU, and standalone formats, with no payment, email requirement, or usage tracking.
Spectrum hold + learn captures resonant peaks from audio: the plug-in can freeze the spectrum and detect prominent frequencies from a source such as a drum loop, turning those peaks into a resonator node layout.
Global resonator shaping includes mix, frequency, resonance, spread, tilt, and stereo offset: all nodes can be adjusted together, including tilt to emphasize higher frequencies and stereo to offset each note differently between left and right channels.
Internal noise source turns the resonator into a drone/pad generator: the built-in noise generator can excite the resonances directly, allowing custom overtone structures without external audio input.
Node editing supports musical and harmonic snapping: left-click adds nodes, right-click removes nodes, and overlays can snap nodes to scales (for example root-only, root+fifth, root+fourth+fifth) or to harmonic / subharmonic series.
Harmonic mode links overtone movement to the fundamental: when harmonic snapping is enabled, moving the lowest note shifts the related overtones with it; sub mode instead derives lower partials by dividing from the topmost frequency.
MIDI mode adds mono, poly, key tracking, and MPE control: resonances can be mapped to a base note like C3/C4, played from a keyboard with monophonic or polyphonic note input, and shaped with attack/release for ring-out; MPE can modulate notes independently for pitch movement and microtonal experiments.
Per-note controls and random modulation add motion, but copying settings is missing: each note can have its own frequency offset, stereo, gain, steepness, and resonance, plus random smoothing modulation, but there is no built-in way to copy settings from one note to another yet.

Polarity Res update: free spectral resonator with MIDI, scales, harmonics, and per-note control

Polarity Res is a free spectral resonator plugin that now goes well beyond simple resonant filtering. It works on macOS, Windows, and Linux and is available as CLAP, VST3, AU, and standalone. There is no payment, no email requirement, no locked features, and no telemetry.

At its core, Polarity Res analyzes or defines sets of resonant frequencies and uses them to reshape incoming audio or synthesize sound from its internal noise source. With the latest additions, it can function both as an audio effect and as a playable instrument.

What It Does

Polarity Res lets users build a bank of resonant peaks, referred to here as nodes, across the frequency spectrum. These nodes emphasize selected frequencies and can be derived from source material or placed manually.

A typical use starts with an audio input such as a drum loop. The plugin can hold the spectrum and learn prominent frequencies from the input, identifying peaks such as kick and snare resonances. Those learned peaks become the basis of a resonator structure that can then be mixed with the original signal.

Core global controls include:

Mix: blends processed and dry signal
Frequency: shifts all nodes together
Resonance: changes how sharply each frequency is emphasized
Spread: adjusts spacing between nodes
Tilt: boosts or attenuates higher frequencies relative to the fundamental
Stereo: offsets note frequencies differently between left and right channels

These controls shape the overall spectral character of the resonator.

How It Works

Polarity Res can be used in two main ways:

Resonating external audio
Generating sound internally from noise

When external audio is used, the plugin imposes the defined resonance structure onto the incoming signal. When the internal noise generator is enabled, the resonator becomes a sound source in its own right, similar to a synth voice built from filtered noise.

This makes it possible to create:

resonant processing for loops and samples
drones
pads
synthetic struck or noisy tones
custom overtone structures

A user can manually add nodes by clicking in the spectrum display and remove them with right-click. This allows precise control over the resonant frequencies rather than relying only on analysis.

Musical overlays: scales and harmonics

A major improvement is the addition of overlay modes that help place nodes musically.

Scale overlay

The note overlay snaps node placement to a musical scale. For example, a scale such as C-sharp minor can be selected, and node placement can be constrained in several ways:

all notes in the scale
root only
root and fifth
root, fourth, and fifth
other limited subsets

This is useful when building resonances that should produce more conventionally musical intervals and tonal relationships.

Harmonic overlay

The harmonics overlay aligns nodes to integer multiples of the lowest frequency. In other words, it places resonances at harmonic positions relative to the fundamental, the lowest note in the set.

With harmonic mode enabled:

snapping follows harmonic ratios automatically
moving the fundamental also moves the overtone structure with it

That second behavior is significant: the overtone relationships remain locked when the lowest note is moved. When harmonic mode is disabled, nodes move independently.

Subharmonic overlay

There is also a sub mode, which works in the opposite direction. Instead of using higher integer multiples of a low fundamental, it uses divisions of the highest frequency:

1/2
1/3
1/4
and so on

This makes it possible to construct subharmonic structures, which can be useful for unusual tonalities and experimental resonances.

MIDI and keyboard control

Polarity Res now includes a dedicated MIDI tab, which turns the resonator into a playable instrument.

A chosen resonance structure can be assigned to a reference key such as C3 or C4. From there, MIDI note input transposes the structure across the keyboard.

Available modes include:

No key tracking
Monophonic key tracking
Polyphonic note input

In monophonic mode, the default resonance stays visible and played notes appear as ghosted transpositions. In polyphonic mode, the default voice is removed and sound is only produced when notes are played.

This works with either:

the internal noise generator, or
an external audio source such as a drum loop

Envelope-style controls

The MIDI section also adds:

Attack
Release

These control how the internally generated sound starts and fades. Increasing release creates more ring-out after a note is released, making the plugin behave more like a synthesizer with sustained decay rather than an immediately gated resonator.

MPE support and microtonal movement

Polarity Res also supports MPE (MIDI Polyphonic Expression). MPE allows expressive per-note control, such as pitch movement affecting only one note of a chord while other notes stay fixed.

In practice, this enables:

individual note pitch bends within a chord
expressive spectral movement
experimentation with microtonality

For a resonator-based instrument, this is especially useful because each note can carry its own overtone structure while still responding independently.

Per-note parameter control

Another important addition is individual note settings. Previously, many controls applied globally to all nodes. Now each note can have its own values for parameters such as:

frequency offset
stereo offset
gain
steepness
resonance

This makes it possible to build much more complex and animated spectra, where some resonances behave differently from others.

Each note can also receive its own modulation. One example shown is random smoothing in Hertz, used to modulate parameters such as gain amount over time. This introduces subtle or unstable movement into specific resonances rather than the entire structure.

At present, there is no stated feature for copying all settings from one note to another, so per-note adjustments must be entered individually.

Random generator and presets

Polarity Res now includes a generator for creating random resonance setups. This is useful for quick exploration, especially when paired with MIDI input and the internal noise source. Randomized overtone structures can quickly produce strange, percussive, or drone-like timbres.

There are also presets, including examples based on the prominent frequencies of recorded sources such as a rim shot. These presets represent stored overtone or resonance profiles rather than exact recreations of the original sound. The result depends heavily on the excitation source used, such as pink noise or other external material.

Workflow

A practical workflow can look like this:

Load Polarity Res as an effect or instrument.
Feed it a source such as a drum loop, or enable the internal noise generator.
Use Learn to detect prominent frequencies, or place nodes manually.
Refine the spectrum using frequency, spread, tilt, resonance, and stereo controls.
Switch on a scale, harmonic, or subharmonic overlay if a more structured result is needed.
Assign a reference note in the MIDI tab.
Play the structure monophonically, polyphonically, or with MPE.
Add per-note offsets or modulation for motion and complexity.

This supports both sound design and musical performance.

Practical uses

Polarity Res is especially suited to:

extracting resonant profiles from recorded material
turning noise into tonal drones and pads
building harmonic or subharmonic textures
creating playable resonator instruments
spectral experimentation with MIDI and MPE
imposing custom overtone structures on samples or loops

Because it supports both internal excitation and external input, it can move between effect processing and synthesis without changing tools.

Limits

A few practical constraints are worth noting:

Some features still require manual setup, especially per-note programming.
Presets based on analyzed sounds do not automatically reproduce the exact source timbre; the excitation signal matters.
Bugs are expected, and troubleshooting depends on detailed system and reproduction information.

Summary

Polarity Res has developed from a free spectral resonator into a hybrid tool that covers resonant processing, overtone design, MIDI performance, and noise-based synthesis. New scale and harmonic overlays make it easier to build musically coherent structures, while MIDI, polyphony, MPE, and per-note control push it into instrument territory.

For users interested in spectral shaping, drones, resonant synthesis, or experimental harmony, it now offers a much deeper workflow without adding payment barriers or account requirements.

Transcript

This is the transcript of the video. The text was generated automatically and may contain small mistakes. The timestamps jump to the matching part of the video.

Click to expand transcript

[00:00:00] Yo, welcome back. I want to give you an update on my plug-in called polarity res which is my spectral resonator and
[00:00:07] I made a video about this a few months ago, but I had some new features. I want to show you so there's some new stuff
[00:00:14] Right, it's still completely free. You don't need to pay anything. I don't want you email address
[00:00:19] There's no in telemetry or anything like this. No. I lock nothing. Okay. It works on all systems
[00:00:26] Mac windows and linux and it's available in all kinds of formats. So a clap VST 3
[00:00:32] AU and standalone. There's a download down here and some install instructions
[00:00:40] Okay, so the link to this website is in the description below
[00:00:43] So I want to show you what's new in polarity res, right? So here that's the plug-in window when you open it
[00:00:50] I'm using here the clap version and let's say you have this drum loop here, right?
[00:00:57] So what you can do now is you can hold the spectrum
[00:01:00] So we have this frequency curve here and then we can learn and it tries to figure out here all the prominent frequencies
[00:01:09] so we have the kick drum here, of course, we have the snare drum and
[00:01:12] Yeah, this is how it looks like. This is our kind of resonator now
[00:01:25] We can also match here the input to the output signal. So when we hit play
[00:01:29] And then we can use the mix button
[00:01:38] It can also change the frequency for all of the nodes
[00:01:44] Change the resonance or we can change the spread
[00:01:55] or
[00:01:57] We can change the tilt
[00:02:03] So all the upper frequencies are have or get more gain than the fundamental
[00:02:11] Then we have stereo which means each note gets a different frequency on the left and the right channel
[00:02:25] Yeah
[00:02:27] Yeah, so these are basically the basic controls. We also have here a noise generator. It's just it just plays a noise sound
[00:02:42] You can
[00:02:48] So we can basically use this as a
[00:02:51] Drone generator you can create of course your own overtones here
[00:02:57] But we just copied this from the drum loop. So maybe we just clear this here. We create our own
[00:03:02] Maybe put the spread here on zero back and steepness frequency
[00:03:19] Okay, so yeah, that's not all we can also instead of just
[00:03:23] Left-clicking here and creating new notes. We can also right-click and remove these notes
[00:03:28] We can also use an overlay like a note overlay and say yeah, we want to
[00:03:33] Create something in the sharp minor for whatever reason and we have here the full scale
[00:03:39] Which means all nodes, but we can also say we only want to have the root nodes of the scale or the root and the fifth and the root
[00:03:45] The fourth and the fifth and so on right and then we can create here
[00:03:49] Much better musical outcome. So we can use the noise again there. We can snap
[00:03:54] Something like that
[00:04:09] Yeah, we can create
[00:04:16] Kind of drones or pad sounds with that. So this was the idea
[00:04:20] If you don't want to use notes, we can also use here the harmonics overlay looks like this and it's all
[00:04:27] Always aligned with the fundamental with the lowest
[00:04:31] note here, right and
[00:04:34] You can see here all these lines are multiples of the fundamental frequency, right?
[00:04:40] So this is the first harmonic second harmonic or third harmonic and
[00:04:44] Then it also snaps your to all these
[00:04:46] lines automatically, so you create easily
[00:04:50] single sounds with different harmonics and
[00:04:54] Also the specialty of this mode when this is here enabled when you move the lowest fundamental or the overtones or move with it
[00:05:04] Right, which is not the case when this is off
[00:05:14] Software like that. So this is important. There's also a different
[00:05:18] mode here sub mode, which is just the opposite way. It takes the
[00:05:22] uppest up
[00:05:25] the top most
[00:05:27] fundamental here and then
[00:05:29] Kind of halves or always the frequency red
[00:05:33] So this is the frequency and then is half the frequency a third of this frequency a fourth of this frequency and so on right
[00:05:40] So you can create sub harmonics
[00:05:43] It's also snapping here with this if you want to do that
[00:05:46] Also important to know if you create let's say a sound like that
[00:06:02] Some overtones here
[00:06:07] So this frequency is somewhere right it's it's
[00:06:13] No specific frequency, but when you want to play this on the MIDI keyboard, which you can do
[00:06:18] You gave you go basically here to this MIDI tab
[00:06:22] You can say I want to send up this on C4, right? So this is now on C4
[00:06:27] or C3
[00:06:29] what to do that and
[00:06:31] With that we can enable here the
[00:06:34] Yeah, MIDI input MIDI keyboard input and we can also enable here the key tracking to mono
[00:06:42] Right and we can change the frequency
[00:06:44] the main or the
[00:06:46] Default frequencies here are stay in place, but you can see these ghost notes here appearing
[00:06:52] This is basically what you play on the keyboard. So we dial in here the noise
[00:06:56] Right and then we can also switch it to polyphonic which
[00:07:07] Removes the default voice and it's quiet now because we haven't pressed the note yet. So we can press a note and
[00:07:13] press multiple notes
[00:07:16] And if you don't want to use the internal noise generator you can also use samples so here
[00:07:30] I'm just using the drum loop again and then we play some notes
[00:07:37] And
[00:07:39] We also have here on the MIDI tab we have attack and release which means we can
[00:07:50] kind of influence how the
[00:07:53] Yeah, release time or attack time is so
[00:07:55] Let's stop this here and go back to the noise
[00:07:58] And then we can say when we release the note
[00:08:02] It has more
[00:08:05] Ring-out time so it's not immediately here
[00:08:08] So you can almost use this like a synthesizer where you can define the overtones
[00:08:32] So it's pretty interesting and nice to experiment with in my opinion
[00:08:36] Then there's of course here MPE. So you can also use MPE for that
[00:08:42] Maybe I just create here
[00:08:45] Can I do this?
[00:08:48] Some notes because I can show you this here outside you can use an MPE keyboard if you want to
[00:08:54] Let's use a note here
[00:09:01] And then we use
[00:09:03] Maybe make this a bit longer
[00:09:14] Something like that
[00:09:22] But more drastic
[00:09:32] You can see only one note is going down to the other note stays on the frequency
[00:09:37] So yeah MPE also works with that and you can experiment with resonances in
[00:09:49] Microtronality if you want to do that. So this is here the new MIDI tab
[00:09:56] Maybe there's more coming to this step, but for now that's it. Then we have some people want to have individual
[00:10:03] Settings for individual notes, right? So here we can change
[00:10:09] Of course the tilt
[00:10:12] Like that
[00:10:16] You can also change the stereo, but it's always for all the notes
[00:10:21] So here we can just say I want to change this note and you can see single note to offset, right?
[00:10:28] So we can say we want to have a different frequency here for that and so on
[00:10:32] We also have here a stereo for each note gain
[00:10:47] Steepness resonance for each note. So everything is specific. You can also say I want to have this note
[00:10:54] And I want to modulate this here with the random smoothing Hertz
[00:10:58] And I want to change the not the frequency I want to change the gain amount something like that
[00:11:14] I'm going to go to this note here also Hertz
[00:11:17] Maybe I need to be something where you can copy all the settings from one note to the other
[00:11:24] But yeah, it's not in there yet. Yes, you have to dial it in every time
[00:11:28] So with this you get a bit of movement in different frequencies and you can experiment with that also interesting
[00:11:41] Then I also added here a generator
[00:11:44] If you want to use that you can just generate here random
[00:11:50] Resonances
[00:11:54] Nice put this on C4 or it's already on C4 C3
[00:12:14] I think this is almost not an audio FX anymore
[00:12:17] It's more like a synthesizer, but you can use it in in both directions
[00:12:21] We can say oh, I want to create a sound with overtones
[00:12:24] Or I want to put this on a sound and just you know instead of using the internal noise source
[00:12:31] I want to use my own samples from the outside you can do that
[00:12:34] There are also now presets here
[00:12:40] So this is rim shot, can I actually play this I have to probably use an internal noise here
[00:12:48] MIDI
[00:12:53] Yeah, these are just the overtones of an
[00:13:05] Of a rim shot you probably need to have some
[00:13:11] Specific
[00:13:13] Noise input here, let's use a test tone
[00:13:16] Let's use pink noise maybe
[00:13:20] and
[00:13:22] Put this on
[00:13:24] onophonic or off
[00:13:26] Then we can use it as external noise source use an LFO
[00:13:32] And
[00:13:37] Steep
[00:13:41] I
[00:13:43] Feel like that
[00:13:47] I can almost create an
[00:14:11] I
[00:14:13] Doesn't sound like a
[00:14:17] Rimshot at all, but I just copied or cloned or saved the preset from a rim shot here with all the prominent frequencies
[00:14:24] You get in the same direction you get what I mean
[00:14:27] So yeah, these are basically all the new features we have individual note settings here
[00:14:34] We have a generator in there for generating random overtones
[00:14:38] We have this MIDI tab now where we can use polyphonic
[00:14:42] Note inputs monophonic note inputs on no key tracking at all
[00:14:46] We can change here the ring out or attack time when we use the internal noise generator
[00:14:52] So there's a lot of stuff in there. I would say that you can try and use and
[00:14:57] It's now also an instrument because you just need to have an external noise source anymore
[00:15:04] You can just use the internal noise generator and then play it on the keyboard
[00:15:08] Polyphonically or with the with the MBE keyboard and you have some fun with it, right?
[00:15:14] So again, that's polarity res as always completely free
[00:15:20] And head over to the website. Let me know what you think. There are probably some bucks
[00:15:26] Probably 100%
[00:15:30] But yeah, I'm trying to fix it if you give me exactly what kind of system you use
[00:15:36] Where the problems are I can fix it. Okay. Thanks for watching and have a good weekend

Stay Here Until Everything Feels Distant

polarity — Sun, 09 Aug 2026 02:00:00 GMT

Music-Video | Aug 09, 2026

A self-running Bitwig Poly Grid soundscape where a sustained drone carries wind, rain, noise, and small randomized percussion through dense delay and reverb.

You can watch the Video on Youtube.
Support me on Patreon if you like what you hear.
Download Presets, Tools and Projects on my Dispenser

About This Soundscape

The preset behind this soundscape is called TiefMief, the German name for Deepstink in The Ascent. The name started as a joke, but it fits the buried cyberpunk atmosphere surprisingly well.

There is no conventional melody leading the piece. A long drone and pad-like layer provide a stable center while filtered wind, occasional rain, random noise artifacts, and small percussive sounds move through delay and reverb. Most events and movements are heavily randomized, but the layers are deliberately blended into one space so that no single element pulls too far forward. The result is designed to keep evolving quietly in the background for the full hour.

Inside the Patch

The patch is not one large signal chain. The analyzer found eleven Audio Out modules, which indicates eleven separately assembled sound branches feeding the preset output. Across those branches are sine, sawtooth, and noise sources, scale-aware pitch processing, probability-based triggers, filters, delays, chorus, pitch shifting, and other processing.

Random control is a major part of the design. The graph contains 44 Dice modules alongside S/H LFO, Chance, Probabilities, Sample / Hold, trigger, clock, and transport modules. Pitch-related modules constrain parts of that movement, while Robert's listening notes establish that the sustained drone remains the carrying layer.

Spatial processing is distributed throughout the patch rather than handled by a single global block. The analyzer found 84 All-pass Delay modules, with several output branches containing their own large diffusion networks, plus Chorus+, Mod Delay, Long Delay, and Pitch Shift modules. This helps explain why the wind, rain, percussion, and noise details feel embedded in the same deep space.

For more on the underlying techniques, see Bitwig Grid Ambient Patches From Noise to Raindrops and All-Pass Reverb in Bitwig Grid That Sounds Diffused.

Technical Snapshot

Created in Bitwig Studio 6.0.6
Device: Poly Grid
487 parsed modules
498 detected connections
11 Audio Out modules
44 Dice modules
84 All-pass Delay modules
8 Noise, 9 Sine, and 2 Sawtooth modules
Duration: 59:57
Preset: free download from the Dispenser

Bitwig Grid Probabilities for Weighted Random Modulation

polarity — Fri, 07 Aug 2026 02:00:00 GMT

Tutorial | Aug 07, 2026

Learn how to use Bitwig Studio Grid with the Probabilities module and Sample and Hold to create weighted random modulation and note sequencing.

You can watch the Video on Youtube
Support me on Patreon if you like what you hear.
Download Presets, Tools and Projects on my Dispenser

Quick Answer

To create weighted random modulation in Bitwig, use a Grid patch with Steps + Probabilities + Sample and Hold + Modulator Out instead of the standard Random modulator, because the Random modulator distributes values evenly and cannot favor some values over others.
Basic patch: send the same synced phase/ramp signal (from Transport or Clock) into both Steps and Probabilities, disable each module’s internal pre-cord, then feed Steps into Sample and Hold as the value source and Probabilities into Sample and Hold as the trigger/gate so only selected steps pass through.
For wavetable index selection: set Steps to 4 values matching the 4 wavetable positions, then set probability weights per step; e.g. Saw high, Sine medium, Triangle low, Pulse zero. Route the result to Modulator Out and assign it to Polymer’s wavetable index so disallowed positions never occur.
To control behavior over time: change the scan speed with Transport/Clock rate, and add Lag or Average before Modulator Out to smooth abrupt jumps between chosen values.
Alternative routing: place a Note Grid/FX Grid in Polymer’s Grid slot and send the weighted-random signal out via CC Out, then receive it with a MIDI modulator on the device; the same method also works for weighted random note generation by replacing Steps with Pitches.

Short Overview

Controlled randomness in Bitwig Studio with Polymer and The Grid allows modulation and note generation to follow weighted probability instead of uniform random distribution. This matters when certain values should occur more often than others, such as favoring specific wavetable positions, excluding unwanted timbres, or prioritizing musically useful notes in a scale.

A practical setup uses a Step mod or Pitches module, a Probabilities module, and Sample and Hold to create a probability-driven control signal. That signal can then be routed through Modulator Out or MIDI CC to modulate Polymer parameters like wavetable index or cutoff, giving precise control over which random outcomes are likely, rare, or impossible.

Key Takeaways

Bitwig’s standard Random modulator can set a start point, modulation range, and rate/smoothing, but it produces an even distribution across the whole range, so it cannot make some values more likely than others.
A weighted-random modulation source can be built in The Grid by pairing a Steps/Step Mod module with a Probabilities module, giving each step a target value and an independent chance of occurring.
To keep value selection and probability selection aligned, both modules should have the same number of steps and both should be driven by the same phase/ramp source (for example, Transport), with each module’s internal playback disabled.
The Sample and Hold module is the key to the workflow: feed the step values into the signal input and use the Probabilities output as the trigger/gate so only allowed or likely values are captured at each step.
This setup is useful for wavetable index selection in Polymer: assign four steps to the four waveforms, set one step’s probability to zero to exclude a waveform entirely, and bias the others so one waveform appears most often.
The generated control signal can be sent to devices either with Modulator Out inside an FX Grid or via CC Out + MIDI modulator when using a Note Grid/Note FX workflow inside Polymer’s Note FX box.
Fast weighted stepping can be made more musical by adding Lag or Average after the sampled signal, which smooths transitions between chosen values instead of hard-jumping every step.
The same probability-driven pattern works for note generation: use a Pitches module for scale notes, scan it with a clock, weight note likelihood with Probabilities, then use an additional Sample and Hold triggered at a musical rhythm to create a probability sequencer for pitches.

Controlled Randomness in Bitwig: Weighted Probabilities for Modulation and Note Generation

Bitwig’s built-in Random modulator is excellent for assigning values within a range. It can define a starting point, an endpoint, and how quickly the value changes. What it cannot do directly is control which values inside that range are more likely to occur.

That missing piece matters whenever random should be guided rather than uniform.

A practical example is wavetable scanning in Polymer. If a wavetable contains four waveforms, sine, triangle, pulse, and saw, it may be useful to randomize the wavetable index while making saw occur most often, sine and triangle occasionally, and pulse never. Standard random modulation does not offer that kind of weighted distribution. The Grid does.

What It Does

This technique creates weighted randomness: a signal where some values are more likely than others.

Instead of letting random values land anywhere with equal probability, the patch defines:

a fixed set of possible values
a probability for each value
a clock or phase source that determines when values are evaluated
a sample-and-hold stage that outputs only the selected values

This can be used for:

modulation targets such as cutoff or wavetable index
note generation from a scale
sequencer-like behavior with controllable randomness

Why the Standard Random Modulator Is Not Enough

A normal random modulator in Bitwig can already control:

start position: the base value of the parameter
modulation range: how far it can move
rate: how quickly it changes
smoothness: how abrupt or gradual the transitions are

But it distributes values evenly across the range. Every point is equally likely.

That is often fine for generic motion. It is not enough when certain states should dominate and others should be rare or excluded entirely.

How It Works

The core idea is to separate value selection from probability selection.

One Grid module provides the possible values. Another provides the probability gates. A shared phase source keeps them aligned. A Sample and Hold module then outputs only the values allowed by the probability pattern.

The important modules are:

Step Mod or another value source
Probabilities
Transport or Clock
Sample and Hold
Modulator Out or CC Out

Workflow

1. Define the possible values

Use a Step Mod with one step per target value.

For a four-waveform Polymer wavetable, set the Step Mod to four steps so each step corresponds to one waveform position:

sine
triangle
pulse
saw

The exact step values should match the wavetable index positions needed by Polymer.

This module acts as a lookup table of allowed values.

2. Drive the step position with phase

Use Transport to generate a phase signal, then disable pre-cord on the Step Mod and feed the phase into it.

This makes the Step Mod scan through its steps in sync with musical time rather than free-running internally.

Rate can be set musically, such as:

quarter notes
eighth notes
other synced divisions

3. Create matching probability weights

Add a Probabilities module and set it to the same number of steps as the Step Mod.

For the four-waveform example:

set the saw step high
set pulse to zero
set triangle low
set sine medium

Then disable pre-cord on the Probabilities module and feed it the same phase signal used by the Step Mod.

Now both modules are perfectly aligned: each step in the value list has a corresponding probability weight.

4. Use Sample and Hold to output only selected values

Add Sample and Hold.

Feed the Step Mod output into the value input.
Feed the Probabilities output into the trigger input.

The probability module determines when a value is accepted. When a gate occurs, Sample and Hold captures the current value from the Step Mod.

This is the key operation. Without it, the patch would simply scan all values in sequence. With Sample and Hold, only the probability-approved values become output.

5. Send the result to a modulation target

To use the signal as modulation, send it through Modulator Out.

That output can then modulate parameters such as:

Polymer wavetable index
filter cutoff
any other assignable destination

In the wavetable case, the index moves among the selected waveform positions, but values assigned zero probability never occur.

Smoothing the transitions

Stepped values can sound abrupt, especially when modulating timbral parameters such as wavetable position.

To soften this, insert a smoothing module before Modulator Out, such as:

Lag
Average

This creates glides or eased transitions between selected values.

The result is similar to increasing smoothness on a Random modulator, but now the distribution is weighted rather than uniform.

Alternative routing: Node Grid inside Polymer

Instead of placing Polymer inside an FX Grid, the setup can be moved into a Note Grid or Grid module inside Polymer’s Note FX slot.

In that arrangement:

the Grid patch generates the weighted control signal
CC Out sends it as MIDI CC
a MIDI modulator inside Polymer receives that CC
the received signal modulates the target parameter, such as wavetable index

This can be cleaner structurally because the Grid lives inside Polymer’s modulation path rather than wrapping the whole instrument. The tradeoff is additional MIDI-based routing.

Practical Uses

Weighted wavetable selection

This is one of the clearest examples.

A wavetable might contain four regions, but not all are equally useful in a patch. Weighted probabilities allow:

frequent use of the most musical waveform
occasional variation to secondary waveforms
complete exclusion of unwanted waveforms

That yields movement without losing character.

Weighted filter motion

Filter cutoff can also benefit from weighted randomness.

Instead of a uniform spread between low and high values, the patch can favor:

mostly dark tones with occasional bright spikes
mostly open states with rare closed dips
a few “sweet spot” regions that recur more often

This is useful when random modulation should stay musically centered.

Probability-based note generation

The same method works for pitch.

Replace the step-value source with a Pitches module containing notes from a scale, for example A minor using white keys. Then:

use one step per note
align a Probabilities module with the same number of steps
assign higher probability to preferred notes such as the root
assign lower or zero probability to less desirable notes

Sample and Hold again captures only the approved pitches.

A Quantizer can be added if needed, and a second Sample and Hold can be used to trigger pitch changes at a more musical rhythm than the fast scanning clock.

This effectively creates a probability sequencer: note choices are random, but their likelihood is controlled.

Building more musical rhythm into note changes

For note generation, it can help to separate:

the fast scan rate that checks available pitches and probabilities
the slower musical trigger that decides when an actual note change happens

For example:

scan candidate notes quickly
hold and output a new pitch only every quarter note

This keeps selection varied while making the musical phrasing more coherent.

Relation to Markov-style sequencing

This weighted-value method controls how likely each value is in general.

A more advanced system, such as a Markov sequencer, goes further by controlling what value is likely to come next depending on the current value.

That means not only saying:

“root should happen often”

but also:

“if currently on the root, the next note is likely to be the dominant”
“if currently on the dominant, the next note is likely to return to the root”

The probability patch described here is simpler, but it forms a useful foundation for those more advanced generative systems.

Limits

This approach is powerful, but it has tradeoffs.

It is more complex than using a standard Random modulator.
It is not as immediate to set up for quick experimentation.
Polyphonic behavior is less straightforward.
Some routings may require nesting devices or using MIDI CC as an intermediate path.

For simple random motion, Bitwig’s normal modulation tools remain faster. This Grid-based method is most useful when the randomness itself needs structure.

Summary

Controlled randomness in Bitwig can be built by combining:

a module that defines possible values
a Probabilities module that weights those values
a shared phase or clock source
Sample and Hold to capture only probability-approved values
an output stage such as Modulator Out or CC Out

The result is a reusable pattern for generating modulation or notes where some outcomes are common, some are rare, and some never happen at all.

That makes random behavior much more musical when equal distribution is too blunt.

Transcript

This is the transcript of the video. The text was generated automatically and may contain small mistakes. The timestamps jump to the matching part of the video.

Click to expand transcript

[00:00:00] Okay, so in this video, I'll try to explain to you how to implement controlled randomness
[00:00:06] or I don't know how to call it or probability values.
[00:00:11] And the hardest part is probably to explain what I actually mean by that and why you want
[00:00:17] to need it or why you need it, because this is something you don't need all the time.
[00:00:24] But when you need it, it's not straightforward to implement.
[00:00:28] So let's say you have a synthesizer here.
[00:00:30] So we have polymer here in Bitwig Studio, and you want to randomize the cutoff knob position,
[00:00:36] which is very easy to do because you just use a random modulator here and we use it
[00:00:42] in a monophonic way.
[00:00:44] And we increase here the smoothness and we modulate the cutoff knob.
[00:00:50] So with this, we can already define a lot of things.
[00:00:54] We can define where we start, which is the initial position of the cutoff knob, which
[00:00:58] is here at 262 Hertz.
[00:01:02] And we can define the endpoint of the modulation, which is this position here.
[00:01:06] And we now know that there are random values happening between the start point and the
[00:01:12] end point of this kind of defined range here.
[00:01:17] We can also change the speed of the modulation or the automation, and that's basically it.
[00:01:26] But what we can't define is which values between these two points, the end points and the start
[00:01:33] point and the endpoint, are more likely to happen.
[00:01:38] So you can see here the randomness is equally distributed between the two points.
[00:01:43] So all kinds of different positions in between can happen.
[00:01:47] And sometimes you want to define that.
[00:01:50] You want to define what kind of values are more likely than others.
[00:01:57] I hope this makes sense.
[00:01:59] Maybe a better example would be if you use the random modulator here on the wave table,
[00:02:05] where we modulate the index of the wave table.
[00:02:08] And we have here four different waveforms in the wave table.
[00:02:11] We have the sine, the triangle, pools, and saw.
[00:02:17] And sometimes you want to define, you want to say, I want to have a random waveform, but
[00:02:23] I don't want to have the pools waveform not happening at all.
[00:02:29] Most of the times I want to have the saw, sometimes I want to have the sine, and maybe
[00:02:35] sometimes the triangle, but the pools not at all.
[00:02:39] And I want to have a randomized.
[00:02:41] So now we have a problem that this random modulator here is equally distributed.
[00:02:46] So all kind of values can happen all the time.
[00:02:49] You have no influence of which values are more likely than others.
[00:02:54] I hope this makes more sense.
[00:02:56] So this would be a practical example for that.
[00:03:00] So how do we implement this?
[00:03:01] This is not straightforward.
[00:03:03] And sometimes you want this, and this is what I show you.
[00:03:07] So you can't do this inside of the modulation matrix here of Bittrick Studio.
[00:03:13] Maybe you can with a lot of modulators and a lot of complexity, but in my opinion, it's
[00:03:17] much easier when you use the grid for that and combine it with the modulation system.
[00:03:24] So we can do this by using an FX grid here.
[00:03:28] You can use whatever you want to use, but I start with an FX grid.
[00:03:33] And we first prepare a signal that we then later on use to modulate something.
[00:03:40] So we can start by, let's say, use a step modulator steps like that.
[00:03:49] And we know that inside of the polymers synthesizer here, we have four waveforms.
[00:03:55] So the sine, tri, pools, and so on, right?
[00:03:59] And we can say, we just use four different steps.
[00:04:04] And we want to have the sine in there.
[00:04:08] We want to have the triangle in there.
[00:04:10] Maybe I can create here just an saw.
[00:04:14] No, that's not going to work.
[00:04:17] Something like that, right?
[00:04:19] So we have the sine.
[00:04:21] We have the triangle, pools, and sine of saw.
[00:04:26] And then we can put here the whole polymers synthesizer into the post FX like that.
[00:04:32] So now we can use here this output and modulate the index.
[00:04:37] You can tweak this a little bit here.
[00:04:41] Maybe like this.
[00:04:42] This should be 75 probably.
[00:04:47] Yeah, OK.
[00:04:51] OK, so this is not what we want.
[00:04:52] So we want to use now, let's say, a transport, which gives us here this kind of phase signal.
[00:05:04] And this phase signal should happen across quarter nodes, one quarter node maybe or two
[00:05:10] quarter nodes, which is in half, half step here, half node, anyway.
[00:05:17] So we then disable here the pre-code of this step sequencer or step mode.
[00:05:23] And we use the output here of this and drive this step mode here with the transport output.
[00:05:29] So the phase signal of the transport drives the position of the step mode.
[00:05:35] Very easy.
[00:05:37] Now use a probabilities module looks like this.
[00:05:43] And we can define also here now the probabilities of each step.
[00:05:46] So we go to the left side here in the inspector and pull this down to four.
[00:05:51] So we have four possible faders for four steps.
[00:05:56] And we want to say the saw should happen most of the time.
[00:06:02] The pull is not at all, so it's zero.
[00:06:06] Then maybe to try and the sign is also cool.
[00:06:11] So also here with disable the pre-code, we use the same phase signal from the transport.
[00:06:16] So now it's synchronized.
[00:06:18] So each step of the step mode equals to each step of the probability sequencer or the probabilities
[00:06:27] module.
[00:06:28] So all we have to do now is to use here maybe an oscilloscope to check the output.
[00:06:38] So here we have all values happening all the time, all over the place, one after the other
[00:06:45] because the step sequencer just runs.
[00:06:48] And then we use here at the bottom input, we use sample and hold.
[00:06:55] And also the signal from the step mode goes into the sample and hold.
[00:06:58] And also the output of the probabilities module goes into the sample and hold to actually
[00:07:04] trigger when we want to sample the data from the step mode.
[00:07:13] So you can see now here that we have the pulls not at all happening.
[00:07:19] So this value is not coming through at all.
[00:07:22] But most of the times we get the saw and sometimes the sign which is down here.
[00:07:27] And very rarely we get the triangle in the middle.
[00:07:31] So now this is very slowly happening or modulating here.
[00:07:37] So all we have to do now is use a modulator out module which gives us kind of a wireless
[00:07:48] ability to modulate here the cutoff or here this kind of thing.
[00:07:53] So let's modulate the index here of the wave table.
[00:07:58] Now we can see we move through the wave table but we never end up on the pulls.
[00:08:05] Does it make sense, I hope so.
[00:08:07] So we can now change the speed of this modulation exactly like we could here do this in the
[00:08:14] random modulator itself.
[00:08:16] So we have here Hertz, then we go to eight note, right?
[00:08:20] Then we have a much faster randomization.
[00:08:24] So we go to eight note, one eight note.
[00:08:27] And you can see we step through each wave from here pretty fast.
[00:08:33] So what we can do about this is also we can make some smoothing happening.
[00:08:40] So we can use maybe an average or maybe a lag module before we go into the modulator
[00:08:50] out and we can change how the transitioning here happens, right, it looks like this.
[00:09:05] Maybe it's a bit too fast, maybe I go to quarter notes here.
[00:09:13] So now with this we can create some kind of values that are more likely than other values
[00:09:21] and you don't need this all the time but sometimes you want exactly that.
[00:09:26] So we don't need a oscilloscope here, that's all we need, these two or these modules here
[00:09:32] in combination.
[00:09:34] You can do this in all kinds of different ways.
[00:09:36] If you want we can just use here this phase signal for the modulation signals, you can
[00:09:43] go straight into that.
[00:09:45] But here you have a bit more control if you use a step mod in between because you can
[00:09:51] decide what kind of step gets which kind of value, right?
[00:09:56] Also a downside is this is not polyphonic, you can do it probably polyphonic by just
[00:10:05] switching here voices on and then you have for each voice multiple modulations.
[00:10:14] But yeah, it's not as straightforward as using just a modulator here.
[00:10:19] Another thing is if you don't like to have this polymer inside of the FX grid, so it's
[00:10:25] like a nested, we can also do something different which looks a bit better but also has a downside
[00:10:32] of course, we can say we use the polymer outside of the FX grid and then we change the FX grid
[00:10:38] to maybe a node grid, something like that and then we put this into the node FX box
[00:10:47] here of the polymer itself.
[00:10:49] So now the node FX or the node grid is inside of the node FX box of the polymer so it wraps
[00:10:57] a bit better or it's more logical in a way.
[00:11:00] We also have here a node through active, we can also instead of using now here this modulator
[00:11:08] out use just a CC out something like this and we send this data the same signal we send
[00:11:16] out as MIDI CC 1 on channel 1, okay?
[00:11:22] And you can then load here a MIDI modulator, looks like this, and we receive the data from
[00:11:33] this output here basically in here, oh we have no signal, sorry, and then we modulate
[00:11:48] of course here the index of the wave table.
[00:12:12] So you have a bit of control over the randomness what's happening.
[00:12:17] I showed something like this in a video a few years ago where I use this for generating
[00:12:23] nodes because this is also possible, so instead of doing that we can say we have a node grid
[00:12:32] in here and we use maybe pitches module like that, I can say I want to have all kinds of
[00:12:42] different nodes in a scale maybe or maybe use your A minor, it's a bit easier.
[00:12:54] So we select here all the white keys, something like that, we maybe don't need eight, we need
[00:13:02] seven maybe so we end up on A again.
[00:13:05] We do the same trick here, right, so we disable the pre chord of the pitches module, we use,
[00:13:14] what can we use, use a probability, probabilities module, we also use here seven steps, we disable
[00:13:22] this, and we scan through that maybe with a clock like that, pretty fast, 32 hertz which
[00:13:32] is a ramp signal then, scanning through the nodes and also scanning through the probabilities
[00:13:39] and then we use here a sample and hold for that and we can now decide oh this node which
[00:13:47] is the root node should happen all the time and maybe where's G this one here, this is
[00:13:53] G actually, yeah this is G, so G the dominant we also want to happen all the time and then
[00:14:01] we get a different node here at the end, use a quantizer, let's see how this looks like.
[00:14:14] So we have A and G, oh it's probably E is the dominant right, not G, G is the dominant
[00:14:23] of C, sorry, maybe something like this, so we get only these two nodes and you can decide
[00:14:35] which nodes are more interesting to you than others in the scale and then you end up with
[00:14:41] the stuff, so then we have here the pretty fast pitch changes, right, so we use another
[00:14:46] sample and hold, yeah and we trigger this with more like, more musical rhythm, let's
[00:14:57] say every quarter note here, every quarter note and then we go from that or maybe from
[00:15:05] that trigger, so you can build more or less a probability sequencer because you can decide
[00:15:35] which nodes you like more than others from a scale and how often they should occur in
[00:15:41] a sequence, right, so it's very easy to do actually in Bitwig if you know the patch,
[00:15:46] so yeah, this is basically a modification of this what we did earlier with the modulations,
[00:15:53] it's all like, you know, it's just a signal and you can decide which kind of values you
[00:15:59] want to have more inside of the signal and then you use the signal for pitch generation
[00:16:03] modulation or I don't know sound design or whatever, so yeah, this is how you do it,
[00:16:11] the probabilities module here is very nice for that and then you need another module that
[00:16:16] spits out the values and then you sync basically the position of the probabilities module to
[00:16:23] the data module and then you use the sample and hold and the gates from the probabilities
[00:16:30] module then hold the right values when here a gate happens, yeah, I hope I explained this
[00:16:38] actually well and you understand what I mean by that, I don't know if you could follow this
[00:16:44] at all, I tried to make it as easy as possible, I hope we get something like this here as a
[00:16:52] modulator at some point where you have like a matrix of values and then you can decide you
[00:17:01] know which values you want to have more than others or maybe something like Markov chains,
[00:17:06] I showed you also at some point I have here a Markov sequencer, I made this a few years ago,
[00:17:14] looks like this here also a lot of values and then here a lot of probabilities modules,
[00:17:20] so here the difference is it's not only deciding which values you want to have more inside of
[00:17:27] the signal, you can also decide where you go next, right, so if you are on the first scale note,
[00:17:35] it's more likely that you go to, I don't know, the dominant note right after that and if you
[00:17:47] are on the dominant it's more likely that you go back to the first note, right, so with this you
[00:17:54] can generate a lot of nice melodies or note sequences, so yeah this is basically how you use
[00:18:02] it to generate modulations, I want to show you this because I just did this yesterday and I thought
[00:18:09] it's maybe a good idea to explain this in a video, yeah maybe I put this here on my on my
[00:18:18] github so you can just download this, anyway, if you have some questions let me know in the
[00:18:22] comments down below, leave a like if you liked the video and just ask if this is too complicated or
[00:18:29] you don't know how to use it and what I actually just explained, just let me know in the comments,
[00:18:34] I maybe make another video or maybe write a blog post that goes more into detail, I don't know,
[00:18:41] anyway leave a like, see you in the next video, thanks for watching and bye.

Bitwig Studio Poly Grid Bass Generator for Random Wavetables

polarity — Sat, 01 Aug 2026 02:00:00 GMT

Tutorial | Aug 01, 2026

Learn Bitwig Studio Poly Grid bass sound design with a random wavetable and PM generator, then render stable bass patches for drums and basslines.

You can watch the Video on Youtube
Support me on Patreon if you like what you hear.
Download Presets, Tools and Projects on my Dispenser

Quick Answer

Use Bitwig Studio’s Poly Grid to build a random bass-line/bass-sound generator: create a monophonic sine-based bass, then generate custom waveforms on the fly and use them for phase modulation (PM/FM-style) to get aggressive bass overtones.
Core patch idea: trigger several Dice modules into a Merge, scan them with a Phasor at note pitch, and the result becomes a one-cycle random waveform; route that waveform into a sine oscillator’s phase modulation input for instantly varied bass timbres.
Add wavetable-style movement by creating 2, 4 random waveform “indexes” and morphing between them with a Value control; then automate that morph position with another Merge + Dice + Transport phasor chain to create randomized “VT” motion over beats or bars.
Shape the sound musically: smooth harsh edges with Lag / Average / Low-pass, keep the patch mono, and in post-FX split lows/highs, leave lows clean, then widen or filter the highs with notch filtering, saturation, LFO movement, EQ, OTT, and limiting.
Important limitation and workaround: Dice values are not persistent when reopening a project, so once a good bass appears, record/resample it to audio or a wavetable to keep the result and reuse the generated bass sounds reliably.

Short Overview

Bitwig Studio Poly Grid bass generator design offers a fast way to create original bass timbres without relying on preset wavetables or standard subtractive patches. By building a random wavetable-like modulation source inside Poly Grid, it becomes possible to generate phase-modulated sine basses with evolving harmonics, controllable morphing, and repeatable post-processing chains.

This matters in practice because it speeds up bass sound design for genres that need complex overtones, movement, and variation, such as drum and bass or experimental electronic production. The approach combines randomized waveform creation, wavetable-style index morphing, modulation sequencing, and post-FX shaping into one flexible Bitwig patch that can be recorded and reused as custom source material.

Key Takeaways

Uses Poly Grid as a bass-line generator instead of picking presets: starts with a sine oscillator + amp envelope, short attack/release, and sets the patch to monophonic so only one bass note plays at a time.
Builds a random single-cycle waveform by feeding several Dice modules into a Merge, then scans those points with a Phasor driven by incoming note pitch; this turns random values into a waveform that tracks the played note correctly.
Creates harmonic content by using the generated waveform to phase-modulate a sine oscillator, similar to FM/PM bass design in Serum; changing the Phasor ratio adds different overtone structures.
Smooths harsh random shapes before modulation with modules like Lag / Averager / low-pass, which rounds sharp waveform edges and changes the character of the resulting bass timbre.
Extends the idea into a mini wavetable by generating multiple random waveforms and morphing between them with a knob, effectively recreating a wavetable position (VT) control inside Grid.
Randomizes wavetable movement over time by creating a second Merge-based shape scanned by Transport phase instead of audio-rate phase; this becomes a bar-synced modulation source for wavetable position or PM amount.
Adds post-FX inside Grid by splitting lows and highs, keeping the low band clean/mono, widening the high band, and applying a moving notch filter with saturation whose motion can also be randomized or macro-controlled.
Notes a key limitation: Dice-generated values are not persistent when reopening a project, so useful results are best recorded/resampled to audio or waveform once a good bass sound is found.

Randomized Bass Design in Bitwig Studio’s Poly Grid

Bitwig Studio’s Poly Grid can be used as a fast, playful bass generator instead of relying on a conventional wavetable synth such as Serum or Vital. The core idea is simple: generate a waveform on the fly from randomized values, use it to phase-modulate a sine oscillator, then add movement and post-processing to turn it into a usable bass sound.

This approach is useful for creating drum-and-bass-style bass timbres, unusual overtones, and rapidly varied source material that can later be recorded and reused.

What It Does

The patch builds a monophonic bass instrument with three main parts:

a sine oscillator as the fundamental tone
a randomly generated waveform used as a phase modulation source
optional random modulation and post-FX to animate the timbre over time

Instead of choosing a fixed wavetable from a browser, the patch creates a small custom wavetable-like structure from randomized values inside The Grid. This produces new overtones each time the generator is triggered.

Basic Voice Setup

Start with a Poly Grid device and create a simple note clip, for example a repeated F, just to feed the instrument with pitch.

The base voice is straightforward:

Sine oscillator
Amplitude envelope
short attack and release
Monophonic voice mode

Monophonic mode is appropriate because bass lines are typically played one note at a time.

The oscillator should also be retriggered on each note so each hit starts from a defined phase.

Creating a Random Waveform

A sine wave alone has no overtones, so it is not very interesting for aggressive bass design. A common synthesis trick is to use another oscillator to phase-modulate the sine. In a wavetable synth, that second source might be another sine, a different ratio, or a selected wavetable. Here, the modulation source is built from scratch.

Using Merge as a waveform table

The patch uses a Merge module with multiple inputs, for example eight positions. Each position acts like a point in one cycle of a waveform.

Each input receives a Dice module:

one Dice per input
bipolar enabled so values can be positive or negative
all Dice modules triggered together by a Trigger module

This creates a set of random values that define the shape of one waveform cycle.

Reading the waveform at the right pitch

To turn those values into audio, the patch uses a Phasor:

the note input from the piano roll drives the Phasor
the Phasor generates a phase signal at the frequency of the incoming note
that phase signal scans through the Merge inputs at audio rate

The result is a periodic waveform in the correct pitch of the played note. Viewed on an oscilloscope, it appears as a custom waveform generated from the random points.

The Phasor ratio can also be changed:

1x = same frequency as the note
2x, 3x, etc. = harmonic multiples

Changing this ratio alters the overtone structure significantly.

Using the Random Waveform for Phase Modulation

Once the randomized waveform exists, it can be used to phase modulate the main sine oscillator.

This is the same general principle used in many bass patches: a simple fundamental is driven by a brighter modulator source, producing more complex harmonics. Because the modulator waveform is random, the resulting bass timbre can change drastically from one trigger to the next.

Even at this stage, the patch already produces a range of useful bass tones.

Smoothing the Waveform

The raw randomized waveform often contains hard edges. Those sharp discontinuities can be useful, but they can also sound too harsh or uncontrolled.

To soften the waveform before it reaches the modulation stage, the patch can insert modules such as:

Lag
Averager
or effectively a low-pass-like smoothing stage

This rounds the shape and changes the harmonic content. In practice, this acts somewhat like smoothing a wavetable frame before using it as a modulation source.

Expanding from One Waveform to Multiple Indexes

A single random waveform is only one “position.” To behave more like a wavetable, the patch can generate multiple waveforms and morph between them.

Building several waveform stages

Duplicate the waveform generator so there are multiple versions, for example four:

waveform 1
waveform 2
waveform 3
waveform 4

Each waveform can have:

its own random point values
its own Phasor ratio

A second Merge then combines these waveforms into a small wavetable-like structure. A Value control can move through these stages, effectively acting like the WT position or VT parameter in a wavetable synth.

As the control moves between stages, the output crossfades between waveforms.

Adding Random WT-Style Motion

The patch does not stop at generating random waveforms. It also randomizes the movement through the wavetable positions over time.

Creating modulation curves

Another Merge is used as a control-rate shape rather than an audio-rate waveform. For example:

four control points
each filled by a Dice module
this time unipolar rather than bipolar, because the modulation should move between 0 and 1

Instead of using a Phasor, the patch uses a Transport phase signal to scan this Merge over musical time, such as one bar.

This creates a modulation curve that can be thought of as randomized automation.

Again, the curve can be smoothed with an Averager or similar module if the transitions feel too abrupt.

Applying the modulation

That control signal is then used to modulate the wavetable-position parameter. The result is a bass tone whose phase-mod source not only changes shape randomly when generated, but also moves through multiple random waveform stages over time.

The patch can also randomize the duration of this modulation, for example between half a bar and one bar, by modulating the Transport-related timing values.

Modulating Phase Modulation Depth

The same randomized control idea can be duplicated and applied to the phase modulation amount.

A useful design choice here is to keep the beginning of the note cleaner by starting modulation depth near zero, then increasing it over time. That allows the bass to begin with a purer sine-like core before moving into more aggressive overtones.

This shape often makes the resulting bass more punchy and easier to place in a groove.

Post-FX Processing

Once the oscillator section is working, the signal can be shaped further in the Post FX stage.

Frequency split

A practical approach is to split the bass into low and high frequency bands, for example around 120 Hz:

keep the low band mostly untouched
process the high band for width and movement

This preserves low-end focus while making the upper harmonics more interesting.

Stereo widening

The upper band can be widened with a stereo utility such as Blur or another widening process. Since the patch is monophonic, widening only the top range helps maintain solid low-end mono compatibility.

Moving notch filter

A filter on the high band can add animated spectral motion. In the transcript, a notch filter with some saturation is used.

An LFO modulates the notch frequency:

free-running
lowest point around 150 Hz
modulation moving upward from there

The LFO speed itself can also be randomized, although this can become too chaotic and may be better exposed as a manual macro control.

Additional processing

Further processing may include:

EQ
OTT-style multiband compression
limiter
pitch envelope
saturation

The exact chain is flexible. The main purpose is to shape the randomized source into a more mix-ready bass sound.

Workflow

A practical workflow with this kind of patch looks like this:

Create or load a drum loop.
Add the Poly Grid bass generator.
Trigger new waveforms until something promising appears.
Adjust PM amount, smoothing, and movement depth.
Add post-FX to control width, filtering, and tone.
Record the most useful results to audio.
Slice, layer, or arrange the rendered basses into a track.

This turns sound design into a generative exploration process rather than a preset-selection process.

Why Record the Results

One important limitation is that the random values generated by Dice are not persistent when reopening the project. On reload, those modules generate new values, so the exact sound may be lost.

Because of that, it makes sense to record the output to audio once a useful bass is found. Rendering the result gives a stable, reusable asset and allows the generated waveform or phrase to be dropped back into the arrangement.

In practice, this also aligns with how many bass sounds are ultimately used: as edited audio clips rather than endlessly tweakable patches.

Practical Uses

This method is especially good for:

generating many bass timbres quickly
creating unusual phase-modulated textures
producing wavetable-like motion without browsing tables
building source material for resampling
learning The Grid through a musically useful project

It is less about precision than exploration. The value lies in producing unexpected but playable results, then committing the best ones to audio.

Limits

This technique has a few clear limitations:

Random states are not persistent when using Dice-based generation
some modulation choices can become too random to be musically useful
more advanced parameter randomization, such as per-note EQ movement or gain shaping, quickly increases patch complexity
the system benefits from manual curation after generation

For that reason, a hybrid approach works best: use randomness to generate ideas, then keep the most effective parameters under manual control.

Summary

The patch functions as a small randomized bass synthesis system inside Bitwig Studio’s Poly Grid:

generate random waveform points
scan them at note frequency with a Phasor
use the result to phase-modulate a sine oscillator
expand to multiple waveform stages for wavetable-style morphing
add randomized control-rate movement
shape the result with filtering, stereo treatment, and dynamics
record the best outcomes to audio for stability

It is a strong example of how The Grid can be used not just as a modular environment, but as an idea generator for sound design that would be cumbersome or less immediate in a fixed architecture synth.

Transcript

This is the transcript of the video. The text was generated automatically and may contain small mistakes. The timestamps jump to the matching part of the video.

Click to expand transcript

[00:00:00] Okay, so in this video, I want to show you one of the reasons why I love Bitwig studio
[00:00:04] Because I was just working on this track here for no reason at all and I have this drum loop here sounds like this
[00:00:11] Right and I need some kind of bass sound to it
[00:00:18] So I could go to zero or some other wave tables in the size or maybe use some stock devices of Bitwig studio to just create some
[00:00:26] Random bass sounds, but what I do now is what I sometimes do because it's just fun to me at least I
[00:00:33] use the pulley grid here
[00:00:36] To create a bass line generator
[00:00:42] So yeah, I'm just a basic pulley grid and we create here a note clip, but maybe a note on F
[00:00:50] Just so we have a note
[00:00:57] It's just a sign so in here we have a sign oscillator of course with an amplitude envelope we
[00:01:03] Reduce here the attack and release maybe like this and we also make sure that the grid is in
[00:01:10] Monophonic mode because bass sounds or bass lines are usually just one note at a time
[00:01:16] So we use this here. So we also want to re-trigger the sign oscillator every time we hit the note in the in the note clip and
[00:01:25] The sign oscillator itself of course is not interesting enough because it's just a sign. It's just a pure
[00:01:31] Wave form with no overtones. So what we want to do or what you usually do inside of serum is use another
[00:01:39] Maybe sign oscillator and then just face modulate the first one which gives you some interesting sounds
[00:01:46] Right or you change the ratio of the second one
[00:01:55] So this gives you some some overtones some kind of drum and bass bass sound overtones
[00:02:01] You really like and then you add some filtering some EQing and the end of course
[00:02:06] What you also can do is you can use here the wave table oscillator and then search for some random wave table here
[00:02:12] To create overtones and then use that to face modulate the first sign oscillator
[00:02:25] And then you get some nice sounds out of it
[00:02:27] But the problem is you always have to select some kind of wave table and then you know scan through the wave table and see if it's
[00:02:35] You know fits your style or whatever
[00:02:38] So my idea for this is why not just do a wave table
[00:02:43] On the fly randomly
[00:02:46] You can do this in multiple ways and I show you here maybe all of the ways
[00:02:51] But I start just by using a merge
[00:02:55] Um like this one and maybe we go for eight
[00:02:59] Positions this is our wave table right the first
[00:03:03] second as a multiple indexes inside of the wave table
[00:03:07] Or not not really in the wave table. It's actually multiple points inside of one cycle
[00:03:14] I show you this in a minute what I mean, so I use dice module here and
[00:03:19] Just use a dice on each input
[00:03:24] Like this and we probably want to use here the bipolar option because we also want to
[00:03:31] Create random negative values and I use a trigger
[00:03:36] Module yes, we can just trigger a new random
[00:03:43] Number generation on each of these dice
[00:03:47] Modules so what we do then is we want to iterate over this merge here
[00:03:54] with audio rate
[00:03:56] And of course exactly the right audio rate, so it fits the pitch of the incoming note
[00:04:02] So we do this by using a phaser
[00:04:05] Looks like this right and has here some kind of note input
[00:04:11] So it takes the note from the piano roll and then generates a phase signal
[00:04:17] exactly in the frequency of the note and we take this here and go into the
[00:04:23] Merge and now it iterates over all of these values here
[00:04:27] Exactly in the right pitch
[00:04:29] And we can now hook up here an oscilloscope to that
[00:04:33] And then you can see nothing comes out of it, but when you get the trigger here we get this kind of waveform
[00:04:41] Yeah, this is a waveform exactly in the right pitch of the note
[00:04:47] So I can show you this by maybe
[00:04:51] Going into that and let's hit play
[00:04:53] Right, so we have a sound instead of a sign
[00:04:58] You have now the sound
[00:05:01] Sounds like a saw almost a try so we can change the waveform here by just hitting trigger and we get a random waveform on each trigger
[00:05:17] Easy we can also change here the ratio so instead of having the frequency of the note
[00:05:23] We can have twice the frequency of the note
[00:05:26] Or three times the frequency of the note
[00:05:29] We can you know
[00:05:32] Change the ratio
[00:05:34] Compared to the input frequency. So now we can use the signal here and phase modulate the sign oscillator
[00:05:43] Which brings us back to the first example
[00:05:47] So
[00:05:49] This gives you already interesting sounds or interesting overtones that are quite different, but we can
[00:06:04] Apply more processing here
[00:06:07] Before we hit the post FX stage. So it's all about creating nice interesting overtones. So we can also
[00:06:17] use maybe a leg or an average shear like this and we can round out
[00:06:22] The waveform so instead of having here these hard edges
[00:06:27] So we can play around with the wave cycle here and maybe
[00:06:41] Make it a bit more smoother. It's almost like a low pass
[00:06:45] We probably could use a low pass here also
[00:06:48] And have different effects. Yeah, more or less
[00:06:52] Okay, so now that we know how this kind of works we can also imagine
[00:07:05] Well, this is one index of a wavetable. Why not use movable indexes, right? This could be interesting, too
[00:07:13] so let's spread this out here a bit more and
[00:07:16] Go here, maybe put this there and
[00:07:21] Like this, let's say we want to use
[00:07:25] Two of them, right? So we have now two wave forms and we can use another merge
[00:07:32] Like this and say this is the first wave form. This is the second wave form and then we have
[00:07:43] the value knob
[00:07:45] And we can morph between the two wave forms like this
[00:07:49] Okay, let's see how this sounds
[00:07:54] Maybe make this here a loop for no reason
[00:08:03] So yeah, so we have two wave forms we can also say the second one is the ratio two to one
[00:08:13] But
[00:08:15] Why not just use a dice
[00:08:20] And say every time I trigger a new wave form here, I also would change the ratio of
[00:08:28] Some of the phasers so maybe the first one here by let's say up to five
[00:08:35] And the second one also up to five
[00:08:44] Something like that so now we have this system so we can create a new a new bunch of wave forms here
[00:08:52] Easy so we have two wave forms here with different
[00:09:04] Wave forms and different ratios we can just you know take this further
[00:09:13] Maybe I spread this out. So I use this one here
[00:09:17] And bring this closer together, yeah
[00:09:24] Why not why not go to four so we use four inputs here
[00:09:37] And this is the third one and this is the fourth one and now we can generate a new wave form and we can go through
[00:09:44] four different stages
[00:09:47] Oh, we need different
[00:09:58] Phasers here maybe for the other ones. So this is
[00:10:04] This is here the second one, okay
[00:10:07] And this is the
[00:10:12] Fourth and this is the third is the fourth. Okay, so this is what you like this is what you like this. Okay, fine
[00:10:18] Let's try it out again
[00:10:21] Well, so now that we have this we have basically here
[00:10:33] the parameter that's called VT inside of
[00:10:37] Serum because we morph through different indexes of our wave tables
[00:10:43] So this is a small little wave table here
[00:10:46] So this is way from one two three four and then we have here volume fades in between right
[00:10:52] So we can also have here a state between the first one and the second one
[00:10:56] So it's just a volume of fate and that's usually what these wave tables do they just volume fade
[00:11:04] Oh
[00:11:06] Okay, so what you do then in serum is you
[00:11:15] modulate the VT right over time and you can do this two year we can just go into the
[00:11:21] Automation pane here and say we want to modulate the BT parameter
[00:11:31] And you have some kind of baseline
[00:11:33] Right, but we can also say I'm too lazy. I also want to randomize this we use another
[00:11:44] merge and
[00:11:46] this is our
[00:11:48] Yeah, our automation more or less. So we have want to have maybe also four stages and
[00:11:54] We want to go through that not with audio rates, but with the
[00:11:58] modulation speed
[00:12:00] So this time instead of using here a phaser
[00:12:03] We use a transport
[00:12:06] and
[00:12:08] We generate a phase signal here
[00:12:10] That is exactly. I don't know one bar long and when we fit this in here
[00:12:16] We have basically a modulation or automation that is one bar long and
[00:12:22] Then we can use again dice
[00:12:25] Modules here, but this time not bipolar
[00:12:30] This time you need polar because we want to go from a zero to plus one
[00:12:34] And then we also do here. Let's use another trigger
[00:12:40] Here
[00:12:44] So we can generate a
[00:12:48] new modulation
[00:12:51] independent from
[00:12:53] Generating a
[00:12:54] Wave form or wave table. Okay, so we hit this here and then we maybe use an
[00:13:01] oscilloscope
[00:13:02] Put this on slow
[00:13:04] You can see here, this is more or less the modulation
[00:13:10] If you think this is too too edgy again, you can use a low pass here
[00:13:19] And make it a bit smoother
[00:13:24] Or maybe use an average it's probably better
[00:13:31] Yeah, something like that
[00:13:33] So, yeah, this is all modulation so we use that
[00:13:40] and
[00:13:43] We can use your modulator out and just modulate that if you want to keep this parameter
[00:13:48] But you can also go just straight in here and just delete this and that right
[00:13:53] But I want to have it this way because this way you can see what's going on here
[00:14:00] And then you can also
[00:14:02] Say maybe with an attenuate which is the modulation amount now
[00:14:09] I don't want to have this
[00:14:12] Randomized modulation here. I want to keep this manually inside of the door
[00:14:16] But here you can add modulation one. So now that we have here this randomized modulation amount
[00:14:23] We don't need to draw in here some modulation
[00:14:29] Right, we have a modulation in there
[00:14:31] And we can just randomize this so every time we
[00:14:34] Generate a new wave table. We also generate a new modulation
[00:14:39] So what we also can do is we can use the dice module and
[00:14:58] Just mutilate
[00:15:00] How fast or how long this is so we can say two
[00:15:07] Two beats there's two beats here probably
[00:15:12] So one beat is half a bar and two is one bar. So we can randomize this and say this goes up to one so one
[00:15:22] So so it's by by chance. It's either half a bar or one bar long the modulation so we can do this here
[00:15:30] Also, we randomized this
[00:15:32] Or we can make it even longer, let's go to two
[00:15:42] This is one bar and a half
[00:15:51] We could also randomize how edgy this is I just going here
[00:15:57] Yeah, it's all randomized now
[00:16:01] Nice so with this we can oh
[00:16:11] We don't use this here. Okay. I see so with this we can also duplicate this and
[00:16:19] Say this one
[00:16:21] This is what you like in this does what you like with that cool stays in place
[00:16:27] So with this we modulate here the amount the PM amount
[00:16:32] So we need to randomize
[00:16:35] Right
[00:16:50] Oh
[00:16:52] So with the modulation here, I would say in the beginning of this PM
[00:17:02] We maybe want to start instead with the random value. We want to start with the zero value
[00:17:08] we always want to start at the
[00:17:10] Zero point here because in the beginning the base
[00:17:13] I want to have a pure sine wave and then I want to move into the overtones. I hope this makes sense
[00:17:20] Hey a bit more
[00:17:43] So this is basically a small bass sound generator
[00:17:47] At the moment, it's just the oscillator
[00:17:50] With no post FX, but we can go further right and we're gonna go into the post FX and say
[00:17:58] We want to split the signal into two frequency parts
[00:18:03] Maybe at 120 Hertz. So here we have the low part. We don't touch this. Maybe we make it mono, but it's
[00:18:11] Monophonic anyway
[00:18:13] Top part maybe that put here a blue device to make it stereo
[00:18:17] Or bit wider
[00:18:21] Right something like that and we maybe use a filter here and say we want to have a notch filter with a bit of saturation
[00:18:34] So here we can use an LFO
[00:18:41] Classic one and we want to no treat we got this one and we keep it free running here
[00:18:46] And we want to have the lowest point of the notch maybe at 150
[00:18:53] So we keep it there and then we modulate upwards
[00:18:58] Which means?
[00:19:01] Unipolar
[00:19:03] Up to here and then we use
[00:19:05] Yeah, let's see use another dice
[00:19:10] thing here
[00:19:12] And call this maybe
[00:19:14] LFO speed
[00:19:17] This one changes the LFO speed or maybe even better
[00:19:22] Even better we do the same thing here
[00:19:27] Use this one and here we modulate the LFO speed like that. So over time it changes the LFO
[00:19:40] So
[00:19:42] Yeah, the problem here is with the this one
[00:19:56] Sometimes it's it's it's too random. So you maybe cut this out and
[00:20:02] make this manual and maybe put this here into a
[00:20:06] macro not
[00:20:10] Like that
[00:20:12] Face mod
[00:20:16] And then we use a button here and to use a button there
[00:20:24] Call this generate
[00:20:29] Bam
[00:20:33] Jen
[00:20:40] So
[00:20:42] You get a different sound on different modulation out of that and
[00:20:48] Why is there but I don't know
[00:20:52] Maybe an EQ and do an EQ thing here
[00:20:57] Move this over there
[00:21:01] It's there and then we had to use here multiple of these for different lanes we can
[00:21:08] Maybe we can do this
[00:21:10] Also need something for gain I think it's too complicated for this tutorial
[00:21:18] But you have to use multiple of these for gain for each note and also for the frequency of each note and then you can
[00:21:26] Randomize also this kind of movement, but I want to you know, keep it simple and it's already pretty complex
[00:21:33] So
[00:21:38] So, yeah, so we have post FX we can change here or modulate over time randomly and we also have
[00:21:45] The
[00:21:49] Oscillator the waveform itself that we generate randomly every time. I think this is a
[00:21:55] Great thing you had to do. The only problem is when you save this now as a project
[00:22:02] It's gone because all of these modules here are generating new values when you load up the project
[00:22:09] So they're not persistent
[00:22:11] You can make this persistent by using a step modulator or something like that
[00:22:15] But I really prefer to just record to waveform at some point
[00:22:21] Because it's just easier and you want to use waveforms probably anyway. So what I do then is
[00:22:27] Maybe go into here and then use
[00:22:33] MPE
[00:22:35] Maybe I don't know about 12
[00:22:37] And slowly go here
[00:22:43] Something like that and then maybe put not here
[00:23:00] Maybe here, I don't know usually people just use OTT, right? I put the OTT on that
[00:23:06] Then peak limiter at the end
[00:23:09] And then you use some kind of recorder here
[00:23:17] Don't feel like that then
[00:23:23] Maybe put this in here
[00:23:27] And then we just drag it out
[00:23:31] Right and then you have it persistent, then you generate some new bass sounds for here
[00:23:39] Let's try this
[00:23:42] Maybe different pitch, pitch envelope here
[00:24:01] Something like that, I don't know
[00:24:06] I think you can
[00:24:15] Take this too and put it here and then you can just remove it
[00:24:20] You don't need to use this anymore
[00:24:23] Because we have now the waveforms and then you can combine this in
[00:24:29] Different ways, I don't know
[00:24:31] Maybe it's over here
[00:24:34] Then put this here into the bass because I have some kind of sidechain already in place
[00:24:47] Then go from there and you generate multiple sounds or you know
[00:24:58] 1000 sounds and then you try to
[00:25:01] Put them together
[00:25:04] Okay, so this is my idea for
[00:25:20] how to create bass sounds in a kind of different way than just going straight to zero and
[00:25:26] Then come up with a new sound design every time you need a new sound
[00:25:30] I put you some of the things here in the description below so you can download this if you
[00:25:37] Don't want to create this for yourself
[00:25:39] But
[00:25:43] Where was it?
[00:25:45] That saved it. Yeah, it's here
[00:25:47] So yeah, but you can create this on the fly or I do this on the fly I've moved the ball of these things here
[00:25:56] in bitwig and I do them sometimes when I'm in the mood I create some kind of generators and then
[00:26:02] Get new ideas and it's also nice practicing for the grid and it's not that hard to do in my opinion
[00:26:10] Yeah, that's it. That's why I love bitwig studio, of course
[00:26:14] And that's how I use the grid and this is how you do sound design in a kind of different way in bitwig studio
[00:26:22] Thanks for watching. See you next video. Bye
[00:26:26] [BLANK_AUDIO]

Bitwig Studio 6.1 Sampler Live Select for Smooth Crossfades

polarity — Fri, 17 Jul 2026 02:00:00 GMT

Tutorial | Jul 17, 2026

Learn how Bitwig Studio 6.1 Sampler Live Select Updating enables smooth multisample crossfades for strings, pads, and expressive custom libraries.

You can watch the Video on Youtube
Support me on Patreon if you like what you hear.
Download Presets, Tools and Projects on my Dispenser

Quick Answer

Bitwig Studio 6.1 adds Live Select Updating in Sampler’s Multi-sample mode, letting the Select knob switch or crossfade between sample layers while a note is held, instead of requiring note re-triggering.
To use it: load multiple samples into Sampler → Multi-sample, open List View, select the layers, then choose Distribute Select Equally so each sample gets its own range on the Select axis.
Smooth morphing comes from setting fade in/out ranges per layer so adjacent samples overlap; this enables continuous transitions between pads, strings, piano intensities, articulations, or timbral variations.
The key improvement over Bitwig 6.0 and earlier is that sample selection now updates live during playback; previously, changing Select only took effect after triggering a new note.
Best use cases: building Kontakt-style expressive instruments with dynamic layer blending; for clean results, carefully tune overlap widths and avoid too many tightly packed layers unless longer fades are set.

Short Overview

Bitwig Studio 6.1 Sampler live select updating in Multi-Sample mode adds real-time sample switching and crossfading between layers without retriggering notes. This makes it possible to hold a note and smoothly move between articulations, dynamics, or timbral variations using the Select control.

In practice, this is especially useful for building more expressive string, piano, and pad instruments from layered samples. Combined with Select distribution and fade-in/fade-out ranges, the new behavior enables smoother transitions between sample layers and brings Bitwig’s stock sampler closer to the workflow used in dedicated library tools like Kontakt.

Key Takeaways

Bitwig Studio 6.1 adds “Live Select Updating” in Sampler’s multi-sample mode, allowing the selected sample layer to change while a note is held, instead of requiring the note to be retriggered.
The Select dimension can be distributed across layers with “Distribute Select Equally,” which maps each imported sample to a different position on the Select knob rather than stacking all samples on every position.
Crossfading between adjacent sample layers is set per layer with fade-in and fade-out step ranges, enabling smoother transitions between samples such as expression layers, pad textures, or intensity variations.
This makes Sampler more practical for building custom instrument libraries like strings or pianos, where smooth blending between different articulations, dynamics, or timbral layers is needed.
Without Live Select Updating, older Sampler behavior only switched layers on retrigger, even if Select zones and fades were configured; real-time morphing during sustained playback was not possible in 6.0.
When editing multiple layers, the fade value display can be misleading, because the panel shows the currently selected layer’s value rather than a combined multi-selection state.
Using too many layers with short crossfades can make transitions feel too abrupt, so fewer samples or longer fade regions may produce more usable morphing results.
Current crossfades appear to use a linear curve only, with no per-crossfade curve shaping, and Bitwig’s other container devices still have routing limits compared with this new multi-sample Select workflow.

Bitwig Studio 6.1: Live Sample Switching in Sampler’s Multi-Sample Mode

Bitwig Studio 6.1 adds a small but important improvement to Sampler in multi-sample mode: samples assigned across the Select dimension can now update while a note is being held.

This matters because earlier behavior required a re-trigger. A held note would continue playing the currently selected sample, even if the Select position changed. In 6.1, enabling Live Select Updating allows smooth movement between sample layers during playback.

For sound design and sample-instrument building, this makes Sampler much more useful for crossfading between articulations, intensities, or timbral variations.

What It Does

In a multi-sample patch, several samples can be distributed across the Select axis. Each sample occupies a range of the Select knob, and Sampler plays the corresponding layer based on the current Select position.

Previously:

changing Select while holding a note did not switch the sounding sample live
the note had to be played again to hear the new layer

In 6.1, the new Live Select Updating option changes that behavior:

hold a note
move the Select control
Sampler updates the active sample layer in real time

With overlapping ranges and fades, this becomes a continuous crossfade rather than a hard switch.

How It Works

In multi-sample mode, samples can be viewed in the list view and assigned to the Select dimension.

A typical setup looks like this:

Create a new multi-sampler patch.
Drag multiple samples into Sampler.
Open the list view.
Select the imported layers.
Use Distribute Select Equally.

This places each sample at an even position across the Select range.

Without any further setup, moving Select simply jumps from one sample to another. To make the transition smooth, each layer needs some overlap.

Fades and Crossfades

Each sample layer can be given a fade in and fade out range on the Select axis.

That means:

one sample gradually decreases as Select moves away from its zone
the next sample gradually increases as Select enters its zone

When these ranges overlap, Sampler produces a crossfade between the layers.

This was already possible before 6.1, but the result only updated properly when notes were re-triggered. The new behavior makes those crossfades usable during sustained playback.

Workflow

A practical workflow for building a morphing multi-sample patch is:

Load several related samples into Sampler.
Assign them to the Select dimension.
Use Distribute Select Equally.
Set fade in and fade out amounts for each layer.
Adjust each layer’s range so one fade begins where the previous one ends.
Enable Live Select Updating.
Modulate or automate the Select control.

This works especially well when the source samples are variations of the same sound family rather than unrelated material.

Example: String Layers

Two string samples can be placed at opposite ends of the Select range.

one sample sits at the lower end
the other sits at the upper end
both are given overlapping fades

With Live Select Updating enabled, a held note can move smoothly between the two layers instead of switching only on the next key press.

This is useful for simulating expression changes or intensity transitions.

Example: Pads

The same technique works well with a bank of pad samples.

After loading several pads:

distribute them equally across Select
add overlapping fade ranges
move through the Select dimension manually or with modulation

The result is a patch that can morph continuously between different pad textures.

Practical Uses

This feature is particularly useful for sample libraries that rely on gradual timbral change rather than simple switching.

Good use cases include:

string libraries with different expression or intensity layers
piano libraries with multiple tonal states
pad instruments that morph across multiple sampled textures
any patch built from several related recordings with different overtones or dynamics

In short, it makes Bitwig’s Sampler better suited to the kind of layered intensity blending often associated with dedicated sample-instrument platforms.

Limits

A few limitations remain.

Careful fade setup is important

The quality of the transition depends heavily on how the fade ranges are arranged. If many samples are packed too closely together, each crossfade may become too short, making the morph feel abrupt.

Longer overlaps often work better, especially with evolving or sustained material.

Fade curve control is limited

The fades appear to be linear. That is usable, but some situations would benefit from adjustable crossfade curves so the blend could bend more toward one layer or the other.

Multi-selection editing can be unclear

When multiple layers are selected, displayed values may reflect only the last selected layer. For example, a fade value may show 0 even though other selected layers have nonzero settings. That makes batch editing less obvious than it could be.

Comparison to Earlier Workarounds

Before this update, achieving similar results in Bitwig often meant using container devices such as:

Instrument Layer
Instrument Selector
XY Instrument

Those approaches could help with layered transitions, but they were less direct for building a true multi-sampled instrument inside Sampler.

The new Sampler behavior is cleaner because the crossfade happens inside the sample-layer system itself, on the Select axis, with live updating during sustained playback.

Why It Matters

This is not a flashy headline feature, but it fills an important gap in Bitwig’s sampling workflow.

The addition of Live Select Updating means Sampler can now do something essential for expressive multi-sample instruments:

assign layers across Select
overlap them with fades
move between them smoothly while notes are still sounding

For anyone building custom libraries or morphing sampled instruments, that makes Bitwig Studio 6.1’s Sampler significantly more capable.

Transcript

This is the transcript of the video. The text was generated automatically and may contain small mistakes. The timestamps jump to the matching part of the video.

Click to expand transcript

[00:00:00] So welcome back guys, there's another feature in Bitwig Studio 6.1 with a sampler here that
[00:00:05] no one really talks about and this is when you use the multi-sample feature here, what
[00:00:10] I want to do, so we create a new multi-sampler patch and we want to use multiple samples.
[00:00:17] So let's go here to my sample thing and search for something, yeah, I prepared some strings
[00:00:25] here.
[00:00:26] We have two string samples, C3, long CS and just long, so we bring this in, direct this
[00:00:35] into here and then we use here this list view.
[00:00:40] We have on the right side here basically the select knob, this is this knob here and this
[00:00:45] works like this that you can play a note on the keyboard and it plays one sample.
[00:00:55] When you select here, let's say distribute select equally, so we have at the bottom end
[00:01:01] here of this knob we have this sample and at the top end we have this sample and yeah,
[00:01:09] you can basically play a note and play different samples but you can't move between the two,
[00:01:18] so it's like you play one note and hold it and nothing really changes, you need to re-trigger
[00:01:27] the note.
[00:01:32] And in 6.1 we have now this button here, it's called live select updating the sample which
[00:01:39] allows you to switch between these two samples here in kind of a fluid way.
[00:01:50] So you can press and hold the note and then switch between two samples.
[00:01:55] So this was not possible before, we only had this feature here since they updated sampler
[00:02:01] I think it was in 2.0 where you had to re-trigger more or less, so you couldn't just morph between
[00:02:08] the two.
[00:02:10] So this is now possible and yeah, we can define now some kind of fade between the two.
[00:02:20] This was also possible before, we can go here to the first sample and say on the left side
[00:02:27] we want to have a fade in or a fade out, let's say 15 steps and then we have this one here
[00:02:35] which has also 15 steps, then we maybe drag this a little bit in this direction and this
[00:02:43] one a bit longer.
[00:02:46] So now here the fade in starts where the fade out starts from this kind of sample and now
[00:02:52] we have more like a fluid.
[00:03:04] So it doesn't really make sense here but you can imagine that you can build with this some
[00:03:09] kind of string libraries where you have different expression settings or different velocities
[00:03:14] and you are smoothly fade between them which makes it much better to actually create string
[00:03:25] libraries this way.
[00:03:26] So this was not possible before, it's not possible in 6.0 with the old sampler.
[00:03:31] Now here 6.1 has the sampler where you can now fade between the layers which is kind
[00:03:38] of cool.
[00:03:39] So I want to use here something different, let's remove that and use some pads for samples.
[00:03:47] I have a lot of different pads here and just grab a bunch and just drag this in and they
[00:03:54] all play at the same time because we have your select and everything is selected basically
[00:03:59] on every position, that's not what we want.
[00:04:02] We select here all these layers and then say distribute, select equally.
[00:04:09] So now we have a nice little equal distribution of these select positions and it works like
[00:04:16] you expect it to be.
[00:04:28] So this was not possible before and it's really nice for pad sounds because we can morph between
[00:04:33] different samples.
[00:04:35] So all we need to do now is here select everything and then define maybe fade in and fade out.
[00:04:43] Let's say fade in, it's actually 14 steps long.
[00:04:52] Let's go to 7 here maybe and also 7 here.
[00:04:57] And then we make this longer, something like that.
[00:05:02] So right the fade in here starts when the fade out here starts on this sample and then
[00:05:08] the last one we don't need to fade out and here we don't need to fade in, maybe something
[00:05:15] like this.
[00:05:16] So let's try this out.
[00:05:34] So this is perfect for samples, it's perfect for sampling string libraries or piano libraries
[00:05:40] and you want to smoothly fade between different intensities or different overtones or different
[00:05:49] samples.
[00:05:50] So yeah, it's pretty cool to have and I really want to use this.
[00:05:56] I mean this is a basic feature for contact users.
[00:06:00] I don't know if this is possible in able to live in the Simpler or any other stock samplers
[00:06:06] of any other DAW, but this is kind of nice to have and you can simulate better what you
[00:06:13] are used to in contact or whatever people use these days.
[00:06:18] So yeah, let's put a reverb on that and we can also use of course all the other features
[00:06:24] like spectral and slow down the playback attack maybe.
[00:06:54] But as you can see it's probably better to have not that many samples in here because
[00:06:59] all of these fade in and fade outs are a bit too quick, maybe we can make this a bit longer.
[00:07:07] Let me see, so we have a fade, a longer fade time, something like that and it would be
[00:07:23] nice if we could define actually at the cross over curve.
[00:07:27] So at the moment it's linear and this is okay, this is pretty fine but sometimes you
[00:07:32] maybe want to adjust the curves so to make it more like a bend in one or the other direction.
[00:08:02] So yeah, it's pretty important that you define here these cross over and fade positions perfectly
[00:08:18] so it makes sense when you you know modulate this, also you can see a fade is zero which
[00:08:24] makes no sense because we select here multiple things and it takes basically the last selected
[00:08:31] layer here, right so here it's 10 and when I select this one where it's zero then it
[00:08:38] takes zero for everything.
[00:08:47] But yeah this is now possible in 6.1 in the new sampler and I'm happy that we have this
[00:08:52] because I always wanted to create some libraries for myself to use and this was a feature I
[00:09:00] was missing from contact you know to kind of use some string libraries or piano libraries
[00:09:08] and you need to have this feature to fade between different intensities.
[00:09:14] So this is what we have now and I want to show you this how it works.
[00:09:18] This kind of thing here was also possible before 6.1 it was just not updating live so
[00:09:25] you had basically everything in this kind of mode here where you need to press and you
[00:09:31] select your position or maybe you are somewhere here right where you have two things playing
[00:09:37] at once these two in a kind of a middle position but you couldn't change while playing.
[00:09:49] How cool do I have?
[00:09:56] Yeah not a big feature but I want to show you this maybe you haven't noticed already
[00:10:02] but try it out it's a cool feature and it's something along those lines where we had to
[00:10:09] use back then here the instrument layer, instrument selector and we needed to use multiple layers
[00:10:17] here and then you could use here what's the name the fade out is there actually a fade
[00:10:23] here or is it actually only in the FX selector I think there's no fade here between these
[00:10:29] two or we had to use the XY instrument container this one here where we could fade between
[00:10:38] four different positions oh yeah this is not possible also here we have to fade from this
[00:10:47] layer to this layer it's not possible to fade from here to here or from here to here right
[00:10:53] it's kind of always in the same sequence like an wavetable where you always have to go through
[00:11:01] all of the states in the same order so it's not like it's not possible to fade from here
[00:11:06] to here would be nice to have but yeah that's how it is at the moment cool to have at least
[00:11:12] this feature here and I probably use this a lot anyway that's it for this video I want
[00:11:17] to show you this let me know what to think in the comments down below and I see you in
[00:11:21] the next video there's more stuff coming next week bye

Polarity - Music Producer & Teacher

Polarity-Recorder Plugin: Capture Ideas and Make Loops

Quick Answer #

Short Overview #

Key Takeaways #

Polarity-Recorder: a free background audio ring recorder for Windows, macOS, and Linux #

What It Does #

How It Works #

Editing and Extraction Workflow #

File Naming and Searchable Metadata #

History Browser #

Practical Uses #

Capturing missed performances #

Extracting loops from the master bus #

Recording stems and one-shots #

Building sample libraries during production #

Loop Repair and Seamless Looping Tools #

Rotate #

Wrap #

DAW Integration Notes #

Why This Workflow Matters #

Limits and Compatibility Notes #

Summary #

Transcript #

Soft Orbit (Ambient Tales)

From the Original Bitwig Patch #

Listen, Stream and Buy #

We Can Sleep in Orbit

About This Soundscape #

Inside the Patch #

Technical Snapshot #

My Soundscape for Sleeping in a Slowly Turning World

About This Soundscape #

Watch the Patch Being Built #

Inside the Patch #

Technical Snapshot #

Bitwig Grid Generative Harmony with Fifths and Octave Wrapping

Quick Answer #

Listen to the Finished Soundscape #

Build Overview #

Patch Decisions #

Interesting Moments #

YouTube Description Timestamps #

What This Build Is Useful For #

Transcript #

Polarity Res Spectral Resonator Free Plugin Update Guide

Quick Answer #

Short Overview #

Key Takeaways #

Polarity Res update: free spectral resonator with MIDI, scales, harmonics, and per-note control #

What It Does #

How It Works #

Musical overlays: scales and harmonics #

Scale overlay #

Harmonic overlay #

Subharmonic overlay #

MIDI and keyboard control #

Envelope-style controls #

MPE support and microtonal movement #

Per-note parameter control #

Random generator and presets #

Workflow #

Practical uses #

Limits #

Summary #

Transcript #

Stay Here Until Everything Feels Distant

About This Soundscape #

Inside the Patch #

Technical Snapshot #

Bitwig Grid Probabilities for Weighted Random Modulation

Quick Answer #

Short Overview #

Key Takeaways #

Controlled Randomness in Bitwig: Weighted Probabilities for Modulation and Note Generation #

What It Does #

Why the Standard Random Modulator Is Not Enough #

How It Works #

Workflow #

1. Define the possible values #

Quick Answer

Short Overview

Key Takeaways

Polarity-Recorder: a free background audio ring recorder for Windows, macOS, and Linux

What It Does

How It Works

Editing and Extraction Workflow

File Naming and Searchable Metadata

History Browser

Practical Uses

Capturing missed performances

Extracting loops from the master bus

Recording stems and one-shots

Building sample libraries during production

Loop Repair and Seamless Looping Tools

Rotate

Wrap

DAW Integration Notes

Why This Workflow Matters

Limits and Compatibility Notes

Summary

Transcript

From the Original Bitwig Patch

Listen, Stream and Buy

About This Soundscape

Inside the Patch

Technical Snapshot

About This Soundscape

Watch the Patch Being Built

Inside the Patch

Technical Snapshot

Quick Answer

Listen to the Finished Soundscape

Build Overview

Patch Decisions

Interesting Moments

YouTube Description Timestamps

What This Build Is Useful For

Transcript

Quick Answer

Short Overview

Key Takeaways

Polarity Res update: free spectral resonator with MIDI, scales, harmonics, and per-note control

What It Does

How It Works

Musical overlays: scales and harmonics

Scale overlay

Harmonic overlay

Subharmonic overlay

MIDI and keyboard control

Envelope-style controls

MPE support and microtonal movement

Per-note parameter control

Random generator and presets

Workflow

Practical uses

Limits

Summary

Transcript

About This Soundscape

Inside the Patch

Technical Snapshot

Quick Answer

Short Overview

Key Takeaways

Controlled Randomness in Bitwig: Weighted Probabilities for Modulation and Note Generation

What It Does

Why the Standard Random Modulator Is Not Enough

How It Works

Workflow

1. Define the possible values

2. Drive the step position with phase

3. Create matching probability weights

4. Use Sample and Hold to output only selected values

5. Send the result to a modulation target

Smoothing the transitions

Alternative routing: Node Grid inside Polymer

Practical Uses

Weighted wavetable selection

Weighted filter motion