Serum Formular Parser Explained

Tutorial | May 07, 2025

In this video, I show you how to use formulas in Serum's wavetable editor to create unique waveforms by manipulating variables like X, V, and Q. By focusing on simple mathematical expressions and randomization, you can generate interesting sound variations across different harmonic bins. Experiment with these techniques to expand your sound design possibilities in Serum.

You can watch the Video on Youtube

• support me on Patreon

Summary #

Maybe you don't watch the video, here are some important takeaways:

Hey folks, welcome back! Today, I'm excited to show you something new you might not have tried in Serum yet, mainly because there aren't any tutorials on it, and it might seem complicated. But I'll simplify it for you, so you'll get the concept and can explore more on your own. This works in both Serum 1 and Serum 2.

You probably already know that Serum has an empty wavetable that we can edit using the editor. Inside, you can adjust partials or draw waveforms. But let's reset this and focus on typing formulas. This might be new for you, so let's start simple.

To understand what we can do, you need to look at the manual, specifically section 15 on the formula parser. You’ll find all the math functions and variables like W and X, which are time values plotted from 0 to 1 or -1 to +1. By typing "X," you’ll notice it forms a saw wave. This is because the parser operates from left to right, mapping position values.

For example, typing in a formula like "X" gives different values at positions, creating a waveform. You can manipulate this by multiplying or adding values, such as reversing the waveform with "-1" or using "rand" for randomness, creating variations in the waveform.

Now, let’s focus on "Q" to work with FFT bins instead of the waveform display. By using "Q," you can set conditions, such as "Q < 10," which gives true or false outputs affecting the harmonics visible at the top. You can randomize harmonics or apply math operations like dividing to scale values. Using "abs" ensures all values remain positive.

To make multiple frames, introduce "Y" or "Z," representing table numbers. You can create variations with functions like "rrand" for randomness per frame. I showed how to build in custom conditions, like ensuring lower harmonics have higher values, which often results in interesting sound patterns.

Reducing tables or using morph functions can enhance these sounds. Ultimately, these custom formulas allow you to create unique waveforms, expanding Serum’s capabilities.

I plan to write all these details in the video description or on my website for further reference. Try these examples, experiment, and maybe share your creations in the comments.

Export your creations as 16-bit waves for use in other synthesizers like Bitwig’s Polymer. Thanks for watching, and if you enjoyed this guide, leave a like, subscribe, and let me know your thoughts! See you tomorrow at Superbooth. Bye!

Formulas I used in the video #

Here are some formulas I used in the video. You can use them to create your own waveforms in Serum. Maybe come back later. I will add more formulas to this list.

x

Maps the position to a value from -1 to +1 in the waveform editor. The process always works from left to right, iterating over each position and assigning a value based on the formula. So left position is -1 so x is -1 so the value of the position -1 is -1. The position 0 is 0 and the position +1 is +1. EASY!

x * -1

Does the same but reverses the waveform. So the position -1 gets the value +1, the position 0 gets the value 0 and the position +1 gets the value -1. So we have a reversed waveform.

x + 0.5

we offset the waveform to the right side. So the position -1 gets the value -0.5, the position 0 gets the value +0.5 and the position +1 gets the value +1.5.

x * rand

randomizes the waveform. So the position -1 gets a random value between -1 and +1, the position 0 gets 0 (because 0 * rand = 0) and the position +1 gets a random value between -1 and +1.

abs(x)

makes all values positive. So the position -1 gets +1, the position 0 gets 0 and the position +1 gets +1.

(q < 10) rand / q

because we use q in the formula, we plot to the FFT bins instead of the waveform display. So we can use q to set conditions. In this case, we check if q is smaller than 10. If this is true, we get a 1, if not we get a 0. So we multiply this by a random value and divide it by q. This gives us a random value for the first 10 bins and 0 for all other bins.

(q<20) * abs(rrnd) / (q*0.5) * (y/y)

this only randomizes all bins below 20. So we check if q is smaller than 20. If this is true, we get a 1, if not we get a 0. We multiply this by a random value (only positive because of abs()) and divide it by q * 0.5. This gives us a random value for the first 20 bins and 0 for all other bins. The y/y is just to make sure that we have a math operation in there but still use y to create multiple frames in the table.

(q < 100) * rrnd * (1 / q^0.8) + 0*z

Creates random "Growl" wavetables with a lot of harmonics. Try to change q^0.8 to differnt floats, and watch how the waveforms change. We also modulate only the low 100 partials with (q < 100). The 0*z is just to make sure that we have a math operation in there but still use z to create multiple frames in the table.

Parser - From the Serum Manual #

Type some math, make a sound. The Formula Parser (a type-able text feld located in the Waveform Editor) allows you to enter math functions in order to plot tables
generatively. This is a fairly advanced feature, and something most people probably have no desire to explore. However if you want to generate waveforms
from thin air, then perhaps now is the time you'll fnally wish you paid attention in math class! Fortunately there are many formula presets included, and it is pretty
easy to paste in formulas provided by other users (I'm sure a nice list will get made in the Serum registered user forum!)

Basic Functions #

The following table lists the default functions supported by the parser. The function name is the name of the function, and the arguments are the number of arguments that the function takes. The explanation is a brief description of what the function does.

Built-in binary operators #

The following table lists the default binary operators supported by the
parser.

Constants and Variables: #

Constants and variables are used in the formula parser to create a variety of waveforms. The following table lists the constants and variables available in the parser.

There are two fles in SerumPresets/System/ - FormulaUserMultis.txt and FormulaUserSingles.txt, these files, if not empty, will add additional submenus “User Singles” and “User Multis” to the Formulas list. Serum plug-in must be de-instantiated and re-inserted for formula menus to refresh. The text fles have a format as follows:

[formula1][formula1 name]
[formula2][formula2 name]

Refer to the fles FormulaFactorySingles.txt or FormulaFactorySingles.txt for examples. Note: While you can technically also edit FormulaFactorySingles.txt and FormulaFactoryMultis.txt, it is recommended to use the User Files instead. This way you won't accidentally overwrite your personal formulas when installing an update, for instance.

Transcription #

This is what im talking about in this video. The text is transcribed by AI, 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.

[00:00:00] Hey, folks, welcome back.
[00:00:01] So today I want to show you something
[00:00:03] that you probably haven't done in Serum yet.
[00:00:06] And it's maybe because there are no tutorials about this
[00:00:10] on YouTube, maybe it's too complicated,
[00:00:12] but I want to show you this and keep it really simple
[00:00:15] so you get the idea how it works.
[00:00:18] And it works in Serum 1 and also in Serum 2,
[00:00:22] so you can use one of them.
[00:00:24] It doesn't matter, it's the same thing.
[00:00:26] So you probably already know that we have here
[00:00:29] an empty table and we can edit this table
[00:00:31] by just clicking here this edit button.
[00:00:34] And then inside of the wavetable editor,
[00:00:36] you can change here the partials
[00:00:39] and you can also draw in here stuff to create waveforms.
[00:00:43] We already know this, right?
[00:00:45] So let's reset this.
[00:00:46] And we can also type in here a formula
[00:00:50] and I want to focus on this and give you an idea
[00:00:52] how this works and I try to keep it as simple as possible
[00:00:56] so you get the idea how it works
[00:00:58] and you can make it complicated later on.
[00:01:01] We start simple and then make it complicated.
[00:01:03] This is how you learn, right?
[00:01:05] So there's also here some kind of presets you can use,
[00:01:10] but that's not what we want to do.
[00:01:11] We want to type in our own formulas.
[00:01:15] And to get a hint of what we can do,
[00:01:18] we have to go to the manual.
[00:01:19] So read the manual and you probably already read it.
[00:01:23] I know it, we all read manuals, right?
[00:01:26] So there's a section down here, 15 formula parser.
[00:01:29] Types of math make a sound
[00:01:31] and then all kinds of different variables
[00:01:34] and functions and so on, a lot of stuff.
[00:01:37] And I don't want to explain everything.
[00:01:39] I just want to give you a starting point here.
[00:01:42] So we want to focus on V and X for a moment here.
[00:01:46] So V is a variable and this is the current time value
[00:01:50] getting plotted from zero to one
[00:01:53] and X is the current time value
[00:01:55] getting plotted from minus one to plus one.
[00:01:58] So the range is different, but it's the same thing.
[00:02:02] It's just different values for the same things.
[00:02:06] So here in the editor, we can type in just X
[00:02:11] and this gives you a saw wave.
[00:02:14] So the question now is why does it give us a saw wave?
[00:02:21] And it's pretty simple.
[00:02:22] The parser or the processing here
[00:02:25] is always working from the left side to the right side.
[00:02:30] It iterates over each position
[00:02:33] and gives each position a different value.
[00:02:36] So here, the position from top to bottom
[00:02:39] is the value of minus one, so position minus one.
[00:02:44] And this is position zero, okay?
[00:02:47] And this is position plus one, if you use X.
[00:02:52] If you use V, this is value or position zero
[00:02:56] and this is position zero dot five
[00:02:59] and this is position one, okay?
[00:03:01] So X gives you position minus one, zero plus one, okay?
[00:03:06] So why does it give us now here some kind of saw?
[00:03:09] It's pretty simple.
[00:03:10] So position minus one gives it a value of minus one
[00:03:15] because this is position minus one.
[00:03:18] So X is the position.
[00:03:20] Give position minus one value of minus one,
[00:03:23] which is down here, right?
[00:03:24] So down here is minus one, this is plus one.
[00:03:28] So all we do now is map the position to a value, right?
[00:03:33] So position minus one gets value minus one,
[00:03:36] position zero gets value zero,
[00:03:39] position plus one gives you value one, pretty easy.
[00:03:44] So this also means we can type in here,
[00:03:48] multiply by minus one, which is just reversing, right?
[00:03:53] If you just take minus one and multiply it by minus one,
[00:03:56] we get plus one.
[00:03:59] And if you take zero and multiply it by minus one,
[00:04:03] we get zero and if you take plus one
[00:04:06] and multiply it by minus one, we get minus one.
[00:04:08] So we have now here exactly the opposite.
[00:04:12] So we map the opposite to the opposite more or less.
[00:04:16] Gives you also a sort just to reverse, so on.
[00:04:18] We can also offset this.
[00:04:24] We can also say minus one, so it looks like this.
[00:04:28] We can say plus zero dot five, so we offset to the right side.
[00:04:35] This doesn't work because there's a minus here.
[00:04:39] So it gives you something like this.
[00:04:43] So we can do all kinds of different things.
[00:04:46] We can also multiply by a random value, rent.
[00:04:50] It gives you something like this, right?
[00:04:52] Minus one gets a random value.
[00:04:54] And here we have nothing because this is zero.
[00:04:56] So zero multiplied by a random value is zero.
[00:05:00] So it's always no value here, right?
[00:05:02] We can also see this in here.
[00:05:05] There is a pi we can use.
[00:05:07] There are also some functions here, rent.
[00:05:10] That's what I used here.
[00:05:11] A random number from minus one to plus one, right?
[00:05:16] So that's why it looks like this because it's just a random value.
[00:05:21] We mapped to this position.
[00:05:23] So this is how it works inside of this wave form editor here.
[00:05:31] It works always from the left to the right.
[00:05:34] So you can type in all kinds of formulas there.
[00:05:39] But I want to focus actually on this on top here on the bins.
[00:05:44] We can also automate this or use math to change how this looks like here at the top.
[00:05:51] So let's go back here to in it.
[00:05:53] So to make this work, we have to use Q inside of the formula.
[00:05:59] And you can see this also here, Q.
[00:06:03] When Q is preset, it's probably they mean present here.
[00:06:08] When a Q is present in the formula, the function plots to the FFT bins
[00:06:13] instead of plotting to the waveform display.
[00:06:16] Q iterates from one to five and 12 for the respective harmonic bins.
[00:06:23] So here it's the same thing.
[00:06:27] If we if we type something in here and we use Q in the formula,
[00:06:31] this is one, this is two, this is three, this is four and so on.
[00:06:36] And always starts here and then iterate from the left to the right side.
[00:06:40] So we can say or we can actually type in your condition.
[00:06:46] We can say Q smaller than 10, which means this parenthesis here
[00:06:53] gives you a true or a false.
[00:06:55] If if it's below 10, if Q is below 10, then this gives you a true, which is one.
[00:07:03] And if it's above 10, then it gives you a false, which is zero.
[00:07:07] So this equation here or this result gives you either one or zero.
[00:07:13] And then we multiply this by a random value.
[00:07:18] And it looks like this.
[00:07:22] So we have only the first nine bins here, modulated or randomized, more or less.
[00:07:28] And we can also just leave this out.
[00:07:33] Um, so we can randomize everything.
[00:07:35] So rent and we multiply this by Q divided by Q, because this gives you always one.
[00:07:46] As we have to include the Q to make it actually to make it work on top here.
[00:07:52] But you also have to do some kind of math operation.
[00:07:55] So the math operation that gives you kind of nothing is Q divided by Q.
[00:08:02] Because you have been one divided by bin one is one, the two divided by two is also one.
[00:08:08] So it gives you always a one.
[00:08:10] So we randomize each partial.
[00:08:13] I don't know how many parcels there are 512.
[00:08:18] So it gives us something like this.
[00:08:20] And some of these parcels have here zero in there because, um, random is always
[00:08:30] between minus one and plus one.
[00:08:33] So sometimes you get minus 0.5 minus 0.3 and so on.
[00:08:38] So we have a lot of parcels in here that are below zero.
[00:08:42] So there are zero.
[00:08:43] So what we can do is we can use here and method, um, apps, absolute, absolute value.
[00:08:51] And all this method does is it's taking negative values and puts it into a positive range.
[00:08:59] So minus one becomes plus one minus 0.3 becomes plus 0.3.
[00:09:04] Right.
[00:09:04] So with this, we should land more often inside of the positive range.
[00:09:11] So let's do something like this.
[00:09:14] Right.
[00:09:14] So now you can see we have much, much more parcels here getting values, um, that are in
[00:09:22] the positive range, but still nothing you want to use.
[00:09:27] That actually sounds, sounds like something.
[00:09:30] Okay.
[00:09:33] So there's a partial in here at some point with a pretty big value.
[00:09:38] Anyway, so this is cool, but it's better to actually limit yourself to the first few
[00:09:51] parcels, um, minus, I don't know, 20 maybe, right?
[00:09:58] Only randomized here from zero or one to 19.
[00:10:03] And then it gives you much more pleasant or interesting sounds.
[00:10:09] Can I repeat this?
[00:10:11] No, I have to change the parsing.
[00:10:15] Oh, that's, that's wrong.
[00:10:19] 10.
[00:10:22] So you can create random sounds here with this pretty easily.
[00:10:31] This is a condition pretty easy and gives you a zero or one, one, when it's below 10,
[00:10:37] zero, when it's above 10, multiplied by your, um, 10.
[00:10:42] Multiply it by your, um, absolute random value, right?
[00:10:47] So each partial gets then a random value and then we multiply here by Q divided by Q,
[00:10:53] just to have Q in the equation to make it actually work on top or in the top, uh,
[00:11:01] harmonics, harmonic table instead of this wave editor.
[00:11:05] Yeah.
[00:11:05] So that's, that's why we use this.
[00:11:09] Um, another thing we can do is, um, instead of this apps rent or maybe we keep this apps rent,
[00:11:17] uh, we can also include here another thing.
[00:11:21] Let me go back in here.
[00:11:24] Um, where is it?
[00:11:28] Um, so we have your Q, uh, and we also have, oh yeah, C and Y, that's the thing.
[00:11:38] So that's the current table number.
[00:11:40] And this is also from zero to one and Z is from minus one to plus one.
[00:11:47] So this represents actually the tables in here.
[00:11:52] So at the moment, we just generate one frame, but we can also generate multiple frames.
[00:11:58] So this is then represented by Z and Y.
[00:12:05] Um, so we can use maybe Y in here.
[00:12:08] We have to multiply it by something.
[00:12:10] So we can just do something like this.
[00:12:13] So table one, right?
[00:12:15] So we have a random value here.
[00:12:17] And this random value then is multiplied by, by zero here.
[00:12:20] Here it's multiplied by one.
[00:12:22] Here it's multiplied by two.
[00:12:23] Here it's multiplied by three and so on.
[00:12:25] So each table frame is a number here and we multiply this.
[00:12:29] And I guess we can also, if we don't want to do this, we
[00:12:35] can just divide this by Y.
[00:12:38] So we get the one each time, hit this and takes a while.
[00:12:42] And then we generate here multiple tables.
[00:12:45] And you can see all of these tables are the same.
[00:12:48] The reason for that is because of random.
[00:12:52] So let's go back to random here and says a random number from minus one to plus
[00:12:58] one stays the same for all tables because it's pre calculated for every time position.
[00:13:05] Um, which means random is the same for each table, but there is another function
[00:13:11] here that's not in the manual for some reason.
[00:13:13] Um, it's called rrnd.
[00:13:17] So it's R random, random or something like this.
[00:13:20] So this is a random value.
[00:13:22] It's the same as random, but it's recalculated for each frame.
[00:13:27] So we type this in and then you can see each table is now slightly
[00:13:34] different and you can see all the values here are kind of randomized.
[00:13:39] But it's, it stays below 10.
[00:13:42] So this was, was the postman on the door.
[00:13:45] Anyway, so we have now here random values.
[00:13:51] But there's a problem here, in my opinion.
[00:13:55] You can see it's too much random here to too much randomness.
[00:14:01] What I want to have is I want to have higher values for the low
[00:14:06] partials and lower values for the top partials.
[00:14:09] That's usually how the sounds are.
[00:14:12] So we can build this in here.
[00:14:14] We can multiply this by, let's say, multiply also in here.
[00:14:22] Um, so the Q or let's actually just divide this by Q.
[00:14:28] Um, which means each partial here, so we have a random value, right?
[00:14:36] And then partial five here, we have a random value.
[00:14:38] And this is then divided by five.
[00:14:41] This is divided by six.
[00:14:43] This is divided by seven.
[00:14:44] So it should be the case that each partial gets lower.
[00:14:49] Um, the higher you go in the harmonics.
[00:14:53] So let's try this out.
[00:14:54] Maybe make a space in here.
[00:14:57] So this looks much better, right?
[00:15:01] You can see a high partial and then it gets lower over time.
[00:15:05] Um, let's see how this looks like.
[00:15:09] Okay, maybe use more partials.
[00:15:24] Let's use 20 and generate this again.
[00:15:27] Oh, this kind of looks interesting.
[00:15:33] So maybe you can lower this value here.
[00:15:47] Um, so the Q is basically too much.
[00:15:52] So, um, it's always one, two, three, four, five, and so on.
[00:15:56] So we can multiply this by zero dot five on something like this
[00:16:00] to scale it to make this value a bit smaller.
[00:16:03] Let's see how this looks like.
[00:16:05] Maybe a bit better.
[00:16:08] So we get also random random sounds here.
[00:16:12] So what I usually do then to create something more interesting
[00:16:22] out of this is I go to add, remove, and say reduce to,
[00:16:26] let's say 16 tables, right?
[00:16:29] So just select the first 16 tables and you remove all the rest.
[00:16:35] So we do this.
[00:16:37] You can see we have 16 tables here.
[00:16:39] And then we just, uh, maybe select everything.
[00:16:45] I don't think you need to select everything actually.
[00:16:47] And then I say more spectral.
[00:16:50] And it gives serum the information that you want to morph
[00:16:54] spectrally from one table to the other.
[00:16:57] Maybe you can also do this here, zero or phases.
[00:17:01] Yeah, maybe it does.
[00:17:05] Okay.
[00:17:05] So then there's something in between.
[00:17:08] That's maybe not interesting.
[00:17:10] Should remove this.
[00:17:11] Remove current index.
[00:17:18] Yeah, that's what I need.
[00:17:20] Again, process.
[00:17:22] Something like this.
[00:17:26] So now we have here 260, 256 tables, but you can morph between them.
[00:17:32] And this is how we can create random wave tables that have multiple
[00:17:48] different entries and, uh, just with some kind of simple math.
[00:17:53] I probably write all of this here in the description below and a
[00:17:58] small description why I typed it in, or maybe even write it on my website
[00:18:03] and make more explanations.
[00:18:04] What, what does what and why, but the main idea, what you need to get is
[00:18:11] that this parser always iterates from the left side to the right side.
[00:18:16] And if you put Q in there, it iterates from the left bin to the right
[00:18:21] bin here, and you can use all kinds of math in here to modify the value.
[00:18:27] And use more or less the positions like X or Q, which is the, the bin number
[00:18:34] and multiply this to actually scale these values.
[00:18:39] Uh, so this is the idea behind it.
[00:18:41] I want to show you this actually.
[00:18:43] So maybe you can try it out, type in these examples here for yourself
[00:18:47] and experiment with this.
[00:18:49] And as you can see, you can create so many wave tables just with randomization
[00:18:55] and typing in here, some random math equations and play around with this.
[00:19:00] Maybe you get something interesting.
[00:19:01] Maybe you can put it in the comments down below if you want to.
[00:19:05] And, um, yeah, I want to basically give you a starting point and maybe
[00:19:11] something that you can use to get more out of serum.
[00:19:14] And like I said, um, this also works here in the new serum.
[00:19:19] Let's type this in.
[00:19:21] It gives you more or less the same.
[00:19:24] I think that's basically the same editor like in here.
[00:19:26] It's just a different, uh, different GUI layout or skin or whatever.
[00:19:32] It kind of works in the same way.
[00:19:33] Um, and then if you want to use this in Bitwig, all you have to do is
[00:19:38] here export as 16 bit wave.
[00:19:40] That's what I do most of the times.
[00:19:43] And then you can drag it into, um, polymer or any other, uh, wave tables
[00:19:48] synthesizer, kind of neat and interesting.
[00:19:51] So that's it for this video.
[00:19:53] Um, read the manual and, uh, leave a like, leave a subscription and let
[00:19:59] me know in the comments down below what you do or if you use this or how
[00:20:03] you use it or what kind of formulas you come up with.
[00:20:05] Okay.
[00:20:06] Thanks for watching.
[00:20:07] And I'll see you tomorrow at super booth.
[00:20:09] Bye.