Year: 2025

Understanding JUCE Drawing

This session provides a hands-on approach to optimising JUCE GUI performance through interactive demonstrations with measurable before-and-after performance comparisons.

We'll focus on three key optimisation topics:

1. Component hierarchy
In this section we'll dive into the details of how JUCE traverses components while drawing, taking a look at some of the ways you can influence this using setOpaque, setPaintingIsUnclipped, and setBufferedToImage. We'll also discuss the "leaf node only" drawing pattern to see how it can help avoid some surprising performance pitfalls.

2. Paint function
We'll look at Paths, Transforms, Text rendering with GlyphArrangement, and some useful caching techniques, to see how we can reduce the workload required in each of our paint calls.

3. Platform-specific
Finally we'll explore the strategic use of platform-specific optimisations such as setBackupEnabled for transient image caching in the Windows Direct2D renderer, and discussing when you should and shouldn't enable JUCE_COREGRAPHICS_RENDER_WITH_MULTIPLE_PAINT_CALLS on macOS.

Filed under: Uncategorized

Enumerate and Extract Audio Buffers When Debugging C++ Applications

We show a method to add introspection capabilities to any C++ application by combining DWARF debug information with simulated execution. For example, we simulate execution of the begin() and end() methods of C++ containers to enumerate all elements of a container. Applying this method recursively to all local and global variables allows us to iterate over all C++ objects in a live process or core dump. Combining this with user-provided information about which types own audio buffers and how the samples are encoded allows us extraction of audio buffers.

Filed under: Uncategorized

The Shape of Sound

What does it take to turn an audio signal into the spiral groove of a vinyl record—and how can we simulate that process digitally?

This talk explores the complete journey from sound to surface, starting with an overview of traditional analog disk cutting and how each step can be modeled in software. We'll look at how to generate a virtual groove—a digital, geometric representation of the modulated groove path—and how this opens up powerful new possibilities for analysis, playback emulation, and hardware interfacing.

In the second part, the talk introduces a new open-source groove file format designed to standardize virtual groove data for use in simulation, experimentation, and physical disk cutting. The format aims to create a common language for anyone working at the intersection of digital audio and analog grooves.

Whether you're interested in physical modeling, restoration, or just curious about what grooves really look like under the hood, this talk offers tools and ideas to explore—and invites collaboration on shaping the future of vinyl through code.

Filed under: Uncategorized

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

After two and a half years as a R&D engineer in a public research laboratory, I'm happy (and stressed) to open source a big part of my work.

RT-Machine is a c++20 framework developed to help prototyping audio applications & libraries embedding neural networks. It targets linux/android/iOS to integrate ONNX/Tflite/executorch models and provide various features, like pre-processing and asynchronous processing.
We've been using it quite extensively to provide demonstration libraries to our partners.

In this talk I'd like to present you my work, but also discuss what it means to work as an engineer in a public research laboratory and what impact it had on the design of such a tool.

Filed under: Uncategorized

Testing Testing 1, 2, 3

Testing is a massively important part of releasing high quality software, and it is often overlooked when starting a project. Retro-fitting testing onto an existing project can be hard, leading to either a labour intensive process, or more frequently, lower software quality.

This talk discusses practical, pragmatic approaches to building software that makes testing easier. It will discuss this in the context of the Cmajor project, showing the approaches used to ensure that new features can be tested quickly, and reducing the risk of regressions.

The talk will focus on the challenges facing audio software developers, specifically hard realtime audio contexts.

Filed under: Uncategorized

Beyond the DAW

Most music composition tools originate from either traditional sequencing DAWs or purely procedural programming environments. While many have evolved into hybrid DAWs that incorporate elements of both approaches, they remain largely defined by their origins - addressing innovation through UI enhancements rather than rethinking core architecture.

This talk explores a DAW reimagined, merging clip-based sequencing with procedural programming principles and a graph-based framework. Our approach treats music theory not as an absolute truth, but as a set of human-created toolboxes - for jazz harmony, classical composition, microtonal musics, and more - that musicians can apply creatively and procedurally while maintaining full non-destructive control within a linear timeline.

This system lets musicians navigate by ear through theoretical possibilities — trying different tools, keeping what fits, and discarding the rest. Procedural generation becomes an optional co-pilot rather than a gatekeeper, helping musicians leverage complex theoretical concepts without formal training or simply step around them altogether.

The main focus will be on combining the immediacy of traditional sequencing with the flexibility of procedural systems, where theory can shape compositions - rather than merely sketching them out. We'll examine how to architect the sequencer as a directed graph of conventional DAW elements such as tracks and clips, and combine this with composable, non-destructive operations. It will be explained how such graph-based architectures enable complex node interdependencies that formally represent and manipulate various aspects of music theory.

Filed under: Uncategorized

Finding OSCar

The OSCar synthesiser, designed by Chris Huggett and launched in 1983, was a programmable hybrid monosynth. It appeared just as Roland and Yamaha were releasing polyphonic digital synths running on custom chips. Competing with its one-and-a-bit voices, OSCar sold modestly. But its architecture and versatility affords a unique palette of sounds that has seldom been imitated. Today, it is a classic instrument. It features heavily in music by Stevie Wonder, Ultravox, Jean-Michel Jarre, Orbital, Underworld, and many others. Several hundred units are still around, preserved in working order. They change hands for about three times their inflation-adjusted original price.

This talk is about how I'm working with PWM, with the blessing of Chris Huggett's estate, to resurrect and continue the legacy of OSCar. We needed to learn what makes the original instrument so appealing technically and aesthetically. Little of the original design work was available to us apart from what is already online: schematics hand-drawn on A3 paper, object code in an 8 kilobyte EPROM but no source code; user manuals for the synth and a later MIDI retrofit; the supplied factory presets recorded on a badly-wrinkled cassette. On the other hand, we have Chris's own OSCar synth in the final revision state, good software disassembly tools, a supportive and intrigued community of fans and users, and a terror of messing up.

Much of the appeal of OSCar lies in the ingenious workarounds Chris found to push the limits of 1980s technology. It enabled him to create, at the scale of a small business, a synthesiser of enduring quality and versatility from a Z80 processor, a single 8-bit DAC, and a handful of voltage-controlled amplifiers. This talk will reveal some of these tricks while considering the bigger picture:

  • How did we go about reverse-engineering OSCar, and what did we learn?
  • What defines the instrument and its sound?
  • How do we continue a brand that saw its only product released in 1983, recently lost its creator, and has fans from several eras of music?

 

Filed under: Uncategorized

Database Synchronisation for Audio Plugins, Part Two

Need to sync presets or user data between desktop, web and mobile? Want users to share a document or preset with a friend without emailing files around?

After years of trying options that were expensive, deprecated, or just didn’t work well in plugins, I gave in and made my own.

Introducing Replicant: An open-source library written in Rust for syncing JSON documents between desktop apps, mobile apps, and audio plugins.

Filed under: Uncategorized

Tabla to Drumset

Tabla is known for its complex and expressive rhythms, but what if we could make those patterns playable on a drum kit? This talk introduces a system that listens to tabla performances, classifies each stroke using machine learning, and responds with a drum groove that follows the flow of the original rhythm.
Built with stroke detection, pattern prediction, and cross-instrument mapping, the system acts as a rhythm translator. Instead of copying tabla phrases, it interprets them, helping non-tabla players groove with its unique phrasing and energy.
Whether you are into Indian classical music, drum machines, or creative AI workflows, this talk will show how rhythm can move across traditions and tools, and how machine learning can help bridge that gap.
Filed under: Uncategorized

Mind the Spike

What’s the longest your audio callback will ever take?

On modern CPUs, execution time is anything but consistent. Cache misses, pipeline stalls, thread contention, and OS jitter introduce variability—and occasionally, catastrophic outliers. These rare spikes are exactly what can break realtime audio, yet they’re nearly impossible to capture with conventional benchmarking. After all, how do you know the longest time you saw… really was the longest?

This talk introduces Extreme Value Theory (EVT) as a practical framework for analyzing the worst-case execution time of realtime-critical code. We’ll look at how to apply EVT to benchmark data, how to interpret the results, and how this method can reveal serious system-level issues that may only surface once in a million callbacks.

Attendees will leave with actionable techniques for measuring, analyzing, and reasoning about the statistical edge cases of their code’s timing behavior—gaining stronger confidence in the robustness of their audio systems.

Filed under: Uncategorized