Gen~ vs FAUST for Hardware Audio DSP

When Your Effects Need to Run on Real Hardware

Most audio effects start life as software plugins running on a laptop. But what happens when you want that same sound processing to run on a guitar pedal, a Eurorack module, or a standalone box like Dubby? The audio code needs to be compiled down to something a small processor can run in real time - usually C or C++.

Writing raw C++ DSP from scratch is powerful but slow and error-prone. Several higher-level tools have emerged over the years - Csound, SuperCollider, Pure Data, and others - but two in particular stand out for their ability to compile directly to efficient, embeddable C++ code. Gen~, from Cycling '74's Max/MSP, takes a visual approach - you connect oscillators, filters, and math blocks with virtual patch cables, and Gen~ compiles that into C++. FAUST (Functional Audio Stream), developed at GRAME in Lyon, takes a text-based approach - you write concise functional code that describes the signal flow, and the FAUST compiler turns it into optimized C++.

Both produce high-performance code that can run on embedded hardware. But they reflect very different ideas about how musicians and developers should think about sound processing. Here's how they compare.

What is FAUST?

FAUST is an open-source, functional programming language designed specifically for real-time audio signal processing. Born in academia at GRAME (Centre National de Création Musicale) in 2002, it takes a radically different approach from visual patching: you write concise, mathematical expressions that describe audio transformations, and the FAUST compiler generates optimized C++, WebAssembly, Rust, or even LLVM IR.

A simple FAUST program might look like: process = _ : *(0.5); - that's a complete mono volume control. The language's composition operators (: for series,, for parallel, ~ for feedback) let you build complex signal graphs from simple building blocks.

FAUST powers DSP in projects like Elk Audio OS, MOD Devices, and the Web Audio Modules ecosystem. It's deeply respected in the academic and research audio communities.

Gen~ vs FAUST: Side-by-Side

Where Each Shines

Gen~ excels when you want to prototype quickly and hear results immediately. The visual workflow means you can literally see signal flow - patch an oscillator into a delay, tweak feedback with a slider, and hear the result in real time. For musicians and sound designers who think spatially rather than syntactically, this is powerful. The massive Max/MSP community also means decades of shared patches, tutorials, and forum knowledge.

FAUST shines when you need mathematical precision, cross-platform deployment, or when your DSP is complex enough that text becomes clearer than patch cables. A 200-line FAUST program might produce a patch with hundreds of visual connections in Gen~. FAUST's compiler also performs aggressive optimizations - automatic vectorization, parallelization - that can produce remarkably efficient code. And because it's open-source, there are no licensing concerns about deploying FAUST-generated code commercially.

Why Dubby Chose Gen~

When we designed Dubby, we wanted the algorithm creation process to be accessible to the widest possible audience. Not everyone writes code, but many musicians already use or are curious about Max/MSP. Gen~'s visual patching lowers the barrier: you can build a functioning delay or reverb algorithm without writing a single line of text.

Our Dubby Max Patcher takes this further - it handles compilation, metadata packaging, and flashing directly from within Max. One click to go from visual patch to running hardware effect. This workflow simply doesn't exist in the FAUST ecosystem yet, where deployment to custom hardware typically requires more manual integration work.

The Max/MSP community also matters. Thousands of musicians share Gen~ patches, tutorials, and techniques. When someone gets stuck building a Dubby algorithm, they can tap into decades of collective knowledge - on the Cycling '74 forums, on YouTube, and in our Discord community.

Could Dubby Run FAUST?

Technically? Yes. Both Gen~ and FAUST export C++ code, and Dubby's algorithm format is open and documented. The libDubby API already supports writing algorithms in plain C++ - so FAUST-generated code could theoretically be adapted to target Dubby's architecture.

This is the beauty of an open platform: the door is never closed. If the community shows strong interest in FAUST support, it's something we can explore. The public roadmap is where decisions like this get shaped - by the people who actually use the hardware.

What About Pure Data?

There's a third path worth mentioning: Pure Data and plugdata. Pure Data is Miller Puckette's free, open-source sibling to Max/MSP, and plugdata gives it a modern interface. Combined with the Heavy compiler (hvcc), Pure Data patches can also be compiled to embeddable C++ - and we're actively working on bringing Heavy support to Dubby. This would open up algorithm development to anyone, using entirely free and open-source tools.

The Bottom Line

Gen~ and FAUST aren't competitors so much as they are different tools for different thinkers. Gen~ is for visual, intuitive, "I want to hear it now" workflows. FAUST is for precise, mathematical, "I want to prove it correct" approaches. Both produce professional-grade DSP code that runs on embedded hardware.

For Dubby, Gen~ was the right starting point - it matches our philosophy of making powerful tools accessible. But we respect FAUST deeply, and the fact that both languages export to C++ means the future is wide open.

Ready to try Gen~ for yourself? Check out our getting started guide or dive deeper into how Dubby uses Gen~, or browse the patch library on Dubby.Studio.