diff --git a/.github/workflows/build-teensy.yml b/.github/workflows/build-teensy.yml
index 121bbc37f..1c30af49c 100644
--- a/.github/workflows/build-teensy.yml
+++ b/.github/workflows/build-teensy.yml
@@ -55,8 +55,8 @@ jobs:
       - name: Build
         run: |
           cc=~/.platformio/packages/toolchain-gccarmnoneeabi/bin/arm-none-eabi-g++
-          $cc -DCORE_TEENSY=1 --std=c++17 -mcpu=cortex-m7 -mfloat-abi=hard -mfpu=fpv5-d16 --specs=nosys.specs -Imodules/common -Imodules/dsp -DJUCE_MODULE_AVAILABLE_chowdsp_buffers=1 -c modules/common/chowdsp_core/chowdsp_core.cpp
-          $cc -DCORE_TEENSY=1 --std=c++17 -mcpu=cortex-m7 -mfloat-abi=hard -mfpu=fpv5-d16 --specs=nosys.specs -Imodules/common -Imodules/dsp -DJUCE_MODULE_AVAILABLE_chowdsp_buffers=1 -c modules/dsp/chowdsp_buffers/chowdsp_buffers.cpp
-          $cc -DCORE_TEENSY=1 --std=c++17 -mcpu=cortex-m7 -mfloat-abi=hard -mfpu=fpv5-d16 --specs=nosys.specs -Imodules/common -Imodules/dsp -DJUCE_MODULE_AVAILABLE_chowdsp_buffers=1 -c modules/dsp/chowdsp_dsp_data_structures/chowdsp_dsp_data_structures.cpp
-          $cc -DCORE_TEENSY=1 --std=c++17 -mcpu=cortex-m7 -mfloat-abi=hard -mfpu=fpv5-d16 --specs=nosys.specs -Imodules/common -Imodules/dsp -DJUCE_MODULE_AVAILABLE_chowdsp_buffers=1 -c modules/dsp/chowdsp_dsp_utils/chowdsp_dsp_utils.cpp
-          $cc -DCORE_TEENSY=1 --std=c++17 -mcpu=cortex-m7 -mfloat-abi=hard -mfpu=fpv5-d16 --specs=nosys.specs -Imodules/common -Imodules/dsp -DJUCE_MODULE_AVAILABLE_chowdsp_buffers=1 -c modules/dsp/chowdsp_math/chowdsp_math.cpp
+          $cc -DCORE_TEENSY=1 --std=c++17 -mcpu=cortex-m7 -mfloat-abi=hard -mfpu=fpv5-d16 --specs=nosys.specs -Imodules/common -Imodules/dsp -DJUCE_MODULE_AVAILABLE_chowdsp_buffers=1 -DJUCE_MODULE_AVAILABLE_chowdsp_data_structures=1 -c modules/common/chowdsp_core/chowdsp_core.cpp
+          $cc -DCORE_TEENSY=1 --std=c++17 -mcpu=cortex-m7 -mfloat-abi=hard -mfpu=fpv5-d16 --specs=nosys.specs -Imodules/common -Imodules/dsp -DJUCE_MODULE_AVAILABLE_chowdsp_buffers=1 -DJUCE_MODULE_AVAILABLE_chowdsp_data_structures=1 -c modules/dsp/chowdsp_buffers/chowdsp_buffers.cpp
+          $cc -DCORE_TEENSY=1 --std=c++17 -mcpu=cortex-m7 -mfloat-abi=hard -mfpu=fpv5-d16 --specs=nosys.specs -Imodules/common -Imodules/dsp -DJUCE_MODULE_AVAILABLE_chowdsp_buffers=1 -DJUCE_MODULE_AVAILABLE_chowdsp_data_structures=1 -c modules/dsp/chowdsp_dsp_data_structures/chowdsp_dsp_data_structures.cpp
+          $cc -DCORE_TEENSY=1 --std=c++17 -mcpu=cortex-m7 -mfloat-abi=hard -mfpu=fpv5-d16 --specs=nosys.specs -Imodules/common -Imodules/dsp -DJUCE_MODULE_AVAILABLE_chowdsp_buffers=1 -DJUCE_MODULE_AVAILABLE_chowdsp_data_structures=1 -c modules/dsp/chowdsp_dsp_utils/chowdsp_dsp_utils.cpp
+          $cc -DCORE_TEENSY=1 --std=c++17 -mcpu=cortex-m7 -mfloat-abi=hard -mfpu=fpv5-d16 --specs=nosys.specs -Imodules/common -Imodules/dsp -DJUCE_MODULE_AVAILABLE_chowdsp_buffers=1 -DJUCE_MODULE_AVAILABLE_chowdsp_data_structures=1 -c modules/dsp/chowdsp_math/chowdsp_math.cpp
diff --git a/examples/SimpleEQ/CMakeLists.txt b/examples/SimpleEQ/CMakeLists.txt
index 8a3c441ee..85f507c7e 100644
--- a/examples/SimpleEQ/CMakeLists.txt
+++ b/examples/SimpleEQ/CMakeLists.txt
@@ -15,3 +15,7 @@ target_sources(SimpleEQ
         PluginEditor.cpp
         FilterPlots.cpp
 )
+target_compile_definitions(SimpleEQ
+    PRIVATE
+        CHOWDSP_BUFFER_MAX_NUM_CHANNELS=2
+)
diff --git a/examples/SimpleEQ/SimpleEQPlugin.cpp b/examples/SimpleEQ/SimpleEQPlugin.cpp
index a68aa56a9..3da96bcdb 100644
--- a/examples/SimpleEQ/SimpleEQPlugin.cpp
+++ b/examples/SimpleEQ/SimpleEQPlugin.cpp
@@ -63,7 +63,7 @@ void SimpleEQPlugin::processAudioBlock (juce::AudioBuffer<float>& buffer)
     // any thread, but we'll do it on the audio thread here.
     setEQParams();
 
-    if (state.params.linPhaseMode.get())
+    if (state.params.linPhaseMode->get())
     {
         // Linear phase mode is on: processing the linear phase EQ here!
         linPhaseEQ.processBlock (buffer);
diff --git a/modules/dsp/chowdsp_buffers/Buffers/chowdsp_BufferView.h b/modules/dsp/chowdsp_buffers/Buffers/chowdsp_BufferView.h
index 68210eeda..fbe1afa38 100644
--- a/modules/dsp/chowdsp_buffers/Buffers/chowdsp_BufferView.h
+++ b/modules/dsp/chowdsp_buffers/Buffers/chowdsp_BufferView.h
@@ -1,5 +1,9 @@
 #pragma once
 
+#if JUCE_MODULE_AVAILABLE_chowdsp_data_structures
+#include <chowdsp_data_structures/chowdsp_data_structures.h>
+#endif
+
 namespace chowdsp
 {
 /**
@@ -372,4 +376,18 @@ template <typename BufferType,
               std::is_same_v<BufferType, const Buffer<xsimd::batch<double>>> || (std::is_const_v<BufferType> && detail::is_static_buffer_v<std::remove_const_t<BufferType>, xsimd::batch<double>>)>>
 BufferView (BufferType&, Ts...) -> BufferView<const xsimd::batch<double>>;
 #endif // ! CHOWDSP_NO_XSIMD
+
+#if JUCE_MODULE_AVAILABLE_chowdsp_data_structures
+template <typename T>
+BufferView<T> make_temp_buffer (ArenaAllocatorView arena, int num_channels, int num_samples)
+{
+    std::array<T*, CHOWDSP_BUFFER_MAX_NUM_CHANNELS> channel_pointers {};
+    for (size_t ch = 0; ch < static_cast<size_t> (num_channels); ++ch)
+    {
+        channel_pointers[ch] = arena.allocate<T> (num_samples, SIMDUtils::defaultSIMDAlignment);
+        jassert (channel_pointers[ch] != nullptr);
+    }
+    return { channel_pointers.data(), num_channels, num_samples };
+}
+#endif
 } // namespace chowdsp
diff --git a/modules/dsp/chowdsp_dsp_data_structures/Other/chowdsp_SmoothedBufferValue.cpp b/modules/dsp/chowdsp_dsp_data_structures/Other/chowdsp_SmoothedBufferValue.cpp
index 6f262799b..b944c0322 100644
--- a/modules/dsp/chowdsp_dsp_data_structures/Other/chowdsp_SmoothedBufferValue.cpp
+++ b/modules/dsp/chowdsp_dsp_data_structures/Other/chowdsp_SmoothedBufferValue.cpp
@@ -99,6 +99,14 @@ void SmoothedBufferValue<FloatType, ValueSmoothingTypes>::process (int numSample
     }
 }
 
+template <typename FloatType, typename ValueSmoothingTypes>
+void SmoothedBufferValue<FloatType, ValueSmoothingTypes>::process (int numSamples, ArenaAllocatorView alloc)
+{
+    bufferData = alloc.allocate<FloatType> (numSamples, bufferAlignment);
+    jassert (bufferData != nullptr); // arena allocator is out of memory!
+    process (numSamples);
+}
+
 template <typename FloatType, typename ValueSmoothingTypes>
 void SmoothedBufferValue<FloatType, ValueSmoothingTypes>::process (FloatType value, int numSamples)
 {
@@ -117,6 +125,14 @@ void SmoothedBufferValue<FloatType, ValueSmoothingTypes>::process (FloatType val
         bufferData[n] = smoother.getNextValue();
 }
 
+template <typename FloatType, typename ValueSmoothingTypes>
+void SmoothedBufferValue<FloatType, ValueSmoothingTypes>::process (FloatType value, int numSamples, ArenaAllocatorView alloc)
+{
+    bufferData = alloc.allocate<FloatType> (numSamples, bufferAlignment);
+    jassert (bufferData != nullptr); // arena allocator is out of memory!
+    process (value, numSamples);
+}
+
 template class SmoothedBufferValue<float, juce::ValueSmoothingTypes::Linear>;
 template class SmoothedBufferValue<double, juce::ValueSmoothingTypes::Linear>;
 template class SmoothedBufferValue<float, juce::ValueSmoothingTypes::Multiplicative>;
diff --git a/modules/dsp/chowdsp_dsp_data_structures/Other/chowdsp_SmoothedBufferValue.h b/modules/dsp/chowdsp_dsp_data_structures/Other/chowdsp_SmoothedBufferValue.h
index d82a8da6c..132e1009d 100644
--- a/modules/dsp/chowdsp_dsp_data_structures/Other/chowdsp_SmoothedBufferValue.h
+++ b/modules/dsp/chowdsp_dsp_data_structures/Other/chowdsp_SmoothedBufferValue.h
@@ -79,12 +79,7 @@ class SmoothedBufferValue
      */
     void process (int numSamples);
 
-    void process (int numSamples, ArenaAllocatorView alloc)
-    {
-        bufferData = alloc.allocate<FloatType> (numSamples, bufferAlignment);
-        jassert (bufferData != nullptr); // arena allocator is out of memory!
-        process (numSamples);
-    }
+    void process (int numSamples, ArenaAllocatorView alloc);
 
     /**
      * Process smoothing for the input value.
@@ -92,12 +87,7 @@ class SmoothedBufferValue
      */
     void process (FloatType value, int numSamples);
 
-    void process (FloatType value, int numSamples, ArenaAllocatorView alloc)
-    {
-        bufferData = alloc.allocate<FloatType> (numSamples, bufferAlignment);
-        jassert (bufferData != nullptr); // arena allocator is out of memory!
-        process (value, numSamples);
-    }
+    void process (FloatType value, int numSamples, ArenaAllocatorView alloc);
 
     /** Returns a pointer to the current smoothed buffer. */
     [[nodiscard]] const FloatType* getSmoothedBuffer() const { return bufferData; }
diff --git a/modules/dsp/chowdsp_dsp_utils/Processors/chowdsp_BypassProcessor.cpp b/modules/dsp/chowdsp_dsp_utils/Processors/chowdsp_BypassProcessor.cpp
index ac6eeeccb..92d4ef955 100644
--- a/modules/dsp/chowdsp_dsp_utils/Processors/chowdsp_BypassProcessor.cpp
+++ b/modules/dsp/chowdsp_dsp_utils/Processors/chowdsp_BypassProcessor.cpp
@@ -1,14 +1,21 @@
 namespace chowdsp
 {
 template <typename SampleType, typename DelayInterpType>
-void BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<std::is_same_v<DelayInterpType, std::nullptr_t>>>::prepare (const juce::dsp::ProcessSpec& spec, bool onOffParam)
+void BypassProcessor<SampleType,
+                     DelayInterpType,
+                     std::enable_if_t<std::is_same_v<DelayInterpType, NullType>>>::prepare (const juce::dsp::ProcessSpec& spec, bool onOffParam, bool useInternalBuffer)
 {
     prevOnOffParam = onOffParam;
-    fadeBuffer.setMaxSize ((int) spec.numChannels, (int) spec.maximumBlockSize);
+    if (useInternalBuffer)
+        fadeBuffer.setMaxSize ((int) spec.numChannels, (int) spec.maximumBlockSize);
 }
 
 template <typename SampleType, typename DelayInterpType>
-bool BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<std::is_same_v<DelayInterpType, std::nullptr_t>>>::processBlockIn (const BufferView<const SampleType>& block, bool onOffParam)
+bool BypassProcessor<SampleType,
+                     DelayInterpType,
+                     std::enable_if_t<std::is_same_v<DelayInterpType, NullType>>>::processBlockIn (const BufferView<const SampleType>& block,
+                                                                                                   bool onOffParam,
+                                                                                                   std::optional<ArenaAllocatorView> arena)
 {
     if (! onOffParam && ! prevOnOffParam)
     {
@@ -17,15 +24,21 @@ bool BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<std::is_same_
 
     if (onOffParam != prevOnOffParam)
     {
-        fadeBuffer.setCurrentSize (block.getNumChannels(), block.getNumSamples());
-        BufferMath::copyBufferData (block, fadeBuffer);
+        if (arena.has_value())
+            fadeBufferView = make_temp_buffer<SampleType> (*arena, block.getNumChannels(), block.getNumSamples());
+        else
+            fadeBufferView = BufferView { fadeBuffer, 0, block.getNumSamples(), 0, block.getNumChannels() };
+
+        BufferMath::copyBufferData (block, fadeBufferView);
     }
 
     return true;
 }
 
 template <typename SampleType, typename DelayInterpType>
-void BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<std::is_same_v<DelayInterpType, std::nullptr_t>>>::processBlockOut (const BufferView<SampleType>& block, bool onOffParam)
+void BypassProcessor<SampleType,
+                     DelayInterpType,
+                     std::enable_if_t<std::is_same_v<DelayInterpType, NullType>>>::processBlockOut (const BufferView<SampleType>& block, bool onOffParam)
 {
     auto fadeOutputBuffer = [onOffParam] (auto* blockPtr, const auto* fadePtr, const int startSample, const int numSamples)
     {
@@ -68,7 +81,7 @@ void BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<std::is_same_
     for (int ch = 0; ch < numChannels; ++ch)
     {
         auto* blockPtr = block.getWritePointer (ch);
-        const auto* fadePtr = fadeBuffer.getReadPointer (ch);
+        const auto* fadePtr = fadeBufferView.getReadPointer (ch);
 
         fadeOutputBuffer (blockPtr, fadePtr, 0, numSamples);
     }
@@ -79,29 +92,40 @@ void BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<std::is_same_
 
 //===========================================================
 template <typename SampleType, typename DelayInterpType>
-void BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_same_v<DelayInterpType, std::nullptr_t>>>::prepare (const juce::dsp::ProcessSpec& spec, bool onOffParam)
+void BypassProcessor<SampleType,
+                     DelayInterpType,
+                     std::enable_if_t<! std::is_same_v<DelayInterpType, NullType>>>::prepare (const juce::dsp::ProcessSpec& spec,
+                                                                                              bool onOffParam,
+                                                                                              bool useInternalBuffer)
 {
     prevOnOffParam = onOffParam;
-    fadeBuffer.setMaxSize ((int) spec.numChannels, (int) spec.maximumBlockSize);
+    if (useInternalBuffer)
+        fadeBuffer.setMaxSize ((int) spec.numChannels, (int) spec.maximumBlockSize);
 
     compDelay.prepare (spec); // sample rate does not matter
 }
 
 template <typename SampleType, typename DelayInterpType>
-void BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_same_v<DelayInterpType, std::nullptr_t>>>::setLatencySamples (int delaySamples)
+void BypassProcessor<SampleType,
+                     DelayInterpType,
+                     std::enable_if_t<! std::is_same_v<DelayInterpType, NullType>>>::setLatencySamples (int delaySamples)
 {
     setLatencySamplesInternal ((NumericType) delaySamples);
 }
 
 template <typename SampleType, typename DelayInterpType>
-void BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_same_v<DelayInterpType, std::nullptr_t>>>::setLatencySamples (NumericType delaySamples)
+void BypassProcessor<SampleType,
+                     DelayInterpType,
+                     std::enable_if_t<! std::is_same_v<DelayInterpType, NullType>>>::setLatencySamples (NumericType delaySamples)
 {
     static_assert (! std::is_same_v<DelayInterpType, DelayLineInterpolationTypes::None>, "Attempting to set non-integer latency value without using delay interpolation!");
     setLatencySamplesInternal (delaySamples);
 }
 
 template <typename SampleType, typename DelayInterpType>
-void BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_same_v<DelayInterpType, std::nullptr_t>>>::setLatencySamplesInternal (NumericType delaySamples)
+void BypassProcessor<SampleType,
+                     DelayInterpType,
+                     std::enable_if_t<! std::is_same_v<DelayInterpType, NullType>>>::setLatencySamplesInternal (NumericType delaySamples)
 {
     if (juce::approximatelyEqual (delaySamples, prevDelay))
         return;
@@ -115,7 +139,11 @@ void BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_sam
 }
 
 template <typename SampleType, typename DelayInterpType>
-bool BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_same_v<DelayInterpType, std::nullptr_t>>>::processBlockIn (const BufferView<SampleType>& block, bool onOffParam)
+bool BypassProcessor<SampleType,
+                     DelayInterpType,
+                     std::enable_if_t<! std::is_same_v<DelayInterpType, NullType>>>::processBlockIn (const BufferView<SampleType>& block,
+                                                                                                     bool onOffParam,
+                                                                                                     std::optional<ArenaAllocatorView> arena)
 {
     enum class DelayOp
     {
@@ -161,9 +189,13 @@ bool BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_sam
 
     if (onOffParam != prevOnOffParam)
     {
-        fadeBuffer.setCurrentSize (block.getNumChannels(), block.getNumSamples());
-        BufferMath::copyBufferData (block, fadeBuffer);
-        doDelayOp (fadeBuffer, compDelay, DelayOp::Pop);
+        if (arena.has_value())
+            fadeBufferView = make_temp_buffer<SampleType> (*arena, block.getNumChannels(), block.getNumSamples());
+        else
+            fadeBufferView = BufferView { fadeBuffer, 0, block.getNumSamples(), 0, block.getNumChannels() };
+
+        BufferMath::copyBufferData (block, fadeBufferView);
+        doDelayOp (fadeBufferView, compDelay, DelayOp::Pop);
 
         if (onOffParam && latencySampleCount < 0)
             latencySampleCount = (int) compDelay.getDelay();
@@ -177,7 +209,9 @@ bool BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_sam
 }
 
 template <typename SampleType, typename DelayInterpType>
-void BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_same_v<DelayInterpType, std::nullptr_t>>>::processBlockOut (const BufferView<SampleType>& block, bool onOffParam)
+void BypassProcessor<SampleType,
+                     DelayInterpType,
+                     std::enable_if_t<! std::is_same_v<DelayInterpType, NullType>>>::processBlockOut (const BufferView<SampleType>& block, bool onOffParam)
 {
     auto fadeOutputBuffer = [onOffParam] (auto* blockPtr, const auto* fadePtr, const int startSample, const int numSamples)
     {
@@ -222,7 +256,7 @@ void BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_sam
     for (int ch = 0; ch < numChannels; ++ch)
     {
         auto* blockPtr = block.getWritePointer (ch);
-        const auto* fadePtr = fadeBuffer.getReadPointer (ch);
+        const auto* fadePtr = fadeBufferView.getReadPointer (ch);
 
         fadeOutputBuffer (blockPtr, fadePtr, startSample, numSamples);
     }
@@ -232,7 +266,9 @@ void BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_sam
 }
 
 template <typename SampleType, typename DelayInterpType>
-int BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_same_v<DelayInterpType, std::nullptr_t>>>::getFadeStartSample (const int numSamples)
+int BypassProcessor<SampleType,
+                    DelayInterpType,
+                    std::enable_if_t<! std::is_same_v<DelayInterpType, NullType>>>::getFadeStartSample (const int numSamples)
 {
     if (latencySampleCount <= 0)
     {
diff --git a/modules/dsp/chowdsp_dsp_utils/Processors/chowdsp_BypassProcessor.h b/modules/dsp/chowdsp_dsp_utils/Processors/chowdsp_BypassProcessor.h
index 614519446..a66525bb4 100644
--- a/modules/dsp/chowdsp_dsp_utils/Processors/chowdsp_BypassProcessor.h
+++ b/modules/dsp/chowdsp_dsp_utils/Processors/chowdsp_BypassProcessor.h
@@ -22,11 +22,11 @@ namespace chowdsp
  * }
  * ```
  */
-template <typename SampleType, typename DelayInterpType = std::nullptr_t, typename = void>
+template <typename SampleType, typename DelayInterpType = NullType, typename = void>
 class BypassProcessor;
 
 template <typename SampleType, typename DelayInterpType>
-class BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<std::is_same_v<DelayInterpType, std::nullptr_t>>>
+class BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<std::is_same_v<DelayInterpType, NullType>>>
 {
 public:
     using NumericType = SampleTypeHelpers::NumericType<SampleType>;
@@ -40,14 +40,14 @@ class BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<std::is_same
     }
 
     /** Allocated required memory, and resets the property */
-    void prepare (const juce::dsp::ProcessSpec& spec, bool onOffParam);
+    void prepare (const juce::dsp::ProcessSpec& spec, bool onOffParam, bool useInternalBuffer = true);
 
     /**
       * Call this at the start of your processBlock().
       * If it returns false, you can safely skip all other
       * processing.
       */
-    bool processBlockIn (const BufferView<const SampleType>& buffer, bool onOffParam);
+    bool processBlockIn (const BufferView<const SampleType>& buffer, bool onOffParam, std::optional<ArenaAllocatorView> arena = std::nullopt);
 
     /**
       * Call this at the end of your processBlock().
@@ -59,12 +59,13 @@ class BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<std::is_same
 private:
     bool prevOnOffParam = false;
     Buffer<SampleType> fadeBuffer;
+    BufferView<SampleType> fadeBufferView;
 
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (BypassProcessor)
 };
 
 template <typename SampleType, typename DelayInterpType>
-class BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_same_v<DelayInterpType, std::nullptr_t>>>
+class BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_same_v<DelayInterpType, NullType>>>
 {
 public:
     using NumericType = SampleTypeHelpers::NumericType<SampleType>;
@@ -78,7 +79,7 @@ class BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_sa
     }
 
     /** Allocated required memory, and resets the property */
-    void prepare (const juce::dsp::ProcessSpec& spec, bool onOffParam);
+    void prepare (const juce::dsp::ProcessSpec& spec, bool onOffParam, bool useInternalBuffer = true);
 
     /**
      * If the non-bypassed processing has some associated
@@ -101,7 +102,7 @@ class BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_sa
       * If it returns false, you can safely skip all other
       * processing.
       */
-    bool processBlockIn (const BufferView<SampleType>& buffer, bool onOffParam);
+    bool processBlockIn (const BufferView<SampleType>& buffer, bool onOffParam, std::optional<ArenaAllocatorView> arena = std::nullopt);
 
     /**
       * Call this at the end of your processBlock().
@@ -116,6 +117,7 @@ class BypassProcessor<SampleType, DelayInterpType, std::enable_if_t<! std::is_sa
 
     bool prevOnOffParam = false;
     Buffer<SampleType> fadeBuffer;
+    BufferView<SampleType> fadeBufferView;
 
     DelayLine<SampleType, DelayInterpType> compDelay { 1 << 18 }; // max latency = 2^18 = 262144 samples
     NumericType prevDelay {};
diff --git a/modules/dsp/chowdsp_eq/EQ/chowdsp_EQBand.cpp b/modules/dsp/chowdsp_eq/EQ/chowdsp_EQBand.cpp
index 49b2fc93a..5a0822ea8 100644
--- a/modules/dsp/chowdsp_eq/EQ/chowdsp_EQBand.cpp
+++ b/modules/dsp/chowdsp_eq/EQ/chowdsp_EQBand.cpp
@@ -39,9 +39,6 @@ void EQBandBase<FloatType, FilterChoicesTuple>::prepare (const juce::dsp::Proces
 {
     fs = (NumericType) spec.sampleRate;
 
-    fadeBuffer.setMaxSize ((int) spec.numChannels, (int) spec.maximumBlockSize);
-    fadeBuffer.clear();
-
     TupleHelpers::forEachInTuple (
         [spec] (auto& filter, size_t)
         {
@@ -58,7 +55,7 @@ void EQBandBase<FloatType, FilterChoicesTuple>::prepare (const juce::dsp::Proces
 
     for (auto* smoother : { &freqSmooth, &qSmooth, &gainSmooth })
     {
-        smoother->prepare (spec.sampleRate, (int) spec.maximumBlockSize);
+        smoother->prepare (spec.sampleRate, (int) spec.maximumBlockSize, false);
         smoother->setRampLength (0.05);
     }
 
@@ -278,24 +275,26 @@ void EQBandBase<FloatType, FilterChoicesTuple>::fadeBuffers (const FloatType* fa
 }
 
 template <typename FloatType, typename FilterChoicesTuple>
-void EQBandBase<FloatType, FilterChoicesTuple>::processBlock (const BufferView<FloatType>& buffer) noexcept
+void EQBandBase<FloatType, FilterChoicesTuple>::processBlock (const BufferView<FloatType>& buffer, ArenaAllocatorView arena) noexcept
 {
     const auto numChannels = buffer.getNumChannels();
     const auto numSamples = buffer.getNumSamples();
+    const auto frame = arena.create_frame();
 
-    freqSmooth.process (freqHzHandle, numSamples);
-    qSmooth.process (qHandle, numSamples);
-    gainSmooth.process (gainHandle, numSamples);
+    freqSmooth.process (freqHzHandle, numSamples, arena);
+    qSmooth.process (qHandle, numSamples, arena);
+    gainSmooth.process (gainHandle, numSamples, arena);
 
     const auto needsFade = filterType != prevFilterType;
+    BufferView<FloatType> fadeBuffer {};
     if (needsFade)
     {
-        fadeBuffer.setCurrentSize (numChannels, numSamples);
+        fadeBuffer = make_temp_buffer<FloatType> (arena, numChannels, numSamples);
         BufferMath::copyBufferData (buffer, fadeBuffer);
     }
 
     TupleHelpers::forEachInTuple (
-        [this, &buffer] (auto& filter, size_t filterIndex)
+        [this, &buffer, &fadeBuffer] (auto& filter, size_t filterIndex)
         {
             if ((int) filterIndex == filterType)
             {
@@ -320,62 +319,4 @@ void EQBandBase<FloatType, FilterChoicesTuple>::processBlock (const BufferView<F
 
     prevFilterType = filterType;
 }
-
-template <typename FloatType, typename FilterChoicesTuple>
-template <typename ProcessContext>
-void EQBandBase<FloatType, FilterChoicesTuple>::process (const ProcessContext& context) noexcept
-{
-    const auto& inputBlock = context.getInputBlock();
-    auto& block = context.getOutputBlock();
-    const auto numChannels = block.getNumChannels();
-    const auto numSamples = (int) block.getNumSamples();
-
-    jassert (inputBlock.getNumChannels() == numChannels);
-    jassert (inputBlock.getNumSamples() == (size_t) numSamples);
-
-    freqSmooth.process (freqHzHandle, numSamples);
-    qSmooth.process (qHandle, numSamples);
-    gainSmooth.process (gainHandle, numSamples);
-
-    // the filters will need to do in-place processing anyway, so let's just copy the blocks here
-    if (context.usesSeparateInputAndOutputBlocks())
-        block.copyFrom (inputBlock);
-
-    if (context.isBypassed)
-    {
-        reset();
-        return;
-    }
-
-    const auto needsFade = filterType != prevFilterType;
-    if (needsFade)
-        BufferMath::copyBufferData (block, fadeBuffer, 0, numSamples, 0, numChannels);
-
-    TupleHelpers::forEachInTuple (
-        [this, &block] (auto& filter, size_t filterIndex)
-        {
-            if ((int) filterIndex == filterType)
-            {
-                processFilterChannel (filter, block);
-            }
-            else if ((int) filterIndex == prevFilterType)
-            {
-                processFilterChannel (filter, fadeBuffer);
-                filter.reset();
-            }
-        },
-        filters);
-
-    if (needsFade)
-    {
-        for (size_t channel = 0; channel < numChannels; ++channel)
-        {
-            auto* blockPtr = block.getChannelPointer (channel);
-            fadeBuffers (blockPtr, fadeBuffer.getReadPointer ((int) channel), blockPtr, numSamples);
-        }
-    }
-
-    prevFilterType = filterType;
-}
-
 } // namespace chowdsp::EQ
diff --git a/modules/dsp/chowdsp_eq/EQ/chowdsp_EQBand.h b/modules/dsp/chowdsp_eq/EQ/chowdsp_EQBand.h
index 6daca56eb..eaf395308 100644
--- a/modules/dsp/chowdsp_eq/EQ/chowdsp_EQBand.h
+++ b/modules/dsp/chowdsp_eq/EQ/chowdsp_EQBand.h
@@ -58,11 +58,7 @@ class EQBandBase
     void reset();
 
     /** Processes an buffer of samples. */
-    void processBlock (const BufferView<FloatType>& buffer) noexcept;
-
-    /** Processes an audio context */
-    template <typename ProcessContext>
-    void process (const ProcessContext& context) noexcept;
+    void processBlock (const BufferView<FloatType>& buffer, ArenaAllocatorView arena) noexcept;
 
 private:
     template <typename FilterType, typename T = FloatType, size_t N = FilterType::Order>
@@ -93,8 +89,6 @@ class EQBandBase
 
     NumericType fs = NumericType (44100.0);
 
-    Buffer<FloatType> fadeBuffer;
-
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (EQBandBase)
 };
 
diff --git a/modules/dsp/chowdsp_eq/EQ/chowdsp_EQProcessor.cpp b/modules/dsp/chowdsp_eq/EQ/chowdsp_EQProcessor.cpp
index 656957341..265b39436 100644
--- a/modules/dsp/chowdsp_eq/EQ/chowdsp_EQProcessor.cpp
+++ b/modules/dsp/chowdsp_eq/EQ/chowdsp_EQProcessor.cpp
@@ -51,8 +51,14 @@ void EQProcessor<FloatType, numBands, EQBandType>::prepare (const juce::dsp::Pro
     for (size_t i = 0; i < numBands; ++i)
     {
         bands[i].prepare (spec);
-        bypasses[i].prepare (spec, onOffs[i]);
+        bypasses[i].prepare (spec, onOffs[i], false);
     }
+
+    const auto paddedChannelSize = Math::ceiling_divide (static_cast<size_t> (spec.maximumBlockSize), SIMDUtils::defaultSIMDAlignment) * SIMDUtils::defaultSIMDAlignment;
+    const auto requiredMemoryBytes = paddedChannelSize * sizeof (FloatType) * 3 // per-band smoothed values
+                                     + paddedChannelSize * spec.numChannels * sizeof (FloatType) * 2 // per-band fade and bypass buffers
+                                     + 32; // extra padding
+    arena.reset (requiredMemoryBytes);
 }
 
 template <typename FloatType, size_t numBands, typename EQBandType>
@@ -67,10 +73,14 @@ void EQProcessor<FloatType, numBands, EQBandType>::processBlock (const BufferVie
 {
     for (size_t i = 0; i < numBands; ++i)
     {
-        if (! bypasses[i].processBlockIn (block, onOffs[i]))
+        const auto frame = arena.create_frame();
+        if (! bypasses[i].processBlockIn (block, onOffs[i], arena))
+        {
+            bands[i].reset();
             continue;
+        }
 
-        bands[i].processBlock (block);
+        bands[i].processBlock (block, arena);
 
         bypasses[i].processBlockOut (block, onOffs[i]);
     }
diff --git a/modules/dsp/chowdsp_eq/EQ/chowdsp_EQProcessor.h b/modules/dsp/chowdsp_eq/EQ/chowdsp_EQProcessor.h
index 0c8fe17ab..a2605a3ee 100644
--- a/modules/dsp/chowdsp_eq/EQ/chowdsp_EQProcessor.h
+++ b/modules/dsp/chowdsp_eq/EQ/chowdsp_EQProcessor.h
@@ -64,6 +64,8 @@ class EQProcessor
     std::array<BypassProcessor<FloatType>, numBands> bypasses;
     std::array<bool, numBands> onOffs = { false };
 
+    ArenaAllocator<> arena;
+
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (EQProcessor)
 };
 } // namespace chowdsp::EQ
diff --git a/modules/dsp/chowdsp_filters/LowerOrderFilters/chowdsp_IIRFilter.h b/modules/dsp/chowdsp_filters/LowerOrderFilters/chowdsp_IIRFilter.h
index 9b191016a..c7594f81a 100644
--- a/modules/dsp/chowdsp_filters/LowerOrderFilters/chowdsp_IIRFilter.h
+++ b/modules/dsp/chowdsp_filters/LowerOrderFilters/chowdsp_IIRFilter.h
@@ -39,7 +39,7 @@ class IIRFilter
         if constexpr (maxChannelCount == dynamicChannelCount)
             z.resize (numChannels);
         else
-            jassert (numChannels <= maxChannelCount);
+            jassert (numChannels <= static_cast<int> (maxChannelCount));
     }
 
     /** Reset filter state */
diff --git a/modules/gui/chowdsp_visualizers/SpectrumPlots/chowdsp_EQFilterPlots.h b/modules/gui/chowdsp_visualizers/SpectrumPlots/chowdsp_EQFilterPlots.h
index 2211de965..f2b6d0184 100644
--- a/modules/gui/chowdsp_visualizers/SpectrumPlots/chowdsp_EQFilterPlots.h
+++ b/modules/gui/chowdsp_visualizers/SpectrumPlots/chowdsp_EQFilterPlots.h
@@ -273,8 +273,8 @@ struct HigherOrderLPFPlot : EQFilterPlot
 
 private:
     LPF1Plot extraPlot;
-    std::array<SecondOrderFilterPlot, size_t (order / 2)> plots;
-    static constexpr auto butterQVals = chowdsp::QValCalcs::butterworth_Qs<float, order>();
+    std::array<SecondOrderFilterPlot, size_t (order / 2)> plots {};
+    static constexpr auto butterQVals = QValCalcs::butterworth_Qs<float, order>();
 };
 
 /** Plotting helper for higher-order HPFs. */
@@ -318,7 +318,7 @@ struct HigherOrderHPFPlot : EQFilterPlot
 
 private:
     HPF1Plot extraPlot;
-    std::array<SecondOrderFilterPlot, size_t (order / 2)> plots;
-    static constexpr auto butterQVals = chowdsp::QValCalcs::butterworth_Qs<float, order>();
+    std::array<SecondOrderFilterPlot, size_t (order / 2)> plots {};
+    static constexpr auto butterQVals = QValCalcs::butterworth_Qs<float, order>();
 };
 } // namespace chowdsp::EQ
diff --git a/modules/gui/chowdsp_visualizers/SpectrumPlots/chowdsp_EqualizerPlot.cpp b/modules/gui/chowdsp_visualizers/SpectrumPlots/chowdsp_EqualizerPlot.cpp
index 99b6190c3..f121a68e5 100644
--- a/modules/gui/chowdsp_visualizers/SpectrumPlots/chowdsp_EqualizerPlot.cpp
+++ b/modules/gui/chowdsp_visualizers/SpectrumPlots/chowdsp_EqualizerPlot.cpp
@@ -2,142 +2,154 @@
 
 namespace chowdsp::EQ
 {
-EqualizerPlot::EqualizerPlot (int numBands, SpectrumPlotParams&& plotParams)
-    : SpectrumPlotBase (std::move (plotParams)),
-      filterPlots ((size_t) numBands),
-      filtersActiveFlags ((size_t) numBands, true)
+template <size_t numBands>
+EqualizerPlot<numBands>::EqualizerPlot (SpectrumPlotParams&& plotParams)
+    : SpectrumPlotBase (std::move (plotParams))
 {
+    std::fill (filtersActiveFlags.begin(), filtersActiveFlags.end(), true);
     for (auto& plot : filterPlots)
-        plot.plot = std::make_unique<EQFilterPlot>();
+        plot.plot.template emplace<EQFilterPlot>();
 }
 
-void EqualizerPlot::setFilterType (int bandIndex, EQPlotFilterType type)
+template <size_t numBands>
+void EqualizerPlot<numBands>::setFilterType (int bandIndex, EQPlotFilterType type)
 {
     auto& plot = filterPlots[(size_t) bandIndex].plot;
+    auto& plotType = filterPlots[(size_t) bandIndex].type;
+    if (plotType.has_value() && *plotType == type)
+        return;
+
+    plotType = type;
     switch (type)
     {
         case EQPlotFilterType::LPF1:
-            plot = std::make_unique<LPF1Plot>();
+            plot.template emplace<LPF1Plot>();
             break;
         case EQPlotFilterType::LPF2:
-            plot = std::make_unique<LPF2Plot>();
+            plot.template emplace<LPF2Plot>();
             break;
         case EQPlotFilterType::LPF3:
-            plot = std::make_unique<HigherOrderLPFPlot<3>>();
+            plot.template emplace<HigherOrderLPFPlot<3>>();
             break;
         case EQPlotFilterType::LPF4:
-            plot = std::make_unique<HigherOrderLPFPlot<4>>();
+            plot.template emplace<HigherOrderLPFPlot<4>>();
             break;
         case EQPlotFilterType::LPF5:
-            plot = std::make_unique<HigherOrderLPFPlot<5>>();
+            plot.template emplace<HigherOrderLPFPlot<5>>();
             break;
         case EQPlotFilterType::LPF6:
-            plot = std::make_unique<HigherOrderLPFPlot<6>>();
+            plot.template emplace<HigherOrderLPFPlot<6>>();
             break;
         case EQPlotFilterType::LPF7:
-            plot = std::make_unique<HigherOrderLPFPlot<7>>();
+            plot.template emplace<HigherOrderLPFPlot<7>>();
             break;
         case EQPlotFilterType::LPF8:
-            plot = std::make_unique<HigherOrderLPFPlot<8>>();
+            plot.template emplace<HigherOrderLPFPlot<8>>();
             break;
         case EQPlotFilterType::LPF9:
-            plot = std::make_unique<HigherOrderLPFPlot<9>>();
+            plot.template emplace<HigherOrderLPFPlot<9>>();
             break;
         case EQPlotFilterType::LPF10:
-            plot = std::make_unique<HigherOrderLPFPlot<10>>();
+            plot.template emplace<HigherOrderLPFPlot<10>>();
             break;
         case EQPlotFilterType::LPF11:
-            plot = std::make_unique<HigherOrderLPFPlot<11>>();
+            plot.template emplace<HigherOrderLPFPlot<11>>();
             break;
         case EQPlotFilterType::LPF12:
-            plot = std::make_unique<HigherOrderLPFPlot<12>>();
+            plot.template emplace<HigherOrderLPFPlot<12>>();
             break;
 
         case EQPlotFilterType::HPF1:
-            plot = std::make_unique<HPF1Plot>();
+            plot.template emplace<HPF1Plot>();
             break;
         case EQPlotFilterType::HPF2:
-            plot = std::make_unique<HPF2Plot>();
+            plot.template emplace<HPF2Plot>();
             break;
         case EQPlotFilterType::HPF3:
-            plot = std::make_unique<HigherOrderHPFPlot<3>>();
+            plot.template emplace<HigherOrderHPFPlot<3>>();
             break;
         case EQPlotFilterType::HPF4:
-            plot = std::make_unique<HigherOrderHPFPlot<4>>();
+            plot.template emplace<HigherOrderHPFPlot<4>>();
             break;
         case EQPlotFilterType::HPF5:
-            plot = std::make_unique<HigherOrderHPFPlot<5>>();
+            plot.template emplace<HigherOrderHPFPlot<5>>();
             break;
         case EQPlotFilterType::HPF6:
-            plot = std::make_unique<HigherOrderHPFPlot<6>>();
+            plot.template emplace<HigherOrderHPFPlot<6>>();
             break;
         case EQPlotFilterType::HPF7:
-            plot = std::make_unique<HigherOrderHPFPlot<7>>();
+            plot.template emplace<HigherOrderHPFPlot<7>>();
             break;
         case EQPlotFilterType::HPF8:
-            plot = std::make_unique<HigherOrderHPFPlot<8>>();
+            plot.template emplace<HigherOrderHPFPlot<8>>();
             break;
         case EQPlotFilterType::HPF9:
-            plot = std::make_unique<HigherOrderHPFPlot<9>>();
+            plot.template emplace<HigherOrderHPFPlot<9>>();
             break;
         case EQPlotFilterType::HPF10:
-            plot = std::make_unique<HigherOrderHPFPlot<10>>();
+            plot.template emplace<HigherOrderHPFPlot<10>>();
             break;
         case EQPlotFilterType::HPF11:
-            plot = std::make_unique<HigherOrderHPFPlot<11>>();
+            plot.template emplace<HigherOrderHPFPlot<11>>();
             break;
         case EQPlotFilterType::HPF12:
-            plot = std::make_unique<HigherOrderHPFPlot<12>>();
+            plot.template emplace<HigherOrderHPFPlot<12>>();
             break;
 
         case EQPlotFilterType::BPF2:
-            plot = std::make_unique<BPF2Plot>();
+            plot.template emplace<BPF2Plot>();
             break;
         case EQPlotFilterType::Bell:
-            plot = std::make_unique<BellPlot>();
+            plot.template emplace<BellPlot>();
             break;
         case EQPlotFilterType::Notch:
-            plot = std::make_unique<NotchPlot>();
+            plot.template emplace<NotchPlot>();
             break;
         case EQPlotFilterType::LowShelf:
-            plot = std::make_unique<LowShelfPlot>();
+            plot.template emplace<LowShelfPlot>();
             break;
         case EQPlotFilterType::HighShelf:
-            plot = std::make_unique<HighShelfPlot>();
+            plot.template emplace<HighShelfPlot>();
             break;
 
         default:
-            plot = std::make_unique<EQFilterPlot>();
+            plot.template emplace<EQFilterPlot>();
             break;
     }
 }
 
-void EqualizerPlot::setFilterActive (int bandIndex, bool isActive)
+template <size_t numBands>
+void EqualizerPlot<numBands>::setFilterActive (int bandIndex, bool isActive)
 {
     filtersActiveFlags[(size_t) bandIndex] = isActive;
 }
 
-bool EqualizerPlot::getFilterActive (int bandIndex) const
+template <size_t numBands>
+bool EqualizerPlot<numBands>::getFilterActive (int bandIndex) const
 {
     return filtersActiveFlags[(size_t) bandIndex];
 }
 
-void EqualizerPlot::setCutoffParameter (int bandIndex, float cutoffHz)
+template <size_t numBands>
+void EqualizerPlot<numBands>::setCutoffParameter (int bandIndex, float cutoffHz)
 {
     filterPlots[(size_t) bandIndex].plot->setCutoffFrequency (cutoffHz);
 }
 
-void EqualizerPlot::setQParameter (int bandIndex, float qValue)
+template <size_t numBands>
+void EqualizerPlot<numBands>::setQParameter (int bandIndex, float qValue)
 {
     filterPlots[(size_t) bandIndex].plot->setQValue (qValue);
 }
 
-void EqualizerPlot::setGainDBParameter (int bandIndex, float gainDB)
+template <size_t numBands>
+void EqualizerPlot<numBands>::setGainDBParameter (int bandIndex, float gainDB)
 {
     filterPlots[(size_t) bandIndex].plot->setGainDecibels (gainDB);
 }
 
-void EqualizerPlot::updateFilterPlotPath (int bandIndex)
+template <size_t numBands>
+void EqualizerPlot<numBands>::updateFilterPlotPath (int bandIndex)
 {
     const auto width = getWidth();
     if (width == 0 || getHeight() == 0)
@@ -168,7 +180,8 @@ void EqualizerPlot::updateFilterPlotPath (int bandIndex)
     repaint();
 }
 
-void EqualizerPlot::updateMasterFilterPlotPath()
+template <size_t numBands>
+void EqualizerPlot<numBands>::updateMasterFilterPlotPath()
 {
     const auto width = getWidth();
     if (width == 0 || getHeight() == 0)
@@ -184,10 +197,10 @@ void EqualizerPlot::updateMasterFilterPlotPath()
             activePlots.push_back (&filterPlot.plotData);
     }
 
-    const auto getPointForXCoord = [this, &activePlots = std::as_const (activePlots)] (int x) -> juce::Point<float>
+    const auto getPointForXCoord = [this, &currentActivePlots = std::as_const (activePlots)] (int x) -> juce::Point<float>
     {
         float magLinear = 1.0f;
-        for (auto* plotData : activePlots)
+        for (auto* plotData : currentActivePlots)
         {
             if (plotData->size() <= (size_t) x)
                 break;
@@ -204,15 +217,114 @@ void EqualizerPlot::updateMasterFilterPlotPath()
         masterFilterPlotPath.lineTo (getPointForXCoord (x));
 }
 
-void EqualizerPlot::resized()
+template <size_t numBands>
+void EqualizerPlot<numBands>::resized()
 {
     for (int i = 0; i < (int) filterPlots.size(); ++i)
         updateFilterPlotPath (i);
 }
 
-const juce::Path& EqualizerPlot::getPath (int bandIndex) const
+template <size_t numBands>
+const juce::Path& EqualizerPlot<numBands>::getPath (int bandIndex) const
 {
     jassert (juce::isPositiveAndBelow (bandIndex, (int) filterPlots.size()));
     return filterPlots[(size_t) bandIndex].plotPath;
 }
+
+//=================================================================================================
+#if JUCE_MODULE_AVAILABLE_chowdsp_plugin_state && JUCE_MODULE_AVAILABLE_chowdsp_eq
+template <size_t numBands>
+EqualizerPlotWithParameters<numBands>::EqualizerPlotWithParameters (ParameterListeners& listeners,
+                                                                    EQ::StandardEQParameters<numBands>& eqParameters,
+                                                                    const std::function<EQPlotFilterType (int)>& filterTypeMap,
+                                                                    SpectrumPlotParams&& plotParams)
+    : EqualizerPlot<numBands> (std::move (plotParams)),
+      eqParams (eqParameters)
+{
+    for (const auto [index, bandParams] : enumerate (eqParams.eqParams))
+    {
+        const auto bandIndex = (int) index;
+        callbacks +=
+            {
+                listeners.addParameterListener (
+                    bandParams.freqParam,
+                    ParameterListenerThread::MessageThread,
+                    [this, bandIndex]
+                    {
+                        updateFreqParameter (bandIndex);
+                        EqualizerPlot<numBands>::updateFilterPlotPath (bandIndex);
+                    }),
+                listeners.addParameterListener (
+                    bandParams.qParam,
+                    ParameterListenerThread::MessageThread,
+                    [this, bandIndex]
+                    {
+                        updateQParameter (bandIndex);
+                        EqualizerPlot<numBands>::updateFilterPlotPath (bandIndex);
+                    }),
+                listeners.addParameterListener (
+                    bandParams.gainParam,
+                    ParameterListenerThread::MessageThread,
+                    [this, bandIndex]
+                    {
+                        updateGainDBParameter (bandIndex);
+                        EqualizerPlot<numBands>::updateFilterPlotPath (bandIndex);
+                    }),
+                listeners.addParameterListener (
+                    bandParams.typeParam,
+                    ParameterListenerThread::MessageThread,
+                    [this, bandIndex, filterTypeMap]
+                    {
+                        updateFilterType (bandIndex, filterTypeMap);
+                        EqualizerPlot<numBands>::updateFilterPlotPath (bandIndex);
+                    }),
+                listeners.addParameterListener (
+                    bandParams.onOffParam,
+                    ParameterListenerThread::MessageThread,
+                    [this, bandIndex]
+                    {
+                        updateFilterOnOff (bandIndex);
+                        EqualizerPlot<numBands>::updateFilterPlotPath (bandIndex);
+                    })
+            };
+
+        updateFilterType (bandIndex, filterTypeMap);
+        updateFilterOnOff (bandIndex);
+    }
+}
+
+template <size_t numBands>
+void EqualizerPlotWithParameters<numBands>::updateFreqParameter (int bandIndex)
+{
+    EqualizerPlot<numBands>::setCutoffParameter (bandIndex, eqParams.eqParams[(size_t) bandIndex].freqParam->get());
+}
+
+template <size_t numBands>
+void EqualizerPlotWithParameters<numBands>::updateQParameter (int bandIndex)
+{
+    EqualizerPlot<numBands>::setQParameter (bandIndex, eqParams.eqParams[(size_t) bandIndex].qParam->get());
+}
+
+template <size_t numBands>
+void EqualizerPlotWithParameters<numBands>::updateGainDBParameter (int bandIndex)
+{
+    EqualizerPlot<numBands>::setGainDBParameter (bandIndex, eqParams.eqParams[(size_t) bandIndex].gainParam->get());
+}
+
+template <size_t numBands>
+void EqualizerPlotWithParameters<numBands>::updateFilterType (int bandIndex, const std::function<EQPlotFilterType (int)>& filterTypeMap) // NOSONAR
+{
+    const auto& bandTypeParam = eqParams.eqParams[(size_t) bandIndex].typeParam;
+    EqualizerPlot<numBands>::setFilterType (bandIndex, filterTypeMap (bandTypeParam->getIndex()));
+    updateFreqParameter (bandIndex);
+    updateQParameter (bandIndex);
+    updateGainDBParameter (bandIndex);
+}
+
+template <size_t numBands>
+void EqualizerPlotWithParameters<numBands>::updateFilterOnOff (int bandIndex)
+{
+    EqualizerPlot<numBands>::setFilterActive (bandIndex, eqParams.eqParams[(size_t) bandIndex].onOffParam->get());
+}
+#endif
 } // namespace chowdsp::EQ
diff --git a/modules/gui/chowdsp_visualizers/SpectrumPlots/chowdsp_EqualizerPlot.h b/modules/gui/chowdsp_visualizers/SpectrumPlots/chowdsp_EqualizerPlot.h
index f4a5cc363..f8f118a33 100644
--- a/modules/gui/chowdsp_visualizers/SpectrumPlots/chowdsp_EqualizerPlot.h
+++ b/modules/gui/chowdsp_visualizers/SpectrumPlots/chowdsp_EqualizerPlot.h
@@ -39,10 +39,11 @@ enum class EQPlotFilterType
 };
 
 /** UI component for plotting EQ filter frequency responses. */
+template <size_t numBands>
 class EqualizerPlot : public SpectrumPlotBase
 {
 public:
-    explicit EqualizerPlot (int numBands, SpectrumPlotParams&& params = {});
+    explicit EqualizerPlot (SpectrumPlotParams&& plotParams);
 
     /** Sets the filter type for a given band. */
     void setFilterType (int bandIndex, EQPlotFilterType type);
@@ -78,118 +79,44 @@ class EqualizerPlot : public SpectrumPlotBase
 
     struct BandPlotInfo
     {
-        std::unique_ptr<EQFilterPlot> plot;
-        juce::Path plotPath;
+        LocalPointer<EQFilterPlot, 512> plot {};
+        std::optional<EQPlotFilterType> type {};
+        juce::Path plotPath {};
         std::vector<float> plotData {};
     };
 
-    std::vector<BandPlotInfo> filterPlots;
-    juce::Path masterFilterPlotPath;
+    std::array<BandPlotInfo, numBands> filterPlots {};
+    juce::Path masterFilterPlotPath {};
 
-    std::vector<bool> filtersActiveFlags;
+    std::array<bool, numBands> filtersActiveFlags {};
 
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (EqualizerPlot)
 };
 
 #if JUCE_MODULE_AVAILABLE_chowdsp_plugin_state && JUCE_MODULE_AVAILABLE_chowdsp_eq
 template <size_t numBands>
-class EqualizerPlotWithParameters : public EqualizerPlot
+class EqualizerPlotWithParameters : public EqualizerPlot<numBands>
 {
 public:
-    EqualizerPlotWithParameters (chowdsp::ParameterListeners& listeners,
-                                 chowdsp::EQ::StandardEQParameters<numBands>& eqParameters,
+    EqualizerPlotWithParameters (ParameterListeners& listeners,
+                                 EQ::StandardEQParameters<numBands>& eqParameters,
                                  const std::function<EQPlotFilterType (int)>& filterTypeMap,
-                                 SpectrumPlotParams&& plotParams = {})
-        : EqualizerPlot (numBands, std::move (plotParams)),
-          eqParams (eqParameters)
-    {
-        for (const auto [index, bandParams] : chowdsp::enumerate (eqParams.eqParams))
-        {
-            const auto bandIndex = (int) index;
-            callbacks +=
-                {
-                    listeners.addParameterListener (
-                        bandParams.freqParam,
-                        chowdsp::ParameterListenerThread::MessageThread,
-                        [this, bandIndex]
-                        {
-                            updateFreqParameter (bandIndex);
-                            updateFilterPlotPath (bandIndex);
-                        }),
-                    listeners.addParameterListener (
-                        bandParams.qParam,
-                        chowdsp::ParameterListenerThread::MessageThread,
-                        [this, bandIndex]
-                        {
-                            updateQParameter (bandIndex);
-                            updateFilterPlotPath (bandIndex);
-                        }),
-                    listeners.addParameterListener (
-                        bandParams.gainParam,
-                        chowdsp::ParameterListenerThread::MessageThread,
-                        [this, bandIndex]
-                        {
-                            updateGainDBParameter (bandIndex);
-                            updateFilterPlotPath (bandIndex);
-                        }),
-                    listeners.addParameterListener (
-                        bandParams.typeParam,
-                        chowdsp::ParameterListenerThread::MessageThread,
-                        [this, bandIndex, filterTypeMap]
-                        {
-                            updateFilterType (bandIndex, filterTypeMap);
-                            updateFilterPlotPath (bandIndex);
-                        }),
-                    listeners.addParameterListener (
-                        bandParams.onOffParam,
-                        chowdsp::ParameterListenerThread::MessageThread,
-                        [this, bandIndex]
-                        {
-                            updateFilterOnOff (bandIndex);
-                            updateFilterPlotPath (bandIndex);
-                        })
-                };
-
-            updateFilterType (bandIndex, filterTypeMap);
-            updateFilterOnOff (bandIndex);
-        }
-    }
+                                 SpectrumPlotParams&& plotParams = {});
 
 private:
-    void updateFreqParameter (int bandIndex)
-    {
-        setCutoffParameter (bandIndex, eqParams.eqParams[(size_t) bandIndex].freqParam->get());
-    }
+    void updateFreqParameter (int bandIndex);
+    void updateQParameter (int bandIndex);
+    void updateGainDBParameter (int bandIndex);
+    void updateFilterType (int bandIndex, const std::function<EQPlotFilterType (int)>& filterTypeMap); // NOSONAR
+    void updateFilterOnOff (int bandIndex);
 
-    void updateQParameter (int bandIndex)
-    {
-        setQParameter (bandIndex, eqParams.eqParams[(size_t) bandIndex].qParam->get());
-    }
+    EQ::StandardEQParameters<numBands>& eqParams;
 
-    void updateGainDBParameter (int bandIndex)
-    {
-        setGainDBParameter (bandIndex, eqParams.eqParams[(size_t) bandIndex].gainParam->get());
-    }
-
-    void updateFilterType (int bandIndex, const std::function<EQPlotFilterType (int)>& filterTypeMap) // NOSONAR
-    {
-        const auto& bandTypeParam = eqParams.eqParams[(size_t) bandIndex].typeParam;
-        setFilterType (bandIndex, filterTypeMap (bandTypeParam->getIndex()));
-        updateFreqParameter (bandIndex);
-        updateQParameter (bandIndex);
-        updateGainDBParameter (bandIndex);
-    }
-
-    void updateFilterOnOff (int bandIndex)
-    {
-        setFilterActive (bandIndex, eqParams.eqParams[(size_t) bandIndex].onOffParam->get());
-    }
-
-    chowdsp::EQ::StandardEQParameters<numBands>& eqParams;
-
-    chowdsp::ScopedCallbackList callbacks;
+    ScopedCallbackList callbacks {};
 
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (EqualizerPlotWithParameters)
 };
 #endif
 } // namespace chowdsp::EQ
+
+#include "chowdsp_EqualizerPlot.cpp"
diff --git a/modules/gui/chowdsp_visualizers/chowdsp_visualizers.cpp b/modules/gui/chowdsp_visualizers/chowdsp_visualizers.cpp
index 11bd561a1..97f96dda4 100644
--- a/modules/gui/chowdsp_visualizers/chowdsp_visualizers.cpp
+++ b/modules/gui/chowdsp_visualizers/chowdsp_visualizers.cpp
@@ -1,7 +1,6 @@
 #include "chowdsp_visualizers.h"
 
 #include "SpectrumPlots/chowdsp_SpectrumPlotBase.cpp"
-#include "SpectrumPlots/chowdsp_EqualizerPlot.cpp"
 #include "SpectrumPlots/chowdsp_GenericFilterPlotter.cpp"
 
 #include "WaveshaperPlot/chowdsp_WaveshaperPlot.cpp"
diff --git a/tests/dsp_tests/chowdsp_dsp_utils_test/BypassTest.cpp b/tests/dsp_tests/chowdsp_dsp_utils_test/BypassTest.cpp
index 41a2007f3..2759fdba7 100644
--- a/tests/dsp_tests/chowdsp_dsp_utils_test/BypassTest.cpp
+++ b/tests/dsp_tests/chowdsp_dsp_utils_test/BypassTest.cpp
@@ -10,10 +10,20 @@ constexpr float delaySamp = 5.0f;
 } // namespace
 
 template <typename BypassType, typename FuncType>
-void processFunc (const chowdsp::BufferView<float>& buffer, BypassType& bypass, std::atomic<float>* onOffParam, FuncType&& blockFunc)
+void processFunc (const chowdsp::BufferView<float>& buffer,
+                  BypassType& bypass,
+                  std::atomic<float>* onOffParam,
+                  chowdsp::ArenaAllocatorView* arena,
+                  FuncType&& blockFunc)
 {
+    std::optional<chowdsp::ArenaAllocatorView::Frame> arena_frame;
+    if (arena != nullptr)
+        arena_frame.emplace (*arena);
+
     auto onOff = bypass.toBool (onOffParam);
-    if (! bypass.processBlockIn (buffer, onOff))
+    if (! bypass.processBlockIn (buffer,
+                                 onOff,
+                                 arena == nullptr ? std::optional<chowdsp::ArenaAllocatorView> { std::nullopt } : *arena))
         return;
 
     blockFunc (buffer);
@@ -73,59 +83,79 @@ TEST_CASE ("Bypass Test", "[dsp][misc]")
     static constexpr int bufferTestNIters = 5;
     SECTION ("Audio Buffer Test")
     {
-        chowdsp::BypassProcessor<float> bypass;
-        std::atomic<float> onOffParam { 0.0f };
-        bypass.prepare ({ fs, (juce::uint32) nSamples, 1 }, bypass.toBool (&onOffParam));
-
-        chowdsp::Buffer<float> buffer (1, bufferTestNIters * nSamples);
-        buffer.clear();
-        for (int i = 0; i < bufferTestNIters; ++i)
+        auto arena = chowdsp::ArenaAllocator<std::array<std::byte, nSamples * sizeof (float) + 32>> {};
+        auto arenaView = chowdsp::ArenaAllocatorView { arena };
+        for (auto& arenaPtr : std::vector<chowdsp::ArenaAllocatorView*> { nullptr, &arenaView })
         {
-            chowdsp::BufferView<float> subBuffer { buffer, i * nSamples, nSamples };
-            processFunc (subBuffer,
-                         bypass,
-                         &onOffParam,
-                         [] (const chowdsp::BufferView<float>& block)
-                         {
-                             for (auto [ch, data] : chowdsp::buffer_iters::channels (block))
-                                 juce::FloatVectorOperations::add (data.data(), 1.0f, data.size());
-                         });
-            onOffParam.store (1.0f - onOffParam.load());
-        }
+            chowdsp::BypassProcessor<float> bypass;
+            std::atomic<float> onOffParam { 0.0f };
+            bypass.prepare ({ fs,
+                              (juce::uint32) nSamples,
+                              1 },
+                            bypass.toBool (&onOffParam),
+                            arenaPtr == nullptr);
+
+            chowdsp::Buffer<float> buffer (1, bufferTestNIters * nSamples);
+            buffer.clear();
+            for (int i = 0; i < bufferTestNIters; ++i)
+            {
+                chowdsp::BufferView<float> subBuffer { buffer, i * nSamples, nSamples };
+                processFunc (subBuffer,
+                             bypass,
+                             &onOffParam,
+                             arenaPtr,
+                             [] (const chowdsp::BufferView<float>& block)
+                             {
+                                 for (const auto& [ch, data] : chowdsp::buffer_iters::channels (block))
+                                     juce::FloatVectorOperations::add (data.data(), 1.0f, data.size());
+                             });
+                onOffParam.store (1.0f - onOffParam.load());
+            }
 
-        checkForClicks (buffer.getReadPointer (0), bufferTestNIters * nSamples, 0.005f, "Audio Buffer has clicks!");
+            checkForClicks (buffer.getReadPointer (0), bufferTestNIters * nSamples, 0.005f, "Audio Buffer has clicks!");
+        }
     }
 
     static constexpr int delayTestNIters = 8;
     SECTION ("Audio Buffer Delay Test")
     {
-        chowdsp::BypassProcessor<float, chowdsp::DelayLineInterpolationTypes::Linear> bypass;
-        std::atomic<float> onOffParam { 0.0f };
-        bypass.prepare ({ fs, (juce::uint32) nSamples, 1 }, bypass.toBool (&onOffParam));
-        bypass.setLatencySamples (delaySamp);
-
-        chowdsp::DelayLine<float> delay { 2048 };
-        delay.prepare ({ fs, (juce::uint32) nSamples, 1 });
-        delay.setDelay (delaySamp);
-
-        chowdsp::Buffer<float> buffer (1, delayTestNIters * nSamples);
-        createPulseTrain (buffer.getWritePointer (0), delayTestNIters * nSamples, pulseSpace);
-        for (int i = 0; i < delayTestNIters; ++i)
+        auto arena = chowdsp::ArenaAllocator<std::array<std::byte, nSamples * sizeof (float) + 32>> {};
+        auto arenaView = chowdsp::ArenaAllocatorView { arena };
+        for (auto& arenaPtr : std::vector<chowdsp::ArenaAllocatorView*> { nullptr, &arenaView })
         {
-            chowdsp::BufferView<float> subBuffer { buffer, i * nSamples, nSamples };
-            processFunc (subBuffer,
-                         bypass,
-                         &onOffParam,
-                         [&] (const chowdsp::BufferView<float>& block)
-                         {
-                             delay.processBlock (block);
-                         });
-
-            if (i % 2 != 0)
-                onOffParam.store (1.0f - onOffParam.load());
-        }
-        delay.free();
+            chowdsp::BypassProcessor<float, chowdsp::DelayLineInterpolationTypes::Linear> bypass;
+            std::atomic<float> onOffParam { 0.0f };
+            bypass.prepare ({ fs,
+                              (juce::uint32) nSamples,
+                              1 },
+                            bypass.toBool (&onOffParam),
+                            arenaPtr == nullptr);
+            bypass.setLatencySamples (delaySamp);
+
+            chowdsp::DelayLine<float> delay { 2048 };
+            delay.prepare ({ fs, (juce::uint32) nSamples, 1 });
+            delay.setDelay (delaySamp);
+
+            chowdsp::Buffer<float> buffer (1, delayTestNIters * nSamples);
+            createPulseTrain (buffer.getWritePointer (0), delayTestNIters * nSamples, pulseSpace);
+            for (int i = 0; i < delayTestNIters; ++i)
+            {
+                chowdsp::BufferView<float> subBuffer { buffer, i * nSamples, nSamples };
+                processFunc (subBuffer,
+                             bypass,
+                             &onOffParam,
+                             arenaPtr,
+                             [&] (const chowdsp::BufferView<float>& block)
+                             {
+                                 delay.processBlock (block);
+                             });
+
+                if (i % 2 != 0)
+                    onOffParam.store (1.0f - onOffParam.load());
+            }
+            delay.free();
 
-        checkPulseSpacing (buffer.getReadPointer (0), delayTestNIters * nSamples, pulseSpace);
+            checkPulseSpacing (buffer.getReadPointer (0), delayTestNIters * nSamples, pulseSpace);
+        }
     }
 }