Skip to content
Published on

Game Audio Middleware in 2026 — A Deep Dive into Wwise (Sony-Owned) / FMOD / Steam Audio (OSS) / Resonance / Tempest 3D / MetaSounds

🇰🇷KO🇺🇸EN🇯🇵JA
Split View필사 모드
Authors

Why Game Audio Suddenly Got Loud

In May 2024, Sony Interactive Entertainment quietly acquired Audiokinetic, the company behind Wwise. One month later, in June 2024, Valve open-sourced Steam Audio under Apache 2.0. The same year, Epic deprecated SoundCue and elevated MetaSounds to the default sound system in Unreal 5.x. AMD TrueAudio Next was revived on RDNA 4. Sony doubled down on Tempest 3D AudioTech for the PS5 Pro. As of 2026, the game audio middleware landscape has shifted more in two years than it had in the previous decade.

This deep dive maps out the entire stack: middleware, engine-native audio systems, spatial audio runtimes, and the DSP plugin ecosystem that feeds them. It is meant to help an indie team decide whether to start with FMOD or Wwise, an AAA studio decide whether to embed Steam Audio directly or rely on Dolby Atmos for Games, and a mobile team decide whether Resonance Audio still earns a slot on the bill.

1. The 2026 Map — Three Camps

The game audio stack splits into three camps: middleware, engine-native systems, and spatial audio runtimes.

CampRepresentative ProductsLicensePrimary Use
Middleware (external tooling)Wwise, FMOD Studio, Criware ADXCommercial (free indie tier)AAA, mobile, console
Engine-nativeUnity Audio Mixer, Unreal MetaSoundsBundled with engineIndie, small/mid studios
Spatial audio runtimesSteam Audio, Resonance Audio, OpenAL Soft, Sony Tempest 3D, AMD TrueAudioOSS / platform SDKVR, PS5, simulation

These camps are not mutually exclusive. The Last of Us Part 2 ships with Wwise as middleware while invoking Tempest 3D on PS5 and Steam Audio on the PC port. Helldivers 2 shipped with a Wwise + Steam Audio combination.

Five Key Trends

  1. Open-source spatial audio breakthrough — Valve open-sourcing Steam Audio under Apache 2.0 in 2024, paired with Google's earlier Resonance Audio OSS release, means indies now have AAA-class spatial audio for free.
  2. Sony's vertical integration — Audiokinetic acquisition + Tempest 3D + PSVR2 = Sony 1st party studios now share a single audio pipeline owned end-to-end by Sony.
  3. The MetaSounds era — In Unreal 5.x, the SoundCue-based workflow has been deprecated, and a sample-level DSP graph system is now the default.
  4. Atmos for Games at home — Xbox Series X/S, PS5 Pro, and PC all support Dolby Atmos output natively.
  5. Ray-traced audio — Steam Audio + Embree, AMD TrueAudio Next with Radeon Rays 2.0, and (historically) NVIDIA VRWorks Audio all support GPU-accelerated ray-traced reverb.
2026 Game Audio Stack Diagram

  [ DAW / Sound Design ]
        Reaper, Pro Tools, Logic Pro, Ableton
        ↓ wav, ogg, opus
  [ Middleware / Engine ]
        Wwise · FMOD · MetaSounds · Unity Audio Mixer
        ↓ event, parameter, snapshot
  [ Spatial Audio Runtime ]
        Steam Audio · Resonance Audio · Tempest 3D · OpenAL Soft
        ↓ binaural / ambisonic / object-based
  [ Output ]
        Speakers / Headphones / Dolby Atmos / DTS:X

2. Wwise — Audiokinetic (Acquired by Sony, May 2024)

Wwise is the game audio middleware built by Audiokinetic, originally based in Montreal, Canada. In May 2024, Sony Interactive Entertainment acquired Audiokinetic, giving Sony direct control over the audio pipeline used by every PlayStation 1st party studio. Sony officially committed to keeping Wwise platform-neutral, and as of 2026 Wwise still ships for every console, PC, mobile, and VR target.

Wwise Core Concepts

  • Event — The unit a game calls. One PostEvent("Play_Footstep_Concrete", actor) triggers all randomization, layering, and attenuation defined by the sound designer.
  • SoundBank — A bundle of sound assets loaded into memory, usually per level.
  • RTPC (Real-Time Parameter Control) — Maps game variables to audio parameters. Player health drives heartbeat intensity; vehicle RPM drives engine pitch.
  • State / Switch — State is global context (combat vs. peace); Switch is per-object context (concrete vs. grass footstep).
  • Bus / Mixer — Signal routing graph with side-chain, EQ, and dynamics.

Wwise Integration Example — Unity

// Wwise Unity Integration
using UnityEngine;
using AK.Wwise;

public class FootstepController : MonoBehaviour
{
    public AK.Wwise.Event footstepEvent;
    public AK.Wwise.Switch concreteSurface;
    public AK.Wwise.RTPC playerSpeedRtpc;

    private CharacterController controller;

    void Start()
    {
        controller = GetComponent<CharacterController>();
    }

    void Update()
    {
        // RTPC update - drive footstep intensity from speed
        float speed = controller.velocity.magnitude;
        playerSpeedRtpc.SetValue(gameObject, speed);

        // Switch change based on surface
        if (Physics.Raycast(transform.position, Vector3.down, out var hit, 1.5f))
        {
            if (hit.collider.CompareTag("Concrete"))
                concreteSurface.SetValue(gameObject);
        }
    }

    public void OnFootstep()  // Called from Animation Event
    {
        footstepEvent.Post(gameObject);
    }
}

Licensing (2026)

  • Indie (revenue under 250K USD) — Free
  • Small/mid studio — About 800 to 8,000 USD per project
  • AAA — Negotiated (typically tens to hundreds of thousands of USD)

Wwise powers The Witcher 3, Cyberpunk 2077, Helldivers 2, Hogwarts Legacy, Black Myth: Wukong, Spider-Man 2, The Last of Us Part 2, and most major AAA titles.

3. FMOD Studio — Firelight Technologies

FMOD is built by Firelight Technologies in Australia. It splits the market with Wwise, but its indie-friendly UX and clean licensing make it the dominant choice for indie and small/mid studios.

What Sets FMOD Apart

  • DAW-like workflow — Timeline, automation curves, multi-track editing — very similar to Reaper or Pro Tools.
  • Affordable license — Free for indie (under 200K USD), then a flat 5,000 USD per project (2026 rates).
  • Fast iteration — Live Update lets sound designers tweak parameters while the game is running.

FMOD Integration Example — C++

// FMOD Core API + Studio API integration
#include <fmod_studio.hpp>
#include <fmod.hpp>

FMOD::Studio::System* studioSystem = nullptr;

void InitFMOD()
{
    FMOD::Studio::System::create(&studioSystem);

    // 1024 channels, Studio init flags, Core init flags
    studioSystem->initialize(
        1024,
        FMOD_STUDIO_INIT_NORMAL,
        FMOD_INIT_NORMAL,
        nullptr);

    // Load master bank
    FMOD::Studio::Bank* masterBank = nullptr;
    studioSystem->loadBankFile(
        "Master.bank",
        FMOD_STUDIO_LOAD_BANK_NORMAL,
        &masterBank);
}

void PlayFootstep(const FMOD_3D_ATTRIBUTES& playerAttribs)
{
    FMOD::Studio::EventDescription* eventDesc = nullptr;
    studioSystem->getEvent("event:/Player/Footstep", &eventDesc);

    FMOD::Studio::EventInstance* instance = nullptr;
    eventDesc->createInstance(&instance);

    // Set 3D position
    instance->set3DAttributes(&playerAttribs);

    // Set parameter
    instance->setParameterByName("Surface", 0.0f);  // 0 = concrete
    instance->start();
    instance->release();  // auto-release after start
}

void UpdateFMOD()
{
    studioSystem->update();
}

Notable FMOD Titles

  • Celeste, Hades, Hollow Knight, Cuphead — indie standouts
  • Forza Horizon 5, Halo Infinite — Xbox 1st party
  • Battlefield, FIFA — some EA titles

FMOD plays particularly well with both Unity and Unreal integrations, and the licensing model stays simple.

4. Steam Audio — Valve (Open-Sourced June 2024)

Steam Audio is Valve's spatial audio SDK. It started life as Phonon in 2017, was rebranded Steam Audio in 2018, and went fully open source under Apache 2.0 in June 2024. The full source lives at ValveSoftware/steam-audio on GitHub.

What Steam Audio Does

Steam Audio is not middleware. It plugs into Wwise, FMOD, Unity, or Unreal and handles four things:

  1. HRTF-based binaural rendering — Synthesizes left/right ear signals based on the listener's head shape. The bedrock of directional sound.
  2. Occlusion — Attenuation behind walls or obstacles. Not a single distance calculation but actual ray traced paths.
  3. Reverb baking + real-time — Static environment reverb is baked; dynamic objects are computed live.
  4. Reflections (ray-traced) — Intel Embree BVH ray tracing computes first-, second-, and third-order reflections.

Steam Audio Integration — Unity Plugin Example

// Steam Audio Unity integration
using UnityEngine;
using SteamAudio;

public class SteamAudioSourceSetup : MonoBehaviour
{
    void Start()
    {
        // 1. Attach Steam Audio Source component to the AudioSource
        var src = gameObject.AddComponent<SteamAudioSource>();
        src.directBinaural = true;       // enable HRTF binaural
        src.applyOcclusion = true;       // enable occlusion
        src.occlusionMode = OcclusionMode.Raycast;
        src.applyReflections = true;     // enable reflections
        src.reflectionType = ReflectionType.RealTime;

        // 2. Listener (usually the camera) needs SteamAudioListener
        if (Camera.main.GetComponent<SteamAudioListener>() == null)
            Camera.main.gameObject.AddComponent<SteamAudioListener>();

        // 3. The Steam Audio Manager bakes static environment offline
        // (Steam Audio Static Mesh + Bake Reflections in the editor)
    }
}

Why Open-Sourcing Matters

Apache 2.0 permits free commercial use, modification, redistribution, and includes an explicit patent grant. That means Sony, Microsoft, and Epic can all fork Steam Audio into their own engines without restriction. In fact, Unreal 5.5+ ships with some Steam Audio-based reverb baking out of the box.

5. Resonance Audio — Google to Open Source

Resonance Audio was originally launched by Google in 2017. It was a core component of Daydream VR, and it powered the ambisonic decoder for YouTube 360 video. In 2022, Google deprecated the project but open-sourced it under Apache 2.0. As of 2026 the community forks at GoogleArchive/resonance-audio (plus active forks like AndrewIOM/resonance-audio-active) are still maintained.

Resonance Audio Strengths

  • Ambisonic decoding — Supports 1st, 2nd, and 3rd-order ambisonic. Ideal for 360 video and VR ambience.
  • Lightweight — Significantly lower CPU usage than Steam Audio. Wins on mobile VR / WebXR.
  • Standards-aligned — Supports AmbiX (ACN/SN3D) format and interoperates with Reaper, Spat Revolution, and similar tools.

Web Audio + Resonance Audio Example

// Resonance Audio Web usage (resonance-audio npm package)
import { ResonanceAudio } from 'resonance-audio'

const audioContext = new AudioContext()
const scene = new ResonanceAudio(audioContext, {
  ambisonicOrder: 3,
})
scene.output.connect(audioContext.destination)

// Configure room
scene.setRoomProperties({
  width: 10,
  height: 4,
  depth: 8,
})

// Add a source
const source = scene.createSource()
source.setPosition(2, 1, 0)

// Connect an audio buffer to the source
fetch('/sounds/footstep.wav')
  .then((r) => r.arrayBuffer())
  .then((buf) => audioContext.decodeAudioData(buf))
  .then((decoded) => {
    const bufferSource = audioContext.createBufferSource()
    bufferSource.buffer = decoded
    bufferSource.connect(source.input)
    bufferSource.start()
  })

Resonance Audio still makes sense on mobile, web, and lightweight VR targets, where Steam Audio would demand desktop-class GPU compute that ARM-class devices (Snapdragon and friends) simply do not have.

6. Sony Tempest 3D AudioTech (PS5 / PS5 Pro)

Sony announced Tempest 3D AudioTech alongside the PS5 launch. The core is a custom-designed Tempest Engine — a dedicated audio coprocessor on the PS5 SoC.

Tempest Engine Hardware

  • One AMD Compute Unit dedicated to audio (PS5)
  • A more powerful unit + matrix acceleration on PS5 Pro (used for AI HRTF personalization)
  • Up to 5,000 simultaneous sound objects
  • Almost no CPU or main GPU usage

Developer View

Tempest is accessed via PS5 1st party SDKs and through Wwise / FMOD. After Sony acquired Audiokinetic in 2024, the Wwise Tempest output backend gained much deeper integration, and some 1st party studios use a private API to route Wwise straight into Tempest.

Tempest 3D vs. Dolby Atmos

ItemTempest 3DDolby Atmos
PlatformPS5 / PS5 Pro onlyXbox, PS5, PC, mobile
OutputHeadphone binaural / speakersAtmos AVR / soundbar / headphones
Object count5,000+128 dynamic objects
CertificationSony internalDolby certification required
AI HRTFSupported on PS5 ProSupported on some headphones

Showcase titles include Returnal, Demon's Souls Remake, The Last of Us Part 1, and Ghost of Tsushima Director's Cut.

7. AMD TrueAudio Next — Revived on RDNA

AMD TrueAudio first appeared on GCN 1.1 (R9 290X) in 2013, was rebranded TrueAudio Next in 2016, and was nearly forgotten by the late 2010s. It came back into focus on RDNA 4 in the 2024–2025 generation.

TrueAudio Next Core Capabilities

  • GPU-based convolution reverb — Long impulse responses (IRs) are processed via FFT convolution on the GPU.
  • Convolution reverb + ray tracing — Combined with Radeon Rays 2.0 to compute ray-traced reverb in real time.
  • Steam Audio backend — Steam Audio can use TrueAudio Next as a backend.
// Steam Audio + TrueAudio Next setup example
IPLContextSettings ctxSettings = {};
ctxSettings.version = STEAMAUDIO_VERSION;

IPLContext context = nullptr;
iplContextCreate(&ctxSettings, &context);

IPLOpenCLDeviceSettings clSettings = {};
clSettings.type = IPL_OPENCLDEVICETYPE_GPU;
clSettings.numCUsToReserve = 4;  // reserve 4 CUs on AMD GPU
clSettings.fractionCUsForIRUpdate = 0.5f;

IPLOpenCLDevice clDevice = nullptr;
iplOpenCLDeviceCreate(context, &clSettings, &clDevice);

// Now use TrueAudio Next-accelerated reflection compute
IPLRadeonRaysDeviceSettings rrSettings = {};
IPLRadeonRaysDevice rrDevice = nullptr;
iplRadeonRaysDeviceCreate(clDevice, &rrSettings, &rrDevice);

NVIDIA's Counterpart — VRWorks Audio

NVIDIA had a similar product called VRWorks Audio that used OptiX-based path tracing. NVIDIA quietly deprecated VRWorks Audio after 2022 and reallocated resources to Omniverse Audio2Face and RTX Voice.

8. Dolby Atmos for Games — Home IMAX

Dolby Atmos started as an object-based audio format for cinemas. It moved into games in 2017, and by 2026 every Xbox Series X/S, PS5 Pro, and mainstream PC officially supports Dolby Atmos for Headphones and Speakers.

Atmos for Games Core

  • 128 dynamic objects — Each carries (x, y, z) coordinates and a wav stream.
  • Bed + objects — Channel-based bed (7.1.4, etc.) plus objects painted on top.
  • Rendering decoupling — The game emits object metadata; the headphone, AVR, or soundbar does the final rendering.

Activating Atmos Directly

// Windows Spatial Audio API (XAudio2 / WASAPI)
#include <SpatialAudioClient.h>

ISpatialAudioClient* spatialAudioClient = nullptr;
// ... activate the device ...

SpatialAudioObjectRenderStreamActivationParams streamParams = {};
streamParams.ObjectFormat = WAVEFORMATEX_FOR_48KHZ_FLOAT_MONO;
streamParams.StaticObjectTypeMask = AudioObjectType_None;
streamParams.MinDynamicObjectCount = 0;
streamParams.MaxDynamicObjectCount = 128;
streamParams.Category = AudioCategory_GameEffects;

ISpatialAudioObjectRenderStream* renderStream = nullptr;
spatialAudioClient->ActivateSpatialAudioStream(
    &streamParams,
    __uuidof(ISpatialAudioObjectRenderStream),
    (void**)&renderStream);

// Spawn objects dynamically and position them
ISpatialAudioObject* audioObject = nullptr;
renderStream->ActivateSpatialAudioObject(AudioObjectType_Dynamic, &audioObject);
audioObject->SetPosition(2.0f, 1.5f, -3.0f);
audioObject->SetVolume(0.8f);

Wwise and FMOD both ship Atmos backends so you do not have to call this API directly. Selecting "Atmos Object" on a bus output automatically delegates to the API above.

Atmos for Games Titles

Halo Infinite, Forza Horizon 5, Gears 5, Diablo IV, Battlefield 2042, Resident Evil 4 Remake, and Spider-Man 2 PC all ship with Atmos.

9. Unity Audio Mixer + Wwise / FMOD Integration

Unity ships its own Audio Mixer. It is good enough for small projects and mobile, but as sound design grows in complexity teams migrate to Wwise or FMOD.

Unity Audio Mixer Basics

  • AudioSource to AudioMixerGroup to AudioListener routing
  • Snapshot — A preset of mixer state (menu, gameplay, cutscene)
  • Exposed Parameter — Volume, pitch, and EQ controlled from external scripts
  • Send / Receive — Bus routing

When Unity Audio Mixer Is Enough

  • Fewer than 200 sound cues
  • A single platform (mobile)
  • Modest 3D spatial audio needs
  • No need for object-based output like Atmos or Tempest

Signals That You Should Move to Wwise / FMOD

  • Sound designer and coder are separate roles, and a DAW-style UI is needed
  • Shipping on multiple consoles, mobile, and VR at once
  • More than 1,000 sound instances to manage
  • A/B sound testing and real-time parameter automation
// Unity Audio Mixer baseline usage
using UnityEngine;
using UnityEngine.Audio;

public class MixerController : MonoBehaviour
{
    public AudioMixer mixer;

    public void SetMasterVolume(float volume)
    {
        // -80dB to 0dB
        float db = volume > 0.0001f ? Mathf.Log10(volume) * 20f : -80f;
        mixer.SetFloat("MasterVolume", db);
    }

    public void TransitionToCombatSnapshot()
    {
        var combat = mixer.FindSnapshot("Combat");
        combat.TransitionTo(0.5f);  // 0.5s crossfade
    }
}

10. Unreal MetaSounds — Replacing SoundCue

Epic shipped MetaSounds in Unreal 5.0 and deprecated the SoundCue workflow in 5.4–5.5. As of 2026, Unreal 5.6/5.7 projects default to MetaSounds.

How MetaSounds Differ

SoundCue was a graph of high-level pre-defined nodes (Random, Mixer, etc.). MetaSounds are sample-level DSP graphs. You can implement wavetable synthesis, FM, granular synthesis, and real-time pitch shifting directly inside the engine.

Comparison

ItemSoundCue (legacy)MetaSounds (2026)
Graph granularitySound cue (event level)Sample (DSP level)
Procedural soundHardBuilt-in (oscillator, filter nodes)
Live updateLimitedEditor-to-game live link
External middlewareWwise / FMOD recommendedOften self-sufficient
C++ extensionHardSubclass MetaSound Node

MetaSounds C++ Node Example

// A simple saw-wave oscillator MetaSound node
#include "MetasoundFacade.h"
#include "MetasoundNodeRegistrationMacro.h"

namespace Metasound
{
    class FSawOscillatorOperator : public TExecutableOperator<FSawOscillatorOperator>
    {
    public:
        static const FNodeClassMetadata& GetNodeInfo();
        static const FVertexInterface& GetVertexInterface();

        FSawOscillatorOperator(const FOperatorSettings& InSettings,
                               const FFloatReadRef& InFrequency)
            : Frequency(InFrequency)
            , Phase(0.0f)
            , SampleRate(InSettings.GetSampleRate())
        {
        }

        void Execute()
        {
            const float freq = *Frequency;
            const float dt = 1.0f / SampleRate;
            for (int32 i = 0; i < AudioBuffer->Num(); i++)
            {
                (*AudioBuffer)[i] = 2.0f * Phase - 1.0f;
                Phase += freq * dt;
                if (Phase >= 1.0f) Phase -= 1.0f;
            }
        }

    private:
        FFloatReadRef Frequency;
        FAudioBufferWriteRef AudioBuffer;
        float Phase;
        float SampleRate;
    };
}

METASOUND_REGISTER_NODE(Metasound::FSawOscillatorNode)

MetaSounds shine for procedural sound (alien creature vocals, jet engines, magic missile sounds). Most of the new weapon sounds in Fortnite Battle Royale are now built with MetaSounds.

11. OpenAL Soft — Open-Source 3D Audio

OpenAL was originally pitched in the early 2000s as the audio counterpart to OpenGL. Creative Labs led the spec, but by the 2010s the maintenance was on life support. OpenAL Soft (maintained by kcat) stepped in, and by 2026 it is the de facto standard OpenAL implementation.

Why OpenAL Soft Is Attractive

  • LGPL license — Free for commercial use as long as you do not statically link
  • Cross-platform — Windows, Linux, macOS, Android, BSD
  • HRTF built in — Uses public HRTF datasets like IRC and MIT KEMAR
  • Ambisonic support — 1st through 3rd-order ambisonic output
  • EFX extension — Reverb, chorus, distortion, and other DSP effects

OpenAL Soft Example — C

// Baseline OpenAL Soft usage
#include <AL/al.h>
#include <AL/alc.h>

ALCdevice* device = alcOpenDevice(nullptr);
ALCcontext* context = alcCreateContext(device, nullptr);
alcMakeContextCurrent(context);

// Enable HRTF (OpenAL Soft extension)
ALCint attribs[] = {
    ALC_HRTF_SOFT, ALC_TRUE,
    ALC_HRTF_ID_SOFT, 0,  // use first HRTF
    0
};
alcResetDeviceSOFT(device, attribs);

// Listener position
alListener3f(AL_POSITION, 0.0f, 0.0f, 0.0f);
ALfloat orientation[] = { 0.0f, 0.0f, -1.0f,  0.0f, 1.0f, 0.0f };
alListenerfv(AL_ORIENTATION, orientation);

// Source
ALuint source;
alGenSources(1, &source);
alSource3f(source, AL_POSITION, 5.0f, 0.0f, 0.0f);
alSourcef(source, AL_GAIN, 1.0f);

// Fill a buffer with wav data...
ALuint buffer;
alGenBuffers(1, &buffer);
alBufferData(buffer, AL_FORMAT_MONO16, pcmData, dataSize, sampleRate);

alSourcei(source, AL_BUFFER, (ALint)buffer);
alSourcePlay(source);

OpenAL Soft is used by classics like Doom 3, Quake 4, and Minecraft, all the way through to a swath of modern indie titles. It is a sane choice for small projects where Wwise and FMOD are overkill.

12. Csound + Game Integration — Academic Meets Experimental

Csound is an open-source sound synthesis and DSP language that originated at MIT in 1985. It is the de facto standard for academic and computer music research, but it has rarely been used in games. The 2020s changed that: as demand for procedural sound and experimental sound design grew, Csound embedding has come back onto the radar.

Csound API Example

// Embedding Csound in C++
#include <csound/csound.hpp>

class CsoundEngine
{
    Csound* csound;
public:
    void init()
    {
        csound = new Csound();
        csound->SetOption("-odac");      // output to DAC
        csound->SetOption("--realtime"); // real-time mode

        // Load CSD (Csound document)
        const char* orc =
            "sr = 48000\n"
            "kr = 4800\n"
            "ksmps = 10\n"
            "nchnls = 2\n"
            "instr 1\n"
            "  iamp = p4\n"
            "  ifreq = p5\n"
            "  a1 oscili iamp, ifreq, 1\n"
            "  outs a1, a1\n"
            "endin\n";

        csound->CompileOrc(orc);
        csound->Start();
    }

    void playNote(float amp, float freq, float duration)
    {
        char score[128];
        snprintf(score, sizeof(score), "i 1 0 %f %f %f", duration, amp, freq);
        csound->ReadScore(score);
    }

    void update()
    {
        csound->PerformKsmps();
    }
};

Csound is useful for interactive music systems where the music evolves with player behavior, and it occasionally shows up in experimental indie titles and sound-art works.

13. Spatial Audio Concepts — Occlusion / Reverb / HRTF / Ray Tracing

13.1 HRTF (Head-Related Transfer Function)

HRTF mathematically models how the two ears hear differently depending on the direction of the source. The diffraction, reflection, and shadowing produced by the head, shoulders, and outer ear are encoded as filters in the Fourier domain.

  • Left ear signal = source signal * HRIR_left(direction)
  • Right ear signal = source signal * HRIR_right(direction)

The * operator here is convolution. Public HRIR datasets (MIT KEMAR, IRCAM Listen, CIPIC) are used by Steam Audio, OpenAL Soft, and Resonance Audio.

13.2 Occlusion

A source behind a wall has its direct path blocked or attenuated. The simplest implementation is a single raycast.

// Simple occlusion implementation
Vector3 dir = source.position - listener.position;
float dist = dir.magnitude;
if (Physics.Raycast(listener.position, dir.normalized, out RaycastHit hit, dist))
{
    // Wall present - apply low-pass filter
    float occlusionAmount = 1.0f - (hit.distance / dist);
    audioSource.outputAudioMixerGroup.audioMixer.SetFloat(
        "Cutoff", Mathf.Lerp(22000f, 500f, occlusionAmount));
}

A more sophisticated implementation traces diffraction paths around the obstacle to model partial occlusion. Steam Audio offers path-traced occlusion out of the box.

13.3 Reverb Zones and Late Reverb

Room reverb is modeled in two stages:

  • Early reflections — The first 50ms or so of 1st- to 3rd-order reflections. Critical for perceiving room size and shape.
  • Late reverb — Diffuse energy after that point. Usually modeled statistically (T60, EDC).

Steam Audio, Wwise, and FMOD all separate early and late processing. In games, you usually drop reverb zones per room: when the listener enters a zone, its reverb preset activates.

13.4 Ray-Traced Audio

NVIDIA OptiX, Intel Embree, and AMD Radeon Rays can all compute the acoustic ray paths. Steam Audio uses Embree as its default, and AMD TrueAudio Next uses Radeon Rays 2.0.

Acoustic ray tracing diagram

  Source ●────────────────●  Listener
          \              /
           \────[wall]───/    ← 1st-order reflection
            \           /
             \────●────/      ← 2nd-order reflection
                  |
                  ●─────────  ← diffraction

For each path:
  - Distance → delay time
  - Material → absorption coefficient (low-pass)
  - Angle    → HRTF index

14. Spatial Audio Standards — MPEG-H Audio and Atmos

MPEG-H Audio (3D Audio)

MPEG-H is ISO/IEC 23008-3, unifying object-, channel-, and scene-based audio.

  • Used by some Korean, Japanese, and European broadcast standards (KBS UHD, NHK 8K)
  • The audio codec for DVB and ATSC 3.0
  • Adoption in games is low; Sony has experimented with MPEG-H for some PSVR2 content.

Dolby Atmos (object-based)

  • Recommended for Xbox Series X/S 1st party
  • Activated on PS5 Pro headphone output
  • Requires Dolby certification (developers partner with Dolby)

Auro-3D / DTS:X

  • Cinema and AV receiver-centric
  • Game adoption remains marginal

In 2026, Dolby Atmos is the de facto object-based audio standard on game consoles, with MPEG-H carving out specific broadcast niches in Japan and Korea.

15. DSP Plugins — The Sound Designer's Toolbox

Game sound designers craft sounds in a DAW before they ever reach middleware. Here are the DSP plugins they reach for.

NewFangled Audio (an Eventide brand)

  • Elevate — Multiband intelligent limiter. Common on AAA game masters.
  • Generate — Procedural sound synthesizer. Useful for alien creature and fantasy SFX.
  • Pendulate — Chaos synthesizer for non-linear and unconventional sounds.

Eventide

  • Blackhole — Infinite reverb. The go-to for cosmic and abstract spaces.
  • H9 Plugins — Pitch / time / modulation classics.

FabFilter

  • Pro-Q 4 — Effectively the standard EQ in game audio
  • Pro-L 2 — Master limiter
  • Pro-R 2 — Algorithmic reverb
  • Pro-MB — Multiband compressor

Soundtoys

  • Decapitator — Saturation and distortion
  • EchoBoy — Classic digital and tape echo
  • Crystallizer — Granular pitch shifting

iZotope

  • RX 11 — Sound restoration and cleaning (essential for field recording post)
  • Ozone 11 — Mastering
  • Iris 2 — Spectral synthesizer

These tools produce wavs that get triggered and modulated from inside Wwise or FMOD. The dividing line is clean: DSP plugins are asset-creation tools; middleware are runtime asset-control tools.

16. Korea and Japan — Studio-by-Studio Audio Pipelines

Korea (as of 2026)

Nexon

  • MapleStory, Dungeon & Fighter, KartRider Drift all use Wwise plus internal libraries
  • Some mobile titles use FMOD Studio + Unity Audio Mixer
  • MapleStory Worlds is experimenting with Steam Audio-based spatial audio

NCSOFT

  • Lineage W and TL use Wwise + Atmos for Games
  • Some legacy projects still carry their internal sound engine from the Project K era
  • AI-driven voice synthesis research (PROJECT M synthetic voice)

Kakao Games / Pearl Abyss

  • Black Desert and Crimson Desert use Wwise plus an in-house reverb engine
  • Pearl Abyss has an internal acoustic R&D team and uses some proprietary middleware components

Smilegate

  • Crossfire and Lost Ark use FMOD Studio
  • Lord Nine pairs Wwise with Steam Audio

Japan (as of 2026)

Sony Interactive Entertainment

  • All 1st party subsidiaries (Naughty Dog, Insomniac, Guerrilla, Sucker Punch, Polyphony Digital) use Wwise + Tempest 3D
  • License costs eased after the Audiokinetic acquisition
  • Polyphony Digital uses granular synthesis plus proprietary algorithms for engine sound in the Gran Turismo series

Square Enix

  • Final Fantasy 16 / 17 use Wwise
  • Forspoken used ADX (Criware), a Japanese middleware
  • Some mobile titles (FFBE, FF7EC) use FMOD

Capcom

  • The RE Engine plus ADX2 (Criware) is the standard combo
  • Resident Evil, Monster Hunter Wilds, Street Fighter 6 all use ADX2
  • Dolby Atmos for Games supported

Bandai Namco

  • Tekken 8 uses a proprietary sound engine plus some Wwise
  • Elden Ring (co-developed with FromSoftware) uses Wwise

Sega

  • Sonic Frontiers, Like a Dragon: Infinite Wealth use Wwise plus internal libraries
  • Sega Sound Engineering has an internal procedural sound system research team

Criware ADX — The third major middleware after Wwise and FMOD in Japanese game development. Big in Japanese mobile and console markets, almost invisible in Korea and the West.

17. Who Should Choose What — Decision Matrix

Indie (1 to 5 people, tight budget)

PickWhy
FMOD StudioFree tier + DAW-style UI
Unity Audio MixerMobile / simple 2D games
Unreal MetaSoundsUsing Unreal + procedural sound
OpenAL Soft + custom codeLearning purposes / writing your own engine

Small/Mid Studio (10 to 50 people, original IP)

PickWhy
Wwise (small license)Scalability + multi-platform console
FMOD Studio + Steam AudioLicense savings + VR support
MetaSounds + Steam AudioAll-in on Unreal

AAA / Major Console Titles

PickWhy
Wwise + Tempest 3D / AtmosTightest integration after the Sony acquisition
Wwise + Steam Audio + AtmosIntegrated PC / Xbox / PS5
Capcom pattern (RE Engine + ADX2)Japanese market

VR / AR

PickWhy
Steam Audio + Wwise/FMODHRTF + spatial audio standard
Resonance AudioMobile VR / WebXR
Sony Tempest 3DPSVR2 exclusive

Mobile

PickWhy
FMOD Studio + UnityCommon ground for iOS / Android
Wwise (indie free tier)Unify middleware across platforms
Resonance AudioMobile VR / 360 video

Web / Browser Games

PickWhy
Web Audio API + Resonance AudioStandard + ambisonic
Howler.jsSimple 2D games
WebXR + ResonanceBrowser VR

Closing — The 2026 Workflow

The 2026 game audio workflow looks like this:

  1. Sound designer crafts wavs in Reaper / Pro Tools with FabFilter / Soundtoys / iZotope
  2. Technical sound designer designs events, RTPCs, and snapshots in Wwise / FMOD / MetaSounds
  3. Spatial audio owner configures Steam Audio / Resonance / Tempest 3D / Atmos
  4. Programmers trigger events and update RTPCs from C++ / C# code
  5. QA verifies on headphones / Atmos soundbars / multiple platforms

Compared to a decade ago, the game audio middleware market is both more diverse (Steam Audio open-sourcing) and more consolidated (Sony's acquisition of Audiokinetic). Indies can use AAA-class sound tools for free, and AAA studios routinely deploy ray-traced reverb and object-based audio.

The next decade's headline issue will be AI-generated sound (Adobe Project Music GenAI, Stable Audio 2) coupled with procedural sound. EA, Ubisoft, and Sony are already running AI sound synthesis R&D internally, and some NPC voices are starting to be synthesized.

References

Discuss on Twitter • View on GitHub