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.
Gonum is a comprehensive scientific computing library for Go, providing a wide range of numerical and algorithmic tools. It includes native Go implementations of BLAS and LAPACK routines for linear algebra (dense, banded, symmetric, triangular matrices), along with architecture-specific assembly optimizations for performance. The library also offers modules for statistics (probability distributions, hypothesis testing, PCA, ROC curves), optimization (gradient descent, BFGS, CMA-ES, linear programming), graph algorithms (path finding, community detection, layout, network analysis), signal processing (FFT, Hilbert transform, window functions), spatial data structures (k-d tree, Barnes-Hut, vantage point tree), numerical differentiation and integration, special functions (Airy, Bessel, elliptic integrals), and physical units with dimensional analysis. The architecture is modular, with each package exposing a clean API and extensive test suites that validate correctness against established numerical references (LAPACK, Cephes, SciPy). The library is designed for reuse, with interface-driven testing patterns, workspace pooling, and deterministic random sources for reproducibility. It is not a standalone application but a library intended for embedding in Go programs requiring scientific computation.
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.
The pyespargos repository provides a Python library for interacting with ESPARGOS WiFi channel sounder hardware to capture, process, and deliver Channel State Information (CSI) data. The library handles low-level communication with single or multiple ESPARGOS boards, clusters CSI data from distributed antennas, applies calibration to compensate for hardware imperfections, and offers signal processing utilities for beamforming, polarization analysis, and direction-of-arrival estimation. The architecture is modular, with core components separated into board communication (board.py), multi-board pooling and clustering (pool.py), calibration management (calibration.py), and signal processing (util.py). A demo framework (demos/common/) provides reusable Qt/QML-based applications for various WiFi sensing tasks, including MUSIC spectrum analysis, polarization visualization, radar CSI processing, and camera-based beamforming overlays. The demos inherit from a base application class and combine mixins for backlog handling, combined array configuration, and CSI format selection. While the library is tightly coupled to the ESPARGOS hardware firmware (particularly the CSI packet formats and controller API), it encapsulates this complexity behind a clean interface. The signal processing utilities in util.py are hardware-agnostic and represent the most reusable component, offering implementations of advanced algorithms like MUSIC and MVDR beamforming. The clustering logic in cluster.py provides a general pattern for fusing sensor data from multiple distributed nodes. The repository shows active maintenance with recent commits and a linting CI workflow, though it carries some technical debt in the form of incomplete features and hardware-specific calibration complexity.
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.
Lcapy is a Python library for symbolic linear circuit analysis and signal processing. It enables analysis of circuits in multiple domains (time, s-domain, frequency, discrete-time) using SymPy for symbolic mathematics. The library supports netlist-based circuit description, circuit solving via modified nodal analysis, transfer function analysis, noise analysis, state-space representation, and schematic generation using Circuitikz. It is designed for educational, research, and engineering applications in electrical engineering, providing both symbolic and numeric analysis capabilities.
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/`.
Pyroomacoustics is a Python library for room acoustics simulation and audio array signal processing. It provides a modular framework for creating virtual acoustic environments (rooms with walls, materials, sources, and microphone arrays) and simulating room impulse responses using both image-source and ray-tracing methods, with a C++ backend for performance. Beyond simulation, it offers a comprehensive suite of audio processing algorithms: beamforming (delay-and-sum, MVDR, rake filters), direction-of-arrival estimation (MUSIC, SRP-PHAT, FRIDA, CSSM, TOPS, WAVES), blind source separation (AuxIVA, ILRMA, FastMNMF, TRINICON), adaptive filtering (NLMS, RLS, subband LMS), and noise reduction (spectral subtraction, subspace, iterative Wiener). It also includes directivity modeling (analytic patterns and measured SOFA data), STFT/DFT transforms with multiple backends, and utility modules for resampling, filterbanks, and metrics (RT60, PESQ). The library is designed for research prototyping and reproducible experiments, with extensive unit tests and CI/CD for multi-platform builds.
This is a full-stack, self-hosted satellite ground station, not a data-research repository, though it contains substantial orbital-data ingestion, telemetry parsing, and signal-processing components. The application connects software-defined radios (RTL-SDR, Airspy, UHD, SoapySDR, SDRplay) to a real-time web UI for satellite tracking, hardware control, IQ/waterfall visualization, demodulation, decoding, recording, and observation scheduling. The backend is Python with FastAPI/Socket.IO, SQLAlchemy/Alembic, multiprocessing workers, and pub/sub broadcaster components; the frontend is React/Redux Toolkit/Material-UI. The user-facing system manages rotators and rigs via Hamlib, propagates TLE/OMM orbital elements, predicts passes, applies Doppler correction, schedules automated observations, and exposes file browsing, telemetry analysis, and audio transcription through external AI providers.
Cog is a native macOS audio player with an exceptionally broad format support, uniquely specializing in video-game music emulation and obscure audio codec playback. Its architecture is built on a clean, modular plugin system (CogDecoder, CogSource, CogContainer protocols) that integrates dozens of vendored emulator cores (vgmstream, GME, OpenMPT, lazyusf) and general decoders (FFmpeg, TagLib). The app features a composable DSP chain for real-time effects (equalizer, HRTF binaural, tempo/pitch shifting), high-performance threading primitives (CogSemaphore), and a modern Model Context Protocol (MCP) server for remote control by AI agents. This is a classic case of a well-crafted application core coupled with a massive, critical dependency on vendored third-party code; the plugin protocols, DSP nodes, synchronization primitives, and MCP bridge are high-quality, reusable components, while the collection of emulator cores introduces significant licensing and maintenance complexity.
opentrack is a mature desktop head-tracking application (C++/Qt) that computes 6-DOF head pose from many input sources — IR point trackers, ArUco/paper markers, ONNX neural-network face pose estimation, IMU/serial devices, Wiimote, joysticks, eye trackers, and XR glasses — and streams it to games and flight simulators through output protocols such as Freetrack shared memory, TrackIR/NPClient emulation, SimConnect, UDP, X-Plane, virtual joystick (vJoy/libevdev), and a Wine/Proton bridge. The core is a plugin architecture defined in api/plugin-api.hpp (ITracker, IFilter, IProtocol) with dynamic loading, a processing pipeline (logic/pipeline.cpp) that applies axis mapping, centering, relative translation, and filtering, and a main Qt GUI (opentrack/main-window.cpp) for module selection and profile management. The application is organized as dozens of CMake-built plugin modules (tracker-*, proto-*, filter-*) around a compact core of shared infrastructure: a type-safe options/settings framework with versioned migrations, a spline-based response-curve system, cross-platform compatibility helpers (shared memory, timers, math, camera enumeration), and video abstraction. Notable strengths are the clean separation between modules, self-registering plugin macros, and genuinely reusable subsystems (spline library, UKF sigma-point header, settings framework, migration framework). Some modules are research-grade: the Alpha Spectrum adaptive filter (EMA/Brownian/predictive mixture with Rényi entropy), UKF-based deadzone filtering, and ONNX head-pose models. Weaknesses: the codebase carries significant legacy and platform fragmentation — dozens of optional SDK bindings (SimConnect, RealSense, Kinect, Tobii, SteamVR, Oculus Rift) that silently skip on missing SDKs, macOS is explicitly unmaintained, translations are largely unfinished stubs, several modules are experimental (tracker-papertracker, filter-alpha-spectrum), and some bundled third-party code (WiiYourself) has non-free terms. There are also signs of Qt6 migration in progress and mixed OpenCV version requirements. Overall this is an active, real-world, well-architected application with strong reusable components, though the long tail of legacy modules should not be mistaken for production quality.
Praat is a cross-platform desktop application for phonetic analysis, speech manipulation, and linguistic research. It provides a rich GUI with interactive editors for viewing and editing sounds, spectrograms, pitch, formants, text annotations, and more. The core architecture is a monolithic C++ application built on a custom object system (Thing/oo_* macros) with automatic serialization, a comprehensive preferences framework, and a scriptable interface. The codebase bundles many external libraries (GSL, eSpeak, FLAC, Opus, LAME, PortAudio, WhisperCPP, etc.) for numerical computing, audio I/O, speech synthesis, and machine learning. It includes modules for linear predictive coding (LPC), cepstral analysis, neural networks (FFNet), optimality theory grammar, multidimensional scaling, and EEG/ERP processing. While the code is well-structured and domain-specific, the heavy reliance on external libraries, custom object system, and platform-specific ifdefs introduce maintenance complexity and moderate technical drift.
The FFTW.jl package provides Julia bindings to the FFTW library for performing fast Fourier transforms (FFTs) and related operations. It also supports Intel's MKL as an alternative backend via the MKL_jll package. The package is designed as a drop-in replacement for the FFT functionality that was formerly part of Base Julia, and it integrates with the AbstractFFTs.jl package to provide a unified interface for various FFT implementations. The architecture of the package centers around the FFTW module, which re-exports AbstractFFTs and defines concrete implementations of FFT plans for the FFTW and MKL libraries. Key features include support for multi-dimensional transforms, in-place and out-of-place operations, real-to-real transforms (including various types of discrete cosine and sine transforms), and thread-safe execution through the use of a global lock and careful management of plan lifecycle to avoid issues with the garbage collector during planning. The package allows users to switch between the FFTW and MKL backends at runtime (requiring a restart for the change to take effect) via the `set_provider!` function. One notable aspect of the codebase is its handling of thread safety and resource management. The package uses a reentrant lock to protect calls into the FFTW library, which is not thread-safe by default, and integrates with Julia's threading system to allow FFTW to utilize multiple threads. Additionally, it employs a deferred destruction mechanism for FFTW plans to prevent the garbage collector from running during critical planning operations, which could lead to deadlocks. These patterns demonstrate a high level of expertise in wrapping C libraries in Julia while maintaining safety and performance. The package is actively maintained, with recent commits and ongoing issue triage. It keeps pace with its dependencies, as evidenced by compatible version ranges in its Project.toml file, and does not show significant signs of technical debt. Overall, FFTW.jl is a robust and well-engineered solution for performing FFTs in Julia, suitable for both interactive use and high-performance applications.