A modular Unity toolkit that consolidates audio management and haptic feedback into a single ScriptableObject-based architecture. Provides audio pooling for 2D and 3D sounds, music playback with smooth transitions, and curve-based vibration control using AnimationCurve. Includes Odin Inspector-powered editor tools that auto-generate type-safe enums for sounds, music tracks, and vibration patterns. The vibration system supports preset patterns, constant vibrations, emphasis modes, and custom curve-based playback with real-time updates and cancellation via UniTask. Designed for Android deployment with runtime performance in mind. All audio and haptic configurations are managed through visual editors with real-time preview capabilities.

barelyMusician is a real-time music engine designed for interactive systems that generates and performs musical sounds programmatically with sample-accurate timing. It provides a modern C/C++ API for creating instruments, performers, and musical tasks that can be sequenced and synchronized precisely. The engine supports procedural note control, tempo management, looping performers, and task-based event scheduling. It processes audio synchronously and is designed for integration into real-time audio applications where predictable timing and low latency are critical. The project includes native plugins for Unity and Godot, a VST instrument plugin, and builds for multiple platforms including Windows, macOS, Linux, Android, WebAssembly, and embedded hardware (Daisy). It offers an alternative to asset-based approaches when you need fully generative or algorithmically controlled musical content.

A Bevy plugin integrating the Kira audio library as an alternative to bevy_audio. Supports playback of ogg, mp3, flac, and wav formats across native and web builds. Provides granular control over audio instances and channels, including dynamic transitions for volume, panning, playback rate, and looping behavior. Sound playback is organized into channels, each offering independent control over pause, stop, volume, speed, and panning for all sounds within that channel. Audio instances can be configured at start time or controlled individually during playback, with support for smooth transitions using tweens and various easing curves. Includes settings loader functionality for pre-configuring audio sources via ron files. Offers basic spatial audio capabilities that automatically adjust volume and panning based on emitter and receiver positions in 3D space.

An idiomatic Bevy plugin wrapping libfmod to integrate FMOD audio middleware into Bevy-based games. Provides ECS-native access to FMOD's event system, including event instances, buses, parameters, and live update connectivity for real-time content iteration. Requires manual linking of FMOD libraries due to licensing restrictions. Supports FMOD Engine 2.02.22 and Bevy 0.18. The plugin handles initialization, event playback, and parameter control through Bevy's component and resource systems. Live update mode enables connection to FMOD Studio during runtime for in-game audio editing and monitoring.

BnkExtractor is a library for parsing and extracting content from Wwise soundbank files. It handles the proprietary .bnk container format used by Audiokinetic Wwise and extracts .wem audio files embedded within. The tool is designed for reverse engineering workflows, asset recovery, and technical analysis of Wwise-integrated games. It provides programmatic access to soundbank structures without requiring the original Wwise project files.

Cavern is a C# audio framework offering object-based spatial audio rendering with unlimited channels and advanced room correction capabilities. It handles Dolby Atmos and other immersive formats natively, providing self-calibration with microphone-based measurement that achieves sub-0.01 dB frequency response uniformity. The framework includes filter engines, real-time surround upconversion, headphone virtualization, and codec support for E-AC-3 JOC, LAF, and various container formats. Room correction profiles export to hardware DSPs, AVRs, and software EQ solutions like Equalizer APO and CamillaDSP. Designed for low-latency operation and Unity-like listener/source workflows, Cavern functions as both a spatial audio renderer and a comprehensive audio pipeline toolkit with measurement and analysis capabilities. Note: distributed under a custom source-available license that restricts commercial use without permission — it is not a standard OSI-approved open-source license.

A C-family programming language and toolchain purpose-built for audio DSP. Cmajor code compiles to native VST / AU / AAX plug-ins via a JUCE bridge, to WebAssembly + WebAudio for browser deployment, or to dependency-free C++ for embedding in your own runtime. VSCode-based development with hot-reload through a host VST/AU. Not a runtime middleware on its own — it produces plug-ins and embeddable DSP that you integrate via your normal audio pipeline. Dual-licensed: open source under GPLv3 with a separate commercial license available.

CORPUS Intelligence is a semantic music search and exploration tool that matches tracks against dense natural-language descriptions in embedding space rather than relying on traditional tag-based taxonomy. The system accepts text descriptions, reference audio files, or images as query inputs, enabling users to search for music based on mood, scene context, sonic characteristics, or conceptual ideas. The platform indexes over 40,000 Creative Commons (CC-BY) licensed tracks and uses AI-powered semantic understanding to retrieve musically relevant results. This approach allows for more intuitive and flexible music discovery compared to conventional keyword or metadata filtering systems.

Engine Sound Generator is a procedural audio synthesis tool that generates physically-modeled engine sounds using the Web Audio API. It implements waveguide-based synthesis techniques derived from research on physically informed car engine sound synthesis, simulating intake, exhaust, and engine block vibrations with configurable parameters like cylinder count, waveguide lengths, and reflection factors. The tool offers multiple implementations including a JavaScript AudioWorklet version and a WebAssembly-compiled version for improved performance. It integrates with Three.js for spatial audio positioning and includes Doppler effect simulation using DelayNodes. Parameters like RPM, muffler configurations, and individual component volumes can be adjusted in real-time. The WebAssembly version eliminates audio glitches present in pure JavaScript implementations while maintaining the same API surface. All synthesis is done procedurally without sample playback, making it suitable for dynamic vehicle simulations where engine characteristics need to change based on gameplay state.

FMOD for Foxes is a high-level C# wrapper for the FMOD audio engine, designed primarily for MonoGame but adaptable to any C# game project. It abstracts away the complexity of FMOD's bare-bones C# wrapper, providing a clean interface for loading and playing audio without dealing directly with C++ interop. The library handles cross-platform setup for Windows, Linux, and Android, managing native library loading and providing convenient APIs for both FMOD Core and FMOD Studio. It includes helpers for streaming sounds, channel management, and proper lifecycle integration with game loops. The setup requires manually downloading FMOD binaries due to licensing restrictions, but the library handles the runtime complexity once configured.

FMOD GD4 is a Godot 4.4 engine module that integrates FMOD Studio middleware. It requires compiling a custom Godot build with the module included, then copying FMOD runtime libraries alongside the executable. The integration provides a singleton for bank loading, event instance creation, and VCA access. Banks can be configured as autoloadable resources through the Godot project settings. The module includes an editor plugin for browsing events from the Master.strings bank cache. This is an active development project targeting FMOD 2.02 and the latest stable Godot 4.4 releases. Installation involves cloning Godot source, adding the module, linking FMOD SDK libraries, and compiling from source.

A GDExtension that integrates FMOD Studio API into Godot 4, providing native access to FMOD's interactive audio capabilities. Exposes most of the FMOD Studio API functions to GDScript and includes dedicated nodes like FmodEventEmitter2D/3D and FmodEventListener2D/3D for scene-based audio implementation. Auto-loads FMOD bank files and supports live updating during development. Provides helpers for common workflows like attaching Studio events to Godot nodes and implementing 3D positional audio. The extension handles the C++ layer, making FMOD's middleware accessible through Godot's scripting system. Note that this is a C++ GDExtension rather than a C# binding, relying on Godot's auto-binding feature for language support. Compatible with any language binding that supports auto-binding, though C# support is currently limited by engine capabilities.

A collection of implementation utilities that extend FMOD's Unity integration with workflow-focused features. Includes triggering and randomization tools, integration with Unity Timeline and Animator, an ambience area system for seamless transitions and large sound sources, reverb zones with blend areas, and a third-person footstep system that doesn't require animation keyframe tagging. Provides surface detection for both mesh and terrain textures, a voiceover system with dialogue queuing and pacing controls, room-portal sound occlusion, and raycast-based obstruction. Designed to reduce repetitive scripting tasks and improve iteration speed for common audio implementation patterns in Unity projects using FMOD.

Fmod5Sharp is a managed C# library that decodes FMOD 5 sound bank files. It reads FSB5 files, extracts contained samples with their metadata (frequency, channels, names), and exports them to standard formats like WAV and OGG. The library supports multiple encoding formats including PCM variants, GCADPCM, IMAADPCM, Vorbis, and FADPCM. It handles both throwing and non-throwing load operations, provides format validation, and reports file extensions for supported codecs. The tool is primarily used for extracting game audio from Unity and Unreal Engine titles that use FMOD middleware. It exposes sample properties like frequency and channel count, making it useful for audio asset inspection and conversion pipelines. The library can rebuild audio data into standard file formats that can be played by common media players or further processed by other audio tools.

A C++ module that provides GDScript bindings for the FMOD Studio API in Godot. Exposes most Studio API functions to GDScript with helpers for common tasks like attaching events to nodes and handling 3D positional audio. Supports live updates from FMOD Studio editor during development, automatic 3D attribute updates, and event callbacks for timeline markers and music beats. The integration handles automatic cleanup of event instances and provides convenience methods for common audio operations. Note: This repository is no longer actively maintained by the original author, who recommends the GDNative fork by utopia-rise for new projects. Includes precompiled binaries for Windows, macOS, and Linux. Requires FMOD licensing for commercial use.

A modular audio plugin for Godot that extends the engine's built-in bus system with adaptive music features. Provides node-based composition for interactive soundtracks with vertical remixing, horizontal resequencing, and procedural elements. Supports overlays, random containers, sequential playback, concatenated tracks, and rollover transitions. Includes multiple playback modes (loop, shuffle, endless) and parameter-driven volume automation. Handles beat-synced transitions and layer crossfading through a straightforward node hierarchy. Designed to reduce the code needed for dynamic music implementation while leveraging Godot's existing audio architecture.

A GDExtension that integrates Valve's Steam Audio SDK into Godot 4.4. Provides real-time acoustic simulation including geometric occlusion, sound transmission through surfaces, distance-based attenuation, room reverb via reflections, and spatial ambisonics rendering. Supports dynamic geometry updates. Currently in alpha with working Linux and Windows builds. Includes basic scene setup nodes and runtime effects processing. Planned features include baked reflection maps for performance optimization and expanded raycasting configuration. The extension wraps Steam Audio's Apache-licensed SDK, which is used in production titles like Counter-Strike 2 and Half-Life: Alyx. Intended to provide feature parity with official Unity and Unreal plugins. Note: the author has stated they are no longer actively maintaining the project and welcome community forks.

hvcc is a compiler that translates Pure Data patches into optimized C/C++ source code and platform-specific wrappers. Originally developed to overcome performance limitations of libpd on mobile devices, it statically analyzes dataflow audio patches and generates low-level code that maintains the same behavior while taking advantage of modern hardware. The compiler supports multiple output targets including Unity plugins, Wwise integration, DPF plugins, DAW plugins, and embedded platforms like Daisy and OWL. It handles patch resolution, abstraction, and generates both C and C++ APIs with optional framework-specific scaffolding. Integrated into plugdata and several online build services, hvcc enables sound designers to work in Pure Data's visual environment while deploying to production environments that require native performance. The toolchain preserves patch semantics while producing portable, optimized implementations suitable for real-time audio processing.

JPL Spatial is a sound spatialization and propagation library written in C++ with no external dependencies for the core implementation. It provides Vector-Base Amplitude Panning (VBAP) and Multi-Direction Amplitude Panning (MDAP) for 2D and 3D speaker layouts, supporting source elevation and a wide range of channel configurations from mono to 9.1.6 surround. The library handles distance attenuation through custom functions, curves, or predefined models (inverse, linear, exponential), plus cone-based angle attenuation for directional sources. It exposes both low-level panners and a high-level SpatialManager API that integrates panning, direct path services, and attenuation caching for per-frame spatial updates. JPL Spatial is used in production by Hazel Engine and is cross-platform (Windows, Linux, macOS on x64/ARM64). The architecture separates concerns into services (PanningService, DirectPathService) that can be used standalone or orchestrated through the manager layer for real-time spatial audio rendering.

A Rust wrapper around the FMOD Engine C API that provides idiomatic, safe bindings for audio playback and management. The library abstracts away manual C interface handling with type-safe Rust code, supporting both FMOD Core and FMOD Studio APIs. Requires manual installation of FMOD development libraries for your platform. Supports dynamic linking only, following FMOD's licensing restrictions. The library provides optional features for C-style bitflags and debug logging builds.

libmysofa is a C library for reading and processing Head-Related Transfer Function (HRTF) data stored in AES SOFA files conforming to the AES69-2015 standard. It provides functions to load SOFA files, extract HRTF filters for specific spatial coordinates, and convert between Cartesian and spherical coordinate systems. The library handles automatic normalization of HRTF data, nearest-neighbor interpolation for arbitrary listener positions, and efficient caching of multiple SOFA files. It supports both integer and floating-point filter extraction with configurable sample rates and neighbor search parameters. Designed for integration into spatial audio engines and renderers, libmysofa offers both simple and advanced APIs for developers who need direct access to HRTF data without implementing SOFA parsing from scratch.

A cross-platform spatializer plugin that integrates spatial audio processing into Unity projects. The plugin uses efficient DSP algorithms to render head-related transfer functions (HRTF) for immersive 3D audio positioning. Designed to fit Unity's audio engine architecture, it supports both Windows and Android platforms. Version 2.0 represents a complete rewrite focused on performance optimization and cross-platform compatibility. The plugin uses a multi-source mixer architecture that reduces CPU overhead compared to previous implementations. While an older HoloLens 2-specific version (v1) offered hardware DSP offload, the current version prioritizes flexibility and integration with Unity's audio pipeline. Note: the GitHub repository was archived (made read-only) in July 2024 and is no longer actively developed, though it remains usable for existing projects. It enables realistic directional audio cues essential for VR, AR, and immersive gaming experiences.

Neural Acoustic Fields is a research implementation that models acoustic propagation in physical scenes as a continuous implicit function. By treating sound propagation as a linear time-invariant system, NAF learns to map any emitter-listener location pair to a neural impulse response that can be applied to arbitrary audio sources. The system enables continuous spatial audio rendering for listeners at any position in a scene, including novel locations not seen during training. NAF learns magnitude-only representations (using random phase similar to Image2Reverb) and demonstrates how acoustic structure emerges as a byproduct of learning spatial sound propagation. The learned representations can also improve visual learning tasks with sparse views. This is research code from a NeurIPS 2022 paper, providing training and evaluation pipelines for learning acoustic fields from 3D scene data. It includes baseline comparisons against codec-based interpolation methods (AAC-LC, Opus) and tools for analyzing spectral accuracy, T60 error, and learned feature representations.

NoiseBandNet is a neural network architecture for synthesizing controllable sound effects using filterbanks. It provides multiple control schemes: automatic extraction using loudness and spectral centroid, loudness-only control for loudness transfer between sounds, and user-defined control parameters drawn directly on spectrograms. The system uses a DDSP-inspired approach with learned filter banks, allowing real-time parameter manipulation and amplitude randomization for variations. The tool includes training workflows for custom sound effect datasets and inference notebooks demonstrating loudness transfer, amplitude randomization for stereo generation, and custom control curve synthesis. Users can train models on their own sound libraries and define control parameters through an interactive labeling interface that displays waveforms and spectrograms. Implemented in PyTorch, NoiseBandNet outputs controllable synthesis parameters that can be manipulated post-training without retraining, making it suitable for adaptive sound design and procedural audio generation in interactive contexts.

A collection of ReaScripts designed specifically for game audio and sound design workflows in Reaper. The scripts automate common tasks and streamline asset preparation processes within the Reaper environment. Installable via ReaPack, the scripts provide functionality tailored to the needs of sound designers working on game projects, addressing typical bottlenecks in the DAW-to-engine pipeline. Note: the repository does not declare an explicit open-source license, so the code is technically all-rights-reserved despite being freely distributed.

Language bindings for the FMOD audio middleware API targeting the Odin programming language. Provides direct access to FMOD's core, studio, and fsbank APIs through idiomatic Odin interfaces. Covers FMOD version 2.02.25 with bindings for all three major API surfaces. Includes basic examples demonstrating integration with raylib. The bindings expose raw FMOD API calls with plans to add more idiomatic Odin wrappers using slices and allocators.

Omnitone is a Web Audio API implementation of ambisonic decoding and binaural rendering. It supports first-order (4-channel) and higher-order ambisonic streams (2nd and 3rd order, up to 16 channels). The library uses native Web Audio nodes for performance-critical processing, ensuring efficient CPU usage. The implementation follows the Google spatial media specification and uses SADIE binaural filters for rendering. It accepts input from HTML media elements or multichannel AudioBufferSourceNodes, with support for dynamic rotation matrices to orient the sound field in response to user interaction or sensor data. Omnitone powers the Resonance Audio SDK for web and provides both ambisonic and bypass rendering modes. The library is designed for browser-based spatial audio applications, VR experiences, and 360-degree video playback. Note: the last release (v1.3.0) was in January 2019, so the project is effectively dormant.

OpenPL (Open Propagation Library) is a dissertation project exploring acoustic propagation modeling concepts similar to Microsoft's Project Triton/Acoustics system. Built with JUCE, it provides a framework for studying and implementing spatial audio propagation algorithms. The library is structured as modular components that can be opened in JUCE's Projucer for experimentation. As an academic research project, it focuses on understanding propagation-based acoustic simulation rather than production-ready integration.

A programmable version of Neil Thapen's Pink Trombone that models the human vocal tract using physical simulation. The tool exposes audio parameters for glottal intensity, frequency, tenseness, and vocal tract shape, allowing direct control over tongue position and diameter. Implemented as a Web Audio API worklet processor with an optional interactive visualization. Developers can create, manipulate, and remove vocal tract constrictions in real-time to produce specific phonemes or arbitrary vocal sounds. The system handles both voiced and voiceless sounds through tenseness and loudness parameters. Includes presets for common phonemes (fricatives, stops, nasals, vowels) with precise index and diameter values. Built for web-based applications requiring real-time procedural speech synthesis without relying on recorded samples or TTS engines.

Generates melodies procedurally using Perlin noise mapped to musical scales. The noise curve is controlled by seed, octaves, lacunarity, and persistence parameters to produce deterministic, infinitely variable melodies suited for adaptive game music. Same seed always produces the same melody, allowing for reproducible results. The tool quantizes smooth Perlin noise curves to chosen musical scales (major, minor, pentatonic, blues, chromatic) with configurable BPM, note range, and length. Supports rhythm and rests via a separate Perlin noise track. Includes a web-based demo with real-time playback (MIDI export is listed on the roadmap, not yet implemented). Note: This project has evolved into SeedSong, a more complete system with multi-instrument support and genre presets. The original repository was archived in 2026 and is maintained as reference for the Perlin noise melody generation approach.

Project Acoustics is a wave-based acoustics simulation system that bakes acoustic propagation into pre-computed data files. It models occlusion, obstruction, portalling, and reverberation using physics-based wave simulation during an offline baking process, then provides runtime queries for interpolated acoustic parameters. The system uses the Triton engine for voxel-free interpolation and supports multiple ACE files simultaneously. It includes HRTF processing validated through FLEX listening tests published in the Journal of the Acoustic Engineering Society. Runtime performance remains efficient by querying pre-baked simulations rather than computing wave propagation in real-time. Integrations provide spatial reverb, custom impulse responses, and parameter exposure to engine-native systems. The tool handles large worlds through double-precision mesh parsing and supports both middleware and engine-native audio pipelines.

PyWwise is a Python wrapper around the Wwise Authoring API (WAAPI) that provides a Pythonic, object-oriented interface for Wwise scripting. Instead of manually constructing WAAPI JSON-RPC calls, PyWwise exposes type-safe classes and methods for common operations like object property manipulation, sound engine queries, and project automation. The library includes specialized types (GUID, Name, ProjectPath), enumerations for Wwise constraints (bit depth, sample rate), and dataclasses for structured data (Vector3, PlatformInfo). Objects retrieved from Wwise become live-connected instances with property getters and setters that automatically sync with the authoring tool. Designed for Wwise 2021+, PyWwise supports context-managed connections, WAQL queries, and comprehensive type hints for IDE autocomplete. It's suited for pipeline tools, batch processing, automated testing, and data validation workflows.

Raveler is a Wwise plugin that runs RAVE (Realtime Audio Variational autoEncoder) models for real-time timbre transfer via neural audio synthesis in game audio contexts. The plugin provides direct integration of trained RAVE models into Wwise effect chains, enabling neural processing of game audio with adjustable latent space manipulation. The plugin exposes controls for model performance parameters including latent noise injection, prior sampling, and dry/wet mixing. It offers direct manipulation of up to 8 latent dimensions with bias and scaling controls, all of which can be bound to RTPCs for dynamic runtime control. Buffer settings allow balancing between audio quality and latency based on project requirements. Based on the RAVE VST project, Raveler brings research-grade neural audio synthesis techniques into production game audio workflows through Wwise's standard plugin architecture. Note: the core is released under CC BY-NC 4.0 (non-commercial), which restricts use in commercial products.

A Reaper extension that streamlines the workflow between Reaper DAW and Wwise middleware. It automates the process of transferring rendered audio files from Reaper sessions into Wwise projects via the Wwise Authoring API (WAAPI). The extension eliminates manual copy-paste workflows when moving audio assets from DAW to middleware. While no longer actively maintained, it provides a foundation for automated asset pipeline integration between these tools.

ReaTeam ReaScripts is a community-maintained collection of scripts for REAPER, distributed through ReaPack. The repository serves as a central hub for user-contributed automation scripts, custom actions, and workflow enhancements. Scripts cover various audio production tasks including editing, mixing, sound design, and project management. Contributors can upload their own scripts using the ReaPack upload interface, making the collection continuously evolving with community contributions. The repository uses ReaPack's package management system for installation and updates, providing version control and dependency management for REAPER scripts.

Resonance Audio is a spatial audio SDK that provides HRTF-based binaural rendering, ambisonic encoding/decoding, and room modeling. Originally developed by Google and released as open source, it offers cross-platform support with integrations for Unity, Wwise, FMOD, and VST. The SDK includes tools for geometrical acoustics simulation, reverberation estimation from game geometry, and ambisonic soundfield capture. It supports first-order and higher-order ambisonics, room effects modeling, and binaural rendering using the SADIE HRTF database. The codebase is written in C++ and provides bindings for multiple platforms including desktop, mobile (Android/iOS), and various audio middleware systems. Note: Google archived the GitHub repository in November 2023, so it is no longer actively maintained, though all source code, build scripts, and platform integrations remain available under an open source license.

SFX Stacks is a desktop application that uses AI to search local sound effects libraries with natural language queries. It combines semantic search with similarity-based discovery, allowing you to find sounds by description then explore similar variations from any result or reference file. The tool indexes your existing library locally and provides integrated preview, waveform editing, and export capabilities in a single interface. Unlike cloud-based solutions, all processing happens on your machine—your library stays local. The similarity search feature lets you use any found result or dropped reference file as a starting point to discover related sounds you wouldn't have thought to search for directly. This workflow reduces the time spent manually browsing folders or clicking through near-matches. The application runs on Windows 10/11 and macOS (Apple Silicon) and works with your existing file organization. No restructuring or uploading required. A free tier (limited results, no account) is available, with a one-time Pro purchase unlocking the full library size.

SPARTA is a suite of open-source spatial audio plug-ins built on the Spatial Audio Framework. The collection provides comprehensive tools for Ambisonic encoding, decoding, rotation, and analysis, as well as specialized processors for beamforming, binaural rendering, room simulation, and sound-field visualization. Each plug-in supports high-order operations (up to 10th order Ambisonics) and many include SOFA file loading for HRIR/BRIR data and OSC head-tracking integration. The suite covers the full spatial audio pipeline: Array2SH encodes microphone arrays to Ambisonics, AmbiENC provides source panning, AmbiRoomSim adds image-source reflections, and AmbiDEC/AmbiBIN decode to loudspeakers or headphones. Analysis tools like PowerMap, DirASS, and SLDoA visualize directional sound-field characteristics. Additional utilities include dynamic range compression (AmbiDRC), arbitrary spreading (Spreader), VBAP panning, and matrix/multi-channel convolution with partitioned modes. All plug-ins are available as VST, VST3, AU, LV2, and AAX formats for macOS, Linux (x86_64 and ARM), and Windows. The codebase is built with JUCE and distributed under GPLv3, making it suitable for research, production, and custom extensions.

A modular suite of 12 MCP servers exposing 97 tools for Audiokinetic Wwise, built on the Wwise Authoring API (WAAPI). Each server handles a specific domain: browsing project hierarchies, creating and editing objects, managing audio import and SoundBank generation, controlling transport playback, querying profiler data, and automating UI workflows. The architecture uses a thread-safe WAAPI dispatcher with queue-based serialization to prevent race conditions. Ships as a standalone Windows executable requiring no Python installation, with pre-configured Agent Skills routing for multi-agent orchestration. Also includes WwiseConsole CLI integration for headless operations like project creation and migration. Designed to stay under per-server tool limits (15 tools each) to reduce LLM confusion, with 450 unit tests and 44 integration tests against live Wwise instances.

An open-source, cross-platform framework for developing spatial audio algorithms in C/C++. Provides modular components for Ambisonics encoding/decoding, spherical array processing, amplitude panning, HRIR/HRTF processing, room simulation, and other spatial audio techniques. Leverages optimized linear algebra libraries (Intel MKL, Apple Accelerate, OpenBLAS) and x86 SIMD intrinsics for performance. The framework includes core modules covering higher-order Ambisonics, spherical harmonics, VBAP, the Covariance Domain Framework, HRIR utilities, and reverb algorithms. Optional modules add SOFA file reading, particle-filtering tracking, and HADES binaural rendering. Originally designed for researchers, it has evolved into a substantial codebase with several example implementations realized as VST/LV2 plugins under the SPARTA project. The modular architecture allows straightforward extension and integration into existing projects via CMake or direct source inclusion. Supports optional Intel IPP for FFT/resampling, FFTW for DFT operations, and NetCDF for large SOFA files.

A Python package focused on spatial audio encoders and decoders. Provides implementations of spherical harmonics processing, loudspeaker decoder algorithms including VBAP and AllRAD, and binaural rendering capabilities. Designed for spatial audio research and development workflows requiring programmatic control over encoding and decoding processes. The library offers building blocks for ambisonics workflows, loudspeaker array optimization, and spatial audio format conversion. It integrates with scientific Python ecosystem tools and is particularly suited for prototyping spatial audio systems or analyzing spatial audio signals in research contexts.

Stable Audio 3 is a state-of-the-art generative audio platform built on diffusion transformers and the SAME (Semantic-Acoustic Music Encoder) autoencoder. It supports three core workflows: text-to-audio generation from natural language prompts, audio-to-audio editing with prompt-guided style transfer, and precise inpainting or continuation of specific regions within existing recordings. The platform offers multiple model sizes: Small models (433M params) run on CPU with no GPU required for lightweight music and SFX generation up to 120 seconds, while the Medium model (1.4B params) delivers higher quality output up to 380 seconds on GPU. Generation speed is measured in milliseconds for multi-second outputs on modern hardware. The SAME autoencoder produces stereo 44.1kHz output at 256-dimensional latents, balancing reconstruction fidelity with generative tractability. Stable Audio 3 includes LoRA fine-tuning support for personalization, variable-length generation to avoid wasting compute on unused latents, and broad hardware compatibility including CUDA, TensorRT, and Apple Silicon via CoreML. Note: the open-weight models are released under the Stability AI Community License (free for research and for commercial use below a revenue threshold), while the largest model is available via API only — it is open-weight, not OSI-approved open source.

Spatial audio SDK from Valve. Provides geometric acoustics (ray-traced occlusion, early reflections, late reverb) and HRTF-based binaural rendering with a single core library plus first-party integrations for the four main game engines and middlewares. The core is C++ under the hood. You can either link it directly or drop in the Unity / Unreal / FMOD / Wwise integration packages and configure spatializers from each tool's authoring UI. Windows (32/64), Linux (32/64), macOS, Android (armv7/arm64/x86/x64), and iOS.

A long-running community extension for REAPER, broadly adopted by game audio teams that use REAPER as their DAW. Adds snapshots for track-parameter recall, region playlists for live audition, EBU R128 loudness analysis, marker-triggered actions, cycle actions, ReaConsole keyboard control, contextual toolbars, and a deep grab-bag of workflow utilities. Windows / macOS / Linux (including ARM builds). Requires REAPER 5.982 or newer.

A Unity plugin for importing and playing standard MIDI files (type 0 and 1) through MIDI outputs. Supports basic MIDI playback functionality and provides an API for procedural music generation using MIDI messages. The tool handles MIDI file import by converting .mid files to .txt format within Unity's asset system. It provides scheduling functions for precise timing control, including DSP-scheduled playback and sequential note triggering based on PPQ calculations. Note that older MIDI features like embedded lyrics are not supported and may cause import errors. The codebase originated from academic research in 2016 and the author acknowledges its rough implementation state.

UnityVSTHost is a minimal VST2 plugin host implementation for Unity that enables loading and processing audio through VST plugins within the engine. It uses OnAudioFilterRead to call VST DSP callbacks and exposes plugin parameters directly in the Unity Inspector. The implementation is limited to 64-bit VST2 plugins on Windows only. It does not support MIDI input or plugin GUIs, instead providing parameter control through Unity's inspector interface. The tool processes audio in real-time by routing Unity's audio callback through loaded VST plugins. This is early research code from 2016 with significant limitations and minimal ongoing maintenance. It requires users to obtain the VST2 SDK separately from Steinberg, as the SDK cannot be redistributed.

A Python script that integrates with Wwise via WAAPI to generate WAV files from text-to-speech. It reads text from Sound Voice object notes and uses Windows PowerShell text-to-speech to generate audio files, then automatically imports them into the Wwise project. The tool works as a Wwise external editor, allowing sound designers to right-click Sound Voice objects and generate placeholder VO without leaving the authoring environment. It demonstrates WAAPI usage for retrieving selected objects and importing audio files programmatically. Note: originally created by decasteljau (Audiokinetic). The standalone waapi-text-to-speech repository has been archived, with its functionality consolidated into the actively maintained ak-brodrigue/waapi-python-tools collection.

A GDExtension-based integration that bridges Audiokinetic's Wwise audio middleware with Godot Engine. Provides native Wwise functionality through custom Godot nodes including AkEvent3D/2D, AkBank, AkListener3D/2D, AkState, AkSwitch, and spatial audio nodes for environments, geometry, rooms, and portals. Includes a Wwise Browser for querying the integrated Wwise project, generating SoundBanks directly in the editor, and an embedded IDs generator tool. Event callbacks are exposed as Godot Signals, and the profiler connection works in debug and profile builds. Supports multi-platform deployment across Windows, macOS, Linux, Android, iOS, and experimental Web builds. The stream manager uses Wwise's default blocking I/O implementation with extensibility for custom I/O devices. Auto-Defined SoundBanks are supported, and per-platform Wwise configurations can be managed through Godot Project Settings. Plugin detection and export work across desktop and mobile platforms, including custom plugin support.

Wwise Gyms provides example projects and test suites for both Unity and Unreal Wwise integrations. The projects demonstrate integration patterns, feature usage, and serve as validation testbeds for the official Wwise middleware implementation in each engine. The repository includes automated testing infrastructure, particularly for Unity Addressables integration, and supports the latest major Wwise version alongside the most recent three LTS versions of Unity and Unreal. Setup requires the Audiokinetic Launcher, Python 3 with NumPy for audio file generation, and proper Wwise integration into the target engine. Primarily useful as a reference for integration developers, QA engineers validating Wwise functionality, or teams implementing complex Wwise features who need working examples to verify expected behavior.

Wwise-MCP is a Model Context Protocol server that exposes Wwise Authoring functionality to AI agents through WAAPI. It enables LLMs to navigate project hierarchies, create and organize audio objects, author events, manage game objects with 3D positioning, configure RTPCs/switches/states, import audio files, and build soundbanks. The tool allows natural-language composition of complex workflows that would otherwise require repetitive manual WAAPI scripting. The system works by first connecting to an active Wwise session, then indexing project structure so the AI can understand path relationships. From there, agents can perform batch operations like creating dozens of events from source objects, positioning game objects in 3D space, or importing entire audio folders—all through conversational prompts. Currently experimental and not recommended for production projects. Requires Wwise 2024.1+ and an MCP-compatible client.

This package integrates Wwise with Unity's Addressables system, enabling dynamic loading and distribution of audio assets. It allows audio content to be managed through Unity's modern asset management framework, supporting remote content delivery and optimized memory usage. The integration handles SoundBank loading through Addressables, letting developers manage Wwise assets alongside other game content in Unity's asset bundles. This is particularly useful for projects requiring downloadable content, platform-specific audio packages, or memory-efficient asset streaming.

wwiser is a parser for Wwise .bnk banks that reads and displays all bank chunks, including HIRC (audio scripting) data with properly identified fields. It cannot modify banks but provides comprehensive analysis of Wwise's internal structure. The tool's primary use case is generating TXTP files that allow vgmstream to simulate Wwise's audio playback, including complex features like dynamic music stems and layered audio. It handles both Wwise's sound module (simple SFX) and music module (realtime-mixed stems), attempting to recreate the engine's behavior in a static playback format. wwiser supports automatic name resolution from companion files like SoundbanksInfo.xml or custom name lists, and provides both a web-based viewer and command-line interface for exploring bank contents. It works with nearly all .bnk versions except the earliest two used in Shadowrun and Too Human.

A comprehensive collection of ReaScripts for REAPER, covering automation, batch processing, take properties manipulation, and various workflow enhancements. Includes scripts written by X-Raym and community contributors, distributed via ReaPack for easy installation and automatic updates. The repository contains utilities for randomizing take properties, advanced editing operations, and specialized audio processing tasks. Scripts range from simple automation helpers to complex workflow tools designed to extend REAPER's native capabilities for game audio production and post-production work.