diff --git a/ChocolArm64/Instruction/AInstEmitSimdCvt.cs b/ChocolArm64/Instruction/AInstEmitSimdCvt.cs
index 98bb972a2d..da584743c3 100644
--- a/ChocolArm64/Instruction/AInstEmitSimdCvt.cs
+++ b/ChocolArm64/Instruction/AInstEmitSimdCvt.cs
@@ -45,10 +45,10 @@ namespace ChocolArm64.Instruction
             {
                 if (SizeF == 0)
                 {
-                    //TODO: This need the half precision floating point type,
-                    //that is not yet supported on .NET. We should probably
-                    //do our own implementation on the meantime.
-                    throw new NotImplementedException();
+                    EmitVectorExtractZx(Context, Op.Rn, Part + Index, 1);
+                    Context.Emit(OpCodes.Conv_U2);
+
+                    Context.EmitCall(typeof(ASoftFloat), nameof(ASoftFloat.ConvertHalfToSingle));
                 }
                 else /* if (SizeF == 1) */
                 {
diff --git a/ChocolArm64/Instruction/AInstEmitSimdMove.cs b/ChocolArm64/Instruction/AInstEmitSimdMove.cs
index 95fe594994..d67946a977 100644
--- a/ChocolArm64/Instruction/AInstEmitSimdMove.cs
+++ b/ChocolArm64/Instruction/AInstEmitSimdMove.cs
@@ -339,9 +339,12 @@ namespace ChocolArm64.Instruction
 
                 EmitVectorExtractZx(Context, (Index & 1) == 0 ? Op.Rn : Op.Rm, Elem, Op.Size);
 
-                EmitVectorInsert(Context, Op.Rd, Index, Op.Size);
+                EmitVectorInsertTmp(Context, Index, Op.Size);
             }
 
+            Context.EmitLdvectmp();
+            Context.EmitStvec(Op.Rd);
+
             if (Op.RegisterSize == ARegisterSize.SIMD64)
             {
                 EmitVectorZeroUpper(Context, Op.Rd);
@@ -363,9 +366,12 @@ namespace ChocolArm64.Instruction
 
                 EmitVectorExtractZx(Context, Index < Half ? Op.Rn : Op.Rm, Elem, Op.Size);
 
-                EmitVectorInsert(Context, Op.Rd, Index, Op.Size);
+                EmitVectorInsertTmp(Context, Index, Op.Size);
             }
 
+            Context.EmitLdvectmp();
+            Context.EmitStvec(Op.Rd);
+
             if (Op.RegisterSize == ARegisterSize.SIMD64)
             {
                 EmitVectorZeroUpper(Context, Op.Rd);
@@ -387,9 +393,12 @@ namespace ChocolArm64.Instruction
 
                 EmitVectorExtractZx(Context, (Index & 1) == 0 ? Op.Rn : Op.Rm, Elem, Op.Size);
 
-                EmitVectorInsert(Context, Op.Rd, Index, Op.Size);
+                EmitVectorInsertTmp(Context, Index, Op.Size);
             }
 
+            Context.EmitLdvectmp();
+            Context.EmitStvec(Op.Rd);
+
             if (Op.RegisterSize == ARegisterSize.SIMD64)
             {
                 EmitVectorZeroUpper(Context, Op.Rd);
diff --git a/ChocolArm64/Instruction/ASoftFloat.cs b/ChocolArm64/Instruction/ASoftFloat.cs
index e63c82beea..27f4f7fb4f 100644
--- a/ChocolArm64/Instruction/ASoftFloat.cs
+++ b/ChocolArm64/Instruction/ASoftFloat.cs
@@ -225,5 +225,41 @@ namespace ChocolArm64.Instruction
 
             return 2.0 + op1 * op2;
         }
+
+        public static float ConvertHalfToSingle(ushort x)
+        {
+            uint x_sign = (uint)(x >> 15) & 0x0001;
+            uint x_exp = (uint)(x >> 10) & 0x001F;
+            uint x_mantissa = (uint)x & 0x03FF;
+
+            if (x_exp == 0 && x_mantissa == 0)
+            {
+                // Zero
+                return BitConverter.Int32BitsToSingle((int)(x_sign << 31));
+            }
+
+            if (x_exp == 0x1F)
+            {
+                // NaN or Infinity
+                return BitConverter.Int32BitsToSingle((int)((x_sign << 31) | 0x7F800000 | (x_mantissa << 13)));
+            }
+
+            int exponent = (int)x_exp - 15;
+
+            if (x_exp == 0)
+            {
+                // Denormal
+                x_mantissa <<= 1;
+                while ((x_mantissa & 0x0400) == 0)
+                {
+                    x_mantissa <<= 1;
+                    exponent--;
+                }
+                x_mantissa &= 0x03FF;
+            }
+
+            uint new_exp = (uint)((exponent + 127) & 0xFF) << 23;
+            return BitConverter.Int32BitsToSingle((int)((x_sign << 31) | new_exp | (x_mantissa << 13)));
+        }
     }
 }
\ No newline at end of file
diff --git a/README.md b/README.md
index 71dad9ce29..f6bac98c8c 100644
--- a/README.md
+++ b/README.md
@@ -85,6 +85,8 @@ If you have some homebrew that currently doesn't work within the emulator, you c
 For help, support, suggestions, or if you just want to get in touch with the team; join our Discord server!  
 https://discord.gg/VkQYXAZ
 
+For donation support, please take a look at our Patreon: https://www.patreon.com/ryujinx
+
 **Running**
 
 To run this emulator, you need the .NET Core 2.1 (or higher) SDK *and* the OpenAL 11 Core SDK.  
@@ -92,6 +94,7 @@ Run `dotnet run -c Release -- path\to\homebrew.nro` inside the Ryujinx solution
 Run `dotnet run -c Release -- path\to\game_exefs_and_romfs_folder` to run official games (they need to be decrypted and extracted first!)
 
 **Compatibility**
+
 You can check out the compatibility list within the Wiki. Only a handful of games actually work.
 
 **Latest build**
diff --git a/Ryujinx.Audio/OpenAL/OpenALAudioOut.cs b/Ryujinx.Audio/OpenAL/OpenALAudioOut.cs
index f574b46f38..2860dc2e2d 100644
--- a/Ryujinx.Audio/OpenAL/OpenALAudioOut.cs
+++ b/Ryujinx.Audio/OpenAL/OpenALAudioOut.cs
@@ -20,7 +20,7 @@ namespace Ryujinx.Audio.OpenAL
             public int SourceId { get; private set; }
 
             public int SampleRate { get; private set; }
-            
+
             public ALFormat Format { get; private set; }
 
             private ReleaseCallback Callback;
@@ -153,7 +153,7 @@ namespace Ryujinx.Audio.OpenAL
                     ShouldCallReleaseCallback = true;
                 }
             }
-            
+
             private void SyncQueuedTags()
             {
                 AL.GetSource(SourceId, ALGetSourcei.BuffersQueued,    out int QueuedCount);
@@ -249,11 +249,6 @@ namespace Ryujinx.Audio.OpenAL
 
         private ALFormat GetALFormat(int Channels, AudioFormat Format)
         {
-            if (Channels < 1 || Channels > 2)
-            {
-                throw new ArgumentOutOfRangeException(nameof(Channels));
-            }
-
             if (Channels == 1)
             {
                 switch (Format)
@@ -262,7 +257,7 @@ namespace Ryujinx.Audio.OpenAL
                     case AudioFormat.PcmInt16: return ALFormat.Mono16;
                 }
             }
-            else /* if (Channels == 2) */
+            else if (Channels == 2)
             {
                 switch (Format)
                 {
@@ -270,6 +265,18 @@ namespace Ryujinx.Audio.OpenAL
                     case AudioFormat.PcmInt16: return ALFormat.Stereo16;
                 }
             }
+            else if (Channels == 6)
+            {
+                switch (Format)
+                {
+                    case AudioFormat.PcmInt8:  return ALFormat.Multi51Chn8Ext;
+                    case AudioFormat.PcmInt16: return ALFormat.Multi51Chn16Ext;
+                }
+            }
+            else
+            {
+                throw new ArgumentOutOfRangeException(nameof(Channels));
+            }
 
             throw new ArgumentException(nameof(Format));
         }
@@ -288,7 +295,7 @@ namespace Ryujinx.Audio.OpenAL
             {
                 return Td.ContainsBuffer(Tag);
             }
-            
+
             return false;
         }
 
@@ -298,7 +305,7 @@ namespace Ryujinx.Audio.OpenAL
             {
                 return Td.GetReleasedBuffers(MaxCount);
             }
-            
+
             return null;
         }
 
diff --git a/Ryujinx.Graphics/Gal/GalTextureFormat.cs b/Ryujinx.Graphics/Gal/GalTextureFormat.cs
index 7d19dc26d4..231d33ec0e 100644
--- a/Ryujinx.Graphics/Gal/GalTextureFormat.cs
+++ b/Ryujinx.Graphics/Gal/GalTextureFormat.cs
@@ -17,6 +17,7 @@ namespace Ryujinx.Graphics.Gal
         BC3          = 0x26,
         BC4          = 0x27,
         BC5          = 0x28,
+        ZF32         = 0x2f,
         Astc2D4x4    = 0x40,
         Astc2D5x5    = 0x41,
         Astc2D6x6    = 0x42,
diff --git a/Ryujinx.Graphics/Gal/IGalRasterizer.cs b/Ryujinx.Graphics/Gal/IGalRasterizer.cs
index 2598efb610..0c5d37e40e 100644
--- a/Ryujinx.Graphics/Gal/IGalRasterizer.cs
+++ b/Ryujinx.Graphics/Gal/IGalRasterizer.cs
@@ -2,6 +2,9 @@ namespace Ryujinx.Graphics.Gal
 {
     public interface IGalRasterizer
     {
+        void LockCaches();
+        void UnlockCaches();
+
         void ClearBuffers(GalClearBufferFlags Flags);
 
         bool IsVboCached(long Key, long DataSize);
@@ -46,9 +49,9 @@ namespace Ryujinx.Graphics.Gal
 
         void CreateIbo(long Key, byte[] Buffer);
 
-        void SetVertexArray(int VbIndex, int Stride, long VboKey, GalVertexAttrib[] Attribs);
+        void SetVertexArray(int Stride, long VboKey, GalVertexAttrib[] Attribs);
 
-        void SetIndexArray(long Key, int Size, GalIndexFormat Format);
+        void SetIndexArray(int Size, GalIndexFormat Format);
 
         void DrawArrays(int First, int PrimCount, GalPrimitiveType PrimType);
 
diff --git a/Ryujinx.Graphics/Gal/IGalTexture.cs b/Ryujinx.Graphics/Gal/IGalTexture.cs
index 6379e73af4..2ab4119904 100644
--- a/Ryujinx.Graphics/Gal/IGalTexture.cs
+++ b/Ryujinx.Graphics/Gal/IGalTexture.cs
@@ -2,6 +2,9 @@ namespace Ryujinx.Graphics.Gal
 {
     public interface IGalTexture
     {
+        void LockCache();
+        void UnlockCache();
+
         void Create(long Key, byte[] Data, GalTexture Texture);
 
         bool TryGetCachedTexture(long Key, long DataSize, out GalTexture Texture);
diff --git a/Ryujinx.Graphics/Gal/OpenGL/OGLCachedResource.cs b/Ryujinx.Graphics/Gal/OpenGL/OGLCachedResource.cs
index 06d76b8bdd..01ebf98202 100644
--- a/Ryujinx.Graphics/Gal/OpenGL/OGLCachedResource.cs
+++ b/Ryujinx.Graphics/Gal/OpenGL/OGLCachedResource.cs
@@ -36,6 +36,10 @@ namespace Ryujinx.Graphics.Gal.OpenGL
 
         private DeleteValue DeleteValueCallback;
 
+        private Queue<T> DeletePending;
+
+        private bool Locked;
+
         public OGLCachedResource(DeleteValue DeleteValueCallback)
         {
             if (DeleteValueCallback == null)
@@ -48,11 +52,33 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             Cache = new Dictionary<long, CacheBucket>();
 
             SortedCache = new LinkedList<long>();
+
+            DeletePending = new Queue<T>();
+        }
+
+        public void Lock()
+        {
+            Locked = true;
+        }
+
+        public void Unlock()
+        {
+            Locked = false;
+
+            while (DeletePending.TryDequeue(out T Value))
+            {
+                DeleteValueCallback(Value);
+            }
+
+            ClearCacheIfNeeded();
         }
 
         public void AddOrUpdate(long Key, T Value, long Size)
         {
-            ClearCacheIfNeeded();
+            if (!Locked)
+            {
+                ClearCacheIfNeeded();
+            }
 
             LinkedListNode<long> Node = SortedCache.AddLast(Key);
 
@@ -60,7 +86,14 @@ namespace Ryujinx.Graphics.Gal.OpenGL
 
             if (Cache.TryGetValue(Key, out CacheBucket Bucket))
             {
-                DeleteValueCallback(Bucket.Value);
+                if (Locked)
+                {
+                    DeletePending.Enqueue(Bucket.Value);
+                }
+                else
+                {
+                    DeleteValueCallback(Bucket.Value);
+                }
 
                 SortedCache.Remove(Bucket.Node);
 
@@ -78,6 +111,12 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             {
                 Value = Bucket.Value;
 
+                SortedCache.Remove(Bucket.Node);
+
+                LinkedListNode<long> Node = SortedCache.AddLast(Key);
+
+                Cache[Key] = new CacheBucket(Value, Bucket.DataSize, Node);
+
                 return true;
             }
 
diff --git a/Ryujinx.Graphics/Gal/OpenGL/OGLEnumConverter.cs b/Ryujinx.Graphics/Gal/OpenGL/OGLEnumConverter.cs
index 3a81150d6f..8f189d2b08 100644
--- a/Ryujinx.Graphics/Gal/OpenGL/OGLEnumConverter.cs
+++ b/Ryujinx.Graphics/Gal/OpenGL/OGLEnumConverter.cs
@@ -129,15 +129,16 @@ namespace Ryujinx.Graphics.Gal.OpenGL
         {
             switch (Format)
             {
-                case GalTextureFormat.R32G32B32A32: return (PixelFormat.Rgba, PixelType.Float);
-                case GalTextureFormat.R16G16B16A16: return (PixelFormat.Rgba, PixelType.HalfFloat);
-                case GalTextureFormat.A8B8G8R8:     return (PixelFormat.Rgba, PixelType.UnsignedByte);
-                case GalTextureFormat.R32:          return (PixelFormat.Red,  PixelType.Float);
-                case GalTextureFormat.A1B5G5R5:     return (PixelFormat.Rgba, PixelType.UnsignedShort5551);
-                case GalTextureFormat.B5G6R5:       return (PixelFormat.Rgb,  PixelType.UnsignedShort565);
-                case GalTextureFormat.G8R8:         return (PixelFormat.Rg,   PixelType.UnsignedByte);
-                case GalTextureFormat.R16:          return (PixelFormat.Red,  PixelType.HalfFloat);
-                case GalTextureFormat.R8:           return (PixelFormat.Red,  PixelType.UnsignedByte);
+                case GalTextureFormat.R32G32B32A32: return (PixelFormat.Rgba,           PixelType.Float);
+                case GalTextureFormat.R16G16B16A16: return (PixelFormat.Rgba,           PixelType.HalfFloat);
+                case GalTextureFormat.A8B8G8R8:     return (PixelFormat.Rgba,           PixelType.UnsignedByte);
+                case GalTextureFormat.R32:          return (PixelFormat.Red,            PixelType.Float);
+                case GalTextureFormat.A1B5G5R5:     return (PixelFormat.Rgba,           PixelType.UnsignedShort5551);
+                case GalTextureFormat.B5G6R5:       return (PixelFormat.Rgb,            PixelType.UnsignedShort565);
+                case GalTextureFormat.G8R8:         return (PixelFormat.Rg,             PixelType.UnsignedByte);
+                case GalTextureFormat.R16:          return (PixelFormat.Red,            PixelType.HalfFloat);
+                case GalTextureFormat.R8:           return (PixelFormat.Red,            PixelType.UnsignedByte);
+                case GalTextureFormat.ZF32:         return (PixelFormat.DepthComponent, PixelType.Float);
             }
 
             throw new NotImplementedException(Format.ToString());
diff --git a/Ryujinx.Graphics/Gal/OpenGL/OGLRasterizer.cs b/Ryujinx.Graphics/Gal/OpenGL/OGLRasterizer.cs
index a4ec7f87cf..0dc56966b3 100644
--- a/Ryujinx.Graphics/Gal/OpenGL/OGLRasterizer.cs
+++ b/Ryujinx.Graphics/Gal/OpenGL/OGLRasterizer.cs
@@ -71,6 +71,18 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             IndexBuffer = new IbInfo();
         }
 
+        public void LockCaches()
+        {
+            VboCache.Lock();
+            IboCache.Lock();
+        }
+
+        public void UnlockCaches()
+        {
+            VboCache.Unlock();
+            IboCache.Unlock();
+        }
+
         public void ClearBuffers(GalClearBufferFlags Flags)
         {
             ClearBufferMask Mask = ClearBufferMask.ColorBufferBit;
@@ -223,7 +235,7 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             GL.BufferData(BufferTarget.ElementArrayBuffer, Length, Buffer, BufferUsageHint.StreamDraw);
         }
 
-        public void SetVertexArray(int VbIndex, int Stride, long VboKey, GalVertexAttrib[] Attribs)
+        public void SetVertexArray(int Stride, long VboKey, GalVertexAttrib[] Attribs)
         {
             if (!VboCache.TryGetValue(VboKey, out int VboHandle))
             {
@@ -270,7 +282,7 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             }
         }
 
-        public void SetIndexArray(long Key, int Size, GalIndexFormat Format)
+        public void SetIndexArray(int Size, GalIndexFormat Format)
         {
             IndexBuffer.Type = OGLEnumConverter.GetDrawElementsType(Format);
 
diff --git a/Ryujinx.Graphics/Gal/OpenGL/OGLTexture.cs b/Ryujinx.Graphics/Gal/OpenGL/OGLTexture.cs
index c50bdd71b5..5caca6ecde 100644
--- a/Ryujinx.Graphics/Gal/OpenGL/OGLTexture.cs
+++ b/Ryujinx.Graphics/Gal/OpenGL/OGLTexture.cs
@@ -26,6 +26,16 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             TextureCache = new OGLCachedResource<TCE>(DeleteTexture);
         }
 
+        public void LockCache()
+        {
+            TextureCache.Lock();
+        }
+
+        public void UnlockCache()
+        {
+            TextureCache.Unlock();
+        }
+
         private static void DeleteTexture(TCE CachedTexture)
         {
             GL.DeleteTexture(CachedTexture.Handle);
diff --git a/Ryujinx.HLE/Gpu/Engines/NvGpuEngine3d.cs b/Ryujinx.HLE/Gpu/Engines/NvGpuEngine3d.cs
index b9f9cc4974..2bacd71b36 100644
--- a/Ryujinx.HLE/Gpu/Engines/NvGpuEngine3d.cs
+++ b/Ryujinx.HLE/Gpu/Engines/NvGpuEngine3d.cs
@@ -73,6 +73,8 @@ namespace Ryujinx.HLE.Gpu.Engines
 
         private void VertexEndGl(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
         {
+            LockCaches();
+
             SetFrameBuffer(Vmm, 0);
 
             long[] Keys = UploadShaders(Vmm);
@@ -90,6 +92,20 @@ namespace Ryujinx.HLE.Gpu.Engines
             UploadTextures(Vmm, Keys);
             UploadUniforms(Vmm);
             UploadVertexArrays(Vmm);
+
+            UnlockCaches();
+        }
+
+        private void LockCaches()
+        {
+            Gpu.Renderer.Rasterizer.LockCaches();
+            Gpu.Renderer.Texture.LockCache();
+        }
+
+        private void UnlockCaches()
+        {
+            Gpu.Renderer.Rasterizer.UnlockCaches();
+            Gpu.Renderer.Texture.UnlockCache();
         }
 
         private void ClearBuffers(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
@@ -570,7 +586,7 @@ namespace Ryujinx.HLE.Gpu.Engines
                     Gpu.Renderer.Rasterizer.CreateIbo(IboKey, Data);
                 }
 
-                Gpu.Renderer.Rasterizer.SetIndexArray(IboKey, IbSize, IndexFormat);
+                Gpu.Renderer.Rasterizer.SetIndexArray(IbSize, IndexFormat);
             }
 
             List<GalVertexAttrib>[] Attribs = new List<GalVertexAttrib>[32];
@@ -634,7 +650,7 @@ namespace Ryujinx.HLE.Gpu.Engines
                     Gpu.Renderer.Rasterizer.CreateVbo(VboKey, Data);
                 }
 
-                Gpu.Renderer.Rasterizer.SetVertexArray(Index, Stride, VboKey, Attribs[Index].ToArray());
+                Gpu.Renderer.Rasterizer.SetVertexArray(Stride, VboKey, Attribs[Index].ToArray());
             }
 
             GalPrimitiveType PrimType = (GalPrimitiveType)(PrimCtrl & 0xffff);
diff --git a/Ryujinx.HLE/Gpu/Engines/NvGpuFifo.cs b/Ryujinx.HLE/Gpu/Engines/NvGpuFifo.cs
index 0bc682a70f..7b999eaed1 100644
--- a/Ryujinx.HLE/Gpu/Engines/NvGpuFifo.cs
+++ b/Ryujinx.HLE/Gpu/Engines/NvGpuFifo.cs
@@ -1,5 +1,6 @@
 using Ryujinx.HLE.Gpu.Memory;
 using System.Collections.Concurrent;
+using System.Threading;
 
 namespace Ryujinx.HLE.Gpu.Engines
 {
@@ -18,6 +19,8 @@ namespace Ryujinx.HLE.Gpu.Engines
 
         private NvGpuEngine[] SubChannels;
 
+        public AutoResetEvent Event { get; private set; }
+
         private struct CachedMacro
         {
             public int Position { get; private set; }
@@ -60,6 +63,8 @@ namespace Ryujinx.HLE.Gpu.Engines
             Macros = new CachedMacro[MacrosCount];
 
             Mme = new int[MmeWords];
+
+            Event = new AutoResetEvent(false);
         }
 
         public void PushBuffer(NvGpuVmm Vmm, NvGpuPBEntry[] Buffer)
@@ -68,6 +73,8 @@ namespace Ryujinx.HLE.Gpu.Engines
             {
                 BufferQueue.Enqueue((Vmm, PBEntry));
             }
+
+            Event.Set();
         }
 
         public void DispatchCalls()
diff --git a/Ryujinx.HLE/Gpu/Texture/TextureHelper.cs b/Ryujinx.HLE/Gpu/Texture/TextureHelper.cs
index ac8f75c5f1..6b9a306355 100644
--- a/Ryujinx.HLE/Gpu/Texture/TextureHelper.cs
+++ b/Ryujinx.HLE/Gpu/Texture/TextureHelper.cs
@@ -28,23 +28,30 @@ namespace Ryujinx.HLE.Gpu.Texture
         {
             switch (Texture.Format)
             {
-                case GalTextureFormat.R32G32B32A32: return Texture.Width * Texture.Height * 16;
-                case GalTextureFormat.R16G16B16A16: return Texture.Width * Texture.Height * 8;
-                case GalTextureFormat.A8B8G8R8:     return Texture.Width * Texture.Height * 4;
-                case GalTextureFormat.R32:          return Texture.Width * Texture.Height * 4;
-                case GalTextureFormat.A1B5G5R5:     return Texture.Width * Texture.Height * 2;
-                case GalTextureFormat.B5G6R5:       return Texture.Width * Texture.Height * 2;
-                case GalTextureFormat.G8R8:         return Texture.Width * Texture.Height * 2;
-                case GalTextureFormat.R16:          return Texture.Width * Texture.Height * 2;
-                case GalTextureFormat.R8:           return Texture.Width * Texture.Height;
+                case GalTextureFormat.R32G32B32A32:
+                    return Texture.Width * Texture.Height * 16;
+
+                case GalTextureFormat.R16G16B16A16:
+                    return Texture.Width * Texture.Height * 8;
+
+                case GalTextureFormat.A8B8G8R8:
+                case GalTextureFormat.R32:
+                case GalTextureFormat.ZF32:
+                    return Texture.Width * Texture.Height * 4;
+
+                case GalTextureFormat.A1B5G5R5:
+                case GalTextureFormat.B5G6R5:
+                case GalTextureFormat.G8R8:
+                case GalTextureFormat.R16:
+                    return Texture.Width * Texture.Height * 2;
+
+                case GalTextureFormat.R8:
+                    return Texture.Width * Texture.Height;
 
                 case GalTextureFormat.BC1:
                 case GalTextureFormat.BC4:
                 {
-                    int W = (Texture.Width  + 3) / 4;
-                    int H = (Texture.Height + 3) / 4;
-
-                    return W * H * 8;
+                    return CompressedTextureSize(Texture.Width, Texture.Height, 4, 4, 8);
                 }
 
                 case GalTextureFormat.BC7U:
@@ -53,16 +60,86 @@ namespace Ryujinx.HLE.Gpu.Texture
                 case GalTextureFormat.BC5:
                 case GalTextureFormat.Astc2D4x4:
                 {
-                    int W = (Texture.Width  + 3) / 4;
-                    int H = (Texture.Height + 3) / 4;
-
-                    return W * H * 16;
+                    return CompressedTextureSize(Texture.Width, Texture.Height, 4, 4, 16);
+                }
+                    
+                case GalTextureFormat.Astc2D5x5:
+                {
+                    return CompressedTextureSize(Texture.Width, Texture.Height, 5, 5, 16);
+                }
+                
+                case GalTextureFormat.Astc2D6x6:
+                {
+                    return CompressedTextureSize(Texture.Width, Texture.Height, 6, 6, 16);
+                }
+                    
+                case GalTextureFormat.Astc2D8x8:
+                {
+                    return CompressedTextureSize(Texture.Width, Texture.Height, 8, 8, 16);
+                }
+                    
+                case GalTextureFormat.Astc2D10x10:
+                {
+                    return CompressedTextureSize(Texture.Width, Texture.Height, 10, 10, 16);
+                }
+                    
+                case GalTextureFormat.Astc2D12x12:
+                {
+                    return CompressedTextureSize(Texture.Width, Texture.Height, 12, 12, 16);
+                }
+                
+                case GalTextureFormat.Astc2D5x4:
+                {
+                    return CompressedTextureSize(Texture.Width, Texture.Height, 5, 4, 16);
+                }
+				
+                case GalTextureFormat.Astc2D6x5:
+                {
+                    return CompressedTextureSize(Texture.Width, Texture.Height, 6, 5, 16);
+                }
+				
+                case GalTextureFormat.Astc2D8x6:
+                {
+                    return CompressedTextureSize(Texture.Width, Texture.Height, 8, 6, 16);
+                }
+				
+                case GalTextureFormat.Astc2D10x8:
+                {
+                    return CompressedTextureSize(Texture.Width, Texture.Height, 10, 8, 16);
+                }
+				
+                case GalTextureFormat.Astc2D12x10:
+                {
+                    return CompressedTextureSize(Texture.Width, Texture.Height, 12, 10, 16);
+                }
+				
+                case GalTextureFormat.Astc2D8x5:
+                {
+                    return CompressedTextureSize(Texture.Width, Texture.Height, 8, 5, 16);
+                }
+				
+                case GalTextureFormat.Astc2D10x5:
+                {
+                    return CompressedTextureSize(Texture.Width, Texture.Height, 10, 5, 16);
+                }
+				
+                case GalTextureFormat.Astc2D10x6:
+                {
+                    return CompressedTextureSize(Texture.Width, Texture.Height, 10, 6, 16);
                 }
             }
 
             throw new NotImplementedException(Texture.Format.ToString());
         }
 
+        public static int CompressedTextureSize(int TextureWidth, int TextureHeight, int BlockWidth, int BlockHeight, int Bpb)
+        {
+            int W = (TextureWidth  + (BlockWidth - 1)) / BlockWidth;
+            int H = (TextureHeight + (BlockHeight - 1)) / BlockHeight;
+
+            return W * H * Bpb;
+        }
+        
         public static (AMemory Memory, long Position) GetMemoryAndPosition(
             IAMemory Memory,
             long     Position)
diff --git a/Ryujinx.HLE/Gpu/Texture/TextureReader.cs b/Ryujinx.HLE/Gpu/Texture/TextureReader.cs
index 48bf1a90fe..8bd4dbcbaa 100644
--- a/Ryujinx.HLE/Gpu/Texture/TextureReader.cs
+++ b/Ryujinx.HLE/Gpu/Texture/TextureReader.cs
@@ -10,22 +10,36 @@ namespace Ryujinx.HLE.Gpu.Texture
         {
             switch (Texture.Format)
             {
-                case GalTextureFormat.R32G32B32A32: return Read16Bpp   (Memory, Texture);
-                case GalTextureFormat.R16G16B16A16: return Read8Bpp    (Memory, Texture);
-                case GalTextureFormat.A8B8G8R8:     return Read4Bpp    (Memory, Texture);
-                case GalTextureFormat.R32:          return Read4Bpp    (Memory, Texture);
-                case GalTextureFormat.A1B5G5R5:     return Read5551    (Memory, Texture);
-                case GalTextureFormat.B5G6R5:       return Read565     (Memory, Texture);
-                case GalTextureFormat.G8R8:         return Read2Bpp    (Memory, Texture);
-                case GalTextureFormat.R16:          return Read2Bpp    (Memory, Texture);
-                case GalTextureFormat.R8:           return Read1Bpp    (Memory, Texture);
-                case GalTextureFormat.BC7U:         return Read16Bpt4x4(Memory, Texture);
-                case GalTextureFormat.BC1:          return Read8Bpt4x4 (Memory, Texture);
-                case GalTextureFormat.BC2:          return Read16Bpt4x4(Memory, Texture);
-                case GalTextureFormat.BC3:          return Read16Bpt4x4(Memory, Texture);
-                case GalTextureFormat.BC4:          return Read8Bpt4x4 (Memory, Texture);
-                case GalTextureFormat.BC5:          return Read16Bpt4x4(Memory, Texture);
-                case GalTextureFormat.Astc2D4x4:    return Read16Bpt4x4(Memory, Texture);
+                case GalTextureFormat.R32G32B32A32: return Read16Bpp                 (Memory, Texture);
+                case GalTextureFormat.R16G16B16A16: return Read8Bpp                  (Memory, Texture);
+                case GalTextureFormat.A8B8G8R8:     return Read4Bpp                  (Memory, Texture);
+                case GalTextureFormat.R32:          return Read4Bpp                  (Memory, Texture);
+                case GalTextureFormat.A1B5G5R5:     return Read5551                  (Memory, Texture);
+                case GalTextureFormat.B5G6R5:       return Read565                   (Memory, Texture);
+                case GalTextureFormat.G8R8:         return Read2Bpp                  (Memory, Texture);
+                case GalTextureFormat.R16:          return Read2Bpp                  (Memory, Texture);
+                case GalTextureFormat.R8:           return Read1Bpp                  (Memory, Texture);
+                case GalTextureFormat.BC7U:         return Read16BptCompressedTexture(Memory, Texture, 4, 4);
+                case GalTextureFormat.BC1:          return Read8Bpt4x4               (Memory, Texture);
+                case GalTextureFormat.BC2:          return Read16BptCompressedTexture(Memory, Texture, 4, 4);
+                case GalTextureFormat.BC3:          return Read16BptCompressedTexture(Memory, Texture, 4, 4);
+                case GalTextureFormat.BC4:          return Read8Bpt4x4               (Memory, Texture);
+                case GalTextureFormat.BC5:          return Read16BptCompressedTexture(Memory, Texture, 4, 4);
+                case GalTextureFormat.ZF32:         return Read4Bpp                  (Memory, Texture);
+                case GalTextureFormat.Astc2D4x4:    return Read16BptCompressedTexture(Memory, Texture, 4, 4);
+                case GalTextureFormat.Astc2D5x5:    return Read16BptCompressedTexture(Memory, Texture, 5, 5);
+                case GalTextureFormat.Astc2D6x6:    return Read16BptCompressedTexture(Memory, Texture, 6, 6);
+                case GalTextureFormat.Astc2D8x8:    return Read16BptCompressedTexture(Memory, Texture, 8, 8);
+                case GalTextureFormat.Astc2D10x10:  return Read16BptCompressedTexture(Memory, Texture, 10, 10); 
+                case GalTextureFormat.Astc2D12x12:  return Read16BptCompressedTexture(Memory, Texture, 12, 12);
+                case GalTextureFormat.Astc2D5x4:    return Read16BptCompressedTexture(Memory, Texture, 5, 4);
+                case GalTextureFormat.Astc2D6x5:    return Read16BptCompressedTexture(Memory, Texture, 6, 5);
+                case GalTextureFormat.Astc2D8x6:    return Read16BptCompressedTexture(Memory, Texture, 8, 6);
+                case GalTextureFormat.Astc2D10x8:   return Read16BptCompressedTexture(Memory, Texture, 10, 8);
+                case GalTextureFormat.Astc2D12x10:  return Read16BptCompressedTexture(Memory, Texture, 12, 10);
+                case GalTextureFormat.Astc2D8x5:    return Read16BptCompressedTexture(Memory, Texture, 8, 5);
+                case GalTextureFormat.Astc2D10x5:   return Read16BptCompressedTexture(Memory, Texture, 10, 5);
+                case GalTextureFormat.Astc2D10x6:   return Read16BptCompressedTexture(Memory, Texture, 10, 6);
             }
 
             throw new NotImplementedException(Texture.Format.ToString());
@@ -306,10 +320,10 @@ namespace Ryujinx.HLE.Gpu.Texture
             return Output;
         }
 
-        private unsafe static byte[] Read16Bpt4x4(IAMemory Memory, TextureInfo Texture)
+        private unsafe static byte[] Read16BptCompressedTexture(IAMemory Memory, TextureInfo Texture, int BlockWidth, int BlockHeight)
         {
-            int Width  = (Texture.Width  + 3) / 4;
-            int Height = (Texture.Height + 3) / 4;
+            int Width  = (Texture.Width  + (BlockWidth - 1)) / BlockWidth;
+            int Height = (Texture.Height + (BlockHeight - 1)) / BlockHeight;
 
             byte[] Output = new byte[Width * Height * 16];
 
diff --git a/Ryujinx.HLE/OsHle/Services/Aud/IAudioOutManager.cs b/Ryujinx.HLE/OsHle/Services/Aud/IAudioOutManager.cs
index 54ffa6d901..8c78d1d493 100644
--- a/Ryujinx.HLE/OsHle/Services/Aud/IAudioOutManager.cs
+++ b/Ryujinx.HLE/OsHle/Services/Aud/IAudioOutManager.cs
@@ -14,6 +14,10 @@ namespace Ryujinx.HLE.OsHle.Services.Aud
     {
         private const string DefaultAudioOutput = "DeviceOut";
 
+        private const int DefaultSampleRate = 48000;
+
+        private const int DefaultChannelsCount = 2;
+
         private Dictionary<int, ServiceProcessRequest> m_Commands;
 
         public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
@@ -122,7 +126,12 @@ namespace Ryujinx.HLE.OsHle.Services.Aud
             int SampleRate = Context.RequestData.ReadInt32();
             int Channels   = Context.RequestData.ReadInt32();
 
-            if (SampleRate != 48000)
+            if (SampleRate == 0)
+            {
+                SampleRate = DefaultSampleRate;
+            }
+
+            if (SampleRate != DefaultSampleRate)
             {
                 Context.Ns.Log.PrintWarning(LogClass.Audio, "Invalid sample rate!");
 
@@ -133,7 +142,7 @@ namespace Ryujinx.HLE.OsHle.Services.Aud
 
             if (Channels == 0)
             {
-                Channels = 2;
+                Channels = DefaultChannelsCount;
             }
 
             KEvent ReleaseEvent = new KEvent();
@@ -145,7 +154,7 @@ namespace Ryujinx.HLE.OsHle.Services.Aud
 
             IAalOutput AudioOut = Context.Ns.AudioOut;
 
-            int Track = AudioOut.OpenTrack(SampleRate, 2, Callback, out AudioFormat Format);
+            int Track = AudioOut.OpenTrack(SampleRate, Channels, Callback, out AudioFormat Format);
 
             MakeObject(Context, new IAudioOut(AudioOut, ReleaseEvent, Track));
 
diff --git a/Ryujinx.HLE/OsHle/Services/Nv/NvHostCtrl/NvHostCtrlIoctl.cs b/Ryujinx.HLE/OsHle/Services/Nv/NvHostCtrl/NvHostCtrlIoctl.cs
index a9fd9d3abd..7705a1f78f 100644
--- a/Ryujinx.HLE/OsHle/Services/Nv/NvHostCtrl/NvHostCtrlIoctl.cs
+++ b/Ryujinx.HLE/OsHle/Services/Nv/NvHostCtrl/NvHostCtrlIoctl.cs
@@ -2,6 +2,7 @@ using ChocolArm64.Memory;
 using Ryujinx.HLE.Logging;
 using System;
 using System.Collections.Concurrent;
+using System.Text;
 using System.Threading;
 
 namespace Ryujinx.HLE.OsHle.Services.Nv.NvHostCtrl
@@ -10,9 +11,16 @@ namespace Ryujinx.HLE.OsHle.Services.Nv.NvHostCtrl
     {
         private static ConcurrentDictionary<Process, NvHostCtrlUserCtx> UserCtxs;
 
+        private static bool IsProductionMode = true;
+
         static NvHostCtrlIoctl()
         {
             UserCtxs = new ConcurrentDictionary<Process, NvHostCtrlUserCtx>();
+
+            if (Set.NxSettings.Settings.TryGetValue("nv!rmos_set_production_mode", out object ProductionModeSetting))
+            {
+                IsProductionMode = ((string)ProductionModeSetting) != "0"; // Default value is ""
+            }
         }
 
         public static int ProcessIoctl(ServiceCtx Context, int Cmd)
@@ -71,17 +79,52 @@ namespace Ryujinx.HLE.OsHle.Services.Nv.NvHostCtrl
 
         private static int GetConfig(ServiceCtx Context)
         {
-            long InputPosition  = Context.Request.GetBufferType0x21().Position;
-            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+            if (!IsProductionMode)
+            {
+                long InputPosition  = Context.Request.GetBufferType0x21().Position;
+                long OutputPosition = Context.Request.GetBufferType0x22().Position;
 
-            string Nv   = AMemoryHelper.ReadAsciiString(Context.Memory, InputPosition + 0,    0x41);
-            string Name = AMemoryHelper.ReadAsciiString(Context.Memory, InputPosition + 0x41, 0x41);
+                string Domain = AMemoryHelper.ReadAsciiString(Context.Memory, InputPosition + 0, 0x41);
+                string Name   = AMemoryHelper.ReadAsciiString(Context.Memory, InputPosition + 0x41, 0x41);
 
-            Context.Memory.WriteByte(OutputPosition + 0x82, 0);
+                if (Set.NxSettings.Settings.TryGetValue($"{Domain}!{Name}", out object NvSetting))
+                {
+                    byte[] SettingBuffer = new byte[0x101];
 
-            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+                    if (NvSetting is string StringValue)
+                    {
+                        if (StringValue.Length > 0x100)
+                        {
+                            Context.Ns.Log.PrintError(Logging.LogClass.ServiceNv, $"{Domain}!{Name} String value size is too big!");
+                        }
+                        else
+                        {
+                            SettingBuffer = Encoding.ASCII.GetBytes(StringValue + "\0");
+                        }
+                    }
 
-            return NvResult.Success;
+                    if (NvSetting is int IntValue)
+                    {
+                        SettingBuffer = BitConverter.GetBytes(IntValue);
+                    }
+                    else if (NvSetting is bool BoolValue)
+                    {
+                        SettingBuffer[0] = BoolValue ? (byte)1 : (byte)0;
+                    }
+                    else
+                    {
+                        throw new NotImplementedException(NvSetting.GetType().Name);
+                    }
+
+                    Context.Memory.WriteBytes(OutputPosition + 0x82, SettingBuffer);
+
+                    Context.Ns.Log.PrintDebug(Logging.LogClass.ServiceNv, $"Got setting {Domain}!{Name}");
+                }
+                
+                return NvResult.Success;
+            }
+
+            return NvResult.NotAvailableInProduction;
         }
 
         private static int EventWait(ServiceCtx Context)
@@ -352,4 +395,4 @@ namespace Ryujinx.HLE.OsHle.Services.Nv.NvHostCtrl
             UserCtxs.TryRemove(Process, out _);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/Ryujinx.HLE/OsHle/Services/Nv/NvResult.cs b/Ryujinx.HLE/OsHle/Services/Nv/NvResult.cs
index 720f5ccf2c..78ae5ae33b 100644
--- a/Ryujinx.HLE/OsHle/Services/Nv/NvResult.cs
+++ b/Ryujinx.HLE/OsHle/Services/Nv/NvResult.cs
@@ -2,12 +2,13 @@ namespace Ryujinx.HLE.OsHle.Services.Nv
 {
     static class NvResult
     {
-        public const int Success      = 0;
-        public const int TryAgain     = -11;
-        public const int OutOfMemory  = -12;
-        public const int InvalidInput = -22;
-        public const int NotSupported = -25;
-        public const int Restart      = -85;
-        public const int TimedOut     = -110;
+        public const int NotAvailableInProduction = 196614;
+        public const int Success                  = 0;
+        public const int TryAgain                 = -11;
+        public const int OutOfMemory              = -12;
+        public const int InvalidInput             = -22;
+        public const int NotSupported             = -25;
+        public const int Restart                  = -85;
+        public const int TimedOut                 = -110;
     }
-}
\ No newline at end of file
+}
diff --git a/Ryujinx.HLE/OsHle/Services/ServiceFactory.cs b/Ryujinx.HLE/OsHle/Services/ServiceFactory.cs
index 914c84490d..b69fc9f884 100644
--- a/Ryujinx.HLE/OsHle/Services/ServiceFactory.cs
+++ b/Ryujinx.HLE/OsHle/Services/ServiceFactory.cs
@@ -18,6 +18,7 @@ using Ryujinx.HLE.OsHle.Services.Prepo;
 using Ryujinx.HLE.OsHle.Services.Set;
 using Ryujinx.HLE.OsHle.Services.Sfdnsres;
 using Ryujinx.HLE.OsHle.Services.Sm;
+using Ryujinx.HLE.OsHle.Services.Spl;
 using Ryujinx.HLE.OsHle.Services.Ssl;
 using Ryujinx.HLE.OsHle.Services.Vi;
 using System;
@@ -66,6 +67,9 @@ namespace Ryujinx.HLE.OsHle.Services
                 case "caps:ss":
                     return new IScreenshotService();
 
+                case "csrng":
+                    return new IRandomInterface();
+
                 case "friend:a":
                     return new IServiceCreator();
 
diff --git a/Ryujinx.HLE/OsHle/Services/Spl/IRandomInterface.cs b/Ryujinx.HLE/OsHle/Services/Spl/IRandomInterface.cs
new file mode 100644
index 0000000000..489ca52ce6
--- /dev/null
+++ b/Ryujinx.HLE/OsHle/Services/Spl/IRandomInterface.cs
@@ -0,0 +1,50 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System;
+using System.Collections.Generic;
+using System.Security.Cryptography;
+
+namespace Ryujinx.HLE.OsHle.Services.Spl
+{
+    class IRandomInterface : IpcService, IDisposable
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private RNGCryptoServiceProvider Rng;
+
+        public IRandomInterface()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, GetRandomBytes }
+            };
+
+            Rng = new RNGCryptoServiceProvider();
+        }
+
+        public long GetRandomBytes(ServiceCtx Context)
+        {
+            byte[] RandomBytes = new byte[Context.Request.ReceiveBuff[0].Size];
+
+            Rng.GetBytes(RandomBytes);
+
+            Context.Memory.WriteBytes(Context.Request.ReceiveBuff[0].Position, RandomBytes);
+
+            return 0;
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        protected virtual void Dispose(bool Disposing)
+        {
+            if (Disposing)
+            {
+                Rng.Dispose();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Ryujinx.HLE/OsHle/Services/Time/ITimeZoneService.cs b/Ryujinx.HLE/OsHle/Services/Time/ITimeZoneService.cs
index 39454d4335..a2206a126e 100644
--- a/Ryujinx.HLE/OsHle/Services/Time/ITimeZoneService.cs
+++ b/Ryujinx.HLE/OsHle/Services/Time/ITimeZoneService.cs
@@ -2,6 +2,7 @@ using Ryujinx.HLE.Logging;
 using Ryujinx.HLE.OsHle.Ipc;
 using System;
 using System.Collections.Generic;
+using System.Text;
 
 namespace Ryujinx.HLE.OsHle.Services.Time
 {
@@ -13,20 +14,31 @@ namespace Ryujinx.HLE.OsHle.Services.Time
 
         private static readonly DateTime Epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
 
+        private TimeZoneInfo TimeZone = TimeZoneInfo.Local;
+
         public ITimeZoneService()
         {
             m_Commands = new Dictionary<int, ServiceProcessRequest>()
             {
-                { 0,   GetDeviceLocationName    },
-                { 101, ToCalendarTimeWithMyRule }
+                { 0,   GetDeviceLocationName     },
+                { 1,   SetDeviceLocationName     },
+                { 2,   GetTotalLocationNameCount },
+                { 3,   LoadLocationNameList      },
+                { 4,   LoadTimeZoneRule          },
+                { 100, ToCalendarTime            },
+                { 101, ToCalendarTimeWithMyRule  }
             };
         }
 
         public long GetDeviceLocationName(ServiceCtx Context)
         {
-            Context.Ns.Log.PrintStub(LogClass.ServiceTime, "Stubbed.");
+            char[] TzName = TimeZone.Id.ToCharArray();
 
-            for (int Index = 0; Index < 0x24; Index++)
+            Context.ResponseData.Write(TzName);
+
+            int Padding = 0x24 - TzName.Length;
+
+            for (int Index = 0; Index < Padding; Index++)
             {
                 Context.ResponseData.Write((byte)0);
             }
@@ -34,11 +46,94 @@ namespace Ryujinx.HLE.OsHle.Services.Time
             return 0;
         }
 
-        public long ToCalendarTimeWithMyRule(ServiceCtx Context)
+        public long SetDeviceLocationName(ServiceCtx Context)
         {
-            long PosixTime = Context.RequestData.ReadInt64();
+            byte[] LocationName = Context.RequestData.ReadBytes(0x24);
+            string TzID         = Encoding.ASCII.GetString(LocationName).TrimEnd('\0');
 
-            DateTime CurrentTime = Epoch.AddSeconds(PosixTime).ToLocalTime();
+            long ResultCode = 0;
+
+            try
+            {
+                TimeZone = TimeZoneInfo.FindSystemTimeZoneById(TzID);
+            }
+            catch (TimeZoneNotFoundException e)
+            {
+                ResultCode = 0x7BA74;
+            }
+
+            return ResultCode;
+        }
+
+        public long GetTotalLocationNameCount(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(TimeZoneInfo.GetSystemTimeZones().Count);
+
+            return 0;
+        }
+
+        public long LoadLocationNameList(ServiceCtx Context)
+        {
+            long BufferPosition = Context.Response.SendBuff[0].Position;
+            long BufferSize     = Context.Response.SendBuff[0].Size;
+
+            int i = 0;
+            foreach (TimeZoneInfo info in TimeZoneInfo.GetSystemTimeZones())
+            {
+                byte[] TzData = Encoding.ASCII.GetBytes(info.Id);
+
+                Context.Memory.WriteBytes(BufferPosition + i, TzData);
+
+                int Padding = 0x24 - TzData.Length;
+
+                for (int Index = 0; Index < Padding; Index++)
+                {
+                    Context.ResponseData.Write((byte)0);
+                }
+
+                i += 0x24;
+            }
+            return 0;
+        }
+
+        public long LoadTimeZoneRule(ServiceCtx Context)
+        {
+            long BufferPosition = Context.Request.ReceiveBuff[0].Position;
+            long BufferSize     = Context.Request.ReceiveBuff[0].Size;
+
+            if (BufferSize != 0x4000)
+            {
+                Context.Ns.Log.PrintWarning(LogClass.ServiceTime, $"TimeZoneRule buffer size is 0x{BufferSize:x} (expected 0x4000)");
+            }
+
+            long ResultCode = 0;
+
+            byte[] LocationName = Context.RequestData.ReadBytes(0x24);
+            string TzID         = Encoding.ASCII.GetString(LocationName).TrimEnd('\0');
+
+            // Check if the Time Zone exists, otherwise error out.
+            try
+            {
+                TimeZoneInfo Info = TimeZoneInfo.FindSystemTimeZoneById(TzID);
+                byte[] TzData     = Encoding.ASCII.GetBytes(Info.Id);
+
+                // FIXME: This is not in ANY cases accurate, but the games don't about the content of the buffer, they only pass it.
+                // TODO: Reverse the TZif2 conversion in PCV to make this match with real hardware.
+                Context.Memory.WriteBytes(BufferPosition, TzData);
+            }
+            catch (TimeZoneNotFoundException e)
+            {
+                Context.Ns.Log.PrintWarning(LogClass.ServiceTime, $"Timezone not found for string: {TzID} (len: {TzID.Length})");
+                ResultCode = 0x7BA74;
+            }
+
+            return ResultCode;
+        }
+
+        private long ToCalendarTimeWithTz(ServiceCtx Context, long PosixTime, TimeZoneInfo Info)
+        {
+            DateTime CurrentTime = Epoch.AddSeconds(PosixTime);
+            CurrentTime          = TimeZoneInfo.ConvertTimeFromUtc(CurrentTime, Info);
 
             Context.ResponseData.Write((ushort)CurrentTime.Year);
             Context.ResponseData.Write((byte)CurrentTime.Month);
@@ -46,31 +141,54 @@ namespace Ryujinx.HLE.OsHle.Services.Time
             Context.ResponseData.Write((byte)CurrentTime.Hour);
             Context.ResponseData.Write((byte)CurrentTime.Minute);
             Context.ResponseData.Write((byte)CurrentTime.Second);
-            Context.ResponseData.Write((byte)0);
-
-            /* Thanks to TuxSH
-                struct CalendarAdditionalInfo {
-	                u32 tm_wday; //day of week [0,6] (Sunday = 0)
-	                s32 tm_yday; //day of year [0,365]
-	                struct timezone {
-		                char[8] tz_name;
-		                bool isDaylightSavingTime;
-		                s32 utcOffsetSeconds;
-	                };
-                };
-            */
+            Context.ResponseData.Write((byte)0); //MilliSecond ?
             Context.ResponseData.Write((int)CurrentTime.DayOfWeek);
-
             Context.ResponseData.Write(CurrentTime.DayOfYear - 1);
-
-            //TODO: Find out the names used.
-            Context.ResponseData.Write(new byte[8]);
-
+            Context.ResponseData.Write(new byte[8]); //TODO: Find out the names used.
             Context.ResponseData.Write((byte)(CurrentTime.IsDaylightSavingTime() ? 1 : 0));
-
-            Context.ResponseData.Write((int)TimeZoneInfo.Local.GetUtcOffset(CurrentTime).TotalSeconds);
+            Context.ResponseData.Write((int)Info.GetUtcOffset(CurrentTime).TotalSeconds);
 
             return 0;
         }
+
+        public long ToCalendarTime(ServiceCtx Context)
+        {
+            long PosixTime      = Context.RequestData.ReadInt64();
+            long BufferPosition = Context.Request.SendBuff[0].Position;
+            long BufferSize     = Context.Request.SendBuff[0].Size;
+
+            if (BufferSize != 0x4000)
+            {
+                Context.Ns.Log.PrintWarning(LogClass.ServiceTime, $"TimeZoneRule buffer size is 0x{BufferSize:x} (expected 0x4000)");
+            }
+
+            // TODO: Reverse the TZif2 conversion in PCV to make this match with real hardware.
+            byte[] TzData = Context.Memory.ReadBytes(BufferPosition, 0x24);
+            string TzID   = Encoding.ASCII.GetString(TzData).TrimEnd('\0');
+
+            long ResultCode = 0;
+
+            // Check if the Time Zone exists, otherwise error out.
+            try
+            {
+                TimeZoneInfo Info = TimeZoneInfo.FindSystemTimeZoneById(TzID);
+
+                ResultCode = ToCalendarTimeWithTz(Context, PosixTime, Info);
+            }
+            catch (TimeZoneNotFoundException e)
+            {
+                Context.Ns.Log.PrintWarning(LogClass.ServiceTime, $"Timezone not found for string: {TzID} (len: {TzID.Length})");
+                ResultCode = 0x7BA74;
+            }
+
+            return ResultCode;
+        }
+
+        public long ToCalendarTimeWithMyRule(ServiceCtx Context)
+        {
+            long PosixTime = Context.RequestData.ReadInt64();
+
+            return ToCalendarTimeWithTz(Context, PosixTime, TimeZone);
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/Ryujinx.HLE/Switch.cs b/Ryujinx.HLE/Switch.cs
index f7b263cd0f..1946b187ba 100644
--- a/Ryujinx.HLE/Switch.cs
+++ b/Ryujinx.HLE/Switch.cs
@@ -71,6 +71,11 @@ namespace Ryujinx.HLE
             Os.LoadProgram(FileName);
         }
 
+        public bool WaitFifo()
+        {
+            return Gpu.Fifo.Event.WaitOne(8);
+        }
+
         public void ProcessFrame()
         {
             Gpu.Fifo.DispatchCalls();
diff --git a/Ryujinx.Tests/Cpu/CpuTestSimdCvt.cs b/Ryujinx.Tests/Cpu/CpuTestSimdCvt.cs
new file mode 100644
index 0000000000..2d021616c6
--- /dev/null
+++ b/Ryujinx.Tests/Cpu/CpuTestSimdCvt.cs
@@ -0,0 +1,40 @@
+using ChocolArm64.State;
+
+using NUnit.Framework;
+
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+
+namespace Ryujinx.Tests.Cpu
+{
+    public class CpuTestSimdCvt : CpuTest
+    {
+        [TestCase((ushort)0x0000, 0x00000000u)] // Positive Zero
+        [TestCase((ushort)0x8000, 0x80000000u)] // Negative Zero
+        [TestCase((ushort)0x3E00, 0x3FC00000u)] // +1.5
+        [TestCase((ushort)0xBE00, 0xBFC00000u)] // -1.5
+        [TestCase((ushort)0xFFFF, 0xFFFFE000u)] // -QNaN
+        [TestCase((ushort)0x7C00, 0x7F800000u)] // +Inf
+        [TestCase((ushort)0x3C00, 0x3F800000u)] // 1.0
+        [TestCase((ushort)0x3C01, 0x3F802000u)] // 1.0009765625
+        [TestCase((ushort)0xC000, 0xC0000000u)] // -2.0
+        [TestCase((ushort)0x7BFF, 0x477FE000u)] // 65504.0 (Largest Normal)
+        [TestCase((ushort)0x03FF, 0x387FC000u)] // 0.00006097555 (Largest Subnormal)
+        [TestCase((ushort)0x0001, 0x33800000u)] // 5.96046448e-8 (Smallest Subnormal)
+        public void Fcvtl_V_f16(ushort Value, uint Result)
+        {
+            uint Opcode = 0x0E217801;
+            Vector128<float> V0 = Sse.StaticCast<ushort, float>(Sse2.SetAllVector128(Value));
+
+            AThreadState ThreadState = SingleOpcode(Opcode, V0: V0);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(Sse41.Extract(Sse.StaticCast<float, uint>(ThreadState.V1), (byte)0), Is.EqualTo(Result));
+                Assert.That(Sse41.Extract(Sse.StaticCast<float, uint>(ThreadState.V1), (byte)1), Is.EqualTo(Result));
+                Assert.That(Sse41.Extract(Sse.StaticCast<float, uint>(ThreadState.V1), (byte)2), Is.EqualTo(Result));
+                Assert.That(Sse41.Extract(Sse.StaticCast<float, uint>(ThreadState.V1), (byte)3), Is.EqualTo(Result));
+            });
+        }
+    }
+}
diff --git a/Ryujinx/Ui/GLScreen.cs b/Ryujinx/Ui/GLScreen.cs
index 7a4e42e9e2..9b5dda4f0c 100644
--- a/Ryujinx/Ui/GLScreen.cs
+++ b/Ryujinx/Ui/GLScreen.cs
@@ -5,6 +5,9 @@ using Ryujinx.Graphics.Gal;
 using Ryujinx.HLE;
 using Ryujinx.HLE.Input;
 using System;
+using System.Threading;
+
+using Stopwatch = System.Diagnostics.Stopwatch;
 
 namespace Ryujinx
 {
@@ -16,6 +19,8 @@ namespace Ryujinx
         private const float TouchScreenRatioX = (float)TouchScreenWidth  / TouchScreenHeight;
         private const float TouchScreenRatioY = (float)TouchScreenHeight / TouchScreenWidth;
 
+        private const int TargetFPS = 60;
+
         private Switch Ns;
 
         private IGalRenderer Renderer;
@@ -24,6 +29,14 @@ namespace Ryujinx
 
         private MouseState? Mouse = null;
 
+        private Thread RenderThread;
+
+        private bool ResizeEvent;
+
+        private bool TitleEvent;
+
+        private string NewTitle;
+
         public GLScreen(Switch Ns, IGalRenderer Renderer)
             : base(1280, 720,
             new GraphicsMode(), "Ryujinx", 0,
@@ -36,13 +49,85 @@ namespace Ryujinx
             Location = new Point(
                 (DisplayDevice.Default.Width  / 2) - (Width  / 2),
                 (DisplayDevice.Default.Height / 2) - (Height / 2));
+
+            ResizeEvent = false;
+
+            TitleEvent = false;
         }
 
-        protected override void OnLoad(EventArgs e)
+        private void RenderLoop()
         {
-            VSync = VSyncMode.On;
+            MakeCurrent();
+
+            Stopwatch Chrono = new Stopwatch();
+
+            Chrono.Start();
+
+            long TicksPerFrame = Stopwatch.Frequency / TargetFPS;
+
+            long Ticks = 0;
+
+            while (Exists && !IsExiting)
+            {
+                if (Ns.WaitFifo())
+                {
+                    Ns.ProcessFrame();
+                }
+
+                Renderer.RunActions();
+
+                if (ResizeEvent)
+                {
+                    ResizeEvent = false;
+
+                    Renderer.FrameBuffer.SetWindowSize(Width, Height);
+                }
+
+                Ticks += Chrono.ElapsedTicks;
+
+                Chrono.Restart();
+
+                if (Ticks >= TicksPerFrame)
+                {
+                    RenderFrame();
+
+                    //Queue max. 1 vsync
+                    Ticks = Math.Min(Ticks - TicksPerFrame, TicksPerFrame);
+                }
+            }
+        }
+
+        public void MainLoop()
+        {
+            VSync = VSyncMode.Off;
+
+            Visible = true;
 
             Renderer.FrameBuffer.SetWindowSize(Width, Height);
+
+            Context.MakeCurrent(null);
+
+            //OpenTK doesn't like sleeps in its thread, to avoid this a renderer thread is created
+            RenderThread = new Thread(RenderLoop);
+
+            RenderThread.Start();
+
+            while (Exists && !IsExiting)
+            {
+                ProcessEvents();
+
+                if (!IsExiting)
+                {
+                    UpdateFrame();
+
+                    if (TitleEvent)
+                    {
+                        TitleEvent = false;
+
+                        Title = NewTitle;
+                    }
+                }
+            }
         }
         
         private bool IsGamePadButtonPressedFromString(GamePadState GamePad, string Button)
@@ -99,7 +184,7 @@ namespace Ryujinx
             }
         }
 
-        protected override void OnUpdateFrame(FrameEventArgs e)
+        private new void UpdateFrame()
         {
             HidControllerButtons CurrentButton = 0;
             HidJoystickPosition  LeftJoystick;
@@ -278,13 +363,9 @@ namespace Ryujinx
                 CurrentButton,
                 LeftJoystick,
                 RightJoystick);
-
-            Ns.ProcessFrame();
-
-            Renderer.RunActions();
         }
 
-        protected override void OnRenderFrame(FrameEventArgs e)
+        private new void RenderFrame()
         {
             Renderer.FrameBuffer.Render();
 
@@ -293,16 +374,25 @@ namespace Ryujinx
             double HostFps = Ns.Statistics.GetSystemFrameRate();
             double GameFps = Ns.Statistics.GetGameFrameRate();
 
-            Title = $"Ryujinx | Host FPS: {HostFps:0.0} | Game FPS: {GameFps:0.0}";
+            NewTitle = $"Ryujinx | Host FPS: {HostFps:0.0} | Game FPS: {GameFps:0.0}";
+
+            TitleEvent = true;
 
             SwapBuffers();
 
             Ns.Os.SignalVsync();
         }
 
+        protected override void OnUnload(EventArgs e)
+        {
+            RenderThread.Join();
+
+            base.OnUnload(e);
+        }
+
         protected override void OnResize(EventArgs e)
         {
-            Renderer.FrameBuffer.SetWindowSize(Width, Height);
+            ResizeEvent = true;
         }
 
         protected override void OnKeyDown(KeyboardKeyEventArgs e)
diff --git a/Ryujinx/Ui/Program.cs b/Ryujinx/Ui/Program.cs
index b14897695d..5cacc6228b 100644
--- a/Ryujinx/Ui/Program.cs
+++ b/Ryujinx/Ui/Program.cs
@@ -67,7 +67,7 @@ namespace Ryujinx
                     Screen.Exit();
                 };
 
-                Screen.Run(0.0, 60.0);
+                Screen.MainLoop();
             }
 
             Environment.Exit(0);