Open Source C++ Library for Audio Apps & Plug-ins

Getting Started with JUCE

The easiest way to install JUCE is using GitHub. Please use the following command for complete installation.

 git clone https://github.com/juce-framework/JUCE.git 

 cd JUCE
cmake . -B build
cmake --build build
 

Audio Processing and DSP Support

The open source JUCE provides built-in modules for digital signal processing (DSP), allowing developers to build audio effects, synthesizers, and sound processors. The framework includes tools for filters, oscillators, FFT analysis, and real-time audio processing. This makes JUCE ideal for creating music production tools and audio effects plugins. Here is a code processing example for an audio buffer and reduces the amplitude of each sample. Such operations are commonly used to implement gain control or audio effects.

void processBlock(juce::AudioBuffer& buffer)
{
    for (int channel = 0; channel < buffer.getNumChannels(); ++channel)
    {
        auto* samples = buffer.getWritePointer(channel);

        for (int i = 0; i < buffer.getNumSamples(); ++i)
            samples[i] *= 0.5f; // reduce volume
    }
}

Audio Plugin Development via C++ API

The JUCE library simplifies the creation of professional audio plugins. Developers can build plugins compatible with major audio standards like VST, VST3, AU, AUv3, AAX, and LV2 using a single framework. This feature allows developers to distribute their plugins across many DAWs without rewriting the code. The code shows a simple audio plugin reduces the signal gain by 20%. In real projects, developers can add parameters, automation, and complex DSP algorithms.

 class GainProcessor : public juce::AudioProcessor
{
public:
    void processBlock(juce::AudioBuffer& buffer,
                      juce::MidiBuffer&) override
    {
        buffer.applyGain(0.8f);
    }
};

Cross-Platform Development

One of the most powerful features of JUCE is its ability to build applications for multiple platforms using a single C++ codebase. Developers can create software that runs on Windows, macOS, Linux, iOS, and Android without rewriting platform-specific code. This dramatically reduces development time and ensures consistent behavior across operating systems. The following example creates a simple JUCE application that shows a dialog window. Because JUCE handles the platform abstraction, the same code works across multiple operating systems.

#include 

class HelloWorld  : public juce::JUCEApplication
{
public:
    const juce::String getApplicationName() override { return "JUCE Demo"; }
    const juce::String getApplicationVersion() override { return "1.0"; }

    void initialise (const juce::String&) override
    {
        juce::AlertWindow::showMessageBoxAsync(
            juce::AlertWindow::InfoIcon,
            "JUCE App",
            "Hello from a cross-platform JUCE application!");
    }

    void shutdown() override {}
};

START_JUCE_APPLICATION (HelloWorld)

MIDI and Audio Device Integration

JUCE also includes APIs for interacting with audio devices and MIDI controllers. Developers can access microphones, speakers, MIDI keyboards, and other hardware directly through the framework. This is critical for applications such as synthesizers, DAWs, and live performance software. This following code listens for incoming MIDI messages and prints the note number whenever a MIDI key is pressed.

void handleIncomingMidiMessage(juce::MidiInput*,
                               const juce::MidiMessage& message)
{
    if (message.isNoteOn())
    {
        int note = message.getNoteNumber();
        juce::Logger::writeToLog("Note On: " + juce::String(note));
    }
}