FaucK is a Chugin allowing to combine the powerful, succinct Functional AUdio STream (Faust) language with the strongly-timed ChucK audio programming language. FaucK allows programmers to on-the-fly evaluate Faust code directly from ChucK code and control Faust signal processors using ChucK's sample-precise timing and concurrency mechanisms. The goal is to create an amalgam that plays to the strengths of each language, giving rise to new possibilities for rapid prototyping, interaction design and controller mapping, pedagogy, and new ways of working with both Faust and ChucK.
FaucK should work both in the terminal and MiniAudicle.
Warning: FaucK is still being developed and things are moving quickly. Use it a your own risks!
Unfortunately, FaucK is only compatible with versions of OSX greater or equal to 10.9 (thanks Apple).
There is an installation package including FaucK, MiniAudicle and Chuck available on OSX that can be downloaded here. It is still being beta tested.
Alternatively, you can use this build which should contain the latest version (it was built on Nov. 4, 2016) of FaucK, MiniAudicle and Chuck (read the README to know how to use it).
Finally, building FaucK from scratch might not be a bad idea... If you want to do that, please refer to the following section.
FaucK is still being actively developed, therefore it hasn't been packaged for any Linux distribution yet. If you wish to use FaucK on Linux, you will have to build it from scratch (see the following section on building FaucK).
First, you should compile Chuck and MiniAudicle using the
fauck branch for both cases which should be done like this (more or less):
git clone https://github.com/ccrma/chuck.git cd chuck git checkout fauck cd src make [yourTarget] sudo make install
git clone https://github.com/ccrma/miniAudicle cd miniAudicle git checkout fauck cd src make [yourTarget] sudo make install
FaucK uses the "on-the-fly" LLVM based version of the Faust compiler (http://faust.grame.fr) also known as
libfaust. Thus, in order to compile FaucK, you need to make sure that
faust2 is installed on your system.
faust2 is an experimental branch of the Faust compiler, so it is very unlikely that you wont find a pre-compiled package for it. The latest stable release of the source code of
faust2 can be downloaded here, however we recommend you to get a snapshot of the
faust2 git repository: https://sourceforge.net/p/faudiostream/code/ci/faust2/tree/.
faust2 has a couple of dependencies so you might have to fix them before you can do anything. For instance, the
LLVM developement files (we recommend version 3.8 or <) as well as
openssl will be needed.
Once you compiled and installed
faust2, you should be able to build FaucK. For this, you must first get the latest version of the
Chugins source code:
git clone https://github.com/ccrma/chugins.git cd chugins
Next, switch to the
git checkout fauck
If you only want to build FaucK, go in the Faust folder (
cd Faust), otherwise, follow the regular build instructions contained in the
To build FaucK on Linux, just type:
make linux sudo make install
make osx sudo make install
As this was explained previously, FaucK has to be compiled with a maximum number of inputs and outputs. The default is 12x12 but you can change that by using the
MAX_OUTPUTS compilation options. For example, if you want FaucK to have a maximum of 2 inputs and 4 outputs on Linux you would run something like:
make linux MAX_INPUTS=2 MAX_OUTPUTS=4
Hopefully, everything went well and you're now ready to FaucK around! If it's not the case, shoot me an e-mail!
FaucK hasn't been tested on Windows so let us know if you make it work! Good luck...
FaucK objects can be used easily in any ChucK code through a Chugin called
Faust. For example, a new
Faust unit generator (e.g., an audio DSP effect that takes an input from ChucK) can be declared as follow:
adc => Faust foo => dac;
In the case where
foo would be a synthesizer, the
adc would be ignored and we could simply write:
Faust foo => dac;
Any Faust program can be associated with
foo and dynamically evaluated by calling the
For brevity and convenience,
stdfaust.lib is by default automatically imported by FaucK. Furthermore, note the use of the backtick (`) to delineate the inline Faust code - this removes the need to manually escape single and double quotation marks used in the Faust code.
Alternately, the same object can load a Faust program from the file system by invoking
compile and providing a path to a Faust
v method can be called at anytime to change the value of a specific parameter defined on the Faust object that is specified by its path (
v stands for "value"; we chose this abbreviation in anticipation that most program will invoke this method often). For example, here we create a sine wave oscillator whose only parameter is its frequency (
freq) and we set it to 440Hz:
foo.eval(` frequency = nentry("freq",200,50,1000,0.01); process = osc(frequency); `); foo.v("freq",440);
dump method can be called at any time to print a list of the parameters of the Faust object as well as their current value. This is useful to observe large Faust programs that have a large number of parameters in complex grouping paths. Programmers can also directly copy the path of any parameter to control for use with the
Examples can be found in the
examples folder of the FaucK distribution: https://github.com/ccrma/chugins/tree/master/Faust/examples