Architecture of Movement in Sound: Design and Implementation of a High-Performance Modulation Matrix

Full report

On this page

The evolution of software synthesis and interactive audio relies fundamentally on the architecture of parameter modulation. Sound that remains static over time is perceived by the human auditory system as synthetic and lifeless; movement is the primary mechanism by which raw oscillators, noise generators, and filters are transformed into organic, breathing instruments. Historically, digital and analog synthesizers alike have relied on hard-coded modulation pathways—such as a dedicated analog filter envelope or a vibrato low-frequency oscillator (LFO) directly wired to an oscillator's pitch control1. While efficient and straightforward to implement, this paradigm strictly limits the sound designer to the permutations anticipated by the hardware or software developer.

To achieve the sonic equivalent of a powerful, programmatic motion-design system, modern audio architectures deploy a unified, reusable modulation matrix3. This matrix acts as a central nervous system, decoupling the generation of control signals (the modulation sources) from the parameters they affect (the modulation destinations). Designing such a system for high-performance contexts—such as C++ environments, digital signal processors (DSPs), or Web Audio API AudioWorklet modules—requires strict memory safety, precise semantic limits, and robust graph execution strategies to handle deeply nested modulation without triggering catastrophic feedback loops or performance degradation5.

This report provides an exhaustive architectural framework for building a deterministic, zero-allocation modulation matrix capable of evolving virtually every meaningful synthesis parameter over time, complete with safeguards against control-rate garbage creation, aliasing artifacts, and state-based ghost effects.

Matrix Execution Topology and the Directed Acyclic Graph (DAG)

A generalized, non-hard-coded modulation system inevitably allows for nested modulation: a scenario where one modulator controls the parameter of another modulator4. For example, a random walk generator might modulate the frequency of an LFO, which in turn modulates the decay time of a multi-stage envelope generator, which finally modulates a filter cutoff.

To process these dependencies correctly and deterministically, the modulation matrix cannot execute source algorithms in a randomized or fixed linear array order. It must dynamically construct a Directed Acyclic Graph (DAG) based on the active routings defined by the user10. Within this architecture, every active source and destination represents a node, and every active modulation routing represents a directed edge indicating data flow.

Prior to the execution of the audio-rate or block-rate processing loop, a topological sort is performed on the DAG to establish a deterministic execution sequence12. The topological sorting algorithm (often a variant of Kahn’s algorithm or depth-first search) ensures that if Source A modulates Source B, Source A is fully evaluated for the current sample or block before Source B is calculated14.

Resolving Graph Cycles and Uncontrollable Complexity

Complex motion-design systems naturally invite users to create mutual or recursive modulations—for instance, routing LFO 1 to modulate the amplitude of LFO 2, while simultaneously routing LFO 2 to modulate the rate of LFO 1\. This creates a feedback cycle, which mathematically invalidates standard topological sorting and creates an infinite loop if left unhandled13.

To prevent uncontrollable complexity and software lockups, the matrix must implement a cycle-breaking heuristic. When the topological sort detects a back-edge (a cyclic dependency), the system implicitly inserts a one-sample unit delay ([Figure omitted from source export]) on that specific routing path13. This breaks the mathematical deadlock, allowing the matrix to evaluate the current state of LFO 1 using the previous sample state of LFO 2\. This approach preserves absolute system stability and deterministic execution without forcing the user interface to forbid creative, recursive routing configurations.

Modulation Sources: Mechanisms of Movement

Modulation sources can be grouped by their temporal behaviors, mathematical underpinnings, and responsiveness to external triggers. To maintain absolute consistency across the matrix, the architecture normalizes all source outputs to a standardized bipolar scale of \[-1.0, 1.0\] or a unipolar scale of \[0.0, 1.0\] before the values enter the routing logic3.

Periodic, Stochastic, and Generative Generators

The foundation of any modulation system relies on continuous autonomous generators. Table 1 details the core continuous sources and their algorithmic derivations.

 

Reactive and Envelope-Based Sources

Reactive sources do not run freely in the background; they are provoked by external MIDI events, internal triggers, or incoming audio signals.

Envelopes and Macrocycle Curves: Standard envelopes are finite state machines transitioning through predetermined temporal phases, typically Attack, Decay, Sustain, and Release (ADSR)17. However, to achieve motion-design parity, the system implements Multi-Stage Envelope Generators (MSEGs) or macrocycle curves18. These utilize cubic splines or Bezier curves to interpolate between user-defined temporal knots. This allows for complex rhythmic contours, such as an envelope that rises, oscillates, and falls over the duration of a single note trigger.

Follower Envelopes: Envelope followers extract the amplitude contour of an incoming audio signal, converting dynamic acoustic energy into a mathematical modulation signal. This allows the matrix to extract the groove from a drum loop and apply it to a synthesizer's filter cutoff20. The implementation relies on full-wave rectification (taking the absolute value of the signal) or Root Mean Square (RMS) calculation over a rolling window, followed by an asymmetric leaky integrator21. The integrator uses separate coefficients for the attack phase ([Figure omitted from source export]) and decay phase ([Figure omitted from source export]), calculated via half-life exponential formulas: [Figure omitted from source export]23. This ensures rapid response to transients while preventing low-frequency modulation stutter during the decay tail.

Audio Analyzer Bands: Going beyond simple amplitude tracking, audio analyzer bands utilize Fast Fourier Transform (FFT) analysis. The energy of a specific frequency bin (e.g., isolating the 40Hz \- 80Hz sub-bass region) is normalized, smoothed, and utilized as a unipolar modulation source. This allows for highly localized audio-reactive sound design.

Structural and Sequencing Generators

Step Sequencers: Sequencers are arrays of discrete floating-point values stepped through at a given subdivision of a master clock. The modulation matrix allows interpolation to be disabled for hard, rhythmic stepping, or enabled for linear glides between steps, mimicking acid-bass slide lines.

Euclidean Triggers: Euclidean rhythms are algorithmic rhythm generators based on E. Bjorklund’s algorithm, originally developed to optimize the timing of spallation neutron source accelerators24. By distributing a specified number of active pulses ([Figure omitted from source export]) as evenly as possible across a total number of steps ([Figure omitted from source export]), the algorithm uses recursive subtraction of remainders to generate rhythm necklaces that perfectly mirror traditional musical rhythms found in West African, Cuban, and Middle Eastern music24. In the modulation matrix, these Euclidean rhythms act as triggers to rhythmically reset LFO phases or fire envelope generators autonomously.

Progress Trackers: "Authored score progress" and "journey progress" act as macroscopic, unipolar \[0.0, 1.0\] ramps. They track the global playback time of a DAW timeline or the narrative progression of an interactive game engine state. This allows parameters (such as overall reverb size or harmonic density) to evolve slowly and deterministically over an entire multi-minute piece without requiring a massive, impractically slow envelope generator.

Modulation Destinations and Transfer Functions

Destinations map the normalized \[-1.0, 1.0\] modulation values generated by the matrix to the physical audio properties of the DSP engine. Because audio parameters exist across drastically diverse mathematical scales—ranging from hertz to milliseconds to abstract probabilities—the matrix must apply specific transfer functions to prevent unnatural or sonically destructive modulation17.

Spectral and Pitch Destinations

Human pitch perception is logarithmic. Therefore, modulating pitch-based destinations requires an exponential transfer function to ensure the modulation sounds musical.

• Oscillator Frequency and Detune: To ensure a linear modulation source (like a triangle LFO) produces equal pitch deviations (e.g., exactly [Figure omitted from source export] semitones) above and below the base frequency, the matrix uses the [Figure omitted from source export] standard mapping. The final frequency is calculated as [Figure omitted from source export]. Detune operates on the same math but is scaled to a fraction of a semitone (cents)1.
• Filter Cutoff and Q: Filter cutoff also requires exponential mapping to sweep smoothly across the acoustic spectrum (e.g., 20 Hz to 20,000 Hz). A linear sweep across this range would spend the vast majority of its time in the high frequencies, ignoring the critical musical ranges below 1 kHz. Resonance (Q) is typically mapped linearly or logarithmically depending on the chosen filter topology's stability limits.
• FM Index: Frequency modulation (FM) index determines the amplitude of the modulating oscillator, which directly dictates the expansion of Bessel function sidebands around the carrier frequency30. This is mapped linearly.
• Spectral Brightness and Harmonic Density: In additive synthesis or spectral morphing engines, spectral brightness acts as a spectral tilt or high-frequency shelf, while harmonic density dictates the number of active overtones above the fundamental. Both are mapped linearly but are bound strictly by the Nyquist limit to prevent aliasing.

Spatial, Morphological, and Temporal Destinations

• Wavetable Position: Wavetable synthesis relies on interpolating between pre-sampled waveforms in a table32. Position modulation uses a linear mapping across the phase of a 1D, 2D, or 3D wavetable space.
• Grain Density and Size: Used in granular synthesis to create evolving textures5. Density (number of grains emitted per second) and size (duration of each grain in milliseconds) must be heavily bound by performance limits. While mapped linearly, the canonical maximums are dictated by the available CPU budget, as spawning too many simultaneous grains causes audio thread lockups.
• Delay Time and Feedback: Delay time modulation introduces tape-style Doppler pitch shifts if the delay line interpolation is smooth. Feedback must be strictly clamped below [Figure omitted from source export] (or a safe structural margin like [Figure omitted from source export]) to prevent infinite gain accumulation and speaker-damaging runaway feedback loops.
• Reverb, Width, and Pan: Reverb size, reverb mix, and stereo width operate on unipolar \[0.0, 1.0\] linear mappings. Panning operates on a bipolar \[-1.0, 1.0\] scale. The matrix must utilize equal-power panning laws (applying sine and cosine curves to the left and right channels respectively) so that the perceived volume remains constant as the sound sweeps across the stereo field8.
• Source Gain and Source Probability: The architecture's support for nested modulation means that the gain (amplitude) or the firing probability of one modulation source can be the destination of another. Modulating the probability of a generative source (e.g., a Euclidean trigger chance) enables self-modifying, autonomous generative patches that evolve without human intervention.

Strict Safeguards and Operational Semantics

A primary engineering challenge in matrix design is preventing the audio engine from exploding into positive feedback loops, outputting Not-a-Number (NaN) values, or failing due to memory allocation pauses. The architecture enforces strict bounds through structural design rather than post-calculation correction.

Additive vs. Multiplicative Semantics

Every modulation route defines a specific mathematical semantic operation determining how it interacts with the base parameter and other modulators29:

1. Additive Modulation: The modulator’s scaled value is added to the base parameter. If multiple sources route to the same destination, they are summed.

[Figure omitted from source export]

Application: Pitch vibrato, filter sweeps, wavetable scanning.

2. Multiplicative Modulation: The modulator scales the base parameter. This is critical for amplitude controls.

[Figure omitted from source export]

Application: An envelope acting on a Voltage Controlled Amplifier (VCA), tremolo, or source gain nesting34.

Visitor Authority and Canonical Bounds

A critical principle for a non-destructive user interface is Visitor Authority. The "public base controls" (the graphical knobs and sliders visible to the user) dictate the immutable [Figure omitted from source export] value in the state dictionary. The modulation matrix acts strictly as a visitor: it reads [Figure omitted from source export], applies the additive or multiplicative modulation calculations in temporary audio-thread memory, and pushes the final result to the DSP engine3. The [Figure omitted from source export] state is never permanently overwritten by the modulation. This ensures that if a modulation route is bypassed or deleted, the parameter instantly and cleanly reverts to its authored state.

Furthermore, all destinations possess canonical bounds. A filter cutoff mathematically cannot drop below 0 Hz; in practice, it is clamped between 20 Hz and 20,000 Hz to prevent filter blowups. The matrix enforces hard clamping at the final stage of calculation, guaranteeing safety regardless of the modulation depth:

[Figure omitted from source export]

Real-Time Concurrency and Zero Control-Rate Garbage

In high-performance environments like the Web Audio API AudioWorklet or C++ processBlock functions, dynamic memory allocation on the real-time audio thread is strictly prohibited. Allocating memory triggers Garbage Collection (GC) in JavaScript engines (V8/SpiderMonkey) or OS-level mutex locks in C++, both of which stall the thread and cause audible dropouts and clicking35.

To achieve absolute zero control-rate garbage creation, the architecture enforces the following:

• The modulation matrix pre-allocates the maximum supported routing slots (e.g., 256 routes) and memory buffers at initialization. There is no dynamically unbounded source count38.
• Data transfer between the UI/Main thread and the Audio thread relies exclusively on Single-Producer Single-Consumer (SPSC) lock-free ring buffers39. Wait-free atomic memory barriers are used to pass parameter updates without invoking system locks.
• Parameter changes do not generate new objects. Instead, lightweight structs are updated in place using a SharedArrayBuffer (in Web Audio) or contiguous memory blocks35.

Audio-Thread Scheduling for AudioParams

When modulating destinations that are native Web Audio AudioParam objects, the matrix bypasses JavaScript event loops entirely. Control signals are generated at the block rate (e.g., every 128 samples) or at the audio sample rate, writing directly into the AudioParam's corresponding input buffer via the AudioWorkletProcessor7. To prevent zipper noise (audible stepping artifacts), block-rate control signals are subjected to 1-pole low-pass smoothing before interacting with the final DSP stages2.

Mitigating Artifacts: Anti-Aliasing and Ghost Effects

When a modulation source is driven into the audio rate (e.g., an LFO running at 500 Hz modulating oscillator frequency, resulting in FM synthesis30), or when a step sequencer produces instantaneous changes (a transient with theoretically infinite frequency content), the digital system becomes highly susceptible to aliasing. Aliasing occurs when generated sidebands exceed the Nyquist frequency ([Figure omitted from source export]) and reflect back into the audible spectrum as dissonant, inharmonic frequencies43.

To safeguard the modulation matrix against aliasing, two primary DSP techniques are conditionally deployed, as summarized in Table 2\.

 

The Ghost Effect

A notorious issue in complex DSP systems and nested modulation matrices is the "Ghost Effect." This occurs when residual energy—such as offsets in delay lines, integrator memory in envelope followers, or historical states in filters—bleeds into subsequent playback events, causing clicks, pops, or unwanted tonal artifacts52. The architecture requires a dedicated diagnostic contract to ensure pristine state initialization, clearing all buffers and integrators to absolute zero when a voice is re-triggered or the matrix is reset.

Interaction Design: Visualizing Depth on Mobile

A sophisticated, deeply nested modulation matrix can quickly become unintelligible if the user cannot visually parse the signal flow. On mobile interfaces and web applications where screen real estate is severely constrained, standard spreadsheet-style matrix grids fail entirely, inducing cognitive overload.

The interaction design relies on contextual, object-oriented UI principles tailored for capacitive touch:

• Modulation Arcs: Instead of displaying modulation depth on a disconnected, abstract grid page, the base parameter knob is surrounded by a secondary, color-coded arc indicating the bipolar or unipolar modulation depth. If LFO 1 (assigned the color blue) is modulating Filter Cutoff, a blue arc appears around the Cutoff knob spanning the exact minimum and maximum range of the modulation.
• Animated Rings: To demonstrate active movement and confirm that routing is functioning, a glowing indicator travels along the modulation arc in real-time, displaying the instantaneous [Figure omitted from source export] value calculated by the matrix.
• Long-Press Drag-and-Drop: Users assign modulation by long-pressing a source (e.g., tapping and holding Envelope 1\) and dragging a visual tether to a destination knob. Upon connection, the screen enters a temporary "Routing Mode" where turning the knob adjusts the modulation depth rather than the base value.
• Collapsible Diagnostic Menus: Tapping a parameter reveals a localized, collapsible list of all incoming modulation sources affecting it. This menu displays their additive or multiplicative mathematics, allowing for quick deletion or granular depth adjustment without leaving the context of the parameter.

Software Contracts and Specifications

To guarantee system stability, enforce the zero-allocation rules, and enable cross-platform compatibility (e.g., serializing a patch in a Web Audio browser and loading it in a C++ VST), the architecture relies on strict software contracts. The following TypeScript and C++ hybrid interfaces define the system's core capabilities, bounds, and diagnostics.

1. Data Structures and Routing Contracts

The data structures must enforce the allowed ranges, transfer semantics, and the Visitor Authority principle.

 

 

 

TypeScript

// Enforces allowed ranges, transfer semantics, and visitor authority interface ModulationDestination {     readonly id: string;     readonly canonicalMin: number;     readonly canonicalMax: number;     readonly scaleMode: 'linear' | 'exponential' | 'logarithmic';          // The base state authored by the user. Never overwritten by modulators.     baseValue: number;  }

// Bounded state for reproducible stochastic sources (e.g., Random Walk, Coherent Noise) interface DeterministicSeededState {     seed: number;     position: number; }

// Contract for all generators. Must yield normalized floats. interface ModulationSource {     readonly id: string;     readonly isAudioRate: boolean;     // Evaluates the source. Must strictly return a value in \[-1.0, 1.0\] or \[0.0, 1.0\]     generateValue(time: number, state: DeterministicSeededState): number;  }

// Contract defining the edge of the DAG interface ModulationRoute {     sourceId: string;     destinationId: string;     depth: number; // Bounded strictly to \[-1.0, 1.0\]     semantic: 'additive' | 'multiplicative';     smoothingTimeConstant: number; // For anti-zippering on block-rate updates }

2. The Modulation Matrix and Performance Limits

The engine implementation dictates the pre-allocation of resources to avoid garbage collection, alongside the lock-free SPSC queue for thread-safe interaction.

 

 

 

C++

class ModulationMatrix { public:     // Fixed capacity ensures no runtime allocation (Zero-Garbage rule)     static constexpr size\_t MAX\_ROUTES \= 256;          // Updates DAG and performs topological sort.      // Invoked via SPSC queue to ensure audio thread safety.     void bindRoute(const ModulationRoute& route);          // Processes all active modulations. Topological sorting handles dependencies.     // Detects cycles and applies z^-1 delays automatically.     // Executed exactly once per audio render block.     void processMatrix(size\_t numSamples);

private:     std::array\<ModulationRoute, MAX\_ROUTES\> activeRoutes;     DirectedAcyclicGraph dependencyGraph;          // Lock-free queue for receiving UI parameter changes without mutexes     SPSCQueue\<ParameterChange\> paramQueue; };

3. Diagnostics and Ghost Effect Tests

To ensure the engine behaves predictably in automated CI/CD pipelines, strict diagnostic contracts are implemented.

 

 

 

TypeScript

interface DiagnosticContracts {     /\\      \ Ghost Effect Test:      \ Asserts that after calling reset(), passing zero-energy audio      \ through the matrix and DSP yields strictly 0.0 across all output buffers.      \ Validates that envelopes, IIR filters, and leaky integrators have no residual state.      \/     testResidualStateClear(matrix: ModulationMatrix, dsp: AudioEngine): boolean;          /\\      \ Canonical Bound Limit Test:      \ Drives all modulation depths to theoretical maximums and inputs \+1.0 signals.      \ Asserts that no destination exceeds its canonicalMin or canonicalMax.      \/     testCanonicalBounds(matrix: ModulationMatrix): boolean;          /\\      \ Performance Limit Test:      \ Fills all MAX\_ROUTES with audio-rate modulations.      \ Asserts that matrix execution time remains safely under the 3ms       \ Web Audio API budget at 44.1kHz.      \/     testExecutionBudget(matrix: ModulationMatrix): boolean; }

4. Serialization and Interaction Design

Serialization of the matrix state must be decoupled entirely from the audio engine's internal state. It captures only the exact parameters required to perfectly recreate the deterministic graph and the interaction UI.

 

 

 

TypeScript

interface SerializedPatch {     version: "1.0.0";     globalSeed: number; // Ensures random walks and coherent noise replay identically     baseParameters: Record\<string, number\>; // The visitor authority base state     routes: Array\<{         src: string;         dest: string;         amt: number;         op: 'add' | 'mult';     }\>; }

interface InteractionDesignContract {     // Maps a modulation depth to a UI arc overlay     renderModulationArc(destinationId: string, activeRoutes: SerializedPatch\['routes'\]): void;     // Animates the instantaneous value along the arc     updateIndicatorRing(destinationId: string, currentValue: number): void; }

Conclusion

The implementation of a reusable, high-performance modulation matrix shifts an audio engine from a static playback tool into a dynamic environment for sonic motion-design. By mapping abstract structural concepts—such as Euclidean geometry, random walks, and frequency analysis—to synthesis destinations, sound designers are granted limitless combinatorial potential.

Achieving this level of flexibility without performance degradation, aliasing, or sonic artifacting requires uncompromising architectural discipline. Through the use of topological sorting for DAG-based execution, SPSC lock-free queues for zero-allocation memory safety, strict visitor authority to preserve base states, and mathematical anti-aliasing techniques to protect audio-rate boundaries, the system remains entirely stable under the most chaotic user configurations. Ultimately, the synthesis of strict deterministic bounds and fluid visual interaction design ensures that even the most deeply nested parameter modulations remain under the artist's total control.

Works cited

1. Moog Modular Synthesizer with Web Audio API \- GitHub, https://github.com/mirchaemanuel/moog-modular

2. Simple Web Synth Architecture \- Adam Murray's Blog, https://adammurray.link/web-audio/simple-web-synth/architecture/

3. SynthLab SDK: Modulation Matrix, https://www.willpirkle.com/synthlab/docs/html/mod\_matrix.html

4. modulation matrix \- modor digital polyphonic synths, https://www.modormusic.com/modmatrix.html

5. Building Modular Audio Nodes in Web Audio \- Casey Primozic, https://cprimozic.net/blog/building-modular-audio-nodes-in-web-audio/

6. How to handle Modulations \- General JUCE discussion, https://forum.juce.com/t/how-to-handle-modulations/36660

7. Web Audio API, https://padenot.github.io/web-audio-api/

8. Web Audio API 1.1 \- W3C, https://www.w3.org/TR/webaudio-1.1/

9. Ways to Connect Env,LFO,Macro to Variables \- Audio Plugins \- JUCE, https://forum.juce.com/t/ways-to-connect-env-lfo-macro-to-variables/24350

10. Neo: Gen AI Driven Personal Assistance Using GPT 4.0 \- IRJET, https://www.irjet.net/archives/V12/i4/IRJET-V12I4177.pdf

11. The Ardour DAW – Latency Compensation and Anywhere-to, https://gareus.org/misc/thesis-p8/2017-12-Gareus-Lat.pdf

12. An Object-Oriented Metamodel for Digital Signal Processing with a, https://amatria.in/Thesis.pdf

13. Arch: An AI-Native Hardware Description Language for Register, https://arxiv.org/html/2604.05983v2

14. QoS Support Path Selection for Inter-Domain Flows Using Effective, https://www.mdpi.com/2079-9292/11/14/2245

15. Floorplan Design and Yield Enhancement of 3-D Integrated Circuits, https://pdxscholar.library.pdx.edu/context/open\_access\_etds/article/3814/viewcontent/nain\_rajeev\_\_kumar\_2011.pdf

16. Data Generator Euclidean Rhythm | Usine Hollyhock Manual, http://www.brainmodular.com/manuals/hh7/en/modules/data/generator/data-generator-euclidean-rhythm

17. Making Audio Plugins Part 11: Envelopes \- Martin Finke's Blog, https://www.martin-finke.de/articles/audio-plugins-011-envelopes/

18. MSEG \- Implemented \- Bitwish, https://bitwish.top/t/mseg/27

19. 5 Things You Can Do With MSEGs \- Bitwig Studio, https://www.bitwig.com/learnings/5-things-you-can-do-with-msegs-248/

20. Expressiveness in Sound Design | AudioServices Studio, https://audioservices.studio/blog/expressiveness-sound-design

21. Dynamics processing: Compressor/Limiter, part 1 \- flyingSand, https://christianfloisand.wordpress.com/2014/06/09/dynamics-processing-compressorlimiter-part-1/

22. Envelope reconstruction algorithm for audio processing, https://dsp.stackexchange.com/questions/62153/envelope-reconstruction-algorithm-for-audio-processing

23. Audio Reactive Programming: Envelope Followers, https://kferg.dev/posts/2020/audio-reactive-programming-envelope-followers/

24. Euclidean Rhythms Part 1: Maximum Evenness, Maximum Groove, https://www.lawtonhall.com/blog/euclidean-rhythms-pt1

25. Euclidean Rhythms \- Medium, https://medium.com/code-music-noise/euclidean-rhythms-391d879494df

26. Euclidean rhythms: Björklund's algorithm in Python · GitHub, https://github.com/brianhouse/bjorklund

27. Whitepaper: A novel Algorithm for generating rhytmic structures, https://moinsound.wordpress.com/2022/08/21/whitepaper-a-novel-algorithm-for-generating-rhytmic-structures-inspired-by-bjorklund-touissant/

28. Bjorklund's vs Bressenham's algorithm for Euclidean rhythms \- Reddit, https://www.reddit.com/r/synthdiy/comments/1jxirk4/bjorklunds\_vs\_bressenhams\_algorithm\_for\_euclidean/

29. How Does The Modulation Matrix Work In Subtractive Synthesis?, https://www.youtube.com/watch?v=9hr15nZKQlI

30. A Different Introduction to the Web Audio API | by Daniel McKemie, https://medium.com/@danielmckemie/tips-and-techniques-for-using-the-web-audio-api-89b8beda6cf2

31. GitHub \- torrancecui/FM-Synthesizer: Frequency modulated, https://github.com/torrancecui/FM-Synthesizer

32. Building a Wavetable Synthesizer from Scratch with Rust, https://cprimozic.net/blog/buliding-a-wavetable-synthesizer-with-rust-wasm-and-webaudio/

33. DSP Technology \- Powersoft, https://www.powersoft.com/en/technologies/dsp-technology

34. Audio Processing and Generation in Max/MSP \- Packt, https://www.packtpub.com/en-us/learning/how-to-tutorials/audio-processing-and-generation-maxmsp

35. High Performance Web Audio with AudioWorklet in Firefox, https://hacks.mozilla.org/2020/05/high-performance-web-audio-with-audioworklet-in-firefox/

36. Wasm Audio Worklets API \- Emscripten 6.0.7-git (dev) documentation, https://emscripten.org/docs/api\_reference/wasm\_audio\_worklets.html

37. Audio worklet design pattern | Blog \- Chrome for Developers, https://developer.chrome.com/blog/audio-worklet-design-pattern

38. spsc-queue · GitHub Topics, https://github.com/topics/spsc-queue

39. A Simple Lock-free Ring Buffer \- Kmdreko's, https://kmdreko.github.io/posts/20191003/a-simple-lock-free-ring-buffer/

40. Building a High-Performance Lock-Free Ring Buffer in C++ for Ultra, https://dev.to/lakshya\_bankey\_27825e4908/building-a-high-performance-lock-free-ring-buffer-in-c-for-ultra-low-latency-messaging-19h6

41. Ring Buffer and it's implementation in C | by Subrata Sarkar | Medium, https://sxvyte.medium.com/ring-buffer-and-its-implementation-in-c-bd687e40e903

42. Background audio processing using AudioWorklet \- Web APIs | MDN, https://developer.mozilla.org/en-US/docs/Web/API/Web\_Audio\_API/Using\_AudioWorklet

43. Antialiasing the modulation \- DSP and Plugin Development Forum, https://www.kvraudio.com/forum/viewtopic.php?t=480748

44. Aliasing Artifacts \- AES Audio, https://www.audiolabs-erlangen.de/content/resources/aesCodingTutorial/aliasing.html

45. Introduction to Oversampling for Alias Reduction \- Nick Thompson, https://www.nickwritesablog.com/introduction-to-oversampling-for-alias-reduction/

46. How do Anti-Aliasing-Filters in audio signal processing work?, https://dsp.stackexchange.com/questions/55096/how-do-anti-aliasing-filters-in-audio-signal-processing-work

47. Downsampling with Anti-Aliasing | Spectral Audio Signal Processing, https://www.dsprelated.com/freebooks/sasp/Downsampling\_Anti\_Aliasing.html

48. Sampling, Oversampling, and Aliasing Part 2 | Musik Hack Blog, https://www.musikhack.com/blog/sampling-oversampling-and-aliasing-part-2/

49. Reducing the aliasing of nonlinear waveshaping using continuous, https://dafx.de/paper-archive/2016/dafxpapers/20-DAFx-16\_paper\_41-PN.pdf

50. Interpolation Filters for Antiderivative Antialiasing, https://dafx.de/paper-archive/2024/papers/DAFx24\_paper\_33.pdf

51. (PDF) Antiderivative Antialiasing Techniques in Nonlinear Wave, https://www.researchgate.net/publication/356185570\_Antiderivative\_Antialiasing\_Techniques\_in\_Nonlinear\_Wave\_Digital\_Structures

52. Switching power converter and system for controlling a plurality of, https://patents.google.com/patent/CN101510730A/en

53. Creative Effects \- pdfcoffee.com, https://pdfcoffee.com/creative-effects-pdf-free.html