diff --git a/Userland/Applications/Piano/Track.cpp b/Userland/Applications/Piano/Track.cpp
index b9132100de..7d006670d3 100644
--- a/Userland/Applications/Piano/Track.cpp
+++ b/Userland/Applications/Piano/Track.cpp
@@ -45,8 +45,11 @@ void Track::fill_sample(Sample& sample)
             m_keyboard_notes[i] = {};
     }
 
-    auto synthesized_sample = m_synth->process(playing_notes).get<LibDSP::Sample>();
-    auto delayed_sample = m_delay->process(synthesized_sample).get<LibDSP::Sample>();
+    auto synthesized_sample = LibDSP::Signal { FixedArray<Audio::Sample>::must_create_but_fixme_should_propagate_errors(1) };
+    m_synth->process(playing_notes, synthesized_sample);
+    auto delayed_signal = LibDSP::Signal { FixedArray<Audio::Sample>::must_create_but_fixme_should_propagate_errors(1) };
+    m_delay->process(synthesized_sample, delayed_signal);
+    auto delayed_sample = delayed_signal.get<FixedArray<Audio::Sample>>()[0];
 
     // HACK: Convert to old Piano range: 16-bit int
     delayed_sample *= NumericLimits<i16>::max();
diff --git a/Userland/Libraries/LibDSP/Effects.cpp b/Userland/Libraries/LibDSP/Effects.cpp
index b62a4b293b..bce940f4a6 100644
--- a/Userland/Libraries/LibDSP/Effects.cpp
+++ b/Userland/Libraries/LibDSP/Effects.cpp
@@ -5,6 +5,7 @@
  */
 
 #include "Effects.h"
+#include <AK/FixedArray.h>
 #include <math.h>
 
 namespace LibDSP::Effects {
@@ -32,23 +33,26 @@ void Delay::handle_delay_time_change()
     }
 }
 
-Signal Delay::process_impl(Signal const& input_signal)
+void Delay::process_impl(Signal const& input_signal, Signal& output_signal)
 {
+    // FIXME: This is allocating and needs to happen on a different thread.
     handle_delay_time_change();
 
-    Sample const& in = input_signal.get<Sample>();
-    Sample out;
-    out += in.log_multiplied(static_cast<double>(m_dry_gain));
-    out += m_delay_buffer[m_delay_index].log_multiplied(m_delay_decay);
+    auto const& samples = input_signal.get<FixedArray<Sample>>();
+    auto& output = output_signal.get<FixedArray<Sample>>();
+    for (size_t i = 0; i < output.size(); ++i) {
+        auto& out = output[i];
+        auto const& sample = samples[i];
+        out += sample.log_multiplied(static_cast<double>(m_dry_gain));
+        out += m_delay_buffer[m_delay_index].log_multiplied(m_delay_decay);
 
-    // This is also convenient for disabling the delay effect by setting the buffer size to 0
-    if (m_delay_buffer.size() >= 1)
-        m_delay_buffer[m_delay_index++] = out;
+        // This is also convenient for disabling the delay effect by setting the buffer size to 0
+        if (m_delay_buffer.size() >= 1)
+            m_delay_buffer[m_delay_index++] = out;
 
-    if (m_delay_index >= m_delay_buffer.size())
-        m_delay_index = 0;
-
-    return Signal(out);
+        if (m_delay_index >= m_delay_buffer.size())
+            m_delay_index = 0;
+    }
 }
 
 Mastering::Mastering(NonnullRefPtr<Transport> transport)
@@ -56,7 +60,7 @@ Mastering::Mastering(NonnullRefPtr<Transport> transport)
 {
 }
 
-Signal Mastering::process_impl([[maybe_unused]] Signal const& input_signal)
+void Mastering::process_impl([[maybe_unused]] Signal const& input_signal, [[maybe_unused]] Signal& output_signal)
 {
     TODO();
 }
diff --git a/Userland/Libraries/LibDSP/Effects.h b/Userland/Libraries/LibDSP/Effects.h
index 10ac20ac87..1f35bb2be3 100644
--- a/Userland/Libraries/LibDSP/Effects.h
+++ b/Userland/Libraries/LibDSP/Effects.h
@@ -20,7 +20,7 @@ public:
     Delay(NonnullRefPtr<Transport>);
 
 private:
-    virtual Signal process_impl(Signal const&) override;
+    virtual void process_impl(Signal const&, Signal&) override;
     void handle_delay_time_change();
 
     ProcessorRangeParameter m_delay_decay;
@@ -38,7 +38,7 @@ public:
     Mastering(NonnullRefPtr<Transport>);
 
 private:
-    virtual Signal process_impl(Signal const&) override;
+    virtual void process_impl(Signal const&, Signal&) override;
 };
 
 }
diff --git a/Userland/Libraries/LibDSP/Music.h b/Userland/Libraries/LibDSP/Music.h
index d4b90ca93e..e82a57b789 100644
--- a/Userland/Libraries/LibDSP/Music.h
+++ b/Userland/Libraries/LibDSP/Music.h
@@ -6,7 +6,9 @@
 
 #pragma once
 
+#include <AK/FixedArray.h>
 #include <AK/HashMap.h>
+#include <AK/Noncopyable.h>
 #include <AK/Types.h>
 #include <AK/Variant.h>
 #include <AK/Vector.h>
@@ -66,13 +68,29 @@ enum class SignalType : u8 {
     Note
 };
 
-using RollNotes = OrderedHashMap<u8, RollNote>;
+// Perfect hashing for note (MIDI) values. This just uses the note value as the hash itself.
+class PerfectNoteHashTraits : Traits<u8> {
+public:
+    static constexpr bool equals(u8 const& a, u8 const& b) { return a == b; }
+    static constexpr unsigned hash(u8 value)
+    {
+        return static_cast<unsigned>(value);
+    }
+};
 
-struct Signal : public Variant<Sample, RollNotes> {
+using RollNotes = OrderedHashMap<u8, RollNote, PerfectNoteHashTraits>;
+
+struct Signal : public Variant<FixedArray<Sample>, RollNotes> {
     using Variant::Variant;
+    AK_MAKE_NONCOPYABLE(Signal);
+
+public:
+    Signal& operator=(Signal&&) = default;
+    Signal(Signal&&) = default;
+
     ALWAYS_INLINE SignalType type() const
     {
-        if (has<Sample>())
+        if (has<FixedArray<Sample>>())
             return SignalType::Sample;
         if (has<RollNotes>())
             return SignalType::Note;
diff --git a/Userland/Libraries/LibDSP/Processor.h b/Userland/Libraries/LibDSP/Processor.h
index c9e26d830d..7df6c9f4ba 100644
--- a/Userland/Libraries/LibDSP/Processor.h
+++ b/Userland/Libraries/LibDSP/Processor.h
@@ -24,12 +24,11 @@ class Processor : public RefCounted<Processor> {
 
 public:
     virtual ~Processor() = default;
-    Signal process(Signal const& input_signal)
+    void process(Signal const& input_signal, Signal& output_signal)
     {
         VERIFY(input_signal.type() == m_input_type);
-        auto processed = process_impl(input_signal);
-        VERIFY(processed.type() == m_output_type);
-        return processed;
+        process_impl(input_signal, output_signal);
+        VERIFY(output_signal.type() == m_output_type);
     }
     SignalType input_type() const { return m_input_type; }
     SignalType output_type() const { return m_output_type; }
@@ -47,7 +46,7 @@ protected:
         , m_transport(move(transport))
     {
     }
-    virtual Signal process_impl(Signal const& input_signal) = 0;
+    virtual void process_impl(Signal const& input_signal, Signal& output_signal) = 0;
 
     NonnullRefPtr<Transport> m_transport;
     Vector<ProcessorParameter&> m_parameters;
diff --git a/Userland/Libraries/LibDSP/Synthesizers.cpp b/Userland/Libraries/LibDSP/Synthesizers.cpp
index 5cab654a2c..9dc8f4887d 100644
--- a/Userland/Libraries/LibDSP/Synthesizers.cpp
+++ b/Userland/Libraries/LibDSP/Synthesizers.cpp
@@ -31,38 +31,41 @@ Classic::Classic(NonnullRefPtr<Transport> transport)
     m_parameters.append(m_release);
 }
 
-Signal Classic::process_impl(Signal const& input_signal)
+void Classic::process_impl(Signal const& input_signal, [[maybe_unused]] Signal& output_signal)
 {
-    auto& in = input_signal.get<RollNotes>();
+    auto const& in = input_signal.get<RollNotes>();
+    auto& output_samples = output_signal.get<FixedArray<Sample>>();
 
-    Sample out;
+    // Do this for every time step and set the signal accordingly.
+    for (size_t sample_index = 0; sample_index < output_samples.size(); ++sample_index) {
+        Sample& out = output_samples[sample_index];
+        u32 sample_time = m_transport->time() + sample_index;
 
-    SinglyLinkedList<PitchedEnvelope> playing_envelopes;
+        SinglyLinkedList<PitchedEnvelope> playing_envelopes;
 
-    // "Press" the necessary notes in the internal representation,
-    // and "release" all of the others
-    for (u8 i = 0; i < note_frequencies.size(); ++i) {
-        if (auto maybe_note = in.get(i); maybe_note.has_value())
-            m_playing_notes.set(i, maybe_note.value());
+        // "Press" the necessary notes in the internal representation,
+        // and "release" all of the others
+        for (u8 i = 0; i < note_frequencies.size(); ++i) {
+            if (auto maybe_note = in.get(i); maybe_note.has_value())
+                m_playing_notes.set(i, maybe_note.value());
 
-        if (m_playing_notes.contains(i)) {
-            Envelope note_envelope = m_playing_notes.get(i)->to_envelope(m_transport->time(), m_attack * m_transport->ms_sample_rate(), m_decay * m_transport->ms_sample_rate(), m_release * m_transport->ms_sample_rate());
-            if (!note_envelope.is_active()) {
-                m_playing_notes.remove(i);
-                continue;
+            if (m_playing_notes.contains(i)) {
+                Envelope note_envelope = m_playing_notes.get(i)->to_envelope(sample_time, m_attack * m_transport->ms_sample_rate(), m_decay * m_transport->ms_sample_rate(), m_release * m_transport->ms_sample_rate());
+                if (!note_envelope.is_active()) {
+                    m_playing_notes.remove(i);
+                    continue;
+                }
+
+                playing_envelopes.append(PitchedEnvelope { note_envelope, i });
             }
+        }
 
-            playing_envelopes.append(PitchedEnvelope { note_envelope, i });
+        for (auto envelope : playing_envelopes) {
+            double volume = volume_from_envelope(envelope);
+            double wave = wave_position(envelope.note);
+            out += volume * wave;
         }
     }
-
-    for (auto envelope : playing_envelopes) {
-        double volume = volume_from_envelope(envelope);
-        double wave = wave_position(envelope.note);
-        out += volume * wave;
-    }
-
-    return out;
 }
 
 // Linear ADSR envelope with no peak adjustment.
diff --git a/Userland/Libraries/LibDSP/Synthesizers.h b/Userland/Libraries/LibDSP/Synthesizers.h
index ee74c4cf9b..9453e97f5c 100644
--- a/Userland/Libraries/LibDSP/Synthesizers.h
+++ b/Userland/Libraries/LibDSP/Synthesizers.h
@@ -47,7 +47,7 @@ public:
     Waveform wave() const { return m_waveform.value(); }
 
 private:
-    virtual Signal process_impl(Signal const&) override;
+    virtual void process_impl(Signal const&, Signal&) override;
 
     double volume_from_envelope(Envelope const&) const;
     double wave_position(u8 note);
diff --git a/Userland/Libraries/LibDSP/Track.cpp b/Userland/Libraries/LibDSP/Track.cpp
index f04b541b2a..160df426c0 100644
--- a/Userland/Libraries/LibDSP/Track.cpp
+++ b/Userland/Libraries/LibDSP/Track.cpp
@@ -4,13 +4,16 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#include <AK/FixedArray.h>
+#include <AK/NoAllocationGuard.h>
 #include <AK/Optional.h>
+#include <AK/StdLibExtras.h>
+#include <AK/TypedTransfer.h>
 #include <AK/Types.h>
+#include <LibDSP/Music.h>
 #include <LibDSP/Processor.h>
 #include <LibDSP/Track.h>
 
-using namespace std;
-
 namespace LibDSP {
 
 bool Track::add_processor(NonnullRefPtr<Processor> new_processor)
@@ -48,20 +51,43 @@ bool NoteTrack::check_processor_chain_valid() const
     return check_processor_chain_valid_with_initial_type(SignalType::Note);
 }
 
-Sample Track::current_signal()
+ErrorOr<void> Track::resize_internal_buffers_to(size_t buffer_size)
 {
+    m_secondary_sample_buffer = TRY(FixedArray<Sample>::try_create(buffer_size));
+    return {};
+}
+
+void Track::current_signal(FixedArray<Sample>& output_signal)
+{
+    // This is real-time code. We must NEVER EVER EVER allocate.
+    NoAllocationGuard guard;
+    VERIFY(output_signal.size() == m_secondary_sample_buffer.get<FixedArray<Sample>>().size());
+
     compute_current_clips_signal();
-    Optional<Signal> the_signal;
+    Signal* source_signal = &m_current_signal;
+    // This provides an audio buffer of the right size. It is not allocated here, but whenever we are informed about a buffer size change.
+    Signal* target_signal = &m_secondary_sample_buffer;
 
     for (auto& processor : m_processor_chain) {
-        the_signal = processor.process(the_signal.value_or(m_current_signal));
+        // Depending on what the processor needs to have as output, we need to place either a pre-allocated note hash map or a pre-allocated sample buffer in the target signal.
+        if (processor.output_type() == SignalType::Note)
+            target_signal = &m_secondary_note_buffer;
+        else
+            target_signal = &m_secondary_sample_buffer;
+        processor.process(*source_signal, *target_signal);
+        swap(source_signal, target_signal);
     }
-    VERIFY(the_signal.has_value() && the_signal->type() == SignalType::Sample);
-    return the_signal->get<Sample>();
+    VERIFY(source_signal->type() == SignalType::Sample);
+    VERIFY(output_signal.size() == source_signal->get<FixedArray<Sample>>().size());
+    // This is one final unavoidable memcopy. Otherwise we need to special-case the last processor or
+    AK::TypedTransfer<Sample>::copy(output_signal.data(), source_signal->get<FixedArray<Sample>>().data(), output_signal.size());
 }
 
 void NoteTrack::compute_current_clips_signal()
 {
+    // Consider the entire time duration.
+    TODO();
+
     u32 time = m_transport->time();
     // Find the currently playing clip.
     NoteClip* playing_clip = nullptr;
@@ -91,22 +117,8 @@ void NoteTrack::compute_current_clips_signal()
 
 void AudioTrack::compute_current_clips_signal()
 {
-    // Find the currently playing clip.
-    u32 time = m_transport->time();
-    AudioClip* playing_clip = nullptr;
-    for (auto& clip : m_clips) {
-        if (clip.start() <= time && clip.end() >= time) {
-            playing_clip = &clip;
-            break;
-        }
-    }
-    if (playing_clip == nullptr) {
-        m_current_signal = Signal(static_cast<Sample const&>(SAMPLE_OFF));
-    }
-
-    // Index into the clip's samples.
-    u32 effective_sample = time - playing_clip->start();
-    m_current_signal = Signal(playing_clip->sample_at(effective_sample));
+    // This is quite involved as we need to look at multiple clips and take looping into account.
+    TODO();
 }
 
 }
diff --git a/Userland/Libraries/LibDSP/Track.h b/Userland/Libraries/LibDSP/Track.h
index d3af5b7abc..f7a484e175 100644
--- a/Userland/Libraries/LibDSP/Track.h
+++ b/Userland/Libraries/LibDSP/Track.h
@@ -23,8 +23,11 @@ public:
     virtual bool check_processor_chain_valid() const = 0;
     bool add_processor(NonnullRefPtr<Processor> new_processor);
 
-    // Creates the current signal of the track by processing current note or audio data through the processing chain
-    Sample current_signal();
+    // Creates the current signal of the track by processing current note or audio data through the processing chain.
+    void current_signal(FixedArray<Sample>& output_signal);
+
+    // We are informed of an audio buffer size change. This happens off-audio-thread so we can allocate.
+    ErrorOr<void> resize_internal_buffers_to(size_t buffer_size);
 
     NonnullRefPtrVector<Processor> const& processor_chain() const { return m_processor_chain; }
     NonnullRefPtr<Transport const> transport() const { return m_transport; }
@@ -42,7 +45,13 @@ protected:
     NonnullRefPtrVector<Processor> m_processor_chain;
     NonnullRefPtr<Transport> m_transport;
     // The current signal is stored here, to prevent unnecessary reallocation.
-    Signal m_current_signal { Audio::Sample {} };
+    Signal m_current_signal { FixedArray<Sample> {} };
+
+    // These are so that we don't have to allocate a secondary buffer in current_signal().
+    // A sample buffer possibly used by the processor chain.
+    Signal m_secondary_sample_buffer { FixedArray<Sample> {} };
+    // A note buffer possibly used by the processor chain.
+    Signal m_secondary_note_buffer { RollNotes {} };
 };
 
 class NoteTrack final : public Track {