This paper introduces Phausto, a library that generates sounds in Pharo programming language using Faust (Functional Audio Streams), a programming language designed to develop real-time digital signal processors (DSP). In Phausto, DSP programs are created by the composition of Unit Generators written in a MUSIC-N style, like the ChucK programming language, or from a string containing a valid Faust program. We present Phausto's API, implementation details and an overview of its syntax, and of Unit Generators and ToolKit elements. We also analyze the motivations behind the project and identify its target audiences. Finally, we present the conclusions drawn after one year of development and use, and outline the agenda for future work.
All Unit Generators have default values for their parameters, which are themself Faust boxes, too. The main contributions of this paper are: • A description of the Phausto library architecture and implementation details. • Examples of sound synthesis using Phausto API.
• An overview of the Phausto Standard Library and ToolKit.
We develop Phausto to generate sound directly from the Pharo environment, without needing external dependencies to play performance during live coding sessions.
We have identified three primary target audiences for Phausto: 1. Pharo programmers who want to include sounds or sonic interaction in their Pharo applications, including procedural audio designed Faust extensive physical modelling synthesis library; 2. Artists with little or no computer literacy who want to design and develop synthesisers and efects for their music creation fast and easily. Pharo ofers a transparent syntax with a neat IDE and a browser that enables users to avoid complex library management; Phausto ensures all Faust libraries are readily accessible as well-documented classes and methods. 3. Students and beginners who want to develop their audio plug-ins, by exporting DSPs developed in Pharo to Cmajor1 patches thanks to the Faust2CMajor export2. Cmajor is a new C-family programming language for writing fast and portable audio software, created by Julian Storer and Cesare Ferrari. Cmajor patches can be exported as native VST/AU/AAX plugins or loaded directly into a Digital Audio Workstation (DAW) with the Cmajor VST/AU plugin
create a Box from Phausto Objects
BOX
API creates DSP PHAUSTO from a String
Unit Generators are
implemented in the FAUST libraries creates a DSP from a Box
DYNAMIC ENGINE
LIBFAUST FAUST LIBRARIES (stdfaust.lib) the FAUST generated prorgam computes samples for the underlying audio layer
PORTAUDIO fills blocks of audio bufffers
PLATFORM
SPECIFIC AUDIO DRIVER outputsacuhdaionntoelleft outpcuhtasnanuedliotoright
Phausto is an open-source Pharo library to create synthesisers and audio efects that are converted into Faust programs by an embedded Faust compiler. Figure 1 shows an overview of its architecture.
2https://github.com/grame-cncm/Faust/tree/master-dev/architecture/cmajor#Faust2cmajor
The Dynamic Engine in the backend initialises the PortAudio library and opens a stream for audio I/O. It creates a DSP from strings of valid Faust codes or Boxes created with the Phausto API. The definitions of the Unit Generators are implemented in the Faust libraries, which are accessed by the Dynamic Engine when DSPs are created.
The DSP is a Faust program that computes floating point numbers between -1.0 and 1.0 as output. These values fill the blocks of a PortAudio stream. The platform-specific audio driver transforms the PortAudio stream into sound, using the sound interface Digital-To-Analog converter.
Faust (Functional Audio Stream) [
The dynamic engine implementation describes a straightforward C API for Faust objects including the audio drivers responsible for rendering the samples computed by the DSP and the library used for reading audio data files. Faust DSP objects are structures that can be either instantiated from a string of valid Faust code by calling the createDsp function: dsp* createDsp (const char* name_app, const char* dsp_content,
int argc, const char* argv[], const char* target, int opt_level); or from Boxes (Section 4.3) with the createDspFromBoxes function: dsp* createDspFromBoxes(const char* name_app, Box box,
int argc, const char* argv[], const char* target, int opt_level);
After being created, DSP needs to be initialized by calling the initDSP function with a sampling rate and bufer size for the audio driver. 5. Finally, start function is called to open the audio stream and processing audio blocks until stop function is called. bool initDsp(dsp* dsp, RendererType renderer, int sr, int bsize); bool startDsp(dsp* dsp);
The dynamic engine also allows access to and modification of DSP parameters using the getParamValueDsp and setParamValueDsp functions: FaustFLOAT getParamValueDsp (dsp* dsp_ext, int p); FaustFLOAT setParamValueDsp (dsp* dsp_ext, int p, FaustFLOAT val);
The dynamic engine includes the Faust Compiler [
4https://Faustdoc.grame.fr/manual/architectures/
5For a more detailed description of sampling rates, audio bufer size and audio drivers, refer to the first chapters of The Audio
Programming Book [
To maintain compatibility across diferent operating systems and keep the ToolKit as lightweight as
possible, we leverage PortAudio. PortAudio is an Open Source Cross Platform C library7 and API for
audio input and output [
PortAudio renders the samples computed by the Faust interpreter with the PortAudio and Faust’s native library10. This approach ensures all the dependencies (including all Faust libraries) to be less than 10 MB.
PortAudio handles the connection with the audio input and audio ports on the host platform. It internally manages audio stream bufers and requests audio processing from the client application via a callback that is associated with an opened stream. In the dynamic engine, this association is managed by the following function: bool initDsp(dsp* dsp, RendererType renderer, int sr, int bsize);
For instance, in Phausto we initialise a DSP by calling: initDsp(aDSP, 0, 44100, 512);
This function sets the sampling rate and the bufer size and allows one to choose a diferent renderer from PortAudio if needed. 4.3. The Box API The Faust C box API11 allows for the programmatic creation of a box expression, which is used to create a DSP object. This stage is an intermediate public entry point created in the Semantic Phase of Faust’s compilation chain. The Semantic Phase is the first step of Faust’s compilation chain; starting from the DSP source code written in Faust, the Semantic Phase produces signals that are (conceptually) infinite streams of samples. Boxes can be created by calling a specific function defined in libFaust-box-c. e.g., for creating a UI button: Box CboxButton(const char* label);
Or from a string of Faust code by calling: Box CDSPToBoxes(const char* name_app, const char* dsp_content,
int argc, const char* argv[], int* inputs, int* outputs, char* error_msg);
The Box API also supplies methods to convert numbers into Boxes and to connect Boxes via the five
binary composition operators of the language12
7https://github.com/PortAudio/portaudio
8https://www.cs.cmu.edu/~music/portmusic/
9https://midi.org/
10https://github.com/grame-cncm/Faust/blob/master-dev/architecture/Faust/gui/Soundfile.h
11https://Faustdoc.grame.fr/tutorials/box-api/
12In Faust there are five binary composition operations to combine block diagrams: sequential( :) , parallel( , ) , split( <: )
merge (:>) , recursive ( ~ ) . For a detailed description of Faust binary operators see [
Programming DSP with Phausto is fast and easy because it combines the modular synthesiser [
Listing 1: Simple example using Phausto
Listing 1 shows a simple example using Phausto playing a Pulse Oscillator. First, we instantiate the UGen to play, in this case, a Pulse Oscillator. Then we create a stereo DSP by sending the messages asDSP to our Pulse Oscillator. (To change the mono output of a synth to stereo, we send the stereo message to the Box that is the result of the multiplication).
Once our DSP is created, we initialize and start it to hear the sound it generates. We can stop the DSP whenever we want. If we are finished with our DSP programming, it would be a good practice to destroy it.
Each UGen has diferent configuration parameters with default values, each of them documented in the class comments. For example, to control the parameters of a Pulse Oscillator we need to specify the freq - for frequency in Hertz, and duty - to change the oscillator duty cycle (between 0 and 1). pulse := PulseOsc new freq: 220; duty: (LFOTriPos new freq: 4). dsp := pulse stereo asDsp. dsp init. dsp start.
Listing 2: Configuring UGen parameters 13The latency time refers to the duration required to execute the message setValue:parameter: (which is is an FFI call), to execute. If we run a simple benchmark: [1000 timesRepeat: [dsp setValue: (Random new nextIntegerBetween: 90 and: 900) parameter: ’SquareOscFreq’ ]] timeToRun.
The results show that a single call takes approximately 0.007 milliseconds. At a 192 kHz sample rate, this latency is slightly more than 1 sample, making it efectively instantaneous compared to the rate at which the computer can generate sound. However, it’s important to consider that the latency of calling the function void setParamValueDsp(dsp* dsp_ext, int p, FaustFLOAT val); through the dynamic engine primarily depends on the bufer size and sample rate parameters used in the Phausto audio layer. By default, Phausto initialize its DSPs with a 44100 sample rate and a bufer size of 512 samples. This corresponds to a latency of approximately 11.6 ms, which is below the 20 ms threshold generally considered to be imperceptible or minimally disruptive for human perception, as demonstrated by the Haas efect.
The code in Listing 2 sets the frequency of the Pulse Oscillator to 220 Hz (default frequency is 440 Hz) and assigns the value of the duty cycle to a Low-Frequency Oscillator (LFO) with a Triangular Positive Waveform (LFOTriPos oscillates between 0 and 1).
To modify a parameter of a UnitGenerator in real time, while the DSP is playing, we create a PhHSlider by sending the message init: initialValue to a ByteSymbol. This creates a PhHSlider with the ByteSymbol as a label and the required initial value. Then, we control the parameter on live by sending the message setValue: parameter: to our DSP. lfoFreq := #lfoFreq init: 2. pulse := PulseOsc new freq: 220; duty: (LFOTriPos new freq: lfoFreq ). dsp := pulse asDsp. dsp init. dsp start. "Change the value of a parameter while the sound is playing" dsp setValue: 8 parameter: ’lfoFreq’. ... "Continue using the DSP until the end"
Listing 3: Changing UGen parameters while playing
Listing 3 shows an example of changing the frequency of the LFO from 2 to 8 Hz after the DSP is started.
Once we have started our DSP we can create music compositions using Pharo Processes, Blocks and Delays. synth := (SquareOsc new freq: #SquareNote) * (AREnv new trigger: #SquareGate). dsp := (synth => SatRev new) stereo asDsp. dsp init. dsp start. note := 72. time := 2.
Essentially, the playNote:prefix:dur: the method simulates the action of playing a key on a MIDI keyboard. For this operation, our DSP needs a parameter with the gate sufix to trigger its envelope and a parameter named Note for controlling the frequency. Both parameters must share the same prefix, which is ’Square’ in this example.
Phausto allows Pharo users to use functions and data structures from the Faust programming language
via Foreign Function Interface (FFI) [
To use Phausto, the librariesBundle folder must be downloaded from the GitHub repository and placed next to the current Pharo image14. The libraries bundle includes hundreds of functions for synthesis and processing audio written in Faust (see Section 7).
We create UnitGenerators objects in Phausto using the Faust Box API (described in Section 4.3). It enables writing DSP in Pharo with a dedicated API that hides Faust syntax from the user.
The Box API class provides the connection to over 50 functions that we have considered fundamental for developing the Phausto API. These functions include those to create Faust primitives, composition operators and mathematical expressions. The methods that create or combine boxes return a new Box. If the operation fails, a null pointer is returned.
A DSP object is originally initialised (i.e., connected to the PortAudio layer) and subsequently started, stopped, and at the end of its use destroyed to avoid dangling pointers. All these methods call to the corresponding function defined in the dynamic engine.
Once a DSP is initialised we can check its parameters on a Transcript (traceAllParams) and modify the value of its parameters sending the message setValue: aParameter with a Number or a Box as the first argument and with a String as the second argument.
To use the Faust Box API we create a singleton global compilation context before we create a Box, and destroy this context after the Box has been used to create a DSP. For this reason, the Box class has a shared variable called libContext not initialised when the Pharo image is opened. Every call to the BoxAPI class in Phausto first ensures the creation of the context by calling createLibContextFFI if not exist. At the same time, every time a DSP is created, the compilation context is destroyed by calling BoxAPI unique instance destroyLibContext.
The Phausto Standard Library includes the bindings to functions in the standard Faust library stdFaust.lib 15. They are implemented as subclasses of UnitGenerator and organised in package tags, while the ma.lib (which includes mathematical operations) is ported as methods of the PhBox superclass. 14https://github.com/lucretiomsp/phausto 15https://faustlibraries.grame.fr/
The design of the Phausto API exposes all original arguments as instance variables of the UGen object and default values are set during initialisation16. The setters convert their arguments into a Box, allowing the user to use both, fixed numbers or other boxes ( e.g., other UnitGenerators, or a UIPrimitive to control the variable in real-time).
One specific UnitGenerator is created by sending the asBox message. This method first creates an intermediateBox from a Faust code string without parameters and returns a finalBox from the connection of the instance variables to the intermediateBox. Listing 5 presents the binding between the djembe function in Faust and the Djembe class in Phausto. "djembe function in physmodels.lib" pm.djembe(freq, strikePosition, strikeSharpness, gain, trigger) : _ "Djembe class Phausto" Djembe >>> initialize super initialize. processExpression := ’process = pm.djembe;’. self freq: 440. self strikePosition: 0.5. self strikeSharpness: 0.8. self gain: 0.5.
self trigger: 0.0 Djembe >>> asBox | intermediateBox finalBox | intermediateBox := super asBox.
finalBox := (freq , strikePosition , strikeSharpness , gain , trigger ) connectTo: intermediateBox.
^ finalBox
Listing 5: Pharo Djembe binding
The ToolKit17 tag of the Phausto package includes a set of classes that do not have a corresponding function in the standard Faust library. These classes encompass units for sound generations that combine one or more UnitGenerators.
The ToolKit includes a combination of efects and modulators ( e.g., FIlterEnvelope or FilterLFO), efects and synthesizers with a custom design ( e.g., DelayFeedBack or SamplePlayer) or ‘utilities’ as the Incrementer (that increments its output by an increment value at every step).
One of the primary sources of inspiration for Phausto is Kyma [
Pharo programmers could play sound samples in Pharo since Pharo 9.0 using the Sound package18. 16The default values have been an arbitrary choice, influenced by other programming languages such as ChucK, PureData,
SuperCollider, as well as our direct experience and by empirical audio tests during development.
17The ToolKit name is a homage to the Synthesis ToolKit [
FaustPy20 is a Python wrapper for Faust implemented using CFFI that works with Python 2.7 and 3.2+. It is the only wrapper for a high-level general-purpose programming language supporting objectoriented programming.
In its first year of development, Phausto has become a cross-platform stable library and we have been able to provide bindings to more of the 30% of the Faust Box API. Additionally, 25% of the functions of the Faust standard library has been implemented as classes and tested. In the following months, our focus will be on porting all the functionalities of the Faust programming language. This includes the ability to visualize the DSP block diagram as a .svg file and the possibility to save DSP written in Pharo as a file, which can be exported to diferent target languages, such as CMajor, C++ and WAST 21.
Along with the implementation of all the UnitGenerators, the new ToolKit classes will be designed and implemented to meet the needs of musician and sonic artists. As Phausto expands, more efort will be required to prepare valid tests for all the UnitGenerators, which include an inquiry into how to write valid tests for audio generators.
In addition, we have planned to develop a new package called TurboPhausto is specifically designed to program music on the fly with Coypu. TurboPhausto is inspired by the SuperDirt engine for SuperCollider. It provides a set of ready-to-use synthesizers and efects and an API to easily play a collection of audio samples located in subfolders of a specific folder. We will include a substantial amount of high-quality samples for instant gratification and the option to expand the collection.
Finally, in collaboration with the Evref team, we are working on a live programming development environment. It encompasses a custom Playground and a set of custom UI elements (faders, rotary sliders, buttons, and more) for Phausto made with Toplo22. 10. Conclusion After ten months of development, Phausto is a comprehensive solution for enabling sound synthesis into Pharo applications. Phausto ofers a diverse ToolKit that includes sample players, basic oscillators, envelopes, various physical models, resonant filters, reverbs, and delays. The extensive list of Unit Generators features a streamlined API for parameter manipulation.
Additionally, TurboPhausto’s synthesizers and efects were showcased in a 30-minute live performance titled "Riding the MoofLod" during the ESUG2024 conference at Lille.
We would like to thank Stephane Sletz, Yann Orlarey, Guillermo Polito, Esteban Lorenzano and Pablo Tesone, for their invaluable support, push and assistance throughout the development of Phausto.
We express our gratitude to the organisation of the ESUG for the inspiration and the knowledge we gained during the conferences. In particular, the meetings with the members of the Pharo team and GRAME in Lyon 2023. It was instrumental in the birth of Phausto. 19SimpleDirectMedia is a cross-platform development library designed to provide low-level access to audio, keyboard, mouse and graphics hardware. 20https://github.com/marcecj/Faust_python 21https://webassembly.js.org/docs/contrib-wat-vs-wast.html 22https://github.com/pharo-graphics/Toplo
Special thanks to Carla Scaletti and Kurt J. Hebel at Symbolic Sound Corporation fo their lifelong efort to spread love for Smalltalk and computer music, and to Cristian Vogel for pushing Kyma into the world of electronic dance music.
This work has been supported by the Pharo Consortium.