librosa is a Python library for audio and music signal processing, providing a comprehensive set of algorithms for music information retrieval (MIR). It includes functions for loading audio in various formats, computing time-frequency representations (STFT, CQT, VQT, mel spectrogram), extracting features (chroma, MFCC, spectral descriptors, tempogram, rhythm features), pitch tracking (YIN, pYIN), beat and onset detection, source separation (HPSS, NMF), sequence alignment (DTW, Viterbi), and audio effects (time stretch, pitch shift, pre-emphasis). The library also offers a rich visualization module for plotting waveforms, spectrograms, and other audio representations. The architecture is modular, organized into subpackages: `librosa.core` for core DSP and I/O, `librosa.feature` for feature extraction, `librosa.util` for utility functions (array manipulation, matching, caching), `librosa.filters` for filter bank construction, `librosa.display` for visualization, and domain-specific modules like `librosa.beat`, `librosa.onset`, `librosa.decompose`, `librosa.effects`, `librosa.segment`, and `librosa.sequence`. Submodules are lazily loaded to reduce import time. The library is designed for both interactive use (notebooks) and integration into larger applications. Key entry points include `librosa.load` for audio I/O, `librosa.stft`/`librosa.cqt` for time-frequency transforms, `librosa.feature.*` for feature extraction, `librosa.beat.beat_track` for beat tracking, `librosa.onset.onset_detect` for onset detection, `librosa.display.specshow`/`librosa.display.waveshow` for visualization, and `librosa.effects.*` for audio effects. Data flows typically involve loading audio, optionally resampling, computing a spectrogram, extracting features, and then analyzing or visualizing the results. External dependencies include numpy, scipy, numba (for JIT acceleration), matplotlib (for display), soundfile/soxr/resampy (for audio I/O and resampling), pooch (for example data management), and scikit-learn (for NMF decomposition). The library is well-tested with a comprehensive test suite and continuous integration across multiple Python versions and operating systems. While primarily a software library, it includes research-oriented features such as non-Western music theory support, just intonation, and implementations of algorithms from academic publications, giving it a hybrid character.
JUCE is a mature, cross-platform C++ application framework specializing in audio software development. It provides a comprehensive set of modules covering core utilities, GUI, graphics, audio processing, MIDI, DSP, and plugin formats (VST3, AU, AAX, LV2, ARA). The architecture is a modular monolith: each module (e.g., juce_core, juce_audio_basics, juce_gui_basics) is a self-contained library that can be selectively included. Key entry points include JUCEApplication for desktop apps, AudioProcessor for audio plugins, and Component for GUI widgets. Data flows center on audio buffers (AudioSampleBuffer), MIDI messages, and event-driven GUI updates via message queues. External dependencies are minimal at the API level, but the framework bundles many third-party libraries (Opus, FLAC, Vorbis, WebP, HarfBuzz, Box2D, etc.) for codec and graphics support. The repository also includes the Projucer IDE for project generation and build tooling (CMake helpers, resource file management).
The KFR library is a high-performance C++ framework for digital signal processing (DSP) and audio applications. It provides optimized implementations of FFT/DFT, filter design (FIR/IIR), sample rate conversion, audio file I/O (supporting WAV, FLAC, MP3, AIFF, CAF, etc.), SIMD-accelerated mathematical operations, and tensor/multi-dimensional array operations. The library is designed for real-time processing and scientific computing, with architecture-specific optimizations for x86 SIMD, ARM NEON, and RISC-V RVV, and runtime dispatch for multiarchitecture support. Key architectural features include a header-only design (with optional separate compilation), expression templates for lazy evaluation and operator fusion, a portable SIMD abstraction layer, and a tensor system with NumPy interoperability. The library is used in production by scientific collaborations such as LIGO, Virgo, and KAGRA for gravitational-wave signal processing, benchmarked against FFTW. It employs a dual licensing model (GPLv2+/commercial) and requires C++20 for compilation. The codebase demonstrates strong engineering practices through reusable components such as the SIMD vector abstraction (vec<T, N>), expression template system, tensor class, and audio data handling unit. These components are self-contained, exhibit non-obvious skill in C++ template metaprogramming, and can be extracted for use in other projects with minimal modification. The library is actively maintained, with recent commits and CI/CD pipelines, and shows low technical drift by keeping pace with modern C++ standards and hardware advancements.
KISS FFT is a mixed-radix Fast Fourier Transform library implemented in C and C++. It provides a compact, portable, and reasonably efficient FFT implementation supporting complex and real-valued transforms in one or multiple dimensions. The library is designed to be simple to integrate, offering both a C API (kiss_fft, kiss_fftr, kiss_fftnd, kiss_fftndr) and a header-only C++ template class. It supports multiple scalar types (float, double, int16_t, int32_t) and SIMD acceleration via SSE, LSX, and LASX instruction sets. The core algorithm uses decimation-in-time with optimized butterflies for radices 2, 3, 4, and 5, and provides a cache mechanism (kfc) to reuse FFT configurations. The codebase is self-contained with no external dependencies beyond libm; optional tools require fftw3 and libpng for benchmarking and image generation. It is widely used in embedded systems, audio processing, and scientific computing due to its permissive BSD license and straightforward API.
Gamma is a cross-platform C++ library for real-time audio signal processing, synthesis, and analysis. It provides a modular collection of DSP building blocks including oscillators, envelopes, filters, effects, spectral analysis (FFT/STFT), spatial audio processing, voice management, and audio I/O via PortAudio. The architecture employs template-based design for type flexibility, strategy patterns for algorithm interchangeability, and a node-based system for constructing processing chains. Key entry points are specialized headers like Gamma/Oscillator.h, Gamma/Filter.h, and Gamma/Envelope.h, with Gamma/Gamma.h serving as a convenience aggregator. Data flows through interconnected processing nodes where audio signals move from sources (oscillators, audio input) through modifiers (filters, effects) to outputs (audio output, sound files), with modulation via envelopes and LFOs. External dependencies include PortAudio for audio I/O and optionally libsndfile for sound file handling.
CamillaDSP is a real-time audio stream processing engine written in Rust. It captures audio from a configurable backend (ALSA, PulseAudio, PipeWire, CoreAudio, WASAPI, ASIO, or file), processes it through a user-defined pipeline of filters, mixers, compressors, and other DSP components, and outputs it to a playback device. The pipeline is defined via YAML configuration, supporting biquad filters, FIR convolution (with hand-optimized NEON and AVX+FMA SIMD kernels), loudness, limiting, noise gates, and dithering. A websocket-based control interface allows runtime adjustments of volume, mute, faders, and config reloads. The architecture is modular with separate threads for capture, processing, and playback, using a PI rate controller for buffer level regulation. Benchmarks demonstrate attention to performance. While primarily an application, the DSP filter implementations and utility components (ring buffer, conversion routines, rate controller) are reusable building blocks for audio software.
songsee is a single-binary Go CLI tool that turns audio files into spectral visualization images. It decodes audio natively (WAV, MP3) or via ffmpeg, computes an FFT specrogram, and renders nine visualiation modes (spectrogram, mel, chroma, HPSS, self-similarity, loudness, tempogram, MFCC, spectral flux) as a grid of heatmaps in PNG or JPEG format. The architecture is a monlith: the `cmd/songsee/main.go` entry point parsers flags using Kong, delegates to `internal/audio` for decoding, `internal/dsp` for signal processing (STFT, mel filtering, chroma, median filters, etc.), and `internal/render` for image generation. It produces deterministic output – same input flags yield identical bytes. The codebase is well-structured with comprehensive tests, CI/CD, and a clean separation of concerns. It demonstrates high craftsmanship in DSP optimization (e.g., bit-exact HPSS with median networks, tiling) and safe WAV parsing.
This repository is the companion to Allen Downey's Think DSP book. It is primarily an educational Python library plus a collection of Jupyter notebooks, not a production service or a research data pipeline. The core deliverable is the `thinkdsp` package, a self-contained module that provides object-oriented primitives for representing periodic signals (`Signal`, `Sinusoid`, `Chirp`, `Noise`), sampling them into `Wave` objects, and transforming between time and frequency domains via FFT and DCT. The library also supports spectral arithmetic, filtering, convolution, autocorrelation, spectrogram generation, WAV file I/O, and basic audio synthesis. The notebooks in `nb/`, `split/`, and `examples/` walk through each chapter of the book, with solution notebooks and standalone solution scripts in `soln/`.
SoundTouchJS is a TypeScript audio processing library for real-time time-stretching and pitch-shifting in web applications using the Web Audio API. It implements the WSOLA algorithm and offers alternatives like phase vocoder for extreme ratios, with formant correction for vocal preservation. The monorepo structure includes core processing engine, AudioWorklet implementations, and interchangeable interpolation strategies. Key features include runtime parameter updates via message passing, offline processing capabilities, and observability metrics. The library is designed for integration via AudioWorklet to offload processing from the main thread, with a demo application and Storybook showcasing usage.
Pydub is a mature, high-level Python library for audio manipulation. It provides an immutable `AudioSegment` class that supports slicing, concatenation, overlaying, gain changes, fading, and format conversion using ffmpeg/avconv as a backend for non-WAV formats. The library includes a variety of DSP effects (normalize, speedup, compression, filters, equalization), silence detection/splitting, signal generators (sine, square, sawtooth, white noise), and optional playback via simpleaudio, pyaudio, or ffplay. Its architecture is modular, with core functionality in `audio_segment.py` and effects registered via a decorator pattern. The codebase demonstrates clean abstractions and is well-tested, though it carries some legacy Python 2 compatibility patterns.
Squeezelite is a lightweight, headless Squeezebox emulator that acts as a network audio player for Lyrion Music Server (formerly Logitech Media Server). It receives audio streams via the Slimproto protocol, decodes a wide range of codecs (MP3, FLAC, AAC, Ogg Vorbis, WMA, ALAC, DSD, Opus), and outputs to local audio hardware through ALSA, PortAudio, PulseAudio, or stdout. The application is written in C with a modular, multi-threaded architecture: separate threads for network streaming, decoding, resampling, and output, all communicating via circular buffers with mutex protection. It supports high-resolution audio, DSD (DoP and native), resampling with libsoxr, visualizer export to shared memory, IR remote control, and GPIO amplifier control. The codebase is highly portable, with dedicated Makefiles for Linux, macOS, Windows, Solaris, and various ARM architectures, as well as Visual Studio project files. Build-time options (LINKALL, DSD, RESAMPLE, etc.) allow static or dynamic linking of codec libraries. The project is actively maintained with a responsive community and is widely used in embedded audio players and home automation systems.
A comprehensive, isomorphic JavaScript audio processing library engineered for editing, analysis, playback, and encoding. It is non-destructive and stream-first, utilizing a paged in-memory architecture with optional OPFS caching and a Web Worker facade for off-main-thread execution. The library exposes a declarative operation (op) and statistics (stat) plugin system, enabling custom DSP atoms to be composed into serializable edit plans with undo/redo support. It includes a CLI for batch processing and a hand-rolled MCP server for AI-agent integration, plus a polished web demo and workshop pages. The codebase spans core engine modules, 50+ built-in operations (gain, fade, filters, reverb, pitch, stretch, loudness normalization, denoising, etc.), and a large ecosystem of @audio/* dependencies for codecs and advanced effects. It is tested across browser (Playwright) and Node, with benchmark comparisons against SoX, FFmpeg, librosa, and Pedalboard. While the architecture is sophisticated and well-documented, the repository exhibits some over-engineering, a very large test suite that is brittle, and identified production defects (e.g., loudness normalization clipping) that undermine its polish.
amsynth is a free and open-source analog modeling software synthesizer. It implements classic subtractive synthesis with dual oscillators, a resonant low-pass filter, ADSR envelopes, LFO, distortion, and reverb. The system is designed for real-time audio and MIDI processing, supporting polyphony, portamento, pitch bend, and microtonal tuning via Scala files. It can run as a standalone application using JACK, ALSA, or OSS audio drivers, or as a plugin in LV2, VST2, DSSI, and AudioUnit formats. The architecture separates the core synthesis engine (Synthesizer, VoiceAllocationUnit, VoiceBoard) from the GUI (JUCE-based with a skinnable control panel) and plugin wrappers, all sharing a common parameter system with observer pattern and value smoothing. The repository includes a large collection of preset banks, a configuration system, and internationalization support. External dependencies include JUCE for the GUI, freeverb for reverb, MTS-ESP for microtonal support, and NSM for session management.
Just a Sample is a modern, open-source audio sampler plugin for VST3 and AU formats, built with the JUCE framework. It provides sample playback with time-stretching and pitch-shifting (via the Bungee library), a reorderable FX chain (reverb, chorus, distortion, EQ), waveform editing, recording, and microtonal tuning support via MTS-ESP. The architecture is a single plugin with a modular internal design: the core audio processing lives in CustomSamplerVoice, while UI components like SampleEditor, SampleNavigator, FxChain, and CustomLookAndFeel are separated into distinct modules. Effects are implemented as independent classes (Reverb, Chorus, Distortion, BandEQ) with a common interface. The project also includes Reaper-specific VST3 extensions for tighter DAW integration. The codebase demonstrates solid engineering practices with custom UI patterns, thread-safe sample loading, and a theme system supporting dark/light modes. While some parts show active development (TODOs, experimental features), the overall structure is clean and well-organized, making it a good reference for JUCE-based plugin development.
This repository provides an alternate firmware for the Ornament & Crime (O_C) Eurorack module, running on a Teensy 4.0 microcontroller. It implements a modular audio processing platform where individual 'engines' (synthesizers, drum machines, effects, sequencers, CV generators, and utilities) are compiled as separate .bin files and dynamically loaded via the udynlink linker. The firmware features a 128x64 OLED UI, two encoders/buttons, MIDI I/O, CV/gate handling, and a modulation routing system. The codebase is a hybrid of custom engine code and extensively vendored third‑party DSP libraries from Mutable Instruments (plaits, rings, marbles, peaks, streams, braids), open303 (TB‑303 emulation), MSFA (DX7 FM synthesis), SAM (text‑to‑speech), soundpipe, Faust‑generated models, and others. The architecture is monolithic with a plugin‑style engine API (setup/process/draw), and the build system uses a custom shell script and Python tools. While the API is explicitly marked as unstable and the code contains some hacks (e.g., #define private public), the DSP components are of high craftsmanship and many are reusable in other audio projects. The project is actively maintained by a single developer and has a small but engaged community.
SoundFlow is a comprehensive .NET audio framework providing cross-platform audio processing, synthesis, MIDI handling, and security features. It features a modular architecture with components, modifiers, and analyzers that can be chained together to build audio applications. The framework supports audio playback/recording, real-time effects, MIDI sequencing, audio analysis, encryption, watermarking, and fingerprinting. It includes extensive platform-specific native libraries (MiniAudio, FFmpeg, PortMidi, WebRTC APM) built for Windows, Linux, macOS, iOS, Android, and FreeBSD. The repository includes numerous sample applications demonstrating various capabilities, from simple playback to complex security-enabled audio processing.
This repository is a collection of professional-grade audio effect and instrument plugins (VST3/AU/LV2/Standalone) originally by Bram @ Smartelectronix and Tobybear, ported from legacy VST2/Delphi code to the modern JUCE 8 framework. It contains 11 distinct plugins including an oscilloscope (Smexoscope), pitch shifter (Madshifta), compressor (H2O), waveshaper (Cyanide2), phaser (SupaPhaser), delay (Bouncy), granular trigger (SupaTrigga), bitcrusher (Bitmurderer), reverb simulator (AnechoicRoomSimulator), synth (OnePingOnly), and multi-effect (CrazyIvan). The architecture is a collection of independent JUCE AudioProcessor subclasses, each with its own DSP logic and custom UI components built from film-strip assets. The modern codebase follows a consistent pattern: APVTS parameter management, binary-embedded resources, and CMake-based build with CI/CD via GitHub Actions. The repository also preserves the original VST2/AU source code in a legacy/ directory for reference. The primary value lies in the reusable UI widgets (FilmStripKnob, SplashOverlay) and the well-isolated DSP algorithms (multitap delay, spline-based waveshaping, polyphase resampling), which demonstrate non-obvious engineering skill in real-time audio optimization. There is some code duplication across plugins and a few incomplete GUI ports, but the overall quality is solid and the modern code is cleanly structured.