Tags: posts bitwig-guides Bitwig Tutorial Grid-Module

Bitwig Array Module - How to Use Recordable Lookup Tables for Powerful Audio Manipulation

Bitwig Guide | Sep 06, 2022

In this tutorial, I explain how the Array (Recordable Lookup Table) module works in Bitwig Studio 3.2 by demonstrating how it stores and plays back audio data, similar to a digital tape recorder. By using envelopes and LFOs to control the read and write phases, you can create a range of effects like pitching, bit crushing, and even realtime audio reversing. The Array module is a versatile tool for creative sound design, and I encourage you to explore its many possibilities.

You can watch the Video on Youtube

Short Overview

In this tutorial, I explain how arrays work in Bitwig Studio’s Grid using the recordable lookup table module. I walk through how you can use an array as a table to store and playback audio data by manipulating read and write phases, allowing creative effects like pitching, bit crushing, and delays. With simple modulation sources like envelopes and LFOs, you can try out different ways to record and play back waveforms in real time. If you found this interesting or have questions, let me know in the comments, and stay tuned for more ideas and tutorials.

Introduction

In this video, I dive into a fundamental topic for my music production channel: explaining what an array does within Bitwig Studio's Poly Grid. I also remind viewers to use my code "polarity" in the shop for a 10% discount and to support the channel. The focus of this tutorial is on Bitwig Studio 3.2, specifically using the array recordable lookup table. I aim to break down how it works, what it can do, and practical ways to use it creatively in music production.

What is an Array in Bitwig Studio?

The array module in Bitwig Studio's Poly Grid acts much like a table or a memory bank, a set of data slots (from 16 up to 1024) where each slot can hold a value, typically a single point from an audio waveform. You have control over how data is written to and read from these slots, which makes the array a versatile tool.

How the Array Module Works

Imagine the array as a row of boxes, each capable of storing one sample point of a waveform. When you feed an audio input into the module, you can control which box (data slot) is filled with new data via the write phase. An index, dictated by the write phase, selects the slot to store data. The read phase chooses which box to read from and push to the output.

For example, if the array contains 1024 slots, you can record 1024 different values, one in each slot. This process works like digitally recording a snippet of audio, breaking it up into bits, and storing each piece in a numbered slot.

Practical Use of the Array Module

To actually use the array, I connect it with the output of my audio patch and control the index number using modules like envelopes. By feeding an envelope (in this case, a loopable AD envelope, a new feature in Bitwig Studio 3.2) to both the read and write phases, I can control where in the array data is written and then immediately read from the same location, essentially “playing” what has just been recorded.

Triggering and Sampling Rate

I use an LFO set to a high rate (up to 32 kHz) to trigger the array. The trigger input effectively acts as the sample clock, every time it fires, one sample is written, determined by the current write phase value, at the envelope's specific point. Faster triggering captures more detail in the waveform.

Decoupling Read and Write for Pitch Effects

One powerful feature of this module is the ability to read from the array at a different speed or index than it was written. By using separate envelopes or mod sources for the read and write phases, I demonstrate the ability to change the pitch of the playback, if you read out data faster than you record, you get a pitched-up effect, akin to playing a tape back at a higher speed.

Applications and Creative Potential

With the array, you can do far more than just simple recording and playback. Possible uses include:

Optimizing Quality

The output quality depends greatly on both the triggering sample rate and how you modulate the read and write phases. Increasing the sample rate (faster LFO) or using smoother, quicker envelopes will improve fidelity. This principle echoes popular sampling techniques from early hardware samplers, where samples recorded at lower rates were pitched up for better resolution upon playback.

Limitations and Flexibility

While I demonstrated triggering and phase control using specific modules (envelopes and LFOs), the Poly Grid is modular, you can use any modulation source to drive these inputs. Imagination is the limit, and plugging different sources into the array leads to endless experimental possibilities.

Conclusion and Future Content

This video aimed to make the array module more accessible, showing that it is not overly complex once you understand the concept. With an understanding of how to store and retrieve waveform data, you can create a vast range of effects, pitch shifts, bitcrushing, reversed audio, delays, and more. I encourage viewers to experiment with all the options in the Poly Grid. More tutorials and preset downloads are planned, so stay tuned. Feedback is always welcome in the comments.

Shoutout

During this period, I want to support fellow creators. If you need graphic or cover art, check out Tatura Hex on Instagram, covers are available for $30 each.

If you appreciated this video, please like, comment, subscribe, and consider supporting me on Patreon. Thanks for watching.

Full Video Transcription

This is what im talking about in this video. The text is transcribed by Whisper, so it might not be perfect. If you find any mistakes, please let me know.
You can also click on the timestamps to jump to the right part of the video, which should be helpful.

Click to expand Transcription

[00:00:00] I actually never thought that I need to explain what an array does in one of my tutorials
[00:00:07] on my music channel.
[00:00:08] But today I will do exactly that.
[00:00:16] Use my code polarity in the shop to save 10% on the price and support my channel.
[00:00:22] So here I have the small poly grid set up inside Bitwig Studio 3.2 and I'm using here
[00:00:31] the new interpolation with the steps as you can see.
[00:00:35] And this is how it sounds.
[00:00:41] So nothing special.
[00:00:43] But I try to use the array now and try to come up with some nice stuff.
[00:00:52] So I'm deleting at the connection between the output and the oscillator or the output
[00:00:57] of the filter here.
[00:01:00] So we have now this module here.
[00:01:02] It's called array recordable lookup table.
[00:01:07] So and this word table exactly makes sense because I try now to explain what this array
[00:01:12] does.
[00:01:13] So we have an input here read phase, write phase and we have actually an audio input
[00:01:19] and we have a trigger input and we have an output.
[00:01:23] So with this array we have data slots and how many data slots you can choose here on
[00:01:33] the left side in the info pane.
[00:01:36] At the moment it's 16 data slots and you can go up to 1024 data slots.
[00:01:46] So this is basically like a table.
[00:01:48] So when we go to the browser I found a small image on the internet and it's actually for
[00:01:56] wave tables but it's exactly enough to explain what this array does.
[00:02:03] So we have here data slots, 1024 data slots and on this table you can see a data slot
[00:02:11] at this rectangle here, this square basically.
[00:02:15] So we store in each of these squares a value and the value is basically some point on our
[00:02:25] waveform.
[00:02:27] So we have an audio input here and then we take or we input an index number for instance
[00:02:35] one and this array module exactly knows okay the user wants to record some value for the
[00:02:43] square one okay which value look at the input, it's audio and then take one sample or one
[00:02:51] point from the input waveform and store it into the data slot okay.
[00:02:58] So we do this for all the slots in the array in this case it's 1024 slots.
[00:03:06] So we sample 1024 data points from our input waveform okay.
[00:03:14] So all we do now is we take the audio input or output of this patch and look it up to
[00:03:21] the input here.
[00:03:22] So we have now something we can sample and then we need of course something to change
[00:03:30] the index, the index number, the slots where we want to store something right.
[00:03:35] We want to store something in one, then two, then three, then four and so on and we can
[00:03:41] do this by using some kind of input so we can take all the modules here inside the grid
[00:03:49] to actually change this number okay.
[00:03:51] So I'm going for an envelope because I tried this before and I think it's pretty fun.
[00:03:59] I using the AD envelope here.
[00:04:02] Why?
[00:04:03] Because it's loopable now.
[00:04:04] It's also a new addition to Bitwig Studio 3.2 you can loop this envelope okay.
[00:04:11] So every time I trigger my keyboard basically let's bring this down here to zero okay.
[00:04:20] So it's completely linear.
[00:04:22] When I trigger my keyboard here you can see this dot goes up right.
[00:04:31] And this dot is also represented by a number.
[00:04:34] So when we take here the output, it's actually the envelope output, you can feed it into
[00:04:40] the read phase and you can also feed it into the write phase okay.
[00:04:46] So now when I press the key on the keyboard we're generating a number from this envelope
[00:04:52] here.
[00:04:53] We use this number to change the index so the array knows exactly where we want to store
[00:04:58] something in the array.
[00:05:01] And we want to store the waveform that's coming from this patch here.
[00:05:06] And we want to store this value at this moment in time in one of the slots okay.
[00:05:12] Because we are using the envelope output here for the read phase and the write phase we
[00:05:17] exactly read at the same place where we write something or we wrote something before into
[00:05:25] the grid right.
[00:05:27] And to make this happen we also need something to trigger here this array.
[00:05:34] And I'm using an LFO here.
[00:05:38] I'm using an LFO and I'm using here this waived shape teeth basically.
[00:05:46] And I'm going out into the trigger switching this to kilohertz.
[00:05:54] And I'm going up to 32 kilohertz.
[00:05:58] So this is basically our sample rate.
[00:06:00] So every time we trigger this array with the LFO we sample something.
[00:06:05] And every time we sample something we take the audio input, take the number from the
[00:06:10] waveform and write it at the index.
[00:06:14] We gave this array via this envelope okay.
[00:06:19] So the envelope decides which slot to take, the input decides what value we want to store
[00:06:28] and the sample rate basically decides when something happens okay.
[00:06:35] So now we can hook up here I think the output or let's actually use an oscilloscope at the
[00:06:42] end so we can see what's happening and we take the output here okay.
[00:06:49] So now when I press the key on the keyboard you can hear it's basically the same output
[00:07:04] as before.
[00:07:05] A lot of crackling is happening but that's okay for now.
[00:07:11] But we change basically the index of the read index the same way we change it for the write
[00:07:25] index.
[00:07:26] So it's every time the same but when we actually use a second AD here the output for the write
[00:07:35] face now we can change the index reading differently from how we write something right.
[00:07:46] So now when I change the read speed we can change some kind of pitch the pitch because
[00:08:09] we are reading the index faster than we are writing to it.
[00:08:15] I hope this makes sense it's just like a tape recorder where you record something slow and
[00:08:21] then you play it back much faster right but in a digital way instead of tape you're using
[00:08:30] basically an array.
[00:08:36] And now we can activate here the sloop function so we have a continuous flow of audio.
[00:09:02] You can also hear that the resolution changes a lot when I change this envelope because
[00:09:17] the resolution is not only decided by the triggering here by the sample rate also by
[00:09:23] the playback speed so when you sample something like with 8-bit and you play it back much
[00:09:30] much faster the resolution becomes better or higher because you just push it together.
[00:09:38] I hope that makes sense in some case but the sample rate is not so important when you basically
[00:09:45] pitch stuff up.
[00:09:47] So that's why we use to sample instruments in the early days at much much lower frequencies
[00:09:59] so we can pitch it up inside the sampler to have a better resolution.
[00:10:04] So this is the same concept.
[00:10:22] What we also can do is we can introduce some kind of logic so we can choose to record something
[00:10:31] at will so let's use a button here and actually use this for the right face go in here or
[00:10:48] actually go in bottom one so and then go with audio in here and this and this then we can
[00:10:57] call this here record and now we just record when we hit this button.
[00:11:22] So when I hit some some key on my keyboard here I actually just play the output buffer
[00:11:27] so there's no audio coming through I can completely remove here the audio input or remove this
[00:11:35] audio input here.
[00:11:41] So it's just the data stored in the slots inside the ray that are playing but you can
[00:11:47] as you can saw before you can basically use this when here you can use this as an audio
[00:12:00] pitch or to pitch some audio up or down on in real time.
[00:12:08] So when we remove this here basically again and go with the audio in here and use this
[00:12:14] for the right face and we use a steeper slope here for the read then for the write then
[00:12:21] the output is always pitched up so 425 is the original.
[00:12:38] So this is the original pitch and now we have always a pitched up audio signal so you can
[00:12:55] not only use this to repeat something you can also use it to pitch audio up and down.
[00:13:04] I know it sounds a bit bit crushed but you can optimize it by using a higher sample
[00:13:11] rate here maybe and or a steeper envelope for the right face so we can write more information
[00:13:20] faster.
[00:13:40] So there's much to much stuff to explore it's actually pretty fun to play around with the
[00:13:59] array here and I hope I explained everything pretty well I know I repeated myself a lot
[00:14:05] in this video but I want to make sure that everyone gets what I'm trying to explain.
[00:14:12] It's not so a complicated module I think you can do a lot of stuff with it and you don't
[00:14:20] need to use an LFO for the triggering and you don't need to use an envelope here for
[00:14:25] the write and the read phase.
[00:14:26] You can use all kinds of modules in the grid as always just feed something into something
[00:14:32] and see what comes out of it.
[00:14:35] So this was just my attempt to try to explain what the array does and I think you can already
[00:14:46] see that's a pretty powerful module and it will be pretty fun to actually explore what
[00:14:53] you can do with it in the future.
[00:14:56] So I hope this was pretty much easy to understand what I'm trying to explain if you have some
[00:15:01] questions of course just tell me in the comments below I try to answer everything.
[00:15:07] This was just my first attempt at trying to explain what this module does.
[00:15:12] I think it's pretty low level but when you get the concept you can do a lot of stuff
[00:15:18] as you can as you just saw you can pitch up and down audio you can use it as a delay
[00:15:24] you can use it a bit crush stuff you can use it to make reverbs all these kinds of stuff
[00:15:34] you can do with the array where we can just store values or values from waveforms and
[00:15:43] then recall it in a different way.
[00:15:46] Maybe you can also do something like a reverse you can reverse audio in real time something
[00:15:51] like this but I will do make more tutorials on this in the future of course also presets
[00:16:00] for you download and yeah tell me what you think about this video and leave me a comment
[00:16:07] down below if a thumbs up subscribe to the channel and subscribe to Patreon and I see
[00:16:15] you in the next video thanks for watching and bye.
[00:16:20] In the current time with the Corona virus a lot of creators struggle to survive so I
[00:16:25] want to place an ad at this point in my video for my man Tatura Hex and he does graphics
[00:16:34] or in fact covers so when you plan to release something in the future then maybe give this
[00:16:41] man a follow on Instagram the name is Tatura Hex and he sells these covers for $30 each
[00:16:50] so maybe it's something for you.
[00:16:53] .
[00:16:56] .
[00:16:58] .
[00:17:00] .
[00:17:01] .
[00:17:03] .
[00:17:05] .
[00:17:07] .
[00:17:08] .
[00:17:09] [BLANK_AUDIO]