This talk will cover the new JUCE 8 Direct2D renderer. We'll discuss the history of JUCE rendering, dig into the black box of what Direct2D is and actually does, explore what the new renderer can do, and cover practical tips for writing high-performance graphics code with JUCE 8.
Conference Year: 2024
Inheriting Mantis from Chris Huggett
Chris Huggett founded the Oxford Synthesiser Company in the 1970s. He spent his career designing what became classic instruments: the EDP Wasp and OSCar synthesisers, most of Akai's samplers in the 1990s, and pretty much all of Novation's musical products.
In 2019, Chris took on a commission for a new company. Given creative free rein, he started developing a hybrid synth that revisited some of his earliest work, but improved it with modern features. Unfortunately, he was diagnosed with cancer at around the same time, and didn't survive the first lockdown.
Having worked with Chris for a while at Novation, and being a little involved with the same new company, I was standing in a footlight when the music stopped. With the permission of his estate, the contents of Chris's desk and hard drive allowed us to inherit a well-conceived, sometimes brilliant, but technically rough proof of concept. We were given permission to see what we might do with the hardware and software.
As a solo engineer, my job was to understand the context and intentions embodied in Chris's draft, to shape and polish it without losing his fingerprints, and to see it into production before the money ran out.
This talk will cover the technically interesting aspects of this project, following the evolution of Chris's demo into a manufacturable product and a codebase for the future, whilst working out which of his fingerprints he meant to polish out and which to leave.
Crafting Better Generative Music in Games with Deep Learning
While the procedural generation of mechanical or visual content is widely adopted within the games industry, procedural music generation is utilised much less. There are a variety of reasons why procedural music has not seen similar levels of adoption, especially in the advent of large language models and Generative AI tools such as ChatGPT and Midjourney, where public opinion on machine learning for creative arts and music is particularly controversial. However, there are ethical, and responsible ways to empower composers and music designers, and even improve procedural music systems with machine and deep learning. The adoption of such technology, if used correctly, could reduce burnout and provide novel experiences for players.
In this talk, I will introduce the audience to the basics of machine learning, before presenting multiple peer reviewed studies from my PhD investigating how deep learning can be used to generate: additional layers for bespoke pre-composed game music; expressive performances of MIDI during game play; and outline ethical and responsible design considerations for AI powered game audio tools.
Can Audio Programming be Safe?
Safety is an increasingly discussed topic in relation to programming and often little or misunderstood. With organisations like the NSA and NIST recommending developers move away from memory unsafe languages (such as C & C++), there is a lot of uncertainty in the air about what this means for current programing practices. With a focus on the audio industry, are we even exposed to any of these risks?
In this talk we look at the different types of safety, including memory and functional safety, and how these relate to security. We see what risks we might be exposed to and the current strategies for mitigating them.
We then look into what possible alternatives to “memory unsafe languages” there are, why they are safer and if they are suitable for audio use. Should we all be migrating to Rust, Hylo, Swift or Cmajor? What can we learn from the approach these languages take?
Finally we look at existing tooling such as static analysers and sanitizers and see if these provide any safety nets for memory unsafe languages. What is the most pragmatic approach to audio development with one eye on the future landscape.
Bug-Free JUCE UI
Do you want to:
- Build large-scale and small-scale applications with graphical user interfaces for clients?
- Confidently design your app’s UI architecture using a structured approach?
- Ensure your app is bug-free also in the UI code without laborous manual testing?
How many times have you opened your JUCE GUI app only to find something isn’t working?
How many times have you ended up with too much logic in your Component classes?
And how many times were you scared to start a new project because of the perceived size of the app and lack of confidence in how to design it or start coding?
Graphical user interfaces often suffer from testability problems and thus require a lot of manual testing. How can we overcome this issue? One approach is automated testing with sophisticated GUI analysis tools. However, an easier solution has largely been ignored by JUCE developers: the Model-View-ViewModel (MVVM) pattern, which has been successful in frameworks like Windows Presentation Foundation (WPF) and Android development.
What will you learn from this talk?
- The differences between modern GUI architectures (MVC, MVP, MVVM).
- How to design your GUI app architecture for scalability and maintainability.
- How to reduce development time, costs, and stress by leveraging the power of the MVVM pattern in JUCE apps for clean and testable GUIs.
- How to effortlessly test your GUIs in an automated way without even launching your app.
- How to handle multithreading issues when interacting with GUI code.
Who is this talk for?
- Mostly mid and senior JUCE developers.
- Junior developers can benefit from learning about the scope of the problem and possible solutions. The talk draws heavily on JUCE concepts, so it may be somewhat challenging for those completely new to the JUCE C++ framework.
The talk will include real-world examples, a step-by-step guide, and additional helpful references for future self-study.
Emulating the TX81Z
We all have our favourite synths and synth patches, but how do we go about creating software synthesisers which recreate these sounds?
Attempting to understand and recreate sounds we appreciate can at times seem overwhelming. This talk focusses on the analysis of a TX18Z hardware module in order to produce a software emulation in the Cmajor programming language.
The talk covers the challenges faced when recreating synthesis building blocks such as oscillators and envelopes, tools and techniques used to analyse hardware sound generation modules, and deducing the often complex interactions which form the character of the sound.
The techniques discussed can be applied to recreating other instruments, and best of all, being inspired by their architecture to build unique instruments of your own.
Digital Audio Workstation Architecture
Last year’s “Architecture of Digital Audio Workstations” talk was a broad introduction, followed by an overview of two DAW applications’ architectures, and the decisions behind these. While it covered a great deal of ground, it also had to leave out several important topics.
This talk concentrates on two additional areas:
- Evaluating Architecture
- Evolving Architecture
We will discuss how requirements, constraints and quality attributes come into play when evaluating architectural decisions. This is needed throughout the design process - definitely while creating the initial architectural design, but equally importantly, continuously while maintaining the software.
The familiar saying bears repeating: “Software is finished when no-one uses it”. Throughout its lifetime, software is bound to evolve. The evolution will be driven by sometimes drastic alterations, making it inevitable that the architecture also changes.
After a general coverage of these two new topics, four concrete example cases will be discussed, connecting practice to theory:
1. On how changing requirements result in architectural changes, and introducing new design decisions, resulting in overall improvement.
2. How an existing architecture allowed adding a complex unpredicted feature, without altering the architecture.
3. How mistaken design choices can create “debt” in the codebase, and when/how to address this.
4. How adding a new feature requires designing around the existing architecture, and finding a good compromise between refactoring, and meeting the new requirements.
Inevitably there will be some overlap with last year’s talk, but that will be kept to a minimum. So while I encourage attendees to watch that talk first, this one will be created so that it can be followed regardless, for an audience with some knowledge of software architecture.
This subject area is vast, but I hope that this introductory coverage of the two additional important topics, of architecture evaluation and evolution, will help further build on the knowledge shared on this very central topic for our community!
Get Real, From Plugins to Hardware
Many audio software developers are working on PC or Mobile only, building plugins, DAWs, various applications. There is the whole world of developing physical audio products - synthesizers, grooveboxes, effect pedals or eurorack modules, that is unknown to them. Working with these may seem very different, strange and scary. The notion of "embedded software" may have bad reputation. Nowadays, the truth about developing on hardware is far more nuanced, if not very different.
The purpose of the talk is to show why developing software for hardware can be fun and satisfying and that it's not that much different to working on a PC or mobile.
A review of typical architectures of such products will be presented - starting from hardware itself, but focusing on software aspects - operating systems, programming languages in use and aspects that may be different to PC architecture - such as differences in (or lack of) threading or handling of interrupts.
Last but not least - some tips on how to get started in the field - review of recommend prototyping hardware platforms, interesting software platforms and open source projects.
Building Audio Apps with Rust
Are you considering Rust for your next audio project? Join this talk to explore the current landscape of Rust’s audio ecosystem and determine if it's the right fit for your needs. We'll cover the essential tools and libraries for building desktop applications and audio plugins, helping you evaluate the maturity of Rust for your specific use case.
The session begins with an overview of how to access system audio across all major platforms—an essential foundation for any standalone audio application. Next, we’ll dive into integrating Digital Signal Processing (DSP) within the audio callback, focusing on writing real-time safe code and managing parameters in a thread-safe manner.
But an audio application is not complete without a user interface. We’ll explore the various strategies for creating GUIs in Rust, ranging from high-performance system UIs to sophisticated web-based interfaces.
By the end of this talk, you'll have the insights and tools necessary to build efficient, real-time audio applications in Rust. You’ll also gain a balanced understanding of the advantages and challenges of adopting Rust for audio development today.
[Unit] Testing like a Lazy Pro
A lot of people have heard of unit testing. Many developers have added unit testing to their procedures. But not so many have tried test-driven development and understand how to build a rock solid test bed, that eventually allows you to throw your code away and replace it with whatever is more readable, more scalable, less resource intensive or better performing. The ‘lazy tester, lazy developer’ pattern is a fun way to explore this important topic.