Bitwig Studio Poly Grid Bass Generator for Random Wavetables
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 note2x,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]
