16BarLogicGame is a Unity/FMOD adaptive music system built around a seven-state finite state machine (Idle, Explore, Combat, Anxiety, Epic, Win, Die). Each state drives a dedicated FMOD transition loop, and all state changes are held in a queue until the current bar boundary is reached — the system reads FMOD's timeline position, calculates bar length from BPM, and fires the transition at the exact bar edge. Priority locking prevents lower-intensity states from interrupting high-priority states (e.g., Anxiety blocks queued Explore or Combat transitions until it resolves). Custom timers govern nuanced exit conditions, such as delaying Combat exit until a configurable post-encounter window elapses. The repo includes a playable Unity scene with combat and spawner scaffolding for exercising all state transitions. It targets Unity 2022.3 with FMOD Studio integration.

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.

UniversalTypes provides drop-in serializable wrapper types for Unity that abstract over multiple backends per field. UniversalSound lets a designer pick AudioClip, Wwise Event, or FMOD EventReference from the Inspector; the code path is gated by scripting defines that are auto-detected when the respective SDKs are present. UniversalString wraps plain text, I2 Localization, and Unity Localization behind a single field with implicit string conversion, resolving the active backend at runtime. UniversalAsset<T> similarly unifies direct object references and Addressables asset references. The package is UPM-installable via Git URL, has zero required dependencies, and works standalone in Unity 2022.3 LTS or later. Optional backends (Wwise, FMOD, Addressables, I2 Localization, Unity Localization) are opt-in and detected automatically via scripting defines.

ArcadeAudioKit is a Swift package for modeling and rendering short synthesized sound effects on Apple platforms (iOS 18+, macOS 12+, tvOS 18+, watchOS 11+, visionOS 2+). It provides a recipe-based API: you describe a sequence of waveform segments (sine, triangle, or square), each with pitch (scientific notation notes, Hz values, sweeps, or interpolated pitch), timing, amplitude, attack, and decay. The renderer converts that recipe into deterministic mono Float PCM samples at a caller-specified sample rate. The library deliberately stops at PCM output. Audio session management, AVFoundation integration, mixing policy, playback, and accessibility behavior are left entirely to the consuming app. This makes it suitable as a dependency in games or game engine extensions where you want reproducible procedural SFX without taking on a full synthesis framework. v1 scope is narrow: recipe modeling, note-to-Hz conversion via A4=440, repeated motif generation for tails and loops, and the PCM renderer. Requires Swift 6.2+ and has no external dependencies.

Audio Agent Creator is a Go-based offline audio synthesis engine designed for programmatic use by game agents or automation scripts. It takes a JSON project description (or a named preset) and deterministically renders stereo PCM, then encodes to 192 kbps MP3 via FFmpeg/libmp3lame or exports lossless PCM16 WAV. The synthesis chain supports oscillators (sine, square, saw, triangle, noise), frequency sweeps, ADSR envelopes, per-track volume/pan/transpose/mute, first-order low-pass/high-pass filters, and basic feedback delay. The tool exposes three interfaces sharing the same project DSL and render contract: a CLI with commands for generation, validation, preset inspection, and schema export; an HTTP API with synchronous and async job endpoints; and a Vite/React web workbench for JSON import, server-side validation, job submission, and MP3/WAV playback. Eight built-in presets (6 SFX, 2 BGM) provide deterministic starting points. This is explicitly an agent-first SFX/BGM MVP, not a DAW replacement. It has no MIDI, piano roll, sampler, plugin host, mixer bus, or generative AI music model. The prompt field currently uses keyword heuristics to select presets rather than text-to-audio synthesis.

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.

Audio Asset Lab is a local, YAML manifest-driven pipeline for producing sound effects and music for games, video, and web projects. You describe generation parameters, seeded variants, post-processing steps, and export formats in a single versionable manifest; the tool produces candidate audio files, selected lossless masters, delivery exports (WAV, OGG, MP3), and provenance records containing prompts, model revisions, processing chains, licenses, and hashes. Two generation paths are available: a deterministic procedural engine (no model weights, included by default) for tonal UI cues, jingles, and synthetic effects; and optional Stable Audio 3 MLX engines (Apple Silicon only) for prompt-driven SFX, ambience, and music. Three model variants are supported: stable-audio-3-small-sfx, stable-audio-3-small-music, and stable-audio-3-medium. Consumer repositories receive only the delivery audio files and have no dependency on the pipeline, Python environment, or any model runtime. Builds are seed-addressed and refuse to overwrite existing outputs without an explicit --force flag. The CLI exposes engine routing and the manifest schema via JSON flags to support agent-assisted manifest authoring. The project is described as usable but early; the manifest and CLI are the stable interface.

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.

Aulos is a small, engine-agnostic audio middleware runtime (~1.3k lines of C++17) that handles everything a game needs after calling aul_play(): voice management and stealing, 3D panning and distance attenuation, Doppler, bus hierarchy, parameter curves, fades, and random variation. Sound behavior lives in a JSON bank — volume, rolloff curves, random pitch ranges — so designers can iterate without recompiles. The library wraps miniaudio for device I/O and decoding. The C API is 20 functions; handles are generation-tagged so stale calls on finished voices are silent no-ops. A lock-free ring separates game-thread commands from the audio thread. Offline rendering mode lets you bounce to file or run deterministic tests. Bindings are provided for Unity (P/Invoke + MonoBehaviours), Unreal (static lib behind a subsystem), Godot (GDExtension), and the browser (Emscripten AudioWorkletProcessor). The web build is bit-identical to native with resampling off. It is not a released product — no authoring GUI, no streaming — but the runtime is tested with 46 measured assertions.

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.

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.

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.

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.

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.

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.

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.

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.

DCSS Remastered Audio retrofits the native, unmodified Dungeon Crawl Stone Soup Windows Tiles executable (x86, 0.34) with an adaptive soundtrack and overlapping sound effects. It works by replacing winmm.dll with a proxy DLL that intercepts sndPlaySoundW calls, forwarding audio events and state-change marker paths over a named pipe to a Python/pygame-ce Audio Director process that runs a multi-channel mixer with per-branch crossfades and HP-based ducking. The approach requires no source code changes and no recompilation. Game state (current branch, HP, events) is extracted via a sandboxed Lua ready() hook that calls crawl.playsound() with marker filenames — the proxy reads the filename rather than playing it, maps it to a mixer command, and the Director responds accordingly. SFX are synthesized locally via make_sfx.py; CC-BY music (Kevin MacLeod) is fetched from an external source at setup time via fetch_music.py. A companion graphics layer extends the same architecture to video post-processing: a second proxy DLL (opengl32.dll) IAT-hooks gdi32!SwapBuffers and reads a shared-memory block written by the same Director process, applying GLSL fragment shader effects (color grading, vignette, bloom pulses) keyed to game state — all without touching the game binary.

DeciWaves parses the proprietary archives of Decima-engine PC titles you legally own, extracts every recorded voice line it can identify, attaches speaker and subtitle metadata where derivable, reorders lines into story sequence, and encodes the result as MP3 reels playable like an audiobook. Nothing is fetched remotely and nothing in your install is modified — the tool operates read-only and produces output entirely from your local disk. Each supported game has a distinct extraction pipeline. Death Stranding uses the Decima resource tree directly and needs no GPU. Horizon Zero Dawn uses content fingerprinting to bind clips to subtitle rows, falling back to on-device WhisperX ASR (CUDA required) only for ambiguous collisions, capped by default at 300 buckets to keep runtime manageable. Horizon Forbidden West extracts and ASR-transcribes clips, then matches them to in-game subtitles; full speaker labels and story ordering require bring-your-own inputs (a Decima type map and a gamescript) that the repo does not ship. DeciWaves ships as a Python package with both a desktop GUI and a CLI. External decode tools (vgmstream-cli, VGAudioCli, ffmpeg, the Oodle DLL from your install) are fetched or located by the setup command. The tool is not affiliated with Guerrilla Games, Kojima Productions, or Sony Interactive Entertainment, and its output is intended for personal use only.

A .NET library and CLI tool for reading and converting Wwise soundbank (.bnk) files across the three Wwise versions found in Diesel engine titles: version 88 (2013), 113 (2015), and 145 (2022). It parses the major section headers—BKHD, STMG, DATA, DIDX, HIRC, ENVS, STID—and within HIRC handles a broad set of object types including Actions, Actor Mixers, Attenuations, Audio Devices, Buses, Events, FX Share Sets, Layer Containers, Music Random Sequence Containers, Music Segments, Music Switches, Music Tracks, Random Sequence Containers, Sounds, and Switch Containers. The converter migrates soundbanks from an older version to a newer one so assets authored against an older Wwise SDK can be loaded by a newer Diesel build. The library exposes an in-memory object model inspectable via any IDE's object inspector, and an accompanying ImHex pattern is provided for raw binary exploration. Format reading was written using bnnm's wwiser as reference.

A Unity + FMOD Studio runtime system that calculates reverb and source occlusion directly from a room's detected geometry and surface materials, frame by frame. There are no manually authored reverb presets — a flood-fill algorithm scans outward from the player to determine room bounds, volume, and portal connections, caches the result per grid cell, and derives FMOD snapshot parameters (reverb time, early/late delay, diffusion, density, HF decay, high-cut, low gain) from volume, material hardness, ceiling height, and wall proximity. Per-source occlusion uses raycasting toward the listener to shift frequency, volume, and pan toward occluded target values, with early/late reflection timing derived from speed of sound. A validation suite tests the model against controlled scenes that isolate single variables (size, material, ceiling height) and a seeded procedural house generator confirms generalization beyond hand-built rooms. Debug tooling includes a live HUD showing reverb parameters and room stats, plus in-editor RoomVisualizer gizmos for detected cells and portals. Portal-based aux routing between adjacent rooms and outdoor/open-space handling are currently disabled and being reworked; core room detection, reverb model, and occlusion are stable. Built on Unity 2022.3, C#, and FMOD Studio.

EchoCompass captures the binaural stereo audio output of FPS games and derives directional information by analyzing inter-aural level differences during transient attack windows. Gunshots appear as red spikes and footsteps as blue dots on a compass display, distributed across a PC window, ESP32 round LCD (GC9A01 240x240), or a phone browser over LAN. Direction is computed with pure signal processing — no ML model, no network calls, no game process access. The tool reads only the OS audio output (what the headphones already receive) and converts it into a visual equivalent of the spatial cues a hearing player gets for free. A legacy 7.1 discrete-channel energy-weighted path is also retained for games that output true surround. Known hard limits: front/back discrimination is not solved (physics boundary for two-channel ILD), simultaneous multi-source events only show one direction, and real-game reflections/reverb cause frequent angle drift. The authors describe it as a validated skeleton — full pipeline works, but real-game accuracy is inconsistent. Intended as an accessibility research starting point, not a finished product.

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.

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 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 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 For Unreal is the official Unreal Engine plugin that connects FMOD Studio to Unreal projects. It exposes FMOD events, buses, snapshots, and parameters to Blueprints and C++, allowing sound designers and engineers to trigger and control adaptive audio at runtime without writing low-level audio code. The repository contains the plugin source for tracking changes and submitting issues or patches, but ships without native binaries — those must be downloaded from FMOD's download page. NDA-covered platform targets (e.g. Xbox) are also excluded from this public repo. Typical use cases include hooking FMOD Studio banks into Unreal's asset system, driving parameter values from gameplay state, and positioning audio via Unreal's spatial transforms.

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.

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.

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.

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.

gion (擬音) is a chiptune/sfxr-style audio workbench and Go library for generating retro 8-bit sound effects and music. Rather than shipping WAV files, you author small deterministic parameter recipes in a .gion document (a Filo s-expression format); the same seed always produces the same samples on every platform. It can render at runtime (under a millisecond for effects, a few dozen milliseconds for music loops) or bake WAVs at build time via the gion-render CLI. The interactive workbench lets you sculpt effects across seven families (pickup, laser, explosion, powerup, hit, jump, blip) with controls for waveform, envelope, frequency slide, vibrato, arpeggio, low-pass, and bit crush. Music generates perfectly-looping chiptune tracks across six moods (upbeat, heroic, dark, chill, battle, boss) with per-instrument mixer and mute switches. A 3D spectral waterfall updates live as you drag sliders; a plain 2D waveform view is also available. The Go library API lets you load a .gion document and render effect parameters to []int16 samples. gion.Mutate derives slightly varied siblings of an effect from a seed, preventing repeated identical sound playback with zero asset overhead. Built on Ebitengine; a browser-based workbench is also available. Not a port of sfxr — written from scratch in Go.

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.

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.

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.

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 Application is a Windows desktop demo that exercises the JPL Spatial library's full signal chain: direct sound spatialization via MDAP, ray-traced specular early reflections using the Image Source method panned with VBAP, and late reverberation rendered by a Filter Delay Network with 4-band crossover decay filters. Propagation delay (including Doppler), inverse-law distance attenuation, and air/material absorption are all configurable at runtime. The GUI (Dear ImGui) exposes a shoebox room model with adjustable dimensions, source/listener positions, surface material absorption coefficients, and RT60 estimates per frequency band. A built-in audio player, spectrogram/waveform preview, loudness meter, and VBAP/MDAP vector visualization make it practical for evaluating spatialization behavior without needing a game engine integration. The project is Windows-only and requires building from source via the provided Visual Studio batch scripts using C++20. It is licensed under ISC and depends on JPL Spatial, MiniaudioCpp, and a CMake fork of Walnut.

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.

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.

lite-audio-pool is a minimal Web Audio utility for real-time browser games that pre-allocates a fixed pool of voices at construction time and reuses them in O(1). It avoids per-play node allocation, which is the main cause of garbage collection stalls in JS audio libraries like Howler. It supports up to 256 concurrent voices (default 32), sprite-based audio (single buffer with named time slices), per-play volume/pan/pitch, and voice stealing with a 20ms anti-pop gain ramp. Generation-stamped handles let callers safely stop a specific play even after its channel has been stolen. At roughly 2 KB minified (under 1 KB gzipped), it has zero dependencies and exposes the raw Web Audio graph, routing voices through an optional output bus node for mixer integration. A destroy() method disconnects all nodes cleanly for scene teardown.

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 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.

mc-audio is a TypeScript package that handles the audio layer for a browser game: it manages a sound cue registry, a BGM state machine, volume category arithmetic, and a caption event stream. The core invariant is that caption events fire before audio gate checks — captions are emitted even when audio is muted, blocked by autoplay policy, or when no backend exists at all. This makes the system correct for deaf and muted players by design. The package deliberately excludes DOM from its TypeScript lib config, forcing all WebAudio-specific behavior behind an AudioBackendPort interface. This means the entire domain — cue planning, volume math, BGM transitions, caption streams — can be tested with Vitest without jsdom or AudioContext. The WebAudio adapter is a separate concern written last, not first. Dependencies are restricted to Effect and an internal kernel package, enforced mechanically by a dependency whitelist script. The package is a sink in the architecture: it receives calls from gameplay and UI layers but never imports from the simulation layer. As of the current state, the WebAudio adapter is not yet implemented, the cue roster is provisional, and there is no build/publish pipeline.

The Meta XR Audio SDK Wwise plug-in bridges Wwise's audio pipeline with Meta's spatial audio and room acoustics engine in Unity projects. It provides HRTF-based spatialization and geometry-driven early reflections and reverberation tuned for Meta Quest hardware, without requiring replacement of Wwise as the runtime audio middleware. Integration targets Unity projects that already use the Wwise Unity Integration, adding Meta-specific spatializer and room acoustics components as Wwise plug-in effects. Spatial mix decisions — source positioning, room material properties — remain inside Wwise's signal chain rather than bypassing it. The plug-in is also referred to in Meta documentation as the Presence Platform Audio SDK Plug-in for Wwise.

MGA Wwise IM Importer automates the translation of music structures designed in a DAW into Wwise Interactive Music. Rather than manually configuring containers, transitions, cues, and fade properties one by one in Wwise, you audition and configure transitions and layers directly on waveforms within the app, then export everything to Wwise in one pass via WAAPI. The tool supports both horizontal (crossfade/switch between tracks) and vertical (additive layer, layer-switch) interactive music patterns simultaneously within one project. It handles WAV splitting, loudness measurement, Make-Up Gain correction for layer balance, and streaming settings (Prefetch Length, Look-ahead Time), going beyond what pure WAAPI scripting can reach. Embedded WAV markers from any DAW work, and the app includes its own marker editing so a separate waveform editor is not required. Nuendo/Cubase marker-track XML unlocks full tempo/bar/beat grid support for visual cue placement, but is not required. Multi-file drop and batch export allow an entire music implementation to be assembled and pushed to Wwise in one session.

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.

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.

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.

opal is a C11 implementation of the Yamaha YMF262 (OPL3) and its OPL2 predecessor — the chips behind AdLib and Sound Blaster cards. The core covers the full register set: two- and four-operator FM, all eight waveforms, tremolo/vibrato LFOs, percussion/rhythm mode with noise generator, timers, and stereo routing including the hardware pipeline delay between left and right channels. Sample-for-sample stereo output matches Nuked-OPL3 at the chip's native 49716 Hz, with internal resampling to any target rate. The public API is eight functions. The chip instance holds no internal pointers, making it trivially copyable as a complete save state. Registers can be written immediately or queued with buffered timing for closer hardware fidelity. A bundled example player streams DRO v1, HSC, IMF, and WLF files to audio via miniaudio, and a WebAssembly build runs the same core in-browser. Builds as a static library via CMake on Windows, Linux, macOS, Android, and iOS. The emulation core is public domain (Shayde of Reality/OpenMPT lineage); the surrounding C API and tooling are MIT.

opal-zig is a Zig binding for the opal OPL3/OPL2 FM synthesis emulator. It compiles the upstream C11 core via the Zig build system and exposes it as a native Zig module with no code generation step and no dependencies beyond libc. Requires Zig 0.16.0 or newer. The public API wraps the eight C functions as methods on a plain `Opal` struct. Because the struct contains no internal pointers, copying an instance produces a complete save state, which is useful for rewinding or snapshotting synthesis state. Internal fields such as envelope stage, envelope generator output, and key state are exposed directly through mirrored `extern struct` types, making it straightforward to build visualizers on top of the emulator. A layout verification test suite checks every field offset and struct size against the C compiler at build time, so Zig-side mirrors cannot silently drift from the C layout. A convenience `render` method fills buffers of interleaved stereo i16 frames. A demo target renders a short FM arpeggio to a WAV file.

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.

Orpheus Audio is a pure C# Unity package providing a structured audio runtime without relying on singletons or implicit scene traversal. Gameplay code references generated typed Audio Keys rather than raw AudioClip assets, and each Audio Session is explicitly created, bound, and disposed by the host. Audio failure degrades silently and never blocks gameplay. The M1 authoring subsystem handles deterministic, recipe-driven generation of Audio Events, Catalogs, and typed keys via Editor tooling. Enrollment is explicit and transactional: an Analyze pass is read-only, Compile is atomic, and orphan deletion requires a second confirmation. All generated outputs, recipes, and manifests are expected to live in the same commit as the Authoring Profile. The package targets Unity 2022.3.62f2c1 minimum, supports Windows Editor and Standalone builds, and marks Android as experimental. iOS, macOS, WebGL, and other platforms are unsupported until verified. It is pre-1.0 at version 0.3.3 but declares a Public Contract v1 with checked-in API and serialization ABI baselines to guard the 0.3 compatibility line.

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.

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).

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.

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.

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.

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.

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 for Wwise is a plugin package that integrates Google's spatial audio engine into the Wwise authoring and runtime pipeline. It provides two plugins: a Renderer that spatializes sound sources binaurally via Wwise's Ambisonic bus pipeline (supporting up to third-order Ambisonics), and a Room Effects plugin that simulates early reflections and late reverberation based on parametric room geometry. The integration targets desktop (Windows, macOS, Linux) and mobile (Android, iOS) platforms. You set up an Ambisonic audio bus in Wwise Authoring, attach the Resonance Audio Renderer as a mixer plugin, and route sound sources through it. Room effects are applied per-source, letting you vary acoustic character across game spaces without baking impulse responses. Requires Wwise 2017.1.0.6302 or newer. This is useful when you need consistent, cross-platform binaural output from Wwise without relying on platform-native spatial audio APIs.

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.

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.

Rewwise is a CLI toolset for extracting and repacking Wwise .bnk soundbanks from FromSoftware titles (Elden Ring, Armored Core 6, Nightreign). It converts a .bnk file into a folder of .wem audio files plus a soundbank.json describing the event routing, bussing, music looping, and other bank metadata. Editing the folder contents and dragging it back onto the tool recreates a .created.bnk ready for use with ModEngine2. The extracted .wem files can be played or converted with vgmstream. Injecting custom audio requires encoding to .wem first, which still requires Wwise Studio itself. The soundbank.json gives readable access to the internal Wwise object graph, making it useful for understanding how audio events are wired without a full Wwise project.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Waapitools is a browser-based collection of JavaScript utilities that connect to Wwise via WAAPI to automate common authoring workflows. Each tool targets a specific tedious task: finding which soundbank(s) contain a given event (including indirect references via parent folders or WWUs), batch-creating and interpolating attenuation curves between a near and far reference, auto-assigning MIDI root keys and key ranges to blend container children based on note names in object names, batch renaming objects and their referencing events, bulk-creating child objects, and nesting flat object lists into new parent containers. The tools run locally from a downloaded HTML file or from the hosted version at waapitools.org, connecting to the Wwise Authoring Tool's WAAPI websocket. No build step or installation is required beyond unzipping. Additional utilities cover project-wide notes review, GUID/path inspection with clipboard copy, and project explorer navigation by path — useful for coordinating across an audio team.

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.

WEM Forge is a standalone Windows GUI tool that encodes WAV files into proper Wwise Vorbis WEM containers without requiring Wwise to be installed. It generates correct modern Wwise Vorbis media structures rather than simply renaming files, handling VBR or target bitrate, resampling, mono downmix, recursive batch processing, and output structure validation. A reference WEM mode lets you match an existing in-game WEM's sample rate, channel config, AkChannelConfig, static codebook, allocation fields, and optional hash block. If the reference file uses an unsupported format (Opus, PCM, ADPCM, encrypted, platform-specific), the tool explicitly rejects it, avoiding generation of structurally invalid WEM files that audio players accept but the game engine rejects. The tool does not modify BNK or PCK index/DIDX structures, so encrypted or custom-packed games still require separate repacking tooling after encoding. The Go-based encoding core is derived from pas2k/wav2wem; the GUI is .NET 8 WPF.

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 Bus Routing Auditor connects to the Wwise Authoring API (WAAPI) via WebSocket and scans every Sound object in a project for bus routing violations. Two scan modes are available: Scan 1 checks asset names using word-token boundaries, while Scan 2 (recommended) checks the Work Unit and hierarchy path. Both modes support multi-keyword OR rules per row, so you can allow multiple valid bus targets for a given source category. Violations are displayed color-coded (red for explicit overrides, yellow for inherited/unset buses), and you can double-click any result to select the object directly in the Wwise Project Explorer. Batch re-routing applies the correct bus to all selected violations in one operation. Results can also be exported to CSV. A signal flow tab visualizes the routing path per bus, and a heatmap tab shows per-bus violation rates at a glance. The tool installs as a Wwise Add-on via a batch script, appearing under the Tools menu, and closes automatically when Wwise exits. Requires Python 3.10 or later and WAAPI enabled on port 8080. Compatible with Wwise 2023, 2024, and 2025.

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.

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 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.

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.

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.

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.

zzfx-rs is a Rust port of ZzFX, the minimal procedural SFX synthesizer originally written in JavaScript by Frank Force. It exposes all 21 ZzFX buildSamples parameters and outputs mono f32 PCM, leaving playback entirely to the caller — compatible with CPAL, rodio, SDL, WAV encoders, or any game engine audio pipeline. The library has zero dependencies in its default build. Deterministic rendering is supported via caller-supplied random sources. A legacy generator mode reproduces the ZzFXM 2.0.3 behavior for song rendering compatibility. Optional Serde support enables preset serialization. A separate egui demo application provides a full parameter editor with waveform preview, preset randomization, native playback (PulseAudio/PipeWire), and WAV export — without pulling GUI or audio deps into the library crate. The crate is not yet published to crates.io and must be installed directly from GitHub.

zzfxm-rs is an unofficial Rust port of ZzFXM, the minimal tracker-style music renderer originally written in JavaScript by Keith Clark and Frank Force. It takes ZzFX instrument definitions, reusable patterns, a sequence, and a BPM and produces stereo f32 PCM output, leaving playback entirely to the caller. The library targets ZzFXM 2.0.3 compatibility, covering beat timing, channel mixing, stereo panning, fractional note attenuation, end-of-note fades, instrument/note sample caching, and legacy ZzFX instrument behavior. It uses zzfx-rs for instrument synthesis. It also supports loading the compact nested-array format used by JavaScript ZzFXM songs, including JavaScript-style sparse array holes represented as None. Useful for embedding chiptune-style music in Rust games or demos where binary size and dependency count matter. Caller-provided randomness allows deterministic rendering, and optional Serde support covers serialization needs. Not yet published to crates.io; installed directly from GitHub.