Unpacking the Role of Audio Programmers in the Games Industry

Demystifying the Responsibilities, Skills, and Career Path of Audio Programmers in Games Industry

JS Engines for Audio Developers

So many engines, so little time

Workshop: Practical Machine Learning

Embed a generative AI model in your app and train your own interactions with it

Workshop: Designing and Developing an AVB/Milan-Compliant Audio Network Endpoint

Workshop: Exploring Percussion Synthesis and Rhythm Generation in Python

Challenges in Real-Time Physical Modelling for Sound Synthesis

Performance Implications of Frequency Domain Crossfading for Time-Varying FIR Filtering

High Performance WebView User Interfaces

Getting the most out of the 2D Canvas and DOM

JUCE and Direct2D

Building a plugin assembly line

The Road to Rapid Plugin Development

Sample Rate Conversion

Bridging the Gap in Multi-Device Audio Environments

Snapshot Testing for Audio DSP

A picture’s worth a 1000 tests

The Curious Case of Subnormals in Audio Code

The Discrete Fourier Transform

Bridging the Gap

Workshop: GPU-Powered Neural Audio

High-Performance Inference for Real-Time Sound Processing

Workshop: Inclusive Design within Audio Products

What, Why, How?

Workshop: Klang: Live and Expressive C++ for Audio

What if C++ had built-in audio semantics? What if you could develop C++ plugins, live in the DAW?

Frontend Development Strategies For WebUI

How to Price an Audio Plugin

Factors to consider when deriving that one elusive value

Squeeze JUCE and Bottle It Into Embedded Devices and More

Beyond ValueTrees

(Confessions of a ValueTree Skeptic)

How To Recreate/Restore a Full Game Boy Advance Soundtrack in High Quality

“Engine-Swap” on Two Spatial Audio Plugins Will Be Easy, Right?

Lessons Learned

Rock-Solid Releases

Beginner-Friendly Introduction to CI/CD for Audio Developers

Javascript, WebViews and C++

“If You Can’t Beat Them, Join Them”

Amplifying Efficiency

Business Infrastructure for Audio Startups

Reinventing the Plugin Editor

Immediate Mode GUIs for Audio Plugins

Building Audio Apps with Rust

An Overview of Tools and Techniques

A Critique of Audio Plug-In Formats

VST, AU, AAX, JUCE and Beyond

Learning While Building

MVPs, Prototypes, and the Importance of Physical Gesture

Our Ultra-Processed Interfaces

What Music Technology Can Learn From Doritos

Engineering Success for Audio Software in a Crowded Market

What Can McDonald's Teach Us About Selling Audio Plugins

Can Audio Programming be Safe?

Bug-Free JUCE UI

Structure Your GUI Code For Stability, Testability & Clean Architecture

How To Read Scientific DSP Publications and Turn Them Into Code

Making Sense of Academic Papers and Patents for People Who Are Not Academics or Patent Lawyers

Get Real, From Plugins to Hardware

Intro to Software Development of Audio Devices

Responsible AI for Offline Plugins

Tamper-Resistant Neural Audio Watermarking

Expanding SDKs and APIs in Pro Tools

Roland’s Holistic Approach to AI for Music Creation

Auditory and Cognitive Neuroscience and the State of Audio Technology

A Multi-Disciplinary Panel Discussion

Introducing ni-midi2

A Modern C++ Library Implementing MIDI2 UMP 1.1 and MIDI CI 1.2

Docker for the Audio Developer

CANCELLED

Deep Dive: Unsupervised Audio Processing with Differentiable Digital Signal Processing (DDSP)

Emulating the TX81Z

Techniques for Reverse Engineering Hardware Synths

Elliptic BLEP

High-Quality Zero-Latency Anti-Aliasing

Crunching the Same Numbers on Different Architectures

Knee-Deep Learning

Practical Steps to Get Started with Audio ML

Accelerated Audio Computing

Unlocking the Future of Real-Time Sound Processing

Inter-Plugin Communication

Breaking out of the Channel Strip

Practical Lessons Learned from Building Audio Applications using AI Models

Inheriting Mantis from Chris Huggett

Branch-Free Oscillators for Fun and Profit

Debugging Audio Content With Visuals

A Debugger Extension and Some Other Helpful Tools

A Spatial Audio Primer

Wait-Free Thread Synchronisation With the SeqLock

Digital Audio Workstation Architecture

Evaluation and Evolution

Crafting Better Generative Music in Games with Deep Learning

[Unit] Testing like a Lazy Pro

LLVM’s Real-Time Safety Revolution

RealtimeSanitizer and Performance Constraints Attributes

Synchronised Data for Audio Plugins

Perceptual Convolution

Fast & High-Fidelity Combined

An Introductory Guide to Virtual Analog Modelling

The Intersection of Analog and Digital Audio Processing

How Long Will It Take…to Clean a Kitchen?

Real-Time FFT Convolution

History and Review

Going Deeper with CLAP

The Future of Immersive Music

In Praise of Loudness

Real-Time Inference of Neural Networks

A Practical Approach for DSP Engineers – Part II

Symphony of a Thousand

GPU Synthesis With Massively Parallel Oscillators

Atmospheric Plugin Design

Pipewire: The How, What and Why of Audio on (Embedded) Linux

An Efficient, Open-Source C++ Loop Classifier and Tempo Estimator

The Algorithm Behind Audacity’s Brand New Tempo Detection Feature

What the World Would Look Like if Plugin Instances Could Simply Talk to Each Other

How We Approach Inter-Plugin-Instance-Communication Today and How It Could Be Approached Tomorrow

Welcome Address

Instrument Your Code So it Can Sing

Workshop 1: Dynamic Cast: Web UIs for Music Apps

Workshop 4: From Paper to Plugin

A guided tour of digital filters

Creative Coding

Geometry and OpenGL with Audio

Tabla to Drumset

Translating Rhythmic Language through Machine Learning

Why You Can’t Get Hired and What You’re Going To Do About It

The Hard Reset for Audio Freelancing

PhilTorch: Accelerating Automatic Differentiation of Digital Filters In PyTorch

How to evaluate differentiable filters 1000 times faster in PyTorch.

Peeking Inside Audio Units

A Practical Reverse Engineering Journey

Converting Source Separation Models to ONNX for Real Time Usage in DJ Software

Should Audio Plugins Have “Everything Everywhere All at Once”?

Exploring Modularity, Reusability, and Instrument Identity in Audio Software

Music Design and Systems

Achieving Inaudibly Complex Systems in Video Games

Why Do People Actually Buy Music Software, Anyway?

Workshop 5: Interactive Panel: Accessibility in Audio Tech

Workshop 8: DSP in Practice

From Block Diagram to Working Plugin

Database Synchronisation for Audio Plugins, Part Two

Here's One I Made Earlier

Driving Chaos

Virtual Analog Modelling of a Chaotic Circuit with Wave Digital Filters

Bridging Audio Analysis and Interaction

An Open Toolkit for Real-Time Descriptors

Real-Time Audio in Python: Introducing the asmu Package

PSD to DAW

Building a Pixel-Perfect UI Pipeline

A History of FLAC

The Free Lossless Audio Codec

A Sine By Any Other Language

Mind the Spike

Benchmarking for Worst-Case Execution Time in Realtime Code

The Real Waveform Matters

The Samples Are Not Always What They Seem

Implementing Wave Terrain Synthesis

Carving Paths into Sonic Landscapes

Real-Time, Low Latency and High Temporal Resolution Spectrograms

Channel Agnosticism in MetaSounds

Simplifying Audio Formats for Reusable Graph Topologies

Efficient Task Scheduling in a Multithreaded Audio Engine

Algorithms and Analysis for Parallel Graph Execution

The Practices of Audio Programming

Engineering Practices Break Music Interaction

(but Can Also Fix It)

Chaos, Logic, and Physics

Lessons from Building a 3D Spatial DAW in Unity

Lock-free Queues in the Multiverse of Madness

Creating from Legacy Code

A Case Study of Porting Legacy Code from Exponential Audio

How To Successfully Develop Software Products

Hacking Handhelds for Creative Audio

Building Music Applications for the New Nintendo 3DS

Building Better Software through Cross-Functional Collaboration

Sneak Peek at ARA Audio Random Access 3.0

Embracing Audio Synthesis

Integrate Your Plugin with the New AI and Automation Features in Pro Tools using SoundFlow’s new SFX Framework

Beyond iLok: Advanced Code Protection and Cryptography for the Next Generation

Protecting the next generation of applications, plug-ins, and AI models.

Beyond the DAW

Designing a Procedural Sequencer Powered by Music-Theory

Real-time Audio on Android

Latency and Performance

Overview of Granular Synthesis

Level Up! Procedural Game Music and Audio

Towards Richer, More Dynamic Soundtracks for Games and Interactive Audio Experiences

Finding OSCar

The Secrets of a Classic British Synth

Continuous QA Testing for Plugins Using AI and Python

Cross-Platform Music Software with Rust

Emotion in the Signal

EEG-Driven Adaptive Music for Games, VR, and Immersive Media

Scripting Architecture for a DAW-like Plugin

How we implemented Lua and JavaScript scripting for Synthesizer V Studio

How To Distribute Your Plugins

Using MuseHub as the Engine To Get Your Audio Tools in the Hands of Millions

Roland X Neutone

DIY NEXT

The Official JUCE Audio Plugin Development Course is Here

And it’s free...

Demystifying std::memory_order

Perfect Oscillators in Less Than One Clock Cycle

Building Inclusive Audio Tools

Accessibility with ARIA, WCAG, and Real-World Projects

Analog Filters for Realtime Audio

Enumerate and Extract Audio Buffers When Debugging C++ Applications

Modernizing Legacy Audio Plugin Codebases

Lessons from FL Studio’s Plugin Suite

How I Learned to Love the Docs

Documentation As Design Process for Music Tech Products

Understanding JUCE Drawing

Rules for Measurable Performance Improvements

Building an Optimized DSP Framework in Modern C++

A Performance Odyssey

Transforming UI Rendering in Cubase and Nuendo

Modern Feedback Delay Networks for Realistic and Creative Reverberation

It’s Just a Phase

Exploring Synthesis With the Phase Vocoder

Bugs I’ve Seen in the Wild

From Confusion to Amazement

When the Code Writes Back

Navigating Confidence, Confusion, and Control

Commercialising Audio Plugins

Going From Development to Sales and Beyond

The Rise of Accelerated Audio Computing

New Modules and Markets with GPU Audio

Testing Testing 1, 2, 3

Doodads & Doohickeys

A Guide to Theory-Crafting & Modelling a Fictional Acoustic Instrument

Distorted Reality

Myths about Harmonics and Distortion

Using Strongly-Typed Units in Digital Audio Software

Safe and Sound

Using C++ Audio Libraries from Rust

The Shape of Sound

Building and Bending Vinyl Grooves in Software

2.5 Years Later: A C++ Framework for Audio ML Research Prototyping

Let's break it down

Crowded Market Launch Playbook: Refining Audio Plugin Success Through Pre‑Launch Metrics

Replacing Hope with Clarity in the Audio Plugin Market