Advanced

Tutor model

i62 💰:9.4

i52 💰:7.9

🏆 i67 💰:62.5

i70 💰:125.0

i68 💰:125.0

🏆 i66 💰:75.0

i65 💰:125.0

i63 💰:62.5

i61 💰:75.0

i60 💰:9.4

i60 💰:37.5

i58 💰:62.5

i57 💰:22.5

i57 💰:37.5

i56 💰:45.0

⚡ i55 💰:11.25

i55 💰:37.5

i54 💰:62.5

i52 💰:35.0

i51 💰:37.5

i49 💰:15.0

i49 💰:62.5

i48 💰:11.3

i47 💰:7.5

i44 💰:25.0

i43 💰:37.5

i42 💰:187.5

i40 💰:5.0

i39 💰:100.0

i38 💰:37.5

i37 💰:11.0

i36 💰:187.5

i34 💰:12.5

i33 💰:37.5

i30 💰:1.0

i29 💰:1.5

i28 💰:150.0

i23 💰:20.0

i20 💰:4.0

i18 💰:1.0

i16 💰:25.0

i13 💰:1.5

Keep session private

What would you like to learn?

Override for the tutor's lesson content generation calls. Auto uses the system default (Claude Sonnet 5 for lesson text, Opus 5 for diagrams).

Lesson generation model

System default

i58 💰:18.8

i31 💰:11.0

i25 💰:31.3

Tutoring abilities

In a standard keyboard synthesizer, every wire is hidden and pre-soldered inside the chassis. But what happens when you sever those internal connections and decide every single wire routing yourself?

In the 1960s, pioneers Bob Moog and Don Buchla independently realized that electrical voltages could automate parameters like pitch, volume, and timbre in real time, giving birth to **modular synthesis** driven by **control voltage (CV)**.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, sans-serif;
      background: #f8f9fa;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      padding: 12px;
      min-height: 100%;
      user-select: none;
    }

    .main-grid {
      display: grid;
      grid-template-columns: 1fr;
      gap: 12px;
      width: 100%;
      max-width: 580px;
    }

    .rack-container {
      position: relative;
      background: #ffffff;
      border: 2px solid #e2e8f0;
      border-radius: 12px;
      padding: 16px 12px;
      display: flex;
      flex-direction: column;
      gap: 18px;
    }

    .signal-legend {
      display: flex;
      justify-content: space-between;
      align-items: center;
      font-size: 13px;
      font-weight: 700;
      padding: 0 4px;
    }

    .legend-tag {
      display: flex;
      align-items: center;
      gap: 6px;
    }

    .legend-line-audio {
      width: 22px;
      height: 4px;
      background: #22b7ff;
      border-radius: 2px;
    }

    .legend-line-cv {
      width: 22px;
      height: 4px;
      background: #f59e0b;
      border-radius: 2px;
      border: 1px dashed #b45309;
    }

    /* Modules row */
    .modules-row {
      display: grid;
      grid-template-columns: repeat(3, 1fr);
      gap: 10px;
      position: relative;
      z-index: 2;
    }

    .module-card {
      background: #f8fafc;
      border: 2px solid #e2e8f0;
      border-radius: 10px;
      padding: 10px 6px;
      text-align: center;
      cursor: pointer;
      transition: all 0.25s ease;
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 6px;
    }

    .module-card:hover {
      border-color: #cbd5e1;
    }

    .module-card.active {
      border-color: #f59e0b;
      background: #fffbeb;
      box-shadow: 0 0 0 3px rgba(245, 158, 11, 0.2);
    }

    .mod-title {
      font-size: 14px;
      font-weight: 800;
      letter-spacing: -0.2px;
    }

    .mod-sub {
      font-size: 12px;
      font-weight: 600;
      color: #64748b;
    }

    .jack-port {
      width: 20px;
      height: 20px;
      border-radius: 50%;
      background: #1e2945;
      border: 3px solid #94a3b8;
      box-shadow: inset 0 2px 4px rgba(0,0,0,0.5);
      position: relative;
    }

    .module-card.active .jack-port {
      border-color: #f59e0b;
      background: #78350f;
    }

    /* Bottom section: CV Source & Visualizer */
    .lower-row {
      display: grid;
      grid-template-columns: 1fr 1.3fr;
      gap: 10px;
      align-items: center;
      position: relative;
      z-index: 2;
    }

    .cv-source {
      background: #f8fafc;
      border: 2px solid #e2e8f0;
      border-radius: 10px;
      padding: 10px;
      display: flex;
      align-items: center;
      justify-content: space-between;
    }

    .scope-box {
      background: #0f172a;
      border-radius: 10px;
      height: 64px;
      position: relative;
      overflow: hidden;
      display: flex;
      align-items: center;
      justify-content: center;
      border: 2px solid #334155;
    }

    canvas {
      width: 100%;
      height: 100%;
    }

    /* SVG Cable Overlay */
    .cables-svg {
      position: absolute;
      top: 0;
      left: 0;
      width: 100%;
      height: 100%;
      pointer-events: none;
      z-index: 1;
    }

    .controls-bar {
      display: flex;
      justify-content: space-between;
      align-items: center;
      width: 100%;
      max-width: 580px;
      padding: 0 4px;
    }

    .btn-audio {
      background: #22b7ff;
      color: #ffffff;
      border: none;
      border-radius: 8px;
      padding: 8px 16px;
      font-size: 13px;
      font-weight: 700;
      cursor: pointer;
      display: flex;
      align-items: center;
      gap: 6px;
      transition: background 0.2s ease;
    }

    .btn-audio:hover {
      background: #009be5;
    }

    .btn-audio.playing {
      background: #e11d48;
    }

    .status-text {
      font-size: 13px;
      font-weight: 700;
      color: #64748b;
    }
  </style>
</head>
<body>

  <div class="main-grid">
    <div class="signal-legend">
      <div class="legend-tag">
        <div class="legend-line-audio"></div>
        <span>Audio Path</span>
      </div>
      <div class="legend-tag">
        <div class="legend-line-cv"></div>
        <span>Control Voltage (CV)</span>
      </div>
    </div>

    <div class="rack-container" id="rack">
      <svg class="cables-svg" id="cableSvg"></svg>

      
      <div class="modules-row">
        <div class="module-card active" data-mod="pitch" id="modVco">
          <div class="jack-port" id="jackVco"></div>
          <div class="mod-title">Pitch</div>
          <div class="mod-sub">VCO</div>
        </div>

        <div class="module-card" data-mod="filter" id="modVcf">
          <div class="jack-port" id="jackVcf"></div>
          <div class="mod-title">Timbre</div>
          <div class="mod-sub">VCF</div>
        </div>

        <div class="module-card" data-mod="amp" id="modVca">
          <div class="jack-port" id="jackVca"></div>
          <div class="mod-title">Volume</div>
          <div class="mod-sub">VCA</div>
        </div>
      </div>

      
      <div class="lower-row">
        <div class="cv-source">
          <div>
            <div class="mod-title" style="font-size: 13px;">CV Source</div>
            <div class="mod-sub">LFO / Env</div>
          </div>
          <div class="jack-port" id="jackCv" style="border-color: #f59e0b;"></div>
        </div>

        <div class="scope-box">
          <canvas id="scopeCanvas" width="260" height="64"></canvas>
        </div>
      </div>
    </div>
  </div>

  <div class="controls-bar">
    <button class="btn-audio" id="btnAudio">Audition 🔊</button>
    <div class="status-text" id="statusLabel">CV → Pitch</div>
  </div>

  <script>
    let activeTarget = 'pitch';
    let isAudioPlaying = false;
    let audioCtx = null;
    let osc = null, filter = null, gainNode = null, lfo = null, lfoGain = null;

    const cards = document.querySelectorAll('.module-card');
    const statusLabel = document.getElementById('statusLabel');
    const btnAudio = document.getElementById('btnAudio');
    const svg = document.getElementById('cableSvg');
    const canvas = document.getElementById('scopeCanvas');
    const ctx = canvas.getContext('2d');

    function updatePatch(target) {
      activeTarget = target;
      cards.forEach(c => c.classList.toggle('active', c.dataset.mod === target));
      
      const labels = {
        pitch: 'CV → Pitch (VCO)',
        filter: 'CV → Timbre (VCF)',
        amp: 'CV → Volume (VCA)'
      };
      statusLabel.textContent = labels[target];
      drawCables();
      updateAudioParams();
    }

    cards.forEach(card => {
      card.addEventListener('click', () => updatePatch(card.dataset.mod));
    });

    function getCenter(elem, relativeTo) {
      const eBox = elem.getBoundingClientRect();
      const rBox = relativeTo.getBoundingClientRect();
      return {
        x: (eBox.left + eBox.right) / 2 - rBox.left,
        y: (eBox.top + eBox.bottom) / 2 - rBox.top
      };
    }

    function drawCables() {
      const rack = document.getElementById('rack');
      const cvJack = document.getElementById('jackCv');
      const targetJack = activeTarget === 'pitch' ? document.getElementById('jackVco') :
                         activeTarget === 'filter' ? document.getElementById('jackVcf') :
                         document.getElementById('jackVca');

      const vcoJack = document.getElementById('jackVco');
      const vcfJack = document.getElementById('jackVcf');
      const vcaJack = document.getElementById('jackVca');

      const pCV = getCenter(cvJack, rack);
      const pTgt = getCenter(targetJack, rack);
      const pVCO = getCenter(vcoJack, rack);
      const pVCF = getCenter(vcfJack, rack);
      const pVCA = getCenter(vcaJack, rack);

      // Audio path (Fixed Blue line linking VCO -> VCF -> VCA)
      const audioPathD = `M ${pVCO.x} ${pVCO.y + 22} L ${pVCF.x} ${pVCF.y + 22} L ${pVCA.x} ${pVCA.y + 22}`;

      // CV Path (Drooping amber cable)
      const midX = (pCV.x + pTgt.x) / 2;
      const midY = (pCV.y + pTgt.y) / 2 + 35;
      const cvPathD = `M ${pCV.x} ${pCV.y} Q ${midX} ${midY} ${pTgt.x} ${pTgt.y}`;

      svg.innerHTML = `
        <path d="${audioPathD}" fill="none" stroke="#22b7ff" stroke-width="4" stroke-linecap="round"/>
        
        <path d="${cvPathD}" fill="none" stroke="rgba(0,0,0,0.15)" stroke-width="6" stroke-linecap="round"/>
        
        <path d="${cvPathD}" fill="none" stroke="#f59e0b" stroke-width="4" stroke-dasharray="6,4" stroke-linecap="round"/>
      `;
    }

    // Canvas Visualizer Loop
    let phase = 0;
    let lfoPhase = 0;

    function renderScope() {
      ctx.clearRect(0, 0, canvas.width, canvas.height);
      
      lfoPhase += 0.05;
      const lfoVal = Math.sin(lfoPhase); // -1 to +1

      let freqMult = 1;
      let filterCutoff = 1;
      let ampMult = 1;

      if (activeTarget === 'pitch') {
        freqMult = 1 + lfoVal * 0.5; // Frequency changes
      } else if (activeTarget === 'filter') {
        filterCutoff = (lfoVal + 1.2) * 0.5; // Harmonic rounding
      } else if (activeTarget === 'amp') {
        ampMult = (lfoVal + 1.2) * 0.45; // Height changes
      }

      phase += 0.08 * freqMult;

      ctx.beginPath();
      ctx.strokeStyle = '#22b7ff';
      ctx.lineWidth = 2.5;

      for (let x = 0; x < canvas.width; x++) {
        const t = (x / canvas.width) * Math.PI * 8 * freqMult + phase;
        // Sawtooth-ish blended with Sine based on filterCutoff
        const rawWave = Math.sin(t) * filterCutoff + (Math.sin(2 * t) * 0.4 + Math.sin(3 * t) * 0.2) * (1 - filterCutoff * 0.5);
        const y = (canvas.height / 2) + rawWave * 20 * ampMult;
        
        if (x === 0) ctx.moveTo(x, y);
        else ctx.lineTo(x, y);
      }
      ctx.stroke();

      requestAnimationFrame(renderScope);
    }
    requestAnimationFrame(renderScope);

    // Audio Engine (Opt-in only)
    function initAudio() {
      if (audioCtx) return;
      audioCtx = new (window.AudioContext || window.webkitAudioContext)();

      osc = audioCtx.createOscillator();
      osc.type = 'sawtooth';
      osc.frequency.value = 130.81; // C3

      filter = audioCtx.createBiquadFilter();
      filter.type = 'lowpass';
      filter.frequency.value = 800;

      gainNode = audioCtx.createGain();
      gainNode.gain.value = 0.2;

      lfo = audioCtx.createOscillator();
      lfo.frequency.value = 2; // 2 Hz CV rate

      lfoGain = audioCtx.createGain();

      lfo.connect(lfoGain);
      osc.connect(filter);
      filter.connect(gainNode);
      gainNode.connect(audioCtx.destination);

      osc.start();
      lfo.start();
    }

    function updateAudioParams() {
      if (!audioCtx || !isAudioPlaying) return;
      const now = audioCtx.currentTime;

      // Disconnect modulation
      lfoGain.disconnect();

      // Reset base values
      osc.frequency.cancelScheduledValues(now);
      filter.frequency.cancelScheduledValues(now);
      gainNode.gain.cancelScheduledValues(now);

      osc.frequency.setValueAtTime(130.81, now);
      filter.frequency.setValueAtTime(1200, now);
      gainNode.gain.setValueAtTime(0.2, now);

      if (activeTarget === 'pitch') {
        lfoGain.gain.setValueAtTime(60, now); // Modulate pitch +/- 60Hz
        lfoGain.connect(osc.frequency);
      } else if (activeTarget === 'filter') {
        lfoGain.gain.setValueAtTime(800, now); // Modulate filter cutoff
        lfoGain.connect(filter.frequency);
      } else if (activeTarget === 'amp') {
        gainNode.gain.setValueAtTime(0.12, now);
        lfoGain.gain.setValueAtTime(0.1, now); // Modulate volume
        lfoGain.connect(gainNode.gain);
      }
    }

    btnAudio.addEventListener('click', () => {
      initAudio();
      if (!isAudioPlaying) {
        if (audioCtx.state === 'suspended') audioCtx.resume();
        isAudioPlaying = true;
        btnAudio.textContent = 'Mute 🔇';
        btnAudio.classList.add('playing');
        updateAudioParams();
      } else {
        gainNode.gain.setValueAtTime(0, audioCtx.currentTime);
        isAudioPlaying = false;
        btnAudio.textContent = 'Audition 🔊';
        btnAudio.classList.remove('playing');
      }
    });

    window.addEventListener('resize', drawCables);
    setTimeout(drawCables, 50);
  </script>
</body>
</html>

To patch effectively, how do we distinguish between electricity that makes sound and electricity that shapes it?

In modular synthesis, all signals travel as electrical voltages through $3.5\text{ mm}$ cables, strictly divided into three domains: **Audio Signals**, **Control Voltages (CV)**, and **Timing/Logic Signals**.

**Audio Signals** are bipolar alternating currents operating within human hearing range ($20\text{ Hz} - 20\text{ kHz}$, typically $\pm 5\text{V}$ or $10\text{V}_{\text{p-p}}$). **Control Voltages** are continuous DC or low-frequency signals shaping parameters (unipolar $0\text{ to }+8\text{V}/+10\text{V}$ or bipolar $\pm 5\text{V}$), while **Logic Signals** provide discrete gate and trigger events.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      background: #f8f9fa;
      color: #1e2945;
      padding: 12px;
      display: flex;
      flex-direction: column;
      gap: 10px;
      min-height: 100%;
    }

    /* Tabs */
    .tabs {
      display: flex;
      gap: 6px;
      width: 100%;
    }
    .tab-btn {
      flex: 1;
      border: 1px solid #e2e8f0;
      background: #ffffff;
      color: #64748b;
      padding: 8px 4px;
      border-radius: 8px;
      font-size: 13px;
      font-weight: 600;
      cursor: pointer;
      display: flex;
      align-items: center;
      justify-content: center;
      gap: 4px;
      transition: all 0.2s ease;
    }
    .tab-btn.active {
      background: #22b7ff;
      color: #ffffff;
      border-color: #22b7ff;
      box-shadow: 0 2px 6px rgba(34, 183, 255, 0.35);
    }

    /* Scope Screen */
    .scope-box {
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 12px;
      padding: 10px;
      position: relative;
      display: flex;
      flex-direction: column;
      gap: 6px;
    }
    .scope-header {
      display: flex;
      justify-content: space-between;
      align-items: center;
      font-size: 12px;
      font-weight: 700;
      color: #64748b;
    }
    .scope-canvas-wrap {
      position: relative;
      width: 100%;
      height: 150px;
      background: #f8fafc;
      border: 1px solid #edf2f7;
      border-radius: 8px;
      overflow: hidden;
    }
    canvas {
      width: 100%;
      height: 100%;
      display: block;
    }

    /* Info Grid */
    .info-grid {
      display: grid;
      grid-template-columns: repeat(3, 1fr);
      gap: 8px;
    }
    .info-card {
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 8px;
      padding: 8px;
      text-align: center;
    }
    .info-card .tag {
      font-size: 10px;
      font-weight: 700;
      color: #94a3b8;
      text-transform: uppercase;
      margin-bottom: 2px;
    }
    .info-card .val {
      font-size: 13px;
      font-weight: 700;
      color: #1e2945;
    }

    /* Bottom Action */
    .actions {
      display: flex;
      gap: 8px;
      align-items: center;
    }
    .sound-btn {
      flex: 1;
      background: #1e2945;
      color: #ffffff;
      border: none;
      border-radius: 8px;
      padding: 10px 14px;
      font-size: 13px;
      font-weight: 600;
      cursor: pointer;
      display: flex;
      align-items: center;
      justify-content: center;
      gap: 6px;
      transition: opacity 0.2s;
    }
    .sound-btn:active {
      opacity: 0.85;
    }
  </style>
</head>
<body>

  
  <div class="tabs">
    <button class="tab-btn active" data-type="audio">🔊 Audio</button>
    <button class="tab-btn" data-type="cv">🎛 Control (CV)</button>
    <button class="tab-btn" data-type="logic">⚡ Logic</button>
  </div>

  
  <div class="scope-box">
    <div class="scope-header">
      <span id="scopeTitle">Audio Signal (AC)</span>
      <span id="scopeTarget" style="color:#22b7ff;">→ Speaker / Audio Out</span>
    </div>
    <div class="scope-canvas-wrap">
      <canvas id="scopeCanvas" width="600" height="200"></canvas>
    </div>
  </div>

  
  <div class="info-grid">
    <div class="info-card">
      <div class="tag">Voltage</div>
      <div class="val" id="specVoltage">±5V (10Vp-p)</div>
    </div>
    <div class="info-card">
      <div class="tag">Polarity</div>
      <div class="val" id="specPolarity">Bipolar</div>
    </div>
    <div class="info-card">
      <div class="tag">Rate</div>
      <div class="val" id="specRate">20Hz – 20kHz</div>
    </div>
  </div>

  
  <div class="actions">
    <button class="sound-btn" id="listenBtn">
      <span>▶ Audition Signal</span>
    </button>
  </div>

  <script>
    const canvas = document.getElementById('scopeCanvas');
    const ctx = canvas.getContext('2d');

    const signals = {
      audio: {
        title: "Audio Signal (AC)",
        target: "→ Speaker / Output",
        voltage: "±5V (10Vp-p)",
        polarity: "Bipolar",
        rate: "20Hz – 20kHz",
        btnText: "▶ Audition Audio (440Hz)",
        type: "audio"
      },
      cv: {
        title: "Control Voltage (CV)",
        target: "→ VCF Cutoff / Pitch",
        voltage: "0 to +8V / ±5V",
        polarity: "Unipolar / Bipolar",
        rate: "< 20Hz (Sub-audio)",
        btnText: "▶ Audition Modulation (LFO)",
        type: "cv"
      },
      logic: {
        title: "Logic (Gate / Trigger)",
        target: "→ Envelope / Clock",
        voltage: "0V / +5V",
        polarity: "Unipolar (Binary)",
        rate: "Discrete Pulses",
        btnText: "▶ Audition Gate Trigger",
        type: "logic"
      }
    };

    let current = 'audio';
    let phase = 0;
    let audioCtx = null;
    let activeNodes = [];

    // Tab switcher
    document.querySelectorAll('.tab-btn').forEach(btn => {
      btn.addEventListener('click', () => {
        document.querySelectorAll('.tab-btn').forEach(b => b.classList.remove('active'));
        btn.classList.add('active');
        current = btn.dataset.type;
        updateUI();
        stopAudio();
      });
    });

    function updateUI() {
      const data = signals[current];
      document.getElementById('scopeTitle').textContent = data.title;
      document.getElementById('scopeTarget').textContent = data.target;
      document.getElementById('specVoltage').textContent = data.voltage;
      document.getElementById('specPolarity').textContent = data.polarity;
      document.getElementById('specRate').textContent = data.rate;
      document.getElementById('listenBtn').querySelector('span').textContent = data.btnText;
    }

    // Oscilloscope Animation
    function drawScope() {
      const w = canvas.width;
      const h = canvas.height;
      const midY = h / 2;

      ctx.clearRect(0, 0, w, h);

      // Grid Lines
      ctx.strokeStyle = '#e2e8f0';
      ctx.lineWidth = 1;
      ctx.setLineDash([4, 4]);

      // +5V line
      ctx.beginPath();
      ctx.moveTo(0, h * 0.2);
      ctx.lineTo(w, h * 0.2);
      ctx.stroke();

      // 0V center line
      ctx.strokeStyle = '#cbd5e1';
      ctx.beginPath();
      ctx.moveTo(0, midY);
      ctx.lineTo(w, midY);
      ctx.stroke();

      // -5V line
      ctx.strokeStyle = '#e2e8f0';
      ctx.beginPath();
      ctx.moveTo(0, h * 0.8);
      ctx.lineTo(w, h * 0.8);
      ctx.stroke();
      ctx.setLineDash([]);

      // Voltage scale text
      ctx.fillStyle = '#94a3b8';
      ctx.font = '12px system-ui';
      ctx.fillText('+5V', 10, h * 0.2 - 4);
      ctx.fillText('0V', 10, midY - 4);
      ctx.fillText('-5V', 10, h * 0.8 - 4);

      // Waveform trace
      ctx.strokeStyle = '#22b7ff';
      ctx.lineWidth = 3;
      ctx.beginPath();

      const points = 200;
      for (let i = 0; i <= points; i++) {
        const x = (i / points) * w;
        let y = midY;

        if (current === 'audio') {
          // Rapid alternating bipolar AC wave
          const t = (i / points) * 16 * Math.PI - phase * 8;
          y = midY - Math.sin(t) * (h * 0.3);
        } else if (current === 'cv') {
          // Slow smooth modulation CV
          const t = (i / points) * 2 * Math.PI - phase;
          // Unipolar LFO shape (0 to +5V)
          const norm = (Math.sin(t) + 1) / 2;
          y = (midY + (h * 0.3)) - norm * (h * 0.6);
        } else if (current === 'logic') {
          // Binary Gate pulses 0V to +5V
          const t = ((i / points) * 4 - phase * 0.3) % 1;
          const isHigh = ((t + 1) % 1) < 0.45;
          y = isHigh ? (h * 0.2) : midY;
        }

        if (i === 0) ctx.moveTo(x, y);
        else ctx.lineTo(x, y);
      }
      ctx.stroke();

      phase += 0.03;
      requestAnimationFrame(drawScope);
    }
    requestAnimationFrame(drawScope);

    // Audio Playback (Opt-in only)
    function stopAudio() {
      activeNodes.forEach(node => {
        try { node.stop(); } catch(e){}
        try { node.disconnect(); } catch(e){}
      });
      activeNodes = [];
    }

    document.getElementById('listenBtn').addEventListener('click', () => {
      if (!audioCtx) {
        audioCtx = new (window.AudioContext || window.webkitAudioContext)();
      }
      if (audioCtx.state === 'suspended') {
        audioCtx.resume();
      }

      stopAudio();

      const now = audioCtx.currentTime;

      if (current === 'audio') {
        // 440 Hz audible tone
        const osc = audioCtx.createOscillator();
        const gain = audioCtx.createGain();
        osc.type = 'sawtooth';
        osc.frequency.setValueAtTime(440, now);
        gain.gain.setValueAtTime(0.2, now);
        gain.gain.exponentialRampToValueAtTime(0.0001, now + 0.8);
        osc.connect(gain);
        gain.connect(audioCtx.destination);
        osc.start(now);
        osc.stop(now + 0.8);
        activeNodes.push(osc);
      } else if (current === 'cv') {
        // CV modulating carrier frequency (LFO demo)
        const carrier = audioCtx.createOscillator();
        const lfo = audioCtx.createOscillator();
        const lfoGain = audioCtx.createGain();
        const mainGain = audioCtx.createGain();

        carrier.frequency.setValueAtTime(300, now);
        lfo.frequency.setValueAtTime(4, now); // 4Hz CV LFO
        lfoGain.gain.setValueAtTime(150, now);

        lfo.connect(carrier.frequency);
        carrier.connect(mainGain);
        mainGain.connect(audioCtx.destination);

        mainGain.gain.setValueAtTime(0.2, now);
        mainGain.gain.exponentialRampToValueAtTime(0.0001, now + 1.2);

        lfo.start(now);
        carrier.start(now);
        lfo.stop(now + 1.2);
        carrier.stop(now + 1.2);
        activeNodes.push(lfo, carrier);
      } else if (current === 'logic') {
        // Discrete Gate trigger pulses
        [0, 0.25, 0.5, 0.75].forEach(offset => {
          const osc = audioCtx.createOscillator();
          const gain = audioCtx.createGain();
          osc.frequency.setValueAtTime(600, now + offset);
          gain.gain.setValueAtTime(0.25, now + offset);
          gain.gain.exponentialRampToValueAtTime(0.0001, now + offset + 0.1);
          osc.connect(gain);
          gain.connect(audioCtx.destination);
          osc.start(now + offset);
          osc.stop(now + offset + 0.1);
          activeNodes.push(osc);
        });
      }
    });

    updateUI();
  </script>
</body>
</html>

If pitch information travels as raw electricity, how does an oscillator know exactly which musical note to play?

## Pitch Tracking: The 1V/Octave Standard

Pitch is governed by the **1 Volt per Octave (1V/Oct)** standard, where each $1\text{V}$ increase doubles the oscillator's fundamental frequency ($f$).

Because musical pitch is logarithmic ($f = f_0 \cdot 2^V$), every semitone corresponds to exactly $\frac{1}{12}\text{V} \approx 0.0833\text{V}$ added to the control input.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, sans-serif;
      background: #f8f9fa;
      color: #1e2945;
      padding: 12px;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      min-height: 100%;
    }

    .main-panel {
      width: 100%;
      max-width: 580px;
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 12px;
      padding: 14px 16px;
      box-shadow: 0 4px 12px rgba(0,0,0,0.03);
      display: flex;
      flex-direction: column;
      gap: 12px;
    }

    .readouts {
      display: grid;
      grid-template-columns: repeat(3, 1fr);
      gap: 8px;
    }

    .meter {
      background: #f1f5f9;
      border: 1px solid #e2e8f0;
      border-radius: 8px;
      padding: 8px 6px;
      text-align: center;
    }

    .meter-label {
      font-size: 11px;
      font-weight: 700;
      text-transform: uppercase;
      letter-spacing: 0.5px;
      color: #64748b;
      margin-bottom: 2px;
    }

    .meter-val {
      font-size: 18px;
      font-weight: 800;
      color: #0284c7;
      font-variant-numeric: tabular-nums;
    }

    .formula-bar {
      background: #e0f2fe;
      border: 1px solid #bae6fd;
      border-radius: 8px;
      padding: 6px 10px;
      font-size: 13px;
      font-weight: 600;
      text-align: center;
      color: #0369a1;
      display: flex;
      justify-content: space-around;
      align-items: center;
      flex-wrap: wrap;
      gap: 4px;
    }

    .kb-container {
      position: relative;
      width: 100%;
      height: 90px;
      background: #0f172a;
      border-radius: 8px;
      padding: 4px;
      display: flex;
      user-select: none;
    }

    .white-keys {
      display: flex;
      width: 100%;
      height: 100%;
      gap: 2px;
    }

    .key-w {
      flex: 1;
      background: #ffffff;
      border-radius: 0 0 5px 5px;
      cursor: pointer;
      display: flex;
      flex-direction: column;
      justify-content: flex-end;
      align-items: center;
      padding-bottom: 4px;
      font-size: 11px;
      font-weight: 700;
      color: #64748b;
      box-shadow: 0 2px 0 #cbd5e1;
      transition: background 0.15s, color 0.15s;
    }

    .key-w.active {
      background: #38bdf8;
      color: #ffffff;
      box-shadow: inset 0 2px 4px rgba(0,0,0,0.2);
    }

    .black-keys {
      position: absolute;
      top: 4px;
      left: 4px;
      right: 4px;
      height: 56px;
      pointer-events: none;
      display: flex;
    }

    .key-b-slot {
      flex: 1;
      position: relative;
    }

    .key-b {
      position: absolute;
      right: -28%;
      width: 56%;
      height: 100%;
      background: #1e293b;
      border-radius: 0 0 4px 4px;
      cursor: pointer;
      pointer-events: auto;
      z-index: 2;
      box-shadow: 0 2px 3px rgba(0,0,0,0.4);
      transition: background 0.15s;
    }

    .key-b.active {
      background: #0284c7;
    }

    .controls-row {
      display: flex;
      align-items: center;
      justify-content: space-between;
      gap: 10px;
    }

    .oct-selector {
      display: flex;
      gap: 4px;
    }

    .oct-btn {
      border: 1px solid #cbd5e1;
      background: #f8fafc;
      padding: 6px 12px;
      border-radius: 6px;
      font-size: 12px;
      font-weight: 700;
      color: #475569;
      cursor: pointer;
      transition: all 0.15s;
    }

    .oct-btn.active {
      background: #0284c7;
      border-color: #0284c7;
      color: #ffffff;
    }

    .sound-btn {
      background: #0284c7;
      color: #ffffff;
      border: none;
      border-radius: 6px;
      padding: 6px 14px;
      font-size: 13px;
      font-weight: 700;
      cursor: pointer;
      display: flex;
      align-items: center;
      gap: 6px;
      transition: background 0.15s;
    }

    .sound-btn:active {
      background: #0369a1;
    }

    .scale-bar {
      display: flex;
      justify-content: space-between;
      padding: 0 4px;
      font-size: 11px;
      font-weight: 600;
      color: #94a3b8;
    }
  </style>
</head>
<body>

  <div class="main-panel">
    <div class="readouts">
      <div class="meter">
        <div class="meter-label">CV Input</div>
        <div class="meter-val" id="cvVal">+0.000 V</div>
      </div>
      <div class="meter">
        <div class="meter-label">Pitch</div>
        <div class="meter-val" id="noteVal">C3</div>
      </div>
      <div class="meter">
        <div class="meter-label">Frequency</div>
        <div class="meter-val" id="freqVal">130.8 Hz</div>
      </div>
    </div>

    <div class="formula-bar">
      <span>1V = 1 Octave (×2 Hz)</span>
      <span>•</span>
      <span>1/12V = 1 Semitone (+0.0833 V)</span>
    </div>

    <div class="kb-container" id="keyboard">
      <div class="white-keys" id="whiteKeys"></div>
      <div class="black-keys" id="blackKeys"></div>
    </div>

    <div class="scale-bar">
      <span>0.00 V</span>
      <span>+0.25 V</span>
      <span>+0.50 V</span>
      <span>+0.75 V</span>
      <span>+1.00 V</span>
    </div>

    <div class="controls-row">
      <div class="oct-selector">
        <button class="oct-btn active" data-oct="0">0.0V (C3)</button>
        <button class="oct-btn" data-oct="1">+1.0V (C4)</button>
        <button class="oct-btn" data-oct="2">+2.0V (C5)</button>
      </div>

      <button class="sound-btn" id="playBtn">🔊 Test Pitch</button>
    </div>
  </div>

  <script>
    const NOTE_NAMES = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B', 'C'];
    const IS_BLACK = [false, true, false, true, false, false, true, false, true, false, true, false, false];
    const BASE_FREQ = 130.8128; // C3 in Hz

    let currentOct = 0;
    let currentSemi = 0;
    let audioCtx = null;

    const cvVal = document.getElementById('cvVal');
    const noteVal = document.getElementById('noteVal');
    const freqVal = document.getElementById('freqVal');
    const whiteKeysEl = document.getElementById('whiteKeys');
    const blackKeysEl = document.getElementById('blackKeys');

    // Build 1-octave keyboard (C to C, 13 keys)
    const whiteIndices = [];
    for (let i = 0; i <= 12; i++) {
      if (!IS_BLACK[i]) {
        whiteIndices.push(i);
        const wk = document.createElement('div');
        wk.className = 'key-w';
        wk.dataset.index = i;
        wk.innerHTML = `<span>${NOTE_NAMES[i]}</span>`;
        whiteKeysEl.appendChild(wk);
      }
    }

    // Build black key overlays aligned to white key slots (0 to 6)
    const blackKeyMap = { 0: 1, 1: 3, 3: 6, 4: 8, 5: 10 };
    for (let w = 0; w < 7; w++) {
      const slot = document.createElement('div');
      slot.className = 'key-b-slot';
      if (blackKeyMap[w] !== undefined) {
        const bk = document.createElement('div');
        bk.className = 'key-b';
        bk.dataset.index = blackKeyMap[w];
        slot.appendChild(bk);
      }
      blackKeysEl.appendChild(slot);
    }

    function update() {
      const totalSemis = currentOct * 12 + currentSemi;
      const voltage = totalSemis / 12;
      const freq = BASE_FREQ * Math.pow(2, voltage);
      const noteName = NOTE_NAMES[currentSemi];
      const octNum = 3 + currentOct + (currentSemi === 12 ? 1 : 0);

      cvVal.textContent = `+${voltage.toFixed(3)} V`;
      noteVal.textContent = `${noteName}${currentSemi === 12 ? octNum : octNum}`;
      freqVal.textContent = `${freq.toFixed(1)} Hz`;

      // Highlight active key
      document.querySelectorAll('.key-w, .key-b').forEach(k => {
        k.classList.toggle('active', parseInt(k.dataset.index) === currentSemi);
      });

      // Highlight active octave button
      document.querySelectorAll('.oct-btn').forEach(btn => {
        btn.classList.toggle('active', parseInt(btn.dataset.oct) === currentOct);
      });
    }

    function playTone() {
      if (!audioCtx) {
        audioCtx = new (window.AudioContext || window.webkitAudioContext)();
      }
      if (audioCtx.state === 'suspended') {
        audioCtx.resume();
      }
      const totalSemis = currentOct * 12 + currentSemi;
      const freq = BASE_FREQ * Math.pow(2, totalSemis / 12);

      const osc = audioCtx.createOscillator();
      const gain = audioCtx.createGain();
      
      osc.type = 'sawtooth';
      osc.frequency.setValueAtTime(freq, audioCtx.currentTime);

      gain.gain.setValueAtTime(0.2, audioCtx.currentTime);
      gain.gain.exponentialRampToValueAtTime(0.001, audioCtx.currentTime + 0.5);

      osc.connect(gain);
      gain.connect(audioCtx.destination);

      osc.start();
      osc.stop(audioCtx.currentTime + 0.5);
    }

    // Key selection
    document.querySelectorAll('.key-w, .key-b').forEach(key => {
      key.addEventListener('pointerdown', (e) => {
        e.stopPropagation();
        currentSemi = parseInt(key.dataset.index);
        update();
        playTone();
      });
    });

    // Octave selection
    document.querySelectorAll('.oct-btn').forEach(btn => {
      btn.addEventListener('click', () => {
        currentOct = parseInt(btn.dataset.oct);
        update();
        playTone();
      });
    });

    document.getElementById('playBtn').addEventListener('click', playTone);

    update();
  </script>
</body>
</html>

Pitch handles which note sounds, but how does the modular system know precisely when and for how long to trigger a sound?

A **trigger** is an ultra-short voltage pulse (typically $1\text{ ms}$ to $10\text{ ms}$ at $+5\text{V}$) that tells a module to start an instant event, such as advancing a sequencer step or firing a percussive drum envelope.

A **gate** is a two-state voltage that stays high ($+5\text{V}$ or $+10\text{V}$) for the entire duration a key or step is held, sustaining an envelope generator until the signal drops back to $0\text{V}$.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, sans-serif;
      background: #f8f9fa;
      color: #1e2945;
      padding: 12px;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      min-height: 100%;
    }

    .controls {
      display: flex;
      gap: 8px;
      width: 100%;
      max-width: 480px;
      justify-content: center;
      margin-bottom: 8px;
    }

    .mode-btn {
      flex: 1;
      padding: 8px 12px;
      font-size: 14px;
      font-weight: 600;
      border: 1px solid #d1d5db;
      background: #ffffff;
      color: #4b5563;
      border-radius: 8px;
      cursor: pointer;
      box-shadow: 0 1px 2px rgba(0,0,0,0.05);
      transition: all 0.2s ease;
      text-align: center;
      user-select: none;
    }

    .mode-btn.active {
      background: #22b7ff;
      color: #ffffff;
      border-color: #0284c7;
      box-shadow: 0 2px 6px rgba(34,183,255,0.3);
    }

    .scope-box {
      width: 100%;
      max-width: 480px;
      background: #ffffff;
      border: 1px solid #e5e7eb;
      border-radius: 10px;
      padding: 8px 12px;
      box-shadow: 0 2px 8px rgba(0,0,0,0.04);
      margin-bottom: 8px;
      position: relative;
    }

    .scope-title {
      font-size: 12px;
      font-weight: 700;
      text-transform: uppercase;
      letter-spacing: 0.5px;
      color: #6b7280;
      margin-bottom: 4px;
      display: flex;
      justify-content: space-between;
    }

    svg {
      width: 100%;
      height: 95px;
      display: block;
    }

    .grid-line {
      stroke: #f1f5f9;
      stroke-dasharray: 4,4;
      stroke-width: 1;
    }

    .axis-line {
      stroke: #e2e8f0;
      stroke-width: 1.5;
    }

    .cv-path {
      fill: none;
      stroke: #2563eb;
      stroke-width: 2.5;
      stroke-linejoin: round;
      stroke-linecap: round;
      transition: d 0.35s ease;
    }

    .adsr-path {
      fill: rgba(34, 183, 255, 0.12);
      stroke: #0284c7;
      stroke-width: 2.5;
      stroke-linejoin: round;
      stroke-linecap: round;
      transition: d 0.35s ease;
    }

    .phase-label {
      font-size: 11px;
      font-weight: 700;
      fill: #64748b;
      text-anchor: middle;
    }

    .voltage-label {
      font-size: 10px;
      font-weight: 600;
      fill: #94a3b8;
    }

    .cursor-line {
      stroke: #f59e0b;
      stroke-width: 1.5;
      stroke-dasharray: 2,2;
      transition: transform 0.05s linear;
    }

    .play-panel {
      display: flex;
      align-items: center;
      justify-content: center;
      gap: 12px;
      width: 100%;
      max-width: 480px;
    }

    .action-btn {
      padding: 10px 20px;
      font-size: 14px;
      font-weight: 700;
      background: #1e2945;
      color: #ffffff;
      border: none;
      border-radius: 8px;
      cursor: pointer;
      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
      user-select: none;
      display: flex;
      align-items: center;
      gap: 6px;
      transition: background 0.15s ease;
    }

    .action-btn:active {
      background: #0f172a;
    }

    .status-badge {
      font-size: 12px;
      font-weight: 600;
      color: #475569;
      background: #e2e8f0;
      padding: 6px 10px;
      border-radius: 6px;
    }
  </style>
</head>
<body>

  <div class="controls">
    <button class="mode-btn active" id="btnGate" onclick="setMode('gate')">Gate (+5V Held)</button>
    <button class="mode-btn" id="btnTrigger" onclick="setMode('trigger')">Trigger (Pulse)</button>
  </div>

  
  <div class="scope-box">
    <div class="scope-title">
      <span>Input Voltage (CV)</span>
      <span id="cvTypeLabel" style="color:#2563eb;">Sustained Gate</span>
    </div>
    <svg viewBox="0 0 400 95" id="cvSvg">
      <line x1="40" y1="20" x2="380" y2="20" class="grid-line" />
      <line x1="40" y1="80" x2="380" y2="80" class="axis-line" />
      <text x="32" y="24" text-anchor="end" class="voltage-label">+5V</text>
      <text x="32" y="83" text-anchor="end" class="voltage-label">0V</text>
      
      <path id="cvCurve" class="cv-path" d="" />
      <line id="cursorCv" class="cursor-line" x1="0" y1="10" x2="0" y2="85" style="display:none;" />
    </svg>
  </div>

  
  <div class="scope-box">
    <div class="scope-title">
      <span>Envelope Output (VCA / Filter)</span>
      <span id="envStateLabel" style="color:#0284c7;">ADSR Response</span>
    </div>
    <svg viewBox="0 0 400 95" id="envSvg">
      <line x1="40" y1="20" x2="380" y2="20" class="grid-line" />
      <line x1="40" y1="80" x2="380" y2="80" class="axis-line" />
      <text x="32" y="24" text-anchor="end" class="voltage-label">Max</text>
      <text x="32" y="83" text-anchor="end" class="voltage-label">0</text>

      <path id="adsrFill" class="adsr-path" d="" />
      
      <g id="phaseLabels">
        <text id="lblA" x="75" y="92" class="phase-label">A</text>
        <text id="lblD" x="120" y="92" class="phase-label">D</text>
        <text id="lblS" x="200" y="92" class="phase-label">S (Held)</text>
        <text id="lblR" x="310" y="92" class="phase-label">R</text>
      </g>
      
      <line id="cursorEnv" class="cursor-line" x1="0" y1="10" x2="0" y2="85" style="display:none;" />
    </svg>
  </div>

  <div class="play-panel">
    <button class="action-btn" id="playBtn" onclick="triggerPlayback()">
      <span>▶</span> Play CV & Sound
    </button>
    <div class="status-badge" id="statusBadge">Ready</div>
  </div>

  <script>
    let currentMode = 'gate';
    let isPlaying = false;
    let animFrame = null;
    let audioCtx = null;

    const paths = {
      gate: {
        cv: "M 40 80 L 70 80 L 70 20 L 270 20 L 270 80 L 380 80",
        env: "M 40 80 L 70 80 L 105 20 L 150 45 L 270 45 L 345 80 L 380 80 Z",
        sLabel: "S (Held)",
        sPos: 210,
        rPos: 310
      },
      trigger: {
        cv: "M 40 80 L 70 80 L 70 20 L 85 20 L 85 80 L 380 80",
        env: "M 40 80 L 70 80 L 105 20 L 175 80 L 380 80 Z",
        sLabel: "No Sustain",
        sPos: 140,
        rPos: 240
      }
    };

    function updateGraphics() {
      const p = paths[currentMode];
      document.getElementById('cvCurve').setAttribute('d', p.cv);
      document.getElementById('adsrFill').setAttribute('d', p.env);
      
      const lblS = document.getElementById('lblS');
      const lblR = document.getElementById('lblR');
      lblS.textContent = p.sLabel;
      lblS.setAttribute('x', p.sPos);
      lblR.style.display = currentMode === 'gate' ? 'block' : 'none';
      
      document.getElementById('cvTypeLabel').textContent = currentMode === 'gate' ? 'Sustained Gate (+5V)' : 'Trigger Pulse (+5V)';
      document.getElementById('btnGate').className = 'mode-btn' + (currentMode === 'gate' ? ' active' : '');
      document.getElementById('btnTrigger').className = 'mode-btn' + (currentMode === 'trigger' ? ' active' : '');
    }

    function setMode(mode) {
      if (isPlaying) stopAnimation();
      currentMode = mode;
      updateGraphics();
    }

    function playTone(type) {
      try {
        const AudioContext = window.AudioContext || window.webkitAudioContext;
        if (!audioCtx) audioCtx = new AudioContext();
        if (audioCtx.state === 'suspended') audioCtx.resume();

        const osc = audioCtx.createOscillator();
        const gain = audioCtx.createGain();
        osc.type = 'sawtooth';
        osc.frequency.setValueAtTime(220, audioCtx.currentTime); // A3 note

        const now = audioCtx.currentTime;
        gain.gain.setValueAtTime(0.001, now);

        if (type === 'gate') {
          // Attack -> Decay -> Sustain (held for 1.3s) -> Release
          gain.gain.setValueAtTime(0.001, now + 0.2);
          gain.gain.linearRampToValueAtTime(0.25, now + 0.45); // Attack
          gain.gain.linearRampToValueAtTime(0.12, now + 0.75); // Decay to Sustain
          gain.gain.setValueAtTime(0.12, now + 1.55);          // Hold Sustain
          gain.gain.exponentialRampToValueAtTime(0.0001, now + 2.05); // Release
          osc.start(now);
          osc.stop(now + 2.1);
        } else {
          // Trigger: Attack -> Direct Decay to 0 (no sustain)
          gain.gain.setValueAtTime(0.001, now + 0.2);
          gain.gain.linearRampToValueAtTime(0.25, now + 0.45); // Attack
          gain.gain.exponentialRampToValueAtTime(0.0001, now + 0.95); // Immediate decay
          osc.start(now);
          osc.stop(now + 1.0);
        }
        osc.connect(gain);
        gain.connect(audioCtx.destination);
      } catch (e) {}
    }

    function triggerPlayback() {
      if (isPlaying) return;
      isPlaying = true;
      playTone(currentMode);

      const cursorCv = document.getElementById('cursorCv');
      const cursorEnv = document.getElementById('cursorEnv');
      const statusBadge = document.getElementById('statusBadge');
      
      cursorCv.style.display = 'block';
      cursorEnv.style.display = 'block';

      const startX = 40;
      const endX = 380;
      const duration = currentMode === 'gate' ? 2400 : 1600;
      const startTime = performance.now();

      function animate(now) {
        const elapsed = now - startTime;
        const progress = Math.min(elapsed / duration, 1);
        const curX = startX + progress * (endX - startX);

        cursorCv.setAttribute('x1', curX);
        cursorCv.setAttribute('x2', curX);
        cursorEnv.setAttribute('x1', curX);
        cursorEnv.setAttribute('x2', curX);

        // Status description
        if (currentMode === 'gate') {
          if (curX < 70) statusBadge.textContent = 'Idle (0V)';
          else if (curX < 105) statusBadge.textContent = 'Attack (Rising)';
          else if (curX < 150) statusBadge.textContent = 'Decay';
          else if (curX < 270) statusBadge.textContent = 'Sustain (Gate Held)';
          else if (curX < 345) statusBadge.textContent = 'Release (Gate Off)';
          else statusBadge.textContent = 'Idle';
        } else {
          if (curX < 70) statusBadge.textContent = 'Idle (0V)';
          else if (curX < 85) statusBadge.textContent = 'Trigger Pulse';
          else if (curX < 105) statusBadge.textContent = 'Attack';
          else if (curX < 175) statusBadge.textContent = 'Decay (No Hold)';
          else statusBadge.textContent = 'Idle';
        }

        if (progress < 1) {
          animFrame = requestAnimationFrame(animate);
        } else {
          stopAnimation();
        }
      }
      animFrame = requestAnimationFrame(animate);
    }

    function stopAnimation() {
      if (animFrame) cancelAnimationFrame(animFrame);
      isPlaying = false;
      document.getElementById('cursorCv').style.display = 'none';
      document.getElementById('cursorEnv').style.display = 'none';
      document.getElementById('statusBadge').textContent = 'Ready';
    }

    // Init
    updateGraphics();
  </script>
</body>
</html>

A common mistake is plugging a trigger output into an ADSR envelope expecting a sustained pad sound. Without a sustained **gate voltage**, the envelope will immediately decay because it has no hold time.

A **Sample & Hold (S&H)** circuit reads the instantaneous voltage of an incoming signal, such as continuous **White Noise** or an LFO, whenever it receives a clock trigger pulse.

It holds that discrete voltage level steady until the next pulse arrives, generating stepped pseudo-random melodies or synchronized filter stepped modulations.

How do we wire all these building blocks together into a working musical voice?

A standard subtractive modular patch separates into two parallel layers: the **audio path** (generating and filtering raw sound) and the **control path** (modulating pitch, cutoff, and amplitude).

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <title>Audio-Rate Modulation Routing</title>
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      background: #f8f9fa;
      color: #1e2945;
      padding: 12px;
      display: flex;
      flex-direction: column;
      gap: 10px;
      min-height: 100%;
    }

    /* Top Selector Tabs */
    .tabs {
      display: flex;
      gap: 6px;
      justify-content: center;
      flex-wrap: wrap;
    }
    .tab-btn {
      background: #ffffff;
      border: 1.5px solid #e2e8f0;
      border-radius: 8px;
      padding: 6px 14px;
      font-size: 13px;
      font-weight: 600;
      color: #64748b;
      cursor: pointer;
      display: flex;
      align-items: center;
      gap: 6px;
      transition: all 0.2s ease;
    }
    .tab-btn.active {
      background: #22b7ff;
      border-color: #22b7ff;
      color: #ffffff;
      box-shadow: 0 2px 8px rgba(34, 183, 255, 0.35);
    }

    /* Main Modular Grid */
    .synth-grid {
      display: grid;
      grid-template-columns: 1fr 1fr;
      gap: 8px;
      flex: 1;
    }
    @media (max-width: 480px) {
      .synth-grid { grid-template-columns: 1fr; }
    }

    .module {
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 10px;
      padding: 10px;
      display: flex;
      flex-direction: column;
      gap: 8px;
      box-shadow: 0 1px 3px rgba(0,0,0,0.03);
    }

    .mod-header {
      display: flex;
      justify-content: space-between;
      align-items: center;
      font-size: 11px;
      font-weight: 700;
      text-transform: uppercase;
      letter-spacing: 0.5px;
      color: #64748b;
      border-bottom: 1px solid #f1f5f9;
      padding-bottom: 4px;
    }

    /* Routing Diagram SVG */
    .route-container {
      position: relative;
      width: 100%;
      height: 125px;
      background: #f8fafc;
      border-radius: 8px;
      border: 1px solid #edf2f7;
      overflow: hidden;
    }
    svg.patch-map {
      width: 100%;
      height: 100%;
      display: block;
    }

    /* Oscilloscope Canvas */
    .scope-box {
      background: #0f172a;
      border-radius: 8px;
      padding: 6px;
      position: relative;
      display: flex;
      flex-direction: column;
      gap: 4px;
    }
    canvas#scopeCanvas {
      width: 100%;
      height: 80px;
      display: block;
      border-radius: 4px;
    }
    .scope-label {
      font-size: 10px;
      font-weight: 700;
      color: #94a3b8;
      display: flex;
      justify-content: space-between;
      padding: 0 2px;
    }

    /* Parameter Controls & Audio Action */
    .control-strip {
      display: flex;
      align-items: center;
      justify-content: space-between;
      gap: 8px;
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 10px;
      padding: 8px 12px;
    }

    .status-tag {
      font-size: 12px;
      font-weight: 600;
      color: #334155;
      display: flex;
      align-items: center;
      gap: 6px;
    }
    .status-tag span.badge {
      background: #e0f2fe;
      color: #0284c7;
      padding: 2px 6px;
      border-radius: 4px;
      font-size: 11px;
      font-weight: 700;
    }

    .audio-btn {
      background: #10b981;
      border: none;
      color: #ffffff;
      padding: 6px 14px;
      border-radius: 8px;
      font-size: 12px;
      font-weight: 700;
      cursor: pointer;
      display: flex;
      align-items: center;
      gap: 6px;
      transition: opacity 0.2s ease;
    }
    .audio-btn.playing {
      background: #ef4444;
    }
    .audio-btn:active {
      opacity: 0.85;
    }
  </style>
</head>
<body>

  
  <div class="tabs">
    <button class="tab-btn active" id="btnFM" onclick="setMode('FM')">
      <span>FM</span> <small style="font-weight: normal; opacity:0.85;">(Pitch CV)</small>
    </button>
    <button class="tab-btn" id="btnAM" onclick="setMode('AM')">
      <span>AM</span> <small style="font-weight: normal; opacity:0.85;">(VCA Gain)</small>
    </button>
    <button class="tab-btn" id="btnRM" onclick="setMode('RM')">
      <span>Ring Mod</span> <small style="font-weight: normal; opacity:0.85;">(Multiplier)</small>
    </button>
  </div>

  
  <div class="synth-grid">
    
    <div class="module">
      <div class="mod-header">
        <span>Patch Flow</span>
        <span id="targetNode">VCO PITCH CV</span>
      </div>
      <div class="route-container">
        <svg class="patch-map" viewBox="0 0 280 125" preserveAspectRatio="xMidYMid meet">
          
          <defs>
            <marker id="arrow" viewBox="0 0 6 6" refX="5" refY="3" markerWidth="5" markerHeight="5" orient="auto">
              <path d="M 0 0 L 6 3 L 0 6 z" fill="#22b7ff" />
            </marker>
            <marker id="arrow-mod" viewBox="0 0 6 6" refX="5" refY="3" markerWidth="5" markerHeight="5" orient="auto">
              <path d="M 0 0 L 6 3 L 0 6 z" fill="#f59e0b" />
            </marker>
          </defs>

          
          
          <rect x="10" y="10" width="70" height="42" rx="5" fill="#fef3c7" stroke="#f59e0b" stroke-width="1.5"/>
          <text x="45" y="27" text-anchor="middle" font-size="9" font-weight="700" fill="#92400e">MODULATOR</text>
          <text x="45" y="42" text-anchor="middle" font-size="8" fill="#b45309" id="modRateText">Audio Rate</text>

          
          <rect x="10" y="70" width="70" height="42" rx="5" fill="#e0f2fe" stroke="#0284c7" stroke-width="1.5"/>
          <text x="45" y="87" text-anchor="middle" font-size="9" font-weight="700" fill="#0369a1">CARRIER</text>
          <text x="45" y="102" text-anchor="middle" font-size="8" fill="#0284c7">Audio Rate</text>

          
          <rect x="115" y="38" width="75" height="50" rx="6" fill="#f1f5f9" stroke="#94a3b8" stroke-width="1.5"/>
          <text x="152" y="60" text-anchor="middle" font-size="10" font-weight="700" fill="#1e2945" id="centerModName">VCO</text>
          <text x="152" y="74" text-anchor="middle" font-size="8" fill="#64748b" id="centerModType">Lin FM Input</text>

          
          <rect x="220" y="43" width="50" height="40" rx="5" fill="#ecfdf5" stroke="#10b981" stroke-width="1.5"/>
          <text x="245" y="62" text-anchor="middle" font-size="9" font-weight="700" fill="#065f46">AUDIO</text>
          <text x="245" y="74" text-anchor="middle" font-size="8" fill="#059669">OUT</text>

          
          <path id="cableMod" d="M 80 31 L 115 52" fill="none" stroke="#f59e0b" stroke-width="2.5" stroke-dasharray="3 2" marker-end="url(#arrow-mod)" />
          <path id="cableCar" d="M 80 91 L 115 72" fill="none" stroke="#0284c7" stroke-width="2.5" marker-end="url(#arrow)" />
          <path d="M 190 63 L 220 63" fill="none" stroke="#10b981" stroke-width="2.5" marker-end="url(#arrow)" />
        </svg>
      </div>
    </div>

    
    <div class="module">
      <div class="mod-header">
        <span>Waveform Output</span>
        <span id="timbreTag" style="color: #22b7ff;">Sideband Rich</span>
      </div>
      <div class="scope-box">
        <canvas id="scopeCanvas" width="300" height="80"></canvas>
        <div class="scope-label">
          <span id="waveDesc">Sidebands: fc ± n·fm</span>
          <span id="scopeMode">Bipolar (FM)</span>
        </div>
      </div>
    </div>
  </div>

  
  <div class="control-strip">
    <div class="status-tag">
      <span id="actionLabel">Destination:</span>
      <span class="badge" id="destBadge">VCO Pitch Modulation</span>
    </div>
    <button class="audio-btn" id="audioToggle" onclick="toggleAudio()">
      <span id="audioIcon">▶</span> <span id="audioBtnText">Play Sound</span>
    </button>
  </div>

  <script>
    let currentMode = 'FM';
    let audioCtx = null;
    let isPlaying = false;
    let oscCarrier = null;
    let oscMod = null;
    let modGain = null;
    let mainGain = null;
    let ringGain = null;
    let phase = 0;

    const modes = {
      FM: {
        title: 'VCO PITCH CV',
        centerName: 'VCO',
        centerType: 'Lin FM Input',
        badge: 'Pitch Modulation (FM)',
        desc: 'Sidebands: fc ± n·fm (Complex)',
        scopeMode: 'Frequency Modulated',
        timbre: 'Metallic / Bell-like',
        cableMod: 'M 80 31 L 115 50',
        cableCar: 'M 80 91 L 115 70'
      },
      AM: {
        title: 'VCA LEVEL CV',
        centerName: 'VCA',
        centerType: 'Unipolar Gain CV',
        badge: 'Amp Modulation (AM)',
        desc: 'Sidebands: fc, fc ± fm',
        scopeMode: 'Amplitude Modulated',
        timbre: 'Tremolo / Sidebands',
        cableMod: 'M 80 31 L 115 50',
        cableCar: 'M 80 91 L 115 70'
      },
      RM: {
        title: '4-QUADRANT MULTIPLIER',
        centerName: 'RING MOD',
        centerType: 'Bipolar Multiplier (X·Y)',
        badge: 'Ring Modulation (RM)',
        desc: 'Carrier Suppressed: fc ± fm',
        scopeMode: 'Suppressed Carrier',
        timbre: 'Inharmonic / Robot',
        cableMod: 'M 80 31 L 115 50',
        cableCar: 'M 80 91 L 115 70'
      }
    };

    function setMode(mode) {
      currentMode = mode;
      
      // Update Tab UI
      ['FM', 'AM', 'RM'].forEach(m => {
        document.getElementById('btn' + m).classList.toggle('active', m === mode);
      });

      const config = modes[mode];
      document.getElementById('targetNode').textContent = config.title;
      document.getElementById('centerModName').textContent = config.centerName;
      document.getElementById('centerModType').textContent = config.centerType;
      document.getElementById('destBadge').textContent = config.badge;
      document.getElementById('waveDesc').textContent = config.desc;
      document.getElementById('scopeMode').textContent = config.scopeMode;
      document.getElementById('timbreTag').textContent = config.timbre;

      // Update Audio Graph if actively playing
      if (isPlaying) {
        stopAudioGraph();
        startAudioGraph();
      }
    }

    // Canvas Real-time Math Plotter
    const canvas = document.getElementById('scopeCanvas');
    const ctx = canvas.getContext('2d');

    function drawWave() {
      ctx.clearRect(0, 0, canvas.width, canvas.height);

      // Grid background line
      ctx.strokeStyle = 'rgba(255, 255, 255, 0.08)';
      ctx.lineWidth = 1;
      ctx.beginPath();
      ctx.moveTo(0, canvas.height / 2);
      ctx.lineTo(canvas.width, canvas.height / 2);
      ctx.stroke();

      // Wave Plot
      ctx.lineWidth = 2;
      ctx.strokeStyle = '#22b7ff';
      ctx.beginPath();

      const w = canvas.width;
      const h = canvas.height;
      const mid = h / 2;
      const amp = h * 0.38;

      const fc = 0.08;
      const fm = 0.015;

      for (let x = 0; x < w; x++) {
        let t = x + phase;
        let y = 0;

        if (currentMode === 'FM') {
          // FM: y = sin(wc*t + I * sin(wm*t))
          const modSignal = Math.sin(t * fm) * 3.5;
          y = Math.sin(t * fc + modSignal);
        } else if (currentMode === 'AM') {
          // AM: y = [0.5 + 0.5 * sin(wm*t)] * sin(wc*t)
          const modEnvelope = (1 + Math.sin(t * fm)) * 0.5;
          y = modEnvelope * Math.sin(t * fc);
        } else if (currentMode === 'RM') {
          // Ring Mod: y = sin(wm*t) * sin(wc*t)
          y = Math.sin(t * fm) * Math.sin(t * fc);
        }

        const plotY = mid - y * amp;
        if (x === 0) ctx.moveTo(x, plotY);
        else ctx.lineTo(x, plotY);
      }

      ctx.stroke();
      phase += 0.8;
      requestAnimationFrame(drawWave);
    }
    requestAnimationFrame(drawWave);

    // Audio Engine via Web Audio API (Opt-in only)
    function initAudio() {
      if (!audioCtx) {
        audioCtx = new (window.AudioContext || window.webkitAudioContext)();
      }
      if (audioCtx.state === 'suspended') {
        audioCtx.resume();
      }
    }

    function startAudioGraph() {
      initAudio();
      const now = audioCtx.currentTime;

      mainGain = audioCtx.createGain();
      mainGain.gain.setValueAtTime(0.18, now);
      mainGain.connect(audioCtx.destination);

      if (currentMode === 'FM') {
        // FM Synthesis: Modulator connected to Carrier frequency
        oscCarrier = audioCtx.createOscillator();
        oscCarrier.type = 'sine';
        oscCarrier.frequency.setValueAtTime(220, now);

        oscMod = audioCtx.createOscillator();
        oscMod.type = 'sine';
        oscMod.frequency.setValueAtTime(110, now);

        modGain = audioCtx.createGain();
        modGain.gain.setValueAtTime(300, now); // FM Index depth

        oscMod.connect(modGain);
        modGain.connect(oscCarrier.frequency);

        oscCarrier.connect(mainGain);
        oscMod.start();
        oscCarrier.start();

      } else if (currentMode === 'AM') {
        // AM Synthesis: Modulator unipolar offset connected to VCA Gain
        oscCarrier = audioCtx.createOscillator();
        oscCarrier.type = 'sine';
        oscCarrier.frequency.setValueAtTime(260, now);

        const vca = audioCtx.createGain();
        vca.gain.setValueAtTime(0.5, now);

        oscMod = audioCtx.createOscillator();
        oscMod.type = 'sine';
        oscMod.frequency.setValueAtTime(110, now);

        modGain = audioCtx.createGain();
        modGain.gain.setValueAtTime(0.5, now);

        oscMod.connect(modGain);
        modGain.connect(vca.gain);

        oscCarrier.connect(vca);
        vca.connect(mainGain);

        oscMod.start();
        oscCarrier.start();

      } else if (currentMode === 'RM') {
        // Ring Mod: Bipolar multiplier (both audio signals multiplied)
        oscCarrier = audioCtx.createOscillator();
        oscCarrier.type = 'sine';
        oscCarrier.frequency.setValueAtTime(330, now);

        ringGain = audioCtx.createGain();
        ringGain.gain.setValueAtTime(0, now);

        oscMod = audioCtx.createOscillator();
        oscMod.type = 'sine';
        oscMod.frequency.setValueAtTime(140, now);

        // Modulator modulates carrier directly through unity gain
        oscMod.connect(ringGain.gain);
        oscCarrier.connect(ringGain);
        ringGain.connect(mainGain);

        oscMod.start();
        oscCarrier.start();
      }
    }

    function stopAudioGraph() {
      if (oscCarrier) {
        try { oscCarrier.stop(); oscCarrier.disconnect(); } catch(e){}
      }
      if (oscMod) {
        try { oscMod.stop(); oscMod.disconnect(); } catch(e){}
      }
      if (mainGain) {
        try { mainGain.disconnect(); } catch(e){}
      }
    }

    function toggleAudio() {
      const btn = document.getElementById('audioToggle');
      const icon = document.getElementById('audioIcon');
      const text = document.getElementById('audioBtnText');

      if (!isPlaying) {
        startAudioGraph();
        isPlaying = true;
        btn.classList.add('playing');
        icon.textContent = '⏹';
        text.textContent = 'Mute Audio';
      } else {
        stopAudioGraph();
        isPlaying = false;
        btn.classList.remove('playing');
        icon.textContent = '▶';
        text.textContent = 'Play Sound';
      }
    }
  </script>
</body>
</html>

Mathematical utilities shape raw CV: **attenuators** scale amplitude ($V_{\text{out}} = k \cdot V_{\text{in}}$ where $0 \le k \le 1$), **inverters** flip polarity ($V_{\text{out}} = -V_{\text{in}}$), **attenuverters** combine both ($-1 \le k \le +1$), and **Summing Mixers** with DC offsets calculate $V_{\text{out}} = \sum V_i + V_{\text{offset}}$ to set modulation depth and resting baselines.

What dynamic textures emerge when you route an audio-rate oscillator directly back into another module's control voltage input?

When control inputs are driven by audio-rate signals ($f > 20\text{ Hz}$) rather than sub-audio Low-**Frequency Oscillators** (LFOs), the modulation produces complex sidebands and harmonically dense textures.

Modulating oscillator pitch at audio rates creates **Frequency Modulation (FM)**, modulating VCA level yields **Amplitude Modulation (AM)**, and multiplying two bipolar audio signals creates **Ring Modulation**.

music-technology

Modular Synthesis and Control Voltage Routing. Analyse modular synthesiser architectures, patch signal flow, and route control voltage (CV/Gate) to create complex modulations.

Synth Secrets: Control Voltages, Modulation, and Modular Routing Architecture

Learning Synths: Interactive Modulation, Envelopes, LFOs, and Signal Routing

VCV Rack: Open-Source Virtual Eurorack Synthesizer Studio for Patch Construction

Pedagogical strategies for Year 13 A-Level Music Technology (MUSTECH-3.10): Scaffold learning by beginning with pure signal taxonomy (Audio vs. Continuous CV vs. Binary Logic) before introducing physical or virtual modular software (such as VCV Rack or Reaktor Blocks). Implement tactile patching tasks: require students to construct an init subtractive voice from zero patch cables to reinforce the non-hardwired requirement of patching pitch CV to VCO, gate to ADSR, ADSR out to VCA CV, and audio from VCO through VCF into VCA. Emphasize numerical mastery of the $1\text{ V/Oct}$ standard and voltage arithmetic ($V_{\text{total}} = V_{\text{bias}} + k \cdot V_{\text{mod}}$) to ensure students excel in examination listening questions and component analysis.

Modular Synthesis and Control Voltage Routing

The Three Signal Domains

Pitch Tracking: The 1V/Octave Standard