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.

16bits-audio-mcp is a Zig-based MCP server that exposes game audio generation as tools callable by Claude. It produces 16-bit PCM WAV files using FM synthesis, reverb, ADSR envelopes, and multi-track mixing, all from the Zig standard library with zero external dependencies. It covers three asset types: BGMs in 15 styles (adventure, dungeon, boss, cyber, horror, etc.) with 4-track arrangements; 20 sound effect types (jump, coin, explosion, laser, etc.) with pitch and volume control; and 12 jingle types for common game events like stage clear and game over. Scales, tempo, key, and a deterministic seed parameter give reproducible iteration. A post-processing tool (wav_fx) chains effects such as reverb, delay, bitcrusher, chorus, and distortion, and a mixer tool combines multiple WAV files. Additional tools handle direct note/FM synthesis, WAV info, and playback. The workflow is prompt-driven: describe what you want to Claude, and WAV files are written to disk.

campello_audio is a C++20 multiplatform audio engine designed for game development. It covers macOS, iOS, Android, Windows, Linux, and WebAssembly using each platform's native audio backend (CoreAudio, AAudio, WASAPI, PulseAudio/ALSA, Web Audio). The API follows a fire-and-forget pattern for simple playback while exposing full voice control, mixing buses, and filter chains when needed. The engine supports WAV, OGG, and MP3 sources, procedural tone generation, streaming for large files, and a RandomSource to avoid repetition artifacts. Up to 8 DSP filters per source or bus are available, including low-pass, high-pass, echo, reverb, compressor, limiter, chorus, flanger, and pitch shift. Filter parameters support timed automation. It is a standalone module within the Campello engine ecosystem but is designed to work independently. Built via CMake with no required external dependencies beyond the target platform SDK.

Codex Game Music Skill is a Codex skill (Python-based) that takes game-scene prompts (e.g. 'desert field', 'volcano final boss', 'active battle') and translates them into multi-track Standard MIDI files. The agent infers scene role, loop structure, motif design, harmonic behavior, and adaptive layer splits, then emits .mid files you can open in any DAW, MuseScore, LMMS, or Midiano. Outputs are intentionally kept editable: note data, loop plans, stem splits, and engine handoff notes rather than rendered audio. Bundled Python scripts reproduce the demo MIDI files without external dependencies. The workflow is honest about the distinction between MIDI sketches, SoundFont renders, and finished stems. Primary use cases are rapid game-jam prototyping, adaptive-music layer design, and scene-aware BGM scaffolding that a composer or sound designer can take into a DAW for final production.

DALIA (Dedicated Abstraction Layer for Interactive Audio) is a C++20 audio engine targeting Windows via WASAPI. All internal pools are pre-allocated at startup, eliminating runtime dynamic allocations outside of background-thread asset loading. It handles asynchronous reference-counted asset management and double-buffered OGG/Vorbis streaming via stb_vorbis. Spatialization covers configurable coordinate handedness, multi-listener support with bitmask routing for split-screen co-op, distance probes that decouple attenuation origin from panning origin, and Doppler shifts with per-playback scaling. The mixing system is a directed acyclic graph with 4 hot-swappable DSP slots per bus. The library integrates via CMake FetchContent or git submodule. A standalone sandbox application ships for testing features without writing code. A studio UI tool is in development but excluded from the default build.

Doppler reads the local EVE Online game client, locates all Wwise sound banks (.bnk) and loose Wwise media (.wem) in the shared cache, and exports them to a folder of playable MP3 or WAV files. It covers embedded bank streams, loose WEM resources, every language voice bank, music, UI, ambience, ship, weapon, and turret audio. The tool downloads portable runtime dependencies (Node.js, vgmstream-cli, FFmpeg) into its own directory on first run, requires no admin access, and does not modify the game client. Output is resumable, grouped by source bank and authored client path, and accompanied by a JSON/CSV manifest and failure log. Exports are configurable via command-line flags for format (MP3/WAV), bitrate, worker count, output path, and more. A full 320 kbps MP3 export of the current EVE client produces roughly 9.5 GiB across ~20,000 files.

FMOD For Unity is Firelight Technologies' official integration between FMOD Studio and the Unity engine. It allows Unity projects to load FMOD banks, trigger events, set parameters, and manage the FMOD runtime from C# scripts and Unity components. The repository contains the integration source code (excluding NDA-protected platforms) but no native binaries. Binaries must be obtained from the Unity Asset Store package or the FMOD download page. Developers can use this repo to track changes between versions, report bugs, or contribute patches. The integration source in this repository is MIT-licensed, but shipping a game with FMOD requires accepting FMOD's own end-user license agreement, which is free for many indie/limited-budget projects and paid for larger commercial titles.

fmod-studio-mcp is an MCP (Model Context Protocol) server that connects to FMOD Studio's built-in scripting terminal over TCP and exposes the full FMOD Studio Scripting API as discrete, schema-validated MCP tools. Instead of editing project XML on disk, it talks to the running editor so changes appear immediately without requiring a project reload. The tool set is auto-generated from the crawled FMOD Scripting API reference — roughly 148 named tools covering events, tracks, banks, sounds, assets, and system operations — plus a set of generic property/relationship tools for dynamic, schema-defined members the static docs don't enumerate. A composite tool (`fmod_create_event`) handles the common one-shot workflow of creating an event, importing audio, wiring a track and instrument, and routing to a bank in a single call. Designed for use with AI coding agents, it requires FMOD Studio 2.02+ with the scripting console active (Ctrl+0) and Python 3.10+. The spec can be regenerated for new FMOD versions by re-crawling the official reference. All edits affect the live project, so version control and explicit saves via `fmod_project_save` are strongly recommended.

GMWwise is a plugin that bridges Wwise audio middleware with GameMaker: Studio. It exposes Wwise functionality to GML scripts, letting you trigger events, manage banks, and control parameters from within a GameMaker project without writing a native extension from scratch. It targets the older GameMaker: Studio (pre-GMS2 era). The last release (1.6.1) dates to 2017 and the repository has seen no meaningful activity since, so treat it as abandoned and expect to update it against current Wwise SDKs and GameMaker versions yourself. The repository ships no license file, so it is all-rights-reserved by default.

KinetiTone is a browser-based generative sound designer targeting game developers and sound designers who need quick SFX prototyping and production without a DAW or local installation. It provides six synthesis engines (Classic, FM, Additive, Wave, Noise, Physical), up to four simultaneous layers, a six-slot effects chain, and a randomize/mutate system for rapid sound exploration. A seed system lets you reproduce any generated sound exactly, and a batch export feature can generate variations downloaded as a ZIP of WAV files. Sound history with waveform previews and favorites keeps your session organized. Sounds you create are yours to use in commercial or non-commercial projects; the stated restriction is that you may not resell the generated sounds as-is. It is a closed-source HTML5 web app hosted on itch.io with no public source repository, so there is no license file and no self-hosting option.

Motif is a browser-based adaptive soundtrack workstation aimed at game composers who need structured, intentional score authoring rather than procedural generation. It covers the full composition pipeline: clip sequencing with music-theory transforms, multi-oscillator synthesis with LFO modulation, sample instrument building, scene layering with intensity curves, and automation lanes. The tool handles the game-integration layer directly: trigger bindings map game state to scenes, deterministic resolution picks the correct cue at runtime, and a runtime-pack exporter serializes the project for engine consumption. MIDI import/export and 24/32-bit WAV export at standard sample rates are also included. Everything runs client-side in the browser with no server, no telemetry, and no cloud sync. The project is a TypeScript monorepo of 16 npm packages under the @motif-studio scope, tested with 1,116 unit tests covering schema validation, playback, synthesis, effects, and studio integration.

NA2FLAC Android is the official Android port of NA2FLAC, written in Kotlin for ARM64 devices running Android 8.0 or newer. It scans a folder of Nintendo audio assets and converts them to FLAC using bundled vgmstream and FFmpeg. It handles the same formats as the desktop version (AST, BRSTM, BCSTM, BFSTM, BFWAV, BWAV, SWAV, STRM, LOPUS, IDSP, HPS, DSP, ADX, MP3, OGG), merges split _l/_r stereo files, and falls back to WAV for files above 8 channels. All dependencies (vgmstream, ffmpeg, ffprobe) are bundled in the APK, so no separate installs are needed. This is the mobile counterpart to the Windows NA2FLAC desktop app; use it when you need to convert assets directly on a phone or tablet rather than on a PC. Used for pulling audio out of Nintendo titles for lossless archival or DAW-ready output on a mobile device. As with the desktop build, the bundled FFmpeg is GPL-licensed while NA2FLAC Android itself is MIT.

NA2FLAC is a Windows desktop tool that converts Nintendo audio formats to FLAC (or WAV) using bundled vgmstream and FFmpeg. It handles AST, BRSTM, BCSTM, BFSTM, BFWAV, BWAV, SWAV, STRM, LOPUS, IDSP, HPS, DSP, ADX, MP3, and OGG, producing FLAC for files up to 8 channels and falling back to WAV for higher channel counts. It ships in two builds: a WPF GUI on .NET 8 with folder selection, a progress bar, multithreading, and an NSIS installer; and a console legacy build for simpler batch runs. Both mirror the source directory structure into the output folder and merge split stereo files (_l/_r) into a single stereo track automatically. Used for pulling audio out of Nintendo titles for archival or editing. Dependencies (vgmstream, ffmpeg, ffprobe) are bundled, so no separate install is needed. Note that the bundled FFmpeg is GPL-licensed even though NA2FLAC itself is MIT.

pssounder is a pure-Python WAV-to-VAG encoder and VAG-to-MP3 decoder targeting PlayStation 1 audio. It implements the full SPU-ADPCM algorithm in Python, using ffmpeg for audio I/O and numpy for the encoding math — no psxavenc or other native VAG tools required. The encoder tries all 65 filter/shift combinations per 28-sample block and selects the one with the lowest mean squared error, matching the quality of psxavenc. It supports loop point authoring with automatic alignment to 28-sample block boundaries as required by PS1 hardware. Batch mode processes an entire input folder; single-file mode handles individual WAVs. Supports configurable sample rates (22050 Hz for the classic lo-fi PS1 texture, 44100 Hz for full fidelity).

REAPER Audio Tag runs the PANNs Cnn14 AudioSet tagging model locally on a selected audio item and displays compact clip-level semantic tags inside a REAPER window. No Python installation is required — the plugin uses a self-contained ReaPack backend and a downloaded ONNX model (~327 MB) stored in REAPER's data folder. The action supports GPU acceleration via CoreML on macOS and DirectML on Windows, falling back to CPU if neither is available. After analysis, tags can be written to item notes and a matching project region can be created automatically. Useful when you need fast sound recognition during sound design or editorial — for example, verifying what AudioSet categories a clip falls into or rough-tagging library assets without leaving the session.

retro-sfx-gen is a zero-dependency Python 3 script that procedurally synthesizes retro/chiptune-style sound effects from scratch using oscillators, pitch glides, arpeggios, ring modulation, filtered noise, and envelope shaping. Output is 44.1 kHz / 16-bit mono WAV. No recordings, no pip installs — just the standard library. Covers 16 effect categories (coin, jump, laser, explosion, powerup, hit, ui_click, alarm, pickup, door, teleport, engine, blip, whoosh, land, shield), each with its own synthesis recipe. Generation is fully deterministic via CRC32-seeded RNG, making it suitable for reproducible builds and git-tracked audio pipelines. A companion QC script validates every output file for correct format, duration, peak level, DC offset, silence, and click-free edges. Generated audio is royalty-free and commercially usable with no attribution required.

rope-audioengine is a C++20 real-time audio mixer for games. It opens a single output stream and mixes an arbitrary number of mono/stereo voices on a dedicated audio thread using lock-free command and event queues — no locking or allocation on the hot path. Per-voice gain, constant-power pan, and master volume are applied in the mixer; engine-to-app events (e.g. VOICE_FINISHED) are delivered via polling rather than callbacks into game code. The backend abstraction separates the platform device layer from the mixer. miniaudio covers Windows, macOS, Linux, Android, and iOS by default; RtAudio adds ASIO on Windows. Audio decoding supports WAV, FLAC, MP3, and OGG/Vorbis via dr_libs and stb_vorbis. The public surface is a stable, POD-only C ABI (`rope.h`) suitable for FFI from any language. Provided bindings include a Flutter/Flame FFI plugin and C# P/Invoke wrappers for Unity or Godot .NET. The mixer is tested headlessly via a Null backend, with a GoogleTest suite and CI across Windows, Linux, and macOS.

Shipwright Audio is a code-first audio pipeline where sounds are defined as Python functions decorated with @sound(). Running `shipwright build` renders them to WAV/OGG/FLAC/MP3. There is no GUI; the source file is the project. It supports direct DSP synthesis via numpy-backed `dsp` helpers (oscillators, envelopes, filters), MIDI/instrument tracks with built-in Faust instruments, SoundFont, VST/AU plugins, and sample-based AudioClip tracks. A mixer model provides gain, pan, sends/returns, and master FX per track. Stems and LUFS-targeted loudness normalization are available as build flags. The `compose` module covers chord progressions, scales, swing/humanization, time signatures, and microtonal tuning (n-EDO and just intonation). An `@instrument` decorator lets you write per-note synthesis functions that drop directly onto a Track. The CLI includes a `--watch` mode for iterative work and `-C` for building projects without changing directories.

When a scene spawns more spatial audio objects than the hardware endpoint supports, sources get dropped or fail to spatialize correctly. This Wwise Object Processor plugin dynamically groups nearby audio objects into clusters each frame, mixes their buffers together, and outputs a single object positioned at the cluster centroid — freeing up object slots without perceptible spatial degradation at close angular separations. The clustering uses a density-aware variant of K-means++ initialization biased toward the listener, with per-frame assignment/update iterations that stop when SSE improvement becomes negligible. Clusters merge across frames, interpolate positions to avoid artifacts, and dissolve when objects spread apart. It was developed for EVE Online and EVE Frontier space battles, where it reduced audio thread CPU usage by up to 60% in dense combat scenarios. The plugin integrates as a Wwise Object Processor bus insert. You place it on busses that carry dense sources (e.g. turrets, engines), tune the distance threshold per bus, and profile results in real-time via the Wwise Audio Object 3D Viewer.

TB Wwise Plugin Bundle is a collection of 20 custom DSP effect plugins built specifically for Audiokinetic Wwise 25.1. It covers a broad range of processing needs: spatial effects (Doppler, Haas), modulation (Chorus, Phaser, Ring Modulator), pitch manipulation (TruePitchShifter with formant control, FrequencyShift), convolution reverb, granular delay, BitCrusher, Vocoder, Distortion, SubEnhancer, NoiseRemover, CrossSynth, and more. Plugins are distributed as pre-built Windows DLLs with accompanying XML definition files, installed by dropping them into the Wwise Authoring plugins directory. The plugins target Wwise 25.1 and may not work in other versions. Android, iOS, PS5, Nintendo Switch, and macOS SDKs are not included — Windows only. Caveat: the license is a custom non-commercial one. Use is limited to personal learning, portfolio work, research, and non-profit projects; use in revenue-generating projects (including commercial games) and redistribution of the files or source are prohibited.

This repository is the companion code for the Wwise Up On Air tutorial video series on Wwise plugin development. It walks through creating, building, and modifying a gain effect plugin using Audiokinetic's wp.py development tool, covering both the Sound Engine plugin (DSP implementation, parameter handling) and the Authoring plugin (XML property definition, GUI registration). The sample demonstrates the full plugin scaffolding workflow: generating a plugin skeleton with wp.py, configuring Visual Studio solutions via Premake for Windows targets, adding decibel-range parameters in XML, and writing sample-level DSP code inside the standard Wwise frame-processing loop. It is a practical starting point for developers who need to understand the Wwise plugin architecture before writing their own effect, source, or mixer plugin.

wwise-control is a Claude Code skill and Python helper module that connects an AI agent to Wwise over the Wwise Authoring API (WAAPI). You describe what you want in plain language — creating containers, setting routing, adjusting properties, generating SoundBanks — and the agent translates that into pywwise calls without you writing or running scripts yourself. The package ships two files: a Python module (`wwise_for_claude.py`) that wraps pywwise with tested helpers for finding, creating, moving, renaming, and routing objects; and a SKILL.md that documents non-obvious WAAPI/WAQL quirks discovered through live testing (e.g. object identity requires `.guid` not `.id`, purely-numeric Bus names are rejected by Wwise). The skill instructs the agent to probe before writing, wrap batch edits in a Wwise undo group, verify results after each write, and confirm before deleting. Intended for use on version-controlled projects.

This Wwise sink plugin creates a JACK client that exposes one output port per channel of the assigned Wwise bus, then optionally auto-connects those ports to input ports of a target JACK client. It solves the problem of getting Wwise audio—including high-order ambisonics configurations—out of the Wwise/Unreal pipeline and into a JACK graph for further routing or processing. Configuration is driven by plugin parameters (`jcName`, `jcOutPortPrefix`, `jtName`, `jtInPortPrefix`, `jtAutoConnect`) set in the Wwise Authoring Tool. Any parameter change requires regenerating and re-saving the audio bank in Unreal before it takes effect. The JACK server buffer size must be less than or equal to the Wwise audio buffer, ideally equal, to avoid underruns. The plugin was tested against Unreal Engine 4.27.2, Wwise SDK 2021.1.10, and libjack 1.9.21. Precompiled bundles are provided for Windows toolchains; macOS support is absent, which prevents distribution through the Wwise Launcher.

Wwise Plugin Manager is a Node.js/Gulp-based utility for managing Wwise plugins. It targets teams or individuals who need a scriptable, repeatable way to handle plugin dependencies in a Wwise project rather than doing it manually through the Wwise Launcher or IDE. The README is minimal, so exact feature scope is not fully documented, but the tooling is oriented around automating plugin setup workflows via a Gulp task runner pipeline.

Setting up a new Wwise plugin project requires creating correctly structured Visual Studio solution and project files, wiring in SDK paths, and assigning unique company and effect IDs. Doing this by hand across multiple platforms is error-prone and time-consuming. This Python script takes plugin name, company ID, effect ID, and SDK root as arguments, then generates a full Wwise 2017-compatible plugin scaffold using format template files. It handles Windows x86/x64, Xbox One (Console SDK), and PS4 (SCE Orbis SDK) targets in one pass. The tool is useful when starting custom Wwise DSP or source plugin development and wanting a known-good project structure without reverse-engineering existing Wwise sample plugins.

A collection of Wwise source and effect plugins written in C++. Includes a wavetable oscillator that uses FFT to split a single-cycle waveform into harmonic bands stored in lookup tables, with linear interpolation playback and a basic ADSR envelope. Also provides a bitcrusher combining bit-rate reduction, downsampling, and optional hard/soft clipping distortion, plus a transient shaper that rescales attack and sustain amplitudes via envelope followers with optional soft-clip saturation. Useful as reference implementations for developers learning Wwise plugin authoring or needing a starting point for custom DSP effects in the Wwise SDK.