The application process for GSoC consists of the next steps:

• become acquainted with the Faust language and ecosystem
• join to Faust Slack channel or #faust channel on The Audio Programmer discord or the Faust Mailing Lists
• search mentor for chosen project in mailing list discussions
• get invite to chosen project in Faust github organization
• submit the application/proposal including all requirements at the Google Summer of Code Site

• Integration in Bespoke
• Integration in HISE
• Integration in Cables.jl
• PluginGuiMagic architecture
• VST plugin embedding the dynamic compiler
• Integration in Audiokinetic Wwise
• Packaging system for Faust libraries
• Faust programming by examples
• Alternative languages built on top of the signal API

Mentor: Stéphane Letz

Expected size of project: 175 hours

More detailed description of the project: Bespoke is a modular DAW for Mac, Windows, and Linux. It contains a bunch of modules, which you can connect together to create sounds. Benedict Gaster work uses WebAssembly as the compilation target language, and has already done the Bespoke Synth integration. So possibly this work could be checked and directly merged. A more ambitious approach would be to directly embed the Faust compiler (using the libfaust + LLVM JIT way) with would even produce faster code. This is currently discussed here. A recent Faust integration in TouchDesigner can be studied as an example.

Expected outcomes: the result will a Bespoke plugin embedding the libfaust library and allowing DSP programs to be edited, dynamically compiled, and run in the platform.

Skills required/preferred: C++ programming, graphical programming, audio and Faust programming

An easy, medium or hard difficulty rating of each project: medium

Mentor: Stéphane Letz

Expected size of project: 175 hours

More detailed description of the project: HISE is a cross-platform open source audio application for building virtual instruments. It emphasizes on sampling, but includes some basic synthesis features for making hybrid instruments as well as audio effects. You can export the instruments as VST/AU/AAX plugins or as standalone application for Windows / macOS or iOS.

The project would be to integrate the Faust compiler (using the libfaust + LLVM JIT way) into HISE for live editing and then used to generate C++ at compile time. This would allow for much more complex effects development without need to delve into C++ DSP. This is currently discussed here. A recent Faust integration in TouchDesigner can be studied as an example.

Expected outcomes: the result will be a HISE plugin embedding the libfaust WASM library, and allowing DSP programs to be edited, dynamically compiled, and run in the platform.

Skills required/preferred: C++ programming, audio and Faust programming, knowledge of the JUCE framework

An easy, medium or hard difficulty rating of each project: medium

Mentor: Stéphane Letz

Expected size of project: 175 hours

More detailed description of the project: Cables.gl is a tool for creating beautiful interactive content. With an easy to navigate interface and real time visuals, it allows for rapid prototyping and fast adjustments. You are provided with a set of operators, such as mathematical functions, shapes, materials and post processing effects. Connect these to each other with virtual cables to create the experience you have in mind. Easily export your piece of work at any time. Embed it into your website or use it for any kind of creative installation.

The project would be to integrate the Faust Web Audio Library to dynamically compile and run Faust DSP programs in Cables.jl. A recent Faust integration in TouchDesigner can be studied as an example.

Expected outcomes: the result will be a Cable.ji plugin embedding the libfaust WASM library, and allowing DSP programs to be edited, dynamically compiled, and run in the platform.

Skills required/preferred: TypeScript/JavaScript programming, Web technologies, audio and Faust programming

An easy, medium or hard difficulty rating of each project: medium

Mentor: Stéphane Letz

Expected size of project: 175 hours

More detailed description of the project: PluginGuiMagic is a WYSWYG runtime design system for JUCE plugins. The foleys_plugin_magic module allows to have a generated UI, that can be edited at runtime using advanced layout and styling options. It also adds visualisers to display signals, levels and spectra with no extra coding involved. The project is to develop new C++ architecture files to ease the use of PGM in the faust2juce tool.

Expected outcomes: the result will be set of C++ architecture files and an improved faust2juce tool.

Skills required/preferred: C++ programming, knowledge of the JUCE framework, knowledge of the foleys_plugin_magic module, audio and Faust programming

An easy, medium or hard difficulty rating of each project: medium

Mentor: Stéphane Letz

Expected size of project: 175 possibly 350 hours

More detailed description of the project: A VST plugin using the libfaust + LLVM JIT to do DSP live coding in any VST aware host. FX and monophonic or polyphonic synthesizers can be written. The source code can be edited and recompiled on the fly. The GUI has to be automatically created. The pMix and Amati projects can be used as starting points. An integration with the PluginGuiMagic architecture could possibly be added.

Expected outcomes: the result will be a VST plugin developed with the JUCE framework

Skills required/preferred: C++ programming, audio and Faust programming, knowledge of the JUCE framework

An easy, medium or hard difficulty rating of each project: medium

Mentor: Stéphane Letz

Expected size of project: 350 hours

More detailed description of the project: Audiokinetic is the leading global provider of the most advanced and scalable cross platform interactive audio solutions. A trusted technology partner to the world’s largest developers, OEMs, and audio production companies, its flagship product Wwise is the gold standard interactive audio engine on the market. Wwise features a complete suite of design and development tools, making it easy to prototype and bring to life your creative vision for audio, no matter the scale of your project. The project is to integrate Faust in the Wwise architecture, both as a static faust2wwise tool as well as an integration of the libfaust + LLVM JIT dynamic compiler technology in a plugin

Expected outcomes: the result will be:

• a new faust2wwise tool with the associated C++ architecture files to compile a DSP project in a ready to use Wwise plugin
• a plugin embedding the libfaust + LLVM JIT dynamic compiler technology to allow Faust DSP live-coding

Skills required/preferred: C++ programming, audio and Faust programming, knowledge of the Audiokinetic Wwise archiecture

An easy, medium or hard difficulty rating of each project: hard

Mentors: Yann Orlarey and Stéphane Letz

Expected size of project: 350 hours

More detailed description of the project: The idea is to develop a packaging system to facilitate the integration of Faust libraries in a DSP project. The inspiration comes from the Julia language with the JuliaHub project and/or the Rust language with the Cargo package manager.

• load packages containing Faust sources, either in .dsp or in .lib format
• be able to load sets of files (typically a library that is written as several .lib files)
• isolate packages in different environments, to avoid name conflicts
• notion of a centralized directory on GitHub, where contributions can be made in the form of Pull Requests. Publishing tool (with search by content) of this directory, general, like fausthub (inspired for example by Juliahub https://juliahub.com/lp/).
• at each PR, test of the syntax of the code with GitHub actions
• cache management: typically 1) the package is loaded the 1st time and kept in a cache, 2) then the compiler uses the version in the cache. Work on the question of new version management.
• automatic generation of the documentation from the lib files (stating from the existing tools and possibly adapting them), automatic deployment
• preservation semantic: we want to be able to keep a project as a DSP file with all its needed libraries with specific version numbers

package("foo") ⇒ syntactic sugar for library("https://faustpackages.grame.fr, "path/to/actual/librarie.lib")

package("foo", "3.4") ⇒ syntactic sugar for library("https://faustpackages.grame.fr, "path/to/actual/3.4/librarie.lib")

package("foo").bar

or else:

foo = package("foo") and foo.bar in the DSP code

• look at the package format of Rust or Julia: .toml file, src folders, tests
• look at the TOML format (https://toml.io/en/), used by Rust and Julia

Expected outcomes:

• a working insfrastructure with a server hosting the published packages
• an extended Faust compiler able to access the server

Skills required/preferred: C++ programming, server/client technology

An easy, medium or hard difficulty rating of each project: hard

Mentors: Yann Orlarey and Stéphane Letz

Expected size of project: 350 hours

More detailed description of the project: The objective is to develop a new approach to Faust programming, not textual or graphical, but based on DAW-like examples. This programming principle is analogue to the one described in the article Real time Composition in Elody. This approach is based on the idea of manipulating and editing virtual "audio files" which represent the real time audio inputs and outputs.

To take a simple monophonic example, let's call these two virtual audio files INPUT and OUTPUT. Let's note t:file the fact of placing in the DAW a file fileat time t in seconds and t:file*0.75 the fact of placing in the DAW a file at time t but also controlling its sound level. So the DAW construction {0:INPUT, 1:OUTPUT*0.75} corresponds to a realtime echo whose Faust translation is process = + ~ (@(ma.SR):*(0.75));.

Expected outcomes: the project consists in exploring this model and see how standard DAW editing actions can be translated in Faust DSP programs. A prototype coded in TypeScript, JavaScript or any other scripting languages will be developed.

Skills required/preferred: C++ programming, possibly TypeScript + JavaScript or other scripting languages.

An easy, medium or hard difficulty rating of each project: hard

Mentors: Yann Orlarey and Stéphane Letz

Expected size of project: 350 hours

More detailed description of the project: The signal API opens an intermediate access inside the Faust compilation chain. Generating complex expressions by directly using it can quickly become really tricky and unpracticable. So a language created on top of the signal API is usually needed. This is exactly what the Block Diagram Algebra is all about, and the entire Faust language itself.

But some other approaches can possibly be tested. The Elementary audio language for instance is built over a similar signal language and uses JavaScript as the upper layer language to help create complex signal graphs programmatically.

Expected outcomes: the project consits in exploring various approaches to build a language on top of the signal API. It could be a textual one (like JavaScript, Haskell or scripting languages...) or a purely graphical tool.

Skills required/preferred: C++ programming, possibly TypeScript + JavaScript, Haskell or other functional languages.

An easy, medium or hard difficulty rating of each project: hard

This repository hosts the "TODO/ideas list" for the Faust programming language.

• Items are placed at the bottom of the file and separated by ---.
• Items can have a person associated to them by declaring * Currently addressed by: xxx. If no-one is currently working on the item, replace xxx by nil.
• Items are ordered by priority and are also listed in the List section below.
• Items can be commented by adding subsections, pictures, etc.

• Implement Jonathan Abel's Modal Reverb
• Improved UI Declarations
• TensorFlow Support
• Improved Linear Algebra Support
• Finish the DX7 Implementation
• Trigonometric simplifications
• WebAssembly specific optimisations
• Improve faust2audiokit
• Testing tools on the Web

• Currently addressed by: Romain and Yann

This should be done as part of the Longyou grottoes project. The "final goal" would be to create an interactive website where users can process the sound of their microphone to apply the acoustics of this ancient space. Modal reverb would allow to interpolate between IRs and change some of the parameters of the space in real-time. It'd be nice if this could be reproducible so we need to think about a way to nicely generate these reverbs from an impulse response. This tool could be similar to mesh2faust or could come as part of a toolkit in matlab/octave/pyhton, etc.

• Currently addressed by: Romain and Yann

Essentially allow for specific UI elements to have metadatas associated to them outside of their declaration. As part of that, we want to implement a system to further customize UI elements.

Several approaches are being considered to further customize UI elements. The first one would consist of being able to declare a "CSS" allowing for the use of CSS code. Another approach (more generic and not limited to the web) would allow for the declaration of UI-specific metadata inspired by CSS.

declare UI "
  synth{
    background-color: blue;
  }
  synth/freq{
    tooltip: Frequency parameter of the synth;
    width: 70%;
  }
  synth/gain{
    style: knob;
    tooltip: Gain parameter of the synth;
    width: 70%;
  }
";

f = hslider("freq",400,50,1000,0.1);
g = hslider("gain",0.5,0,1,0.01);
process = hgroup("synth",os.sawtooth(f)*g);

Of course, it would still be possible to declare metadatas within the UI declaration (this system would be fully backward compatible). Internally, we'd have to parse the metadata and create a corpus of supported CSS metadatas knowing that interfaces would be based on a specific kind of layout (e.g., grid layout). Once again, another option would be to allow to specify "pure CSS" giving access to all the CSS features without having to do some reformatting.

• Currently addressed by: nil

Be able to generate TensorFlow code with Faust.

• Currently addressed by: nil

Linear algebra operations are currently poorly supported in Faust. Having a way to conveniently express matrices would improvement. As part of that, linear algebra/matrix operations (e.g., inversion, multiplication, determinant, etc.) primitives could be added to the language.

Matrices could be expressed using the Faust-multirate vectorize primitives by creating vectors of vectors.

It would be interesting to try to implement matrix operations from scratch in Faust. Although it might be hard and not so optimized, thus a more pragmatic solution would be to implement them as primitives. That would be a fair amount of work as this would imply that the corresponding code for each language supported by Faust would have to be supported.

• Currently addressed by: nil

Essentially, finish dx7.lib. It might be worth looking at these elements to make this happen:

• https://webaudiomodules.org/demos/wasm/dx7.html
• https://github.com/everythingwillbetakenaway/DX7-Supercollider

• Currently addressed by: nil (suggested by Pierre Leconte)

For some applications, trigonometric functions (spherical harmonics) are used, and depending on the algorithm, the output formula could be very complicated. However, in a lot of cases, trigonometric identities could help to simplify drastically the expressions.

• Currently addressed by: Stéphane and Yann

To run as fast as possible and approch native code performances as much as possible, WebAssembly code requires some specific optimisations, like: memory access (index precomputation as much as possible...), delay lines handling, struct/stack variables access...etc. We have started an informal collaboration with Mozilla engineers (Benjamin Bouvier) to work on this subject.

• Currently addressed by: nil

The faust2audiokit tool transforms a Faust DSP program into a fully working AudioKit node. The result can be a monophonic DSP or a MIDI controllable polyphonic one (when the DSP describes an instrument, following the freq, gain, gate parameter naming convention).

The project consist in improving and finishing the tool.

• Currently addressed by: nil

Faust distribution already contains some testing tools, like faust2plot or faust2octave.etc. It would be great to have them running in a Web page (or some extension of the same idea). For signal generators/processors, several output formats (oscilloscope, spectrogramme...), and for processors several calibrated input signals (dirac impulse, ramp, sinusoide..) would be available.