Circular Echoes: Ring Buffers in Sound

Watch a ring buffer fill with audio samples: [0.2, 0.5, 0.3, _, _], then [0.2, 0.5, 0.3, 0.8, _], then [0.2, 0.5, 0.3, 0.8, 0.1]. Now it’s full. The next sample overwrites the oldest: [0.4, 0.5, 0.3, 0.8, 0.1], with the write head circling back to position 0. This elegant circular motion—no shifting, no malloc, no gaps—is why ring buffers became the foundation of every audio system.

When you’re generating soundscapes that must flow without interruption, you need a data structure that matches the circular nature of sound itself. Audio doesn’t wait for memory allocation.

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_delay(self: *RingBuffer, delay: usize) f32 {
        const pos = (self.head + self.data.len - delay) % self.data.len;
        return self.data[pos];
    }
};

Zig’s zero-cost abstractions make the modulo operation disappear at compile time when the buffer size is a power of two. The hardware loves this predictability.

class RingBuffer
  def initialize(size)
    @data = Array.new(size, 0.0)
    @head = 0
  end
  
  def write(sample)
    @data[@head] = sample
    @head = (@head + 1) % @data.size
  end
  
  def read_delay(delay)
    pos = (@head - delay) % @data.size
    @data[pos]
  end
end

Ruby’s version reads like the original algorithm sketched on a napkin in 1970. The % operator handles negative numbers gracefully—a detail that trips up many C implementations.

In generative composition, ring buffers become echo chambers, delay lines, and granular sample windows. They let algorithms reach back in time, creating the temporal layers that transform noise into soundscape. The buffer doesn’t just store samples; it stores the recent past, ready to be woven into the present moment.