diff --git a/CMakeLists.txt b/CMakeLists.txt
index 41eb905..d4b9db8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,6 +18,8 @@ add_executable(Prune
         src/prune/core/time.cpp
         src/prune/core/input.cpp
 
+        src/prune/audio/audio_system.cpp
+
         src/prune/editor/editor_command.cpp
         src/prune/editor/editor_actions.cpp
 
diff --git a/DECISIONS.md b/DECISIONS.md
index 4f74182..c4f5298 100644
--- a/DECISIONS.md
+++ b/DECISIONS.md
@@ -892,3 +892,80 @@ Initial tool modes are deliberately limited to Select and Move. Select keeps sel
 
 The active tool is transient editor state. It lives in the generic world scene state so viewport interaction and UI can share it, but it is not saved into scene files.
 
+
+## Decision — Add basic audio hooks before final event management design
+
+### Context
+
+Prune needs basic sound playback now for clear runtime feedback in the existing sample scenes:
+
+Simple Shooter firing and enemy destruction.
+Platformer jumping and player hit/death feedback.
+Artillery firing and explosion/player hit feedback.
+
+The broader event/reaction system is not designed yet. Long term, events may drive multiple reaction types, including sounds, animations, sprite changes, UI effects, screen shake, object spawning, and scene-specific behaviours.
+
+Adding a full authored event system now would be premature. The editor UI, asset model, serialisation shape, and scene semantics are not ready for that decision.
+
+### Decision
+
+Add a minimal audio hook path now, built on lightweight scene event ids.
+
+Scenes may emit simple event ids such as:
+
+player_fired
+player_jumped
+enemy_destroyed
+player_hit
+round_reset
+
+A small audio layer maps those event ids to hard-coded sound resources and plays them when received.
+
+Scene behaviour must not know:
+
+- Which sound file is used.
+- How sound is loaded.
+- How sound is mixed.
+- Whether audio is enabled.
+- Which future reaction types may also respond to the same event.
+
+The app/runtime layer is responsible for passing emitted scene events to the audio system.
+
+- Initial constraints
+- Use hard-coded event-to-sound mappings only.
+- Keep sound resources small and explicit.
+- Keep the audio enable/disable toggle global.
+- Do not add authored event UI yet.
+- Do not serialise event bindings yet.
+- Do not introduce a full asset browser or asset registry for this pass.
+- Do not make scene behaviour call audio playback directly.
+
+#### Consequences
+
+This gives Prune useful runtime feedback immediately without committing to the final event architecture.
+
+The current audio hook path is intentionally disposable at the mapping level but not at the boundary level. The important boundary is that scenes emit events and another system consumes them.
+
+Later, the hard-coded audio mapping can be replaced by a more general event reaction system, for example:
+
+player_fired
+  - Play sound: shoot.wav
+  - Play animation: muzzle_flash
+  - Spawn object: projectile
+  - Trigger UI effect: screen_shake
+
+### Rejected alternative
+
+Direct sound calls inside scene behaviour
+
+Rejected because it would couple scene behaviour to audio playback and make later event-driven reactions harder.
+
+#### Bad direction:
+
+Platformer jump code -> play jump.wav directly
+
+#### Preferred direction:
+
+Platformer jump code -> emit player_jumped
+Audio system -> maps player_jumped to jump.wav
+Future reaction system -> may also map player_jumped to animation, particles, UI effects, or scene-specific responses
diff --git a/NOTES.md b/NOTES.md
index f37d94e..dfc15b3 100644
--- a/NOTES.md
+++ b/NOTES.md
@@ -1,192 +1,124 @@
-# Current Phase — Immediate hardening before next tools
+# Current Phase — Short-term editor/runtime hardening
 
 ## Goal
 
-Make Prune feel like a real editor rather than a set of game type scene slices with panels attached.
+Turn the current editor/runtime foundation into something that behaves more like a typical game engine/editor.
 
-All the previous development proved that multiple scene types can share the same editor/runtime while owning their own behaviour, tools, panels, inspectors, object semantics, defaults, and save data.
+The previous phase proved the important foundations: editor commands, undo/redo, multi-select, explicit tool modes, scale, and the first audio/event hook path. The next phase should now harden the everyday editor behaviour around saving, reset/reload, ordering, and scene state tracking.
 
-During the next development phase, we should now prove that the editor can safely manipulate scene-owned objects without bypassing those scene rules.
+This phase is not about adding new systems. It is about removing rough edges that will be awkward to deal with later.
 
-## Guiding rule
+Prune should know when a scene has changed, what can be saved, what can be reset, what order objects render in, and whether runtime state is being viewed or rebuilt. These behaviours should not be inferred accidentally from object shape, current UI selection, or temporary scene runtime state.
 
-Editor tools must act through explicit editor semantics, not through incidental object shape.
+## Targets
 
-A selected object is not just a rectangle. It may be authored, runtime-created, selectable, editable, movable, persistent, solid, hazardous, scene-specific, or protected.
+### 1. Dirty state tracking
 
-## Must do first
-
-- [x] Keep player/controller ownership scene-specific unless a genuinely shared abstraction appears.
-- [x] Introduce an editor command/change model before implementing undo/redo.
-- [x] Keep undo/redo editor-only at first.
-- [x] Keep scene activation separate from default scene creation so loading cannot be overwritten by `on_enter()`.
-
-## Phase targets
-
-### 1. Editor command/change model
-
-Create the smallest useful model for editor-authored changes.
-
-Initial command candidates:
-
-- [x] Move object in scene
-- [x] Create object
-- [x] Delete object
-- [x] Rename object
-- [x] Change object size
-- [x] Change object rendering type (rectangle/colour)
-- [x] Change object colour
-- [x] Change object sprite
-- [x] Viewport movement/zoom (no zoom yet)
-- [x] Record state snapshots not delta changes.
-
-Avoid runtime/gameplay commands for now. A projectile moving, an enemy spawning, or an artillery round ending should not enter editor undo history, we just care about what the user did in the editor.
-
-### 2. Undo/redo
-
-Build undo/redo on top of the command model, not as custom reversal logic scattered through tools and panels.
+Track whether the current scene has unsaved editor-authored changes.
 
 Initial scope:
 
-- [x] Command history buffer panel with list of past commands
-- [x] Move transform tool from scene/tools to editor/tools
-- [x] Viewport object movement
-- [x] Object creation
-- [x] Object deletion
-- [x] Simple inspector edits
+* [ ] Mark scene dirty when editor commands are executed.
+* [ ] Mark scene dirty when inspector edits are committed.
+* [ ] Mark scene dirty when authored objects are created, deleted, duplicated, moved, scaled, or reordered.
+* [ ] Clear dirty state after a successful save.
+* [ ] Keep runtime-only behaviour out of dirty tracking.
+* [ ] Show dirty state somewhere lightweight in the editor UI.
 
 Out of scope for the first pass:
 
-- Runtime object history
-- Gameplay state rewind
-- Save/load history restoration
-- Multi-scene history
-
-### 3. Delete and duplicate workflow
-
-Add normal editor actions once command history exists.
-
-Initial scope:
-
-- [x] Delete selected authored object
-- [x] Duplicate selected authored object
-- [x] Select the duplicated object
-- [x] Offset duplicates slightly so the result is visible
-
-This gives undo/redo useful behaviour to prove.
+* Save confirmation modal when closing Prune.
+* Save confirmation modal when switching scenes.
+* Per-scene dirty tracking across multiple open scenes.
+* Autosave.
 
-### 4. Multi-select
+### 2. CTRL-S save shortcut
 
-Add multi-select after the single-object command path is stable.
+Add a normal editor save shortcut once dirty state exists.
 
 Initial scope:
 
-- [x] Selection set instead of one selected id
-- [x] Shift-click to add/remove from the selection set
-- [x] Clear selection on empty viewport click
-- [x] Outliner multi-select support
-- [x] Visible outline for every selected object
-- [x] Combined selection bounds in the viewport
-- [x] Multi-selection drag handle on the selection bounds
-- [x] Selection count in editor UI
-- [x] Move selected objects as one editor command
-- [x] Delete selected deletable objects as one editor command
-
-Multi-select now supports grouped viewport move and grouped delete. Grouped inspector/property edits remain deferred because they need more specific UX and command labels.
-
-### 5. Tool mode state
+* [ ] CTRL-S saves the current scene when a scene file path is known.
+* [ ] CTRL-S uses the same save path as the existing save workflow.
+* [ ] Successful save clears dirty state.
+* [ ] Failed save leaves dirty state unchanged.
+* [ ] Avoid triggering save repeatedly while the key is held.
 
-Status: implemented.
+Out of scope for the first pass:
 
-Introduce an explicit editor tool mode before adding more viewport tools.
+* Save As shortcut.
+* Recent files.
+* Save failure recovery UI beyond a simple message/log entry.
 
-Suggested initial tools:
+### 3. Runtime reset and reload
 
-```cpp
-enum class EditorTool {
-    Select,
-    Move,
-    Scale,
-    Rotate
-};
-```
+Add explicit runtime reset/reload behaviour rather than relying only on pause/resume.
 
-This avoids hiding editor behaviour inside whichever handle happened to be clicked.
+Initial scope:
 
-Current implementation:
+* [ ] Reset runtime state for the active scene without destroying authored scene data.
+* [ ] Reload the scene from saved data when a backing file exists.
+* [ ] Preserve the distinction between editor-authored objects and runtime-only objects.
+* [ ] Clear runtime-only objects during reset/reload.
+* [ ] Re-enter scene runtime cleanly after reset/reload.
+* [ ] Make behaviour consistent across Simple Shooter, Platformer, and Artillery.
+* [ ] New toolbar in the editor for reset/reload/pause/resume.
 
-- [x] Active tool state lives in generic world scene state.
-- [x] A fixed viewport palette exposes Select and Move as text tool buttons.
-- [x] The viewport palette also exposes scene-owned creation actions such as Wall, Platform, Hazard, and Terrain Line.
-- [x] Select keeps the existing selection and move-handle behaviour.
-- [x] Move allows direct body dragging for movable authored objects.
-- [x] Scale and rotate remain unimplemented until their interaction rules are explicit.
+Out of scope for the first pass:
 
-### 6. Scale tool
+* Save prompts before reload.
+* Runtime state snapshots.
+* Gameplay rewind.
 
-Implement scale before rotate.
+### 4. Z-index ordering
 
-Scale fits the current object model because Prune already has width/height and rectangle bounds.
+Add authored object ordering so render order is deliberate and editable.
 
 Initial scope:
 
-- [x] Single selected authored object
-- [x] Corner or edge handle
-- [x] Minimum size clamp
-- [x] Inspector updates immediately
-- [x] Undo/redo command recorded when the drag completes
+* [ ] Add an authored z-index/order field to scene objects.
+* [ ] Render authored objects using explicit ordering.
+* [ ] Persist ordering in scene save data.
+* [ ] Restore ordering on load.
+* [ ] Add basic editor actions for moving selected object up/down in order.
+* [ ] Keep runtime-only ordering behaviour simple and deterministic.
 
-### 7. Basic audio and event hooks
-
-Add audio through events.
-
-Preferred direction:
-
-- Scenes emit lightweight event ids such as `player_fired`, `enemy_destroyed`, `player_hit`, `round_reset`.
-- A small audio layer maps event ids to sounds.
-- Scene behaviour does not know how sound is played.
-
-Initial scope:
+Out of scope for the first pass:
 
-- [ ] One or two hard-coded sound resources
-- [ ] Fire event
-- [ ] Hit/destroy event
-- [ ] Global enable/disable toggle
-
-## Short term, in no particular order
-
-- Z-Index ordering
-- Runtime reset and reload, not just pause/resume
-- CTRL-S to save scene
-- Dirty state tracking for scene
-
-## Medium term, in no particular order
-
-- Rotate tool
-- Background image support
-- Simplified asset management
-- Text rendering
-- Behaviour toggles for authored objects
-- Polished sample scenes
-- Asset browser
-- Animated sprites/facing support
-- Scene file versioning
-- Grid snapping support on all tools and UI option, not in settings
-- Object locking and protection
-- More robust collision shapes and collision options
-- Scene layering, rendering and collision etc.
-
-## Long term, in no particular order
-
-- Grouping
-- Input mapping and rebinding
-- Scene settings panel for background, music, and other scene-wide options
-- Game UI panels 
-- Pathfinding support
-- Full audio mixer
-- Prefabs/templates
-- Native playable export
-- WebAssembly playable export
-- Card scene
-- Puzzle scene
-- Many more scene tools
+* Full layer system.
+* Separate render/collision layers.
+* Drag-and-drop ordering in the outliner.
+
+## Follow on development targets
+
+### Medium term, in no particular order
+
+* Rotate tool
+* Background image support
+* Simplified asset management
+* Text rendering
+* Behaviour toggles for authored objects
+* Polished sample scenes
+* Event management and event-driven reactions (play audio, spawn objects, play animation, screen effects, etc.)
+* Asset browser
+* Animated sprites/facing support
+* Scene file versioning
+* Grid snapping support on all tools and UI option, not in settings
+* Object locking and protection
+* More robust collision shapes and collision options
+* Scene layering, rendering and collision etc.
+
+### Long term, in no particular order
+
+* Grouping
+* Input mapping and rebinding
+* Scene settings panel for background, music, and other scene-wide options
+* Game UI panels
+* Pathfinding support
+* Full audio mixer
+* Prefabs/templates
+* Native playable export
+* WebAssembly playable export
+* Card scene
+* Puzzle scene
+* Many more scene tools
diff --git a/README.md b/README.md
index 962cf84..d85f685 100644
--- a/README.md
+++ b/README.md
@@ -196,7 +196,7 @@ Current priorities:
 - [x] Multi-select move/delete
 - [x] Tool mode state
 - [x] Scale tool
-- [ ] Basic audio hooks
+- [x] Basic audio hooks
 
 My development plan is tracked in [NOTES.md](NOTES.md), check the file for more details on what each of these points mean as well as what is included - this is what I will be working on in the next development phase.
 
@@ -209,13 +209,14 @@ I will consider Prune ready for users when the below is ready, this is the minim
 - [x] Select object in viewport.
 - [x] Move with handle.
 - [x] Resize with scale tool.
-- [ ] Duplicate it.
-- [ ] Delete it.
+- [x] Duplicate it.
+- [x] Delete it.
 - [x] Undo/redo all of that.
 - [x] Save.
 - [x] Load.
 - [x] Behaviour still works.
 - [x] Runtime objects do not get accidentally edited or saved.
+- [x] Basic audio hooks
 
 ## Documentation stance
 
@@ -315,6 +316,7 @@ build/Debug/Prune.exe
 - [SDL2_image](https://github.com/libsdl-org/SDL_image) — sprite loading
 - [The Cherno](https://www.youtube.com/@TheCherno) — C++ game engine architecture and editor design inspiration
 - [Kenny](https://kenney.nl/) — free game assets for prototyping
+- [jsfxr](https://sfxr.me/) - free sound effect generator for prototyping
 
 ## Licence
 
diff --git a/assets/sound-effects/explosion.wav b/assets/sound-effects/explosion.wav
new file mode 100644
index 0000000..67cecb7
Binary files /dev/null and b/assets/sound-effects/explosion.wav differ
diff --git a/assets/sound-effects/jump.wav b/assets/sound-effects/jump.wav
new file mode 100644
index 0000000..e0f0fef
Binary files /dev/null and b/assets/sound-effects/jump.wav differ
diff --git a/assets/sound-effects/shoot.wav b/assets/sound-effects/shoot.wav
new file mode 100644
index 0000000..96bd3a6
Binary files /dev/null and b/assets/sound-effects/shoot.wav differ
diff --git a/src/prune/app/app.cpp b/src/prune/app/app.cpp
index 540374f..a55c767 100644
--- a/src/prune/app/app.cpp
+++ b/src/prune/app/app.cpp
@@ -12,6 +12,7 @@
 #include "backends/imgui_impl_sdlrenderer2.h"
 
 #include "prune/app/app.hpp"
+#include "prune/audio/audio_system.hpp"
 #include "prune/core/time.hpp"
 #include "prune/scene/scene_factory.hpp"
 #include "prune/tooling/theme.hpp"
@@ -25,6 +26,8 @@ namespace prune {
         init_sdl();
 
         m_window = std::make_unique<Window>(config.window);
+        init_audio();
+
         m_input = std::make_unique<Input>();
         m_time = std::make_unique<Time>();
         m_scene = SceneFactory::create(SceneType::Platformer, m_window->width(), m_window->height());
@@ -48,6 +51,7 @@ namespace prune {
         m_ui.reset();
         m_input.reset();
         m_time.reset();
+        m_audio.reset();
         m_window.reset();
 
         shutdown_sdl();
@@ -83,14 +87,23 @@ namespace prune {
                 SceneType new_scene_type = SceneType::SimpleShooter;
                 bool load_scene_requested = false;
 
+                bool audio_enabled = m_audio ? m_audio->enabled() : false;
+                const bool audio_available = m_audio ? m_audio->available() : false;
+
                 m_ui->build(
                     *m_scene,
                     m_window->renderer(),
                     new_scene_requested,
                     new_scene_type,
-                    load_scene_requested
+                    load_scene_requested,
+                    audio_enabled,
+                    audio_available
                 );
 
+                if (m_audio) {
+                    m_audio->set_enabled(audio_enabled);
+                }
+
                 if (new_scene_requested) {
                     m_scene->on_exit();
 
@@ -206,9 +219,49 @@ namespace prune {
     {
         if (m_scene) {
             m_scene->update(dt, *m_input);
+            dispatch_scene_events();
         }
     }
 
+
+    void App::init_audio()
+    {
+        m_audio = std::make_unique<AudioSystem>();
+
+        std::string error;
+        if (!m_audio->initialise(error)) {
+            m_audio.reset();
+            return;
+        }
+
+        const std::filesystem::path sound_path =
+            std::filesystem::current_path() / "assets" / "sound-effects";
+
+        m_audio->load_sound(sound_ids::shoot, sound_path / "shoot.wav", error);
+        m_audio->load_sound(sound_ids::jump, sound_path / "jump.wav", error);
+        m_audio->load_sound(sound_ids::explosion, sound_path / "explosion.wav", error);
+
+        m_audio->map_event_to_sound(scene_events::player_fired, sound_ids::shoot);
+        m_audio->map_event_to_sound(scene_events::player_jumped, sound_ids::jump);
+        m_audio->map_event_to_sound(scene_events::player_hit, sound_ids::explosion);
+        m_audio->map_event_to_sound(scene_events::enemy_destroyed, sound_ids::explosion);
+
+        m_audio->start();
+    }
+
+    void App::dispatch_scene_events()
+    {
+        if (!m_scene) {
+            return;
+        }
+
+        if (m_audio) {
+            m_audio->handle_events(m_scene->pending_scene_events());
+        }
+
+        m_scene->clear_scene_events();
+    }
+
     void App::render()
     {
         SDL_Renderer* renderer = m_window->renderer();
diff --git a/src/prune/app/app.hpp b/src/prune/app/app.hpp
index cc5fe42..d9134e4 100644
--- a/src/prune/app/app.hpp
+++ b/src/prune/app/app.hpp
@@ -7,6 +7,7 @@
 
 namespace prune {
 
+    class AudioSystem;
     class Time;
     class Scene;
     class Ui;
@@ -46,6 +47,10 @@ namespace prune {
 
         void render();
 
+        void init_audio();
+
+        void dispatch_scene_events();
+
         void init_imgui();
 
         void shutdown_imgui();
@@ -53,6 +58,7 @@ namespace prune {
         void begin_imgui_frame();
 
         std::unique_ptr<Window> m_window;
+        std::unique_ptr<AudioSystem> m_audio;
         std::unique_ptr<Time> m_time;
         std::unique_ptr<Input> m_input;
         std::unique_ptr<Scene> m_scene;
diff --git a/src/prune/audio/audio_system.cpp b/src/prune/audio/audio_system.cpp
new file mode 100644
index 0000000..5a40e4b
--- /dev/null
+++ b/src/prune/audio/audio_system.cpp
@@ -0,0 +1,287 @@
+#include "prune/audio/audio_system.hpp"
+
+#include <algorithm>
+#include <cstring>
+#include <utility>
+
+namespace prune {
+
+    namespace {
+        constexpr int k_audio_frequency = 48'000;
+        constexpr int k_audio_channels = 2;
+        constexpr int k_audio_sample_buffer = 1024;
+        constexpr std::size_t k_max_active_voices = 16;
+    }
+
+    AudioSystem::~AudioSystem()
+    {
+        shutdown();
+    }
+
+    bool AudioSystem::initialise(std::string& error)
+    {
+        if (m_device_id != 0) {
+            return true;
+        }
+
+        if (SDL_WasInit(SDL_INIT_AUDIO) == 0) {
+            if (SDL_InitSubSystem(SDL_INIT_AUDIO) != 0) {
+                error = SDL_GetError();
+                return false;
+            }
+
+            m_owns_audio_subsystem = true;
+        }
+
+        SDL_AudioSpec desired{};
+        desired.freq = k_audio_frequency;
+        desired.format = AUDIO_F32SYS;
+        desired.channels = k_audio_channels;
+        desired.samples = k_audio_sample_buffer;
+        desired.callback = &AudioSystem::audio_callback;
+        desired.userdata = this;
+
+        m_device_id = SDL_OpenAudioDevice(nullptr, 0, &desired, &m_device_spec, 0);
+        if (m_device_id == 0) {
+            error = SDL_GetError();
+
+            if (m_owns_audio_subsystem) {
+                SDL_QuitSubSystem(SDL_INIT_AUDIO);
+                m_owns_audio_subsystem = false;
+            }
+
+            return false;
+        }
+
+        return true;
+    }
+
+    void AudioSystem::shutdown() noexcept
+    {
+        if (m_device_id != 0) {
+            SDL_LockAudioDevice(m_device_id);
+            m_voices.clear();
+            SDL_UnlockAudioDevice(m_device_id);
+
+            SDL_CloseAudioDevice(m_device_id);
+            m_device_id = 0;
+        }
+        else {
+            m_voices.clear();
+        }
+
+        m_sounds.clear();
+        m_sound_indices.clear();
+        m_event_sound_map.clear();
+
+        if (m_owns_audio_subsystem) {
+            SDL_QuitSubSystem(SDL_INIT_AUDIO);
+            m_owns_audio_subsystem = false;
+        }
+    }
+
+    void AudioSystem::start() noexcept
+    {
+        if (m_device_id != 0) {
+            SDL_PauseAudioDevice(m_device_id, 0);
+        }
+    }
+
+    bool AudioSystem::load_sound(
+        std::string_view sound_id,
+        const std::filesystem::path& path,
+        std::string& error
+    )
+    {
+        if (sound_id.empty()) {
+            error = "Sound id cannot be empty.";
+            return false;
+        }
+
+        if (m_device_id == 0) {
+            error = "Audio device is not initialised.";
+            return false;
+        }
+
+        if (m_sound_indices.contains(std::string(sound_id))) {
+            return true;
+        }
+
+        SDL_AudioSpec source_spec{};
+        Uint8* source_buffer = nullptr;
+        Uint32 source_length = 0;
+
+        if (SDL_LoadWAV(path.string().c_str(), &source_spec, &source_buffer, &source_length) == nullptr) {
+            error = SDL_GetError();
+            return false;
+        }
+
+        SDL_AudioCVT converter{};
+        if (SDL_BuildAudioCVT(
+            &converter,
+            source_spec.format,
+            source_spec.channels,
+            source_spec.freq,
+            m_device_spec.format,
+            m_device_spec.channels,
+            m_device_spec.freq
+        ) < 0) {
+            error = SDL_GetError();
+            SDL_FreeWAV(source_buffer);
+            return false;
+        }
+
+        converter.len = static_cast<int>(source_length);
+        converter.buf = static_cast<Uint8*>(SDL_malloc(source_length * static_cast<Uint32>(converter.len_mult)));
+
+        if (converter.buf == nullptr) {
+            error = "Could not allocate audio conversion buffer.";
+            SDL_FreeWAV(source_buffer);
+            return false;
+        }
+
+        std::memcpy(converter.buf, source_buffer, source_length);
+        SDL_FreeWAV(source_buffer);
+
+        if (SDL_ConvertAudio(&converter) < 0) {
+            error = SDL_GetError();
+            SDL_free(converter.buf);
+            return false;
+        }
+
+        SoundResource sound;
+        sound.id = std::string(sound_id);
+        sound.buffer.assign(converter.buf, converter.buf + converter.len_cvt);
+        SDL_free(converter.buf);
+
+        SDL_LockAudioDevice(m_device_id);
+
+        const std::size_t index = m_sounds.size();
+        m_sound_indices.emplace(sound.id, index);
+        m_sounds.push_back(std::move(sound));
+
+        SDL_UnlockAudioDevice(m_device_id);
+        return true;
+    }
+
+    void AudioSystem::map_event_to_sound(std::string_view event_id, std::string_view sound_id)
+    {
+        if (event_id.empty() || sound_id.empty()) {
+            return;
+        }
+
+        m_event_sound_map.insert_or_assign(std::string(event_id), std::string(sound_id));
+    }
+
+    void AudioSystem::handle_events(std::span<const SceneEvent> events)
+    {
+        if (!m_enabled.load() || m_device_id == 0 || events.empty()) {
+            return;
+        }
+
+        for (const SceneEvent& event : events) {
+            play_event(event.id);
+        }
+    }
+
+    void AudioSystem::play_event(std::string_view event_id)
+    {
+        if (!m_enabled.load() || m_device_id == 0 || event_id.empty()) {
+            return;
+        }
+
+        const auto event_match = m_event_sound_map.find(std::string(event_id));
+        if (event_match == m_event_sound_map.end()) {
+            return;
+        }
+
+        const auto sound_match = m_sound_indices.find(event_match->second);
+        if (sound_match == m_sound_indices.end()) {
+            return;
+        }
+
+        SDL_LockAudioDevice(m_device_id);
+
+        if (m_voices.size() >= k_max_active_voices) {
+            m_voices.erase(m_voices.begin());
+        }
+
+        m_voices.push_back(ActiveVoice{ sound_match->second, 0 });
+        SDL_UnlockAudioDevice(m_device_id);
+    }
+
+    void AudioSystem::set_enabled(bool enabled) noexcept
+    {
+        m_enabled.store(enabled);
+
+        if (!enabled) {
+            stop_all_voices();
+        }
+    }
+
+    void AudioSystem::audio_callback(void* userdata, std::uint8_t* stream, int length) noexcept
+    {
+        auto* audio = static_cast<AudioSystem*>(userdata);
+        if (audio == nullptr) {
+            std::memset(stream, 0, static_cast<std::size_t>(std::max(length, 0)));
+            return;
+        }
+
+        audio->mix(stream, length);
+    }
+
+    void AudioSystem::mix(std::uint8_t* stream, int length) noexcept
+    {
+        if (stream == nullptr || length <= 0) {
+            return;
+        }
+
+        std::memset(stream, 0, static_cast<std::size_t>(length));
+
+        if (!m_enabled.load() || m_voices.empty()) {
+            return;
+        }
+
+        for (ActiveVoice& voice : m_voices) {
+            if (voice.sound_index >= m_sounds.size()) {
+                continue;
+            }
+
+            const SoundResource& sound = m_sounds[voice.sound_index];
+            if (voice.position >= sound.buffer.size()) {
+                continue;
+            }
+
+            const std::uint32_t remaining = static_cast<std::uint32_t>(sound.buffer.size() - voice.position);
+            const std::uint32_t bytes_to_mix = std::min(static_cast<std::uint32_t>(length), remaining);
+
+            SDL_MixAudioFormat(
+                stream,
+                sound.buffer.data() + voice.position,
+                m_device_spec.format,
+                bytes_to_mix,
+                SDL_MIX_MAXVOLUME
+            );
+
+            voice.position += bytes_to_mix;
+        }
+
+        std::erase_if(m_voices, [this](const ActiveVoice& voice) {
+            return voice.sound_index >= m_sounds.size() ||
+                voice.position >= m_sounds[voice.sound_index].buffer.size();
+        });
+    }
+
+    void AudioSystem::stop_all_voices() noexcept
+    {
+        if (m_device_id == 0) {
+            m_voices.clear();
+            return;
+        }
+
+        SDL_LockAudioDevice(m_device_id);
+        m_voices.clear();
+        SDL_UnlockAudioDevice(m_device_id);
+    }
+
+}
diff --git a/src/prune/audio/audio_system.hpp b/src/prune/audio/audio_system.hpp
new file mode 100644
index 0000000..025aac8
--- /dev/null
+++ b/src/prune/audio/audio_system.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <atomic>
+#include <cstdint>
+#include <filesystem>
+#include <span>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+
+#include <SDL2/SDL.h>
+
+#include "prune/scene/scene_event.hpp"
+
+namespace prune {
+
+    namespace sound_ids {
+        inline constexpr std::string_view shoot = "shoot";
+        inline constexpr std::string_view jump = "jump";
+        inline constexpr std::string_view explosion = "explosion";
+    }
+
+    class AudioSystem {
+    public:
+        AudioSystem() = default;
+        ~AudioSystem();
+
+        AudioSystem(const AudioSystem&) = delete;
+        AudioSystem& operator=(const AudioSystem&) = delete;
+
+        [[nodiscard]] bool initialise(std::string& error);
+        void shutdown() noexcept;
+        void start() noexcept;
+
+        [[nodiscard]] bool load_sound(
+            std::string_view sound_id,
+            const std::filesystem::path& path,
+            std::string& error
+        );
+
+        void map_event_to_sound(std::string_view event_id, std::string_view sound_id);
+        void handle_events(std::span<const SceneEvent> events);
+        void play_event(std::string_view event_id);
+
+        void set_enabled(bool enabled) noexcept;
+        [[nodiscard]] bool enabled() const noexcept { return m_enabled.load(); }
+        [[nodiscard]] bool available() const noexcept { return m_device_id != 0; }
+
+    private:
+        struct SoundResource {
+            std::string id;
+            std::vector<std::uint8_t> buffer;
+        };
+
+        struct ActiveVoice {
+            std::size_t sound_index = 0;
+            std::uint32_t position = 0;
+        };
+
+        static void audio_callback(void* userdata, std::uint8_t* stream, int length) noexcept;
+        void mix(std::uint8_t* stream, int length) noexcept;
+        void stop_all_voices() noexcept;
+
+        SDL_AudioSpec m_device_spec{};
+        SDL_AudioDeviceID m_device_id = 0;
+        bool m_owns_audio_subsystem = false;
+
+        std::vector<SoundResource> m_sounds;
+        std::vector<ActiveVoice> m_voices;
+        std::unordered_map<std::string, std::size_t> m_sound_indices;
+        std::unordered_map<std::string, std::string> m_event_sound_map;
+
+        std::atomic_bool m_enabled = true;
+    };
+
+}
diff --git a/src/prune/scene/artillery/artillery_behaviour.cpp b/src/prune/scene/artillery/artillery_behaviour.cpp
index 5cf413b..f0f2eb2 100644
--- a/src/prune/scene/artillery/artillery_behaviour.cpp
+++ b/src/prune/scene/artillery/artillery_behaviour.cpp
@@ -217,6 +217,7 @@ namespace prune {
         artillery_state.projectile_id = state.objects.create_object(projectile);
         artillery_state.projectile_owner_id = tank->identity.id;
         artillery_state.projectile_active = true;
+        state.events.emit(scene_events::player_fired);
     }
 
     void ArtilleryBehaviour::update_projectile(SceneState& state, ArtilleryState& artillery_state, float dt) const
@@ -241,6 +242,7 @@ namespace prune {
         GameObjectId hit_id = k_invalid_game_object_id;
         if (projectile->lifecycle.remaining <= 0.0f || projectile->transform.y > 360.0f || projectile_hit_solid(state, *projectile, artillery_state.projectile_owner_id, hit_id)) {
             if (GameObject* hit = state.objects.get_by_id(hit_id); hit && artillery_concepts::is_tank(*hit)) {
+                state.events.emit(scene_events::player_hit);
                 reset_round(state, artillery_state);
                 return;
             }
@@ -292,6 +294,7 @@ namespace prune {
         artillery_state.projectile_owner_id = k_invalid_game_object_id;
         artillery_state.projectile_active = false;
         artillery_state.current_turn = ArtilleryTurn::PlayerOne;
+        state.events.emit(scene_events::round_reset);
     }
 
     GameObject* ArtilleryBehaviour::current_tank(SceneState& state, const ArtilleryState& artillery_state) const noexcept
diff --git a/src/prune/scene/platformer/platformer_behaviour.cpp b/src/prune/scene/platformer/platformer_behaviour.cpp
index 7542be6..ddd5b5f 100644
--- a/src/prune/scene/platformer/platformer_behaviour.cpp
+++ b/src/prune/scene/platformer/platformer_behaviour.cpp
@@ -109,6 +109,7 @@ namespace prune {
             if ((input.was_key_pressed(SDL_SCANCODE_W) || input.was_key_pressed(SDL_SCANCODE_SPACE)) && platformer_state.player_grounded) {
                 player->motion.velocity.y = -platformer_state.options.jump_velocity;
                 platformer_state.player_grounded = false;
+                state.events.emit(scene_events::player_jumped);
             }
         }
 
@@ -130,6 +131,7 @@ namespace prune {
         }
 
         if (touches_hazard(state, *player) || player->transform.y > 512.0f) {
+            state.events.emit(scene_events::player_hit);
             reset_player(state, platformer_state);
         }
 
diff --git a/src/prune/scene/scene.hpp b/src/prune/scene/scene.hpp
index 05b0266..71612cb 100644
--- a/src/prune/scene/scene.hpp
+++ b/src/prune/scene/scene.hpp
@@ -12,6 +12,7 @@
 #include "prune/scene/game_object_manager.hpp"
 #include "prune/scene/object_concept.hpp"
 #include "prune/scene/scene_camera.hpp"
+#include "prune/scene/scene_event.hpp"
 #include "prune/scene/scene_state.hpp"
 
 namespace prune {
@@ -133,6 +134,9 @@ namespace prune {
 
         virtual SceneOptions& get_scene_options() = 0;
 
+        [[nodiscard]] virtual std::span<const SceneEvent> pending_scene_events() const noexcept = 0;
+        virtual void clear_scene_events() noexcept = 0;
+
         [[nodiscard]] virtual EditorTool current_editor_tool() const noexcept { return EditorTool::Select; }
         virtual void set_current_editor_tool(EditorTool) noexcept {}
 
diff --git a/src/prune/scene/scene_event.hpp b/src/prune/scene/scene_event.hpp
new file mode 100644
index 0000000..2bbff9f
--- /dev/null
+++ b/src/prune/scene/scene_event.hpp
@@ -0,0 +1,47 @@
+#pragma once
+
+#include <span>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace prune {
+
+    namespace scene_events {
+        inline constexpr std::string_view player_fired = "player_fired";
+        inline constexpr std::string_view player_jumped = "player_jumped";
+        inline constexpr std::string_view player_hit = "player_hit";
+        inline constexpr std::string_view enemy_destroyed = "enemy_destroyed";
+        inline constexpr std::string_view round_reset = "round_reset";
+    }
+
+    struct SceneEvent {
+        std::string id;
+    };
+
+    class SceneEventQueue {
+    public:
+        void emit(std::string_view event_id)
+        {
+            if (event_id.empty()) {
+                return;
+            }
+
+            m_events.push_back(SceneEvent{ std::string(event_id) });
+        }
+
+        [[nodiscard]] std::span<const SceneEvent> pending() const noexcept
+        {
+            return std::span<const SceneEvent>{ m_events.data(), m_events.size() };
+        }
+
+        void clear() noexcept
+        {
+            m_events.clear();
+        }
+
+    private:
+        std::vector<SceneEvent> m_events;
+    };
+
+}
diff --git a/src/prune/scene/scene_state.hpp b/src/prune/scene/scene_state.hpp
index 05c7e32..13517f7 100644
--- a/src/prune/scene/scene_state.hpp
+++ b/src/prune/scene/scene_state.hpp
@@ -6,6 +6,7 @@
 #include "prune/editor/editor_tool.hpp"
 #include "prune/scene/game_object.hpp"
 #include "prune/scene/game_object_manager.hpp"
+#include "prune/scene/scene_event.hpp"
 
 #include <vector>
 
@@ -83,6 +84,7 @@ namespace prune {
         DragState drag_state{};
         SceneOptions scene_options{};
         EditorTool editor_tool = EditorTool::Select;
+        SceneEventQueue events;
 
         GameObjectManager objects;
         EditorCommandHistory editor_commands;
diff --git a/src/prune/scene/simple_shooter/simple_shooter_behaviour.cpp b/src/prune/scene/simple_shooter/simple_shooter_behaviour.cpp
index 9917350..c918ddb 100644
--- a/src/prune/scene/simple_shooter/simple_shooter_behaviour.cpp
+++ b/src/prune/scene/simple_shooter/simple_shooter_behaviour.cpp
@@ -233,6 +233,7 @@ namespace prune {
             )
         );
 
+        state.events.emit(scene_events::player_fired);
         shooter_state.fire_cooldown_remaining = shooter_state.options.fire_cooldown;
     }
 
@@ -339,6 +340,7 @@ namespace prune {
                 enemy.lifecycle.active = false;
                 enemy.render.visible = false;
                 enemy.motion.velocity = {};
+                state.events.emit(scene_events::enemy_destroyed);
                 break;
             }
         }
diff --git a/src/prune/scene/world_scene.cpp b/src/prune/scene/world_scene.cpp
index 7bbb39b..1e85ae6 100644
--- a/src/prune/scene/world_scene.cpp
+++ b/src/prune/scene/world_scene.cpp
@@ -159,6 +159,8 @@ namespace prune {
             }
 
             SceneState loaded_state = m_state;
+            loaded_state.events.clear();
+
             SceneCamera loaded_camera = m_camera;
             GridOptions loaded_grid_options = m_grid_options;
 
@@ -175,6 +177,7 @@ namespace prune {
             }
 
             m_state = std::move(loaded_state);
+            m_state.events.clear();
             m_state.drag_state = {};
             m_state.editor_commands.clear();
             m_camera = loaded_camera;
@@ -260,6 +263,16 @@ namespace prune {
         return m_state.scene_options;
     }
 
+    std::span<const SceneEvent> WorldScene::pending_scene_events() const noexcept
+    {
+        return m_state.events.pending();
+    }
+
+    void WorldScene::clear_scene_events() noexcept
+    {
+        m_state.events.clear();
+    }
+
     EditorTool WorldScene::current_editor_tool() const noexcept
     {
         return m_state.editor_tool;
diff --git a/src/prune/scene/world_scene.hpp b/src/prune/scene/world_scene.hpp
index aaa4015..5c7db2e 100644
--- a/src/prune/scene/world_scene.hpp
+++ b/src/prune/scene/world_scene.hpp
@@ -39,6 +39,8 @@ namespace prune {
         bool undo_editor_command() final;
         bool redo_editor_command() final;
         SceneOptions& get_scene_options() final;
+        [[nodiscard]] std::span<const SceneEvent> pending_scene_events() const noexcept final;
+        void clear_scene_events() noexcept final;
         [[nodiscard]] EditorTool current_editor_tool() const noexcept final;
         void set_current_editor_tool(EditorTool tool) noexcept final;
         bool execute_scene_creation_action(std::string_view action_id) final;
diff --git a/src/prune/tooling/ui.cpp b/src/prune/tooling/ui.cpp
index bfaa6c0..7504c75 100644
--- a/src/prune/tooling/ui.cpp
+++ b/src/prune/tooling/ui.cpp
@@ -260,7 +260,9 @@ namespace prune {
         SDL_Renderer* renderer,
         bool& new_scene_requested,
         SceneType& new_scene_type,
-        bool& load_scene_requested
+        bool& load_scene_requested,
+        bool& audio_enabled,
+        bool audio_available
     )
     {
         draw_scene_viewport(scene, renderer);
@@ -323,6 +325,21 @@ namespace prune {
                 ImGui::EndMenu();
             }
 
+            if (ImGui::BeginMenu("Audio")) {
+                if (!audio_available) {
+                    ImGui::BeginDisabled();
+                }
+
+                ImGui::MenuItem("Sound Enabled", nullptr, &audio_enabled);
+
+                if (!audio_available) {
+                    ImGui::EndDisabled();
+                    ImGui::TextDisabled("Audio device unavailable");
+                }
+
+                ImGui::EndMenu();
+            }
+
             if (ImGui::BeginMenu("View")) {
                 ImGui::MenuItem("Scene", nullptr, &m_show_scene_viewport);
                 ImGui::MenuItem("Outliner", nullptr, &m_show_outliner);
diff --git a/src/prune/tooling/ui.hpp b/src/prune/tooling/ui.hpp
index bae0b6d..f024462 100644
--- a/src/prune/tooling/ui.hpp
+++ b/src/prune/tooling/ui.hpp
@@ -25,7 +25,9 @@ namespace prune {
             SDL_Renderer* renderer,
             bool& new_scene_requested,
             SceneType& new_scene_type,
-            bool& load_scene_requested
+            bool& load_scene_requested,
+            bool& audio_enabled,
+            bool audio_available
         );
         void render_scene_viewport_content(Scene& scene, SDL_Renderer* renderer);
         void set_file_status(std::string status, bool is_error);