Pros of VST3 SDK

• Official SDK from Steinberg, ensuring compatibility with VST3 standard
• Comprehensive documentation and examples
• Regular updates and maintenance by Steinberg

Cons of VST3 SDK

• Steeper learning curve compared to iPlug2
• More complex setup and configuration process
• Limited cross-platform support out of the box

Code Comparison

VST3 SDK:

#include "public.sdk/source/vst/vstaudioeffect.h"

class MyPlugin : public Steinberg::Vst::AudioEffect {
    // Implementation
};

iPlug2:

#include "IPlug_include_in_plug_hdr.h"

class MyPlugin : public iplug::Plugin {
    // Implementation
};

The VST3 SDK provides a more standardized approach, while iPlug2 offers a simplified API for rapid development. iPlug2 abstracts many complexities, making it easier for beginners to create plugins. However, the VST3 SDK gives developers more control over low-level details and ensures full compliance with the VST3 standard.

Pros of JUCE

• More extensive and mature ecosystem with a larger community
• Cross-platform support for desktop, mobile, and web applications
• Comprehensive documentation and learning resources

Cons of JUCE

• Commercial licensing can be expensive for some developers
• Steeper learning curve due to its extensive feature set
• Larger codebase and potential overhead for simpler projects

Code Comparison

JUCE example:

class MainComponent : public juce::Component
{
public:
    MainComponent()
    {
        addAndMakeVisible(myButton);
        myButton.onClick = [this] { buttonClicked(); };
    }
    // ...
};

iPlug2 example:

class MyPlugin : public Plugin
{
public:
    MyPlugin(const InstanceInfo& info)
    : Plugin(info, MakeConfig(kNumParams, kNumPresets))
    {
        GetParam(kGain)->InitDouble("Gain", 0., 0., 100.0, 0.01, "%");
    }
    // ...
};

Both frameworks provide abstractions for audio plugin development, but JUCE offers a more comprehensive set of tools for general application development, while iPlug2 focuses specifically on audio plugins with a simpler API.

Pros of Surge

• Fully-featured, production-ready synthesizer with a rich set of features
• Active community and regular updates
• Extensive documentation and user guides

Cons of Surge

• Steeper learning curve for beginners
• Less flexibility for creating custom audio plugins
• More complex codebase, potentially harder to contribute to

Code Comparison

Surge (C++):

void SurgeVoice::processBlock(float *__restrict L, float *__restrict R, int nsamples)
{
   for (int s = 0; s < nsamples; s++)
   {
      float oL = 0.f, oR = 0.f;
      // ... (processing logic)
      L[s] += oL;
      R[s] += oR;
   }
}

iPlug2 (C++):

void MyPlugin::ProcessBlock(sample** inputs, sample** outputs, int nFrames)
{
  const double gain = GetParam(kGain)->Value();
  const int nChans = NOutChansConnected();
  
  for (int s = 0; s < nFrames; s++) {
    for (int c = 0; c < nChans; c++) {
      outputs[c][s] = inputs[c][s] * gain;
    }
  }
}

Summary

Surge is a full-featured synthesizer with a rich set of capabilities, while iPlug2 is a framework for building audio plugins. Surge offers a complete synth experience but may be more complex for beginners. iPlug2 provides more flexibility for creating custom plugins but requires more work to build a complete synthesizer. The code examples show the difference in approach, with Surge focusing on synthesizer-specific processing and iPlug2 providing a more generic plugin structure.

Pros of libsoundio

• Lightweight and focused on audio I/O, making it easier to integrate into projects
• Cross-platform support with a consistent API across different operating systems
• Low-latency design, suitable for real-time audio applications

Cons of libsoundio

• Limited to audio I/O functionality, lacking features for plugin development
• Smaller community and ecosystem compared to iPlug2
• Less comprehensive documentation and examples

Code Comparison

libsoundio:

SoundIoOutStream *outstream = soundio_outstream_create(device);
outstream->format = SoundIoFormatFloat32NE;
outstream->write_callback = write_callback;
soundio_outstream_open(outstream);
soundio_outstream_start(outstream);

iPlug2:

void MyPlugin::ProcessBlock(sample** inputs, sample** outputs, int nFrames)
{
  for (int s = 0; s < nFrames; s++) {
    outputs[0][s] = inputs[0][s] * mGain;
    outputs[1][s] = inputs[1][s] * mGain;
  }
}

libsoundio focuses on low-level audio I/O, while iPlug2 provides a higher-level framework for audio plugin development. libsoundio is more suitable for applications requiring direct audio stream control, whereas iPlug2 offers a more comprehensive solution for creating audio plugins with GUI support and additional features.

Pros of STK

• Focused on sound synthesis and audio processing algorithms
• Extensive collection of physical modeling instruments
• Lightweight and portable, suitable for embedded systems

Cons of STK

• Limited GUI capabilities compared to iPlug2
• Less comprehensive plugin development framework
• Smaller community and fewer resources for plugin developers

Code Comparison

STK (C++):

StkFloat MyInstrument::tick() {
    lastOut_ = filter_.tick(excitation_);
    return lastOut_;
}

iPlug2 (C++):

void MyPlugin::ProcessBlock(sample** inputs, sample** outputs, int nFrames) {
    for (int s = 0; s < nFrames; s++) {
        outputs[0][s] = mFilter.Process(inputs[0][s]);
    }
}

STK focuses on low-level audio processing and synthesis, while iPlug2 provides a more comprehensive framework for plugin development, including GUI tools and host integration. STK is better suited for audio algorithm development and embedded applications, whereas iPlug2 is more appropriate for creating full-featured audio plugins with graphical interfaces.