From 3c0c6d64ca0cfd81d839128c8503678a16d6db79 Mon Sep 17 00:00:00 2001
From: Rokas Puzonas <rokas.puz@gmail.com>
Date: Sat, 17 Jan 2026 10:45:24 +0200
Subject: [PATCH] add audio subsystem

---
 README.md                                     |   5 +
 build.zig                                     |  11 +-
 build.zig.zon                                 |   4 +-
 libs/stb/build.zig                            |  38 ++++
 libs/{stb_image => stb}/build.zig.zon         |   0
 .../src/root.zig => stb/src/stb_image.zig}    |   0
 libs/{stb_image => stb}/src/stb_image_impl.c  |   0
 libs/stb/src/stb_vorbis.zig                   | 170 ++++++++++++++++++
 libs/stb/src/stb_vorbis_impl.c                |   3 +
 libs/stb_image/build.zig                      |  31 ----
 src/assets.zig                                |  22 ++-
 src/assets/wood01.ogg                         | Bin 0 -> 8569 bytes
 src/assets/wood02.ogg                         | Bin 0 -> 8672 bytes
 src/assets/wood03.ogg                         | Bin 0 -> 9832 bytes
 src/engine/audio/data.zig                     |  64 +++++++
 src/engine/audio/mixer.zig                    | 131 ++++++++++++++
 src/engine/audio/root.zig                     | 100 +++++++++++
 src/engine/audio/store.zig                    | 106 +++++++++++
 src/engine/root.zig                           |  11 +-
 src/game.zig                                  |  11 ++
 20 files changed, 662 insertions(+), 45 deletions(-)
 create mode 100644 libs/stb/build.zig
 rename libs/{stb_image => stb}/build.zig.zon (100%)
 rename libs/{stb_image/src/root.zig => stb/src/stb_image.zig} (100%)
 rename libs/{stb_image => stb}/src/stb_image_impl.c (100%)
 create mode 100644 libs/stb/src/stb_vorbis.zig
 create mode 100644 libs/stb/src/stb_vorbis_impl.c
 delete mode 100644 libs/stb_image/build.zig
 create mode 100644 src/assets/wood01.ogg
 create mode 100644 src/assets/wood02.ogg
 create mode 100644 src/assets/wood03.ogg
 create mode 100644 src/engine/audio/data.zig
 create mode 100644 src/engine/audio/mixer.zig
 create mode 100644 src/engine/audio/root.zig
 create mode 100644 src/engine/audio/store.zig

diff --git a/README.md b/README.md
index 54b01d0..51fb2d6 100644
--- a/README.md
+++ b/README.md
@@ -20,6 +20,11 @@ zig build -Dtarget=x86_64-windows
 ## TODO
 
 * Use [Skribidi](https://github.com/memononen/Skribidi) instead of fontstash for text rendering
+* Support for audio formats (Might not need all of them, haven't decided):
+  * QOA, maybe [qoa.h](https://github.com/phoboslab/qoa/blob/master/qoa.h)?
+  * Flac, maybe [dr_flac.h](https://github.com/mackron/dr_libs/blob/master/dr_flac.h)?
+  * Wav, maybe [dr_wav.h](https://github.com/mackron/dr_libs/blob/master/dr_wav.h)?
+  * Mp3, maybe [dr_mp3.h](https://github.com/mackron/dr_libs/blob/master/dr_mp3.h)?
 * Gamepad support.
   * WASM Support. Currently a build config isn't provided for this target.
   * Update build config for other platforms to reduce binary size. All of the video and audio drivers aren't needed, only gamepads
diff --git a/build.zig b/build.zig
index 3693756..004e8b7 100644
--- a/build.zig
+++ b/build.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const cimgui = @import("cimgui");
 const sokol = @import("sokol");
 const builtin = @import("builtin");
 
@@ -24,7 +23,6 @@ pub fn build(b: *std.Build) !void {
         .link_libc = true
     });
 
-    const cimgui_conf = cimgui.getConfig(false);
     const dep_sokol = b.dependency("sokol", .{
         .target = target,
         .optimize = optimize,
@@ -38,6 +36,8 @@ pub fn build(b: *std.Build) !void {
             .target = target,
             .optimize = optimize,
         })) |dep_cimgui| {
+            const cimgui = b.lazyImport(@This(), "cimgui").?;
+            const cimgui_conf = cimgui.getConfig(false);
             mod_main.addImport("cimgui", dep_cimgui.module(cimgui_conf.module_name));
             dep_sokol.artifact("sokol_clib").addIncludePath(dep_cimgui.path(cimgui_conf.include_dir));
         }
@@ -57,8 +57,9 @@ pub fn build(b: *std.Build) !void {
     const dep_tiled = b.dependency("tiled", .{});
     mod_main.addImport("tiled", dep_tiled.module("tiled"));
 
-    const dep_stb_image = b.dependency("stb_image", .{});
-    mod_main.addImport("stb_image", dep_stb_image.module("stb_image"));
+    const dep_stb = b.dependency("stb", .{});
+    mod_main.addImport("stb_image", dep_stb.module("stb_image"));
+    mod_main.addImport("stb_vorbis", dep_stb.module("stb_vorbis"));
 
     const dep_fontstash_c = b.dependency("fontstash_c", .{});
     mod_main.addIncludePath(dep_fontstash_c.path("src"));
@@ -106,7 +107,6 @@ pub fn build(b: *std.Build) !void {
             .name = "sokol_template",
             .mod_main = mod_main,
             .dep_sokol = dep_sokol,
-            .cimgui_clib_name = cimgui_conf.clib_name,
         });
     } else {
         try buildNative(b, "sokol_template", mod_main, has_console);
@@ -169,7 +169,6 @@ const BuildWasmOptions = struct {
     name: []const u8,
     mod_main: *std.Build.Module,
     dep_sokol: *std.Build.Dependency,
-    cimgui_clib_name: []const u8,
 };
 
 fn patchWasmIncludeDirs(
diff --git a/build.zig.zon b/build.zig.zon
index 24484e4..0aee37a 100644
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -28,8 +28,8 @@
         .tiled = .{
             .path = "./libs/tiled",
         },
-        .stb_image = .{
-            .path = "./libs/stb_image",
+        .stb = .{
+            .path = "./libs/stb",
         },
         // .sdl = .{
         //     .url = "git+https://github.com/allyourcodebase/SDL3.git#f85824b0db782b7d01c60aaad8bcb537892394e8",
diff --git a/libs/stb/build.zig b/libs/stb/build.zig
new file mode 100644
index 0000000..963b76f
--- /dev/null
+++ b/libs/stb/build.zig
@@ -0,0 +1,38 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const stb_dependency = b.dependency("stb", .{});
+
+    {
+        const mod_stb_image = b.addModule("stb_image", .{
+            .target = target,
+            .optimize = optimize,
+            .root_source_file = b.path("src/stb_image.zig"),
+            .link_libc = true,
+        });
+
+        mod_stb_image.addIncludePath(stb_dependency.path("."));
+        mod_stb_image.addCSourceFile(.{
+            .file = b.path("src/stb_image_impl.c"),
+            .flags = &.{}
+        });
+    }
+
+    {
+        const mod_stb_image = b.addModule("stb_vorbis", .{
+            .target = target,
+            .optimize = optimize,
+            .root_source_file = b.path("src/stb_vorbis.zig"),
+            .link_libc = true,
+        });
+
+        mod_stb_image.addIncludePath(stb_dependency.path("."));
+        mod_stb_image.addCSourceFile(.{
+            .file = b.path("src/stb_vorbis_impl.c"),
+            .flags = &.{}
+        });
+    }
+}
diff --git a/libs/stb_image/build.zig.zon b/libs/stb/build.zig.zon
similarity index 100%
rename from libs/stb_image/build.zig.zon
rename to libs/stb/build.zig.zon
diff --git a/libs/stb_image/src/root.zig b/libs/stb/src/stb_image.zig
similarity index 100%
rename from libs/stb_image/src/root.zig
rename to libs/stb/src/stb_image.zig
diff --git a/libs/stb_image/src/stb_image_impl.c b/libs/stb/src/stb_image_impl.c
similarity index 100%
rename from libs/stb_image/src/stb_image_impl.c
rename to libs/stb/src/stb_image_impl.c
diff --git a/libs/stb/src/stb_vorbis.zig b/libs/stb/src/stb_vorbis.zig
new file mode 100644
index 0000000..ea25583
--- /dev/null
+++ b/libs/stb/src/stb_vorbis.zig
@@ -0,0 +1,170 @@
+const std = @import("std");
+const assert = std.debug.assert;
+const log = std.log.scoped(.stb_vorbis);
+
+const c = @cImport({
+    @cDefine("STB_VORBIS_NO_INTEGER_CONVERSION", {});
+    @cDefine("STB_VORBIS_NO_STDIO", {});
+    @cDefine("STB_VORBIS_HEADER_ONLY", {});
+    @cInclude("stb_vorbis.c");
+});
+
+const STBVorbis = @This();
+
+pub const Error = error {
+    NeedMoreData,
+    InvalidApiMixing,
+    OutOfMemory,
+    FeatureNotSupported,
+    TooManyChannels,
+    FileOpenFailure,
+    SeekWithoutLength,
+    UnexpectedEof,
+    SeekInvalid,
+    InvalidSetup,
+    InvalidStream,
+    MissingCapturePattern,
+    InvalidStreamStructureVersion,
+    ContinuedPacketFlagInvalid,
+    IncorrectStreamSerialNumber,
+    InvalidFirstPage,
+    BadPacketType,
+    CantFindLastPage,
+    SeekFailed,
+    OggSkeletonNotSupported,
+
+    Unknown
+};
+
+fn errorFromInt(err: c_int) ?Error {
+    return switch (err) {
+        c.VORBIS__no_error => null,
+        c.VORBIS_need_more_data => Error.NeedMoreData,
+        c.VORBIS_invalid_api_mixing => Error.InvalidApiMixing,
+        c.VORBIS_outofmem => Error.OutOfMemory,
+        c.VORBIS_feature_not_supported => Error.FeatureNotSupported,
+        c.VORBIS_too_many_channels => Error.TooManyChannels,
+        c.VORBIS_file_open_failure => Error.FileOpenFailure,
+        c.VORBIS_seek_without_length => Error.SeekWithoutLength,
+        c.VORBIS_unexpected_eof => Error.UnexpectedEof,
+        c.VORBIS_seek_invalid => Error.SeekInvalid,
+        c.VORBIS_invalid_setup => Error.InvalidSetup,
+        c.VORBIS_invalid_stream => Error.InvalidStream,
+        c.VORBIS_missing_capture_pattern => Error.MissingCapturePattern,
+        c.VORBIS_invalid_stream_structure_version => Error.InvalidStreamStructureVersion,
+        c.VORBIS_continued_packet_flag_invalid => Error.ContinuedPacketFlagInvalid,
+        c.VORBIS_incorrect_stream_serial_number => Error.IncorrectStreamSerialNumber,
+        c.VORBIS_invalid_first_page => Error.InvalidFirstPage,
+        c.VORBIS_bad_packet_type => Error.BadPacketType,
+        c.VORBIS_cant_find_last_page => Error.CantFindLastPage,
+        c.VORBIS_seek_failed => Error.SeekFailed,
+        c.VORBIS_ogg_skeleton_not_supported => Error.OggSkeletonNotSupported,
+        else => Error.Unknown
+    };
+}
+
+handle: *c.stb_vorbis,
+
+pub fn init(data: []const u8, alloc_buffer: []u8) Error!STBVorbis {
+    const stb_vorbis_alloc: c.stb_vorbis_alloc = .{
+        .alloc_buffer = alloc_buffer.ptr,
+        .alloc_buffer_length_in_bytes = @intCast(alloc_buffer.len)
+    };
+    var error_code: c_int = -1;
+    const handle = c.stb_vorbis_open_memory(
+        data.ptr,
+        @intCast(data.len),
+        &error_code,
+        &stb_vorbis_alloc
+    );
+    if (handle == null) {
+        return errorFromInt(error_code) orelse Error.Unknown;
+    }
+
+    return STBVorbis{
+        .handle = handle.?
+    };
+}
+
+pub fn getMinimumAllocBufferSize(self: STBVorbis) u32 {
+    const info = self.getInfo();
+    return info.setup_memory_required + @max(info.setup_temp_memory_required, info.temp_memory_required);
+}
+
+fn getLastError(self: STBVorbis) ?Error {
+    const error_code = c.stb_vorbis_get_error(self.handle);
+    return errorFromInt(error_code);
+}
+
+pub fn seek(self: STBVorbis, sample_number: u32) !void {
+    const success = c.stb_vorbis_seek(self.handle, sample_number);
+    if (success != 1) {
+        return self.getLastError() orelse Error.Unknown;
+    }
+}
+
+pub fn getStreamLengthInSamples(self: STBVorbis) u32 {
+    return c.stb_vorbis_stream_length_in_samples(self.handle);
+}
+
+pub fn getStreamLengthInSeconds(self: STBVorbis) f32 {
+    return c.stb_vorbis_stream_length_in_seconds(self.handle);
+}
+
+pub fn getSamples(
+    self: STBVorbis,
+    channels: []const [*]f32,
+    max_samples_per_channel: u32
+) u32 {
+    const samples_per_channel = c.stb_vorbis_get_samples_float(
+        self.handle,
+        @intCast(channels.len),
+        @constCast(@ptrCast(channels.ptr)),
+        @intCast(max_samples_per_channel)
+    );
+    return @intCast(samples_per_channel);
+}
+
+const Frame = struct {
+    channels: []const [*c]const f32,
+    samples_per_channel: u32
+};
+
+pub fn getFrame(self: STBVorbis) Frame {
+    var output: [*c][*c]f32 = null;
+    var channels: c_int = undefined;
+    const samples_per_channel = c.stb_vorbis_get_frame_float(
+        self.handle,
+        &channels,
+        &output
+    );
+    return Frame{
+        .channels = output[0..@intCast(channels)],
+        .samples_per_channel = @intCast(samples_per_channel)
+    };
+}
+
+pub const Info = struct {
+    sample_rate: u32,
+    channels: u32,
+
+    setup_memory_required: u32,
+    setup_temp_memory_required: u32,
+    temp_memory_required: u32,
+
+    max_frame_size: u32
+};
+
+pub fn getInfo(self: STBVorbis) Info {
+    const info = c.stb_vorbis_get_info(self.handle);
+    return Info{
+        .sample_rate = info.sample_rate,
+        .channels = @intCast(info.channels),
+
+        .setup_memory_required = info.setup_memory_required,
+        .setup_temp_memory_required = info.setup_temp_memory_required,
+        .temp_memory_required = info.temp_memory_required,
+
+        .max_frame_size = @intCast(info.max_frame_size),
+    };
+}
diff --git a/libs/stb/src/stb_vorbis_impl.c b/libs/stb/src/stb_vorbis_impl.c
new file mode 100644
index 0000000..4a53456
--- /dev/null
+++ b/libs/stb/src/stb_vorbis_impl.c
@@ -0,0 +1,3 @@
+#define STB_VORBIS_NO_INTEGER_CONVERSION
+#define STB_VORBIS_NO_STDIO
+#include "stb_vorbis.c"
diff --git a/libs/stb_image/build.zig b/libs/stb_image/build.zig
deleted file mode 100644
index 970e6ca..0000000
--- a/libs/stb_image/build.zig
+++ /dev/null
@@ -1,31 +0,0 @@
-const std = @import("std");
-
-pub fn build(b: *std.Build) void {
-    const target = b.standardTargetOptions(.{});
-    const optimize = b.standardOptimizeOption(.{});
-
-    const mod = b.addModule("stb_image", .{
-        .target = target,
-        .optimize = optimize,
-        .root_source_file = b.path("src/root.zig"),
-        .link_libc = true,
-    });
-
-    const stb_dependency = b.dependency("stb", .{});
-    mod.addIncludePath(stb_dependency.path("."));
-    mod.addCSourceFile(.{
-        .file = b.path("src/stb_image_impl.c"),
-        .flags = &.{}
-    });
-
-    {
-        const tests = b.addTest(.{
-            .root_module = mod
-        });
-
-        const run_tests = b.addRunArtifact(tests);
-
-        const test_step = b.step("test", "Run tests");
-        test_step.dependOn(&run_tests.step);
-    }
-}
diff --git a/src/assets.zig b/src/assets.zig
index 010e749..8ea3e31 100644
--- a/src/assets.zig
+++ b/src/assets.zig
@@ -1,5 +1,9 @@
 const std = @import("std");
-const Gfx = @import("./engine/graphics.zig");
+
+const Math =  @import("./engine/math.zig");
+const Engine = @import("./engine/root.zig");
+const Gfx = Engine.Graphics;
+const Audio = Engine.Audio;
 
 const Assets = @This();
 
@@ -13,18 +17,28 @@ const FontName = enum {
 
 font_id: FontName.EnumArray,
 
-pub fn init() !Assets {
+wood01: Audio.Data.Id,
+
+pub fn init(gpa: std.mem.Allocator) !Assets {
+    _ = gpa; // autofix
     const font_id_array: FontName.EnumArray = .init(.{
         .regular = try Gfx.addFont("regular", @embedFile("assets/roboto-font/Roboto-Regular.ttf")),
         .bold = try Gfx.addFont("bold", @embedFile("assets/roboto-font/Roboto-Bold.ttf")),
         .italic = try Gfx.addFont("italic", @embedFile("assets/roboto-font/Roboto-Italic.ttf")),
     });
 
+    const wood01 = try Audio.load(.{
+        .format = .vorbis,
+        .data = @embedFile("assets/wood01.ogg"),
+    });
+
     return Assets{
-        .font_id = font_id_array
+        .font_id = font_id_array,
+        .wood01 = wood01
     };
 }
 
-pub fn deinit(self: *Assets) void {
+pub fn deinit(self: *Assets, gpa: std.mem.Allocator) void {
     _ = self; // autofix
+    _ = gpa; // autofix
 }
diff --git a/src/assets/wood01.ogg b/src/assets/wood01.ogg
new file mode 100644
index 0000000000000000000000000000000000000000..be5a4094b6800ca7aa26754fa8a6148cf2ea587c
GIT binary patch
literal 8569
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
T2<6_ypI^QoXt*HH??L_tKk5(g

literal 0
HcmV?d00001

diff --git a/src/assets/wood02.ogg b/src/assets/wood02.ogg
new file mode 100644
index 0000000000000000000000000000000000000000..71323568cef8a0bac2c430dc08968c9d72eeab45
GIT binary patch
literal 8672
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
G;y(b;I5{=|

literal 0
HcmV?d00001

diff --git a/src/assets/wood03.ogg b/src/assets/wood03.ogg
new file mode 100644
index 0000000000000000000000000000000000000000..070b762929fc22aba4b7f5650da1dbd03aeef5a0
GIT binary patch
literal 9832
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

literal 0
HcmV?d00001

diff --git a/src/engine/audio/data.zig b/src/engine/audio/data.zig
new file mode 100644
index 0000000..36c9d67
--- /dev/null
+++ b/src/engine/audio/data.zig
@@ -0,0 +1,64 @@
+const std = @import("std");
+const assert = std.debug.assert;
+
+const STBVorbis = @import("stb_vorbis");
+
+pub const Data = union(enum) {
+    raw: struct {
+        channels: [][*]f32,
+        sample_count: u32,
+        sample_rate: u32
+    },
+    vorbis: struct {
+        alloc_buffer: []u8,
+        stb_vorbis: STBVorbis,
+    },
+
+    pub fn streamChannel(
+        self: Data,
+        buffer: []f32,
+        cursor: u32,
+        channel_index: u32,
+        sample_rate: u32
+    ) []f32 {
+        // var result: std.ArrayList(f32) = .initBuffer(buffer);
+        switch (self) {
+            .raw => |opts| {
+                if (opts.sample_rate == sample_rate) {
+                    assert(channel_index < opts.channels.len); // TODO:
+                    const channel = opts.channels[channel_index];
+
+                    var memcpy_len: usize = 0;
+                    if (cursor + buffer.len <= opts.sample_count) {
+                        memcpy_len = buffer.len;
+                    } else if (cursor < opts.sample_count) {
+                        memcpy_len = opts.sample_count - cursor;
+                    }
+
+                    @memcpy(buffer[0..memcpy_len], channel[cursor..][0..memcpy_len]);
+                    return buffer[0..memcpy_len];
+                } else {
+                    // const in_sample_rate: f32 = @floatFromInt(opts.sample_rate);
+                    // const out_sample_rate: f32 = @floatFromInt(sample_rate);
+                    // const increment = in_sample_rate / out_sample_rate;
+                    // _ = increment; // autofix
+                    unreachable;
+                }
+            },
+            .vorbis => |opts| {
+                _ = opts; // autofix
+                unreachable;
+            },
+        }
+        // return result.items;
+    }
+
+    pub fn getSampleCount(self: Data) u32 {
+        return switch (self) {
+            .raw => |opts| opts.sample_count,
+            .vorbis => |opts| opts.stb_vorbis.getStreamLengthInSamples()
+        };
+    }
+
+    pub const Id = enum (u16) { _ };
+};
diff --git a/src/engine/audio/mixer.zig b/src/engine/audio/mixer.zig
new file mode 100644
index 0000000..31b0f89
--- /dev/null
+++ b/src/engine/audio/mixer.zig
@@ -0,0 +1,131 @@
+const std = @import("std");
+const log = std.log.scoped(.audio);
+const assert = std.debug.assert;
+const Allocator = std.mem.Allocator;
+
+const sokol = @import("sokol");
+const saudio = sokol.audio;
+
+const AudioData = @import("./data.zig").Data;
+pub const Store = @import("./store.zig");
+
+const Mixer = @This();
+
+pub const Instance = struct {
+    data_id: AudioData.Id,
+    cursor: u32 = 0,
+};
+
+pub const Command = union(enum) {
+    play: struct {
+        data_id: AudioData.Id,
+    },
+
+    pub const RingBuffer = struct {
+        // TODO: This ring buffer will work in a single producer single consumer configuration
+        // For my game this will be good enough
+
+        items: []Command,
+        head: std.atomic.Value(usize) = .init(0),
+        tail: std.atomic.Value(usize) = .init(0),
+
+        pub fn push(self: *RingBuffer, command: Command) error{OutOfMemory}!void {
+            const head = self.head.load(.monotonic);
+            const tail = self.tail.load(.monotonic);
+            const next_head = @mod(head + 1, self.items.len);
+
+            // A single slot in the .items array will always not be used.
+            if (next_head == tail) {
+                return error.OutOfMemory;
+            }
+
+            self.items[head] = command;
+            self.head.store(next_head, .monotonic);
+        }
+
+        pub fn pop(self: *RingBuffer) ?Command {
+            const head = self.head.load(.monotonic);
+            const tail = self.tail.load(.monotonic);
+
+            if (head == tail) {
+                return null;
+            }
+
+            const result = self.items[tail];
+            self.tail.store(@mod(tail + 1, self.items.len), .monotonic);
+            return result;
+        }
+    };
+};
+
+// TODO: Tracks
+
+instances: std.ArrayList(Instance),
+commands: Command.RingBuffer,
+
+pub fn init(
+    gpa: Allocator,
+    max_instances: u32,
+    max_commands: u32
+) !Mixer {
+    var instances = try std.ArrayList(Instance).initCapacity(gpa, max_instances);
+    errdefer instances.deinit(gpa);
+
+    const commands = try gpa.alloc(Command, max_commands);
+    errdefer gpa.free(commands);
+
+    return Mixer{
+        .instances = instances,
+        .commands = .{
+            .items = commands
+        }
+    };
+}
+
+pub fn deinit(self: *Mixer, gpa: Allocator) void {
+    self.instances.deinit(gpa);
+    gpa.free(self.commands.items);
+}
+
+pub fn queue(self: *Mixer, command: Command) void {
+    self.commands.push(command) catch log.warn("Maximum number of audio commands reached!", .{});
+}
+
+pub fn stream(self: *Mixer, store: Store, buffer: []f32, num_frames: u32, num_channels: u32) !void {
+    while (self.commands.pop()) |command| {
+        switch (command) {
+            .play => |opts| {
+                self.instances.appendBounded(.{
+                    .data_id = opts.data_id
+                }) catch log.warn("Maximum number of audio instances reached!", .{});
+            }
+        }
+    }
+
+    assert(num_channels == 1); // TODO:
+    const sample_rate: u32 = @intCast(saudio.sampleRate());
+
+    @memset(buffer, 0);
+
+    // var written: u32 = 0;
+    for (self.instances.items) |*instance| {
+        const audio_data = store.get(instance.data_id);
+        const samples = audio_data.streamChannel(buffer[0..num_frames], instance.cursor, 0, sample_rate);
+        instance.cursor += @intCast(samples.len);
+    }
+
+    {
+        var i: usize = 0;
+        while (i < self.instances.items.len) {
+            const instance = self.instances.items[i];
+            const audio_data = store.get(instance.data_id);
+            const is_complete = instance.cursor == audio_data.getSampleCount();
+
+            if (is_complete) {
+                _ = self.instances.swapRemove(i);
+            } else {
+                i += 1;
+            }
+        }
+    }
+}
diff --git a/src/engine/audio/root.zig b/src/engine/audio/root.zig
new file mode 100644
index 0000000..c384a4d
--- /dev/null
+++ b/src/engine/audio/root.zig
@@ -0,0 +1,100 @@
+const std = @import("std");
+const log = std.log.scoped(.audio);
+const assert = std.debug.assert;
+
+const tracy = @import("tracy");
+
+const Math = @import("../math.zig");
+const STBVorbis = @import("stb_vorbis");
+
+pub const Data = @import("./data.zig").Data;
+pub const Store = @import("./store.zig");
+pub const Mixer = @import("./mixer.zig");
+
+const sokol = @import("sokol");
+const saudio = sokol.audio;
+
+var stopped: bool = true;
+var gpa: std.mem.Allocator = undefined;
+var store: Store = undefined;
+pub var mixer: Mixer = undefined;
+
+const Options = struct {
+    allocator: std.mem.Allocator,
+    logger: saudio.Logger = .{},
+    channels: u32 = 1,
+    max_vorbis_alloc_buffer_size: u32 = 1 * Math.bytes_per_mib,
+    buffer_frames: u32 = 2048,
+    max_instances: u32 = 64
+};
+
+pub fn init(opts: Options) !void {
+    gpa = opts.allocator;
+
+    store = try Store.init(.{
+        .allocator = opts.allocator,
+        .max_vorbis_alloc_buffer_size = opts.max_vorbis_alloc_buffer_size,
+    });
+
+    mixer = try Mixer.init(gpa, opts.max_instances, opts.max_instances);
+
+    saudio.setup(.{
+        .logger = opts.logger,
+        .stream_cb = sokolStreamCallback,
+        .num_channels = @intCast(opts.channels),
+        .buffer_frames = @intCast(opts.buffer_frames)
+    });
+    stopped = false;
+
+    const sample_rate: f32 = @floatFromInt(saudio.sampleRate());
+    const audio_latency: f32 = @as(f32, @floatFromInt(opts.buffer_frames)) / sample_rate;
+    log.debug("Audio latency = {D}", .{@as(u64, @intFromFloat(audio_latency * std.time.ns_per_s))});
+}
+
+pub fn deinit() void {
+    stopped = true;
+    saudio.shutdown();
+    mixer.deinit(gpa);
+    store.deinit();
+}
+
+pub fn load(opts: Store.LoadOptions) !Data.Id {
+    return try store.load(opts);
+}
+
+pub const PlayOptions = struct {
+    id: Data.Id,
+    delay: f32 = 0
+};
+
+pub fn play(opts: PlayOptions) void {
+    mixer.queue(.{
+        .play = .{
+            .data_id = opts.id
+        }
+    });
+}
+
+fn sokolStreamCallback(buffer: [*c]f32, num_frames: i32, num_channels: i32) callconv(.c) void {
+    if (stopped) {
+        return;
+    }
+
+    const zone = tracy.initZone(@src(), .{ });
+    defer zone.deinit();
+
+    const num_frames_u32: u32 = @intCast(num_frames);
+    const num_channels_u32: u32 = @intCast(num_channels);
+
+    mixer.stream(
+        store,
+        buffer[0..(num_frames_u32 * num_channels_u32)],
+        num_frames_u32,
+        num_channels_u32
+    ) catch |e| {
+        log.err("mixer.stream() failed: {}", .{e});
+        if (@errorReturnTrace()) |trace| {
+            std.debug.dumpStackTrace(trace.*);
+        }
+    };
+}
diff --git a/src/engine/audio/store.zig b/src/engine/audio/store.zig
new file mode 100644
index 0000000..10e3b13
--- /dev/null
+++ b/src/engine/audio/store.zig
@@ -0,0 +1,106 @@
+const std = @import("std");
+const assert = std.debug.assert;
+
+const Math = @import("../math.zig");
+const STBVorbis = @import("stb_vorbis");
+
+const AudioData = @import("./data.zig").Data;
+
+const Store = @This();
+
+arena: std.heap.ArenaAllocator,
+list: std.ArrayList(AudioData),
+temp_vorbis_alloc_buffer: []u8,
+
+const Options = struct {
+    allocator: std.mem.Allocator,
+    max_vorbis_alloc_buffer_size: u32,
+};
+
+pub fn init(opts: Options) !Store {
+    const gpa = opts.allocator;
+
+    const temp_vorbis_alloc_buffer = try gpa.alloc(u8, opts.max_vorbis_alloc_buffer_size);
+    errdefer gpa.free(temp_vorbis_alloc_buffer);
+
+    return Store{
+        .arena = std.heap.ArenaAllocator.init(gpa),
+        .list = .empty,
+        .temp_vorbis_alloc_buffer = temp_vorbis_alloc_buffer
+    };
+}
+
+pub fn deinit(self: *Store) void {
+    const gpa = self.arena.child_allocator;
+    gpa.free(self.temp_vorbis_alloc_buffer);
+    self.list.deinit(gpa);
+    self.arena.deinit();
+}
+
+pub const LoadOptions = struct {
+    const PlaybackStyle = enum {
+        stream,
+        decode_once,
+
+        // If the decoded size is less than `stream_threshold`, then .decode_once will by default be used.
+        const stream_threshold = 10 * Math.bytes_per_mib;
+    };
+
+    const Format = enum {
+        vorbis
+    };
+
+    format: Format,
+    data: []const u8,
+    playback_style: ?PlaybackStyle = null,
+};
+
+pub fn load(self: *Store, opts: LoadOptions) !AudioData.Id {
+    const gpa = self.arena.child_allocator;
+
+    const id = self.list.items.len;
+    try self.list.ensureUnusedCapacity(gpa, 1);
+
+    const PlaybackStyle = LoadOptions.PlaybackStyle;
+    const temp_stb_vorbis = try STBVorbis.init(opts.data, self.temp_vorbis_alloc_buffer);
+    const info = temp_stb_vorbis.getInfo();
+    const duration_in_samples = temp_stb_vorbis.getStreamLengthInSamples();
+    const decoded_size = info.channels * duration_in_samples * @sizeOf(f32);
+    const stream_threshold = PlaybackStyle.stream_threshold;
+    const default_playback_style: PlaybackStyle = if (decoded_size < stream_threshold) .decode_once else .stream;
+
+    const arena_allocator = self.arena.allocator();
+    const playback_style = opts.playback_style orelse default_playback_style;
+    if (playback_style == .decode_once) {
+        const channels = try arena_allocator.alloc([*]f32, info.channels);
+        for (channels) |*channel| {
+            channel.* = (try arena_allocator.alloc(f32, duration_in_samples)).ptr;
+        }
+        const samples_decoded = temp_stb_vorbis.getSamples(channels, duration_in_samples);
+        assert(samples_decoded == duration_in_samples);
+
+        self.list.appendAssumeCapacity(AudioData{
+            .raw = .{
+                .channels = channels,
+                .sample_count = duration_in_samples,
+                .sample_rate = info.sample_rate
+            }
+        });
+    } else {
+        const alloc_buffer = try arena_allocator.alloc(u8, temp_stb_vorbis.getMinimumAllocBufferSize());
+        const stb_vorbis = STBVorbis.init(opts.data, alloc_buffer) catch unreachable;
+
+        self.list.appendAssumeCapacity(AudioData{
+            .vorbis = .{
+                .alloc_buffer = alloc_buffer,
+                .stb_vorbis = stb_vorbis
+            }
+        });
+    }
+
+    return @enumFromInt(id);
+}
+
+pub fn get(self: Store, id: AudioData.Id) AudioData {
+    return self.list.items[@intFromEnum(id)];
+}
diff --git a/src/engine/root.zig b/src/engine/root.zig
index e479b60..1a7bfe2 100644
--- a/src/engine/root.zig
+++ b/src/engine/root.zig
@@ -13,6 +13,7 @@ pub const Input = @import("./input.zig");
 const ScreenScalar = @import("./screen_scaler.zig");
 pub const imgui = @import("./imgui.zig");
 pub const Graphics = @import("./graphics.zig");
+pub const Audio = @import("./audio/root.zig");
 const tracy = @import("tracy");
 const builtin = @import("builtin");
 const STBImage = @import("stb_image");
@@ -148,7 +149,12 @@ fn sokolInit(self: *Engine) !void {
         }
     });
 
-    self.assets = try Assets.init();
+    try Audio.init(.{
+        .allocator = self.allocator,
+        .logger = .{ .func = sokolLogCallback },
+    });
+
+    self.assets = try Assets.init(self.allocator);
     self.game = try Game.init(self.allocator, &self.assets);
 }
 
@@ -156,8 +162,9 @@ fn sokolCleanup(self: *Engine) void {
     const zone = tracy.initZone(@src(), .{ });
     defer zone.deinit();
 
+    Audio.deinit();
     self.game.deinit();
-    self.assets.deinit();
+    self.assets.deinit(self.allocator);
     Gfx.deinit();
 }
 
diff --git a/src/game.zig b/src/game.zig
index 02636a3..a3a1836 100644
--- a/src/game.zig
+++ b/src/game.zig
@@ -9,6 +9,7 @@ const imgui = Engine.imgui;
 const Vec2 = Engine.Vec2;
 const rgb = Engine.Math.rgb;
 const Gfx = Engine.Graphics;
+const Audio = Engine.Audio;
 
 const Game = @This();
 
@@ -48,6 +49,12 @@ pub fn tick(self: *Game, frame: Engine.Frame) !void {
     }
     dir = dir.normalized();
 
+    if (dir.x != 0 or dir.y != 0) {
+        Audio.play(.{
+            .id = self.assets.wood01
+        });
+    }
+
     self.player = self.player.add(dir.multiplyScalar(50 * frame.dt));
 
     const regular_font = self.assets.font_id.get(.regular);
@@ -77,4 +84,8 @@ pub fn debug(self: *Game) !void {
     defer imgui.endWindow();
 
     imgui.text("Hello World!\n");
+    imgui.textFmt("Audio: {}/{}\n", .{
+        Audio.mixer.instances.items.len,
+        Audio.mixer.instances.capacity
+    });
 }