GSoC 2026
GRAME

GRAME — Project Ideas

View Original

Google Summer of Code possible projects

This page contains a list of possible GSoC projects, with a preliminary section explaining the prerequisites to follow before working on a real project.

Discovering the Faust ecosystem

The application process for GSoC consists of the next steps:

Information Candidates Should Supply

The application process has several steps. First, verify that you meet the GSoC contributor eligibility requirements, i.e. you are at least 18 years old, eligible to work in your country of residence, etc. As of 2023, GSoC eligibility has been expanded to include "open source beginners" in addition to students. The next step is to contact the mentor(s) of the project you are interested in; the best place to do so is in the #gsoc channel of the Faust Discord server, where you can ask questions related to the project you're interested in working on, and submit draft proposals for feedback. Your goal is to convince prospective mentors that you are the right person to get the job done; you can do this by sharing your previous work, demonstrating relevant experience/intuition, asking pertinent questions, etc. Finally, submit a project proposal via your GSoC contributor dashboard. Your submission must include a PDF that should contain the following information:

  • Project:

    • A detailed description of the project that you wish to tackle. Either select a topic from the list below, or, if you wish to work on an idea of your own, we are pretty open as long as this serves the goal of consolidating Faust and its ecosystem as a whole.
    • A proposal of a technical solution with your envisioned methodology. The more detailed the better.
    • A realistic schedule with objectives (one every two weeks for example) and deadlines. Focus on mid-term objectives as well as on the final evaluation.

  • Personal data:

    • First name, last name, affiliation and geographical location.
    • A brief list of the main studies and programming courses attended, with ranking.
    • List of the most important software projects contributed and success.
    • Which are your best skills in terms of programming ?
    • In general what is your taste in terms of programming? language, methodology, team work, etc.
    • Is there anything that prevents you from working full time on the project during the program period?
    • How do you see your involvement after the program ends? Do you see yourself pushing the project further, or do you see yourself contributing to other Faust and its ecosystem projects?
    • Are you more interested in the Faust language and its ecosystem, or do you feel more like a hacker?
    • What are your long-term wishes in terms of job?

Use of LLM (ChatGPT, Mistral AI, etc.)

Usage of LLM must be done responsibly. Improper use can undermine trust—and trust is the foundation of any successful collaboration.

We agree with this section of Rust GSoC site: We would appreciate if you used your own words when writing GSoC project proposals. It is fine to use LLMs/AI for spellcheck, language correction or translation, but do not rely on AI to write the proposal for you. We will ignore proposals that look like they were generated by AI. Please don't submit AI-generated proposals! They won't be accepted, and will just create additional work for us. We're interested in seeing your work and your thinking, since you are applying to do the project — not the AI!.

Or read the University of Alaska Anchorage Acceptable and Ethical AI Use Policy.

Possible projects:

https://github.com/grame-cncm/faustideas/blob/master/GSOC.md#integrated-faust-language-server-and-formatting-extension-for-vs-code-taken-in-2025

Some more ideas could possibly be turned as GSoC projects.

Web-Based UI System for Faust (Inspired by Cmajor Patch GUIs)

Mentor: To be confirmed

Expected size of project: 175 hours

Description:
Faust provides several automatic UI generation backends, but it currently lacks a modern, fully web-based patch UI system comparable to the Cmajor patch GUI model. This project proposes the design and implementation of a standardized Web UI layer for Faust, enabling DSP modules to expose rich, interactive graphical interfaces directly in the browser.

Inspired by the Cmajor patch format, the project will define a Faust Web UI specification, along with a reference implementation. The system will rely on standard Web technologies (HTML, CSS, JavaScript) and provide real-time parameter control via WebAudio.

  • Define a Faust Web UI specification:
    Based on Faust JSON format and inspired by Cmajor’s patch GUI format.

  • Implement the Web UI backend:
    Generate parameter bindings and Web UI templates from Faust DSP code.

  • Real-time DSP/UI communication:
    Using WebAudio AudioWorklet and WebAssembly.

  • Integration and demos:
    Compatibility with Faust PWAs and online demo instruments/effects.

Expected outcomes:

  • A new Faust Web UI architecture.
  • A standardized parameter binding and messaging format.
  • A set of documented Web-based Faust demo applications.

Skills required: JavaScript/TypeScript, HTML/CSS, WebAudio API, Faust.

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

Integrated Faust Language Server and Formatting Extension for VS Code [Taken in 2025]

Mentor: Stéphane Letz

Expected size of project: 175 hours

Description: A language server, sometimes called an LSP, is a code analysis tool that allows programming environments to get information about projects. This lets them display information like code completions, inline errors, locations of function definitions, reference official documentation, and more. Many programming languages have their own language server (see https://langserver.org/ for a list), but Faust does not. If there was a Faust language server, it would make it easier to write Faust code using any IDE that supports LSP. This would make it easier for beginners to get started writing Faust using programming tools they're already familiar with, and it would make it easier for experts to navigate large codebases. The tree-sitter-faust project could be helpful in doing any parsing required for a language server.

We propose to create a Visual Studio Code extension that integrates the Faust Language Server with a dedicated Faust code formatter. Leveraging the vscode-languageclient package, the extension will launch the Faust Language Server to provide robust features (code completion, diagnostics, navigation) while also offering context-aware formatting tailored to Faust DSP syntax.

  • Integrate the Faust Language Server:
    Use vscode-languageclient to launch and manage the server, ensuring features like auto-completion and error checking are available for .dsp files.

  • Develop a Faust Code Formatter:
    Implement a formatter that understands Faust’s constructs, providing commands and auto-format-on-save functionality to improve readability and enforce best practices.

Expected outcomes:

  • A fully functional VS Code extension that combines the Faust Language Server with a dedicated code formatter.
  • Enhanced developer productivity through improved code intelligence and formatting.
  • Comprehensive documentation and user-friendly configuration options, making it easier for the Faust community to adopt best practices.

Skills required: Faust programming, TypeScript and Web programming.

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

Extending the Faust DSP Testbench

Mentor: Stéphane Letz

Expected size of project: 175 hours

Description: The Faust DSP Testbench, a fork of the DSP-Testbench project, is designed to help developers using the JUCE framework to analyse their Faust DSP. This project will focus on extending the Testbench’s functionality to make it a more comprehensive and user-friendly tool for developers and researchers working with Faust.

The proposed extensions aim to:

  • Extend and improve the visualisation tools.
  • Enable better visualization of DSP performance and behavior.

Expected outcomes:

  • A robust, user-friendly Faust DSP Testbench with automated testing, benchmarking, and visualization capabilities.
  • Comprehensive documentation and tutorials for using the Testbench effectively.

Skills required: Faust programming, DSP theory, C++, knowledge of the JUCE framework.

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

Backend for MOJO [Will be taken in 2026]

Mentors: Stéphane Letz and Yann Orlarey

Expected size of project: 175 hours

Mojo is a new programming language that bridges the gap between research and production by combining the best of Python syntax with systems programming and metaprogramming. Mojo combines the usability of Python with the performance of C, unlocking unparalleled programmability of AI hardware and extensibility of AI models. With Mojo, you can write portable code that’s faster than C and seamlessly inter-op with the Python ecosystem. Having autodifferentiation inside the language is not yet ready but is regularly discussed on Mojo Discord.

The primary objective of the project is to develop a backend for this new language, add architecture files, and measure how the generated code behaves doing various benchmarks.

Expected outcomes:

  • a new backend to generate MOJO code
  • development of MOJO architecture files to create benchmarks and measure the speed of the generated code

Skills required/preferred: C++ and basic Python programming, Faust programming

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

Differentiable DSP in Faust [Taken in 2024]

Mentors: Thomas Rushton, David Braun, Stéphane Letz, and Yann Orlarey

Expected size of project: 175 hours

Differentiable programming is a technique whereby a program can be differentiated with respect to its inputs, permitting the computation of the sensitivity of the program's outputs to changes in its inputs.

Partial derivatives of a program can be found analytically via automatic differentiation and, coupled with an appropriate loss function, used to perform gradient descent. Differentiable programming has consequently become a key tool in solving machine learning problems.

Differentiable digital signal processing (DDSP) is the specific application of differentiable programming to audio tasks. DDSP has emerged as a key component in machine learning approaches to problems such as source separation, timbre transfer, parameter estimation, etc. DDSP is reliant on a programming language with a supporting framework for automatic differentiation. In Python, this is provided by libraries such as TensorFlow and JAX; other languages, Swift for example, may feature native support.

We would like to explore the possibility of implementing automatic differentiation in Faust; the successful implementation of a Faust library for differentiable programming would permit the application of Faust to DDSP problems. Exploratory work on such a library has begun; one aim is to turn this into a comprehensive package of support for differentiable Faust programs.

Related work, concerned with adding automatic differentiation capabilities to the Faust compiler, was conducted for a previous edition of GSoC. Also consult David Braun's DawDreamer project, which uses Faust's JAX backend.

Expected outcomes:

  • creation of an automatic differentiation library describing derivatives for all of Faust's operators, helper functions for generalising the creation of differentiable Faust programs, a variety of time- and frequency-domain loss functions, etc.;
  • development of a series of practical applications of the new library;
  • a new autodiff (or machine learning) architecture file, to support the training of machine learning models and the generation of parameter weights;
  • a means to use the generated weights for real-time inference.

Skills required/preferred: Faust programming, machine learning

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

Support for CLAP format [Taken in 2025]

Mentor: Stéphane Letz

Expected size of project: 175 hours

CLAP is an Audio Plugin format (as pure C api), liberally licensed (MIT), entirely developers in the open (GitHub), with support from commercial developers (u-he, Bitwig, more). CLAP has many design goals, but a primary one was to allow developers to build their base plugin layer using a properly open clean C standard, to replace the VST2 API which most folks base their plugin model on, and then project into other systems. An extensive discussion can be accessed here.

The project is to develop:

Look at additional CLAP projects.

Expected outcomes: The result will be a faust2clap script to compile a DSP program in a CLAP plugin, and a CLAP pluging embedding libfaust.

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

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

Integration in Surge

Mentor: Stéphane Letz

Expected size of project: 175 hours

The Surge Synth Team is a group of musicians, developers, testers, documenters, and general volunteer open source enthusiasts who randomly assembled to work on the Surge Synthesizer. Use the Discord channel to connect to their community.

The project is to develop a faust2surge tool (see faust2xx Tools and Developing a faust2xx Script) to statically compile Faust DSP code in a Surge plugin. This is currently discussed here. You'll probably have to develop or adapt C++ architecture files.

Expected outcomes: The result will be a faust2surge script to compile a DSP program in a Surge plugin.

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

Integration in Bespoke

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. Use the Discord channel to connect to their community. The integration could follow the two steps:

This is currently discussed here. You'll probably have to develop or adapt C++ architecture files. A recent Faust integration in TouchDesigner can be studied as an example.

Expected outcomes: The result will be:

  • afaust2bespoke tool to compile Faust DSP code in Bespoke modules

  • a Bespoke plugin embedding the libfaust + LLVM 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 to hard

References:

Integration in Godot [Taken as an internship in 2025]

Mentor: Stéphane Letz

Expected size of project: 175 hours

More detailed description of the project: Godot Engine is a feature-packed, cross-platform game engine to create 2D and 3D games from a unified interface. It provides a comprehensive set of common tools, so that users can focus on making games without having to reinvent the wheel. The integration could follow the two steps:

You'll probably have to develop or adapt C++ architecture files. A recent Faust integration in TouchDesigner can be studied as an example.

Expected outcomes: The result will be:

  • afaust2godot tool to compile Faust DSP code in Godot modules

  • a Godot plugin embedding the libfaust + LLVM library, and allowing DSP programs to be edited, dynamically compiled, and run in the platform

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

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

Integration in Cables.gl [Taken in 2024]

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. Use the Discord channel to connect to their community.

The project would be to integrate the Faust Web Audio Library to dynamically compile and run Faust DSP programs in Cables.gl.

Expected outcomes: The result will be a Cable.gl plugin embedding the libfaust WASM library, and allowing DSP programs to be edited, dynamically compiled, and controlled with an adapted Graphical User Interface.

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

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

PluginGuiMagic architecture

Mentor: Stéphane Letz and Daniel Walz

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 spectral with no extra coding involved. The project is to develop new C++ architecture files to ease the use of PGM in the faust2juce tool. Another faust_juce_pgm_skeleton project to look at.

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

VST plugin embedding the dynamic compiler [Taken in 2024]

Mentor: Stéphane Letz

Expected size of project: 175 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

Integration in Audiokinetic Wwise [Taken in 2025]

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 integration could follow the two steps:

Look at the faust2wwise preliminary work. You'll probably have to develop or adapt C++ architecture files.

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 architecture.

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

Integration in BELA

Mentor: Stéphane Letz

Expected size of project: 175 hours

More detailed description of the project: BELA is a maker platform for creating beautiful interaction. Designed for artists, musicians, researchers and makers, Bela brings the power of ultra-low latency interactive audio and sensors to your digital projects. A Faust/BELA integration has already been done in a faust2bela tool and some preliminary work on the dynamic compilation chain have been done.

Expected outcomes: The result will be:

  • an improved faust2bela tool

  • a fully integrated Faust/BELA IDE that would allow to design and experiment Faust code in the Web plaform (using the dynamic WebAssembly based compilation chain), then compile it in C++ and deploy it on the BELA board. Monophonic DSP and MIDI controllable polyphonic instruments should be supported.

  • a finished dynamic compilation chain integration.

Integration in openFramework

Mentor: Stéphane Letz

Expected size of project: 175 hours

More detailed description of the project: openFrameworks is an open source C++ toolkit designed to assist the creative process by providing a simple and intuitive framework for experimentation. It allows to access a lot of additional extensions and libraries in the form of addons. The project is to explore how Faust can be integated in the framework as an ofxFaust addon, either statically (using the C++ generated code from a DSP program), or possibly embedding the libfaust compiler. Adapted architecture files will have to be developed.

Expected outcomes: The result will be a new ofxFaust and openFrameworks demo examples explaining how to use it.

Integration in the Heavy Compiler Collection

Mentor: Alexander Chalikiopoulos

Expected size of project: 175 hours

More detailed description of the project: HVCC is a python-based dataflow audio programming language compiler that generates C/C++ code and a variety of specific framework wrappers. It's main focus is in parsing Pure Data DSP patch files, statically interprets them, and converts them to C/C++. The project is to explore how Faust can be integrated into the compiler toolchain. Likely starting from pd-faustgen external and then internally calling faustdoctor to wrap the resulting C into separate header and implementation files. A crude proof of concept integration between faust generated code and a heavy DSP graph was done to explore the feasibility of this integration.

Expected outcomes: The result will be:

  • extending hvcc compiler steps pd2hv, hv2ir and ir2c
  • jinja2 templates that create Heavy compatible C header and implementation files, based on Faust code
  • successfully create DSP prototypes using PD and Faust that can be compiled to C/C++ projects based on Heavy

Skills required/preferred: Python, C, Pure Data, audio and Faust programming.

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

Packaging system for Faust libraries [Taken in 2024]

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.

Requirements

  • 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 (starting 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

Syntax proposal

Simple version

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

Version with constraint on version number

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

package("foo").bar

or else:

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

Tools to describe packages

  • 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

Faust programming by examples

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

Languages built on top of the signal API

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

Developing modular synthesis using widget modulation

Mentors: Yann Orlarey and Stéphane Letz

Widget modulation acts on the widgets of an existing Faust expression, but without requiring any manual modifications of the expression's code. This operation is done directly by the compiler, according to a list of target widgets and associated modulators. Target widgets are specified by their label, as used in the graphical user interface. Modulators are Faust expressions that describe how to transform the signal produced by widgets.

The project would be to develop a set of modular synthesizers, typically by choosing and adapting existing functions in the Faust Libraries, each of them with a pretty GUI, to be combined in a patch like model. The widget modulation syntax will be used to prepare the widgets to be modulable. The implementation will be done using web technologies, and in particular FaustWasm, a high-level API that wraps around Faust compiler. Here is a list of possible steps:

  • choose and adapt existing functions in the Faust Libraries and add a pretty GUI with User Interface Primitives to create modules including oscillators (which generate sound), filters (which modify sound by frequency), amplifiers (which control the volume), and modulators (like LFOs and envelopes, which affect other parameters over time)

  • create sequencing modules, vital for composition in modular synthesis. It allows users to create a series of notes (a sequence) that can be sent to an oscillator to produce rhythmic patterns or melodies

  • define a library of modulation circuits, using the lowest/highest primitives of the language, and define adapted signal mappings

  • create a global GUI to rack all used modules as in VCV Rack, using Web technologies, and develop the connection logic needed between all considered modules, compiled and connected as separated Faust Web Audio nodes

Expected size of project: 350 hours

Expected outcomes: The project aims in developing new libraries for modular synthesis and a prototype Web application.

Skills required/preferred: Faust programming, Web programming

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

Past GSoC editions

2024: FaustNet - DDSP, Faust in Cables.gl, Amati++, a VST/CLAP Plugin embedding the dynamic compiler and Faust Package Manager

  • FaustNet - DDSP aimed to continue the work done on adding automatic differentiation in Faust (started in a GSOC 2023 project), to leverage machine learning for audio processing tasks directly within the familiar Faust environment. It was worked on by Advik Raj Basani and contributed as a Pull Request on Thomas Rushton faust-ddsp library.

  • Faust in Cables.gl aimed to develop a Cables.gl plugin that compiles Faust DSP code into a WASM AudioWorklet in real-time. It was worked on by Fay Carsons and contributed as a separated Faust Cables plugin project.

  • Amati++, a VST/CLAP Plugin embedding the dynamic compiler, inspired by the pMix and Amati projects, this plugin has been built using the JUCE framework for the interface and libfaust with LLVM and interpreter backend API to compile Faust code. It was worked on by Tyler Li and is still a work-in-progress.

  • Faust Package Manager aimed to add a packaging system to facilitate the integration of Faust libraries in a DSP project. It was worked on by Shehab Khaled Roshdy and a was contributed as a Pull Request that is still in test in a master-dev-pacman branch.

2023: Automatic Differentiation in the Faust Compiler and Better Faust on the Web

  • Automatic Differentiation in the Faust Compiler aimed at adding Automatic differentiation directly in the compiler, so that gradient calculation can be carried out natively in Faust, with applications in Machine Learning algorithms. The project was worked by Thomas Rushton and completed with this Pull Request, and finally integrated in the Faust master-branch.

  • Better Faust on the Web aimed at enhancing Faust’s support for the web platform, and was worked on by Ian Clester. Transitioning the Faust web tools to a rewritten TypeScript version has been completed and deployed in updated versions of the Faust editor and Faust playground and soon in the Faust Web IDE with this Pull Request. A Faust web component embedding the libfaust JS/WebAssembly compiler has been developed and will be used soon in the Faust documentation. The development is fully detailed in this blog post.

2022: Integration in HISE

Faust Integration in HISE aimed at integrating support for the Faust audio programming language into HISE, an extensive framework for the creation of sample-based virtual musical instruments. The project has been completed by Roman Sommer with the help of Christoph Hart as mentor, and announced here.

Command Palette

Search for a command to run...