| Target/Platform | Linux | MacOS | Windows |
|---|---|---|---|
| Plugin |  |
 |
 |
| App |  |
 |
 |
| VST |  |
 |
 |
| WASM |  |
- | - |
Granade is a cross-platfrom real-time granular synthesizer. Granade runs as a vst3 plugin in a DAW; as a standalone application on mac, windows, and linux; and in the browser. Granade records audio input into a buffer and deconstructs the sound into multiple overlapping delayed, enveloped, and panned segments called grains, creating complex textures and new sonic landscapes. Interactive parameters such as grain size, density, spread, and windowing allow for dynamic manipulation of grain playback in real time.
- Key Features
- Installation
- Documentation
- Quick Start Guide
- FAQ
- Future Work
- Release Notes
- Acknowledgments
- Real-time granular synthesis
- Advanced grain control: size, density, spread, windowing, panning, and mix controls
- Cross-platform support (Windows, macOS, Linux, Web)
The easiest way to get Granade is to download pre-built releases from our GitHub Releases page.
For building from source, you'll need:
- OpenGL
- CMake (for vst)
- msvc (windows)
- clang (mac and linux)
Linux users will also need the development versions (ie with headers) of all packages JUCE requires for building VSTs (eg gtk, asound, etc).
git clone --recurse-submodules https://github.com/Audio-Project-Workgroup/granular_synth This places the https://github.com/juce-framework/JUCE repository within src/JUCE directory.
-
Configure your shell to be able to call a C compiler from the command line:
- Open a Developer Command Prompt and run (e.g. for x64 architectures):
"C:\Program Files\Microsoft Visual Studio\[YEAR]\Community\VC\Auxiliary\Build\vcvarsall.bat" x64 -
Set up GLFW:
- Download GLFW and extract the folder
- Open the
lib-vc[YEAR]folder corresponding to your version of Visual Studio. - Copy the
glfw3.libandglfw3_mt.libfiles to thesrc\libsfolder in the project root.
-
Build all targets
cd src buildThis creates a new
builddirectory in the project root, which contains the executable (Granade.exe), plugin library (plugin.dll), and VST3 bundle (build_JUCE\Granade_artefacts\Debug\VST3) targets. See Configuration Options for how to enable developer features, or only recompile specific targets. Note that building the WebAssembly target is not supported on Windows. The recommended way for Windows users to build the WASM target is to set up WSL2 and follow the linux build instructions. Since we ship a compiled WASM module with the project, there is no benefit to building the WASM target unless you are modifying the code. -
Install VST
You will have to put the VST3 bundle somewhere where your DAW/plugin host can find it.
-
Install the required dependencies via your package manager
-
Set up environment paths (optional):
- on mac, you may need to set/modify your shell's include, library, and pkg-config paths. For example:
# ~/.zshrc # replace /opt/homebrew with /usr/local on intel macs export CPATH=/opt/homebrew/include # append to this path if it exists already export LIBRARY_PATH=/opt/homebrew/lib # append to this path if it exists already export PKG_CONFIG_PATH="/opt/homebrew/lib/pkgconfig:$PKG_CONFIG_PATH"
- Build all targets
This creates a new
cd src ./build.shbuilddirectory in the project root, which contains the executable (Granade.exe), plugin library (plugin.dylibon mac andplugin.soon linux), and VST3 bundle (build_JUCE/Granade_artefacts/Debug/VST3) targets. See Configuration Options for how to enable developer features, or only recompile specific targets. Mac users may see one or more errors relating to WebAssembly build failure. This is not a problem, it only means your version of clang does not support WebAssembly (which the default version that comes with Xode does not). To build the WebAssembly target on Mac, you will need to replace the system's version of clang with a more recent version, which can be installed from homebrew. Since we ship a compiled WASM module with the project, there is no benefit to building the WASM target unless you are modifying the code.
To build `Granade` from source, the following configuration options are available:
config Options
| Value | Description |
|---|---|
debug |
Compiles with debug info and enables asserts. |
logging |
Enables the logging system. |
release |
Assembles a distributable application bundle (mac and linux only). |
target Options
| Value | Description |
|---|---|
plugin |
Compiles the plugin to a dynamic library. |
exe |
Compiles the host executable. |
vst |
Compiles the VST target. |
wasm |
Compiles the WebAssembly target (mac and linux only). |
all |
Compiles all targets. (Default) |
Display available commands and usage information using the `help` option.
You can configure builds using key–value pairs passed as command-line arguments:
```bash
./build.sh <key>:<value1>+<value2>+...
```
on mac and linux, or
``` batch
build <key>:<value1>+<value2>+...
```
on windows.
The following example enables debug mode and logging and builds the executable target.
bash ./build.sh config:debug+logging target:exe+wasm
on mac and linux, or
batch build config:debug+logging target:exe+wasm
on windows
Defaults
- All
configoptions are disabled by default. - All
targetoptions are enabled by default. - Enabling any option will disable all other unenabled options for that key.
Note: Unknown arguments will print a warning but won’t stop the build.
To test the standalone application, simply:
- in Windows: Run `build\Granade`
- in macOS/Linux: Run `./build/Granade`
To test the VST3 plugin, make sure it is visible by your DAW by either moving it inside the default VST directory, or adding the parent directory of the VST3 bundle to your DAW's list of scanned directories.
Some files include comments explaining implementation details. Documentation coverage is currently limited but being expanded. For more technical information, visit [How Granade Works](data/docs/HOW_GRANADE_WORKS.md).
Granade is a working granular synthesizer with room for future development. Some interface elements may not yet be fully functional.
- Standalone: Uses any audio device as input
- VST: Works as audio effect
- Web: Uses the microphone as input
- Left click and drag a knob or slider up or down to change its value.
- You can also navigate the ui with tab and backspace. Use + and - on a selected control to change parameter values.
- Pressing ESC opens a menu to select audio input and output devices with the mouse. Press ESC again to close.
| Parameter | Description | How to Use |
|---|---|---|
| Density | Controls the number of playing grains | Turn left for fewer grains, and right for more. |
| Spread | Controls the random stereo widening applied to each grain | Fully left is dual mono, middle is unmodified, right is wider. |
| Offset | Controls the space between the read and write heads of the buffer | Turn left for less delay, and right for more. |
| Size | Controls the size of new grains | Left is shorter, right is longer. |
| Mix | Controls the dry/wet mix | Fully left is completely dry, fully right is completely wet. |
| Pan | Controls the pan of the wet signal | Left is left, right is right. |
| Window | Controls the amplitude window shape applied to each grain | Turn left for a smoother ramp, and right for a choppier sound |
| Level | Controls the overall amplitude of the output signal | Up for louder, down for quieter |
Feel free to experiment - Granade is designed for artistic exploration and creative discovery!
Is Granade a cross-platform project? Does it support both standalone apps and VST3 plugins for each platform?
Yes it is, and so it does! You can download precompiled binaries for macOS (arm), Windows (x64), and Linux (x64). Other combinations of OS and architecture are supported via building from source.
What makes Granade different from other granular synthesizers?
While inspired by existing granular synths, Granade brings its own unique approach to granular synthesis. Therefore, it's not novel, but unique.
Is Granade ready for production use?
Granade is in a nascent stage of development, developed by a small team, and only tested on a handful of systems. As such, you may experience crashes, bugs, or be missing certain features. In any of these cases, please let us know by submitting an issue (bug report or feature request) on github. While functional for experimentation and creative use, some features are incomplete. We recommend it for creative exploration rather than critical production work at this stage.
Can I load my own audio files?
File loading is supported in the codebase under the hood but the UI control is not yet implemented. Currently, the standalone application uses microphone input and the VST processes audio directly from your DAW tracks.
Some controls in the interface don't seem to work. Is this a bug?
No, this is expected. Granade is in its first release and not all visible controls are fully functional yet. For more details, see Future work.
Does Granade use machine learning for audio processing?
Not currently. The codebase includes ONNX runtime integration to support potential ML features, but the current audio processing pipeline is purely algorithmic. ML inclusion for granular synthesis is on our future development list.
This is a list of bugs and issues that require fixing:
- vst3 automatic installation into default VST3 directory
- get JUCE to do the installation automatically
- make parameters visible to fl studio last tweaked automation menu
- per-grain level
- modulation
- linux hot reloading sometimes fails (recompiling the executable at runtime sometimes crashes the application)
This is a list of existing features that require curation and improvement:
- automatically detect if we need to build a miniaudio library, discarding the need of commenting out compilation instructions
- condense builds into a single script, with optional arguments
- Improve UI:
- improve font rendering
- tooltips when hovering (eg show numeric parameter value)
- improve grain buffer state display
- support modifying parameters with mouse wheel scrolling
- full state (de)serialization (not just parameters, also grain buffer)
- File Loading:
- speed up reads
- better samplerate conversion
- MIDI:
- cc channel - parameter remapping at runtime
- Enhance development practices:
- static analysis
- hook a fuzzer up to the input for resilience testing
- remove plugin dependence on crt for maximum portability
- Optimize codebase:
- profiling
- simd everywhere
This is a list of missing features for concrete Granade implementation, or envisioned features that aim to highly leverage Granade:
-
Implement missing grain controls:
- Pitch-Shift
- Time-Stretch
- Modulation
-
Extend UI:
- interface for selecting files to load at runtime.
- interface for remapping midi cc channels with parameters.
-
Extend File Loading:
- Support more audio file formats
- flac
- ogg
- mp3
- ...
- (ML depended) load in batches to pass to ML model
- Support more audio file formats
-
save and restore plugin state
-
screen reader support
-
Integrate ML into the pipeline for grouping grains
New WebAssembly target, renderer improvements, reduced memory footprint, build configuration interface
Initial release with real-time granular synthesis, cross-platform support, and VST3 plugin.
For a complete changelog of all versions, see CHANGELOG.md
- Born from connections made at ADC 24, Granade exists thanks to the Audio-Project-Workgroup's initiative to unite developers with shared interests under the scope of music and IT. Special appreciation to all the people who contributed their time to it.