diff --git a/.vscode/settings.json b/.vscode/settings.json
index ea34286..1a79a42 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -11,6 +11,6 @@
         "source.fixAll.dotnet": "explicit"
     },
     "[csharp]": {
-        "editor.defaultFormatter": "ms-dotnettools.csharp"
+        "editor.defaultFormatter": "csharpier.csharpier-vscode"
     }
 }
\ No newline at end of file
diff --git a/samples/pong/Game.cs b/samples/pong/Game.cs
index 4fc1f7e..0c15cdc 100644
--- a/samples/pong/Game.cs
+++ b/samples/pong/Game.cs
@@ -1,4 +1,5 @@
 using rasdaq;
+using rasdaq.Audio;
 using rasdaq.Core.ECS;
 using rasdaq.Graphics;
 using rasdaq.Resources;
diff --git a/samples/pong/Soldier.cs b/samples/pong/Soldier.cs
index e675c5b..ef77e26 100644
--- a/samples/pong/Soldier.cs
+++ b/samples/pong/Soldier.cs
@@ -1,23 +1,34 @@
-using rasdaq;
+using OpenTK.Audio.OpenAL;
+using rasdaq;
+using rasdaq.Audio;
 using rasdaq.Core.ECS;
 using rasdaq.Graphics;
 using rasdaq.Inputs;
 using rasdaq.Logging;
+using rasdaq.Resources;
 using rasdaq.Transformations;
 
 namespace pong;
 
 internal class Soldier : Component
 {
+    AudioSource _audioSource;
+
     public override void Start()
     {
         base.Start();
+
+        Audio audio1 = ResourceManager.Load<Audio>("assets/laser.wav");
+        AudioSource source = new();
+        // source.Handle = audio1.Handle;
+        source.SetAudio(audio1);
+        _audioSource = source;
+        Entity.AddComponent(source);
     }
 
     public override void Update(double deltaTime)
     {
         base.Update(deltaTime);
-
     }
 
     public override void FrameUpdate(double deltaTime)
@@ -29,6 +40,16 @@ public override void FrameUpdate(double deltaTime)
             Entity.Transform.RotateFromPoint(new Vector2(800, 200), 90);
         }
 
+        if (Input.IsKeyPressed(Keys.Space))
+        {
+            _audioSource.Play();
+        }
+
+        if (Input.IsKeyPressed(Keys.LeftShift))
+        {
+            _audioSource.Stop();
+        }
+
         PhysicsBody? body = Entity?.GetComponent<PhysicsBody>();
 
         if (Input.IsKeyDown(Keys.W))
@@ -70,6 +91,10 @@ public override void FrameUpdate(double deltaTime)
             var x = Entity?.Transform.position.X - (Application.WindowSize?.X / 2) ?? 0;
             var y = Entity?.Transform.position.Y - (Application.WindowSize?.Y / 2) ?? 0;
             Renderer.Instance.Camera.SetPosition(x, y);
+            if (Input.IsKeyDown(Keys.W))
+            {
+                ALContext context = ALC.GetCurrentContext();
+            }
         }
     }
 }
diff --git a/samples/pong/assets/laser.wav b/samples/pong/assets/laser.wav
new file mode 100644
index 0000000..f14037e
Binary files /dev/null and b/samples/pong/assets/laser.wav differ
diff --git a/src/rasdaq/Application.cs b/src/rasdaq/Application.cs
index fb04ec6..f5ae3df 100644
--- a/src/rasdaq/Application.cs
+++ b/src/rasdaq/Application.cs
@@ -1,6 +1,8 @@
 using OpenTK.Graphics.OpenGL4;
 using OpenTK.Windowing.Common;
 using OpenTK.Windowing.Desktop;
+
+using rasdaq.Audio;
 using rasdaq.Core.ECS;
 using rasdaq.Graphics;
 using rasdaq.Inputs;
@@ -20,17 +22,13 @@ public class Application : IDisposable
     /// <summary>
     /// The <c>Application</c> instance is created after <c>Run</c> is called.
     /// </summary>
+    private static Application? _instance;
     public static Application Instance
     {
         get => _instance ?? throw new InvalidOperationException("Application not started. Call Run() first.");
         private set => _instance = value;
     }
-    private static Application? _instance;
     public static Vector2? WindowSize => Instance._gameWindow?.Size;
-    /// <summary>
-    /// Return list of instantiated <c>Worlds</c>.
-    /// </summary>
-    public List<World> Worlds => _worlds.Objects;
 
     private InputManager? _inputManager;
     internal InputManager InputManager
@@ -39,7 +37,13 @@ internal InputManager InputManager
         private set => _inputManager = value;
     }
 
+    public AudioManager AudioManager { get; private set; }
+
     private FlushEnumerable<World> _worlds = new();
+    /// <summary>
+    /// Return list of instantiated <c>Worlds</c>.
+    /// </summary>
+    public List<World> Worlds => _worlds.Objects;
 
     private GameWindow? _gameWindow;
     internal GameWindow GameWindow
@@ -86,6 +90,7 @@ public void Run(int width, int height, string title)
         GameWindow.FramebufferResize += OnFramebufferResize;
 
         InputManager = new InputManager(new GameWindowWrapper(GameWindow));
+        AudioManager = new AudioManager();
 
         InputManager.SetEventListeners();
         GameWindow.Run();
diff --git a/src/rasdaq/Audio/Audio.cs b/src/rasdaq/Audio/Audio.cs
new file mode 100644
index 0000000..0ec230e
--- /dev/null
+++ b/src/rasdaq/Audio/Audio.cs
@@ -0,0 +1,28 @@
+using OpenTK.Audio.OpenAL;
+using rasdaq.Logging;
+
+namespace rasdaq.Audio;
+
+public class Audio : IDisposable
+{
+    internal int Handle;
+
+    public Audio()
+    {
+        Handle = AL.GenBuffer();
+        // Check for errors
+        ALError error = AL.GetError();
+        if (error != ALError.NoError)
+        {
+            string err = $"OpenAL error while trying to create audio buffer: {error}";
+
+            Log.Error(err);
+            throw new Exception(err);
+        }
+    }
+
+    public void Dispose()
+    {
+        AL.DeleteBuffer(Handle);
+    }
+}
diff --git a/src/rasdaq/Audio/AudioLoader.cs b/src/rasdaq/Audio/AudioLoader.cs
new file mode 100644
index 0000000..8ea563d
--- /dev/null
+++ b/src/rasdaq/Audio/AudioLoader.cs
@@ -0,0 +1,13 @@
+using OpenTK.Audio.OpenAL;
+using rasdaq.Logging;
+using rasdaq.Resources;
+
+namespace rasdaq.Audio;
+
+public class AudioLoader : IResourceLoader
+{
+    public object Load(string path)
+    {
+        return AudioManager.Instance.LoadAudio(path);
+    }
+}
diff --git a/src/rasdaq/Audio/AudioManager.cs b/src/rasdaq/Audio/AudioManager.cs
new file mode 100644
index 0000000..8ad0742
--- /dev/null
+++ b/src/rasdaq/Audio/AudioManager.cs
@@ -0,0 +1,176 @@
+using OpenTK.Audio.OpenAL;
+using rasdaq.Logging;
+
+namespace rasdaq.Audio;
+
+public class AudioManager
+{
+    public static AudioManager Instance
+    {
+        get
+        {
+            if (_instance == null)
+            {
+                _instance = new();
+            }
+
+            return _instance;
+        }
+    }
+
+    private static AudioManager _instance;
+
+    private static void CheckALCError(ALDevice device)
+    {
+        AlcError error = ALC.GetError(device);
+        if (error != AlcError.NoError)
+        {
+            string err = $"OpenAL error: {error}";
+            Log.Error(err);
+            throw new Exception(err);
+        }
+    }
+
+    public static void CheckALError()
+    {
+        ALError error = AL.GetError();
+        if (error != ALError.NoError)
+        {
+            string err = $"OpenAL error: {error}";
+            Log.Error(err);
+            throw new Exception(err);
+        }
+    }
+
+    /// <summary>
+    /// Initialize Audio for the Application, using the default audio device.
+    /// </summary>
+    /// <exception cref="Exception"></exception>
+    public AudioManager()
+    {
+        // Open the default audio device.
+        ALDevice device = ALC.OpenDevice(null);
+        if (device == ALDevice.Null)
+        {
+            string err = "Failed to open the default audio device.";
+            Log.Error(err);
+            throw new Exception(err);
+        }
+
+        // Create a context for the device.
+        ALContext context = ALC.CreateContext(
+            device,
+            new ALContextAttributes(null, null, null, null, null)
+        );
+        if (context == ALContext.Null)
+        {
+            ALC.CloseDevice(device);
+            string err = "Failed to create an OpenAL context.";
+            Log.Error(err);
+            throw new Exception(err);
+        }
+
+        // Check if we have any errors.
+        AlcError error = ALC.GetError(device);
+        CheckALCError(device);
+        // If no errors, make the context current.
+        ALC.MakeContextCurrent(context);
+    }
+
+    /// <summary>
+    /// Load a WAV file that contains PCM data only.
+    /// </summary>
+    /// <param name="path">Path to WAV file</param>
+    /// <returns>A integer handle referring to the loaded audio</returns>
+    /// <exception cref="Exception"></exception>
+    internal Audio LoadAudio(string path)
+    {
+        // Create an OpenAL buffer for the data to go in.
+        Audio audio = new Audio();
+
+        // Load the WAV file
+        WAVLoader.WAVData wavData = WAVLoader.LoadWav(path);
+
+        // Discern the format of the audio data based on number of channels and bits per sample.
+        ALFormat format;
+        if (wavData.Format.NumChannels == 1)
+        {
+            if (wavData.Format.BitsPerSample == 8)
+            {
+                format = ALFormat.Mono8;
+            }
+            else if (wavData.Format.BitsPerSample == 16)
+            {
+                format = ALFormat.Mono16;
+            }
+            else
+            {
+                string err = $"Unsupported bits per sample: {wavData.Format.BitsPerSample}";
+                Log.Error(err);
+                throw new Exception(err);
+            }
+        }
+        else if (wavData.Format.NumChannels == 2)
+        {
+            if (wavData.Format.BitsPerSample == 8)
+            {
+                format = ALFormat.Stereo8;
+            }
+            else if (wavData.Format.BitsPerSample == 16)
+            {
+                format = ALFormat.Stereo16;
+            }
+            else
+            {
+                string err = $"Unsupported bits per sample: {wavData.Format.BitsPerSample}";
+                Log.Error(err);
+                throw new Exception(err);
+            }
+        }
+        else
+        {
+            string err = $"Unsupported number of channels: {wavData.Format.NumChannels}";
+            Log.Error(err);
+            throw new Exception(err);
+        }
+
+        // Load the audio data into the OpenAL buffer.
+        AL.BufferData(audio.Handle, format, wavData.Data.Data, (int)wavData.Format.SampleRate);
+
+        // Check if we have any errors from trying to load the audio data.
+        CheckALError();
+
+        return audio;
+    }
+
+    /// <summary>
+    /// Add a loaded audio file to an audio source, so that it can be played.
+    /// </summary>
+    /// <param name="audio">Audio file</param>
+    /// <param name="audioSource">Audio source</param>
+    internal void AttachAudioToSource(Audio audio, AudioSource audioSource)
+    {
+        AL.Source(audioSource.Handle, ALSourcei.Buffer, audio.Handle);
+        CheckALError();
+    }
+
+    /// <summary>
+    /// Play back an audio source that has audio attached to it.
+    /// </summary>
+    /// <param name="source"></param>
+    internal void PlaySource(AudioSource audioSource)
+    {
+        AL.SourcePlay(audioSource.Handle);
+        CheckALError();
+    }
+
+    /// <summary>
+    /// Stop playback of an audio source.
+    /// </summary>
+    /// <param name="source"></param>
+    internal void StopSource(AudioSource audioSource)
+    {
+        AL.SourceStop(audioSource.Handle);
+        CheckALError();
+    }
+}
diff --git a/src/rasdaq/Audio/AudioSource.cs b/src/rasdaq/Audio/AudioSource.cs
new file mode 100644
index 0000000..00f4b3c
--- /dev/null
+++ b/src/rasdaq/Audio/AudioSource.cs
@@ -0,0 +1,61 @@
+using OpenTK.Audio.OpenAL;
+using rasdaq.Core.ECS;
+using rasdaq.Logging;
+
+namespace rasdaq.Audio;
+
+public class AudioSource : Component, IDisposable
+{
+    internal int Handle;
+    public Audio AudioClip;
+
+    public AudioSource(Audio? audioClip = null)
+    {
+        Handle = AL.GenSource();
+        // Check for errors
+        ALError error = AL.GetError();
+        if (error != ALError.NoError)
+        {
+            string err = $"OpenAL error while trying to create audio source: {error}";
+
+            Log.Error(err);
+            throw new Exception("OpenAL error while trying to create audio source: " + error);
+        }
+
+        if (audioClip != null)
+        {
+            SetAudio(audioClip);
+        }
+    }
+
+    public void Dispose()
+    {
+        AL.DeleteSource(Handle);
+    }
+
+    /// <summary>
+    /// Plays the loaded audio clip.
+    /// </summary>
+    public void Play()
+    {
+        AudioManager.Instance.PlaySource(this);
+    }
+
+    /// <summary>
+    /// Stops playing the audio source.
+    /// </summary>
+    public void Stop()
+    {
+        AudioManager.Instance.StopSource(this);
+    }
+
+    /// <summary>
+    /// Sets the audio clip of the audio source.
+    /// </summary>
+    /// <param name="audioClip"></param>
+    public void SetAudio(Audio audioClip)
+    {
+        AudioManager.Instance.AttachAudioToSource(audioClip, this);
+        this.AudioClip = audioClip;
+    }
+}
diff --git a/src/rasdaq/Audio/WAVLoader.cs b/src/rasdaq/Audio/WAVLoader.cs
new file mode 100644
index 0000000..2a8449c
--- /dev/null
+++ b/src/rasdaq/Audio/WAVLoader.cs
@@ -0,0 +1,246 @@
+using OpenTK.Audio.OpenAL;
+using rasdaq.Logging;
+using rasdaq.Resources;
+using System.Buffers.Binary;
+using System.Text;
+
+namespace rasdaq.Audio;
+
+internal class WAVLoader : IResourceLoader
+{
+    /// <summary>
+    /// Format information about the WAV file.
+    /// </summary>
+    public struct FmtChunk
+    {
+        public ushort AudioFormat;
+        public ushort NumChannels;
+        public uint SampleRate;
+        public uint ByteRate;
+        public ushort BlockAlign;
+        public ushort BitsPerSample;
+        public FmtChunkExtension? Extension;
+    };
+
+    /// <summary>
+    /// Extra format information for certain WAV files.
+    /// </summary>
+    public struct FmtChunkExtension
+    {
+        public ushort ValidBitsPerSample;
+        public uint SpeakerPositionMask;
+        public Guid SubFormat;
+    }
+
+    /// <summary>
+    /// Holds the data of the WAV file, should be PCM data, as that is all is supported currently.
+    /// </summary>
+    public struct DataChunk
+    {
+        public uint Size;
+        public byte[] Data;
+    }
+
+    /// <summary>
+    /// Holds all the information necessary about a WAV file, namely,
+    /// the format information and the data itself.
+    /// </summary>
+    public struct WAVData
+    {
+        public FmtChunk Format;
+        public DataChunk Data;
+    }
+
+    private static byte[] ReadBytesFromStream(FileStream stream, int count)
+    {
+        byte[] buffer = new byte[count];
+        stream.ReadExactly(buffer, 0, count);
+        return buffer;
+    }
+
+    private static FmtChunk ProcessFmtChunck(FileStream stream)
+    {
+        uint size = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4));
+
+        FmtChunk chunk = new FmtChunk();
+        chunk.AudioFormat = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2));
+        chunk.NumChannels = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2));
+        chunk.SampleRate = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4));
+        chunk.ByteRate = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4));
+        chunk.BlockAlign = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2));
+        chunk.BitsPerSample = BinaryPrimitives.ReadUInt16LittleEndian(
+            ReadBytesFromStream(stream, 2)
+        );
+
+        if (size > 16)
+        {
+            ushort extensionSize = BinaryPrimitives.ReadUInt16LittleEndian(
+                ReadBytesFromStream(stream, 2)
+            );
+            if (extensionSize == 22)
+            {
+                chunk.Extension = new FmtChunkExtension()
+                {
+                    ValidBitsPerSample = BinaryPrimitives.ReadUInt16LittleEndian(
+                        ReadBytesFromStream(stream, 2)
+                    ),
+                    SpeakerPositionMask = BinaryPrimitives.ReadUInt32LittleEndian(
+                        ReadBytesFromStream(stream, 4)
+                    ),
+                    SubFormat = new Guid(ReadBytesFromStream(stream, 16)),
+                };
+            }
+        }
+
+        return chunk;
+    }
+
+    private static DataChunk ProcessDataChunk(FileStream stream)
+    {
+        DataChunk chunk = new DataChunk();
+        chunk.Size = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4));
+        chunk.Data = ReadBytesFromStream(stream, (int)chunk.Size);
+        return chunk;
+    }
+
+    /// <summary>
+    /// Load the WAV file at the given path and return a WAVData struct containing the format information and the data itself.
+    /// </summary>
+    /// <param name="path">The path to the WAV file.</param>
+    /// <returns>A WAVData struct containing the format information and the data.</returns>
+    /// <exception cref="Exception">Thrown if the WAV file is not found or is invalid.</exception>
+    public static WAVData LoadWav(string path)
+    {
+        if (!File.Exists(path))
+        {
+            throw new Exception("WAV file not found: " + path);
+        }
+
+        using (FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read))
+        {
+            // Read the RIFF header at the start of the WAV file.
+            byte[] fourcc = new byte[4];
+            stream.ReadExactly(fourcc, 0, 4);
+            if (Encoding.ASCII.GetString(fourcc) != "RIFF")
+            {
+                throw new Exception("Invalid WAV file: missing RIFF header.");
+            }
+
+            // Read the file size
+            byte[] byteFileSize = new byte[4];
+            stream.ReadExactly(byteFileSize, 0, 4);
+            int fileSize = BinaryPrimitives.ReadInt32LittleEndian(byteFileSize) - 4;
+
+            // Check file type is WAVE
+            byte[] byteFileType = new byte[4];
+            stream.ReadExactly(byteFileType, 0, 4);
+            Encoding.UTF8.GetString(byteFileType);
+            if (Encoding.ASCII.GetString(byteFileType) != "WAVE")
+            {
+                throw new Exception(
+                    "Invalid WAV file: file type not listed as WAVE in RIFF header."
+                );
+            }
+
+            FmtChunk fmtChunk = new FmtChunk();
+            DataChunk dataChunk = new DataChunk();
+
+            // Now read the remaining chunks, we want a fmt chunk and a data chunk.
+            while (stream.Position < stream.Length - 4)
+            {
+                byte[] chunkId = new byte[4];
+                stream.ReadExactly(chunkId, 0, 4);
+
+                if (chunkId.SequenceEqual(Encoding.ASCII.GetBytes("fmt ")))
+                {
+                    fmtChunk = ProcessFmtChunck(stream);
+
+                    if (fmtChunk.AudioFormat != 1)
+                    {
+                        throw new Exception("Unsupported WAV file: only PCM format is supported.");
+                    }
+                }
+                else if (chunkId.SequenceEqual(Encoding.ASCII.GetBytes("data")))
+                {
+                    dataChunk = ProcessDataChunk(stream);
+                    break;
+                }
+                else
+                {
+                    throw new Exception(
+                        "Unsupported WAV file: unknown chunk type "
+                            + Encoding.ASCII.GetString(chunkId)
+                    );
+                }
+            }
+
+            return new WAVData() { Format = fmtChunk, Data = dataChunk };
+        }
+    }
+
+    /// <summary>
+    /// Load a WAV file that contains PCM data only.
+    /// </summary>
+    /// <param name="path">Path to WAV file</param>
+    /// <returns>A integer handle referring to the loaded audio</returns>
+    /// <exception cref="Exception"></exception>
+    public object Load(string path)
+    {
+        // Create an OpenAL buffer for the data to go in.
+        Audio audio = new();
+
+        // Load the WAV file
+        WAVData wavData = LoadWav(path);
+
+        // Discern the format of the audio data based on number of channels and bits per sample.
+        ALFormat format;
+        if (wavData.Format.NumChannels == 1)
+        {
+            if (wavData.Format.BitsPerSample == 8)
+            {
+                format = ALFormat.Mono8;
+            }
+            else if (wavData.Format.BitsPerSample == 16)
+            {
+                format = ALFormat.Mono16;
+            }
+            else
+            {
+                string err = $"Unsupported bits per sample: {wavData.Format.BitsPerSample}";
+                Log.Error(err);
+                throw new Exception(err);
+            }
+        }
+        else if (wavData.Format.NumChannels == 2)
+        {
+            if (wavData.Format.BitsPerSample == 8)
+            {
+                format = ALFormat.Stereo8;
+            }
+            else if (wavData.Format.BitsPerSample == 16)
+            {
+                format = ALFormat.Stereo16;
+            }
+            else
+            {
+                string err = $"Unsupported bits per sample: {wavData.Format.BitsPerSample}";
+                Log.Error(err);
+                throw new Exception(err);
+            }
+        }
+        else
+        {
+            string err = $"Unsupported number of channels: {wavData.Format.NumChannels}";
+            Log.Error(err);
+            throw new Exception(err);
+        }
+
+        // Load the audio data into the OpenAL buffer.
+        AL.BufferData(audio.Handle, format, wavData.Data.Data, (int)wavData.Format.SampleRate);
+
+        // Check if we have any errors from trying to load the audio data.
+        AudioManager.CheckALError();
+
+        return audio;
+    }
+}
diff --git a/src/rasdaq/Resources/ResourceManager.cs b/src/rasdaq/Resources/ResourceManager.cs
index 852088f..96a572a 100644
--- a/src/rasdaq/Resources/ResourceManager.cs
+++ b/src/rasdaq/Resources/ResourceManager.cs
@@ -1,4 +1,5 @@
-using rasdaq.Logging;
+using rasdaq.Audio;
+using rasdaq.Logging;
 using rasdaq.Resources.Loaders;
 
 namespace rasdaq.Resources;
@@ -17,6 +18,7 @@ static ResourceManager()
         _loaders["txt"] = new TextLoader();
         _loaders["png"] = new TextureLoader();
         _loaders["jpg"] = new TextureLoader();
+        _loaders["wav"] = new AudioLoader();
     }
 
     /// <summary>