The Physics of Reed Simulation: How Web Audio API Recreates Brass Reeds

The harmonium is more than an instrument; it is a spiritual companion for millions of musicians across the Indian subcontinent. From the high-pitched accompaniment of a fast-paced Qawwali in a sufi shrine to the quiet, meditative morning Riyaz of a classical vocalist in a suburban apartment, the harmonium has established itself as the bedrock of Indian melody. Yet, the physical mechanics of this aerophone are incredibly complex. Unlike stringed instruments like the sitar or piano, or beating-reed woodwinds like the clarinet, the harmonium produces its rich, buzzing, and breathing timbre through the vibration of free brass reeds coupled with wooden acoustic chambers. Recreating this sound digitally is one of the ultimate challenges of virtual instrument design.

Until recently, developers attempting to build online musical tools faced a hard choice: rely on cloud-based audio rendering APIs or deploy bulky, sample-based players in the browser. Both approaches are deeply flawed. Cloud-rendering introduces severe network latency that ruins the performance, while simple sample players feel static, robotic, and consume massive amounts of bandwidth. In this technical article, we will explore the physics of free-reed vibrations, dissect the digital signal processing (DSP) math required to emulate them, and demonstrate how to implement a complete, local-first web audio api synthesizer that runs entirely inside your browser's memory sandbox. We will also examine the security and economic benefits of shifting from central cloud nodes to client-side computing.

1. The Physical Mechanics of Free Reeds

To simulate a harmonium reed digitally, we must first understand the classical physics and fluid dynamics that govern its acoustic behavior. The harmonium reed is a free reed—a metal tongue (usually made of brass or copper alloy) secured at one end over a close-fitting slot in a metal frame. When air is pushed through the slot by the pumping of the wooden bellows, a complex physical interaction occurs.

Unlike a beating reed (found in a saxophone or clarinet), which strikes a mouthpiece to block the airflow completely, a free reed vibrates through its slot without striking the frame. The vibration is a self-excited oscillation driven by the pressure difference across the reed. When air pressure builds up in the wind chest, the air begins to flow through the narrow gap between the reed tongue and the frame. According to Bernoulli's principle, the high velocity of the escaping air creates a localized drop in pressure. This pressure drop, combined with the aerodynamic force of the moving air, forces the reed tongue down into the slot, effectively blocking the airflow.

Once the airflow is blocked, the pressure difference drops, and the elastic restoring force of the brass tongue pulls it back to its original position. The cycle then repeats. This continuous, periodic opening and closing of the slot chops the stream of compressed air into a sequence of rapid pressure pulses. It is this periodic pulsing of air—rather than the vibration of the metal tongue itself—that creates the acoustic sound waves we hear. This fluid-structure interaction produces a highly asymmetric, impulse-like pressure wave.

Mathematically, the motion of the cantilevered brass tongue can be modeled using the Euler-Bernoulli beam equation:

Where:

• E is the Young's modulus of the brass alloy (representing its material stiffness).
• I is the area moment of inertia of the reed's cross-section.
• ρ (rho) is the mass density of the brass material.
• A is the cross-sectional area of the tongue.
• y(x, t) is the transverse displacement of the reed at position x along its length at time t.
• F(x, t) is the external aerodynamic force per unit length exerted by the air pressure differential.

Because the air flow is chopped abruptly as the reed passes through the frame, the resulting pressure wave is highly non-sinusoidal. It resembles an impulse train with a very steep wave front. This pressure wave contains a massive array of harmonics, including both odd and even integer multiples of the fundamental frequency. The raw acoustic output of a free reed is incredibly bright, metallic, and buzzy—often described as harsh when heard in isolation. The warmth and roundness of a physical harmonium come from the coupling of the reed to the wooden cabinet and the key chambers. The wooden box acts as an acoustic resonator, filtering out the harsh upper harmonics (above 5 kHz) while boosting the lower mid-range frequencies (between 200 Hz and 1.5 kHz), creating the rich, woody, and nasal timbre characteristic of a professional Indian harmonium.

2. Digital Signal Processing (DSP) Strategies for Reed Emulation

To simulate harmonium reeds using web technologies, we must implement a DSP architecture that mimics the mechanical and acoustic characteristics described above. While physical modeling synthesis (solving the partial differential equations in real-time) is mathematically ideal, it is extremely CPU-intensive and can cause audio dropouts in browser environments. Instead, we use a hybrid approach combining subtractive synthesis, non-linear waveshaping, and multi-oscillator detuning.

A. The Multi-Oscillator "Beating" Engine

Physical harmoniums are categorized by the number of reed banks they contain. A professional "Double Reed" harmonium has two sets of reeds: a Bass set (tuned to a lower octave) and a Male set (tuned to the middle octave). A "Triple Reed" instrument adds a Female set (tuned an octave higher). When a musician presses a key, air is directed to all active reed banks simultaneously. However, physical reeds are never tuned to the exact same frequency. If a Male reed vibrates at 220 Hz, the Bass reed might vibrate at 110 Hz, and a second Male reed might be tuned to 220.5 Hz.

This deliberate, microscopic tuning difference (measured in "cents," where 100 cents equal one semitone) creates an acoustic phenomenon known as "beating." The sound waves phase-interfere with each other, creating a periodic variation in volume and phase. The mathematics of beating waves is governed by the trigonometric identity:

The cosine term cos(π * (f₁ - f₂) * t) represents a slow amplitude modulation at a frequency equal to half the difference between the two source frequencies. In our virtual instrument synth dsp engine, we simulate this by spawning multiple Web Audio OscillatorNode instances for a single note, detuning them by small values (ranging from 3 to 8 cents). This detuning prevents the digital sound from feeling static, introducing a warm, lush, organic movement that mimics physical brass tongues vibrating in a wooden chamber.

B. Waveform Profile and Pulse Width Modulation

Because the physical reed chops air in an asymmetric manner, the source waveform must have a high harmonic content. We use a raw sawtooth wave as our base signal. To replicate the asymmetry of the airflow, we mix the sawtooth wave with a variable pulse-width square wave. By modulating the width of the pulse wave over time (Pulse Width Modulation or PWM) using a low-frequency oscillator (LFO), we simulate the minor fluctuations in air pressure caused by the player's bellows pumping.

C. Non-Linear Waveshaping (The Brass Saturation)

Brass reeds exhibit a non-linear elastic response when subjected to high air pressure. When the bellows are pumped forcefully, the brass tongue bends further, causing a mild saturation or clipping of the acoustic wave. We simulate this in the Web Audio API using a WaveShaperNode. By passing the audio signal through a mathematical distortion curve, we inject additional odd harmonics that mimic the metallic "edge" of the reed under heavy air pressure. The distortion curve is calculated using a sigmoid function or Chebyshev polynomials to ensure the saturation remains smooth and musical rather than harsh and digital.

D. Dynamic Resonant Filtering (The Cabinet Simulation)

The wooden body of the harmonium acts as a low-pass filter. To simulate this digitally, we route our combined, waveshaped oscillators through a BiquadFilterNode configured as a low-pass filter with a 12 dB/octave roll-off. Crucially, this filter must be dynamic. When you pump a physical harmonium's bellows harder, the air pressure increases, which causes the reed to vibrate with greater amplitude and makes the airflow pulses sharper. This increases the high-frequency harmonic content, making the instrument sound brighter.

In our DSP engine, we link the "Bellows Pressure" control directly to the filter's cutoff frequency. When the bellows pressure is low, the cutoff frequency drops to 800 Hz, creating a soft, muted tone. As the pressure increases, the cutoff frequency rises to 2000 Hz, revealing the bright, metallic buzz of the brass. This relationship between pressure, volume, and brightness is the key to making a digital synthesizer feel like a physical, breathing instrument.

3. Architecture of the Web Audio Graph

The Web Audio API provides an elegant, modular routing graph that executes in the browser's background audio thread, isolated from the main JavaScript execution loop. This isolation is critical; it ensures that even if the main thread is busy rendering complex UI animations or processing document layout tables, the audio stream remains glitch-free. Below is the topology of the MojoDocs Web Harmonium audio graph:

By routing the nodes in this sequence (Oscillators → Waveshaper → Filter → Note Gain → Master Bellows Gain → Destination), we can simulate the complex physical behavior of the instrument. The Waveshaper introduces clipping on the raw oscillator mix before the low-pass filter smooths out the resulting high-frequency square edges, mirroring the exact sequence in a physical wooden cabinet where the brass reed saturates before the sound is filtered by the surrounding wood structure.

4. Implementing Reed Synthesis in the Web Audio API

To help developers build their own instruments, we present a complete, production-ready TypeScript implementation of the reed synthesis engine. This code sets up the AudioContext, generates the non-linear waveshaping distortion curve, spawns the detuned oscillators, and schedules the parameters to prevent pops and clicks using the Web Audio API's scheduling methods.

class ReedSynth {
  private ctx: AudioContext | null = null;
  private masterGain: GainNode | null = null;
  private cabinetFilter: BiquadFilterNode | null = null;
  private waveShaper: WaveShaperNode | null = null;

  constructor() {
    // AudioContext is initialized lazily on the first user interaction
  }

  private init() {
    const AudioContextClass = window.AudioContext || (window as any).webkitAudioContext;
    this.ctx = new AudioContextClass();
    
    // Create the master volume control
    this.masterGain = this.ctx.createGain();
    this.masterGain.gain.setValueAtTime(0.3, this.ctx.currentTime);

    // Create the cabinet filter (wood resonance simulator)
    this.cabinetFilter = this.ctx.createBiquadFilter();
    this.cabinetFilter.type = 'lowpass';
    this.cabinetFilter.frequency.setValueAtTime(1200, this.ctx.currentTime);
    this.cabinetFilter.Q.setValueAtTime(1.0, this.ctx.currentTime);

    // Create the waveshaper for brass saturation
    this.waveShaper = this.ctx.createWaveShaper();
    this.waveShaper.curve = this.makeDistortionCurve(15);
    this.waveShaper.oversample = '4x';

    // Route the nodes: Waveshaper -> Filter -> Master Gain -> Output
    this.waveShaper.connect(this.cabinetFilter);
    this.cabinetFilter.connect(this.masterGain);
    this.masterGain.connect(this.ctx.destination);
  }

  private makeDistortionCurve(amount: number): Float32Array {
    const k = typeof amount === 'number' ? amount : 50;
    const n_samples = 44100;
    const curve = new Float32Array(n_samples);
    const deg = Math.PI / 180;
    for (let i = 0; i < n_samples; ++i) {
      const x = (i * 2) / n_samples - 1;
      // Sigmoid-like distortion function for warm saturation
      curve[i] = ((3 + k) * x * 20 * deg) / (Math.PI + k * Math.abs(x));
    }
    return curve;
  }

  public triggerNote(frequency: number, duration: number, bellowsPressure: number) {
    if (!this.ctx) {
      this.init();
    }
    const context = this.ctx!;
    if (context.state === 'suspended') {
      context.resume();
    }

    const now = context.currentTime;

    // Create three oscillators to simulate a Triple-Reed (Bass, Male, Female) harmonium
    const bassOsc = context.createOscillator();
    const maleOsc = context.createOscillator();
    const femaleOsc = context.createOscillator();

    // Set waveshapes to sawtooth for rich harmonics
    bassOsc.type = 'sawtooth';
    maleOsc.type = 'sawtooth';
    femaleOsc.type = 'sawtooth';

    // Set frequencies (Bass = octave below, Female = octave above)
    bassOsc.frequency.setValueAtTime(frequency / 2, now);
    maleOsc.frequency.setValueAtTime(frequency, now);
    femaleOsc.frequency.setValueAtTime(frequency * 2, now);

    // Apply detuning (in cents) to create organic acoustic beating
    bassOsc.detune.setValueAtTime(-5, now);   // Detune down
    maleOsc.detune.setValueAtTime(0, now);     // Fundamental reference
    femaleOsc.detune.setValueAtTime(6, now);    // Detune up

    // Individual gain nodes to mix the reed banks
    const bassGain = context.createGain();
    const maleGain = context.createGain();
    const femaleGain = context.createGain();

    // Set mix levels: Male is strongest, Bass and Female add depth
    bassGain.gain.setValueAtTime(0.4 * bellowsPressure, now);
    maleGain.gain.setValueAtTime(0.6 * bellowsPressure, now);
    femaleGain.gain.setValueAtTime(0.3 * bellowsPressure, now);

    // Create a local note envelope to prevent clicks when keys are pressed/released
    const noteGain = context.createGain();
    noteGain.gain.setValueAtTime(0, now);
    // Smooth attack mimicking bellows inflation
    noteGain.gain.linearRampToValueAtTime(1.0, now + 0.05); 
    // Sustain
    noteGain.gain.setValueAtTime(1.0, now + duration - 0.05);
    // Smooth release mimicking bellows deflation
    noteGain.gain.linearRampToValueAtTime(0, now + duration);

    // Route individual oscillators to their gains, then to the note envelope
    bassOsc.connect(bassGain);
    maleOsc.connect(maleGain);
    femaleOsc.connect(femaleGain);

    bassGain.connect(noteGain);
    maleGain.connect(noteGain);
    femaleGain.connect(noteGain);

    // Route note envelope to the global waveShaper
    noteGain.connect(this.waveShaper!);

    // Modulate the low-pass filter cutoff based on bellows pressure
    // Higher pressure = brighter sound (cutoff increases)
    const targetCutoff = 800 + (1200 * bellowsPressure);
    this.cabinetFilter!.frequency.cancelScheduledValues(now);
    this.cabinetFilter!.frequency.setValueAtTime(this.cabinetFilter!.frequency.value, now);
    this.cabinetFilter!.frequency.exponentialRampToValueAtTime(targetCutoff, now + 0.1);

    // Start oscillators
    bassOsc.start(now);
    maleOsc.start(now);
    femaleOsc.start(now);

    // Stop oscillators after duration
    bassOsc.stop(now + duration);
    maleOsc.stop(now + duration);
    femaleOsc.stop(now + duration);
  }
}

This implementation uses standard, highly optimized Web Audio nodes, avoiding external Javascript libraries. Because there are no HTTP requests, no server loops, and no audio buffer transmissions, the sound plays with a latency of less than 3 milliseconds on standard hardware. Let's analyze key parameters in the code that ensure clean execution:

• Lazy Initialization: The init() method is not called when the class is instantiated. Instead, it waits for triggerNote(). This conforms to the browser security requirement that an AudioContext must only be started via a user gesture (like clicking a button or pressing a key).
• Oversampling: We set the WaveShaperNode.oversample parameter to '4x'. When applying non-linear distortion, high-frequency harmonics are generated. If these frequencies exceed half the sample rate (the Nyquist frequency), they bounce back into the audible spectrum, creating a harsh digital distortion known as aliasing. Oversampling runs the waveshaping calculations at four times the base sample rate (e.g., 176.4 kHz), filtering out these alias frequencies before downsampling back to 44.1 kHz.
• Parameter Scheduling (De-zippering): In digital synthesis, changing parameters like volume or filter cutoff abruptly causes a click or pop in the speaker (known as zippering). We prevent this by using linearRampToValueAtTime and exponentialRampToValueAtTime. These methods instruct the browser to smoothly interpolate the values over a specified timeframe (e.g., 50 milliseconds for the key attack, 100 milliseconds for the filter transition), ensuring a clean, continuous analog feel.

5. Local-First Philosophy: Data Sovereignty and Privacy in Music

In our contemporary digital ecosystem, user privacy is constantly under siege. Major tech platforms track every keystroke, every location coordinate, and every audio snippet. When you use online musical instruments or recording utilities, many sites require you to log in, accept invasive tracking cookies, or upload your MIDI and audio data to cloud processing nodes. This setup is not just a breach of personal privacy; it is a fundamental threat to data sovereignty. The safest file and the safest data is the one that never leaves your device.

At MojoDocs, we believe that your device's hardware belongs to you, and your creative output should remain strictly private. By running all synthesis algorithms locally within the browser sandbox, MojoDocs guarantees that no audio data, MIDI inputs, or keystrokes are ever sent to an external server. The entire synthesis process occurs in volatile RAM and is completely destroyed when you close the browser tab. This is identical to how we handle document security on our main site. When you convert a document, compress a file, or practice your scales, the processing happens locally on your CPU.

Consider the security implications. In India, individuals regularly upload scanned images of sensitive documents, such as their Aadhaar card (UIDAI), PAN card (NSDL), Driving License (DL) via the Parivahan portal, or Passport pages via the MEA. If they do this using public computers in cyber cafes or local Xerox operators, they risk exposing their identities to malicious scripts or cached file directories on shared hard drives. In the same way, using online audio tools that process data in the cloud exposes your intellectual property, musical vocal takes, or MIDI sequences to remote storage servers. A local-first tool eliminates this vector entirely. Your browser becomes a secure, self-contained processing chamber. You don't need to read complex privacy policies or worry about database leaks. If the code runs locally, your privacy is mathematically guaranteed.

6. Economic Realities: Cloud Subscriptions vs. Local Synthesis in India

Beyond security, there is a clear economic narrative. India has a vibrant, massive community of music students, classical vocalists, and schoolteachers who practice Riyaz daily. However, access to professional instruments is highly restricted by cost. A physical, hand-crafted triple-reed harmonium costs between ₹15,000 and ₹50,000 INR. Furthermore, because physical reeds are made of brass, they expand and contract with seasonal changes in temperature and humidity (such as the intense monsoon season). This requires regular manual tuning by a skilled craftsman, which costs around ₹2,000 INR per visit, multiple times a year.

To bypass this cost, many turn to digital solutions. However, commercial music production software and virtual instrument plugins are locked behind expensive paywalls or subscription models, regularly costing ₹1,500 to ₹3,000 INR per month. For a student practicing in a tier-2 or tier-3 city, these fees are prohibitive. Many online sites offer free tools, but they require a continuous high-speed internet connection, which burns through daily cellular data packs while commuting on local buses or trains.

MojoDocs Web Harmonium provides a professional-grade alternative at zero cost. Because we run the entire DSP logic on the user's local device, we do not have to pay for expensive cloud computing servers. Traditional cloud-based services must pay for massive virtual machines to run their synthesis engines for thousands of concurrent users, forcing them to charge heavy subscription fees to cover their electricity and hosting costs. MojoDocs bypasses this entirely by letting your device do the work. We pay pennies for basic static file hosting, allowing us to keep our tools free, ad-free, and unlimited forever. Even if you are waiting for an instant delivery from Blinkit, Zepto, or Swiggy Instamart, or getting a copy of your PAN card at a cyber cafe, you can open MojoDocs and run a full audio Riyaz session with zero data costs.

7. The Flight Mode Verification: Auditing Web Audio Locally

In the security community, the phrase "trust, but verify" is a fundamental law. Any website can write a copy block claiming they do not upload your files, but a user should never take such statements on trust. That is why MojoDocs is architected to allow instant, definitive verification via a simple browser audit. We make it easy to prove that our application operates 100% locally on your computer's CPU, without communicating with any external server once the page is open.

Here is how you can verify that the MojoDocs Web Harmonium operates completely offline:

This process works because once you navigate to the Web Harmonium page, all the HTML markup, CSS styling, Javascript logic, and Web Audio compilation instructions are loaded into your browser's temporary runtime cache. When you disconnect from the internet, the browser has everything it needs to execute the synthesis algorithm locally. Try doing this with a traditional cloud-based synthesizer, and the sound will fail to play immediately, or you will receive an connection error screen.

The Developer Network Audit Method

If you want a more granular view, you can perform a network request audit using your browser's built-in developer tools. Follow these steps:

1. Open your web browser (Chrome, Firefox, Safari, or Edge) and navigate to the MojoDocs Web Harmonium.
2. Right-click anywhere on the page and select Inspect, or press F12 (or Cmd + Option + I on macOS) to open the Developer Tools panel.
3. Click on the Network tab at the top of the developer panel. Make sure the network activity logging is active.
4. Press several keys on your QWERTY keyboard or click the virtual keys on the screen. Play chords and adjust the register settings.
5. Observe the Network tab. You will see that no network requests are dispatched, no HTTP uploads are triggered, and zero bytes of audio or MIDI data are transmitted to any external API endpoint. The sound wave synthesis occurs locally on your CPU.
6. Disconnect your internet and continue playing. The tool will continue to function perfectly as long as the tab remains open.

8. Advanced Riyaz: Optimizing the Virtual Instrument

To get the most out of the MojoDocs Web Harmonium, you must understand how to configure the virtual instrument to match the traditional acoustic setups used in classical Indian music. Follow these steps to optimize your setup for vocal practice (Riyaz):

Additionally, we recommend following this 3-step 'Stable-Pitch' routine:

1. 01
   Set the Drone

   Hold the root note (Sa) along with the perfect fifth (Pa) or perfect fourth (Ma) depending on the Raag you are practicing. This creates a stable harmonic environment for your vocal cords to align with, helping you build muscle memory for pitch accuracy.

2. 02
   Engage Cabinet Resonance

   Use our 'Wood Resonance' toggle. The added depth mimics a physical wooden cabinet, making it easier to hear if your vocal pitch is flat or sharp relative to the harmonium.

3. 03
   Adjust the Bellows Frequency

   Use the bellows slider to simulate a faster or slower pump. A faster pump increases the air pressure, making the virtual reeds sound brighter and more aggressive, which is ideal for fast-paced Tanaas and sargam practice.

If you want to read more about how local compilation allows us to build fast tools like this, read our companion engineering guide on The Engineering Behind MojoDocs WebAssembly. It covers the compiler optimizations, memory bridges, and thread pools we use to deliver desktop-grade performance on the web.

9. Looking Forward: The Native Web and the End of the Centralized Cloud

The success of client-side synthesis tools points to a larger structural shift in how web software is built. For the past fifteen years, the web was dominated by thin-client SaaS applications that collected all user files, processed them in remote data centers, and returned the results. While this solved execution issues on slow computers, it created an expensive, privacy-invasive ecosystem that treated consumer data as raw material for analytics engines.

WebAssembly and modern browser APIs have changed the rules of the game. Web browsers are no longer just document readers; they are high-performance application runtimes. We are entering a renaissance of local-first software, where the browser acts as a secure sandbox running compiled binary applications directly on the user's local hardware. This model provides major advantages:

• Absolute Data Security: You do not need to read complex privacy policies or worry about server database leaks. The safest file is the one you never upload.
• Cost Sustainability: By running computations on the client side, websites eliminate high server maintenance costs, enabling tools to remain free, accessible, and ad-free.
• Network Resilience: Offline-capable web apps operate in rural areas, on flights, and in regions with unstable network connections.

At MojoDocs, we are building this local-first future. By combining WebAssembly, Rust, and strict privacy principles, we are showing that web software can be fast, free, and completely secure. To experience native-grade document processing with zero uploads, visit our Web Harmonium and reclaim your data sovereignty.