Praat AudioTools – Detailed Script Overview

AI & Adaptive 27

Bayesian Drone Weaver

This script implements Bayesian Drone Weaver, an algorithmic composition system that analyzes audio clips, classifies them into musical gesture types using Bayesian inference, constructs intelligent timelines, and weaves them into continuous ambient drone textures. Process: (1) Audio analysis: Extract intensity, spectral, harmonic, and temporal features from each clip. (2) Bayesian classification: Compute posterior probabilities for five gesture hypotheses (Sustain, Swell, Tension, Air, Pulse). (3) Timeline construction: Build narrative arc (intro→development→climax→resolution) by matching clip characteristics to phase-based targets. (4) Overlap assembly: Mix clips with calculated overlaps and crossfades to create seamless drone. Result: Algorithmically composed ambient piece from raw audio materials.

Chaotic Neural Map Modulator

This script implements a chaotic neural‑network modulator that learns features from your audio, then generates unpredictable modulation signals using a trained neural network with injected chaos parameters. The result is organic, evolving transformations that are different every time.

Gesture-Based Hard Quantization

This script implements gesture-based hard quantization, a technique that reconstructs a reference sound by replacing its temporal segments with the most acoustically similar segments from a dictionary of gesture sounds. It analyzes pitch and intensity contours to find optimal matches, with configurable parameters controlling the balance between similarity, diversity, and repetition.

Gestural Accumulator

This script transforms a single sound gesture into a compositional canon, an accumulating sequence of transformed variants arranged according to acoustic similarity. It generates multiple pitch, time, and formant‑shifted versions of the input, analyzes their MFCC feature space, then sequences them using a "budget‑as‑schedule" algorithm that controls the pacing and overlap rhetoric of the resulting accumulation.

Genetic Recomposer

This script implements evolutionary audio recombination, a genetic algorithm approach to sound transformation that treats audio segments as genetic material to be sliced, recombined, and evolved over generations. The process: (1) Segment Extraction: Automatically slices input audio into variable-length segments based on genome parameters. (2) Population Initialization: Creates multiple "individuals" with different segmentation, reordering, and processing characteristics. (3) Fitness Evaluation: Scores each individual based on rhythmicity, continuity, and novelty. (4) Evolutionary Loop: Selects best performers, breeds new individuals through crossover and mutation. (5) Convergence: Over 10-15 generations, evolves toward optimal recombination based on fitness criteria.

Granular Attention Re-synthesis

This script implements a Granular Attention Re-synthesis engine, a novel approach where grains compete for being chosen (selection probability), not for gain. The source re-synthesizes itself from its own most energetic (or most transient) moments using a ReLU + Softmax attention mechanism applied to grain selection.

Hidden Markov Model (HMM) Timbre Sequencing

This script implements a Hidden Markov Model (HMM) timbre sequencer, an advanced algorithm that analyzes the timbral evolution of a source sound, learns probabilistic transitions between timbre states, and generates new audio sequences that preserve the original sound's timbral relationships while creating novel temporal patterns.

LZ-Inspired Audio Variations

Drives algorithmic variation through lossless-compression-inspired pattern matching, analyzing audio windows via pitch, spectral, or intensity features to build a similarity dictionary using optimized sort-and-sweep algorithms with early termination. The system identifies statistically similar segments through vectorized distance metrics (Euclidean, correlation, cosine), then generates variations through stochastic pitch shifting, time stretching, amplitude modulation, spectral filtering, reversal, or granular shuffling. Implements Lempel-Ziv style dictionary coding for audio, enabling efficient reuse of similar patterns while introducing controlled randomness—ideal for generative music, algorithmic remixing, and intelligent audio transformation with semantic coherence.

Morphic Form

This script implements a Morphic Form grain placement engine, a system that generates new sonic structures by controlling ONLY the placement parameters of grains extracted from a source sound. Unlike granular synthesis that alters spectral content, this engine preserves the original spectral character completely, reshaping only when grains occur, how long they are, how much jitter they have, and whether they repeat or backtrack.

MSE Feature-Constrained Variation

This script implements an MSE Feature-Constrained Variation tool, an experimental sound design system that extracts a high-dimensional feature vector from an audio source and then iteratively applies transformations until the transformed sound reaches a target mean squared error (MSE) distance band from the original. The tool preserves overall duration while transforming spectral and temporal characteristics.

Neural Ambient Drone Designer

This script implements neural-inspired ambient drone generation, an intelligent granular synthesis approach that analyzes source audio for spectral stability, identifies the most tonal segments through clustering, and recombines them into infinite lush ambient textures. Process involves: (1) Feature extraction: Spectral centroid, bandwidth, harmonicity, and pitch analysis across audio grains. (2) AI clustering: K-means grouping of similar spectral profiles. (3) Tonal selection: Identification of most harmonic cluster for drone foundation. (4) Generative synthesis: Randomized grain recombination with optional octave shimmer effects. Result: evolving, texturally rich ambient drones that preserve the spectral character of the source while creating entirely new sonic landscapes.

Neural Audio Mosaic

This script implements a neural audio mosaic system that reconstructs one audio file (Target) using only small grains from another audio file (Source). Through sophisticated feature analysis and stochastic search, it finds the best-matching Source grains for each Target grain, creating a hybrid audio result that preserves the structural characteristics of the Target while adopting the textural qualities of the Source.

Neural Delay Control

This Praat script implements an intelligent delay effect that uses a feedforward neural network (FFNet) to adaptively control delay parameters based on the acoustic characteristics of the input audio. The system first extracts 18 acoustic features per frame, including 12 MFCC coefficients, three formant frequencies (F1, F2, F3), normalized intensity, harmonics-to-noise ratio (HNR), and fundamental frequency (F0). These features are analyzed to compute initial target values for two control parameters: mix (the amount of delayed signal blended with the dry signal) and feedback (the amount of output fed back into the delay line). The neural network is then trained over a specified number of epochs to learn the relationship between acoustic features and optimal delay settings, with the training optimized to favor higher mix and feedback for tonal, pitched sounds with high harmonicity while suppressing the effect during transients and sudden intensity changes. After training, the network generates smoothed control parameter trajectories that are applied sample-by-sample to create an adaptive delay effect where the delay time remains constant but the mix and feedback continuously adapt to the evolving timbre and texture of the audio, producing a delay that responds musically to the content rather than applying uniform processing throughout.

Neural Granular Texture Morpher

Morphs between different granular sound textures using a neural network. The algorithm transitions one texture into another smoothly, enabling evolving soundscapes where one timbral texture gradually becomes another in a creative, machine-guided way.

This script implements a neural granular texture morpher that combines granular synthesis with unsupervised machine learning to analyze, categorize, and regenerate audio textures. Unlike traditional granular synthesis that uses random or sequential grain selection, this system employs K-Means clustering to discover natural sonic categories within your audio and creates intelligent morphing patterns that transition between these discovered textures.

Neural Markov Soundscape Weaver

This script implements neural Markov soundscape weaving, a sophisticated temporal modeling approach that analyzes both the spectral content AND temporal evolution of source audio. Process involves: (1) Granular decomposition: Splits audio into discrete grains (non-overlapping). (2) Texture state learning: K-means clustering groups grains into spectral states. (3) Temporal grammar modeling: Markov chain analysis learns transition probabilities between states. (4) Generative weaving: New sequences generated by sampling grains from current state and transitioning via learned probabilities. Result: infinite streams that preserve both the spectral vocabulary AND temporal flow patterns of the original source.

Neural Phonetic Harmonizer

This Praat script implements an intelligent harmonization system that automatically classifies speech or audio into four phonetic categories and applies different pitch-shifted harmony voices to each. The system first extracts 18 acoustic features per frame, including 12 MFCC coefficients, three formant frequencies (F1, F2, F3), normalized intensity, harmonics-to-noise ratio (HNR), and fundamental frequency (F0). Audio frames are pre-classified into four categories using acoustic heuristics: vowels (high HNR, pitched, prominent F1), fricatives (low HNR, unpitched, sufficient intensity), other sounds (everything else above silence threshold), and silence (very low intensity). A feedforward neural network (FFNet) with configurable hidden units is then trained to learn these classifications from the feature vectors, using early stopping to prevent overtraining. After training, the network generates per-frame probability distributions across the four classes, which are converted to mixing weights using temperature-scaled softmax with an optional voiced boost that increases vowel harmony during pitched, harmonic segments. Four parallel copies of the original audio are created, each pitch-shifted by a user-defined interval in semitones using manipulation and overlap-add resynthesis. These harmony voices are then dynamically mixed using IntensityTiers that modulate the amplitude of each voice according to the neural network's frame-by-frame classification confidence and user-specified mix levels, creating an adaptive harmonization where vowel passages might be harmonized at a perfect fifth (+7 semitones), fricatives at a perfect fourth below (-5 semitones), and other sounds at a major third (+4 semitones), with all mixing amounts responding intelligently to the evolving phonetic content of the audio.

Neural Phonetic Speed Mapper

This Praat script implements an adaptive speech speed modification system powered by a neural network that learns to classify phonetic segments and applies differential time-scaling based on sound type. Unlike traditional uniform time-stretching, this script extracts 18 acoustic features (MFCCs, formants, pitch, intensity, harmonicity) every 5 milliseconds, trains a feedforward neural network to classify each frame as vowel, fricative, other consonant, or silence, then applies independent speed multipliers to each category. The result is speech that can be dramatically accelerated while preserving intelligibility by giving critical sounds (especially fricatives) more relative time. The script uses early-stopping training, voicing-adaptive boosting, confidence-based mixing, temporal smoothing, and PSOLA resynthesis to produce natural-sounding output with configurable speeds ranging from extreme slow-down to 3× acceleration per phonetic class.

Neural Adaptive Phonetic Vibrato

This script implements neural network-based phonetic vibrato processing, an intelligent audio effect that applies stereo vibrato selectively to vocal vowels while leaving consonants, fricatives, and non-vocal sounds untouched. Unlike traditional vibrato effects that indiscriminately modulate the entire signal, this system uses a trained neural network to classify audio frames into phonetic categories (vowel, fricative, silence, other), then generates "liquid masks" that smoothly blend between dry and vibrato-processed signals based on phonetic content. The result is a natural-sounding vocal enhancement that adds rich stereo vibrato to sustained vowels without affecting speech intelligibility or introducing unnatural modulation to consonants.

NMF Spectral Resynthesizer

This script implements Non‑negative Matrix Factorization (NMF) with dual‑mode smoothing and pitch‑locked resynthesis. It decomposes a sound’s spectrogram into spectral bases (W) and temporal activations (H), then reconstructs with perceptual smoothing and original pitch contour.

OT Corpus Concatenator

This script implements Optimality Theory-based audio concatenation, a computational linguistics-inspired approach to automatically select and concatenate audio files from a corpus based on weighted constraint satisfaction. The system analyzes each audio file for four key acoustic properties, computes constraint violations, and ranks files by their Harmony Score (lower = better). The top N files are then concatenated into a single optimized audio sequence.

Parametric Autoencoder Resynthesis with Variations

This script implements a parametric autoencoder for voice analysis and PSOLA-based resynthesis, a two-stage process that: (1) Uses a neural network autoencoder to learn a compact representation of voice parameters (pitch + 4 formants), and (2) Applies PSOLA (Pitch Synchronous Overlap Add) resynthesis to generate realistic voice transformations based on modified parameters, including dramatic voice character changes.

PCA Timbre Selector

This Praat script implements a sophisticated timbre selection tool that uses Principal Component Analysis (PCA) to identify and extract audio segments matching specific timbral characteristics. The script analyzes multiple acoustic features per frame including fundamental frequency (F0), intensity, spectral centroid, spectral spread, bandwidth, harmonics-to-noise ratio (HNR), and dominant frequency. These features are standardized and projected into a reduced dimensional space using PCA, where the first three principal components typically capture spectral brightness, harmonicity, and pitch characteristics. Users can either select from seven preset timbre profiles (Bright/Clear, Dark/Mellow, Breathy/Airy, Strong/Focused, High Pitch, Low Pitch, or Neutral) or specify custom target values in the principal component space. The script then computes the Euclidean distance from each analyzed frame to the target timbre profile, selects segments that fall below a statistical threshold, and concatenates them to produce a new sound object containing only the portions of the original audio that match the desired timbral quality, complete with diagnostic information about the number of extracted segments and target coordinates.

PCA Tone Shaper

This Praat script implements an intelligent tone shaping system that uses Principal Component Analysis to create adaptive spectral equalization based on the evolving acoustic characteristics of the audio. The script first extracts eight acoustic features per analysis frame: the first three formants (F1, F2, F3), formant ratios (F2/F1 and F3/F2), fundamental frequency (F0), intensity, and harmonics-to-noise ratio (HNR). These features are standardized into z-scores and projected into a three-dimensional principal component space, where the components typically capture information about spectral tilt, presence/harmonicity, and body/low-end characteristics. For each processing chunk (user-defined duration, default 200ms), the script computes the mean values of the first three principal components and maps these to gain values for three frequency bands: low (0–200 Hz), mid (200–2000 Hz), and high (2000–8000 Hz). The audio is split into these bands using Hann-windowed spectral filtering, each band is scaled by its computed gain factor (constrained between 0.5× and 1.5×), and the bands are recombined to produce a dynamically equalized output where the tonal balance evolves in response to the timbral content, creating an adaptive tone shaping effect that emphasizes different spectral regions based on the acoustic character of each moment in the audio.

Perceptual Graph Explorer

The Perceptual Graph Explorer analyzes audio by extracting three perceptual features from sliding windows, creating a 3D feature space, clustering similar windows together, and reconstructing separate audio streams for each cluster. Think of it as "color separation for audio" - different texture types are extracted into separate layers.

Perceptual Synchrony

This script implements Perceptual Synchrony Pipeline, a system for detecting and enhancing acoustic synchrony between two audio signals. Process: (1) Feature extraction: Intensity, spectral centroid, and spectral slope over time. (2) Gesture detection: Identify meaningful acoustic changes as "gestures" (80-2000ms). (3) Gesture tagging: Classify gestures into perceptual categories (brightness rise/fall, noise bloom, spectral drop, accent peak, intensity swell, smooth arc). (4) Clustering: Find matching gestures between signals using temporal proximity and structural similarity. (5) Binding effects: Apply audio processing to enhance perceived synchrony (amplification, timbral stamping, stereo width modulation). Result: Stereo mix where similar gestures are perceptually bound together.

Self-Attention Recomposer

This script implements a Self-Attention Recomposer, an AI-inspired tool that segments audio into chunks, computes MFCC (Mel-frequency cepstral coefficient) embeddings for each chunk, and uses a self-attention mechanism to generate a new ordering based on spectral similarity. The result is a recomposed audio file that follows the statistical patterns of the original while creating novel sequences.

Timbral Similarity Browser

This script implements timbral similarity browsing, an intelligent content-based approach to navigating sound collections. Process involves: (1) Batch loading: Automatically loads all WAV files from a folder with stereo-to-mono conversion. (2) MFCC analysis: Extracts Mel-Frequency Cepstral Coefficients to capture perceptual timbral characteristics. (3) Similarity computation: Calculates Euclidean distances between mean MFCC vectors. (4) Path construction: Creates optimal listening sequence using nearest-neighbor algorithm. (5) Seamless concatenation: Joins sounds in similarity order for continuous playback. Result: A single audio file that flows naturally from one sound to its most timbrally similar neighbor, creating an intuitive acoustic journey through the collection.

↑ Back to top

Analysis 35

Acoustic Pedagogy

This script provides 15 interactive acoustic demonstrations covering fundamental psychoacoustic and musical phenomena. Each demonstration generates and plays sounds with visual representations, making abstract concepts tangible through direct auditory experience.

Acoustic Features Batch Extraction

This script implements batch acoustic feature extraction, a comprehensive analysis tool that processes multiple audio files simultaneously and extracts 8 key acoustic metrics: (1) Intensity Mean: Overall loudness/energy level in dB. (2) Harmonicity Mean: Degree of periodicity/tonality. (3) Jitter (Local): Short-term pitch perturbation. (4) Spectral Roll-off (85%): Frequency below which 85% of energy is concentrated. (5) Spectral Flatness: Noise-to-tonality ratio in spectrum. (6) Spectral Roughness: Local spectral irregularity. (7) Spectral Power Ratio (SPR): Low-to-high frequency balance. (8) Band-specific Maxima: Peak spectral density in low/high bands.

Adaptive Transient Decomposition

This script implements adaptive transient decomposition, a sophisticated signal processing technique that separates audio into two distinct components: transients (sharp, impulsive events like drum hits, consonants, attacks) and residual (sustained, tonal content like vowels, pads, reverberation). The method uses Linear Predictive Coding (LPC) to model the predictable components of the signal, then applies mathematical sigmoid gating to precisely isolate transient events based on their energy characteristics.

Auditory Scene Analysis Demonstrations

Auditory Scene Analysis (ASA) is the process by which the human auditory system organizes sound into perceptually meaningful elements. In real-world listening, multiple sound sources overlap in time and frequency. ASA explains how we segregate these sources into separate "streams" and perceive them as distinct auditory objects.

Audio Descriptions and Global Statistics

This script performs comprehensive audio feature extraction on multiple sound files simultaneously, computing 19 quantitative descriptors covering pitch statistics, intensity dynamics, voice quality metrics (jitter, shimmer, harmonicity), and advanced spectral characteristics (centroid, spread, rolloff, flatness, roughness). Output: structured table with one row per sound file, ready for statistical analysis, machine learning, or comparative studies. Perfect for: corpus analysis, instrument classification, voice quality assessment, sound design comparison, experimental composition research. Automated batch processing, analyze hundreds of files in minutes without manual measurement.

Brightness Classifier

Analyzes the spectral centroid ("brightness") of sounds and classifies each into categories (e.g. very dark, dark, medium, bright, very bright). This helps quickly tag or sort sounds by brightness, which is useful for selecting samples by timbre or balancing the timbral brightness in a mix or experimental palette.

Climax Profile Matcher

This script implements a Climax Profile Matcher, an adaptive audio tool that analyzes the climax characteristics of a Source sound and transfers them to a Target sound. It detects regions in the Source that qualify as "climaxes" (peak intensity, high pitch, bright spectral tilt, and strong harmonicity), extracts their acoustic profile, and applies transformations to make the Target sound match that profile.

Chord Detection

Analyzes polyphonic audio to detect musical chords present. It identifies the combination of pitches sounding at a given time and outputs chord names, providing harmonic information from audio. This can guide compositional decisions by extracting underlying chord progressions from recordings.

Continuous Pitch over MIDI Grid Visualizer

Provides a visualization of a sound's continuous pitch contour over a MIDI-note grid. It plots the pitch curve with color-coding, auto-scaling, and smoothing, so one can see microtonal variations and glides relative to standard MIDI notes. This helps composers observe intonation and pitch movement in a performance for analysis or transcription.

Correlation-Based Pitch Class Extraction

Identifies which pitch classes (musical note classes, ignoring octave) are present in an audio signal by correlating the sound's spectrum or pitch content with reference pitch class profiles. It outputs the set of detected notes (e.g. A, C#, F, etc.), which is useful for harmonic analysis or deriving scale/mode information from an audio recording.

DTW-Aligned Multi-Feature Audio Analysis (MFCC, Loudness, Pitch)

Uses Dynamic Time Warping to compare and align two audio files' features over time. It finds an optimal alignment path between the two signals (even if one is performed faster than the other), which helps in comparing performances or aligning events between two recordings of similar content.

Extract Segment

This script implements precise audio segmentation, extracting defined time intervals from sound objects with multiple selection and processing options. Key capabilities: (1) Multiple selection: Extract from multiple sound objects simultaneously. (2) Flexible time specification: Absolute times, percentages, or marker-based. (3) Overlap handling: Extract overlapping segments with fade options. (4) Batch processing: Process multiple intervals in one operation. Process copies selected time region from source sound, applies optional fade in/out, creates new sound object with extracted segment. Result: cleanly extracted audio segments ready for further analysis or composition.

Formant to MIDI Chord Converter

Analyzes a sound's formant frequencies (resonant peaks, often from voice formants) and maps them to nearest musical pitches, generating a corresponding MIDI chord. In other words, it treats prominent formant frequencies as notes of a chord. This allows a composer to derive harmonic material from speech or timbral characteristics of a sound.

Formant to MusicXML Chord Converter

Similar to the above, it converts detected formant frequencies into a chord but outputs it in MusicXML format (a notation-friendly format). This lets one import the chord progression into music notation or composition software. It's a way of turning timbral formant data into written harmonic material for further musical development.

Kick detector and bass adder

Detects kick drum hits in an audio track and automatically adds a bass tone or reinforcement to each kick. Essentially, it finds the timing of kick drum events and layers an additional low-frequency sound (like a sine wave bass or tuned bass note) on those beats. This can beef up the low end in production or creatively augment a rhythmic track in composition.

Krumhansl-Schmuckler Key Profiler

This script implements the Krumhansl-Schmuckler key-finding algorithm, a psychological model of key perception that correlates audio pitch-class distributions with empirically-derived key profiles. Process: (1) Spectral analysis: Extract spectral peaks from sliding windows. (2) Chroma vector construction: Build 12-dimensional pitch-class distribution (C, C#, D, ..., B). (3) Profile correlation: Compute Pearson correlation between audio chroma and 24 key profiles (12 major, 12 minor). (4) Key identification: Select key with highest correlation as detected key. Result: Automatic key detection with confidence scores and visualizations.

Melodic Contour-Parsons Code extraction

This script implements Parsons Code extraction, a melodic contour analysis system that converts audio into Parsons code (U/D/R/*). Process: (1) Segmentation: Detect notes/syllables using silence detection. (2) Pitch analysis: Extract fundamental frequency for each segment. (3) Contour encoding: Compare consecutive pitches, encode direction as U (up), D (down), R (repeat/reference), * (first note). (4) Threshold application: Use semitone threshold to determine what constitutes meaningful change. Result: Compact symbolic representation of melodic contour suitable for music retrieval, analysis, and comparison.

MFCC

Extracts Mel-Frequency Cepstral Coefficients from the audio, which are a set of features representing the sound's timbral texture. MFCCs are commonly used to characterize timbre for tasks like sound classification. In composition, these coefficients (or comparisons of them) can be used to guide timbral similarity decisions or to drive synth parameters for timbre matching between sounds.

Multi-Band Onset Detector

Detects attack onsets (transient beginnings of events) in multiple frequency bands separately. The audio is split into bands and each is analyzed for sudden increases in energy. This yields a detailed picture of where new events occur in low, mid, high frequencies, etc., valuable for rhythmic analysis or for triggering events in a composition whenever a certain band registers an onset.

Multi-Layer Audio Visualizer (EAnalysis Style)

SpectraScore is a lightweight spectral orchestration tool inspired by IRCAM's Orchidée and Orchidea systems. It analyzes a target sound's acoustic properties (pitch, loudness, timbre, harmonicity) and automatically searches through combinations of orchestral instruments to find the best timbral match.

Musikalisches Würfelspiel Audio Game

Analyzes audio segments through intensity, pitch, and spectral centroid features to classify them into harmonic functions (Tonic, Predominant, Dominant, Cadence), then reorders them according to a T‑P‑D‑C pattern while applying expressive phrasing (ritardando, diminuendo) at phrase endings, creating algorithmic recompositions from any audio source.

OT Grammar Learning from Audio

Analyzes a melodic or temporal pattern in audio using Optimality Theory constructs, effectively trying to infer an OT grammar that could produce that audio pattern. In practice, it might derive a set of ranked constraints (like a simple grammar) that explain the timing or melodic choices in the audio. This is an experimental analysis linking audio patterns to formal grammar rules, which could be used for algorithmic composition or musicological insight.

Pitch Loop Finder

Finds loops or repeating patterns in a sound's pitch contour. It analyzes the pitch track of the audio and tries to identify if a segment of the melody repeats (loops) seamlessly. This tool can be used to detect natural loops in bird songs, melodies, or to extract loopable pitch motifs from a recording for use in a composition.

Pitch and Loudness Comparison Two Sounds

This script implements frame-by-frame audio comparison, a specialized tool for comparing two audio recordings along pitch and loudness dimensions. The tool is designed for educational contexts where a "teacher" recording (model) is compared with a "student" recording (attempt). It performs: (1) Temporal Alignment: Aligns the two recordings by time frame based on analysis step size. (2) Loudness Analysis: Computes intensity contours, compares decibel levels frame-by-frame, calculates statistical differences. (3) Pitch Analysis: Extracts fundamental frequency contours, compares in semitone units, assesses pitch matching accuracy. (4) Comprehensive Metrics: Generates multiple difference measures including average difference, RMS difference, maximum difference, dynamic range comparison, and consistency measures.

Recursive WAV opener

Recursively scans through folders and opens all WAV files found. It automates importing a large number of sounds into Praat. This is helpful in preparation for batch processing or analysis, a composer can load an entire corpus of samples at once (including those in subfolders) to then analyze or process them as needed.

SPEAR Par-Text-Frame Format Parser for Praat

Parses output files from SPEAR (a partial analysis software), specifically the partials text frame format, and makes them usable in Praat. In effect, it converts a list of sinusoidal partial data into a Praat-friendly format. This allows a composer to import detailed spectral partial data (from SPEAR analyses) into Praat for resynthesis or further manipulation.

Scala Scale Auralizer

Loads scales from Scala (.scl) files, maps scale degrees to frequencies through an explicit tuning layer, synthesises tones with a separately‑specified spectrum and envelope, and plays the scale in several modes (ascending, descending, ping‑pong, arpeggio, sustained chord, scale against drone, A/B compare). Includes 19 built‑in scales (historical temperaments, just intonation, non‑octave scales) plus support for any external .scl file.

Spatial Trajectory Tracker

This script implements spatial trajectory tracking, a comprehensive analysis tool for stereo audio that tracks panning position, stereo width, and channel energy distribution over time. The script performs frame‑based analysis on stereo input, calculating: (1) Pan position: ‑1 (full left) to +1 (full right). (2) Stereo width: 0 (mono) to 1 (full stereo). (3) Channel energy: RMS energy per channel. (4) Temporal smoothing: Adjustable moving‑average filtering. (5) Silence gating: Automatic detection and exclusion of silent frames. Key features: (1) 4 Built‑in Presets: Fast overview, detailed analysis, ultra‑smooth, transient‑sensitive. (2) Multi‑panel visualization: Panning trajectory, polar stereo field, waveform display. (3) Statistical analysis: Mean, standard deviation, range, bias classification. (4) Data table output: Comprehensive Praat Table with all computed metrics.

Speech to MusicXML Rhythm Converter

Analyzes a spoken audio clip to extract its rhythm (timing of syllables or speech events) and converts that timing pattern into MusicXML rhythm notation. The output is a sequence of note durations that mirror the speech's timing. This allows composers to take natural speech cadence and repurpose it as notated rhythm in a musical context, integrating speech-like rhythms into instrumental compositions.

Self-Similarity Matrix Calculator

Computes a self-similarity matrix from the audio. This matrix shows how similar each moment of the sound is to every other moment (a visual grid where time on one axis vs time on another, with intensity indicating similarity). It reveals structural repetition or motif reoccurrence in the sound. Composers can use this to identify repeating sections or rhythms to either leverage them (echo them in structure) or to inform live processing (e.g., trigger events when the piece "comes back" to a prior state).

Sonic Syntax

This script implements global optimization for audio boundary detection, a dynamic programming approach to finding the optimal sequence of cuts (phrase boundaries) in speech or music audio. Unlike local or rule-based detectors, this solver evaluates all possible cut combinations under defined constraints to find the globally optimal path through candidate boundary points.

SpectraScore, Orchestration Matcher

Analyzes the spectrum of a target sound and attempts to match it with combinations of orchestral instrument spectra (as if "orchestrating" that sound). It likely suggests which instruments or combination of notes could approximate the timbre of the sound. This is a tool for composers aiming to recreate electronic or found-sound timbres with acoustic instruments, essentially an orchestration assistant based on spectral profiles.

Stereo Channel Similarity Meter

Measures how similar the left and right channels of a stereo sound are. This could involve computing the correlation or another similarity index between the two channels over time. A high similarity means a mostly mono-like signal, whereas low means a wide, differing stereo field. It's useful for analysis (checking stereo coherence or phase issues) and for creative decisions (e.g., selecting samples with certain stereo widths or monitoring the effect of stereo processing).

Tempo Curve (IOI) Estimator

Estimates the tempo curve of a performance by measuring Inter-Onset Intervals (IOIs) between attacks/onsets. It essentially tracks how tempo changes over time (accelerating, steady, ritardando) by analyzing the timing between successive beats or events. This is useful for capturing the expressive timing of a performance; composers can use this tempo map to align electronic elements to a live recording or to intentionally mimic human tempo fluctuations in computer-generated music.

Zero Crossing Rate

Frame‑by‑frame analysis of the rate at which the signal crosses zero. High ZCR indicates noisy/unvoiced content; low ZCR indicates voiced/tonal content. Uses Praat’s built‑in PointProcess (zeroes) (C‑level, no per‑sample script loop) for maximum efficiency. Outputs a ZCR time‑series curve, global statistics, voiced/unvoiced segmentation, and optionally exports the ZCR curve as a Sound object for further use.

↑ Back to top

Distortion 15

Full Wave Rectifier Abs

Applies full-wave rectification to the sound (taking the absolute value of the waveform). This is a form of non-linear waveshaping distortion that converts all negative amplitudes to positive. The result is a harsh distortion adding strong even harmonics, useful for creating buzzy, aggressive timbres or strengthening weak signals with rich overtones in experimental sound design.

Adaptive Wave Shaper

Applies a waveshaping distortion that adapts based on the input's characteristics (using logic inspired by jitter and shimmer measures). In other words, the distortion curve may change dynamically according to the signal's micro-variations, yielding a distortion effect that responds to the input's pitch or amplitude instability. This produces a dynamically evolving distorted sound, useful for giving alive, responsive grit to a signal.

Asymmetric Soft Clipping

This script implements asymmetric soft clipping, a tube/tape-style distortion effect using a hyperbolic tangent (tanh) transfer function with independent shaping for positive and negative halves of the waveform. Key features: (1) Drive: Pre‑gain before clipping. (2) Bias: DC offset pushing signal into different regions of the tanh curve. (3) Positive/Negative Shape: Separate coefficients for upper/lower halves, creating asymmetric distortion. (4) Output Gain: Post‑clipping volume adjustment. (5) 5 Built‑in Presets: From subtle warmth to hard fuzz. (6) Visualization: Displays original vs. distorted waveform and the transfer function (input‑output curve).

Chaos Distortion

This script implements chaos distortion, a multi-stage digital degradation processor combining five destructive effects in series: (1) Drive, gain boost for amplitude overdrive, (2) Wave folding, iterative reflection at ±0.7 threshold, (3) Bit crushing, resolution reduction (quantization), (4) Sample rate reduction, temporal decimation with aliasing, (5) Noise injection, random amplitude perturbation. Unlike single-effect processors, this creates compounded degradation: each stage feeds distorted signal into the next, producing complex, unpredictable, chaotic results. Perfect for: lo-fi aesthetics, glitch music, experimental sound design, video game audio, circuit-bent simulation, destroyed textures.

Distortion & Bit-Crusher

Combines an analog-style distortion with a bit-crusher effect. It simultaneously saturates/clips the waveform and reduces the bit depth (and possibly sample rate) of the audio. The outcome is a gritty, lo-fi distortion with digital aliasing artifacts, great for when an experimental piece calls for an aggressive, crushed sound reminiscent of old samplers or 8-bit electronics.

Dynamic Distortion

This script implements dynamic distortion, a responsive saturation effect where the amount of distortion (drive) varies with the input signal's amplitude. An envelope follower tracks the audio level, and this envelope controls the distortion intensity. Key features: (1) Envelope‑following drive: Drive = Base_Drive + (Envelope × Sensitivity). (2) Adjustable response: Control envelope follower speed (Response_Speed_Hz). (3) 4 Built‑in Presets: Touch‑sensitive, Drum pumping, Gated crunch, Expressive lead. (4) Comprehensive visualization: Shows original, distorted, envelope, computed drive, and transfer functions. (5) Stereo‑container processing: Efficient single‑pass algorithm using multichannel trickery.

Hard Clip

This script implements hard clipping with variable knee, a versatile clipping/limiting effect that smoothly transitions from linear to hard‑limited regions via a configurable quadratic knee. Three processing zones: (1) Linear: Below threshold‑knee, signal passes unchanged. (2) Knee: Between threshold±knee, quadratic curve provides smooth transition. (3) Hard Clip: Above threshold+knee, signal is hard‑limited to threshold. Key features: (1) Variable Knee Width: From 0.001 (near‑hard) to 0.5 (very soft). (2) 5 Built‑in Presets: Brickwall limiter, soft clipper, hard distortion, subtle glue, Fuzz Face emulation. (3) Drive + Threshold: Independent control of input gain and clipping ceiling. (4) Mathematical precision: Uses boolean logic for efficient three‑zone processing. (5) Visualization: Shows transfer function with knee region highlighted.

Hysteresis Distortion

This script implements hysteresis distortion, a nonlinear effect with memory, where the output depends not only on the current input but also on the history of previous outputs. The core algorithm: Output[n] = (1−Memory) × tanh(Drive×(Input[n]+Bias)) + Memory × Output[n−1]. Key features: (1) Hysteresis_Memory: Controls how much past output influences current output (0=no memory, 0.9=heavy lag). (2) Drive: Input gain into tanh nonlinearity. (3) Asymmetry_Bias: DC offset creating asymmetric distortion. (4) 5 Built‑in Presets: Warm tape, dark transformer, offset magnetics, sluggish fuzz, infinite sustain. (5) Comprehensive visualization: Six‑panel display showing waveforms, transfer functions, hysteresis loops, and spectral analysis.

Math Operations

Performs sample-by-sample mathematical operations between two sounds (when both are selected). It allows adding, subtracting, multiplying, or otherwise combining waveforms mathematically. This can create ring modulation (multiplication), difference tones (subtraction), or other composite sounds. Musically, it's a way to fuse two audio signals into one hybrid sound or to impose one sound's waveform onto another, enabling innovative sound synthesis.

Multiband Distortion

This script implements multiband distortion, a sophisticated distortion effect that splits the audio signal into three frequency bands (low, mid, high), applies different distortion algorithms to each band independently, then recombines them. Key features: (1) Phase‑coherent crossover: Linear‑phase Hann‑band filters for clean band splitting. (2) Three distortion types: Soft Clip (tanh), Hard Clip, and Sine Fold for each band. (3) Independent controls: Drive, distortion type, and gain per band. (4) 5 Built‑in Presets: Warm bass/frizz highs, V‑shape, mid‑range crunch, full fuzz. (5) Visual spectral analysis: Color‑coded band display with spectral comparison.

Sidechain Feedback VCA

This script implements audio-reactive generative synthesis, a sophisticated simulation of an analog no-input mixer feedback circuit controlled by any audio file. The process: (1) Controller Analysis: Extracts pitch and intensity features from the selected audio file. (2) Circuit Initialization: Creates a stereo feedback loop seeded with low-level noise. (3) Feature Mapping: Maps controller pitch to filter resonance center frequency, controller intensity to VCA (Voltage Controlled Amplifier) feedback gain. (4) Iterative Processing: Runs 40 iterations of filtering and feedback, with the controller audio dynamically modulating circuit parameters each iteration. (5) Spatial Processing: Applies one of four spatialization modes to the resulting sound. The result is a unique, evolving soundscape that "reacts" to the characteristics of the controller audio.

Tanh

Applies a tanh waveshaper to the audio. The hyperbolic tangent function gently limits the amplitude, acting as a soft clipper. The result is a warmer, analog-like distortion, it rounds off peaks without harsh clipping, adding mild saturation and harmonic enrichment. This is useful in experimental mixing to add character to sounds or prevent digital clipping by giving a soft overdrive character.

Virtual Subharmonic Generator

This script implements psychoacoustic bass enhancement combined with stereo spatial widening. It creates the perception of deep bass on systems with limited low-frequency response (small speakers, headphones) by generating harmonic overtones that trick the ear into "hearing" missing fundamentals. Simultaneously, it applies stereo enhancement using both the Haas (precedence) effect and mid-side processing to create a wider, more immersive soundstage.

Wave Shaper Distortion

Applies a generic waveshaping distortion where a user-defined curve or formula shapes the waveform. It allows custom distortion characteristics (for example, polynomial shaping). This lets the composer impart a wide range of distortion flavors, from subtle saturation to extreme transformation, depending on the chosen shaping curve, useful for sculpting timbre very specifically.

Wavefolder (Foldback)

Applies a wavefolding (foldback) distortion, where portions of the waveform exceeding a threshold are folded back on themselves instead of clipping. This technique, common in West Coast analog synthesis, adds a complex, rich harmonic spectrum. The effect produces a sharp, metallic or "rippling" timbre from even simple inputs, useful for creating evolving textures and bright, edgy sounds without simply flattening peaks.

Dynamics & Envelope 19

Auto-Swell

Automatically applies a swelling volume envelope to the sound. It detects the onset of notes or phrases and fades them in (slow attack) to create a swell effect. Loud attacks are softened into crescendos, which can turn percussive sounds into pad-like gentleness. This is useful for creating ambient textures (e.g., turning a piano into a "reverse swell" sound) or emphasizing slow builds in an experimental context.

Compressor

Applies dynamic range compression, attenuating loud parts and boosting softer parts within a threshold and ratio. It smooths out volume differences, making the sound more consistently loud. In experimental composition, this can be used to shape the envelope of sounds, add sustain (by raising decays), or glue elements together, as well as creatively pump the sound for effect.

Concatenate with crossfade

Concatenates multiple sounds with smooth crossfades between them. This is useful for creating seamless transitions between audio segments, building longer pieces from shorter clips, or creating smooth loops without clicks or pops.

Envelope Application

Applies a custom amplitude envelope to the audio. The user can define or provide an envelope shape (over time) which the script then imposes on the sound's volume. This effectively reshapes the dynamics of the sound arbitrarily, for instance, imposing rhythmic gating patterns or complex fades, which is useful for rhythmical transformations or sculpting long drones with designed volume curves.

Fast Waveset Distortion

Implements waveset distortion, which operates on waveform zero-crossing segments (wavesets), altering them (e.g., deleting or amplifying some wavesets) to create crackling or noisy textures. "Fast" suggests this is an optimized or simplified approach. The effect adds crispy, crackle-type distortion by messing with micro-sections of the wave, a technique known from Trevor Wishart's work, giving a sputtery texture ideal for glitch aesthetics.

Intensity Envelope Processor

This script provides six distinct methods for transforming sound intensity envelopes. It analyzes the intensity (loudness) contour of a sound, applies mathematical transformations to that envelope, then re-applies the modified envelope to the original audio. This creates dramatic or subtle changes in dynamics, rhythm, and timing while preserving the original spectral content.

Kinematic Physics Envelope

Generates an amplitude envelope based on a physics simulation (e.g. kinematics of a bouncing ball or mass-spring). The volume might follow a trajectory like a bouncing object, for instance, large bounces (loud peaks) that gradually get smaller (decaying amplitude) and closer together in time. Applying this to a sound means its volume will behave according to physical motion laws, which can create natural-feeling fades, bounces, or oscillations in loudness that add an intriguing, lifelike modulation to the sound.

LUFS Tool

This script performs loudness analysis and normalization using the LUFS (Loudness Units relative to Full Scale) standard. It measures the perceived loudness of audio, compares it to target levels for different platforms (streaming, broadcast, etc.), and optionally applies gain adjustments to match those targets while preventing clipping.

Limiter

Applies peak limiting to the sound, a very high ratio compression that prevents the audio from exceeding a set threshold. This caps the maximum volume, effectively squashing peaks to avoid clipping. The result is a sound that can be pushed louder overall (since peaks are tamed) and ensures no sudden spikes. In a composition, a limiter can be used to protect against overload or to creatively flatten dynamics for a dense, sustained sound.

Linear Fade-In

Applies a simple linear fade-in to the audio. The volume is ramped up from silence to full over the duration of the selection (or a set time). This is a basic envelope shape that can be used to avoid clicks at onsets, or compositionally to have sounds emerge gradually. It's a straightforward tool to make elements sneak into the mix gently.

Linear Fade-out

The converse: applies a linear fade-out, linearly decreasing the volume to silence. It's used to smoothly end a sound or remove tail clicks. In composition, linear fades (in or out) can also be building blocks of shaping phrases, layering sounds that appear or disappear cleanly over time.

Multiband Compressor

Splits the sound into multiple frequency bands and applies compression to each band independently. This multiband compression allows, say, heavy compression on bass frequencies while lightly touching highs, etc. The effect is more transparent control of dynamics across the spectrum, useful for balancing a complex sound's frequency-dynamics (e.g., taming boomy lows without affecting transients) or for creative dynamic EQ-like effects in sound design.

Noise Gate

Applies a gate that mutes the sound when its volume falls below a threshold and lets it through when above. This noise gate cuts out background noise or reverb in pauses. In creative use, it can produce a choppy, cut-out effect where only the louder portions of a sound are audible. For example, one could gate a drone with a noise gate to create a rhythmic on/off pattern if the drone has slight pulsations crossing the threshold.

Polynomial Envelope Shaper

This script implements polynomial envelope shaping, a mathematical approach to amplitude modulation using polynomial functions as envelope curves. Two methods available: (1) Standard polynomial: Direct coefficient specification (ax³ + bx² + cx + d), control via four coefficients for cubic curves. (2) Product terms: Factored form using roots (x - r₁)(x - r₂)(x - r₃), intuitive control via zero-crossing points. Process maps audio duration onto polynomial domain (startx to endx), evaluates polynomial at each sample position, multiplies sample amplitude by envelope value. Result: mathematically-precise amplitude envelopes (fades, swells, complex curves) defined by algebraic expressions rather than drawn automation. Optional minimum threshold prevents complete silence. Visual envelope preview before application.

Sample-and-Hold Processor

Applies a sample-and-hold effect to the audio. This periodically samples the signal's amplitude and holds it for a short interval before updating (a form of temporal quantization). The result is a stepped waveform (if the rate is low) or added high-frequency aliasing noise (if moderate rates, classic bit-crush style). Essentially, it's like drastically lowering the sample rate at intervals, creating a choppy, staircase approximation of the sound. This produces a gritty, lo-fi texture similar to old digital gear or certain analog synth effects, useful for introducing retro digital character or creative stuttered textures.

Sound Duplicator

Duplicates a selected sound N times, assembles the copies into a single longer sound with crossfades at every join, and applies a shaping envelope across the full output. Four envelope types: Linear, Cosine, Triangle, Gentle arch. Optimised for speed: incremental assembly (one copy in RAM at a time) and a single vectorised Formula call for the envelope.

Time-domain RMS envelope follower

Extracts the RMS amplitude envelope of the sound in the time domain. It generates a smooth curve that tracks the loudness of the signal over time. This envelope can either be output as a control signal or applied back to the sound. In usage, one might utilize this to modulate another sound (making one track another's dynamics) or simply to analyze how the loudness evolves. It's a tool that bridges analysis and resynthesis, for instance, one could use the extracted envelope of a drum loop to modulate a drone, imitating the drum dynamics.

Vintage Glue Compressor

This script implements a vintage-style glue compressor that emulates the characteristics of classic analog compression hardware. Unlike digital compressors that focus solely on dynamic control, this processor adds intentional saturation and harmonic generation to mimic the "warmth" and "glue" of analog gear. The dual-stage processing combines: (1) RMS-based compression: Professional dynamic control with auto-calibration. (2) Hyperbolic tangent saturation: Mathematical emulation of analog soft-clipping. (3) 4 vintage-inspired presets: Models classic compressor types including opto, VCA, bus compression, and tape saturation. (4) Adjustable warmth: Continuously variable from clean digital to heavy analog saturation.

Waveset Distortion

Applies waveset distortion (similar to Fast Waveset Distortion, but perhaps with more control or a standard approach). It processes the waveform between zero crossings, possibly muting or amplifying alternating wavesets to create crackle or granularity. By selectively eliminating or boosting small wave cycles, it can impart a chaotic, sputtering texture to the sound. This technique is excellent for transforming steady sounds into glitchy, noisy variants while still retaining some of the original's shape in a novel micro-structured way.

Filter & Color 34

Adaptive Spectral Resonance Suppressor

This script implements an Adaptive Spectral Resonance Suppressor, an offline tool inspired by Oeksound's Soothe2 that dynamically attenuates narrowband resonances (harsh spectral peaks) in audio. Unlike static EQ or hum removal filters, it adaptively detects peaks that protrude above the local spectral envelope and applies time-varying gain reduction only to those resonant bands

Amplitude-Varying Ring Modulation

This script applies amplitude-varying ring modulation, a complex effect combining three modulation types: (1) Ring modulation: Multiplies input by carrier sine wave (creates sum/difference frequencies, metallic/bell-like timbre). (2) Frequency sweep: Carrier frequency accelerates exponentially over time (linear if exponent=1, quadratic if exponent=2, faster if exponent>2). (3) Amplitude tremolo: Ring modulation depth varies sinusoidally at specified rate (creates pulsing/throbbing effect). Result: Highly dynamic, evolving metallic textures. Unlike static ring modulation, this creates continuous timbral change, frequency content and intensity both evolve over duration.

Adaptive Filter

Applies a filter whose cutoff frequency adapts based on the input sound's features. For example, it might track the spectral centroid or loudness: when the sound gets brighter or louder, the cutoff may change accordingly. This results in a filter that dynamically adjusts to the audio, perhaps opening up for bright passages and closing for dull ones. The adaptive nature yields an evolving timbral effect, useful for keeping an ever-changing tonal balance or for creative effects like the filter "following" the melody's brightness.

Autocorrelation-Based Self-Filtering

Filters the sound using a filter derived from the sound's own autocorrelation (essentially convolving the sound with a version of itself). The autocorrelation highlights periodicities, so this technique reinforces the sound's inherent frequencies. It's like the sound is filtered by its own resonant structure, producing a self-similar resonance. The outcome is that tonal aspects get emphasized (it's somewhat like a comb filter tuned to the sound's pitch). This can create a sort of self-reverberation or tone-enhancement, useful for making a sound more resonant or "hollow" in a unique way.

Band-Based Concatenative Synthesis

Performs concatenative synthesis in distinct frequency bands. It likely breaks the source sound into frequency bands and reconstructs each band by concatenating small audio snippets from a corpus that match that band's content. The end result is a new sound assembled from many tiny pieces, where each frequency range may come from a different source but collectively mimic the original. This yields a mosaic-like resynthesis: the texture of the result is a patchwork of other sounds while the overall timbral shape resembles the target. It's an advanced technique for creating rich, collage textures that still follow a desired spectral profile.

Bit Crusher (8-Bit Arcade)

Applies a bit-crusher effect, reducing the audio's bit depth (and possibly sample rate) to emulate an 8-bit digital sound. This introduces quantization distortion and aliasing noise, yielding a lo-fi, "video game" quality. The effect makes the sound gritty, buzzy, and nostalgic (like old arcade game audio). Composers use this to invoke retro digital aesthetics or to add harsh digital artifacts as a sound design choice.

Classic IIR Filter Bank

This script implements a classical analog filter bank in digital form, providing six historically significant filter types (Bessel, Butterworth, Legendre, Chebyshev-I, Chebyshev-II, Elliptic) with precise control over frequency and phase responses. Each filter type offers distinct characteristics in terms of passband ripple, stopband attenuation, phase linearity, and transition sharpness. The implementation uses bilinear transform to convert analog pole-zero designs to digital second-order sections, ensuring numerical stability and accurate frequency response matching to their analog counterparts. With real-time frequency/phase plotting and efficient cascade implementation, this tool brings classic analog filtering theory to digital audio processing.

Classic FIR Filter Bank

This script implements a comprehensive Finite Impulse Response (FIR) filter bank with guaranteed linear phase characteristics. Unlike IIR filters which can introduce phase distortion, all FIR filters in this collection maintain perfect phase linearity, making them ideal for applications where phase preservation is critical. The implementation includes 9 distinct filter types: 6 windowed-sinc designs (Rectangular, Hamming, Hann, Blackman, Kaiser, Bartlett), moving average filters, raised-cosine filters for communication systems, and Hilbert transforms for analytic signal creation. Each filter is implemented with symmetric coefficients to ensure linear phase, and utilizes fast convolution for efficient processing.

Creative Formant Manipulations

Performs various transformations on the formants (resonant frequencies) of the sound. This could include shifting formant frequencies, widening or narrowing formant bandwidths, or mapping formants in unusual ways. Essentially, it allows one to change the vocal or resonant character of a sound creatively, e.g., making a voice sound like different vowels or moving a resonance sweep through an instrument sound. It's useful for vocal effects (like alien or gender changes) and for imparting vocal qualities to non-vocal sounds in an experimental way.

Cross Synthesis

Merges two sounds by filtering one with the spectral characteristics of another. Typically, one sound provides the spectral envelope and the other provides the fine structure/noise. The result is a hybrid: you hear the timbre of one imposed on the other. For example, make a voice take on the texture of a cymbal or vice versa. Cross-synthesis is a powerful technique for creating new timbres that have qualities of both source sounds (commonly used for voice+instrument blends or any "sound morphing" scenarios).

Dynamic Formant Sweeper

This script implements dynamic formant sweeping, a real‑time approach to vocal and timbral transformation using LFO‑modulated formant filters. The process extracts the source signal via inverse LPC, creates a time‑varying formant filter whose first formant (F1) is controlled by an LFO, and resynthesizes the sound with the moving filter. The result is a continuously morphing spectral envelope that can simulate vowel transitions, robotic voices, underwater effects, alien speech, and more.

Dynamic Spectral Hole

Introduces a notch (a "hole") in the spectrum that moves or changes dynamically. For instance, a narrow band of frequencies might be continuously removed or ducked out, and that band might sweep up and down. This creates an effect of a moving void in the sound's timbre, like a whistle filter that cuts out whatever frequencies it currently targets. It's similar to a wah or talking filter but possibly with a narrower band. It can create the impression of an ever-shifting tonal subtraction, useful for making sounds that feel like they have a shifting formant or to carve out evolving "spaces" in a dense sound.

ENTROPY SMART DE-ESSER

Reduces sibilance ("s" and other harsh high-frequency noises) in speech or vocals using an entropy-based detection approach. It measures the spectral entropy (randomness) to identify segments that are noise-like (like sibilants) and then attenuates those intelligently. The result is a smoother vocal sound with controlled "S" sounds without overly dulling the rest of the spectrum. In a creative sense, it can be used on any noisy source to selectively tame high-frequency noise bursts, or even abused to accentuate them by inverting the logic.

Frequency Shifter

Shifts the entire frequency spectrum of the sound by a fixed amount in Hz (not to be confused with musical pitch shifting). This means every frequency is offset linearly, e.g., adding 100 Hz to everything: a 500 Hz tone becomes 600 Hz, 1000 Hz becomes 1100 Hz. This produces inharmonic results if the shift isn't zero or multiples of existing frequencies, often creating metallic or bell-like qualities from tonal material. It's a classic effect to get inharmonic "sideband" sounds and can be used to subtly detune a sound or to create completely new spectra from harmonic sources.

Golden Ratio Processor

This script implements Golden Ratio audio processing, applying mathematical proportions derived from φ (1.618...) to multiple aspects of sound. The processor transforms audio by imposing φ-based relationships on pitch contours, intensity envelopes, spectral characteristics, and stereo imaging, creating harmonically balanced transformations that follow natural proportional relationships.

GRM-Style Resonator

This script implements a GRM-style tuned resonator, a multi-band filter bank with frequency-synchronous feedback delays, inspired by the electroacoustic techniques developed at Groupe de Recherches Musicales (GRM) in Paris. The processor splits audio into multiple frequency bands, applies resonant feedback delays tuned to each band's center frequency, shapes gain via spectral tilt profiles, and positions bands in the stereo field using architectural panning strategies.

Harmonic Formant Locking

This script implements Harmonic Formant Locking, a source-filter coupling effect that snaps formant frequencies to the nearest harmonics of the fundamental frequency (F0). Unlike natural speech where formants are independent of pitch, this effect forces harmonic alignment between the source spectrum and vocal tract resonances, creating bell-like, metallic, or synthetic vocal timbres.

Harmonic Remover

Selectively removes the fundamental frequency and/or chosen overtones from a sound. Uses pitch tracking and a bandpass subtraction method (Hann‑windowed frames, 75 % overlap) to isolate and subtract harmonic content, leaving the residual (noise, breath, or remaining partials). Ideal for spectral sculpting, debuzzing, noise extraction, and educational demonstrations.

Hilbert Transform (for drums)

Applies a Hilbert transform to the signal, generating a 90-degree phase-shifted version (the analytic signal). For drums or percussive sounds, this could be used to separate phase and amplitude information. By processing a drum beat with a Hilbert transform, one might combine the original and the quadrature signal for special filtering or stereo effects. For instance, sending the Hilbert pair to L and R yields a form of phase stereo widening. It can also assist in envelope extraction (amplitude) or instantaneous frequency analysis for transient-rich signals like drums. In short, it's a technical tool that can enable further processing, or produce a subtle thickening if used directly.

Hum Removal using Formant Filtering

Removes electrical hum (like 50/60 Hz mains hum and its harmonics) by treating those frequencies as "formants" to filter out. Essentially, it places narrow notch filters at the hum frequency and its harmonically related frequencies (e.g., 50 Hz, 100 Hz, 150 Hz, etc.) to subtract the hum. The use of "formant filtering" implies leveraging narrow band filters akin to vocal formant filters but tuned to hum. This cleans the audio from low-frequency drone while preserving the rest. It's an audio restoration tool but in creative use, can be a way to precisely cut specific drone frequencies out of a sound to sculpt its low-end.

Intelligent EQ Adaptive Bandpass

This script implements Intelligent Adaptive Bandpass EQ, a pitch-tracking filter that follows the fundamental frequency or its harmonics in real time. Process: (1) Pitch analysis: Track fundamental frequency (F0) using Praat's pitch detection. (2) Target calculation: Apply multiplier (e.g., 2.0 for 2nd harmonic) and offset to F0. (3) Adaptive filtering: Apply time-varying bandpass filter centered on target frequency. (4) OLA processing: Use overlap-add method with Hanning windows for smooth transitions. (5) Unvoiced handling: Bypass, attenuate, or mute non-pitched regions. Result: Clean extraction of harmonic content that follows pitch variations naturally.

Jitter-Shimmer Formant Mapping

Maps the micro-variations of jitter (pitch irregularity) and shimmer (amplitude irregularity) onto the formant frequencies of the sound. In other words, the natural instability in pitch/amplitude (often measured in voices) is used to modulate formant positions or shapes. This results in a formant (resonance) that wobbles or shifts according to those irregular patterns, adding a human-like quaver or instability to the timbre. It can make synthetic sounds feel more organic by imparting subtle random movement to their resonances, or conversely make a voice's formants bounce in exaggerated ways for special effect.

MFCC TRANSFORMER

The MFCC Sound Processor implements spectral feature-based audio transformation, using Mel-Frequency Cepstral Coefficients (MFCCs) to analyze and manipulate audio in perceptually meaningful ways. By extracting MFCCs (compact representations of spectral shape), the script creates control signals that drive pitch, duration, and amplitude modifications. Unlike traditional signal processing, this approach transforms audio based on its spectral characteristics rather than direct waveform manipulation, resulting in organic, perceptually coherent transformations that maintain the original sound's identity while creating dramatic variations.

Moog Ladder Filter

Applies a virtual analog Moog ladder filter, a classic 4-pole resonant low-pass filter. This model is known for its warm, smooth sound and characteristic resonance peak. Using this script, one can sweep the cutoff frequency to emulate synthesizer filter effects, adding resonance to create that familiar "wah" or squelchy bass. In composition, it's handy whenever an element needs the iconic Moog-ish tone shaping, e.g. filtering noise into wind sounds, or making any dull tone come alive with resonant sweeps.

Panning filter

Applies filtering in conjunction with stereo panning to shape the spatial color of the sound. It possibly filters different frequency components to different extents in left vs right channels. For instance, low frequencies could be panned center while highs sweep side to side via a filter. Or it might act like a moving filter that also pans its output. The result is an effect where timbre and stereo placement are linked, as the filter frequency changes, the sound might move across the stereo field or certain frequencies appear more on one side. This enriches spatial movement with tonal change, a creative way to have the sound "travel" in space with a changing color.

Raised-cosine band boost

Applies a filter that boosts a certain frequency band using a raised-cosine shaped curve (which has a smooth, rounded top and gentle tails). This is a gentler way to emphasize a range of frequencies than a sharp EQ peak. It will increase a band (say mid frequencies) in a very smooth fashion without abrupt edges, preserving phase linearity. The result is a natural-sounding enhancement of that band's presence or loudness. Composers might use this to subtly color a sound, for example, highlight the "body" frequencies of an instrument or bring out airiness, in a transparent way.

Resonant

Adds a resonance effect at a particular frequency or set of frequencies. Possibly it introduces a ringing filter or feedback at certain frequencies, making them sustain or ring out when excited. This is akin to placing a resonator (like a tube or string model) on the sound. The effect is that certain notes or frequency areas become much more pronounced and lingering, giving a ringing, droning quality. This can turn percussive hits into pitched resonant tones, or add a sense of acoustic space (like the resonant body of an instrument) to synthetic sounds.

Spectral Filtering Effect

Applies filtering directly in the frequency domain, targeting the spectral brightness in particular. For example, it may allow one to smoothly tilt the spectrum (make the sound brighter or darker) or apply a custom spectral envelope. Because it's done spectrally, the effect can be very precise and transparent. One use is to reduce or enhance the brightness of a sound without touching its loudness, essentially an EQ focusing on overall tone. In experimental use, one could draw a spectral curve to shape the timbre arbitrarily (like drawing out certain formants or clusters).

Spectral Morph

This script implements a Spectral Morph, a true STFT-based spectral morphing between two sounds. It performs per-frame processing with log-space magnitude interpolation and sample-accurate overlap-add reconstruction, similar to techniques found in the Composers Desktop Project (CDP) tools.

Voice Quality Sonification

This script implements a Jitter-Shimmer Formant Mapper, a voice quality sonification tool that analyzes perturbation measurements (jitter and shimmer) from a voice recording and uses these measurements to dynamically control formant filtering. The result is an auditory representation of vocal quality variations: as jitter and shimmer change over time, the perceived vowel quality shifts accordingly.

Wah-Wah Effect

Implements a classic wah-wah pedal effect. It's essentially a band-pass or resonant low-pass filter sweeping back and forth in frequency (often controlled by an LFO or manually). This produces the characteristic "wah" vowel-like sound as it emphasizes different frequency areas over time. In an experimental workflow, a wah can be used not just on guitars but on any sound to inject a vocal, funky quality or to rhythmically filter a sustained sound, creating movement and emphasizing different overtones cyclically.

Whisper Morph

This script implements whisper morph synthesis, a vocal transformation technique that creates smooth transitions between normal voice and synthesized whisper. Unlike simple filtering, this method uses: (1) LPC analysis/resynthesis: Extracts vocal tract filter characteristics. (2) Noise excitation: Replaces periodic glottal source with noise. (3) Dynamic envelope shaping: Preserves amplitude contours from original. (4) Time-varying crossfades: Smooth transitions between vocal modes. Process analyzes source voice, creates whisper version using LPC+noise, then applies time-based mixing between original and whisper. Result: natural-sounding vocal transformations that gradually shift between normal phonation and whisper.

Working Adaptive Filter

An adaptive filter that actively changes its filtering behavior based on some criteria or input analysis (perhaps a more complex or experimental version of adaptive filtering than the simpler low-pass one). It might, for example, adapt multiple bands or track a target spectrum dynamically. Being labeled "Working", it suggests it's a prototype or actively updating filter. It continuously shapes the sound in response to its content, perhaps equalizing on the fly or removing resonances as they appear. In creative use, this could ensure a sound's spectrum stays within certain bounds (self-mixing) or create unusual effects where the filter never stays static, always "working" to change the timbre.

XMod

Applies a cross-modulation effect. Possibly short for "cross modulation," it could involve two forms of modulation at once (frequency and amplitude modulation together) or modulating the sound by a version of itself (self-modulation). It might, for instance, modulate the amplitude of the sound with a filtered copy of itself (creating nonlinear feedback). The result would be complex intermodulation distortion where new frequencies appear from the interaction of the signal with itself or another. In essence, XMod generates rich, edgy timbres by combining modulation techniques, useful for thickening a sound with internal movement or achieving aggressive tones akin to FM plus AM textures.

Vowel Formant Filter (a-e-i-o)

This script applies vowel formant filtering to transform any sound through four vowel timbres. Process: (1) Creates vocal tract models for vowels "a", "e", "i", "o" using Praat's built-in phone models. (2) Converts each vocal tract to LPC (Linear Predictive Coding) filter. (3) Filters the input sound through each vowel's LPC filter separately. (4) Concatenates all four filtered versions (a→e→i→o sequence). Result: Four variations of the input sound, each colored by a different vowel's formant structure. No parameters, fully automatic. Output duration is 4× original duration (four consecutive vowel-filtered versions).

Generative & Synthesis 55

Accelerating Polyrhythm

Generates polyrhythmic patterns whose tempo increases over time. It layers multiple rhythmic cycles (polyrhythms) and makes their pace accelerate gradually. The outcome is an evolving rhythmic texture that starts at one tempo and speeds up, with different rhythm lines interlocking out of phase. This can be used to create tension and complexity in a piece as the interwoven rhythms chase each other faster and faster.

Advanced Brownian Synthesis

This advanced script generates complex, evolving soundscapes using Brownian motion principles. Unlike traditional synthesis that uses fixed oscillators or samples, Brownian synthesis creates organic, unpredictable textures by having frequencies "wander" randomly over time, similar to pollen particles floating in water.

Advanced Chaotic Modulation

Applies chaotic oscillators or maps to modulate some aspect of sound (pitch, amplitude, filter) with more features or complexity than a simple chaos. Perhaps multiple chaotic systems influencing each other or additional parameters to tune the chaos. This yields modulations that are deterministic yet never exactly repeating, providing rich evolving patterns. In practice, it's a source of complex LFO or FM that can create sounds with a sense of organic unpredictability (like wind chimes or certain animal calls but algorithmically).

Advanced Formula Synthesis

Generates audio using user-defined formulas with advanced options (beyond the basic "Create Sound from formula" in Praat). It might support multi-segment formulas, conditionals, or iterative calculations. The user can essentially write mathematical equations to produce waveforms or spectra. This allows extremely flexible synthesis, from simple tones to bizarre wave shapes, limited only by formula creativity. It's powerful for composers who like to directly design sounds via math (for instance generating fractal waveforms, custom noise spectra, etc.).

Advanced Poisson Synthesis

This script implements Poisson-based granular synthesis, generating complex sonic textures using stochastic timing (Poisson processes) and granular synthesis techniques. Process: (1) Creates multiple layers (1-8) of sound grains, (2) Each layer uses Poisson process timing (random with average rate), (3) Each grain is a sine wave with Hanning envelope, (4) Parameters (frequency, duration, amplitude) vary per grain based on synthesis mode, (5) Layers are combined with optional stereo spatialization, (6) Output is a complex, evolving texture with natural-sounding randomness and density control.

Algorithmic Metallic Synthesis

Synthesizes metallic timbres using an algorithmic approach (likely producing inharmonic overtone series typical of metal objects). It might generate a cluster of frequencies or FM synthesis patterns that yield clangorous, bell-like sounds. By varying parameters, it can produce different "metal" sounds, gongs, bells, cymbals, via algorithms rather than recordings. This is useful for composers needing custom metallic sounds or tuned percussion that can be controlled algorithmically (for microtonal or evolving metal-like textures).

AM Additive Synthesis Generator

Generates sound via additive synthesis where partials are modulated in amplitude (AM) in some fashion. It likely creates multiple sine waves (harmonics or not) and possibly applies amplitude envelopes or low-frequency oscillation to each (Amplitude Modulation). This could produce a rich evolving tone or texture with a controlled set of partials that vary in loudness. It's like building a sound from scratch by specifying frequencies and giving each a dynamic profile. Such precise control is great for experimental timbres or slowly evolving drone structures where every overtone's behavior can be composed.

Analogique B: Stochastic Sound Mass Generator

The Analogique B - Stochastic Sound Mass Generator creates electronic sound masses using stochastic (probabilistic) processes. Instead of composing individual notes or rhythms, it generates evolving textures through statistical control of spectral filtering and amplitude modulation.

Audiovisual Sonification

Mapping sound to sight – an algorithmic audiovisual renderer. Generates a stereo master signal and renders synchronised real‑time visuals in Praat’s demo window via a 3‑phase pipeline: (1) synthesise stereo audio, (2) pre‑compute signal analysis and pre‑slice audio chunks, (3) frame‑locked draw + play loop. Seven presets explore different mapping concepts.

Coupled Meshes + String

a physical modelling synthesiser that simulates two 8×8 mass‑spring meshes connected by a 12‑node string. The system has 140 nodes and 235 linear springs, with independent stiffness and damping per spring group. The simulation uses Verlet integration and is fully vectorised – force scattering and state updates are expressed as matrix‑vector products (mul#) and element‑wise vector arithmetic, keeping the hot loop in Praat’s compiled kernels rather than the script interpreter.

Cellular Automata Synthesis

Generates sound by using a cellular automaton (like Conway's Game of Life or other grid-based rules) to drive sound parameters. Commonly, one might map the automaton's evolving pattern to notes (creating generative melodies) or to the amplitude of many oscillators. As the automaton evolves, the sound changes accordingly, often yielding complex, pseudo-organic patterns. This method can produce surprising rhythmic or textural results, e.g., bursts of events when the automaton has activity, silence when it dies out, essentially sonifying the "game" of the cellular automaton.

Chaotic Function Generator

Produces signals from chaotic mathematical functions (such as logistic map, tent map, etc.). These functions, iterated, create sequences between order and randomness. The script probably computes the chaotic sequence and then interprets it as an audio waveform or a modulation source. It results in output that is irregular but with internal structure, neither white noise random nor a simple periodic wave. Composers can use these for unique noise sources, unpredictable control signals, or directly as audio that has a granular, rough texture.

Chaotic Granular Synthesis

Performs granular synthesis where grain parameters (like timing, pitch, or selection) are controlled by a chaotic process. Instead of uniform or random distribution of grains, a low-dimensional chaotic system decides when and how grains play. This yields granular textures that have a kind of self-similar complexity, not entirely random, possibly clustering or bursting in patterns. It's useful for creating evolving clouds of sound that have spontaneous flurries or lulls reminiscent of natural chaotic systems (like popcorn popping or insect sounds) rather than steady or purely random grains.

Chirikov Standard Map Sonification

Generates a sound using the Chirikov standard map, a well-known chaotic map in dynamical systems. It likely treats the iterated values of the map as, say, a waveform or frequency modulation pattern. The Chirikov map can produce chaotic sequences depending on a parameter K. The script probably allows one to set parameters and then "hear" the chaotic output as audio. This results in a chaotic signal with certain periodicity and chaotic transitions, an interesting source of unpredictable oscillations. It's a direct sonification of a mathematical chaotic system, giving composers access to an auditory version of that chaos.

Competing Modulators

Applies multiple modulators (LFOs or envelopes) to a sound or parameter that compete. Possibly two or more modulation signals that affect the same target in different ways (e.g., one tries to increase pitch while another decreases it, at different rates). Their competition could be implemented by summing, alternation, or using the stronger at any time. The effect is complex modulation patterns where sometimes one modulator dominates, then another. This yields more intricate movement than a single LFO, for instance, a tremolo that occasionally beats differently when another oscillator overtakes it. It introduces a layered modulation texture that can be less predictable and more organic.

Convolution Synthesis

Synthesizes sound by convolving signals, for example, convolving a short impulse train with a spectral shape, or convolving two existing sounds to create a new one. Convolution here is used creatively (not just as reverb): it merges the frequency content of one sound with the temporal content of another. By designing impulses or using one sound's transient pattern and another's timbre, one can create hybrid sounds. It's useful for crafting new tones that borrow the rhythmic or envelope characteristics of one source and the timbral body of another, essentially cross-breeding sounds via convolution.

Dynamic Stochastic Synthesis

Implements Xenakis' Dynamic Stochastic Synthesis (as hinted by the name). This technique generates waveforms directly by random processes that evolve (e.g., lists of points that move). The script likely sets up parameters for probabilities that change over time to generate a waveform sample by sample (like Xenakis' GENDYN algorithm). The result is a waveform that never exactly repeats but has constraints, leading to a continuous, noisy but shaped timbre. It's known for creating very rich, evolving timbres or textures without a clear fundamental, perfect for dense, evolving sound masses in experimental music.

Dynamic Vowel Transitions

Synthesizes or processes sound to create continuously morphing vowel sounds. It likely uses formant synthesis or filtering that moves from one vowel's formant settings to another's over time. For example, you could morph "A" into "O" into "I" gradually. This produces an evolving vocal-like tone where the vowel quality is in flux. It's useful for creating talking synth sounds, eerie vocal pads, or transitioning resonant effects that sound as if a formant is sliding (like a mouth shape changing) during a sustained sound.

Evolving Grain Mass

Generates a mass of grains (granular synthesis) where parameters (like grain size, density, pitch) are not static but evolve over time. So the grain cloud might start sparse and get denser, or grains might gradually lengthen or shift pitch range as the piece progresses. Unlike a fixed granular texture, this one has a trajectory or life cycle. The result is a granular sound cloud that transforms, good for long ambiences that need to stay engaging by slowly changing texture, or for simulating natural swarms (starting small, growing, then dissipating, for example).

FM Texture Generator

Creates complex sound textures using Frequency Modulation synthesis. It likely sets up multiple modulators and carriers to produce a rich, possibly noisy or bell-like texture (FM is known for both smooth and clangorous tones). Possibly it generates a layered output or a time-varying FM parameter set to avoid static tones. The "texture" implies it might output a broad-band or evolving sound rather than a stable tone, maybe by randomly varying the FM index or frequency ratios over time. This is useful for pads, drones, or percussion clusters with the distinctive FM character (metallic, rich in sidebands).

Fast Game of Life Synthesis

Similar to cellular automata synthesis, but specifically using Conway's Game of Life, optimized for speed. It likely runs the Game of Life on a grid and sonifies it, perhaps mapping live cells to sound events or summing each row/column as a waveform. "Fast" suggests efficiency or maybe lower resolution for quick generation. The output could be bleeps or aggregate noise that changes each generation. It yields a dynamic pattern that has emergent structures (common in Game of Life), musically, one could get interesting rhythmic or textural evolutions from various starting seeds of the automaton.

Formant Grain Texture

Generates a granular texture where each grain emphasizes certain formants (resonant peaks). It might do this by filtering grains or using vocal-like source grains. Essentially, the granular output has a formant structure, giving it a vowel-like or resonant quality throughout. Perhaps the texture could even alternate between different formants per grain, creating a cloud of "vowel grains." This can result in a choir-like or swirling vocal wind sound, where an ambient granular cloud carries a sense of pitch or resonance (without a clear fundamental, just formant peaks).

Formant Synthesis

Synthesizes sound by generating partials corresponding to formant frequencies of vowels or instruments. It likely creates a voiced vowel sound from scratch by producing a harmonic spectrum shaped with formant filters. You specify formant frequencies and bandwidths (e.g., for a vowel like "Ah"), and the script generates the resulting tone, possibly using a source excitation like a sawtooth or noise with resonators. This is useful for creating choir or vocal-ish tones artificially, or any resonant body imitation (like bell formants or wind instrument formants) purely by synthesis.

Formula Markov Synthesis

Combines the idea of formula-based synthesis and Markov chains. Possibly it has multiple small formula-defined sounds and uses a Markov chain to decide which formula or which parameters to use next, creating a sequence of sounds where each is generated by a formula but the selection follows a probabilistic Markov process. This way, the timbre or waveform might switch among various shapes in a controlled random manner. It produces a sequence or texture that has some coherence (Markov chain ensures transitions follow certain probabilities) but also variety (different formulas). Great for evolving textures that randomly cycle through defined sonic states.

Flute KlattGrid Serial Melody

KlattGrid flute synthesis with dodecaphonic melody and serial rhythm derived from the tone row. Generates a 12‑tone row, applies the chosen row form (Prime, Inversion, Retrograde, Retrograde‑Inversion), derives note durations from pitch‑class intervals, and synthesises a realistic flute note for each row element using layered chiff attacks and formant tracking.

GENDYN Synthesis

This script implements GENDYN (Dynamic Stochastic) Synthesis, a breakpoint-based synthesis method where waveform parameters evolve stochastically within defined barriers. Core concept: A waveform defined by breakpoints (amplitude/duration pairs) undergoes continuous random mutations, with evolution constrained by barrier conditions. The result: Organic, evolving sonic textures that are neither purely random nor deterministic, occupying the fascinating space between order and chaos.

Generative Sound System

A broad framework that likely ties together multiple generative algorithms to create a self-contained generative composition or soundscape. It might allow various modules (random sequences, algorithmic melody, evolving timbres, spatialization) to work together as a "system" generating sound automatically. Essentially, it could be a mini procedural composition environment, one could set some initial conditions and the system outputs a constantly changing sound piece. It's used to produce full generative soundscapes or musical structures without further input, useful for installations or exploring algorithmic composition.

Grisey, Spectral Becoming Engine

This script implements a Spectral Becoming Engine, an additive synthesis system that models the continuous transformation from harmonic to inharmonic spectra, a central concept in the spectral music of Gérard Grisey (1946-1998). The engine generates slowly evolving sounds where individual partials undergo frequency chirps, spectral energy redistribution, and micro-detuning, creating the illusion of a single sound "becoming" something else over time.

IKEDA/SYN Tetralogy

Ryoji Ikeda‑inspired audiovisual renderer. Generates synchronised audio and visuals in real time within Praat’s demo window, modelling four Ikeda works: test pattern (Barcodes & Glitch), datamatics (Grids & Scans), spectra (Drones & Light), and supercodex (Genome Barcodes).

Karplus-Strong Texture Generator

Uses the Karplus-Strong algorithm (a plucked-string synthesis method) not just to synthesize one pluck, but to generate a texture with many pluck sounds or continuous re-triggering. It likely layers multiple Karplus-Strong voices or repeats them at different times and pitches to create a dense output, rather than a single note. The resulting texture could resemble a flurry of string plucks or a sustained tone that has the gritty character of repeated plucked-string impulses. Good for creating ambient textures with a harmonic (but not static) quality, like a shimmering string pad or a rain of plucked tones.

Kotoński FSM Event Generator

This script implements a finite-state machine (FSM) event generator for algorithmic composition, inspired by Polish composer Włodzimierz Kotoński's stochastic synthesis techniques as heard in Aela (1967). The tool generates sequences of sonic events (tones and noise bands) based on a deterministic state machine with four compositional states.

Layered Markov Texture

Produces a sound texture by layering multiple streams of events, each governed by a Markov chain. Perhaps each layer could be a sequence of notes or grain selections determined by its own state-transition probabilities, and all layers play together. The combined effect is a polyphonic tapestry of random sequences that are statistically structured. This can lead to rich, multi-voiced generative music where each voice has its own pattern tendencies yet the overall result is cohesive in a stochastic way. It's particularly useful for creating complex backgrounds or polyphonic algorithmic music that evolves without repeating exactly.

Logistic Map Synthesis

Uses the logistic map (a simple chaotic formula x_{n+1} = r * x_n * (1 - x_n)) to synthesize sound. Depending on the parameter r, the logistic map can produce periodic, quasi-periodic, or chaotic sequences. The script probably runs this iteration at audio-rate (or control-rate to modulate something). As audio-rate, it can generate a waveform that sounds noisy or tonal depending on r, classic chaotic synthesis. As control, it might modulate an oscillator's frequency or amplitude with a logistic output. Either way, it yields signals that can abruptly change behavior with slight parameter shifts, useful for exploring the boundary between order and chaos in timbres or patterns.

Lorenz Deep Analog

Explores the Lorenz attractor (a 3D chaotic system) to create analog-like oscillations. Possibly it treats two of the Lorenz equations' outputs as stereo audio signals or uses one dimension as a waveform shape. "Deep Analog" hints it may map the Lorenz system into a musical analog: for example, using it to modulate a filter cutoff or to create a slowly evolving chaotic LFO that yields warm analog-style unpredictability. The Lorenz attractor can produce smooth but never-repeating trajectories, ideal for a natural-sounding modulator that avoids obvious repetition. This could impart subtle, lifelike drift to synth parameters or be heard directly as a complex pseudo-oscillator with an analog noise-like quality.

Markov Rhythm Generator

Creates rhythmic patterns using a Markov chain. It probably has a set of rhythmic values or beats, and transitions between them based on given probabilities. This yields an infinite rhythmic sequence that has some style (depending on the transition matrix), for instance, it might favor certain beats after others, creating a *Markovian groove*. The composer can craft probabilities to get desired complexity or repetition. It's a way to algorithmically generate drum patterns or rhythmic motives that have coherence (not purely random) but also variation (not a fixed loop).

Organic No-Input Mixer

This script implements pure generative synthesis, creating complex, evolving sounds from nothing but feedback circuits, simulating the behavior of physical "no-input mixer" setups where mixing console outputs are patched back into their own inputs. The process: (1) Circuit Initialization: Seeds a stereo feedback loop with ultra-low-level Gaussian noise. (2) Parameter Presets: Offers four carefully tuned starting points that create specific sonic characters. (3) Organic Evolution: Runs 60 iterations of filtering and feedback with simulated analog drift and instability. (4) Dynamic Filtering: Applies resonant bandpass filtering with center frequencies and bandwidths that drift randomly each iteration. (5) Spatial Processing: Transforms the raw circuit output through one of four spatialization algorithms. The result is a unique, living soundscape that evolves organically over time.

Percussive Image Sonification

Turns a digital image into a series of percussive sounds. Likely, it scans an image (maybe left-to-right) and whenever it finds certain visual features (like a dot or pixel intensity threshold), it triggers a percussion sound or a click. For example, an image with a scatter of dots might be read as a sequence of drum hits spatially corresponding to those dots. This produces rhythmic structures derived from visual patterns, great for multimedia works where images drive sound, or just to generate unusual rhythms that have some spatial or geometric origin.

Photo Brightness-Controlled Pitch Sonification

Sonifies a photograph by mapping pixel brightness to pitch values. Possibly it treats the x-axis as time and y-axis as different notes, reading across and assigning higher brightness to higher pitch (or vice versa). The result is a sequence of notes whose melody contour is directly shaped by brightness variations in the image. For example, a brighter area will result in higher notes. This technique yields melodies or sequences that "play" the image's luminance patterns, an interesting way to derive musical material from visual art or data, useful in synesthetic compositions or data sonification projects.

Photo sonification

(General version, as opposed to the brightness-controlled pitch variant.) It converts an image into sound in a possibly more general sense, perhaps by interpreting one axis as time and the other as frequency and treating pixel values as amplitude (like reading the image as a spectrogram). This could literally turn a picture into an audible scene (common example: draw something in a spectrogram and play it). The resulting sound carries an imprint of the image's structure (e.g., an image with diagonal lines might translate to rising or falling tones). It's a creative tool to make sound directly influenced by visual structures, often yielding intriguing and unexpected sonic results that mirror the original picture in some abstract way.

Poisson Point Process Synthesis

Uses a Poisson point process to schedule sonic events, often creating a random distribution of impulses over time. In stereo, it can run two independent Poisson processes for left and right channels. Each event (point) can trigger a sound grain or noise burst. This produces a sparse, random texture akin to raindrops falling on two separate surfaces, unpredictably timed events that are statistically defined. With customizable parameters, one can set the average density of events and other properties. It's useful for realistic random event clusters (like particle sounds, crackling fire, pops) or as a random rhythmic bed that lacks periodicity.

Poisson Rhythm Synthesis

Similar to above, but likely focusing on the rhythmic aspect, generating entire rhythmic patterns (maybe repeated or structured) using Poisson distributions for onset spacing. It may create one-channel rhythms where inter-onset intervals are drawn from a Poisson process, resulting in jittery but somewhat even distributions (Poisson tends to avoid clustering too tightly). Such rhythms are arrhythmic in a musical sense (no steady beat) but have an even randomness that can be mesmerizing in an experimental piece.

Polyrhythms from Dots

Takes a pattern of dots (perhaps drawn by the user or from an image/graph paper) and interprets each row/column of dots as a rhythm, thereby creating polyrhythms. For example, each row of dots might correspond to a beat pattern for a particular drum, and the horizontal spacing between dots indicates timing. By having multiple rows, you get overlapping rhythms (polyrhythm). The name implies maybe an image with dots positions yields different cycle lengths (like one row of 5 evenly spaced dots vs another of 7, giving a 5:7 polyrhythm when looped). This tool turns simple graphical dot patterns into complex layered rhythms, a very intuitive way to compose cross rhythms visually.

Pulsar Synthesis Engine

Pulsar Synthesis Engine implements the classic pulsar synthesis technique described by Curtis Roads in Microsound (2001). A pulsar is a short waveform (pulsaret) that repeats with a given period. By controlling the ratio of the pulsaret's duration (duty cycle) to the inter‑onset interval, the synthesis spans a continuum from pitched tones (short period, high overlap) to rhythmic pulses (long period) to granular noise (stochastic onsets).

Random Walk Melody

Generates a melody by performing a random walk on pitch space (usually within a scale). Each subsequent note is determined by a random step up or down from the previous note. Over time, this creates a wandering, aimless melody that nonetheless tends to stay around some range. It's unpredictable but not jumpy (since each step is small, like one or two scale steps maybe). Such a melody can serve as an algorithmic motif or background line, especially in aleatoric or process music, it has a meandering quality that can be charming or mysterious.

Random Walk Rhythm

Creates a rhythmic pattern by a random walk process, for example, randomly increasing or decreasing the interval between beats. This might produce a sequence of beats that sometimes speed up slightly, sometimes slow down, but with no fixed tempo, it "wanders" in tempo. Alternatively, it could choose note values in a random walk manner (quarter, then maybe eighth, then back to quarter, then to half, etc.). The effect is an irregular rhythm that drifts instead of staying constant or simply randomizing each value independently. It gives a sense of quasi-coherence (since changes are gradual) while still being unpredictable, useful for creating evolving rhythmic beds or metrical modulation effects in a piece.

Rich Formant Grains

Performs granular synthesis where each grain is enriched with formant filtering or content, making them formant-rich. It could mean each grain is a short burst shaped by a vocal formant filter or extracted from a formant-heavy sound. When these grains are combined, the overall texture has lots of vocal-like resonances, giving it a *choral or buzzy quality.* It's "rich" because the individual grains aren't simple sine blobs; they have internal spectral peaks. This is great for creating drone textures that feel like a crowd of tiny voices or resonant particles, complex and full-bodied rather than plain grains.

Risset's Mutations

This script implements Risset‑inspired algorithmic composition, generating structured computer music through parameterized spectral mutation. Inspired by Jean‑Claude Risset's pioneering work in computer music, the script creates evolving sound textures by scheduling multiple "events" (sine‑based voices) that mutate harmonically over time according to mathematical functions. Each event follows a unique trajectory in frequency‑amplitude space, creating complex emergent textures from simple sine wave foundations.

Spectral Image Sonification

Interprets an image as a target spectrogram and then synthesizes sound from that. Likely one axis of the image corresponds to time and the other to frequency, and pixel brightness is mapped to amplitude. The script then performs an inverse FFT or resynthesis to create a sound whose spectrogram looks like the image. In effect, you can "paint" a desired spectrogram with any pattern and get the corresponding audio. This technique can produce very novel sounds, for example, embedding pictures or text that become audible motifs (though often abstract). It's a powerful way to design sounds with precise spectral features or even hidden messages (drawing a shape that will appear if someone does a spectrogram analysis of the sound).

Vector Synthesis

This script implements vector synthesis, a geometric approach to sound generation where timbre evolves by moving through a 2D space defined by four corner oscillators. A "vector" (point) travels along a mathematical path (circle, ellipse, Lissajous, spiral, etc.), and at each moment, the output sound is a bilinear interpolation between the four oscillator waveforms based on the vector's X,Y coordinates. This creates continuously changing harmonic spectra that follow geometric patterns.

Stockhausen Studie II Generator

This script generates electronic sound compositions inspired by Karlheinz Stockhausen's Studie II (1954), one of the first entirely electronic compositions. It creates complex "tone-mixtures" (Tongemische), each event consists of 5 sinusoidal components spaced according to an exponential frequency scale. The script offers two distinct generation modes: Serial (authentic reconstruction using the historical 3-5-1-4-2 seed) and Random (creative quasi-Studie II variations).

Subtractive Synthesis Generator

Generates sound using subtractive synthesis: starting from a spectrally rich source (like a sawtooth or noise) and applying filters to carve out the desired timbre. The script probably allows one to choose a base waveform and then adjust filter settings (cutoff, resonance) or apply multiple filters in series. It might produce common subtractive synth tones: e.g., a low-pass sweeper for bass or pad sounds. It's a way to get classic analog-style sounds, you generate a bright source then filter it down. Composers can use it to shape noise into wind or whoosh, or harmonically rich waves into warm tonal sounds, all within Praat's offline context.

Wave Terrain Synthesis

Implements wave terrain synthesis, where two low-frequency oscillators (or phase signals) are used as coordinates to traverse a 3D mathematical "terrain" function, and the height of that terrain at those coordinates is output as the audio signal. By using different terrain shapes, one can get complex periodic or quasi-periodic sounds. The script likely lets you pick or define a terrain equation and the frequencies of the two "driver" oscillators. The resulting timbre can be very complex and rich, potentially quasi-periodic (repeating after a long cycle if the ratio of driver frequencies is rational, or never exactly repeating if irrational). It's useful for generating sounds with a lot of internal motion, more complex than simple FM, and can range from edgy and noisy to bizarrely tonal, depending on the terrain function. It's a less common synthesis method that can yield uniquely evolving tones.

Waveguide & Modal Synthesis

Synthesizes sound using physical modeling techniques: waveguide synthesis (simulating vibrating strings or tubes via delay lines and filters) and modal synthesis (simulating resonant modes of an object). The script probably offers a way to generate a tone by specifying model parameters like length, tension (for waveguide, which gives something like a plucked string or blown pipe), or mode frequencies and decay times (for modal, which can model bells, plates, etc.). Combining waveguide & modal means you can simulate both sustained resonators and distinct modal resonances, possibly even feeding one into the other. This produces highly realistic or at least physically plausible sounds, e.g., a string instrument tone, a bell or a drum hit, or creative imaginary instruments by tweaking parameters beyond real-world. It allows composers to conjure instrument-like sounds or unusual resonant bodies within Praat, which is more known for analysis than synthesis, thereby greatly expanding the palette for experimental composition with realistic timbres.

Waveguide Klangmaschine

Generates a randomised SATB chord using digital waveguide synthesis with per‑string allpass fractional delay, stiffness dispersion, LP damping, and bridge coupling — processed through an 8‑mode soundboard resonator bank, spectral‑split stereo imaging, and a true‑stereo Poisson‑process spectral decay reverb. Each run produces a unique, playable chord with deep three‑layer randomisation.

↑ Back to top

Modulation 21

Amplitude-Following Wah-Wah

Applies a wah-wah filter (a resonant band-pass sweep) that is driven by the sound's own amplitude envelope. Essentially an auto-wah: when the input is louder, the filter opens (or closes), and when it's soft, the filter moves accordingly. This makes the wah effect responsive, for example, a guitar chord strummed hard will trigger a wide-open "wah" and then mellow out. In use, it imparts a funky, dynamic filtering that tracks the intensity of the performance, great for adding expressiveness to instruments or adding a vocal-like quality that reacts to how forcefully a sound is played.

Barber-Pole Orbit

Creates a barber-pole effect (an endlessly rising or falling illusion, like a Shepard tone in modulation) possibly applied to panning or phaser "orbiting." The term "orbit" hints it might swirl a sound around continuously. For instance, a barber-pole phaser continuously seems to sweep upward without reset, and an "orbit" might mean it's doing this while panning around. So this effect likely gives the illusion of a filter or phaser that keeps moving in one direction forever (never completing the cycle audibly), and possibly at the same time orbits the sound in stereo. It produces a sense of infinite movement, useful for mesmerizing, otherworldly effects (like a drone that feels like it's always climbing in tone or circling around you).

Chaotic Prosody Manipulation

Modulates the prosodic features (pitch, timing, intensity) of speech or melody using chaotic patterns. For example, it might take a spoken phrase and apply a chaotic LFO to its pitch contour or timing intervals, making the speech sound erratic in intonation or rhythm. The chaos ensures it's unpredictable but not random noise, it might simulate emotional or disturbed speech patterns (like stuttering or manic intonation changes). In composition, one could take a straight vocal line and give it a strange, unstable expressiveness via this tool, making it wobble or jump unexpectedly in a controlled chaotic way.

Dual-Mode Tremolo Generator

Produces a tremolo (volume modulation) with two distinct modes, perhaps switchable or layered. For instance, Mode A could be a standard sine tremolo, Mode B a choppy square tremolo, or maybe one is amplitude modulation of one type and the other of another frequency or shape. "Dual-Mode" suggests it offers two styles of tremolo or two simultaneous LFOs. This allows more variety: one could use the smooth mode for subtle pulsing or the hard mode for rhythmic gating, or even combine them (if both run, you might get a complex amplitude pattern as their product). It's basically an advanced tremolo effect giving creative rhythmic modulation options for dynamic movement in a sound.

Fractal Convolution Swarm

This likely involves repeatedly convolving the sound or impulses in a fractal pattern, possibly combined with swarm-like modulation (maybe many small convolution kernels moving or overlapping). It sounds like a complex modulation effect where convolution (like reverb or filtering) is done using fractal-derived impulse responses or multiple convolutions applied in parallel with slight differences (a swarm of them). The result would be a very dense, textured effect, perhaps a reverb-like cloud that has fractal patterns in time (echoes within echoes). This can create lush, evolving tails or resonances with self-similar detail, giving a sense of chaotic yet structured space around the sound.

Golden Chaos Vibrato

Applies a vibrato (periodic pitch modulation) where the rate or depth is modulated by ratios related to irrational numbers (π, e, φ, the golden ratio φ, etc.). These irrational numbers ensure the vibrato pattern never exactly repeats in a simple way, creating a quasi-chaotic vibrato. For example, perhaps two vibrato LFOs with frequencies in a golden ratio relationship modulate the pitch together, the interference yields a non-repeating modulation pattern. The effect is a pitch warble that feels *natural but never cycles*, unlike a simple periodic vibrato. It's useful for giving sustained tones a lively, unpredictable shimmer that avoids sounding mechanical, great for long drones or pads to keep them sonically engaging without a recognizable LFO pattern.

Hexaphonic Serial Audio Processor

Applies a serialist modulation concept across six channels or six parameters (hexaphonic implies six outputs or voices). Possibly it splits the audio into six bands or channels and then modulates them following a serial (twelve-tone technique-inspired) sequence. "Serialist Amplitude Modulation Audio Effect" suggests maybe each of six modulators corresponds to a note in a tone row or a fixed amplitude pattern that goes through all twelve-tone permutations for amplitude modulation. Alternatively, "hexaphonic" could literally mean 6-channel output, processing each channel in turn or in a series. In practice, this might create a rotation of modulation effects in a sequence that doesn't repeat until going through six steps, like amplitude goes high on channel 1, then channel 2, ... channel 6, each time following some serial order of levels. It results in a complex interplay where each of the six parts goes through a series of modulations without repeating patterns until the full series is done. This is a very specialized effect likely used to impose a highly structured amplitude pattern (or spatial pattern in 6 speakers) derived from serial music concepts, adding a rigorous order to otherwise static or homogeneous sound.

Karplus-Strong Modulator

Uses the Karplus-Strong algorithm (which normally generates plucked string tones) as a modulation source instead of directly audible. For example, the bouncy output of a Karplus-Strong string (which is essentially a damped oscillation with a particular frequency and decay) could modulate the amplitude or frequency of another sound. The "Modulator" suggests you plug a sound in, and the Karplus-Strong process modulates it, maybe by feeding the sound into a delay loop so it becomes part of the pluck feedback, effectively modulating its tone with comb-filter-like resonances. Or it could modulate an effect parameter with the string's envelope. The end result might be a resonant, springy modulation effect, making the target sound wobble as if resonating in a string or echoing with a tone. It's a creative way to imprint string-like qualities (quick attack and decay, slight pitch warble from tension) onto any audio.

METAMODULATOR

The Metamodulator implements advanced ring modulation with phase distortion techniques, far beyond simple amplitude modulation. It transforms audio through 8 distinct algorithms that manipulate phase relationships, frequency sweeps, and time-varying modulations. Each algorithm applies mathematical functions (cubic, quadratic, exponential, logarithmic, sinusoidal) to the phase argument of a sine wave modulator, creating complex sidebands, harmonic distortions, and evolving spectral textures. With 30+ carefully crafted presets, this tool provides instant access to sounds ranging from subtle vintage warmth to extreme sci-fi transformations.

Phonetic Tremolo-Glitch Effect

Applies a tremolo/glitch processing that is aware of phonetic boundaries or content. This likely means when used on speech or vocals, it will modulate or cut audio in sync with phonemes, for example, only during vowels or only between words. It might identify voiced segments and apply a tremolo, or glitch (stutter/cut) only certain parts of the speech like unvoiced consonants. By doing so, it creates a glitch effect that still retains intelligibility or rhythmic pattern of the speech. For example, a singer's voice might get chopped up but each vowel still comes through, or a tremolo that emphasizes the natural syllabic rhythm. This yields a distinctly speech-driven rhythmic effect, great for experimental vocals, keeping some clarity while making them stutter or pulse in novel ways.

Rhythmic LFO Wah-Wah

Runs a wah-wah filter (band-pass resonant sweep) modulated by an LFO that is synced to a rhythm or BPM. So instead of a continuous sweep, the filter might oscillate in time with the beat (like 8th note wah pulses, or a patterned sequence of filter movements). It's essentially an auto-wah where the wah movement is rhythmic and predictable (say, a sine or triangle at musical subdivisions). The result is a funky, periodic filter effect that doubles as a rhythmic element, e.g., making a pad go "wah-wah-wah" on quarter notes. It's useful for adding groove: any sustained sound can become a throbbing, talking rhythm component by this synchronized wah, blending timbral change with the beat.

Spectral-Driven Intensity Modulation

Modulates the intensity (volume) of the sound based on its spectral content in real time. For example, if the spectrum gets brighter (more high-frequency energy), the script might automatically reduce or increase volume, or vice versa. Essentially, some spectral feature (like centroid or specific band energy) is driving an amplitude LFO or envelope. This means the dynamics of the sound become tied to its timbre, e.g., when a noise gets brighter, maybe it ducks in volume, giving a subtle de-essing-like effect but creatively applied, or making a complex sound pulsate whenever certain frequencies dominate. In creative terms, you could have a drone that gets quieter when it becomes more harmonic and louder when it becomes noise-like, etc., establishing an interplay between tone and loudness which can produce self-modulating, breathing textures.

Spectral Driven Vibrato

Applies a vibrato (pitch modulation) to the sound where the depth or rate of vibrato is influenced by spectral characteristics. For instance, if the sound's spectrum is rich in high frequencies at a moment, the vibrato might deepen or speed up, and if it's a pure tone moment, vibrato eases off. This ties vibrato expressiveness to timbre: perhaps a voice automatically gets more vibrato when it grows brighter or louder (since brightness often correlates with intensity). The result is a pitch modulation that isn't constant, but reacts, a voice or instrument could waver more on certain resonant notes, giving an organic feel. It's useful for letting the timbre of a sound dynamically shape its pitch fluctuations, producing a lively, responsive sound, e.g., a violin sample that increases vibrato on louder/brighter notes without manual intervention.

Stereo Flanger

Applies a classic flanger effect (short modulated delay with feedback) in stereo. Likely, it splits the effect so that the delay modulation is offset between left and right channels (e.g., out of phase LFOs), creating a wide swirling effect. The flanger produces comb-filtered sweeps (that jet-plane whoosh), and in stereo this whoosh can travel between speakers or give a sense of space. This effect is great for adding motion and color: a dull pad or guitar can get that psychedelic sweeping texture that moves around the head. It's a staple effect, and here specifically ensuring a rich stereo experience.

Stereo Phaser

Applies a phaser (all-pass filter network creating notches) in stereo, likely with phase-inverted LFO between channels or different notch frequencies per channel. A phaser gives a swirly, whooshy tone similar to flanger but through phase cancellation. In stereo, the notches might sweep opposite in each ear, creating a sense of rotation or a wider image. This gives any sustained sound a more interesting, evolving quality, and in stereo it can sound enveloping, good for electric piano, pads, or any sound you want to make more hypnotic and spatially animated.

Stereo Rotary Speaker

Emulates a Leslie rotary speaker cabinet in stereo. Leslie speakers have a rotating horn (treble) and drum (bass) that create doppler (pitch modulation) and amplitude modulation as well as phase changes. This script likely applies a combination of tremolo (amplitude mod), vibrato (doppler pitch mod), and filtering that correspond to a rotating speaker's effect, with separate treatment for low and high frequencies (two rotating elements) and a certain rotation speed (switchable between slow/fast speeds like a real Leslie). The stereo output simulates the movement around the microphone positions. Using this on organ sounds or guitars gives that classic swirling effect; experimentally, you can put any sound through it to give it a rich, moving character as if placed in a spinning sound field, great for immersive sound or vintage vibes.

Stereo Swirl Vibrato

Applies a vibrato effect (pitch modulation) that swirls in the stereo field. Possibly each channel's vibrato LFO is phase-offset, or maybe the vibrato is paired with panning such that as pitch rises, sound pans, etc. The result is that the vibrato not only wavers the pitch but also causes the sound to move or alternate between left-right, giving a swirling sensation. It's a more complex spatial vibrato: you might hear the tone wobble and also feel it circling your head. This can add a dreamy or disorienting movement to an otherwise static sound, useful for thickening a sound in stereo and making it more captivating.

Stretch-Tremolo Ambience

Combines time-stretching and tremolo to create an ambient effect. It likely stretches the sound (slowing it down significantly, like a mini-Paulstretch) to create a pad or ambient tail, and simultaneously applies a slow tremolo (volume pulsation) to that stretched sound. The outcome is a lush, elongated version of the input that has a gentle pulsing or throbbing in volume, adding motion to the otherwise static stretch. It's like turning a short sound into a long ambient drone that shimmers in loudness. This is great for creating atmospheric backgrounds from small samples, the stretch makes it smooth and sustained, and the tremolo gives it life so it's not just a flat tone.

Time Varying Spectral Vibrato

Applies a vibrato whose characteristics (speed or depth) change over time, specifically possibly targeted at parts of the spectrum differently. It could mean that different frequency bands get vibrato at different rates (like low frequencies wobble slower than high frequencies), or simply that the vibrato LFO itself has an envelope (maybe speeding up or slowing down as time goes). The "spectral" keyword suggests possibly modulating phases of partials differently, which might create an evolving chorusing/vibrato effect across the spectrum. In use, such an effect might make a sustained sound first have a slow gentle vibrato that gradually becomes faster or deeper, or a complex shimmer where the timbre oscillates in a spreading pattern. It adds a dynamic complexity to vibrato beyond a steady sine wave, making the pitch modulation itself an evolving parameter, yielding more interest over longer tones.

Unified Chorus Generator

Creates a flexible chorus/ensemble effect offering multiple modes (Dual Tap, Tri Tap, Orbit, etc.). Chorus duplicates the sound and detunes/delays copies to thicken it. "Dual Tap" might mean two delayed voices, "Tri Tap" three voices, and "Orbit (Drifting Phase)" suggests an option where these voices have slowly drifting phase relationships (giving a lush, swirling result). This unified tool likely lets you choose configurations to simulate anything from a subtle chorus to a big ensemble (like multiple instruments). It's useful for thickening and stereofying sounds: a mono voice can become a wide chorus, a simple synth becomes like an ensemble of oscillators. The flexibility means one can tune how pronounced or complex the chorus is, from a basic doubling to a rich detuned swarm, as needed in an experimental mix.

Unified Multi-Mode Vibrato

Provides a comprehensive vibrato effect with various modes (Standard, Chirped, Rate-Modulated, Swarm, Enveloped). This means you can apply a normal vibrato, or a "chirped" vibrato (maybe whose rate changes like a siren), a rate-modulated one (vibrato speed itself modulated by another LFO, making it speed up/slow down cyclically), a swarm (perhaps multiple vibrato voices out of phase, giving a chorusy vibrato), and enveloped (vibrato depth or rate follows an ADSR envelope, so it might fade in or out). Having all these in one tool allows the composer to tailor pitch modulation intricately: for example, start with no vibrato then increase (enveloped), or have it irregular (rate-modulated), or very thick (swarm, which could simulate multiple vibrating sources together). This is useful on sustained tones or vocals where a simple vibrato is too plain, these modes add character (e.g., a vibrato that wavers erratically or in pulses, or an ensemble of slightly different vibratos) to make the sound more compelling or otherworldly.

XY Shape LFO Modulation

Two-dimensional LFO modulation using mathematical shape trajectories (X and Y functions) for complex time-warping, amplitude modulation, and spatial effects.

↑ Back to top

Pitch 27

Adaptive Pitch Shifter

Shifts the pitch of the sound up or down but in an adaptive way, possibly preserving formants or adjusting amount based on context. It might detect the pitch contour and apply varying shifts: for instance, less shift during certain passages or snap to scale. Or perhaps it automatically chooses the best interval to shift to harmonize with something. The key is it's not a static semitone shift, it adapts to the input's melody or timbre. The result is a pitch change effect that is smarter (maybe keeps vocals sounding natural by not shifting formants, or it could correct certain notes differently). Useful for subtle pitch corrections or creating harmonies that follow the singer intelligently (like shifting more when the singer is lower vs less when higher to keep within range, etc.).

Auto-Harmonic Layering

Automatically adds harmonic layers (additional notes) to an audio's detected pitches. It might track the melody of a monophonic source and generate one or more harmony voices (like a third above, a fifth below, etc.) mixed back in. Essentially, it's an intelligent harmonizer: given a melody, it produces a chord or chorus by layering pitches that musically complement the original. The user might set the interval or it might choose from a key. This enriches the original sound, for a single sung line, it could create a choir effect by adding harmony notes. In experimental use, one could create dense harmonic pads from a simple source or turn a melody into chords automatically.

Bimodal Contour Grammar

A generative contour method: builds melodic shape from phrase‑level gesture primitives (Onset → Nucleus → Coda). The same abstract contour is rendered in two modalities: as sound (via pitch resynthesis) and as image (coloured pitch contour).

Breathing Pitch Waves

Modulates the pitch in a gentle, wave-like pattern that perhaps mimics breathing cycles. This suggests a slow, periodic rise and fall of pitch (like a slow vibrato spanning a few Hz) that might also have a slight rhythmic inhale-exhale feel (maybe asymmetry: slower drift up, quicker drop or vice versa). The outcome is a slow undulation of pitch as if the sound itself is "breathing." This can make drones or held notes more alive, adding a cyclic drifting intonation. It's subtle and organic, great for adding a humanizing fluctuation to sustained tones (like simulate how a singer's pitch might softly oscillate with breath support variations).

Building Block

A basic pitch processing utility, possibly a foundation or template script for other pitch effects. As a standalone, it might simply allow transposition and time-scaling ("globally change pitch and duration" is another script, maybe related). This likely provides fundamental operations: get pitch track, shift it uniformly, maybe stylize it. In context, it could be thought of as a core function other scripts call, but used alone it may do a straightforward pitch transform. For a user, it might mean they can set up a simple pitch manipulation (like "change pitch by X semitones") with this script, which serves as a *building block* for more complex tasks.

Chord Generator from Audio

Analyzes an audio (probably polyphonic or at least with overtones) and generates a musical chord (a set of MIDI pitches or tones) that represent the sound's pitch content. It likely picks out prominent frequencies or fundamental and maybe a few overtones, interpreting them as musical notes forming a chord. For instance, play a piano note, and it might output the nearest chord (like "C major" if the note's harmonics align somewhat). More practically, if given a complex sound or short snippet, it tries to find a chord whose combined sound would approximate that spectrum. This is useful for harmony generation, one can extract chords from arbitrary sounds or noise, turning timbres into harmonic information.

Doppler Effect Simulator

This script simulates the Doppler effect, the change in frequency (and amplitude) of a sound as its source moves relative to a listener. It applies time‑varying pitch‑shifting based on the radial velocity of the source, and optionally a distance‑based amplitude attenuation for enhanced realism. The simulation is physically accurate, using the standard acoustic Doppler formula and inverse‑square‑law amplitude scaling.

Exponential Glide Up

Applies a pitch glide (glissando) upward with an exponential curve (slow start, faster finish). For example, taking a note and making it slide up an octave, starting almost flat then increasing rate exponentially until it reaches the target quickly at the end. This produces a natural-sounding rise (like how some physical sounds might rise in pitch when accelerating). It can be used to create build-ups (like a swooping upward effect into a transition) or to stylize an attack of a note (letting it scoop up into pitch). It's a straightforward effect but with a curved motion that's more interesting than linear, often perceived as more dramatic because it spends time then suddenly leaps to the top.

Formula Audio Manipulation

Allows direct mathematical manipulation of the audio waveform via a formula. The user could input an expression (like a function of time or sample number) that modifies each sample. For instance, applying a formula to distort (like x - 0.5*x^3) or to impose an amplitude pattern (multiplying by a sin wave function) or even to implement custom filters in time domain. This is a very general tool: if you can express the desired effect mathematically, the script will apply it. It's extremely flexible for those comfortable with math, for example, you could remove even samples, invert certain segments, apply bizarre non-linear curves that standard effects can't do. It's essentially a "do it yourself" audio processor that executes a user-given formula on the signal, which in experimental composition is gold for trying unusual transformations that no off-the-shelf plugin offers.

Fractal Pitch Terrain

Generates a pitch contour or variations using fractal algorithms (self-similar patterns). It could create a melody or modulation pattern that has structure at multiple scales (like a pitch wiggle pattern that has similar shape zoomed in and out). Perhaps using fractal noise (like 1/f noise) to vary pitch. The result could be a wandering pitch trajectory that is constrained (not purely random, has continuity) but never repeating exactly, often yielding an interesting balance of unpredictability and coherence. Composers might use this to modulate a sustained tone (giving it a fractally fluctuating pitch) or to create entire fractal melodies (which can sound fluid but non-tonal, good for ambient or experimental pieces that need "organic randomness").

Globally change the pitch and duration

Changes the overall pitch and duration of the sound together, basically like tape speed change. If you raise pitch, duration shortens; if you lower pitch, duration lengthens, preserving the original relationship (no time-stretch algorithm artifacts, just resampling). This is akin to playing a recording faster or slower. It's a simple effect but yields the classic Alvin and the Chipmunks (speed up) or slow-mo low pitch results. In experimental use, one might use it to transpose a recording by some amount *with* the time change (for aesthetic effect, or to match lengths perhaps), or to simulate tape-manipulation pieces. It differs from a normal pitch shifter (which keeps length same) and a time-stretcher (which keeps pitch same), here both change together realistically.

L-System Granular Pitch Effect

Uses an L-system (Lindenmayer system, a recursive grammar often used to model plant growth or fractal patterns) to control granular pitch manipulation. Possibly, it generates a sequence of pitch shifts or grain playback order using an L-system string output. For example, an L-system might produce a sequence of symbols that correspond to pitch transpositions for each grain (like +, - moves). This could result in a structured yet complex pattern of pitch changes in the granular effect, maybe fractal-like transposition patterns. The outcome is a granular sound whose pitch jumps follow an intricate design (like fractal melody bursts or self-similar transposition cascades). This adds a layer of algorithmic complexity to granular pitch effects, making them less random and more pattern-rich, which can be fascinating to listen to.

Messagesquisse Opening

This script implements a Messagesquisse Opening, a Boulez-inspired additive drone machine that transforms a single (cello) tone into a six-layer hexachordal field using the SACHER pitch set and Morse-derived timing, with spatial distribution across the stereo field.

Microtonal Harmonic Field Engine

Analysis‑driven microtonal harmonisation for existing audio. Detects stable (S), unstable (U), and noisy (N) zones from pitch, harmonicity, and intensity. Derives local harmonic anchors from the source itself, then generates companion voices via phrase‑granular resampling (playback‑rate pitch shifting). Commas and wolf intervals are tracked and used as compositional events, not corrected.

Pitch Change (Semitones)

Changes the pitch of the sound by a specified number of semitones. This is a straightforward pitch transposition effect that preserves the duration of the original sound (unlike "globally change pitch and duration" which also changes speed). It's useful for tuning samples to match a key or creating harmonies by layering transposed copies.

Pitch Contour Transfer

Takes the pitch contour (melody shape) from one sound and imposes it on another sound. Essentially, it decouples content and pitch: you have source A's melody and source B's timbre, and it forces B to follow A's pitch changes. This is like using one audio as a "pitch envelope" for another. For instance, you could make a sustained violin sample sing a speech's intonation by applying the speech's pitch contour to the violin sound. The result is that the second sound now rises and falls in pitch exactly as the first did, while keeping its original qualities otherwise. It's very useful for creative sound design (making instruments talk or environmental sounds have a tune) and for composition techniques like cross-synthesis of musical expression, where you borrow the expressivity of one recording to animate another sound.

Pitch Correction

Adjusts the pitch of a monophonic sound to correct it to a nearest desired note or scale. This is akin to Auto-Tune (though likely simpler, offline). It probably detects the pitch curve and then either flattens it toward stable notes or nudges off-pitch parts to intended frequencies. The goal is to make out-of-tune singing or instruments in tune without dramatically changing the performance otherwise. In composition, beyond just tuning vocals, one could use extreme settings to quantize a natural sound's pitches to a scale (making a bird song conform to a C major, for example) or creative misuse for that robotic tuned effect if desired.

Pitch Morphing between Targets

Morphs the pitch contour of a sound gradually from one target pattern to another. Possibly you provide two target pitch patterns (like two melodies or two intonation shapes), and the script transforms the original pitch curve from following target A at start to target B by the end. It's a gradual interpolation between two pitch sequences. This is akin to audio morphing but specifically for pitch structure. If applied to a sustained sound or phrase, its melody would slowly change from one tune to another seamlessly. This is great for creating transitional melodies or portamento effects that literally move one theme into another, or for sound design where an animal call's pitch cadence morphs into a human speech melody, etc.

Pitch Processor

A general tool for processing the pitch of a sound in various ways. It likely provides multiple operations: transposition, bending, scaling vibrato, quantizing, maybe adding portamento or removing it. The name is broad, it's a "Swiss Army knife" for doing things with pitch. With it, a user might be able to do tasks like invert a melody, compress its pitch range, shift certain notes, impose a new contour, etc. In creative terms, if you want to systematically alter how a melody goes (like every interval halved, or smooth out fluctuations), a pitch processor can do that.

Pitch Stylization and Shift

Stylizes the pitch contour (like Praat's pitch stylize function, which simplifies a contour into a few linear segments) and also allows shifting the whole contour up or down. In effect, it smooths a pitch curve (removing micro deviations, maybe to get a more stable intonation or a cartoonish simplified melody) and then can transpose it. The result is a cleaner, possibly monotonic or stepwise version of the original melody at a new pitch. Use-case: turn a natural speech intonation into a simpler "melody" and then shift it into a musical range, effectively making someone "sing" more clearly. It's a way to reduce complexity in a pitch contour for aesthetic effect and transpose it to fit elsewhere.

Quantum Pitch Jumps

Introduces discrete, random pitch jumps as if the pitch is "quantized" in a quantum sense, unpredictably flipping to new values. Instead of continuous pitch movement, the sound jumps in sudden steps to different pitches (maybe within a scale or range), like an electron making quantum leaps rather than gliding. This could be implemented by sampling the pitch at intervals and randomly offsetting it, or by intentionally making a normally smooth pitch track into a stair-stepped one. The result is a jittery pitch effect: the note seems to teleport between different frequencies rather than slide. Musically, it's a glitchy effect, making something sound unstable or stuttering in frequency (like a broken tape that re-pitches now and then), useful for experimental "broken" sounding elements.

Rhythmic Pitch Percussion

Turns pitch changes into a percussive rhythm or uses pitch to create percussive patterns. Possibly it takes a pitched sound and modulates its pitch rapidly to create a sense of pitched percussion hits (like using pitch drops as drum hits). Or it analyzes rhythmic aspects and assigns pitches per beat, making a pitched rhythm sequence. The name suggests maybe it reads the rhythmic envelope of a percussive sound and uses that to drive a pitch pattern. Outcome: you might get something like each drum hit being assigned a note, so a drum loop now plays a melody, or a pitched sound being re-triggered rhythmically by its own pitch envelope. This crossing of pitch and rhythm allows turning melodic content into percussive patterns and vice versa, giving a hybrid element (e.g., a piano phrase that now hits like a rhythmic sequence, or drums that carry a subtle melody through pitch changes on hits).

Spectral Pitch Shifter

Shifts pitch using a spectral method, likely preserving formants or achieving high quality. This might mean it uses the phase vocoder to shift frequencies, or separates harmonics and repositions them. It could allow more advanced pitch shift like shifting different parts of spectrum by different amounts (maybe preserving low frequencies while shifting highs more, etc.). Essentially, it's a pitch shifter operating in frequency domain, which might allow for fewer artifacts or creative tweaks (like only shifting harmonic components, not noise). In usage, one could do smooth pitch adjustments on complex sounds with minimal quality loss, or weird spectral repitching like shifting only certain bands. It's a tool for fine-grained or high-quality pitch transformations beyond simple resampling.

Spiral Pitch Dance

Probably akin to Spiral Frequency Modulation from Filter & Color but applied to pitched content or notes. It might cyclically raise pitch through octaves and drop back in a way that creates a never-ending rising/falling illusion (Shepard tones), a pitch dance that spirals up or down continuously. Or it could be an LFO that modulates pitch in a spiral manner (maybe combining rising gliss with vibrato such that it keeps climbing overall). The result is a pitch pattern that feels like it's always ascending or descending in a spiral, perhaps applied to multiple layers (like one tone goes up as another resets an octave lower). This can be used to create an auditory illusion of infinity in melody, common example: a Shepard-Risset glissando effect for a mind-bending background or transition.

Spiral Segmentation

This script implements Spiral Segmentation, a time and pitch transformation that creates spiral trajectories through audio material. Process: (1) Segmentation: Divide sound into equal-duration segments. (2) Duration spiral: Apply exponential scaling to segment durations (expanding or contracting). (3) Pitch spiral: Apply incremental pitch shifts to each segment. (4) Jitter addition: Add stochastic timing variations for non-metric feel. (5) Resynthesis: Recombine transformed segments via PSOLA (Pitch-Synchronous Overlap-Add). Result: Audio material returns repeatedly, but each return occurs at transformed temporal and spectral levels, never identical, never metrically fixed.

Undertone Field

This script implements an Undertone Field generator, a tool that creates undertone layers from a source sound using sample-rate reinterpretation. The original sound remains at the center, while generated undertones are spread spatially across the stereo field using an equal-power panning arc. No PSOLA or pitch manipulation is used; undertones are created purely by playing the source at lower sample rates and resampling back to the original rate.

Tempo-Pitch Curves (Accelerando & Ritardando)

Applies linked changes in tempo and pitch over time (like one would get by altering playback speed): specifically, Accelerando (speeding up) and Ritardando (slowing down). The script likely lets you define a curve for tempo change (increase or decrease in speed) and then it executes that by continuously resampling the audio. As a result, the audio speeds up or slows down gradually (tempo curve) and concurrently pitch goes up or down (since speed change affects pitch). This simulates how a live ensemble might speed up or slow down, everything including pitch shifts if it were tape. It can be used for dramatic effects: a section of audio gradually becoming faster and higher, or slowing and deepening, which can be quite striking in a composition when applied to recorded material.

Reverb 29

Artificial Room

This script implements artificial room acoustics simulation, a physically-informed approach to reverberation using synthetic impulse responses. The process: (1) Room modeling: Calculate acoustic properties based on dimensions and materials, (2) T60 calculation: Compute frequency-dependent reverberation times using Eyring's formula, (3) IR generation: Create synthetic impulse response with early reflections and filtered noise tails, (4) Convolution: Apply IR to dry sound via convolution. Result: realistic room reverberation with physically accurate decay characteristics.

Cascading Echoes

This script creates cascading echo effects through iterative random-delay feedback processing. Unlike simple delay effects with fixed repetition times, this script applies multiple passes of randomly-varying delays, creating complex, diffuse echo patterns that range from tight reflections to long ambient tails. The result sounds like acoustic reflections in irregular spaces, natural, unpredictable, and spatially rich.

Chaotic Bloom

This script creates chaotic bloom reverberation using convolution with impulse responses generated from Poisson processes. Unlike traditional reverb (which simulates room acoustics) or the Cascading Echoes script (which uses iterative delays), Chaotic Bloom convolves your audio with a mathematically-generated "bloom" impulse, a dense cloud of randomized events that creates shimmering, diffuse, otherworldly reverberation. The result "blooms" outward from the source like light diffracting through a crystal.

Crystalline Cascade

This script creates quantum flutter reverb, a sophisticated multi-layer effect combining stochastic (random) impulse generation via Poisson processes, reverse-exponential amplitude envelopes, complex frequency modulation, and triple-layer mixing. The result: shimmering, crystalline, organic reverb tails that sound like cascading ice crystals, quantum particle decay, or complex acoustic reflections in impossible spaces. Unlike traditional reverb (simple exponential decay) or algorithmic delay (regular echoes), quantum flutter creates dense, random-yet-structured textures with evolving spectral content. The name reflects the quantum-mechanical inspiration: randomness with statistical regularity, like radioactive decay or photon emission.

Entropy-Modulated Dynamic Reverb

This script implements entropy-modulated dynamic reverb, an intelligent reverberation system that analyzes spectral complexity in real-time to control reverb characteristics. The system measures spectral entropy (information content) of the input signal and uses this measurement to dynamically blend between two contrasting reverb impulses: a dark reverb (long decay, heavy damping) for low-entropy signals and a bright reverb (short decay, light damping) for high-entropy signals. Additionally, the overall wet/dry mix is modulated by entropy, creating an adaptive spatial effect that responds to the audio's spectral characteristics.

Feedback-Aware Convolution

This script implements feedback-aware convolution, a dynamic audio processing technique that generates impulse responses based on the acoustic characteristics of the input sound itself. The process: (1) Feature extraction: Analyze the sound for intensity or pitch content, (2) Threshold detection: Identify moments where features exceed user-defined thresholds, (3) Impulse generation: Create an impulse train where each impulse corresponds to a detected event, (4) Amplitude mapping: Scale impulse amplitudes based on feature values, (5) Convolution: Convolve the original sound with the generated impulse train. Result: self-modulating effects where the processing is dynamically controlled by the audio's own characteristics.

Fractal Feedback

This script implements fractal feedback reverb, an advanced reverberation technique that creates complex, evolving spatial effects using fractal mathematics and chaotic feedback patterns. Generates reverb tails with self-similar delay structures, modulated feedback, and stereo variations that create organic, non-linear reverberation characteristics unlike traditional algorithmic reverbs.

Fractal Feedback Reverb

This script implements a Fractal Feedback Reverb, a chaotic delay network that generates non-linear, evolving reverberation tails using fractal exponentiation, memory-depth cycling, and amplitude-modulated feedback. Unlike conventional reverbs with fixed decay patterns, this reverb creates self-similar, recursively generated delay structures that evolve unpredictably over time.

Granular Displacement

This script implements granular displacement, an advanced audio processing technique that applies different delay offsets to individual time segments (grains) of audio. Creates complex phasing, flanging, and micro-temporal effects by displacing segments relative to each other, then mixing them with the original signal. Process divides audio into grains, applies random delays and amplitudes to each, then recombines for rich temporal textures.

Gravitational Lens Reverb

This script implements gravitational lens reverb, an advanced audio processing technique that simulates the effects of gravitational physics on sound propagation. Creates complex, curved delay patterns inspired by gravitational lensing, where massive objects bend the path of sound waves, combined with relativistic time dilation effects. Process models multiple gravitational masses that bend audio "rays" through curved spacetime.

Harmonic Comb

This script implements harmonic comb filtering, an advanced audio processing technique that creates complex resonant patterns using mathematical harmonic series. Generates multiple delay lines tuned to harmonic ratios of a fundamental frequency, creating intricate comb filtering effects that emphasize specific harmonic relationships. Process applies weighted, modulated delays at harmonic intervals to produce rich metallic textures and resonant characteristics.

Harmonic Decay Reverb

Creates echoes at harmonically‑related delay times using power‑law spacing. Delay times follow delay[k] = base × k^(1/spread), creating dense early reflections that spread out over time – similar to natural room mode decay. Amplitude decays exponentially with random variation for organic texture.

Ligeti Micropolyphonic Choir Machine

This script implements Ligeti-inspired micropolyphonic texture generation, creating complex choral clouds from a single sound source through algorithmic voice proliferation. The machine generates 2–60 independent voices, each with carefully controlled variations in timing, pitch, duration, panning, and amplitude. Inspired by György Ligeti's compositions like "Lux Aeterna" and "Atmosphères," this tool transforms monophonic or stereo material into dense, evolving textures through formal structural arcs, Gaussian distribution controls, and intentional stereo asymmetry.

Morphing Resonance

This script implements morphing resonance, an advanced audio processing technique that creates evolving resonant textures through frequency-morphing impulse patterns and stereo chorus enhancement. Generates stochastic Poisson impulse trains that morph in frequency over time, convolves them with audio to create complex resonant textures, then applies chorus effects for rich stereo imaging. Process combines mathematical impulse generation, frequency modulation, convolution processing, and stereo enhancement in a sophisticated processing pipeline.

Ping-Pong Field

Likely a ping-pong delay effect applied in a spatial "field", maybe multi-channel or across stereo widely. "Field" could imply multi-channel environment, but probably stereo where delays bounce left-right. Many DAWs have ping-pong delay (where echo alternates L and R). This script likely outputs a series of echoes that bounce between the channels, possibly even moving position gradually (creating a field of bouncing sound). It's essentially an echo that explicitly fills the stereo field by bouncing. The effect is dynamic and rhythmic, each echo appears to come from opposite side alternately, which can widen the stereo image and create interplay. It's a straightforward but effective spatial echo for rhythmic delay patterns (e.g., a guitar note repeats left, then right, then left, etc., giving a lively movement).

Quantum Uncertainty Reverb

This script implements quantum uncertainty reverb, an algorithmic reverb inspired by quantum mechanics principles of superposition and wave function collapse. Core concept: Each reverb "reflection" represents a quantum state with inherent time-amplitude uncertainty (Heisenberg-inspired). States exist in superposition (multiple delay paths) or collapse to single reflections based on probability thresholds. Algorithm generates N quantum states (default 35), each with: (1) Time uncertainty: Delay time drawn from Gaussian distribution (μ = time_mean, σ = uncertainty_stddev). (2) Amplitude precision: Inversely proportional to time uncertainty (greater time uncertainty = more precise amplitude, mimicking uncertainty principle). (3) Collapse probability: Random value determines if state exists as single reflection (collapsed) or superposition (multiple substates). Result: Organic, non-repeating reverb texture with statistical density control rather than fixed delay taps. Stereo processing uses independent random parameters per channel for spatial width. Optional silent tail extends processing beyond original duration.

Ray Tracing Room Acoustics

Simulates room acoustics using ray tracing, a method from acoustics where sound rays reflect around a modeled room geometry. The script likely lets you input dimensions/materials and then it computes how sound would bounce (to some approximation) and generates the corresponding reverb/echo pattern. This is more physically accurate than algorithmic reverb, more akin to how an actual room responds, including distinct early reflections from walls and a diffuse tail. Using ray tracing suggests it can handle non-trivial room shapes. The result is a realistic spatial simulation: great for research or for placing sounds convincingly in a virtual space (for instance, "what if I clap in a long hallway shaped like X?"). In creative use, you can simulate exotic acoustic spaces that might not exist or just get a unique reverb character by customizing shape and material beyond typical presets.

Ribbon Shimmer

Lush reverb effect with exponentially‑spaced delays and high‑frequency enhancement. Delay times follow: delay[k] = min_delay × (max_delay / min_delay)^(k/N), creating dense early reflections that thin out over time. HF sparkle via differentiation adds “air”. Polarity alternation creates rich phase texture.

Smooth Cosmic Reverb

The Smooth Cosmic Reverb creates a unique reverberation effect by combining multiple delay lines with both delay time modulation and amplitude modulation. Unlike traditional reverb algorithms that use recursive filters or convolution, this approach creates an ethereal, "swimming" quality through carefully modulated delays.

Spectral Decay

Convolution reverb with a Poisson‑based impulse response featuring exponential decay, chirp (sweeping) modulation, and bandpass filtering. The IR is generated from a Poisson point process (simulating sparse reflections) with an amplitude envelope decay_base^(-t/impulse_dur) and a sinusoidal chirp: 1 + 0.7·sin(2π·t·150 + t·20). A Hann bandpass filter (100–4000 Hz) shapes the final tone.

Spectral Drift

This script implements spectral drift — an advanced audio processing technique that creates frequency-dependent modulation effects using harmonic delay patterns. Generates multiple comb filtering layers tuned to different harmonic frequencies, each with randomized drift amounts that create evolving spectral characteristics. Process applies frequency-dependent delays with cosine modulation to produce rich, drifting comb filtering effects that change over time.

Spectral Smearing Reverb

Frequency‑dependent delays simulating acoustic dispersion. Lower frequencies get longer delays (bass “hangs”), higher frequencies shorter. Uses an inverse‑square‑root dispersion model with a Lorentzian frequency response (peak around 600 Hz) and cosine modulation for textural richness.

Stereo Shimmer

Stereo Shimmer generates a dense series of echoes with linear delay spacing (delays increase linearly from a minimum to a maximum), combined with alternating polarity every four echoes and high‑frequency enhancement via a simple high‑pass‑like FIR filter: y[n] = x[n] + hf * (x[n] – x[n-1]).

Temporal Erosion

Gradually erodes the sound as it passes through the reverb, like each echo is more "eroded" than the last. That could be literally degrading audio quality (bit-crushing more per echo, or filtering more and more of it out), so later parts of reverb are more distorted or thinned out, as if the sound is weathering away over time. The reverb tail would thus start clear and slowly break apart (maybe become noise or vanish frequency components). It's an artistic effect: instead of a smooth decay, the tail disintegrates. Composers can use it for a metaphorical fade-out, where a sound's "memory" crumbles with each reflection, good in sound design for signifying decay or deterioration.

Temporal Warping

Warps the time distribution of reflections, likely meaning it might nonlinearly stretch parts of the reverb. For instance, early reflections might be closer than normal but late reflections stretched further, or vice versa. Could also involve modulating the timing of the tail dynamically (like a reverb that momentarily slows down or speeds up, maybe granular processing to time-stretch parts of the tail). The result is a reverb that doesn't flow at a constant rate: some parts might sustain longer than they should, others shorter, possibly producing an odd sensation of time in the space. Great for dreamlike or surreal scenes where the acoustics feel non-Newtonian (like clapping and hearing an echo that first comes quick then "hangs" unnaturally long).

The Lucier Machine

This script implements physical acoustic simulation of Alvin Lucier's iconic piece, a computational recreation of the 1969 experimental composition "I Am Sitting in a Room" through iterative convolution with a physically-modeled room impulse response. The process: (1) Physical Room Modeling: Generates a synthetic impulse response based on acoustic physics (RT60 decay, reflection density, microphone placement). (2) Iterative Convolution: Repeatedly convolves an audio source (typically speech) with the room model, simulating re-recording in the same space multiple times. (3) Gradual Transformation: With each iteration, speech intelligibility decreases while room resonances become dominant. (4) Physical Parameter Control: Models real acoustic phenomena like microphone proximity effect, reflection decay, and pre-delay. The result is a transformation from clear speech to pure resonant tones, exactly as in Lucier's original conceptual piece.

Universal Convolution Generator

A general tool to convolve any two sounds (or to generate convolution effects from provided impulses) in a flexible way. Perhaps it can convolve a sound with either an impulse response or another arbitrary sound to create sound hybrids or reverbs. "Universal" suggests it's not limited to reverb use, one could use it for creative filtering (convolve voice with piano chord to imprint that resonance) or any experimental linear blending. This is the go-to for any situation you want to apply one sound's spectral imprint onto another. Very powerful: e.g., convolving a drum loop with a spoken word might create a rhythmic texture that has vocal quality, etc. It basically opens the door for all convolution-based creativity (reverbs, sound morphs, spectral blending) within Praat.

Spatial & Surround 36

3D Audio Room Simulator with Distance-Based Panning

This script implements dynamic spatial audio processing, combining room convolution reverb with sound source movement around a stationary listener. The process: (1) Room modeling: Generate synthetic impulse response based on room dimensions and absorption, (2) Movement simulation: Calculate multiple positions for sound source around listener, (3) DBAP panning: Use Distance-Based Amplitude Panning for realistic stereo positioning, (4) Segmented convolution: Apply room reverb to each position segment with crossfading. Result: immersive stereo audio with moving sound source in realistic acoustic space.

4-Channel Canon

Takes an input and creates a canon (musical round) across 4 channels. That likely means it will duplicate the sound four times, each starting at different delays (like one after the other) and send each copy to a different speaker/channel. Essentially a quadrophonic round: Channel 1 plays the original, then a bit later Channel 2 plays the same material, etc., until all four are playing offset versions. This can create a complex overlapping texture from one monophonic line. In spatial terms, each channel has part of the melody at any given time, swirling the music around if physically placed speakers accordingly. It's useful in multi-channel compositions to distribute a single motif in time and space, creating an immersive polyphony out of one line.

8-channel I Ching (Yin-Yang Spatializer)

This script implements algorithmic audio transformation using I Ching hexagrams, a unique compositional system that generates 8 parallel audio transformations based on randomly generated I Ching hexagrams. The process: (1) Hexagram Generation: Randomly generates 8 different I Ching hexagrams (6-line binary patterns). (2) Form Manipulation: For each channel, slices the audio into 6 equal segments, reversing segments corresponding to Yin (broken) lines. (3) Speed Variation: Calculates a speed factor from the hexagram's numerical value (0-63), applying time-stretching to each channel. (4) Spatial Combination: Combines the 8 transformed channels into a stereo output using Praat's channel combination algorithm. (5) Visual Display: Draws all 8 hexagrams in a grid layout showing their structure and calculated speed factors.

8-Channel Odd forward Even reversed

For 8-channel setups, this likely means it sends the audio to all 8 outputs, but channels 1,3,5,7 (odd) play it in forward time, while channels 2,4,6,8 (even) play the audio reversed. Possibly each pair might be synced such that e.g., channel 1 and 2 are a forward-reverse pair. The effect: if you have 8 speakers, half of them get a time-reversed version of sound relative to the others. This could produce a surreal spatial smear: as something plays normally on some speakers, an earlier part of it might simultaneously be heard backward on others. It's an experimental spatial effect making use of reversing audio to differentiate half the speakers, could result in interesting phasing or sense of envelopment (sound coming at you and receding). Good for trippy multi-channel soundscapes where time direction becomes a spatial parameter.

8-Channel Canon

Similar idea to 4-channel canon but with 8 channels. Likely it creates up to 7 delayed copies (plus original) of a sound, each starting after the previous, and outputs each copy on its own channel (so a melody or sequence would start on channel 1, then shortly after on channel 2, etc., until channel 8). This results in a rich, overlapping canon in 8-speaker space. If arranged in circle, the melody could appear to travel around as each speaker picks it up in succession. It's a powerful way to distribute one line into an 8-part round, making an immersive polyphonic texture.

8-Channel Delay

Applies delay lines to each of the eight channels of an input Sound, with optional cross-feeding between channels to create motion (ping–pong, ring chases, diffusion). Each delay has independent time, feedback, filter, level, and modulation. A global feedback matrix enables complex energy circulation while ensuring stability.

8-Channel Movements

This script turns an 8-channel bed into a spatial canvas. It distributes input energy to the array based on a time-varying virtual source position (and optional width). You can animate one or multiple sources via keyframes, LFO orbits, or stochastic walkers. Motion is rendered with constant-power panning and optional Vector-Base Amplitude Panning (VBAP) for triangle-based interpolation.

8-Channel Spectral Shift

This script creates 8-voice frequency shift canons by processing one input sound through FFT-based frequency shifting. Process: (1) Convert input to mono. (2) Create 8 copies. (3) Apply different frequency shift to each copy via FFT bin shifting (shift all frequencies up by N Hz). (4) Normalize each shifted version. (5) Combine into stereo pairs (1+2, 3+4, 5+6, 7+8), then mix pairs into final stereo output. Result: Thick, chorused texture with 8 detuned voices. Unlike pitch shifting (preserves harmonic relationships), frequency shifting moves all frequencies linearly, creates inharmonic detuning. Small shifts (50-300 Hz) = chorusing/ensemble. Large shifts (1000+ Hz) = spectral transformation/alienation. Stereo output contains all 8 voices mixed.

8-Channel Speed Deviations

The script varies the instantaneous playback speed of each of the eight channels around unity (1.0×). By default it uses high‑quality resampling with fractional‑delay interpolation. You can drive the speed by constants, LFOs, random walks, or imported envelopes—either independently per channel or linked in groups (e.g., front pair, rear pair).

8-Channels Time Polyphony

This Praat script generates complex, multi-layered textures by creating eight independent voices from a single source sound, each subject to a unique time-stretching factor. The Phase Vocoder algorithm is used to perform the time-stretching without altering the original pitch. The eight processed mono voices are then combined into a single 8-channel output sound object.

22.2 Synthetic Stem Renderer

Psychoacoustic approximation of a 22.2‑style synthetic stem renderer. Takes a mono or stereo input and produces a 24‑channel synthetic surround array (Middle, Upper, Lower layers + LFE) and an optional headphone output (clean fold‑down or true binaural using CNMAT KEMAR HRIRs).

Add Signals

Select two or more Sound objects and combine them into a single output via sum, average, or weighted mixing. The script aligns lengths, manages sample-rate differences (with optional resample), applies per-signal gain/polarity, and prevents clipping via peak normalization or headroom trims.

Advanced Stereo Panner

This script implements advanced stereo panning, a psychoacoustically-informed approach to spatial audio positioning using multiple perceptual cues. Unlike simple amplitude panning, this method incorporates: (1) Constant power panning: Maintains perceived loudness across pan positions. (2) Interaural Level Differences (ILD): Amplitude differences between ears. (3) Interaural Time Differences (ITD): Time delays between ears. (4) Spectral cues: High-frequency filtering simulating head shadow. (5) Distance modeling: Inverse square law attenuation and air absorption. Process converts mono to stereo, applies psychoacoustic cues based on pan position, creates realistic spatial impression. Result: natural-sounding stereo positioning with depth and direction cues rather than simple left-right balance.

BPM Panning

Automates panning based on a musical tempo (BPM). Likely you set a BPM and maybe a note value (like quarter note) and the sound will pan left-right at that rate (like an LFO synced to tempo). It's effectively a rhythmic auto-pan that ensures the movement corresponds to beat timing. E.g., at 120 BPM quarter notes, sound swings left on beat1, right on beat2, etc. This is useful for dance or rhythmic music where spatial movement should lock with the groove, or in experimental where you want a correlated spatial rhythm. It saves manually drawing automation, just specify BPM and pattern, and it does the pan accordingly.

BPM Surround Panning

This script implements algorithmic surround sound spatialization, a mathematical approach to creating immersive 3D audio experiences using parametric motion patterns. Takes mono or stereo source audio, distributes it across 8 channels (7.1 surround: FL, FR, C, LFE, SL, SR, BL, BR), applies time-varying amplitude envelopes to each channel based on chosen spatial pattern. Process creates perceived movement: sound source appears to orbit, spiral, bounce, or swarm through listening space. Mathematical formulas control spatial trajectories: trigonometric functions (sine/cosine) for circular motion, modulo operations for bouncing, Lissajous curves for figure-8 patterns, composite sine waves for chaotic swarm behavior. Result: spatially-animated audio where listener perceives sound moving through 3D space according to algorithmic patterns rather than static positioning or manual automation.

DBAP with Movement Control

Distance-Based Amplitude Panning (DBAP) with the ability to move the source dynamically. DBAP is a method for arbitrary speaker layouts where volume to each speaker is set inversely proportional to distance from a virtual source position. Movement Control implies you can specify a path or real-time movement for the virtual source, and this script updates the speaker gains accordingly over time. In practice, you can animate a sound source moving around in a spatial arrangement smoothly, with the correct amplitude distribution at each moment. This is crucial for spatial music, making a sound travel among speakers convincingly. Possibly you give it a trajectory (like series of coordinates or a function) and it outputs a multi-channel sequence where the sound moves along that path. Great for creating immersive fly-by or orbit effects.

Distance-Based Amplitude Panning (DBAP)

This Praat script implements Distance-Based Amplitude Panning (DBAP), a common spatial audio technique. DBAP determines the gain for each channel (speaker) by calculating the inverse distance between the virtual audio source position and each virtual speaker position. This process simulates the natural decay of sound amplitude over distance.

Distribute sounds in stereo field

This script implements automatic stereo panorama mixing, a spatial audio processing tool that takes multiple mono or stereo sounds and distributes them equally across the stereo field. Process involves: (1) Input validation: Ensures at least 2 sounds selected, handles stereo-to-mono conversion. (2) Parameter detection: Determines maximum duration and common sampling rate. (3) Spatial distribution: Calculates equal pan positions from hard left to hard right. (4) Constant-power panning: Applies psychoacoustically correct gain coefficients. (5) Accumulative mixing: Builds stereo mix by summing panned signals. (6) Peak normalization: Prevents clipping while maintaining optimal levels. Result: A clean stereo mix where each input sound occupies its own distinct spatial position, creating width and separation.

Even-Odd Harmonic Separator

This script separates harmonic sounds into odd and even harmonic series by applying stop-band (notch) filters at harmonic frequencies. Detects or uses specified fundamental frequency (F0), then filters out even harmonics to create odd-only version, and filters out odd harmonics to create even-only version. Outputs stereo file: left channel = odd harmonics, right channel = even harmonics. Listen with headphones for binaural effect!

Fast Spectral Swirl Multi-Channel

Per frame, the spectrum is taken via STFT. Bins are circularly shifted and/or phase‑advanced with a rate that can be constant or modulated. The result is a swirling timbre that preserves overall energy while redistributing partials. Multi‑channel handling keeps imaging stable when desired—or purposely decorrelated for wide, spacious effects.

Hamasaki Square Ambience

Psychoacoustic approximation of a Hamasaki Square ambience processor. Takes a mono or stereo input and produces a 4‑channel output in the order: L, R, Ls, Rs. Uses side‑signal extraction, bandpass filtering, symmetric delays, spectral decorrelation, and optional mid‑signal blending to create a natural surround ambience from any source.

Higher-Order Ambisonic (HOA) Decoder

This script decodes ambisonic B-format into playable speaker feeds. Input: individual ambisonic channel objects (W, X, Y, Z, and higher-order channels). Output: multichannel audio file with one channel per speaker, ready for playback on specific speaker array. Calculates decoder matrix using spherical harmonic functions and speaker positions, mixes channels with appropriate gains per speaker. Companion to HOA Encoder script.

Higher-Order Ambisonic (HOA) Encoder

This script encodes a mono sound source into ambisonic B-format, a full-sphere surround sound format based on spherical harmonics. Position source in 3D space (azimuth 0-360°, elevation -90° to +90°, distance in meters), choose ambisonic order (1st=4 channels, 2nd=9 channels, 3rd=16 channels), and script generates individual ambisonic channels (W, X, Y, Z...) with spherical harmonic weighting. Includes distance attenuation and top-down visualization. Output requires ambisonic decoder for playback on speakers or headphones.

Knight's Tour Sonification

This script implements knight's tour sonification, an advanced audio processing technique that maps the mathematical knight's tour puzzle onto audio parameters. The system divides your audio into 64 segments (matching chessboard squares) and applies dynamic stereo panning and amplitude modulation based on the knight's movement pattern across the board.

Microphone Simulation

This script simulates realistic microphone recording by applying polar pattern responses (omnidirectional, figure-8, cardioid, hypercardioid), stereo configurations (XY, AB, ORTF, Mid-Side, Blumlein, Decca Tree), and spatial cues (interaural time difference, distance attenuation). Takes mono source, positions it in 3D space (azimuth, distance), processes through microphone model(s), outputs mono or stereo result. Uses fractional-sample sinc interpolation for accurate ITD, corrected M/S polarity, and validated configurations. Useful for understanding microphone techniques, virtual mic placement, spatial audio simulation.

Mix selected multi-channel Sound into stereo

This tool mixes any selected Sound with N≥1 channels into stereo L/R. It supports common cinema/music layouts (mono, stereo, 5.1, 7.1) and arbitrary input by means of a configurable routing matrix. Optional normalization, bass/LFE handling, phase‑safe summing, and dB‑based coefficients are provided.

MCMC Musical Variation

This script implements an MCMC (Markov Chain Monte Carlo) Musical Variation engine, a Metropolis-Hastings sampler that explores the space of musical variations on a source sound. The state consists of per-phrase pitch offsets, time stretch ratios, and dynamic scaling factors. Proposals modify these parameters, and an energy function evaluates musicality based on scale conformity, voice leading, rhythmic stability, range, dynamics, phrase integrity, and contour variety. Accepted states are rendered as audio variations.

Multitrack Router

This script implements a Multitrack Router, a comprehensive routing and time-placement engine that takes multiple selected Sound objects, assigns them to virtual tracks, sequences them, applies gain and fades, and renders a single output in mono, stereo, or multichannel format.

Panning variations

This tool performs stereo panning and pan motion on mono or stereo signals. It implements industry-standard equal-gain and equal-power panning laws, supports static positions, time-varying trajectories (linear, curved, sinusoidal/LFO), and keyframe-based segments. Optional mid–side workflow allows widening/narrowing independent of pan.

Partial Panner

This script implements harmonic spray / partial panning, a sophisticated spectral stereo imaging technique that distributes different frequency bands across the stereo field. The process: (1) Frequency analysis: Split audio into logarithmically-spaced frequency bands, (2) Spatial mapping: Assign each band to stereo positions based on frequency, (3) Panning application: Apply constant-power panning to each band, (4) Recombination: Sum all panned bands into stereo output. Result: mono sounds transformed into rich stereo images with frequency-dependent spatial distribution.

Perceptual Fugue

This script implements a Perceptual Fugue, a spatial audio composition engine that generates a true polyphonic fugue from a single source sound. The source becomes the "subject" (theme), and the engine creates multiple voices through pitch transposition, each with a fixed spatial signature (ITD, ILD, spectral shadow, reverb). The voices enter in a classical fugue structure: exposition, episode, middle entries, stretto, and pedal/cadence.

Physics-Based Stereo Dynamics

This script implements physics-based stereo dynamics, an advanced audio processing system that simulates objects moving through physical space with realistic stereo positioning and distance-based loudness. Building on the kinematic physics foundation, this stereo edition adds three-dimensional spatialization: objects move left-to-right (panning), approach and recede (distance attenuation), while following realistic bounce physics. The result is immersive audio that creates the illusion of physical objects moving through the listener's environment, with amplitude, panning, and distance all governed by unified physical laws.

Random Duration Tier Multichannel Generator

This script implements stochastic multichannel temporal manipulation – a method for creating multiple duration-varied versions of audio through random-walk DurationTiers. Process: (1) Random-walk generation: Creates N independent DurationTiers (configurable 1–16+ channels) using Gaussian random walks, each with nInteriorPts control points between bounds [minFactor, maxFactor]. (2) PSOLA resynthesis: Each tier applied via Praat's Manipulation object (pitch-synchronous overlap-add), preserving pitch/formants while modifying duration. (3) Multichannel output: Combines all variants into single N-channel Sound object. Result: temporal uncertainty ensemble – same material with stochastic microrhythmic variation, useful for spatial/textural composition, uncertainty modeling, and perceptual studies.

Simple Rate Panning

This Praat script implements a continuous, high-quality stereo panning effect based on the user-specified rate. It uses an essential acoustic principle called the constant power panning law to ensure the sound's perceived loudness remains stable as it moves between the left and right speakers.

Spectral Panning Mapper

This script implements spectral-driven dynamic panning, an automated stereo spatialization technique that analyzes audio content and translates spectral characteristics into stereo movement. Process: (1) Divide timeline into analysis windows (default 8), (2) Extract spectral features per window: flatness (tonality vs noise) and roughness (spectral irregularity), (3) Map to panning parameters: flatness → panning depth (width), roughness → motion speed (rate), (4) Generate sinusoidal panning: left/right gains modulated by sine/cosine with content-derived phase, (5) Apply to stereo: creates intensity-based stereo field. Result: spatial imaging that responds to audio content, noisy sections pan wider, rough spectra move faster, creating organic, evolving stereo without manual automation.

Spectral 26

Spectral Mirroring

Mirrors the frequency spectrum around a user-defined cutoff point, effectively inverting the harmonic content to create alien or metallic timbres. It offers presets for mild to strong mirroring and uses an optimized overlap-add method to maintain audio quality.

Bell Curve Envelope

Applies a Gaussian (bell-shaped) amplitude envelope combined with spectral filtering to the sound. This effect allows for smooth shaping of the audio's dynamic contour, offering presets for narrow or wide curves to create swelling or fading textures with specific frequency emphasis.

Doppler Shift

Simulates the auditory illusion of a sound source moving relative to a listener. It applies an accelerating frequency shift and amplitude decay to recreate the characteristic "passing by" effect, with customizable parameters for speed, acceleration intensity, and distance simulation.

Dynamic Tremolo Effect

Introduces a rhythmic amplitude modulation (tremolo) that varies across the frequency spectrum. Unlike a standard tremolo, this effect allows for specific frequency ranges to be modulated while attenuating others, creating a pulsing, breathing, or fluttering motion within the sound.

Fast Chunked Spectral Blur

Smears the spectral content of the audio over time to create washed-out, atmospheric textures. By processing the audio in chunks with variable window sizes and blur radii, it can transform distinct sounds into ethereal pads, underwater drones, or robotic, metallic glitched effects.

Flip or Expand the F0 Contours

Manipulates the fundamental frequency (pitch) contour of the audio using PSOLA synthesis. It offers modes to invert the melody (flip), expand or contract the pitch range for dramatic exaggeration, or flatten the intonation entirely to create robotic or monotone speech effects.

Fractal Spectral Hologram

Generates complex, self-similar spectral textures by treating the sound's spectrogram as a holographic image. It applies iterative blurring, sharpening, and "fractal zooming" to the spectral data before resynthesizing it onto a noise carrier, resulting in crystalline echoes, temporal storms, and abstract soundscapes.

Frequency-Dependent Phase Manipulation

Alters the phase relationships of frequency components to create immersive stereo widening and timbral shifts. By applying different phase functions (such as periodic notches, chaotic textures, or spectral blurs) to the left and right channels, it generates complex spatial effects without altering the frequency magnitude.

Harmonic Resonance Boost

Boosts the amplitude of frequencies corresponding to a user-defined harmonic series (based on a fundamental frequency) while actively attenuating the spectral content between those harmonics. Optimized using matrix-based processing for speed, it is used to create resonant, highly synthetic-sounding timbres. It features an optional stereo mode that applies slightly different bandwidths to the left and right channels for an enhanced width effect.

Hilbert Transform

A dynamic effect that extracts the sound's amplitude envelope (using the Hilbert Transform) and then applies this envelope backwards in time to the original signal. This creates the illusion of a sound rapidly decaying and then growing back to its original volume, often used to simulate backward echoes, 'sucking' sounds, or dramatic reversal effects.

LPC Voice Generator

Performs Linear Predictive Coding (LPC) resynthesis. It extracts the spectral envelope (formants) from the original sound and uses this characteristic filter to shape a synthesized excitation source (typically a simple vocal pulse). The result is a natural-sounding, yet often robotic or detached, recreation of the original sound's voice quality and pitch contour.

LPC Voice Morphing

An expanded Linear Predictive Coding (LPC) Vocoder designed for complex voice and sound morphing. It extracts the spectral envelope from the analysis signal (modulator) and applies it to a separate user-selected carrier signal. Features include pitch-tracking, noise, or monotone pulse carriers, with parameters for formant shifting and forcing a specific monotone frequency for a classic robot sound.

Non-Linear Frequency Folding

Applies a mathematical folding function to the frequency spectrum, using combined sine and cosine waves to create dense, non-linear interference patterns (or "spectral knots"). This process folds high-frequency content back down into the lower spectrum, generating a complex, inharmonic, and distorted timbre often described as metallic, digital, or "alien radio."

Partial Editing & Resynthesis

An advanced sinusoidal resynthesis tool that analyzes the input sound, extracts its spectral partials, and reconstructs the audio from a matrix of sine-wave grains. It allows for in-synthesis manipulation of the partials, such as simple or random frequency shifting, or suppressing specific partials to create granular, diffused, or shifting textures.

Phase History Swap

Creates a spectral time-warp effect by splitting the sound into an 'early' and 'late' segment, then swapping spectral information between them. The most common application involves applying the phase information of the 'early' spectrum to the magnitude of the 'late' spectrum, which generates a distinct, hyper-spatialized stereo image and ghost-like textures.

Phase Shaper

A sound design tool that uses various extreme, algorithmically-generated Impulse Responses (IRs) to convolve with the input sound. Unlike standard reverb, the IRs are designed to impose radical spectral and temporal distortions (e.g., 'Fractal Zap', 'Reverse Black Hole', 'Spectral Freeze'), resulting in complex, phase-coherent soundscapes and textures.

Self-Similarity Spectral Resynthesis

The Self-Similarity Spectral Resynthesis script transforms audio by analyzing its internal temporal patterns. Instead of processing frequencies directly, it uses MFCC features to detect when audio segments sound similar to each other, then applies dynamic amplitude changes based on these similarity patterns.

Self-Adaptive Sieve Convolution

Number‑theoretic sieve convolution. Each grain of the source is routed through one of two impulse responses (IR_A or IR_B) based on modular arithmetic conditions, or passed through dry. IRs are harvested live from the source material and crossfaded on an adaptive schedule, so the convolution character evolves continuously with the source. Supports stereo/multi‑channel inputs (per‑channel convolution).

Spectral Effects Suite

A unified tool offering a suite of complex sound design effects. It combines frequency modulation (e.g., "Wobble"), amplitude modulation, and various dynamic temporal envelopes (like rhythmic pulsing or turbulent decay) to create textures ranging from "Underwater" to "Pulsing Reversal".

Spectral Freeze Synthesis

Performs sinusoidal resynthesis to capture a precise moment of the sound's spectrum and hold it. It uses matrix-optimized peak detection to efficiently reconstruct the sound from its spectral partials, creating a sustained, frozen, or decaying drone texture.

Spectral Painter

An advanced tool for spectral gain modulation, which selectively boosts or cuts frequency bands using complex mathematical functions (like sine, logarithmic, or random). It can generate unique textures such as "Metallic Ring," "High Shimmer," or "Random per-bin diffusion".

Spectral Swirl Effect

Creates a distinct, churning phase-shift effect by applying sinusoidal frequency bin shifting. This process warps the spectral content of the sound over time, resulting in a metallic, swirling, or psychedelic texture.

Stepped Notch Filter

Implements a series of stepped notch filters in the frequency domain, creating deep, sharp cuts at specific, user-defined frequencies. This is useful for removing precise frequency ranges or creating harsh, resonant band-pass filter effects.

Subtle Random Texture

Applies Random Spectral Variation by introducing small, controlled random gains to the frequency spectrum. The effect is designed to be subtle, resulting in a slightly diffused, granular, or fuzzy texture without harsh digital artifacts.

Vocoding

An expanded poly-carrier vocoder that modulates a carrier signal with the spectral envelope of a modulator sound. Key features include: Stereo Spreading (distributing odd/even bands to L/R channels), Formant Shifting, and multiple carrier source options (Noise, Sawtooth Drone, or Pitch-Tracking Pulse).

Wave Interference Pattern

Creates a fixed, complex spectral texture by multiplying the input spectrum with a mathematical function that combines a sine wave and a weighted cosine wave. This process generates deep, rhythmic peaks and troughs in the frequency domain, resulting in a distinct, oscillating, or "phaser-like" metallic wash that is static across the duration of the sound.

Time & Granular 45

Adaptive Grain Cloud Synthesis

Drives audio transformation through granular synthesis with spectral-adaptive grain timing, dynamically adjusting duration and pitch scatter based on real-time spectral centroid analysis. Each grain’s parameters are modulated by its spectral character—high frequencies trigger shorter, more scattered grains; low frequencies yield longer, stable grains—creating evolving, textural clouds that preserve organic dynamics. Ideal for spectral morphing, atmospheric pads, and generative soundscapes, with built-in safety limits to prevent system overload.

Beat Repeat

Drives rhythmic manipulation through beat-synced segmentation and iterative repetition, with programmable note values, beat selection modes, and amplitude decay curves. The algorithm extracts musical segments at precise BPM-aligned intervals, then generates cascading repeats with customizable fade profiles and dynamic range preservation. Supports triplet, dotted, and standard note values with intelligent boundary handling to prevent clipping. Ideal for glitch production, rhythmic stuttering, and tempo-synced sound design in electronic music and audio post-production.

Beat-Synced ZigZag

Drives musical time manipulation through tempo-synced segment alternation, intelligently reversing every other musical subdivision while maintaining rhythmic integrity. The algorithm syncs to either auto-detected or manual BPM, slicing audio into bars, beats, or sub-beats before applying the signature forward/reverse pattern. Supports complex time signatures and offers whole-selection or tail-only processing modes, creating polyrhythmic textures, glitch effects, and musical time distortions perfect for electronic production, DJ transitions, and experimental composition.

Bigram Stutter Effect

This script implements a probabilistic stutter effect using a bigram (Markov chain) model. It divides audio into fixed‑length windows, then makes sequential decisions: at each step, either repeat the current segment (stutter) or advance to the next segment. This creates natural‑sounding glitch patterns that are more organic than simple repetition or random skipping.

Brownian Motion Texture Generator

Drives granular synthesis with stochastic movement through time and stereo space using dual Brownian motion engines—temporal displacement for organic rhythm and spatial drift for evolving panning trajectories. Each grain's position undergoes random-walk processes, creating natural, unpredictable textures that drift between dense clouds, sparse fields, and shimmering atmospheres. Preset algorithms model physical diffusion behaviors, while independent control over time-step size, drift magnitude, and panning laws enables precise sculpting of evolving soundscapes for ambient music, spatial audio, and generative sound design.

BP Slicing Protocol

Divides a Sound object into N segments using a Bohlen‑Pierce‑inspired geometric ratio series: ratio[n] = 3^((n‑1)/N). This yields an asymmetric temporal grid where each segment is geometrically wider than its predecessor. The total duration is preserved exactly. Multiple‑block presets divide the sound into equal blocks, then apply the same independent BP grid to each block. The stereo output reorders slices by duration: left channel follows the chosen direction, right channel the opposite – creating a diverging stereo image.

Constraint-Based Duration Control

Drives audio manipulation through Optimality Theory (OT) constraint satisfaction, automatically segmenting audio into sounding/silent intervals and evaluating duration candidates against competing faithfulness and target-length constraints. The system generates multiple rhythmic interpretations, scores them via weighted violation metrics, and selects optimal solutions that balance original timing with programmed duration targets. Supports staccato, legato, strict, and natural presets for rhythmic quantization, tempo adjustment, and expressive timing control—ideal for musical phrase editing, rhythm correction, and prosody modification in speech and music production.

Delay Array

Drives audio transformation through iterative difference equations that create cascading delay networks with prime-like divisor relationships. The algorithm applies successive subtraction operations between samples spaced at programmable intervals (2, 4, 8, 10 or custom divisors), generating evolving spectral cancellations and rhythmic phasing effects. Each iteration introduces new temporal offsets, producing complex interference patterns reminiscent of comb filtering, rhythmic subtraction synthesis, and algorithmic delay matrices—ideal for metallic textures, rhythmic deconstruction, and spectral evolution in experimental sound design and electronic music.

Dramaturgical Structure Composer

This script implements a Dramaturgical Structure Composer, a tool that analyzes the structural properties of an audio recording and reshapes its form according to compositional archetypes. Unlike processors that apply continuous effects, this tool recomposes the material by detecting sections, classifying their textures, and applying structural operations (reordering, looping, silence insertion, stretching, and transformed recalls) to create new musical forms.

Evolving Granular

Drives dynamic granular synthesis with time-evolving parameter trajectories, generating complex textural transformations through density growth, pitch sweeps, or statistical region shifts. The algorithm pre-composes all grain parameters as Sound-object-based control signals, enabling precise temporal evolution of density, duration, pitch, and amplitude across three-stage transformations. Optimized for performance with direct sample-level mixing, it produces cloud textures that morph from sparse fields to dense clusters, micro-grain showers, or sweeping harmonic ascents—ideal for ambient soundscapes, evolving pads, and generative composition with smooth parameter interpolation.

Fractal Convolution Matrix

Drives audio transformation through recursive convolutional structures with self-similarity across multiple depth scales, applying weighted kernel convolutions that reference progressively time-shifted versions of the signal. The algorithm creates fractal-like reverberation tails by iteratively convolving the audio with scaled-down copies of itself, generating complex interference patterns and emergent harmonic structures reminiscent of algorithmic reverberation and granular feedback systems. With preset-controlled depth, width, and amplitude decay profiles, it produces evolving tails that range from subtle room extensions to extreme cascading textures—ideal for ambient sound design, drone music, and non-linear reverb effects.

Harmonic Resonance

Drives spectral enrichment through exponential harmonic progression, applying bidirectional difference equations that generate complex overtone structures via recursive time-shifting operations. The algorithm creates cascading harmonic series using geometric base factors (1.5–6.0), with each iteration adding new partials while applying amplitude decay to simulate natural resonance damping. Bidirectional subtraction between forward and backward-shifted samples produces interference patterns that evolve across multiple iterations, generating rich harmonic tails ranging from subtle shimmer to extreme metallic resonance—ideal for bell-like textures, harmonic enhancement, and synthetic resonance effects in sound design and musical processing.

Harmonic Tension Sorted Grains

This script implements a Harmonic Tension Sorted Grains engine, a granular synthesis tool that extracts grains from audio, analyzes their spectral peaks to derive Pitch Class sets, computes an Interval-Class Dissonance Score based on set theory, then reassembles the grains sorted from Chaos → Clarity (descending dissonance) or Clarity → Chaos (ascending dissonance).

HFD-Driven Time Warping

Adaptive time‑stretching based on signal complexity: uses Higuchi Fractal Dimension (HFD) to measure local signal irregularity, then warps time proportionally to create dynamic, content‑aware temporal transformations.

In-Place Paulstretch Slicer (Multi-Channel)

Drives multi-channel sound design through parallel time-stretching and spatial distribution, extracting random segments from a source audio file and applying real-time phase-randomized PaulStretch processing to each. The algorithm generates multiple independent stretched textures—each occupying its own output channel—while preserving original timing relationships through in-place placement around their extraction centers. Supports optional original channel mixing, vectorized overlap-add synthesis, and instantaneous multi-channel rendering for creating evolving ambient soundscapes, spatialized drone textures, and immersive multi-speaker installations with phase-coherent stretching artifacts.

L-Logic System, Symbolic Granular Recomposition

This script implements the L-Logic System, an analytical and compositional framework based on Rakhat-Bi Abdyssagin's "Logic of Sound and Silence" (2024). It classifies audio into six perceptual categories (Lsets), generates symbolic representations of the sound's structure, and enables recomposition by assembling sequences of classified segments according to user-defined propositions.

Magnetic Tape Degradation

Drives analog tape emulation through multi-generation hysteresis modeling, print-through simulation, bias modulation, and progressive high-frequency loss. The algorithm simulates physical tape degradation by applying successive processing generations that mimic magnetic saturation, inter-layer bleed, bias instability, and cumulative HF attenuation. Parameters control hysteresis memory effects, print-through decay rates, bias randomization, and generational loss characteristics—producing authentic tape artifacts ranging from subtle warmth to extreme degradation, ideal for lo-fi aesthetics, vintage emulation, and analog texture design.

MDS Space Navigator

Drives audio reordering through multidimensional scaling and feature-based similarity analysis, automatically segmenting audio into "word" units via silence detection and analyzing them via formant frequencies, pitch contours, or MFCC timbre vectors. The algorithm constructs a distance matrix using Euclidean metrics, performs MDS dimensionality reduction to project segments into a 2D similarity space, then reorders them via nearest-neighbor chaining or MDS-axis sorting. This creates semantically coherent audio collages where acoustically similar segments are juxtaposed, ideal for sound poetry, audio mosaics, and feature-driven composition with perceptual organization.

Multi-Channel Random Slice Time-Stretcher

Drives spatial audio construction through parallel time-stretching of random source segments distributed across independent output channels. The algorithm extracts variable-duration slices from source audio, applies uniform PSOLA-based time-stretching (with preset speed ratios), then positions each stretched segment in its dedicated channel centered on its original temporal location. Creates multi-channel soundscapes where time-dilated events occupy separate spatial positions while maintaining their original timing relationships—ideal for immersive installations, spatial composition, and algorithmic audio arrangements with channel-specific time manipulations.

Particle Field Renderer Audio

Drives granular synthesis with particle physics-inspired parameter mappings, where each grain acts as an audio particle with position-derived panning, velocity-mapped pitch variation, and acceleration-modeled amplitude envelopes. The system simulates particle fields with linear, exponential, or random time distributions, applying Hann/Gaussian/Rectangular windowing functions and optional LFO modulation for dynamic movement. Creates spatially distributed sound clouds where temporal and spectral properties emerge from simulated particle interactions—ideal for generative sound design, spatial audio installations, and physics-based synthesis of evolving textures.

Particle Field Renderer

Drives granular synthesis through particle physics simulation, where each audio grain functions as an independent particle with position-derived timing, pitch-mapped frequency, and intensity-based amplitude. The system analyzes source audio to extract pitch and intensity contours, then generates synthetic particles whose spatial panning is determined by pitch-derived angular positions or randomized distributions. Creates evolving particle fields with Hann, Gaussian, or rectangular envelopes and optional LFO modulation—ideal for spectral reconstruction, abstract sound synthesis, and physics-based audio rendering of analytical data into immersive sonic spaces.

Paulstretch

Drives extreme time-stretching via phase-randomized spectral processing, applying Hanning-windowed FFT frames with randomized phase components while preserving magnitude spectra. The algorithm decouples time and frequency domains by stretching input hop sizes while maintaining output overlap, creating granular texture clouds with minimal pitch alteration. Implemented with fast matrix operations for phase randomization and efficient overlap-add synthesis, producing characteristic ambient drones, frozen soundscapes, and seamless temporal expansion—ideal for sound design, ambient music, and experimental time manipulation with preserved spectral content.

Paulstretch STEREO

Paulstretch Original Method (Guaranteed Smooth) Apply preset settings Check if a Sound is selected. It is useful in time-domain manipulation, experimental sound design, or the generation of ambient and granular textures, depending on the specific parameter settings used.

Percussive Audio Groove Creator

an intelligent approach to rhythm generation that analyzes audio files to detect percussive events (bass drums, hi-hats, snares) and reassembles them into musically coherent drum patterns. The process: (1) Audio Analysis: Detects sharp amplitude onsets and classifies them by spectral content. (2) Event Classification: Groups detected sounds into three categories: bass drums (low-frequency dominant), hi-hats (high-frequency dominant), and snares (mid-frequency dominant). (3) Pattern Generation: Arranges classified sounds according to selected beat patterns (standard 4/4, funk, breakbeat, etc.) with adjustable density and timing variations. (4) Dynamic Processing: Applies envelope shaping, velocity variation, and optional stereo imaging.

Phase Modulation Matrix

Drives multi-layer phase modulation synthesis through cascaded sinusoidal phase-shifting operations with dynamic feedback and spectral tilt compensation. The algorithm applies successive modulation layers with incrementally increasing depth and carrier frequency ratios, creating complex harmonic spectra through recursive phase distortion. Each layer introduces controlled aliasing artifacts while feedback parameters maintain signal integrity, generating evolving textures ranging from subtle chorus to deep vibrato and metallic resonances—ideal for FM-like synthesis, harmonic enrichment, and dynamic spectral transformation via phase manipulation rather than amplitude modulation.

Peephole montage

This script implements interactive audio montage creation, a unique workflow that combines manual selection with automated processing to create jump-cut collages from any audio file. The process: (1) Interactive Marking: Opens a PointProcess editor for you to manually mark moments of interest (peepholes) in the audio. (2) Window Extraction: Automatically extracts symmetric or asymmetric windows around each marked point. (3) Artistic Processing: Applies one of four creative styles to transform the raw extracts. (4) Seamless Assembly: Concatenates processed windows with crossfading to create a continuous montage. (5) Statistical Analysis: Reports compression ratio and timing information about the created montage.

Polyphonic Improviser

This script implements a Polyphonic Improviser, a chunk-shuffle canon engine that generates multi-voice polyphonic textures entirely from a single source sound. No synthesis or PSOLA is used; all material is derived by dividing the source into chunks, shuffling them independently per voice, applying speed/pitch transformations, and staggering entries in canon style.

Reich Generator

This script implements harmonic phase music synthesis, taking an audio source, extracting a loop, creating multiple processed voices with controlled phase relationships, harmonic transformations, and analog-style imperfections. The result is evolving minimalist textures where identical material drifts in and out of phase, creating constantly shifting perceptual relationships.

Rhythmatist

Rhythmic Strata System with Spectral Identity. Splits audio into segments defined by a mathematical rhythmic series (Uniform, Regular Compound, Irregular Cumulative, Irregular Individual, or Combined), then reassembles the segments in shuffled order to produce new rhythmic structures from source material. Optional BPM snapping, pitch transposition (tape‑speed), and equal‑power stereo panning.

Rhythmic Fractal Granulator

The Rhythmic Fractal Granulator combines two powerful audio processing techniques: granular synthesis (using tiny audio grains) and fractal mathematics (creating self-similar patterns). The result is complex, evolving textures with inherent rhythmic structure that feels both organic and mathematical.

Segment Mixer

Drives multi-file stereo construction through parallel segment extraction and cross-channel temporal offset strategies, building composite textures from multiple source files processed across repeat cycles. The algorithm extracts different temporal segments for left and right channels (using end-of-file, fixed-offset, or random strategies), applies amplitude attenuation and fade curves, then concatenates them into evolving stereo fields. Creates intricate textural mosaics where source materials are spatially distributed and temporally layered—ideal for sound collage, multi-sample composition, and generative stereo field construction from diverse audio sources.

Stereo Micro Macro Time Collapser

This script implements a Stereo Micro ↔ Macro Time Collapser, an electroacoustic composition tool that performs temporal inversion: very short events (micro-bursts) are stretched into sustained textures, while long, slow passages are compressed into brief transient gestures. The result is a radical transformation of temporal perception, creating new relationships between time scales.

Sorts Grains From Dark To Bright

Drives spectral-organized granular synthesis by analyzing and sorting audio grains based on spectral centroid brightness, then concatenating them along a darkness-to-brightness (or brightness-to-darkness) continuum. The algorithm extracts variable-duration grains, measures their spectral centroids, applies adaptive pitch shifting and amplitude scaling to exaggerate spectral differences, and implements strategic gap insertion between grains to enhance perceptual transitions. Creates evolving textures that morph through the timbral spectrum, ideal for spectral narratives, timbral storytelling, and organized granular synthesis with perceptual coherence.

Sound To Grain (Stereo With Independent Reversal)

Drives stereo granular synthesis with independent channel processing, extracting synchronized grain pairs from source audio while applying separate reversal probabilities to left and right channels. The algorithm creates spatially independent texture streams where identical source segments may play forward in one channel while reversed in the other, generating complex stereo phasing and spatial diffusion effects. Supports Hanning, Rectangular, or Triangular windowing for envelope shaping—ideal for immersive stereo field construction, psychoacoustic experiments, and spatial granular synthesis with independent channel treatments.

Sound To Grain

Drives granular deconstruction by extracting random windowed segments from source audio and concatenating them into new temporal sequences. The algorithm samples variable-position grains of consistent duration using Hanning, Rectangular, or Triangular windowing to control envelope shapes, creating stochastic rearrangements of source material. Produces granular textures that preserve spectral identity while disrupting temporal continuity—ideal for glitch art, microsound composition, and source-based granular synthesis with controlled windowing artifacts.

Spectral Echo Cascade

This script creates cascading echo effects using Fibonacci sequence for delay timing (1, 1, 2, 3, 5, 8, 13...), exponential amplitude decay per level, and cosine-modulated spectral coloring that varies across the sample. Result: organic-sounding delays with mathematical structure and frequency-dependent intensity variations.

Spectral Freeze & Glitch

This script creates time-freeze glitch effects, selecting random moments in audio and creating stuttering loops by repeating tiny segments, then adding spectral artifacts through sinusoidal amplitude modulation. The result: time seems to freeze at multiple points, creating digital stuttering, broken-media aesthetics, and glitch textures reminiscent of CD skipping, corrupted digital audio, or malfunctioning playback devices. Unlike simple cut-and-repeat or delay effects, this combines temporal stuttering with spectral distortion for rich, complex glitch artifacts. Perfect for: electronic music production, glitch aesthetics, experimental sound design, broken-media simulation, and rhythmic disruption effects.

Stereo Delay Splitter

Drives independent channel processing through separate difference equation networks applied to left and right audio streams, creating spatialized spectral filtering effects with channel-specific delay divisors. The algorithm splits stereo input, processes each channel through distinct iteration ranges with programmable divisor values (e.g., left: 2,4; right: 8,10), then recombines them to produce enhanced stereo width and spectral separation. Generates complex spatial filtering where each channel develops unique comb-filter characteristics—ideal for stereo enhancement, spatial effect processing, and channel-differentiated spectral manipulation.

Stereo Mosaic

Drives multi-file stereo composition through systematic region partitioning and channel allocation strategies, dividing each source file into multiple equal-duration segments and distributing them between left and right channels according to programmable patterns (alternating, half-split, random, reverse, inside-out, or spiral). The algorithm creates intricate stereo mosaics where temporal segments from multiple sources are interleaved across channels, producing complex spatial narratives and evolving textural fields. Ideal for multi-sample spatial composition, algorithmic stereo collage, and source-based spatial mosaics with controlled segmentation logic.

Stochastic Time Folding

This script implements stochastic time folding, a destructive audio mangling technique that "folds" time by averaging each sample with temporally distant samples selected at random offsets. Process operates iteratively (default 6 passes): for each iteration, (1) Generate probability mask (random 0-1 per sample), (2) If mask < threshold: fold sample = average with forward-offset sample + backward-offset sample (temporal averaging), (3) Else: apply random amplitude variation (0.7-1.2×), (4) Adapt threshold (drifts each iteration). Result: glitchy stutters, temporal smearing, buffer-like artifacts, rhythmic disruption, sample-level chaos. "Folding" = bringing distant time points together (like folding paper). Stochastic = probabilistic, not deterministic. Each run creates different result due to randomness.

Sound atom composer

This script implements an analysis–dictionary–resynthesis workflow: it scans a folder of sounds, extracts small pitched micro‑events ("atoms") using pitch (f0) and intensity (energy), stores them in a dictionary, then recombines them into new textures via additive (sine) resynthesis. Instead of replaying source grains, it recomposes a spectral sketch of the corpus using learned pitch/energy behaviors.

Temporal Turing Morph

This script implements a Temporal Turing Morph, a creative reordering engine that applies a 1D reaction-diffusion (Turing) process to a sequence of audio segments. The emergent stripe pattern from the Turing instability becomes the reordering logic, creating novel temporal structures based on mathematical pattern formation.

Time Manipulation

Drives comprehensive temporal transformation through PSOLA-based time-stretching, spectral blur via cascaded lowpass filtering, and stereo width enhancement via channel-specific delays and spectral detuning. The algorithm combines phase vocoder stretching with configurable blur intensities and spatial processing, creating effects ranging from subtle slowdown to extreme drone textures with enhanced stereo imaging. Integrates multiple time-domain and spectral processing stages into a unified workflow—ideal for ambient sound design, tempo manipulation, spatial audio processing, and immersive texture creation with synchronized time-spectral-spatial transformations.

Total Serialism Machine

This script implements total serialist audio processing, deconstructing a source sound into a series of events whose parameters (timing, duration, pitch, amplitude, panning) are controlled by mathematical series and transformations. Inspired by the post-Webern serialist composers (Boulez, Stockhausen, Babbitt), this machine applies rigorous organizational principles to create complex, pointillistic textures from any audio source. Events are extracted, transformed, and reordered according to serial procedures, resulting in precisely controlled yet perceptually rich sonic structures.

ZigZag Effect

This script implements a ZigZag Time Effect, a complex time-domain manipulation that alternates between forward and backward playback of audio segments. The effect creates stuttering, glitching, and tape-wobble textures by dislocating temporal continuity while maintaining rhythmic structure. Four presets provide instant access to different character effects, with full customization available.

Hybrid Systems 42

AI Conductor Mix

PyTorch‑driven ensemble conductor. Select 2+ Sound objects – the AI assigns dynamic roles (leader, shadow, resonance, noise fringe, pulse carrier, interruption, sustain bed, contrast voice, memory trace, silence) and states (sparse, balanced, agitated, saturated, suspended, released) to segments of each file. A mix plan is generated and rendered in Praat with stereo panning.

Corpus Mosaic

Corpus Mosaic is an offline concatenative synthesizer. It takes a target sound and a folder of corpus sounds, slices both into grains of equal duration (with overlap), extracts a 6‑dimensional feature vector for each grain, and then rebuilds the target by selecting the best‑matching corpus grain for every target grain. The selection process can be influenced by repetition penalties (to avoid reusing the same grain too often), continuity bonuses (to favour consecutive grains from the same source file), and a randomness factor.

Blind Dereverberation

This script implements blind dereverberation using the Weighted Prediction Error (WPE) algorithm. It removes room reverberation from an audio recording without requiring knowledge of the room acoustics or the original dry signal. The result is a "dryer" version of the input, with reduced reverb tails and improved clarity.

Envelope Editor

Interactive multi‑lane breakpoint editor for applying time‑varying pan, pitch, intensity, and formant envelopes to a selected sound.

Formant Swarm Granulator

Formant Swarm Granulator treats each short grain (30–250 ms) as a particle carrying a resonance fingerprint (F1, F2, F3, bandwidths, pitch, intensity). A Python engine projects these particles into a 2‑D similarity field and walks a path through the swarm, selecting grains according to attraction (formant similarity) and two types of repulsion (temporal – avoid grains from the same source region; density – avoid overusing any grain).

Granular Navigation Engine

Granular Navigation Engine treats a folder of sound files as a corpus of grains. All processing – scanning, grain slicing, feature extraction, autoencoder training, and path generation – is handled by a Python script. Praat’s role is limited to folder selection, reading the resulting path CSV, and reconstructing the audio by concatenating grains with crossfade. This clean separation keeps Praat fast and gives Python full control over the neural architecture.

Hierarchical Neural Recomposition

Hierarchical Neural Recomposition learns the latent structure of a sound at three timescales: events (grains), phrases (groups of events), and sections (groups of phrases). A PyTorch model encodes each level and produces a recomposition plan – a 16‑dimensional control vector per phrase that determines repetition, fragmentation, overlap, memory, contrast, inversion, braiding, and more. The engine then renders a new audio stream from the original source material, following the plan.

HPSS Phase Vocoder

HPSS Phase Vocoder performs time‑stretching that preserves the clarity of transients. Traditional phase vocoders smear attacks, producing metallic artefacts when stretching percussive material. This engine first separates the signal into harmonic (sustained tones) and percussive (transients) components using median‑filtering HPSS. The harmonic part is stretched with a high‑quality phase vocoder (instantaneous frequency accumulation), while the percussive part is resampled directly, preserving attack sharpness. The two are recombined into a clean, artefact‑free stretched result.

Identity Separation

This script implements an Acoustic Identity Separation engine, an AI-powered tool that discovers latent acoustic identities within a recording via machine learning clustering, then reorganizes the material by identity. The result is a new composition where different "personalities" within the source sound are separated and rearranged.

Internal Polyphony

Reveals hidden simultaneous voices inside a sound using NMF-based functional decomposition. Support, body, accent, halo, residue, shimmer – each with its own voice engine and compositional staging. Not a denoiser, not a latent gimmick: genuine chamber music already latent in the source.

IRCAM Multichannel to Binaural

Multichannel‑to‑binaural downmix via Spat5 virtual speakers. Takes any multichannel Sound (mono to 24‑channel 22.2) and renders a stereo binaural output using HRTF convolution. Single‑stage pipeline: input channels are treated as speaker feeds at known positions, and spat5.virtualspeakers~ convolves each with the corresponding HRIR pair.

IRCAM Pan to Binaural

Mono/stereo → HOA encode → HOA decode → binaural (3‑stage pipeline). Uses Spat5 command‑line tools via a Python bridge. Supports static positioning and 10 animated trajectories (Linear, Circular, Figure‑8, Spiral, Pendulum, Zigzag, Random Walk, Ellipse, Square).

IRCAM Partial Stretch

SPEAR‑style partial manipulation for electroacoustic composition. Analyses a selected sound with PM2 (partial tracking engine), then applies frequency‑dependent time operations to individual partial tracks and resynthesises via additive synthesis. Five modes: Spectral Stretch, Band Stretch, Freeze, Partial Thin, Spectral Blur.

IRCAM SuperVP Transform

Spectral voice transformation bridge from Praat to the SuperVP engine (AudioSculpt / Ircam). Supports 11 transform modes: Age, Gender, Flatten pitch, Time stretch, Tremolo, Cross synthesis, Vibrato, Breathiness, Formant shift, Harmoniser, De‑noise, and Age+Gender chain. Exports F0 + Intensity BPFs, builds SuperVP parameter files, calls the command‑line engine, and imports the result.

Latent Barycentric Mutation

This script implements a Latent Barycentric Mutation engine, a system that trains a VAE on-the-fly from event-level audio patches, then navigates the latent space according to a navigation plan. At each step, K nearest-neighbor events are found and their waveforms are mixed with barycentric (inverse-distance) weights, creating seamless morphs between acoustic identities.

Latent Counterpoint

This script implements The Latent Counterpoint, an AI-powered multi-agent system that learns a latent space from event-level audio patches using an on-the-fly autoencoder, then deploys multiple agents that navigate this space simultaneously with counterpoint forces (attraction, repulsion, inertia, jitter) to produce polyphonic recombination of the input material.

Latent Diffusion, Morph-Chain Generator

This script implements a Latent Diffusion Resynthesis engine, a morph-chain generator that encodes audio events into a low-dimensional latent space via an on-the-fly autoencoder, discovers K acoustic identity clusters (k-means++), then runs a temperature-annealed diffusion loop that transforms a maximally-corrupted (noisy) seed vector back toward its cluster identity. The output is a Morph-Chain: one continuous audio sequence per cluster, evolving from static / noise-like texture into a recognisable instrument identity.

Latent Folding

This script implements Latent Folding, a topological manifold navigation engine that treats the learned latent audio space as a deformable manifold. Three topologies are available: Mirror (reflection at boundaries), Möbius (twist/inversion), and Torus (seamless wrap). As the observer traverses the space, boundaries fold or invert acoustic identity, creating what might be called "Recursive Spectralism."

Latent-Event Relocation

This script implements an Online Latent-Event Relocation engine, a deep thermodynamic recomposition tool that trains a lightweight autoencoder on-the-fly from the input audio, learns a latent space, then relocates events based on latent thermodynamic fields (temperature, affinity, regimes). All machine learning is pure numpy, no external models, no internet, no PyTorch/TensorFlow.

Latent Space Navigation

This script implements a Latent Space Navigation engine, an AI-powered tool that learns a latent space from event-level audio patches using an on-the-fly autoencoder, then navigates that space to generate a new timeline by selecting or morphing events along a deterministic latent trajectory. The result sounds like traveling through hidden acoustic identities.

Latent Spat

This script implements Latent Spat, an agent-based spatialization engine that extends the Latent Counterpoint concept into physical space. Multiple agents navigate a latent space learned from audio events; their latent positions are mapped to spatial coordinates (azimuth and distance) and rendered into multi-channel audio using VBAP (Vector Base Amplitude Panning).

Latent STFT Decoder

This script implements a Latent STFT Decoder, a system that trains a convolutional Beta-VAE on log-magnitude STFT patches extracted from event-segmented audio, then navigates the latent space to synthesise new audio via decoded STFT patches. Waveform reconstruction is achieved via phase borrowing from nearest real events or iterative Griffin-Lim phase reconstruction.

Multichannel Playback Bridge

This script implements a Multichannel Audio Playback Bridge, a solution for playing back multichannel audio (2, 4, 8, 16+ channels) from Praat, which natively cannot reliably play more than two channels. The script exports the selected Sound to a temporary WAV file and delegates playback to Python using the sounddevice library, which supports ASIO, WASAPI, and CoreAudio for low-latency multichannel output.

Phrase Rewriter

Compositional Archetype Engine for acoustic phrase transformation. Segments a sound, extracts phrase features, and rewrites it according to one of eight structural logics: Constellation, Cloud, Resonance, Center, Becoming, Distance, Mass, Multiplication.

Phase-Space Composer

This script implements a Phase-Space Composer, an attractor-driven event montage engine that segments audio into acoustic events, extracts perceptual feature vectors, and drives event recomposition via a deterministic dynamical system (attractor) in the feature space. Four attractors are available: Hopf (limit cycle), Lorenz, Rössler, and Logistic Map.

Praat Pbind

This script implements PraatPbind, a declarative pattern engine that integrates a SuperCollider-style event pattern system into Praat's analysis–resynthesis workflow. Users define event-based control structures using compact one-line Pbind expressions, which are interpreted by a Python engine and compiled into time-aligned PitchTier and IntensityTier control curves. These curves are then applied to the source sound via Manipulation-based resynthesis.

Phase Diffusion Engine

This script implements an AI‑driven phase diffusion engine based on a Paulstretch‑style time‑domain processor, but with a crucial addition: a NumpyAutoencoder trained on the input signal itself. The autoencoder learns a compressed latent representation of log‑mel spectral patches. Its reconstruction error becomes a per‑frequency coherence weight: low error → structured, tonal regions → receive more diffusion / smearing; high error → noisy, transient regions → are protected.

Recomposer

This script implements a CNN Event Recomposer, a morphological composition engine that automatically segments a selected Sound into events, extracts feature trajectories, and sends them to a self-supervised CNN engine in Python. The CNN learns a latent morphology space of events, clusters them, computes dramaturgical scores, and returns a montage plan. Praat then reassembles the original audio by cutting and concatenating events in the new order (no pitch manipulation or spectral processing).

Rhythmic Voice Flattener

Rhythmic Voice Flattener takes a spoken or vocal recording and strips away its melodic contour, flattening every voiced segment to a single target pitch (40th percentile of the original F0). All musical interest is then constructed from rhythm, timing, silence, density, grouping, accent, and gesture structure. The result is a new composition built entirely from the source material, shaped by a formal design (arc, arrangement, rhythm mode) and a constraint‑satisfaction engine that assigns operations to each event.

Self-Attention Latent Navigation

This script implements a Self-Attention Latent Navigation engine, a system that segments audio into events, trains a lightweight VAE, builds a self-attention matrix, generates a navigation plan with four phases (drift, mutate, return, settle), and executes it to produce a new timeline. The mixing weights combine geometric distance and attention similarity.

Self-Reflective Feedback

This script implements a Self-Reflective Feedback loop, an iterative system where Praat runs a chosen transformation, exports a preview, Python analyzes it and returns updated parameters, and the process repeats until metrics stabilise or max_iter is reached. The system adapts its own parameters based on acoustic analysis of each iteration's output.

Semantic Timbre Retrieval

Free‑text timbre search over a corpus of audio files. Type a prompt like “dark airy swelling scrape” – the engine analyses the corpus, extracts 8 semantic dimensions (brightness, noisiness, tonalness, stability, impulsiveness, sustain, roughness, spatiality), applies rule‑based tagging, and retrieves the best‑matching files or segments using hybrid scoring (semantic + tag + keyword). Returns a ranked list and an optional preview montage.

Spatial Panner

Spatial Panner lets you draw a moving sound source trajectory on a 2D circular stage. The source position at each moment is converted to gains for an arbitrary number of loudspeakers using Distance‑Based Amplitude Panning (DBAP). The result is a multi‑channel audio file (e.g., 8‑channel WAV) that you can play back on a multichannel system or further process in Praat.

Spectral Eraser

Interactive time‑frequency eraser. Opens a Python/tkinter GUI showing the spectrogram of the selected sound. The user draws on it to silence specific frequency‑time regions. Uses STFT → mask → iSTFT round‑trip. Perfect for removing unwanted noise, clicks, or isolating specific spectral elements.

Spectral Morph

CDP‑style spectral morphing powered by a Python STFT engine. Interpolates between two sounds in the spectral domain using three distinct morph modes: log‑magnitude (preserve A phase), full complex (blend phase), and formant/envelope (cepstral envelope morph).

Spectral Noise Shaping

Analyses a folder of audio files, learns their spectral profile and temporal envelope, then generates new stereo audio by shaping white noise to match. No neural networks, no training – finishes in seconds. Perfect for creating synthetic textures, ambient drones, or randomised soundscapes from a corpus.

SM Morph Composer

SSM Morph Composer extracts the structural blueprint of a sound and lets you reshape it. The sound is segmented into short events. For each event we compute a 5‑dimensional feature vector (spectral centroid, flatness, entropy, flux, RMS). The pairwise similarity between events forms a Self‑Similarity Matrix (SSM) – a map of repetitions and contrasts. The engine then applies one of five geometric transformations to the SSM, and finally a path walker moves through the transformed similarity space, generating a new sequence of events that is reassembled into audio.

Sympathetic Resonance

Virtual string physical model. Discovers the latent pitch collection embedded in a source sound, builds a bank of virtual resonant strings tuned to that discovered scale, and excites them with the source. The result is the sympathetic resonance aura: a glowing image of the sound as if it had excited a giant metallic, glassy, wooden, or airy resonant body.

Temporal Elasticity

This script implements a Temporal Elasticity engine, a latent time warping system that segments audio into events, extracts acoustic features, learns a latent space, builds a temporal field, and warps event durations based on their position in that space. Reconstruction is performed via PSOLA, resampling, or simple placement.

Thermodynamic Transform

This script implements a Thermodynamic Transform, an AI-powered audio transformation engine that analyzes acoustic structure, discovers thermodynamic phase regimes via machine learning, and applies regime-dependent transformations to individual audio events. The result is a sound that has been "thermodynamically processed" based on its own intrinsic structure.

TinySOL Orchestration Retrieval

Orchestration retrieval engine for the TinySOL corpus (Filip, 2020). Select a target sound – the backend analyses its timbre, pitch, and harmonics, then finds the closest orchestral samples by weighted multi‑descriptor distance. Supports whole‑file and frame‑based analysis, family/instrument/MIDI constraints, and multi‑layer blending for richer textures.

VST3 Effect

Bridge Praat to any VST3 audio effect using Python + pedalboard. Select a sound, pick a plugin, set parameters, run, the processed result appears as a new Sound object.

Praat for Max and M4L

A hybrid workflow that connects Praat AudioTools to Max/MSP and Ableton Live via Max for Live. Move audio from Max or Ableton into Praat for processing, run Praat scripts behind the scenes, and return the processed result back to the host environment.

↑ Back to top