Chugens (pronounced “chyoo-jens”) facilitate rapid prototyping of audio synthesis and processing algorithms. Chugens also provide a basic framework for extending ChucK’s built-in audio processing functionality. Using the Chugen system, a programmer can implement sample-rate audio algorithms within the ChucK development environment, utilizing the full array of programming facilities provided by ChucK. These processing units can be naturally integrated into standard ChucK programs, even in the same script file, providing seamless control of audio-rate processing, control-rate manipulation, and higher-level compositional organization.

A Chugen is created first by subclassing the built-in Chugen class. This subclass is required to implement a tick function, which accepts a single float argument (the input sample) and returns a single float (the output sample). The tick function is fundamental to a ChucK’s audio architecture; to produce a continuous audio stream, ChucK produces 44100 or 48000 samples per second, and each UGen in your program has its own tick function which generates its contribution to the current sample.

The following code uses a Chugen to synthesize a sinusoid using the cosine function, Math.cos.

class MyCosine extends Chugen
{
    0 => int p;
    440 => float f;
    second/samp => float SRATE;
    
    fun float tick(float in)
    {
        return Math.cos(p++*2*pi*f/SRATE);
    }
}

Note that a cosine wave is a sine wave that is 90° “behind” (out of phase with) a sine wave—in most cases it will sound exactly like a sine wave.

A Chugen, once defined, may then be integrated into audio graphs like any standard ChucK UGen.

MyCosine cos => NRev reverb => dac;

Since the tick function is a standard ChucK class member function, it can be as simple or as elaborate as required. Standard library calls, file I/O, multiprocessing (using spork), and other general ChucK programming structures can be integrated into the tick function and supporting code. In the case of an audio synthesizer that does not process an existing signal, the input sample may be ignored. For performance reasons, it’s important to consider that the tick function will be called for every sample of audio, so simple tick functions will typically perform better. Moreover, the intrinsic overhead of ChucK’s VM architecture will cause Chugens to underperform compared to a native C/C++ implementation.

Since Chugens are only a type of ChucK class, they may define functions to provide structured access to whichever parameters they wish to expose to the programmer.

class MyCosine extends Chugen
{
    0 => int p;
    440 => float freq;
    second/samp => float SRATE;
    
    fun void setFreq(float theFreq)
    {
        theFreq => freq;
    }
    
    fun float tick(float in)
    {
        return Math.cos(p++*2*pi*freq/SRATE);
    }
}

Here, we have added a setFreq function, which allows us to set the frequency of the cosine wave. As a general rule, you should always provide a function to set or get parameters from your Chugens, instead of allowing direct manipulation of member variables within the class. Providing a function to get and set a Chugen parameter indicates which parameters make sense to manipulate, and which ones are only important internally; messing with internal properties of any class is almost always a bad idea.

Lastly, we can make a public Chugen, just like normal classes, using the public keyword.

public class MyCosine extends Chugen

By making a Chugen public, we can use it in other ChucK scripts running in the same virtual machine.