Peter McCulloch

Here's an example of analog-style ADSR envelopes created in gen~. These are RC style (so convex going up, concave going down) and are the sum of an AD envelope and an ASR envelope. If you are interested in analog-style envelopes or slew limiters, there is some useful code that demonstrates how to calculate the attack and decay coefficients for slide.

They can respond to changes in parameters at signal rate and they (should) behave similar to analog envelopes in that they are constant rate rather than constant time. That means that the release time of the envelope may be different depending on where the envelope is when the release is triggered. There is also an attack lockout feature which prevents release/decay from occurring until the attack has finished; this is off by default.

The first one behaves like the Moog Mini (no retriggering while sustaining) and the second one behaves like the Arp 2600 (retriggering on every new note). These are not optimized, but they are functional and commented for learning purposes. I haven't included a reset from 0. capability in order to keep the code simpler, but it is certainly possible to implement this feature. Like analog envelopes, these envelopes are not velocity sensitive, though it is possible to modify them so that they are.

================== UPDATED VERSION POSTED IN COMMENT BELOW =================

Here's an example of analog-style ADSR envelopes created in gen~.  These are RC style (so convex going up, concave going down) and are the sum of an AD envelope and an ASR envelope.   If you are interested in analog-style envelopes or slew limiters, there is some useful code that demonstrates how to calculate the attack and decay coefficients for slide.

They can respond to changes in parameters at signal rate and they (should) behave similar to analog envelopes in that they are constant rate rather than constant time.   That means that the release time of the envelope may be different depending on where the envelope is when the release is triggered.  There is also an attack lockout feature which prevents release/decay from occurring until the attack has finished; this is off by default.

 The first one behaves like the Moog Mini (no retriggering while sustaining) and the second one behaves like the Arp 2600 (retriggering on every new note).  These are not optimized, but they are functional and commented for learning purposes.  I haven't included a reset from 0. capability in order to keep the code simpler, but it is certainly possible to implement this feature.  Like analog envelopes, these envelopes are not velocity sensitive, though it is possible to modify them so that they are.

================== UPDATED VERSION POSTED IN COMMENT BELOW =================


analog-style-adsr-envelopes

Thats really great Peter, but I get an error for the gen~ for gate+trigger :

clang: error line 2132 column 43: use of undeclared identifier 'decay'

Would there be any way to vary the curves amount?

compile errors
clang: error line  2132 column 43: use of undeclared identifier 'decay'
gen~: failed to compile patcher

Would there be any way to vary the curves amount?


Here's a fixed version. It isn't possible to vary the curves in this version as it is now.

A way of doing that would be to construct a linear version of this then selectively apply the curves in the code via scale, though it will take some fancy footwork if you want to be able to change the curves rapidly without introducing discontinuities.

Here's a fixed version.  It isn't possible to vary the curves in this version as it is now.

A way of doing that would be to construct a linear version of this then selectively apply the curves in the code via scale, though it will take some fancy footwork if you want to be able to change the curves rapidly without introducing discontinuities.


just wanna say thanks for this and congratulations on the work.

it is not only typically mccullochian, but is also some of the most amazing dsp research and code i have seen done in max for a very long time.

your contributions to the community are always fantastic and have been so for over a decade.

i'll think of something more creatively useful to contribute to this at some stage.

I'd like to join the chorus here. It's such a treat to be around you egg-heads these days. Amazing work. I've wanted to help out in the BEAP project and such, but I've simply been too swamped to participate. Watching from the sidelines is such great entertainment, though.

Thanks for the feedback, everyone! Maybe with some tweaking these could work in BEAP...

Thanks for the feedback, everyone!  Maybe with some tweaking these could work in BEAP...


My biggest flaw is constantly ripping open BEAP modules and using them for my own non-standard purposes. Eh. I *love* BEAP, but I don't "use BEAP".

I had been working on a modular synth library A couple of years ago but realized I wasn't going to have time to finish it and my dissertation, so I rolled some of it into BEAP. (For instance, Bp.AHD is the guts from MOD.AHD~ with 5V stuff added) The stuff from that project is different from BEAP in that it's much lower level (just objects and arguments; no nice GUI) and inputs are not normalized to 5V.

Maybe when I can get some time I'll throw some of the modules up on GitHub. I learned a lot from working on that and BEAP, and found the Sound On Sound Synth Secrets articles to be really handy, since I don't have a ton of old synth hardware experience.

I had been working on a modular synth library A couple of years ago but realized I wasn't going to have time to finish it and my dissertation, so I rolled some of it into BEAP.  (For instance, Bp.AHD is the guts from MOD.AHD~ with 5V stuff added) The stuff from that project is different from BEAP in that it's much lower level (just objects and arguments; no nice GUI) and inputs are not normalized to 5V.  

Maybe when I can get some time I'll throw some of the modules up on GitHub.  I learned a lot from working on that and BEAP, and found the Sound On Sound Synth Secrets articles to be really handy, since I don't have a ton of old synth hardware experience.


First of all, these envelopes are amazing work.

I realize this is an old thread. I'm a newbie with gen so I wonder how difficult it would be to modify the gen~ here to so that the envelopes could ramp logarithmically or exponentially??

First of all, these envelopes are amazing work.
I realize this is an old thread. I'm a newbie with gen so I wonder how difficult it would be to modify the gen~ here to so that the envelopes could ramp logarithmically or exponentially??


I second everyone here, thanks Peter for all the generous and amazing work! I have zero experience with gen and would love to learn how the code works for this envelope. I'll jump over the search box in a minute and start doing my gen tutorial hunt, but if anyone has a suggestion for where to start, it will be much welcome and appreciated!

 I'm looking for someone who could adjust Peter's patch for me as a payed job (since I assume it won't be a quick job). I would allow the patch to be posted here afterwards so anyone can use it for free unless the programmer disagrees. I contact Peter himself by email, but unfortunately to no avail. If you are interested contact me, and let me know your price: nils.vanderplancken (at) telenet.be

As it is now, it's an ADSR, with (as is always the case)

I'd like to expand this ADSR into more complex envelopes found in the classic vintage synthesizer, the 

The prophet VS not only allows you to adjust the 3 fixed levels mentioned above, but also adds another point and is capable of making repeats (loop points).

These kinds of envelopes are very interesting when for example controlling the LFO rate. The manual describes these envelopes in a very easy way:

When a key is pressed, the envelope begins at a 

. These are all linear (same-rate) movements. Provided the key is still held, the envelope will remain at LEVEL C (=sustain level). Whenever the key is released, the envelope falls to 

you can transform this more complex VS envelope into a simple ADSR (for example A: 200ms, D: 100ms, S: 0.9, R: 900ms) by doing:

: 0  (doesn't matter in this case as it connect two point with the same level)

you can add a delay stage of 500ms to this ADSR example by doing:

As mentioned before the prophet VS was capable of looping the envelopes. As the manual describes it:

If the loop is off, then the envelope remains at 

 for as long the key is held. But by using looping, echo effect, LFO effects, restrike effects can be created. 6 options (3 in one direction, 3 bi-directional) were available:

a segment of the envelope is looped but 'ping-ponged', going left to right and right to left between the looped points.

I have attached an example from the manual, showing these loops.

Screen Shot 2020-10-28 at 11.27.15.png

I have honestly no idea how difficult it would be to add the looping feature to the envelopes :)

Payed job proposal: I'm looking for someone who could adjust Peter's patch for me as a payed job (since I assume it won't be a quick job). I would allow the patch to be posted here afterwards so anyone can use it for free unless the programmer disagrees. I contact Peter himself by email, but unfortunately to no avail.  If you are interested contact me, and let me know your price: nils.vanderplancken (at) telenet.be

- a fixed attack starting level of 0
- a fixed attack ending level of 1
- a fixed rerelease ending level of 0

I'd like to expand this ADSR into more complex envelopes found in the classic vintage synthesizer, the Sequential Circuits Prophet VS (1985). The prophet VS not only allows you to adjust the 3 fixed levels mentioned above, but also adds another point and is capable of making repeats (loop points).

These kinds of envelopes are very interesting when for example controlling the LFO rate. The manual describes these envelopes in a very easy way:

When a key is pressed, the envelope begins at a LEVEL X, proceeds to LEVEL A at RATE A, proceeds to LEVEL B at RATE B, to LEVEL C at RATE C. These are all linear (same-rate) movements. Provided the key is still held, the envelope will remain at LEVEL C (=sustain level). Whenever the key is released, the envelope falls to LEVEL D at RATE D.


you can transform this more complex VS envelope  into a simple ADSR (for example A: 200ms, D: 100ms, S: 0.9, R: 900ms) by doing:

LEVEL X: 0
LEVEL A: 1
RATE A: 200ms
LEVEL B: 0.9
RATE B: 100ms
LEVEL C: 0.9
RATE C: 0  (doesn't matter in this case as it connect two point with the same level)
LEVEL D: 0
RATE D: 900ms

you can add a delay stage of 500ms to this ADSR example by doing:

LEVEL X: 0
LEVEL A: 0
RATE A: 500ms
LEVEL B: 1
RATE B: 200ms
LEVEL C: 0.9
RATE C: 100ms
LEVEL D: 0
RATE D: 900ms


As mentioned before the prophet VS was capable of looping the envelopes. As the manual describes it:

If the loop is off, then the envelope remains at LEVEL C for as long the key is held. But by using looping, echo effect, LFO effects, restrike effects can be created. 6 options (3 in one direction, 3 bi-directional) were available:

LEVEL X => LEVEL C
LEVEL A => LEVEL C
LEVEL B => LEVEL C

LEVEL X <=> LEVEL C
LEVEL A <=> LEVEL C
LEVEL B <=> LEVEL C

in the first 3 options, a segment of the envelope is repeated, always going left to right.
In the last 3 options,

 a segment of the envelope is looped but 'ping-ponged', going left to right and right to left between the looped points.

I have attached an example from the manual, showing these loops. 

In these examples LEVEL X is called point 0, LEVEL A is called point 1, LEVEL B is called point 2, LEVEL C is called point 3 and LEVEL D is called point 4

I have honestly no idea how difficult it would be to add the looping feature to the envelopes :)

Kind regards from Belgium,

Nils Van der Plancken

Just found this while I was looking for some ideas on how to build a ADSR in gen~. And its really nice great work.

I used the first one without a trigger, but added Velocity-sensitivity. It just needs some small additions, so at the begining of the codebox I added:

History vel(1);

if (in1 > 0) {
    vel = in1;
    }

And changed the second last line which sets out1 to:

Just found this while I was looking for some ideas on how to build a ADSR in gen~. And its really nice great work.
I used the first one without a trigger, but added Velocity-sensitivity. It just needs some small additions, so at the begining of the codebox I added:

[sharing] Analog-style ADSR envelopes