Echoes in Digital Memory: Ring Buffers

Picture this: you’re crafting an ambient soundscape and want to add a subtle 0.3-second delay that feeds back into itself, creating those haunting echo chambers that transform simple tones into infinite sonic landscapes. Behind every such effect lies one of computing’s most elegant solutions—the circular buffer.

This deceptively simple data structure emerged in the 1970s as engineers grappled with real-time systems that couldn’t afford to pause, allocate memory, or shuffle data around. Audio was the perfect proving ground: samples arrive at 44,100 per second whether your computer is ready or not.

const RingBuffer = struct {
    data: [1024]f32,
    head: usize = 0,
    
    fn write(self: *RingBuffer, sample: f32) void {
        self.data[self.head] = sample;
        self.head = (self.head + 1) % self.data.len;
    }
    
    fn read_delayed(self: *RingBuffer, delay_samples: usize) f32 {
        const read_pos = (self.head + self.data.len - delay_samples) % self.data.len;
        return self.data[read_pos];
    }
};

Zig’s approach feels like handling raw audio hardware—explicit, fast, and unforgiving of mistakes. That modulo operation is doing all the magic, wrapping the write position back to zero when it hits the buffer’s end.

class AudioDelay
  def initialize(delay_ms, sample_rate = 44100)
    @buffer = Array.new((delay_ms * sample_rate / 1000).to_i, 0.0)
    @position = 0
  end
  
  def process(input)
    delayed = @buffer[@position]
    @buffer[@position] = input + (delayed * 0.6)  # feedback
    @position = (@position + 1) % @buffer.size
    input + delayed
  end
end

Ruby’s version reads like the creative intent: “take the current sample, mix it with its echo from the past, and send both forward.” The circular buffer becomes invisible, just a container for time itself.

This is why circular buffers matter beyond audio—they turn time into space, letting us peek backwards through our data stream without the costly dance of shifting arrays around. Every reverb plugin, every network packet buffer, every real-time system owes its responsiveness to this humble circle.