AcoustX

Two headers. One contract.

acoustx/listener.h is the native surface: listener-out rendering, where the implementation traces, assembles the impulse response, and delivers ear-ready audio. acoustx/compat.h is the migration shim: source-out semantics matching the Steam-Audio-era model, where the title still owns its mix and the hardware accelerates what it can. Both link the same binary. Both hit the same Traversal Engine.

The split is principled, not promotional: everything listener-only exists downstream of the impulse response — and in the source-out model, the title, not the implementation, owns that stage. The moment an engine hands over the listener, the rest of the pipeline lights up.

The same engine sound, both ways.

One emitter, registered through each header. The native path hands the listener to the implementation and receives ear-ready output; the compat path keeps the title's own mixer and receives per-source filtered buffers — with hardware traversal already applied.

#include <acoustx/listener.h>          /* native listener-out surface */

acxScene*    scene    = acxSceneCreate(ACX_SCENE_FROM_TLAS);
acxListener* listener = acxListenerCreate(scene, &(acxListenerDesc){
    .headRadiusM = 0.0875f,                /* BDU runtime parameter  */
    .hrtfProfile = ACX_HRTF_DEVICE_DEFAULT,
});

acxSource* engine = acxSourceRegister(scene, &(acxSourceDesc){
    .position    = { 4.2f, 1.1f, -7.6f },
    .directivity = ACX_DIRECTIVITY_CARDIOID_SH,
    .bands       = ACX_BANDS_OCTAVE_8,
});

while (running) {
    acxSourceSetPosition(engine, world.enginePos);
    acxListenerSetPose(listener, cam.pos, cam.orient);
    acxSceneCommit(scene);     /* IR lands within one audio block */
}

#include <acoustx/compat.h>            /* source-out shim, Steam-Audio-era */

acxCompatContext* ctx = acxCompatInit(NULL);

acxCompatSource* engine = acxCompatAddSource(ctx, &(acxCompatSourceDesc){
    .position  = { 4.2f, 1.1f, -7.6f },
    .falloff   = ACX_COMPAT_FALLOFF_INVERSE,
    .occlusion = ACX_COMPAT_OCCLUSION_RAYCAST,
});

while (running) {
    acxCompatSetSourcePos(engine, world.enginePos);
    acxCompatSetListener(ctx, cam.pos, cam.orient);

    /* source-out: the title mixes. Hardware traversal, distance,
       air absorption and materials are already in the buffers.  */
    acxCompatProcess(ctx, inBufs, outBufs, frames);
}

Recompile first. Believe later.

AcoustX was specified so that adoption never requires an audio-engine rewrite. The path is a cascade, and every stage ships.

Compat vs. native, measured.

The same content ported both ways through the same implementation (Sonoral, Core 500 tier). This comparison is a property of the API split, not of any one vendor's silicon — which is why it lives on this page.

Read the second row twice: the shim isn't a degraded mode, it's the same output for a twentieth of the power. The native premium buys physics the software path never had at any power.