Integrating RNBO into unity: a framework for procedural and adaptive game audio

Abstract

In modern game development, audio plays a critical role in shaping player experience, reinforcing atmosphere, and supporting gameplay. While the industry relies heavily on middleware solutions like FMOD or Wwise to handle sound design and implementation, these systems are sample-based. Relying on pre-recorded assets limits creativity and hinders responsiveness to real-time changes within the game. As games became more complex, the need for procedural, interactive, and real-time audio systems has grown significantly. However, implementing such systems often requires a deep understanding of DSP and programming. This creates a barrier between creative sound design and technical implementation. Max/MSP, developed by Cycling '74, is a visual programming language for creating audio. RNBO is a patching environment inside Max, and its made for exporting software in Max. This thesis explores how RNBO can be integrated into Unity. RNBO allows users to design real-time audio processors visually and export them as in C++ format. This makes it a promising tool for procedural sound. The project examines the RNBO Unity Audio Plugin, which allows RNBO patches to run as natively inside Unity. Although the plugin provides a working base, it also presents several limitations that restrict usability for non-programmers. The main limitations are the need to hardcode parameters in C# and compiling the plugin via command line. To address these limitations, the thesis proposes a custom pipeline that simplifies and improves the process of integrating RNBO patches into Unity. The system introduces a tool that automatically parses RNBO patch metadata and exposes it inside Unity. This eliminates the need for manual parameter declaration in code. This workflow enables sound designers to bind gameplay variables to RNBO parameters directly inside Unity's editor interface. By removing the hardcoded step of identifying and scripting parameter IDs, the process becomes significantly more maintainable. The methodology involves creating a simplified RNBO patch with core parameters (e.g., frequency and gain), exporting it as C++ code, compiling it into a Unity plugin, and testing its integration through both code and editor-driven interaction. The patch is used as a case study to demonstrate the workflow from RNBO design to real-time game interaction. Following this, the proposed tool is implemented to show how metadata parsing can improve accessibility and reduce technical complexity. Findings suggest that while the RNBO Unity Audio Plugin provides a strong technical foundation, its workflow is not optimized for rapid experimentation or non-programmer access. The proposed tooling closes this gap by enabling a more designer-friendly solution. It enhances usability without compromising from the low-latency, platform-independent benefits of native audio plugins. In conclusion, this thesis contributes to procedural and real-time audio in games by presenting a hybrid approach that combines visual sound design with modern game engine integration. It demonstrates that RNBO can function not only as a powerful audio tool, but also as a bridge between creative audio workflows and game development. With further development, the system has the potential to become an alternative or complement to existing middleware, offering more dynamic and expressive sound design options for video games.