Ever wanted to create your own custom guitar effects? Not just tweak existing pedals, but build something entirely original — your own distortion character, your own modulation algorithm, your own signature sound? With Nimbus and the FAUST programming language, that's not just possible — it's surprisingly accessible, even if you've never written audio code before.
This guide will walk you through building your first plugin for the Nimbus platform using FAUST. By the end, you'll have created a working audio effect from scratch, tested it in your browser, and understand how to deploy it to your Nimbus and eventually publish it on Tone Shop.
Let's build something.
What Is FAUST?
FAUST (Functional Audio Stream) is a programming language specifically designed for audio signal processing. Created by GRAME, a French research center for music, FAUST takes a different approach than traditional programming: instead of telling the computer how to process audio step-by-step, you describe what the audio signal should become.
This makes FAUST incredibly powerful for guitarists and audio engineers because:
- The code reads like a signal flow diagram — if you can draw a signal chain, you can write FAUST
- It's built for real-time audio — automatic optimization for low-latency processing
- Cross-platform by design — write once, compile for Nimbus, VST, AU, and more
- Built-in testing tools — hear your effect in your browser before deploying
- Chaos Audio officially supports it — the Nimbus and Stratus platforms have integrated FAUST support
Whether you're a complete programming beginner or an experienced developer, FAUST meets you where you are. Simple effects can be written in just a few lines, while complex plugins can utilize advanced DSP techniques.
What You'll Need
Before we start coding, make sure you have:
- A web browser — Chrome, Firefox, or Safari all work great
- The Faust IDE — faustide.grame.fr (no installation required!)
- A Nimbus — for testing your finished effect on real hardware
- The Chaos Audio mobile app — for deploying and testing
That's it. No complicated development environment setup, no command-line tools to install. The web-based FAUST IDE has everything you need to write, test, and compile audio effects.
Understanding FAUST Basics
Before we build our first effect, let's understand the core concepts of FAUST. Don't worry — this is simpler than it sounds.
The Signal Flow Model
In FAUST, everything is a signal processor. Your entire effect is described as a transformation from input signals to output signals. The most basic FAUST program looks like this:
process = _;This single line means: "Take the input signal and pass it through unchanged." The _ is FAUST's way of saying "the signal" and the semicolon ends the statement. That's a complete, working (albeit boring) effect!
Basic Operations
Let's make it more interesting. Here are the fundamental operations:
// Multiply the signal (volume control)
process = _ * 0.5; // Cuts the volume in half
// Add signals together
process = _ + _; // Sums two input signals
// Sequential processing (one after another)
process = effect1 : effect2 : effect3;
// Parallel processing (side by side)
process = effect1 , effect2;The : operator is your signal chain — it means "then feed into." So gainStage : filter : output reads exactly like a pedal board: gain, then filter, then output.
Variables and Functions
You can name things to make your code readable:
gain = 2.0;
process = _ * gain;And you can create reusable processing blocks:
// A simple hard clipper
clipper(threshold) = min(threshold) : max(-threshold);
// Use it in your signal chain
process = _ * 10 : clipper(0.8);Building Your First Effect: A Simple Overdrive
Now let's build something real — a basic overdrive effect with drive and volume controls. Open the FAUST IDE and paste this code:
import("stdfaust.lib");
// User controls
drive = hslider("Drive", 1, 1, 10, 0.1);
volume = hslider("Volume", 0.5, 0, 1, 0.01);
// Soft clipper using tanh
softClip(x) = ma.tanh(x);
// The overdrive effect
overdrive = _ * drive : softClip : _ * volume;
// Main process
process = overdrive;Let's break down what each part does:
The Import Statement
import("stdfaust.lib");This loads FAUST's standard library, giving you access to hundreds of pre-built DSP functions, math operations, and filters. Think of it as your audio toolkit.
User Controls
drive = hslider("Drive", 1, 1, 10, 0.1);
volume = hslider("Volume", 0.5, 0, 1, 0.01);The hslider function creates a horizontal slider control. The parameters are:
- Name — what appears on the interface ("Drive")
- Default value — where the knob starts (1)
- Minimum value — lowest setting (1)
- Maximum value — highest setting (10)
- Step size — how fine the control is (0.1)
The Clipping Function
softClip(x) = ma.tanh(x);This is where the magic happens. The hyperbolic tangent (tanh) function creates smooth, musical saturation — the same math that describes tube amp distortion. When you push a signal through tanh, quiet signals pass through relatively unchanged while loud signals get compressed and rounded off, creating that warm overdrive character.
The Signal Chain
overdrive = _ * drive : softClip : _ * volume;Read this left to right: Take the input signal, multiply by drive amount, pass through the soft clipper, then multiply by volume. Classic overdrive topology.
Testing It
In the FAUST IDE, click the Run button (or press Ctrl/Cmd + R). You'll see a visual representation of your effect with the Drive and Volume sliders. Click Audio On and you can test with your computer's microphone or load an audio file.
Try adjusting the Drive control — you should hear the signal get progressively grittier as you push it harder. That's your first custom overdrive!
Adding More Features: Tone Control
Let's enhance our overdrive with a tone control. In the real world, overdrives almost always have a tone knob that adjusts the brightness of the output. We'll add a simple low-pass filter:
import("stdfaust.lib");
// User controls
drive = hslider("Drive", 1, 1, 10, 0.1);
tone = hslider("Tone", 5000, 500, 10000, 1) : si.smoo;
volume = hslider("Volume", 0.5, 0, 1, 0.01);
// Soft clipper
softClip(x) = ma.tanh(x);
// Simple one-pole low-pass filter
toneFilter = fi.lowpass(1, tone);
// The overdrive effect with tone control
overdrive = _ * drive : softClip : toneFilter : _ * volume;
process = overdrive;We've added a few new elements:
Smoothed Control
tone = hslider("Tone", 5000, 500, 10000, 1) : si.smoo;The : si.smoo part smooths the control signal. Without this, turning the tone knob quickly could cause clicks and pops. The smoother creates a gentle transition between values — essential for professional-feeling controls.
The Filter
toneFilter = fi.lowpass(1, tone);This creates a first-order low-pass filter (the 1) with a cutoff frequency controlled by our tone knob. Low-pass filters let frequencies below the cutoff through while reducing higher frequencies. At 10,000 Hz, you get full brightness; at 500 Hz, a dark, muffled sound.
Run this updated version and sweep the Tone control. You're now building real, usable audio processors!
Deploying to Nimbus
Once you're happy with your effect in the browser, it's time to run it on real hardware. The FAUST IDE has built-in support for Chaos Audio devices.
Step 1: Export for Nimbus
In the FAUST IDE, look for the Export button (usually in the toolbar or under a menu). Select the Chaos Audio / Stratus target. The IDE will compile your FAUST code into a binary that Nimbus can run.
Step 2: Transfer to Your Device
The export process will generate a .so file — this is your compiled effect. Follow the on-screen instructions to transfer it to your Nimbus. The Chaos Audio mobile app's Development mode handles this connection.
Step 3: Test with Real Guitar
Connect your guitar, open the Chaos Audio app, and add your custom effect to your pedalboard. The Drive, Tone, and Volume controls you defined in FAUST become real knobs on your screen.
There's nothing quite like hearing your own DSP code process your actual guitar signal through a real amp. That's your effect, running on professional hardware.
More Effect Ideas
Once you understand the basics, you can build almost anything. Here are some starting points:
Simple Tremolo
import("stdfaust.lib");
rate = hslider("Rate", 4, 0.5, 12, 0.1);
depth = hslider("Depth", 0.5, 0, 1, 0.01);
// LFO generates a sine wave between (1-depth) and 1
lfo = 1 - depth + depth * (0.5 + 0.5 * os.osc(rate));
process = _ * lfo, _ * lfo;Simple Delay
import("stdfaust.lib");
delayTime = hslider("Time", 300, 50, 1000, 1) : si.smoo;
feedback = hslider("Feedback", 0.4, 0, 0.9, 0.01);
mix = hslider("Mix", 0.3, 0, 1, 0.01);
// Convert ms to samples
delaySamples = delayTime * ma.SR / 1000;
// Delay line with feedback
delayLine = +~(de.delay(96000, delaySamples) * feedback);
// Mix dry and wet
process = _ <: (_, delayLine) : (*(1-mix), *(mix)) :> _;Bit Crusher
import("stdfaust.lib");
bits = hslider("Bits", 8, 2, 16, 1);
rate = hslider("Sample Rate", 44100, 1000, 44100, 1);
// Reduce bit depth
crush(x) = floor(x * levels) / levels with {
levels = pow(2, bits);
};
// Sample rate reduction
decimate = ba.downSample(int(ma.SR / rate));
process = _ : crush : decimate;Publishing to Tone Shop
When your effect is polished and ready for the world, you can submit it to Tone Shop — Chaos Audio's marketplace for plugins. This is where your creation can reach thousands of other guitarists.
What You'll Need for Submission
- Effect name and description — what does it do, how should people use it?
- Your compiled binary — the .so file
- Artwork — pedal mockup, preview card, background image
- Knob and switch graphics — for the visual pedal interface
- Version number — start with 1.0.0
The Chaos Audio Developer Portal on GitHub has complete documentation on artwork requirements, file specifications, and the submission process. You can also reach out to support@chaosaudio.com for developer access and questions.
Resources for Learning More
This tutorial barely scratches the surface. Here's where to go next:
- FAUST Manual — the official documentation, comprehensive and well-written
- FAUST Libraries Documentation — reference for all built-in functions
- Chaos Audio Developer Portal — tutorials and examples specific to Nimbus/Stratus
- FAUST Examples Repository — hundreds of example effects to study and modify
- The FAUST Community — Discord, forums, and mailing lists full of helpful developers
Why Build Your Own?
You might be wondering — with thousands of effects already available, why bother building your own?
Because no one else can make exactly what's in your head.
Maybe you want an overdrive that responds differently to your picking dynamics. Maybe you want a tremolo that speeds up when you play louder. Maybe you hear a sound in your imagination that doesn't exist yet. With FAUST and Nimbus, you can build it.
There's also something deeply satisfying about playing through gear you created yourself. Every time you step on that effect, you know exactly why it sounds the way it does — because you designed it that way.
The open-platform nature of Nimbus means you're not limited to what ships in the box or what's available in a marketplace. You can customize every aspect of your sound, share your creations with other musicians, and be part of a community pushing the boundaries of what guitar effects can do.
So fire up the FAUST IDE, paste in that overdrive code, and start experimenting. Your first plugin is just a few lines of code away.
Ready to take your development further? The Nimbus smart amp platform gives you a professional-grade environment to run your custom effects alongside world-class amp modeling, audio interface capabilities, and a thriving plugin marketplace. Build it, test it, play it — all in one system.
