Karplus–Strong Synthesis

Introduction

In 1983 Kevin Karplus and Alex Strong published one of the most surprising recipes in all of computer music: take a short buffer filled with random noise, then repeatedly replace each sample with the average of its two neighbors, feeding the output back into the buffer. The sound that emerges is a convincing plucked guitar string — bright attack, exponentially decaying tone, harmonic richness.

The algorithm is tiny. On hardware of the era it ran in real time with fewer operations than any other physically plausible string model. Today it still appears in synthesizers, game audio engines, and digital pianos, often wrapped inside digital signal processing libraries.

What makes it remarkable is that no equation for a vibrating string was ever solved. The physics emerges from a single averaging step repeated tens of thousands of times per second. That gap between a mechanical model and a computational shortcut is one of the deepest ideas in DSP.

Try It

Adjust the string length (which sets the pitch) and the blend factor (which controls how quickly energy decays), then press Pluck. The waveform display shows the delay-line buffer evolving in real time — watch the initial noise smooth into a periodic wave.

<!-- Karplus-Strong demo: noise burst -> averaging delay loop -> plucked string sound -->
<div class="controls">
  <label>
    <span class="lbl">String length</span>
    <input type="range" id="length" min="20" max="200" value="80" />
    <span id="length-val" class="val">80</span>
  </label>
  <label>
    <span class="lbl">Blend factor</span>
    <input type="range" id="blend" min="90" max="99" value="96" />
    <span id="blend-val" class="val">0.96</span>
  </label>
</div>
<canvas id="wave" width="480" height="140" title="Delay-line buffer waveform"></canvas>
<div class="status" id="status">Ready. Press Pluck to synthesize a string.</div>
<div class="btns">
  <button id="pluck" type="button">Pluck</button>
  <button id="stop" type="button" class="ghost">Stop</button>
</div>
<p class="hint">Longer buffer = lower pitch. Blend closer to 1 = longer sustain. The waveform shows the delay-line buffer: noise at first, then a clean periodic wave.</p>

/* layout and theme */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; background: #fff; }
.controls { display: flex; flex-direction: column; gap: .6rem; margin-bottom: .8rem; }
label { display: flex; align-items: center; gap: .5rem; font-size: .9rem; }
.lbl { min-width: 7rem; font-weight: 600; color: #1d3557; }
.val { min-width: 2.8rem; font-variant-numeric: tabular-nums; color: #444; }
input[type=range] { flex: 1; accent-color: #1d3557; cursor: pointer; }
canvas { display: block; width: 100%; border-radius: 10px; background: #eef2f6; margin-bottom: .6rem; }
.status { font-size: 1rem; font-weight: 600; min-height: 1.4em; margin-bottom: .4rem; color: #555; }
.status.playing { color: #0a7d33; }
.status.stopped { color: #1d3557; }
.btns { display: flex; gap: .5rem; margin-bottom: .8rem; }
button { font: 600 14px system-ui, sans-serif; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
.hint { font-size: .85rem; color: #555; margin: 0; line-height: 1.5; }

/* Karplus-Strong algorithm: fill buffer with white noise, then each step replaces buffer[pos] with blend * average(buffer[pos], buffer[pos+1]) */
const i18nFmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));

/* audio and animation state */
let audioCtx = null;
let scriptNode = null;
let buffer = null;
let bufPos = 0;
let blend = 0.96;
let bufLen = 80;
let animId = null;
let playing = false;

const canvas = document.getElementById('wave');
const ctx2d = canvas.getContext('2d');
const W = canvas.width;
const H = canvas.height;

/* sync slider labels */
const lenSlider = document.getElementById('length');
const blendSlider = document.getElementById('blend');
const lenVal = document.getElementById('length-val');
const blendVal = document.getElementById('blend-val');

lenSlider.addEventListener('input', () => {
  bufLen = parseInt(lenSlider.value);
  lenVal.textContent = bufLen;
});
blendSlider.addEventListener('input', () => {
  blend = parseInt(blendSlider.value) / 100;
  blendVal.textContent = blend.toFixed(2);
});

/* draw the delay-line buffer onto the canvas */
function drawBuffer(buf) {
  ctx2d.clearRect(0, 0, W, H);
  ctx2d.beginPath();
  for (let i = 0; i < buf.length; i++) {
    const x = (i / buf.length) * W;
    const y = H / 2 - buf[i] * (H / 2 - 8);
    if (i === 0) ctx2d.moveTo(x, y); else ctx2d.lineTo(x, y);
  }
  ctx2d.strokeStyle = '#1d3557';
  ctx2d.lineWidth = 1.8;
  ctx2d.stroke();
}

/* pluck the string — reset buffer with noise and start audio */
function pluck() {
  stop();
  bufLen = parseInt(lenSlider.value);
  blend = parseInt(blendSlider.value) / 100;

  /* fill buffer with white noise (the initial excitation) */
  buffer = new Float32Array(bufLen);
  for (let i = 0; i < bufLen; i++) buffer[i] = Math.random() * 2 - 1;
  bufPos = 0;

  audioCtx = new (window.AudioContext || window.webkitAudioContext)();
  const SR = audioCtx.sampleRate;

  scriptNode = audioCtx.createScriptProcessor(256, 0, 1);
  scriptNode.onaudioprocess = (e) => {
    const out = e.outputBuffer.getChannelData(0);
    for (let i = 0; i < out.length; i++) {
      /* Karplus-Strong averaging step: new sample = blend * 0.5 * (current + next) */
      const cur = buffer[bufPos];
      const next = buffer[(bufPos + 1) % bufLen];
      const avg = blend * 0.5 * (cur + next);
      buffer[bufPos] = avg;
      out[i] = avg;
      bufPos = (bufPos + 1) % bufLen;
    }
  };
  scriptNode.connect(audioCtx.destination);
  playing = true;
  setStatus('Playing — watch the waveform evolve.', 'playing');

  /* animation loop: redraw buffer every frame while playing */
  function frame() {
    if (!playing) return;
    drawBuffer(buffer);
    animId = requestAnimationFrame(frame);
  }
  animId = requestAnimationFrame(frame);
}

function stop() {
  playing = false;
  if (animId) { cancelAnimationFrame(animId); animId = null; }
  if (scriptNode) { scriptNode.disconnect(); scriptNode = null; }
  if (audioCtx) { audioCtx.close(); audioCtx = null; }
  setStatus('Stopped.', 'stopped');
  if (buffer) drawBuffer(buffer);
}

function setStatus(t, cls) {
  const s = document.getElementById('status');
  s.textContent = t;
  s.className = 'status ' + cls;
}

document.getElementById('pluck').addEventListener('click', pluck);
document.getElementById('stop').addEventListener('click', stop);

/* draw the initial flat buffer on load */
buffer = new Float32Array(bufLen).fill(0);
drawBuffer(buffer);

<!-- Karplus-Strong demo: noise burst -> averaging delay loop -> plucked string sound -->
<div class="controls">
  <label>
    <span class="lbl">String length</span>
    <input type="range" id="length" min="20" max="200" value="80" />
    <span id="length-val" class="val">80</span>
  </label>
  <label>
    <span class="lbl">Blend factor</span>
    <input type="range" id="blend" min="90" max="99" value="96" />
    <span id="blend-val" class="val">0.96</span>
  </label>
</div>
<canvas id="wave" width="480" height="140" title="Delay-line buffer waveform"></canvas>
<div class="status" id="status">Ready. Press Pluck to synthesize a string.</div>
<div class="btns">
  <button id="pluck" type="button">Pluck</button>
  <button id="stop" type="button" class="ghost">Stop</button>
</div>
<p class="hint">Longer buffer = lower pitch. Blend closer to 1 = longer sustain. The waveform shows the delay-line buffer: noise at first, then a clean periodic wave.</p>

/* layout and theme */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; background: #fff; }
.controls { display: flex; flex-direction: column; gap: .6rem; margin-bottom: .8rem; }
label { display: flex; align-items: center; gap: .5rem; font-size: .9rem; }
.lbl { min-width: 7rem; font-weight: 600; color: #1d3557; }
.val { min-width: 2.8rem; font-variant-numeric: tabular-nums; color: #444; }
input[type=range] { flex: 1; accent-color: #1d3557; cursor: pointer; }
canvas { display: block; width: 100%; border-radius: 10px; background: #eef2f6; margin-bottom: .6rem; }
.status { font-size: 1rem; font-weight: 600; min-height: 1.4em; margin-bottom: .4rem; color: #555; }
.status.playing { color: #0a7d33; }
.status.stopped { color: #1d3557; }
.btns { display: flex; gap: .5rem; margin-bottom: .8rem; }
button { font: 600 14px system-ui, sans-serif; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
.hint { font-size: .85rem; color: #555; margin: 0; line-height: 1.5; }

/* Karplus-Strong algorithm: fill buffer with white noise, then each step replaces buffer[pos] with blend * average(buffer[pos], buffer[pos+1]) */
const i18nFmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));

/* audio and animation state */
let audioCtx = null;
let scriptNode = null;
let buffer = null;
let bufPos = 0;
let blend = 0.96;
let bufLen = 80;
let animId = null;
let playing = false;

const canvas = document.getElementById('wave');
const ctx2d = canvas.getContext('2d');
const W = canvas.width;
const H = canvas.height;

/* sync slider labels */
const lenSlider = document.getElementById('length');
const blendSlider = document.getElementById('blend');
const lenVal = document.getElementById('length-val');
const blendVal = document.getElementById('blend-val');

lenSlider.addEventListener('input', () => {
  bufLen = parseInt(lenSlider.value);
  lenVal.textContent = bufLen;
});
blendSlider.addEventListener('input', () => {
  blend = parseInt(blendSlider.value) / 100;
  blendVal.textContent = blend.toFixed(2);
});

/* draw the delay-line buffer onto the canvas */
function drawBuffer(buf) {
  ctx2d.clearRect(0, 0, W, H);
  ctx2d.beginPath();
  for (let i = 0; i < buf.length; i++) {
    const x = (i / buf.length) * W;
    const y = H / 2 - buf[i] * (H / 2 - 8);
    if (i === 0) ctx2d.moveTo(x, y); else ctx2d.lineTo(x, y);
  }
  ctx2d.strokeStyle = '#1d3557';
  ctx2d.lineWidth = 1.8;
  ctx2d.stroke();
}

/* pluck the string — reset buffer with noise and start audio */
function pluck() {
  stop();
  bufLen = parseInt(lenSlider.value);
  blend = parseInt(blendSlider.value) / 100;

  /* fill buffer with white noise (the initial excitation) */
  buffer = new Float32Array(bufLen);
  for (let i = 0; i < bufLen; i++) buffer[i] = Math.random() * 2 - 1;
  bufPos = 0;

  audioCtx = new (window.AudioContext || window.webkitAudioContext)();
  const SR = audioCtx.sampleRate;

  scriptNode = audioCtx.createScriptProcessor(256, 0, 1);
  scriptNode.onaudioprocess = (e) => {
    const out = e.outputBuffer.getChannelData(0);
    for (let i = 0; i < out.length; i++) {
      /* Karplus-Strong averaging step: new sample = blend * 0.5 * (current + next) */
      const cur = buffer[bufPos];
      const next = buffer[(bufPos + 1) % bufLen];
      const avg = blend * 0.5 * (cur + next);
      buffer[bufPos] = avg;
      out[i] = avg;
      bufPos = (bufPos + 1) % bufLen;
    }
  };
  scriptNode.connect(audioCtx.destination);
  playing = true;
  setStatus('Playing — watch the waveform evolve.', 'playing');

  /* animation loop: redraw buffer every frame while playing */
  function frame() {
    if (!playing) return;
    drawBuffer(buffer);
    animId = requestAnimationFrame(frame);
  }
  animId = requestAnimationFrame(frame);
}

function stop() {
  playing = false;
  if (animId) { cancelAnimationFrame(animId); animId = null; }
  if (scriptNode) { scriptNode.disconnect(); scriptNode = null; }
  if (audioCtx) { audioCtx.close(); audioCtx = null; }
  setStatus('Stopped.', 'stopped');
  if (buffer) drawBuffer(buffer);
}

function setStatus(t, cls) {
  const s = document.getElementById('status');
  s.textContent = t;
  s.className = 'status ' + cls;
}

document.getElementById('pluck').addEventListener('click', pluck);
document.getElementById('stop').addEventListener('click', stop);

/* draw the initial flat buffer on load */
buffer = new Float32Array(bufLen).fill(0);
drawBuffer(buffer);

Result

Console

Notice how a longer buffer gives a lower pitch (more samples per cycle = lower frequency), and a blend factor closer to 1 makes the string ring longer. The math behind both observations is captured in a single averaging formula: $y[n] = b \cdot \frac{x[n] + x[n-1]}{2}$ , where $b$ is the blend factor and the buffer length $N$ sets the fundamental frequency $f = f_s / N$ .

How It Really Works

The algorithm looks like a trick, but it rests on two well-understood signal-processing structures.

The delay line is a comb filter. A buffer of length $N$ samples fed back to its own input creates resonances at multiples of $f_s / N$ — exactly the harmonic series of a vibrating string of that length.

The averaging step is a low-pass filter. Replacing each sample with $\frac{x[n] + x[n-1]}{2}$ is a two-tap FIR filter with frequency response $|H(e^{j\omega})| = |\cos(\omega/2)|$ . It attenuates high frequencies more than low ones, so each pass around the loop damps the upper harmonics — mimicking the way a real string loses energy faster at its higher modes.

The combination — comb filter + gentle low-pass inside the loop — is a first-order approximation to the wave equation of a plucked string. The blend factor $b$ controls how much energy survives each loop: a value below 1 makes the string decay; the decay time $\tau$ in seconds satisfies $\tau \approx -N / (f_s \ln b)$ .

Extended Karplus–Strong (Jaffe & Smith, 1983) adds a fractional-delay filter so the pitch can be tuned continuously rather than in steps of one sample, and a tuning allpass filter to hit exact frequencies. Modern physical modeling synthesizers build on these ideas but add far more: body resonance, bridge impedance, pick position, and sympathetic string vibrations.

Where It Matters

Karplus–Strong seeded an entire branch of music technology:

Physical modeling synthesis: the insight that a feedback loop can approximate a resonating body led directly to waveguide synthesis (Julius O. Smith III, Stanford CCRMA), the engine inside the Yamaha VL1 and many modern softsynths.
Digital pianos and guitars: instruments like the Korg Prophecy and Roland V-Guitar use waveguide models descended from Karplus–Strong to model string stiffness, hammer impact, and body resonance.
Game and film audio: real-time string plucks, pizzicato layers, and harp glissandi in game engines are often implemented with delay-line synthesis because it costs a handful of multiply-add operations per sample.
DSP education: the algorithm is so compact — a ring buffer and one multiply — that it is a standard first example in courses on digital audio, alongside the fast Fourier transform.

The deeper legacy is conceptual: Karplus–Strong showed that computational shortcuts can replace physical equations when the structure of the shortcut matches the structure of the physics. That principle drives model-based compression, neural vocoders, and learned physics simulators today.

Conclusion

Karplus–Strong synthesis earns its place among the most elegant algorithms ever discovered: fill a buffer with noise, average neighbors in a loop, and physics does the rest. No differential equation is solved; no string is simulated explicitly. The wave equation falls out as an emergent property of a two-line recurrence.

The algorithm was published in 1983, runs efficiently on any modern device, and still sounds convincingly like a plucked string. Its conceptual lesson — that the right computational structure can embody physical behavior without modeling it — remains as fertile as ever, echoed in neural networks that learn to generate speech and images by learning the structure of data rather than the equations that created it.

Comments

Loading comments...

https://www.kipuhub.com/en/article/karplus-strong/Content licensed under CC BY-NC 4.0.

Cookies & privacy

How a burst of noise becomes music