Introduction

When you think of game audio pipelines, the picture that often comes to mind is a large studio with multiple sound designers, composers, and technical audio specialists, each focusing on their own slice of the work. Inventorix was nothing like that.

The game was built by just two people: a solo developer who handled all the design and programming, and me, taking care of everything audio-related - from writing the soundtrack and creating the sound effects to implementing it all in Wwise and hooking it into the game.

Inventorix itself is a space-themed inventory-management, money-making roguelike deckbuilder. Players creatively pack and synergize items and alien perks to generate astronomical wealth, all in an effort to pay off a mysterious space debt. At its heart, it’s a game about experimentation - stacking items, triggering quirky machine-like interactions, and watching as fortunes are made (and sometimes lost in catastrophic ways). That constant loop of anticipation and payoff gave us plenty of opportunities to think about sound not just as feedback, but as a key part of the game’s personality. It’s not the kind of game that screams “you need middleware,” but that was exactly what made this project an interesting case study.

Instead of relying on hard-coded audio triggers or embedding static sound files, I decided to use Wwise from the very beginning. That decision wasn’t about making the game sound like a blockbuster or cramming in the most advanced audio tech features. It was about something more fundamental: building a structured audio pipeline that would let me stay organized, iterate quickly, and deliver a polished result without drowning in technical debt.

The Myth: Wwise Is Only for AAA Studios

When I tell fellow indie developers that we used Wwise on Inventorix, the response is often a mix of surprise and curiosity. Middleware has a reputation problem in the indie space: it’s seen as too complex, too resource-heavy, or something that only makes sense for AAA productions with branching, adaptive soundtracks and huge asset libraries.

That myth keeps a lot of small teams from even considering middleware, even though they might benefit from it the most. Without dedicated audio programmers, indies often face a choice: either hard-code every sound trigger (which quickly becomes unmanageable) or settle for a bare-bones audio setup that limits creativity and flexibility.

Our experience on Inventorix shows that Wwise isn’t just “overkill” for small projects. On the contrary, it was the tool that let me manage audio cleanly and efficiently. Features like random containers, switches, and ducking gave us polish that would have been a headache to replicate with custom code.

So the point of this article isn’t to brag about cutting-edge DSP chains or massive vertical remixing systems. It’s to show how even a relatively simple game can benefit from middleware, and how Wwise can empower small teams to sound professional, stay organized, and scale up when needed.

Why Middleware Matters (Even in Simple Games)

On paper, Inventorix didn’t strictly need middleware. The audio demands were modest compared to sprawling open-world titles or cinematic story-driven games. But that’s exactly why Wwise proved so valuable: it gave me the benefits of a professional pipeline without adding unnecessary overhead.

With Wwise, I could quickly organize sounds into categories, set up transitions, and test everything in isolation before it ever touched the game build. That structure meant I spent less time hunting down issues and more time shaping the player experience.

Another key benefit was iteration speed. Having Wwise as the middle layer meant I didn’t have to constantly ask the developer to hard-code changes or recompile just to test a small adjustment. I could make tweaks on my own, test them in the Soundcaster session, and only push updates once I was confident. This independence kept our workflow smooth and collaborative.

Finally, scalability played a role. Even if the audio design started small, Wwise ensured that we could expand if we wanted to - adding new categories of sounds, layering more dynamic music, or experimenting with interactivity without rewriting the entire system.

Sound Design Categories in Inventorix

One of the first steps I took in Wwise was to break the game’s audio into clear categories. Even though Inventorix is a relatively small project, this structure became essential once dozens of short sounds started piling up. By grouping them, I could manage levels, routing, and logic more easily, and ensure the mix stayed balanced across very different kinds of sounds.

The main categories I worked with were:

• Boss and aliens/gnomes sounds: unique effects that add personality to non-standard encounters.
• Interaction sounds: short, mechanical-like effects triggered when items vibrate or combine inside the machine.
• Reward sounds: the “kaching” effects that highlight money collection and value generation.
• UI sounds: button clicks, feedback cues, and item manipulation sounds that had to be snappy and unobtrusive.
• Music and stingers: playlists for background music plus win/loss stingers that punctuate key gameplay states.

Each category had its own purpose and energy, and Wwise made it possible to treat them differently from the start. For example, UI sounds were placed on their own bus with limited dynamic range so they would always cut through, while item interaction sounds were randomized with slight variations to avoid fatigue when triggered repeatedly in quick succession.

Kaching Sounds and “Kaching Lines”

One of the most recognizable parts of Inventorix’s audio identity is the “kaching” - the sound of money being earned. These cues needed to feel punchy and satisfying without ever becoming grating, since players hear them constantly while generating wealth inside their machines.

Instead of relying on random containers in Wwise, I approached this directly in my DAW. I created and exported 11 distinct, short, and punchy synth sounds, each tuned to a different pitch of the dominant pentatonic scale (C, E, F, G, B^♭), to give the payouts a tone that felt playful and slightly off-kilter. These individual one-shots were triggered separately in the game, giving each reward a slightly different musical flavor.

For larger payouts, I composed and exported three longer “kaching lines,” each a short melodic run built from the same synth palette. These lines came in different lengths and were triggered with a single Wwise event each. The result was that big wins sounded more celebratory, with their own little musical flourish.

This combination of short one-shots and longer lines gave the payout system a sense of progression. Small rewards felt quick and percussive, while big wins had their own payoff moment.

Music Implementation: Playlists, Switches, and Transitions

For music, I kept the implementation structured but not overengineered. Instead of dropping in static tracks, I built music playlists in Wwise that could sequence cues in different orders. Every playlist change was driven by switches, which also let me define how transitions should behave - whether they should fire immediately, wait until the next beat, or hold until the next bar. In addition, each playlist relied on vertical layering of music stems exported from my DAW to avoid listeners’ fatigue, as Inventorix runs can become quite lengthy.

The boss fight transition required more precision than usual. In this case, the switch to the boss track had to happen immediately, but I also wanted a short taiko roll transition stinger to culminate exactly on beat one of the new music. To achieve that, I hard-coded a small delay in the timing of the switch change so the stinger and the downbeat lined up perfectly. It was a small detail, but one that made the shift into the boss fight feel deliberate and impactful.

Another key moment where states came into play was the “Payment Due” mechanic. Whenever the game required the player to settle their mysterious space debt, the engine triggered not only a “Pay Request” sound effect but also flipped a Wwise state to Payment_Due/Yes. While in this state, the entire music bus was processed through a band-pass filter, muting the brightness of the mix to signal urgency and draw the player’s attention. As soon as the player hit the Pay button, the state returned to Payment_Due/No, instantly restoring the music to full clarity. It was a simple but effective way to make sure the audio reinforced the gameplay stakes without needing new compositions or complex re-scoring.

Overall, the music system wasn’t hyper-interactive, but it was expandable. If we ever wanted to add layers, intensities, or branching structures, the groundwork was already in place.

Mixing and Control: Busses and Ducking

To keep the audio mix clear and ensure that every sound could be heard without overwhelming the player, I relied heavily on Wwise’s bus system. Music and SFX were routed to separate top-level busses, giving me independent control over their levels, effects, and routing. Within each top-level bus, I further subdivided sounds for fine-grained control.

Ducking was a key part of making the mix feel dynamic and responsive. Each SFX category was set to duck the gameplay music, but by different amounts depending on the type of sound. Reward sounds like kachings would duck the music just slightly to avoid pumping, whereas a boss attack or major interactions reduce the music volume more significantly, giving these moments the weight they deserve.

There was also a special case with one of the game relics: it had its own dedicated bus, which could duck the “Aliens” bus independently. This setup allowed a unique gameplay moment to stand out without affecting the overall music or other SFX.

By combining clear bus hierarchies with carefully calibrated ducking, I was able to create a mix that stayed balanced, preserved the clarity of fast sequences, and emphasized key gameplay moments. This system also made it much easier to adjust levels later in development.

Conversion Settings: Tailoring Audio for Purpose

One of the advantages of Wwise is the ability to define different conversion settings for audio assets, which allowed me to optimize both quality and file size for Inventorix. Within SFX, I created five specialized conversion settings:

• Alien Speech: short vocalizations with optimized sample rate and mono/stereo choice to save space while remaining clear.
• Kachings: a sonic staple of the game that retains its original uncompressed file format and sample rate for maximum quality.
• SFX HiFi: high-quality effects for important or detailed interactions. 
• SFX Mono: mono sounds to save memory and CPU for repetitive or less critical effects. 
• SFX Stereo: stereo effects to preserve spatial placement where it mattered. 

This setup let me balance audio quality against memory and performance constraints. Each type of sound was treated according to its purpose in the game: vital cues preserved as much detail as possible, while less critical or frequently repeated sounds were optimized to minimize resource load.

Soundcaster Session Setup

One of the most useful features of Wwise for a small team like ours was the Soundcaster. It allowed me to independently test events, transitions, and mix behavior in real-time without needing to run the full game. For Inventorix, I created a Soundcaster session that mirrored the main gameplay loop and key interactions, giving me immediate feedback on how the audio behaved in context. The session included triggers for all the Wwise events in the game, including music.

This setup made it easy to audition different events, tweak ducking levels, and check timing for transitions and stingers. By simulating the full range of gameplay scenarios in Soundcaster, I could refine cues and confirm mix decisions without constantly building or running the game, which saved significant time in our two-person workflow.

Reflections and Takeaways

Working on Inventorix as a two-person team reinforced how much a well-structured audio workflow can impact both quality and efficiency. Even though the game’s audio needs were relatively simple compared to AAA titles, Wwise allowed me to organize assets, implement music and SFX cleanly, and iterate quickly without depending on the programmer for every change.

A few key takeaways from the project:

• Middleware isn’t just for AAA studios: Small teams can benefit from Wwise’s organizational tools, bus system, and Soundcaster sessions, gaining professional-level control over their audio without overwhelming complexity.
• Planning and categorization matter: Clear categories, busses, and conversion settings make a mix manageable and allow tweaks without reworking individual sounds.
• Even simple systems can scale: Playlists, switches, states, and ducking may seem like overkill at first, but they provide a foundation for future expansion without requiring major rewrites.
• Timing and precision are crucial: Small details, like aligning a transition stinger with a downbeat or filtering music during a specific game state, can significantly enhance the player’s experience.
• Soundcaster sessions are indispensable: They allow real-time testing and iteration, which is especially valuable in small teams without dedicated audio programmers.

Ultimately, Inventorix demonstrates that a small team can achieve polished, professional audio using Wwise, even without complex adaptive systems or massive sound libraries. For indie developers looking to elevate their audio, the project shows that careful planning, structured implementation, and the right middleware can make all the difference.