Update README.md

Implement JIT Cache Regions and Add Handheld Input
2025-02-20 20:54:03 +00:00 · 2025-02-19 07:42:45 +00:00 · 2025-02-19 11:16:50 +11:00 · 2025-02-17 01:20:48 +00:00 · 2025-02-17 00:39:04 +01:00 · 2025-02-17 00:39:03 +01:00
62 changed files with 2506 additions and 2135 deletions
--- a/.gitea/workflows/add_release_to_site.yml
+++ b/.gitea/workflows/add_release_to_site.yml
@ -0,0 +1,21 @@
+name: Notify API on Release
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  notify-api:
+    runs-on: debian-trixie
+    steps:
+      - name: Send API Call for New Release
+        run: |
+          curl -X POST http://melonx.org/api/new_release \
+               -H "Content-Type: application/json" \
+               -H "Authorization: Bearer ${{ secrets.MELONX_GITEA_API_KEY }}" \
+               -d '{
+                    "version_number": "${{ github.event.release.tag_name }}",
+                    "download_link": "${{ github.event.release.html_url }}",
+                    "changelog": "${{ github.event.release.body }}",
+                    "is_latest": true
+                  }'
--- a/Compile.md
+++ b/Compile.md
@ -1,33 +1,81 @@
-# How to compile MeloNX using macOS
+# Compiling MeloNX on macOS

 ## Prerequisites
- [.NET 8.0](<https://dotnet.microsoft.com/en-us/download/dotnet/8.0>)
- A computer with macOS

-## Compiling
-1. Clone the Git Repo and build Ryujinx
-    ```
-       git clone https://github.com/melonx-emu/melonx/tree/XC-ios-ht
-       cd melonx
-       ./compile.sh -x
-    ```
+Before you begin, ensure you have the following installed:

-2. Open the Xcode project, stored at MeloNX/src/MeloNX
+- [**.NET 8.0**](https://dotnet.microsoft.com/en-us/download/dotnet/8.0)
+- [**Xcode**](https://apps.apple.com/de/app/xcode/id497799835?l=en-GB&mt=12$0)
+- A Mac running **macOS**

-3. Make sure `Ryujinx.SDL2.Headless.dylib` is set to `Embed & Sign` in the General settings for the Xcode project
+## Compilation Steps

-4. Signing & Capabilities
-    Change your 'Team' to your Developer Account (free or paid) and change Bundle Identifier to
-    `com.*your name*.MeloNX`
+### 1. Clone the Repository and Build Ryujinx

-6. Build and Run
-    `CMD+R`
+Open a terminal and run:

-7. Check the [post-setup guide](<https://github.com/melonx-emu/melonx/tree/XC-ios-ht/postsetup.md>)
-
-## If you don't have a paid developer account
-Make sure these entitlements are removed if you don't have a paid Apple Developer account
+```sh
+git clone https://git.743378673.xyz/MeloNX/MeloNX.git
+cd MeloNX
+./compile.sh
 ```
-    Extended Virtual Addressing
-    Increased Debugging Memory Limit
+You may need to run this command if compilation fails, then run the `./compile.sh` command again (You will need to put in your user password. Your password will not be shown at all.)
+```
+sudo xcode-select --switch /Applications/Xcode.app/Contents/Developer
+```
+
+
+However, if you only need to update MeloNX, make sure you have cd into the directory then run this then skip to step 5 
+```
+git pull
+./compile.sh
+```
+
+### 2. Open the Xcode Project
+
+Navigate to the **Xcode project file** located at:
+
+```
+src/MeloNX/MeloNX.xcodeproj
+```
+
+Double-click to open it in **Xcode**.
+
+### 3. Configure the Project Settings
+
+- In **Xcode**, select the **MeloNX** project.
+- Under the **General** tab, find `Ryujinx.Headless.SDL2.dylib`.
+- Set its **Embed setting** to **"Embed & Sign"**.
+
+### 4. Configure Signing & Capabilities
+
+- In **Xcode**, go to **Signing & Capabilities**.
+- Set the **Team** to your **Apple Developer account** (free or paid).
+- Change the **Bundle Identifier** to:
+
+  ```
+  com.<your-name>.MeloNX
+  ```
+
+  *(Replace `<your-name>` with your actual name or identifier.)*
+
+### 5. Connect Your Device
+
+Ensure your **iPhone/iPad** is **connected** and **selected** (Next to MeloNX with the arrow) in Xcode.
+- You may need to install the iOS SDK. it will say next to MeloNX with the arrow saying "iOS XX Not Installed (GET)"
+- You will be need to press GET and wait for it to finish downloading and installing
+- Then you will be able to select your device and Build and Run.
+
+Make Sure you do **NOT** select the Simulator. (Which is the Generic names and the ones with the non-coloured icons, e.g. "iPhone 16 Pro")
+
+### 6. Build and Run
+
+Click the **Run (▶️) button** in Xcode to compile and launch MeloNX.
+- When running on your device, Click the **Spray Can Button** below the Run button 
+- Right Click where it says "> MeloNX PID XXXX" 
+- Press Detach in the Context Menu.
+
+---
+
+Now you're all set! 🚀 If you encounter issues, please join the discord at https://melonx.org
 ```
--- a/LICENSE.txt
+++ b/LICENSE.txt
@ -1,9 +1,15 @@
-MIT License
+MeloNX License

-Copyright (c) Ryujinx Team and Contributors
+Copyright (c) MeloNX Team and Contributors

-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+Permission is hereby granted, free of charge, to any person (except anyone who has previously attempted or is currently attempting to merge MeloNX with Pomelo) obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. Every file is under this license, and all copies must be redistributed under the same license.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Anyone who attempts or has attempted to merge MeloNX with Pomelo, or otherwise use this source code in conjunction with Pomelo, is prohibited from using, copying, modifying, or distributing the source code without first obtaining explicit, written permission from Stossy11.
+
+Additionally, the names of the developers or contributors to this project may not be used to endorse or promote products derived from this software without specific, prior written permission from the respective developer(s).
+
+Ryujinx is licensed under the MIT License. Copyright (c) Ryujinx contributors. All rights to Ryujinx are held by its respective copyright holders, and its use is subject to the terms of the MIT License.
--- a/README.md
+++ b/README.md
@ -1,22 +1,123 @@
 <p align="center">
-    <a href="https://github.com/MeloNX-Emu/MeloNX">
-        <img src="https://github.com/MeloNX-Emu/melonx-emu.github.io/blob/main/favicon.png?raw=true" alt="MeloNX Logo" width="120">
+    <a href="https://melonx.org">
+        <img src="https://melonx.org/static/imgs/MeloNX.svg" alt="MeloNX Logo" width="120">
    </a>
 </p>

+<h1 align="center">MeloNX</h1>
+
+
+
 <p align="center">
    MeloNX enables Nintendo Switch game emulation on iOS using the Ryujinx iOS code base.
 </p>

 <p align="center">
       MeloNX is an iOS Nintendo Switch emulator based on Ryujinx, written primarily in C#. Designed to bring accurate performance and a user-friendly interface to iOS, MeloNX makes Switch games accessible on Apple devices.
-       Developed from the ground up, MeloNX is open-source and available on Github under the <a href="https://github.com/MeloNX-Emu/MeloNX/blob/master/LICENSE.txt" target="_blank">MIT license</a>. <br 
+       Developed from the ground up, MeloNX is open-source and available on Github under the <a href="https://github.com/MeloNX-Emu/MeloNX/blob/master/LICENSE.txt" target="_blank">MeloNX license (Based on MIT)</a>. <br 
 </p>

-## Compatibility
+# Compatibility

-MeloNX works on iPhone X and later and iPad 7th Gen and later. A lot of games work.
+MeloNX works on iPhone XS/XR and later and iPad 8th Gen and later. Check out the Compatibility on the <a href="https://melonx.org/compatibility/" target="_blank">website</a>.

-## Usage
+# Usage

-To run MeloNX on your iOS device, at least 4GB of RAM is recommended to ensure stability. For full instructions, refer to our [Setup Guide](https://github.com/MeloNX-Emu/MeloNX/wiki/Setup-Guide).
+## FAQ
+- MeloNX is made for iOS 17+, on iOS 15 - 16 MeloNX can be installed but will have issues or may not work at all.
+- MeloNX needs Xcode or a Paid Apple Developer Account. SideStore support may come soon (SideStore Side Issue)
+- MeloNX needs JIT
+- Recommended Device: iPhone 15 Pro or newer.
+- Low-End Recommended Device**: iPhone 13 Pro. 
+- Lowest Supported Device: iPhone XR
+
+
+## How to install
+
+### Paid Developer Account  
+
+1. **Sideload the App**  
+   - Use any sideloading tool that supports Apple IDs.  
+
+2. **Enable Entitlements**  
+   - Visit [Apple Developer Identifiers](https://developer.apple.com/account/resources/identifiers).  
+   - Locate **MeloNX** and enable the following entitlements:  
+     - `Increased Memory Limit`  
+     - `Increased Debugging Memory Limit`  
+
+3. **Reinstall the App**  
+   - Delete the existing installation.  
+   - Sideload the app again with the updated entitlements.  
+
+4. **Enable JIT**  
+   - Use your preferred method to enable Just-In-Time (JIT) compilation.  
+
+5. **Add Necessary Files**  
+
+If having Issues installing firmware (Make sure your Keys are installed first)
+   - If needed, install firmware and keys from **Ryujinx Desktop**.  
+   - Copy the **bis** and **system** folders  
+
+### Xcode
+
+**NOTE: These Xcode builds are nightly and may have unfinished features.**
+
+1. **Compile Guide**
+   - Visit the [guide here](https://git.743378673.xyz/MeloNX/MeloNX/src/branch/XC-ios-ht/Compile.md).
+
+2. **Add Necessary Files**  
+
+If having Issues installing firmware (Make sure your Keys are installed first)
+   - If needed, install firmware and keys from **Ryujinx Desktop**.  
+   - Copy the **bis** and **system** folders  
+   
+## Features
+
+- **Audio**
+
+  Audio output is entirely supported, audio input (microphone) isn't supported.
+  We use C# wrappers for [OpenAL](https://openal-soft.org/), and [SDL2](https://www.libsdl.org/) & [libsoundio](http://libsound.io/) as fallbacks.
+
+- **CPU**
+
+  The CPU emulator, ARMeilleure, emulates an ARMv8 CPU and currently has support for most 64-bit ARMv8 and some of the ARMv7 (and older) instructions, including partial 32-bit support.
+  It translates the ARM code to a custom IR, performs a few optimizations, and turns that into x86 code.
+  There are three memory manager options available depending on the user's preference, leveraging both software-based (slower) and host-mapped modes (much faster).
+  The fastest option (host, unchecked) is set by default.
+  Ryujinx also features an optional Profiled Persistent Translation Cache, which essentially caches translated functions so that they do not need to be translated every time the game loads.
+  The net result is a significant reduction in load times (the amount of time between launching a game and arriving at the title screen) for nearly every game.
+  NOTE: This feature is enabled by default, You must launch the game at least twice to the title screen or beyond before performance improvements are unlocked on the third launch!
+  These improvements are permanent and do not require any extra launches going forward.
+
+- **GPU**
+
+  The GPU emulator emulates the Switch's Maxwell GPU using Metal (via MoltenVK) APIs through a custom build of OpenTK or Silk.NET respectively.
+
+- **Input**
+
+  We currently have support for keyboard, touch input, JoyCon input support, and nearly all controllers.
+  Motion controls are natively supported in most cases; for dual-JoyCon motion support, DS4Windows or BetterJoy are currently required.
+  In all scenarios, you can set up everything inside the input configuration menu.
+
+- **DLC & Modifications**
+
+  MeloNX does not support add-on content/downloadable content.
+  Mods (romfs, exefs, and runtime mods such as cheats) are supported;
+
+- **Configuration**
+
+  The emulator has settings for enabling or disabling some logging, remapping controllers, and more.
+
+## License
+
+This software is licensed under the terms of the [MeloNX license (Based on MIT License)](LICENSE.txt).
+This project makes use of code authored by the libvpx project, licensed under BSD and the ffmpeg project, licensed under LGPLv3.
+See [LICENSE.txt](LICENSE.txt) and [THIRDPARTY.md](distribution/legal/THIRDPARTY.md) for more details.
+
+## Credits
+
+- [Ryujinx](https://github.com/ryujinx-mirror/ryujinx) is used for the base of this emulator. (link is to ryujinx-mirror since they were supportive)
+- [LibHac](https://github.com/Thealexbarney/LibHac) is used for our file-system.
+- [AmiiboAPI](https://www.amiiboapi.com) is used in our Amiibo emulation.
+- [ldn_mitm](https://github.com/spacemeowx2/ldn_mitm) is used for one of our available multiplayer modes.
+- [ShellLink](https://github.com/securifybv/ShellLink) is used for Windows shortcut generation.
--- a/src/ARMeilleure/Memory/ReservedRegion.cs
+++ b/src/ARMeilleure/Memory/ReservedRegion.cs
@ -7,6 +7,7 @@ namespace ARMeilleure.Memory
        public const int DefaultGranularity = 65536; // Mapping granularity in Windows.

        public IJitMemoryBlock Block { get; }
+        public IJitMemoryAllocator Allocator { get; }

        public IntPtr Pointer => Block.Pointer;

@ -21,6 +22,7 @@ namespace ARMeilleure.Memory
                granularity = DefaultGranularity;
            }

+            Allocator = allocator;
            Block = allocator.Reserve(maxSize);
            _maxSize = maxSize;
            _sizeGranularity = granularity;
--- a/src/ARMeilleure/Translation/Cache/JitCache.cs
+++ b/src/ARMeilleure/Translation/Cache/JitCache.cs
@ -3,6 +3,7 @@ using ARMeilleure.CodeGen.Unwinding;
 using ARMeilleure.Memory;
 using ARMeilleure.Native;
 using Ryujinx.Memory;
+using Ryujinx.Common.Logging;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
@ -18,7 +19,7 @@ namespace ARMeilleure.Translation.Cache
        private static readonly int _pageMask = _pageSize - 4;

        private const int CodeAlignment = 4; // Bytes.
-	    private const int CacheSize = 1024 * 1024 * 1024;
+	    private const int CacheSize = 128 * 1024 * 1024;
        private const int CacheSizeIOS = 128 * 1024 * 1024;

        private static ReservedRegion _jitRegion;
@ -31,6 +32,10 @@ namespace ARMeilleure.Translation.Cache
        private static readonly object _lock = new();
        private static bool _initialized;

+        private static readonly List<ReservedRegion> _jitRegions = new();
+
+         private static int _activeRegionIndex = 0;
+
        [SupportedOSPlatform("windows")]
        [LibraryImport("kernel32.dll", SetLastError = true)]
        public static partial IntPtr FlushInstructionCache(IntPtr hProcess, IntPtr lpAddress, UIntPtr dwSize);
@ -49,7 +54,11 @@ namespace ARMeilleure.Translation.Cache
                    return;
                }

-                _jitRegion = new ReservedRegion(allocator, (ulong)(OperatingSystem.IsIOS() ? CacheSizeIOS : CacheSize));
+                var firstRegion = new ReservedRegion(allocator, CacheSize);
+
+
+                _jitRegions.Add(firstRegion);
+                _activeRegionIndex = 0;

                if (!OperatingSystem.IsWindows() && !OperatingSystem.IsMacOS() && !OperatingSystem.IsIOS())
                {
@ -60,7 +69,9 @@ namespace ARMeilleure.Translation.Cache

                if (OperatingSystem.IsWindows())
                {
-                    JitUnwindWindows.InstallFunctionTableHandler(_jitRegion.Pointer, CacheSize, _jitRegion.Pointer + Allocate(_pageSize));
+                    JitUnwindWindows.InstallFunctionTableHandler(
+                         firstRegion.Pointer, CacheSize, firstRegion.Pointer + Allocate(_pageSize)
+                     );
                }

                _initialized = true;
@ -73,7 +84,9 @@ namespace ARMeilleure.Translation.Cache
        {
            while (_deferredRxProtect.TryDequeue(out var result))
            {
-                ReprotectAsExecutable(result.funcOffset, result.length);
+                ReservedRegion targetRegion = _jitRegions[_activeRegionIndex];
+
+                ReprotectAsExecutable(targetRegion, result.funcOffset, result.length);
            }
        }  

@ -87,21 +100,14 @@ namespace ARMeilleure.Translation.Cache

                int funcOffset = Allocate(code.Length, deferProtect);

-                IntPtr funcPtr = _jitRegion.Pointer + funcOffset;
+                ReservedRegion targetRegion = _jitRegions[_activeRegionIndex];
+                IntPtr funcPtr = targetRegion.Pointer + funcOffset;

                if (OperatingSystem.IsIOS())
                {
                    Marshal.Copy(code, 0, funcPtr, code.Length);
-                    if (deferProtect)
-                    {
-                        _deferredRxProtect.Enqueue((funcOffset, code.Length));
-                    }
-                    else
-                    {
-                        ReprotectAsExecutable(funcOffset, code.Length);
-
-                        JitSupportDarwinAot.Invalidate(funcPtr, (ulong)code.Length);
-                    }
+                    ReprotectAsExecutable(targetRegion, funcOffset, code.Length);
+                    JitSupportDarwinAot.Invalidate(funcPtr, (ulong)code.Length);
                }
                else if (OperatingSystem.IsMacOS()&& RuntimeInformation.ProcessArchitecture == Architecture.Arm64)
                {
@ -115,9 +121,9 @@ namespace ARMeilleure.Translation.Cache
                }
                else
                {
-                    ReprotectAsWritable(funcOffset, code.Length);
+                    ReprotectAsWritable(targetRegion, funcOffset, code.Length);
                    Marshal.Copy(code, 0, funcPtr, code.Length);
-                    ReprotectAsExecutable(funcOffset, code.Length);
+                    ReprotectAsExecutable(targetRegion, funcOffset, code.Length);

                    if (OperatingSystem.IsWindows() && RuntimeInformation.ProcessArchitecture == Architecture.Arm64)
                    {
@ -139,41 +145,50 @@ namespace ARMeilleure.Translation.Cache
        {
            if (OperatingSystem.IsIOS())
            {
-                return;
+                // return;
            }

            lock (_lock)
            {
-                Debug.Assert(_initialized);
-
-                int funcOffset = (int)(pointer.ToInt64() - _jitRegion.Pointer.ToInt64());
-
-                if (TryFind(funcOffset, out CacheEntry entry, out int entryIndex) && entry.Offset == funcOffset)
+                foreach (var region in _jitRegions)
                {
-                    _cacheAllocator.Free(funcOffset, AlignCodeSize(entry.Size));
-                    _cacheEntries.RemoveAt(entryIndex);
+                    if (pointer.ToInt64() < region.Pointer.ToInt64() ||
+                        pointer.ToInt64() >= (region.Pointer + CacheSize).ToInt64())
+                    {
+                        continue;
+                    }
+
+                    int funcOffset = (int)(pointer.ToInt64() - region.Pointer.ToInt64());
+
+                    if (TryFind(funcOffset, out CacheEntry entry, out int entryIndex) && entry.Offset == funcOffset)
+                    {
+                        _cacheAllocator.Free(funcOffset, AlignCodeSize(entry.Size));
+                        _cacheEntries.RemoveAt(entryIndex);
+                    }
+
+                    return;
                }
            }
        }

-        private static void ReprotectAsWritable(int offset, int size)
+        private static void ReprotectAsWritable(ReservedRegion region, int offset, int size)
        {
            int endOffs = offset + size;

            int regionStart = offset & ~_pageMask;
            int regionEnd = (endOffs + _pageMask) & ~_pageMask;

-            _jitRegion.Block.MapAsRwx((ulong)regionStart, (ulong)(regionEnd - regionStart));
+            region.Block.MapAsRwx((ulong)regionStart, (ulong)(regionEnd - regionStart));
        }

-        private static void ReprotectAsExecutable(int offset, int size)
+        private static void ReprotectAsExecutable(ReservedRegion region, int offset, int size)
        {
            int endOffs = offset + size;

            int regionStart = offset & ~_pageMask;
            int regionEnd = (endOffs + _pageMask) & ~_pageMask;

-            _jitRegion.Block.MapAsRx((ulong)regionStart, (ulong)(regionEnd - regionStart));
+            region.Block.MapAsRx((ulong)regionStart, (ulong)(regionEnd - regionStart));
        }

        private static int Allocate(int codeSize, bool deferProtect = false)
@ -187,20 +202,35 @@ namespace ARMeilleure.Translation.Cache
                alignment = 0x4000;
            }

-            int allocOffset = _cacheAllocator.Allocate(ref codeSize, alignment);
-
-            //DEBUG: Show JIT Memory Allocation
-
-            //Console.WriteLine($"{allocOffset:x8}: {codeSize:x8} {alignment:x8}");
-
-            if (allocOffset < 0)
+            for (int i = _activeRegionIndex; i < _jitRegions.Count; i++)
            {
-                throw new OutOfMemoryException("JIT Cache exhausted.");
+                int allocOffset = _cacheAllocator.Allocate(ref codeSize, alignment);
+
+                if (allocOffset >= 0)
+                {
+                    _jitRegions[i].ExpandIfNeeded((ulong)allocOffset + (ulong)codeSize);
+                    _activeRegionIndex = i;
+                    return allocOffset;
+                }
            }

-            _jitRegion.ExpandIfNeeded((ulong)allocOffset + (ulong)codeSize);
+            int exhaustedRegion = _activeRegionIndex;
+            var newRegion = new ReservedRegion(_jitRegions[0].Allocator, CacheSize);
+            _jitRegions.Add(newRegion);
+            _activeRegionIndex = _jitRegions.Count - 1;

-            return allocOffset;
+            int newRegionNumber = _activeRegionIndex;
+
+            _cacheAllocator = new CacheMemoryAllocator(CacheSize);
+
+            int allocOffsetNew = _cacheAllocator.Allocate(ref codeSize, alignment);
+            if (allocOffsetNew < 0)
+            {
+                throw new OutOfMemoryException("Failed to allocate in new Cache Region!");
+            }
+
+            newRegion.ExpandIfNeeded((ulong)allocOffsetNew + (ulong)codeSize);
+            return allocOffsetNew;
        }

        private static int AlignCodeSize(int codeSize, bool deferProtect = false)
--- a/src/MeloNX/MeloNX.xcodeproj/project.pbxproj
+++ b/src/MeloNX/MeloNX.xcodeproj/project.pbxproj
@ -25,6 +25,7 @@

 /* Begin PBXBuildFile section */
 		4E0DED342D05695D00FEF007 /* SwiftUIJoystick in Frameworks */ = {isa = PBXBuildFile; productRef = 4E0DED332D05695D00FEF007 /* SwiftUIJoystick */; };
+		4E8A80772D5FDD2D0041B48F /* GameController.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4E80AA622CD7122800029585 /* GameController.framework */; };
 		4EA5AE822D16807500AD0B9F /* SwiftSVG in Frameworks */ = {isa = PBXBuildFile; productRef = 4EA5AE812D16807500AD0B9F /* SwiftSVG */; };
 		CA8F9C322D3F5AB200D7E586 /* GameController.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4E80AA622CD7122800029585 /* GameController.framework */; };
 /* End PBXBuildFile section */
@ -54,6 +55,16 @@
 /* End PBXContainerItemProxy section */

 /* Begin PBXCopyFilesBuildPhase section */
+		4E50F49E2D5CC28B0080F1D1 /* Embed Watch Content */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = "$(CONTENTS_FOLDER_PATH)/Watch";
+			dstSubfolderSpec = 16;
+			files = (
+			);
+			name = "Embed Watch Content";
+			runOnlyForDeploymentPostprocessing = 0;
+		};
 		4E80AA092CD6FAA800029585 /* Embed Libraries */ = {
 			isa = PBXCopyFilesBuildPhase;
 			buildActionMask = 2147483647;
@ -67,6 +78,7 @@
 /* End PBXCopyFilesBuildPhase section */

 /* Begin PBXFileReference section */
+		4E7023A52D5A98E2002C7183 /* UIKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = UIKit.framework; path = System/Library/Frameworks/UIKit.framework; sourceTree = SDKROOT; };
 		4E80A98D2CD6F54500029585 /* MeloNX.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = MeloNX.app; sourceTree = BUILT_PRODUCTS_DIR; };
 		4E80A99D2CD6F54700029585 /* MeloNXTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = MeloNXTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
 		4E80A9A72CD6F54700029585 /* MeloNXUITests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = MeloNXUITests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
@ -96,7 +108,7 @@
 				"Dependencies/Dynamic Libraries/Ryujinx.Headless.SDL2.dylib" = (
 					CodeSignOnCopy,
 				);
-				"Dependencies/Dynamic Libraries/SoftwareKeyboard.framework" = (
+				"Dependencies/Dynamic Libraries/RyujinxKeyboard.framework" = (
 					CodeSignOnCopy,
 					RemoveHeadersOnCopy,
 				);
@ -157,7 +169,7 @@
 				"Dependencies/Dynamic Libraries/libavutil.dylib",
 				"Dependencies/Dynamic Libraries/libMoltenVK.dylib",
 				"Dependencies/Dynamic Libraries/Ryujinx.Headless.SDL2.dylib",
-				"Dependencies/Dynamic Libraries/SoftwareKeyboard.framework",
+				"Dependencies/Dynamic Libraries/RyujinxKeyboard.framework",
 				Dependencies/XCFrameworks/libavcodec.xcframework,
 				Dependencies/XCFrameworks/libavfilter.xcframework,
 				Dependencies/XCFrameworks/libavformat.xcframework,
@ -186,6 +198,7 @@
 				4E0DED342D05695D00FEF007 /* SwiftUIJoystick in Frameworks */,
 				CA8F9C322D3F5AB200D7E586 /* GameController.framework in Frameworks */,
 				4EA5AE822D16807500AD0B9F /* SwiftSVG in Frameworks */,
+				4E8A80772D5FDD2D0041B48F /* GameController.framework in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@ -232,6 +245,7 @@
 		4E80AA192CD700F500029585 /* Frameworks */ = {
 			isa = PBXGroup;
 			children = (
+				4E7023A52D5A98E2002C7183 /* UIKit.framework */,
 				4E80AA622CD7122800029585 /* GameController.framework */,
 			);
 			name = Frameworks;
@ -267,6 +281,7 @@
 				4E80A98A2CD6F54500029585 /* Frameworks */,
 				4E80A98B2CD6F54500029585 /* Resources */,
 				4E80AA092CD6FAA800029585 /* Embed Libraries */,
+				4E50F49E2D5CC28B0080F1D1 /* Embed Watch Content */,
 			);
 			buildRules = (
 			);
@ -337,7 +352,7 @@
 			isa = PBXProject;
 			attributes = {
 				BuildIndependentTargetsInParallel = 1;
-				LastSwiftUpdateCheck = 1610;
+				LastSwiftUpdateCheck = 1620;
 				LastUpgradeCheck = 1610;
 				TargetAttributes = {
 					4E80A98C2CD6F54500029585 = {
@ -634,10 +649,28 @@
 					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
 					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
 					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
 				);
 				GCC_OPTIMIZATION_LEVEL = fast;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = MeloNX/Info.plist;
+				INFOPLIST_KEY_GCSupportsControllerUserInteraction = YES;
 				INFOPLIST_KEY_GCSupportsGameMode = YES;
 				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.games";
 				INFOPLIST_KEY_LSSupportsOpeningDocumentsInPlace = YES;
@ -646,10 +679,9 @@
 				INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents = YES;
 				INFOPLIST_KEY_UILaunchScreen_Generation = YES;
 				INFOPLIST_KEY_UIRequiresFullScreen = YES;
-				INFOPLIST_KEY_UISupportedInterfaceOrientations = "UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight UIInterfaceOrientationPortrait";
-				INFOPLIST_KEY_UISupportedInterfaceOrientations_iPad = "UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight";
+				INFOPLIST_KEY_UISupportedInterfaceOrientations = "UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown";
 				INFOPLIST_KEY_UISupportsDocumentBrowser = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 15.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@ -677,8 +709,36 @@
 					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
 					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
 					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
 				);
-				MARKETING_VERSION = 0.0.8;
+				MARKETING_VERSION = 1.2.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.stossy11.MeloNX;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_EMIT_LOC_STRINGS = YES;
@ -713,10 +773,28 @@
 					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
 					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
 					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
 				);
 				GCC_OPTIMIZATION_LEVEL = fast;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = MeloNX/Info.plist;
+				INFOPLIST_KEY_GCSupportsControllerUserInteraction = YES;
 				INFOPLIST_KEY_GCSupportsGameMode = YES;
 				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.games";
 				INFOPLIST_KEY_LSSupportsOpeningDocumentsInPlace = YES;
@ -725,10 +803,9 @@
 				INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents = YES;
 				INFOPLIST_KEY_UILaunchScreen_Generation = YES;
 				INFOPLIST_KEY_UIRequiresFullScreen = YES;
-				INFOPLIST_KEY_UISupportedInterfaceOrientations = "UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight UIInterfaceOrientationPortrait";
-				INFOPLIST_KEY_UISupportedInterfaceOrientations_iPad = "UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight";
+				INFOPLIST_KEY_UISupportedInterfaceOrientations = "UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown";
 				INFOPLIST_KEY_UISupportsDocumentBrowser = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 15.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@ -756,8 +833,36 @@
 					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
 					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
 					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
+					"$(PROJECT_DIR)/MeloNX/Dependencies/Dynamic\\ Libraries",
 				);
-				MARKETING_VERSION = 0.0.8;
+				MARKETING_VERSION = 1.2.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.stossy11.MeloNX;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_EMIT_LOC_STRINGS = YES;
--- a/src/MeloNX/MeloNX.xcodeproj/project.xcworkspace/xcuserdata/stossy11.xcuserdatad/UserInterfaceState.xcuserstate
+++ b/src/MeloNX/MeloNX.xcodeproj/project.xcworkspace/xcuserdata/stossy11.xcuserdatad/UserInterfaceState.xcuserstate
--- a/src/MeloNX/MeloNX.xcodeproj/xcuserdata/stossy11.xcuserdatad/xcschemes/xcschememanagement.plist
+++ b/src/MeloNX/MeloNX.xcodeproj/xcuserdata/stossy11.xcuserdatad/xcschemes/xcschememanagement.plist
@ -12,12 +12,12 @@
 		<key>Ryujinx.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
-			<integer>2</integer>
+			<integer>1</integer>
 		</dict>
 		<key>com.Stossy11.MeloNX.RyujinxAg.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
-			<integer>1</integer>
+			<integer>2</integer>
 		</dict>
 	</dict>
 	<key>SuppressBuildableAutocreation</key>
--- a/src/MeloNX/MeloNX/App/Core/Entitlements/EntitlementChecker.swift
+++ b/src/MeloNX/MeloNX/App/Core/Entitlements/EntitlementChecker.swift
@ -0,0 +1,58 @@
+//
+//  EntitlementChecker.swift
+//  MeloNX
+//
+//  Created by Stossy11 on 15/02/2025.
+//
+
+import Foundation
+import Security
+
+typealias SecTaskRef = OpaquePointer
+
+@_silgen_name("SecTaskCopyValueForEntitlement")
+func SecTaskCopyValueForEntitlement(
+    _ task: SecTaskRef,
+    _ entitlement: NSString,
+    _ error: NSErrorPointer
+) -> CFTypeRef?
+
+@_silgen_name("SecTaskCreateFromSelf")
+func SecTaskCreateFromSelf(
+    _ allocator: CFAllocator?
+) -> SecTaskRef?
+
+@_silgen_name("SecTaskCopyValuesForEntitlements")
+func SecTaskCopyValuesForEntitlements(
+    _ task: SecTaskRef,
+    _ entitlements: CFArray,
+    _ error: UnsafeMutablePointer<Unmanaged<CFError>?>?
+) -> CFDictionary?
+
+func checkAppEntitlements(_ ents: [String]) -> [String: Any] {
+    guard let task = SecTaskCreateFromSelf(nil) else {
+        print("Failed to create SecTask")
+        return [:]
+    }
+    
+    guard let entitlements = SecTaskCopyValuesForEntitlements(task, ents as CFArray, nil) else {
+        print("Failed to get entitlements")
+        return [:]
+    }
+    
+    return (entitlements as? [String: Any]) ?? [:]
+}
+
+func checkAppEntitlement(_ ent: String) -> Bool {
+    guard let task = SecTaskCreateFromSelf(nil) else {
+        print("Failed to create SecTask")
+        return false
+    }
+    
+    guard let entitlements = SecTaskCopyValueForEntitlement(task, ent as NSString, nil) else {
+        print("Failed to get entitlements")
+        return false
+    }
+    
+    return entitlements.boolValue != nil && entitlements.boolValue
+}
--- a/src/MeloNX/MeloNX/App/Core/Headers/Ryujinx-Header.h
+++ b/src/MeloNX/MeloNX/App/Core/Headers/Ryujinx-Header.h
@ -5,7 +5,8 @@
 //  Created by Stossy11 on 3/11/2024.
 //

-#define DRM 1
+#define DRM 0
+#define CS_DEBUGGED 0x10000000

 #ifndef RyujinxHeader
 #define RyujinxHeader
@ -30,8 +31,21 @@ struct GameInfo {
    unsigned int ImageSize;
 };

+struct DlcNcaListItem {
+    char Path[256];
+    unsigned long TitleId;
+};
+
+struct DlcNcaList {
+    bool success;
+    unsigned int size;
+    struct DlcNcaListItem* items;
+};
+
 extern struct GameInfo get_game_info(int, char*);

+extern struct DlcNcaList get_dlc_nca_list(const char* titleIdPtr, const char* pathPtr);
+
 void install_firmware(const char* inputPtr);

 char* installed_firmware_version();
--- a/src/MeloNX/MeloNX/App/Core/JIT/IsJITEnabled.swift
+++ b/src/MeloNX/MeloNX/App/Core/JIT/IsJITEnabled.swift
@ -0,0 +1,19 @@
+//
+//  IsJITEnabled.swift
+//  MeloNX
+//
+//  Created by Stossy11 on 10/02/2025.
+//
+
+
+
+func isJITEnabled() -> Bool {
+    var flags: Int = 0
+    
+    csops(getpid(), 0, &flags, sizeof(flags))
+    return (Int32(flags) & CS_DEBUGGED) != 0;
+}
+
+func sizeof<T>(_ value: T) -> Int {
+    return MemoryLayout<T>.size
+}
--- a/src/MeloNX/MeloNX/App/Core/JIT/JitStreamerEB/EnableJIT.swift
+++ b/src/MeloNX/MeloNX/App/Core/JIT/JitStreamerEB/EnableJIT.swift
@ -0,0 +1,78 @@
+//
+//  EnableJIT.swift
+//  MeloNX
+//
+//  Created by Stossy11 on 10/02/2025.
+//
+
+import Foundation
+
+func enableJITEB()  {
+    guard let bundleID = Bundle.main.bundleIdentifier else {
+        return
+    }
+    let address = URL(string: "http://[fd00::]:9172/launch_app/\(bundleID)")!
+    
+    let task = URLSession.shared.dataTask(with: address) { data, response, error in
+        if error != nil {
+            return
+        }
+        
+        
+        guard let httpResponse = response as? HTTPURLResponse else {
+            return
+        }
+        DispatchQueue.main.async {
+            showLaunchAppAlert(jsonData: data!, in: UIApplication.shared.windows.last!.rootViewController!)
+        }
+        
+        return
+    }
+    
+    task.resume()
+}
+
+struct LaunchApp: Codable {
+    let ok: Bool
+    let error: String?
+    let launching: Bool
+    let position: Int?
+    let mounting: Bool
+}
+
+func showLaunchAppAlert(jsonData: Data, in viewController: UIViewController) {
+    do {
+        let result = try JSONDecoder().decode(LaunchApp.self, from: jsonData)
+        
+        var message = ""
+        
+        if let error = result.error {
+            message = "Error: \(error)"
+        } else if result.mounting {
+            message = "App is mounting..."
+        } else if result.launching {
+            message = "App is launching..."
+        } else {
+            message = "App launch status unknown."
+        }
+        
+        if let position = result.position {
+            message += "\nPosition: \(position)"
+        }
+        
+        let alert = UIAlertController(title: "Launch Status", message: message, preferredStyle: .alert)
+        alert.addAction(UIAlertAction(title: "OK", style: .default))
+        
+        DispatchQueue.main.async {
+            viewController.present(alert, animated: true)
+        }
+        
+    } catch {
+        let alert = UIAlertController(title: "Decoding Error", message: error.localizedDescription, preferredStyle: .alert)
+        alert.addAction(UIAlertAction(title: "OK", style: .default))
+        
+        DispatchQueue.main.async {
+            viewController.present(alert, animated: true)
+        }
+    }
+}
--- a/src/MeloNX/MeloNX/App/Core/JIT/utils.m
+++ b/src/MeloNX/MeloNX/App/Core/JIT/utils.m
@ -60,15 +60,6 @@ void ShowAlert(NSString* title, NSString* message, _Bool* showok)

 __attribute__((constructor)) static void entry(int argc, char **argv)
 {
-    if (isJITEnabled()) {
-        NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
-        [defaults setBool:YES forKey:@"JIT"];
-        [defaults synchronize]; // Ensure the value is saved immediately
-    } else {
-        NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
-        [defaults setBool:NO forKey:@"JIT"];
-        [defaults synchronize]; // Ensure the value is saved immediately
-    }
    
    if (getEntitlementValue(@"com.apple.developer.kernel.increased-memory-limit")) {
        NSLog(@"Entitlement Does Exist");
--- a/src/MeloNX/MeloNX/App/Core/Ryujinx/Controller/NativeController.swift
+++ b/src/MeloNX/MeloNX/App/Core/Ryujinx/Controller/NativeController.swift
@ -0,0 +1,237 @@
+//
+//  NativeController.swift
+//  MeloNX
+//
+//  Created by XITRIX on 15/02/2025.
+//
+
+import CoreHaptics
+import GameController
+
+class NativeController: Hashable {
+    private var instanceID: SDL_JoystickID = -1
+    private var controller: OpaquePointer?
+    private var nativeController: GCController
+    private let controllerHaptics: CHHapticEngine?
+
+    public var controllername: String { "GC - \(nativeController.vendorName ?? "Unknown")" }
+
+    init(_ controller: GCController) {
+        nativeController = controller
+        controllerHaptics = nativeController.haptics?.createEngine(withLocality: .default)
+        try? controllerHaptics?.start()
+        setupHandheldController()
+    }
+
+    deinit {
+        cleanup()
+    }
+
+    private func setupHandheldController() {
+        if SDL_WasInit(Uint32(SDL_INIT_GAMECONTROLLER)) == 0 {
+            SDL_InitSubSystem(Uint32(SDL_INIT_GAMECONTROLLER))
+        }
+
+        var joystickDesc = SDL_VirtualJoystickDesc(
+            version: UInt16(SDL_VIRTUAL_JOYSTICK_DESC_VERSION),
+            type: Uint16(SDL_JOYSTICK_TYPE_GAMECONTROLLER.rawValue),
+                naxes: 6,
+                nbuttons: 15,
+                nhats: 1,
+                vendor_id: 0,
+                product_id: 0,
+                padding: 0,
+                button_mask: 0,
+                axis_mask: 0,
+                name: (controllername as NSString).utf8String,
+                userdata: Unmanaged.passUnretained(self).toOpaque(),
+                Update: { userdata in
+                    // Update joystick state here
+                },
+                SetPlayerIndex: { userdata, playerIndex in
+                    print("Player index set to \(playerIndex)")
+                },
+                Rumble: { userdata, lowFreq, highFreq in
+                    print("Rumble with \(lowFreq), \(highFreq)")
+                    guard let userdata else { return 0 }
+                    let _self = Unmanaged<NativeController>.fromOpaque(userdata).takeUnretainedValue()
+                    VirtualController.rumble(lowFreq: Float(lowFreq), highFreq: Float(highFreq), engine: _self.controllerHaptics)
+                    return 0
+                },
+                RumbleTriggers: { userdata, leftRumble, rightRumble in
+                    print("Trigger rumble with \(leftRumble), \(rightRumble)")
+                    return 0
+                },
+                SetLED: { userdata, red, green, blue in
+                    print("Set LED to RGB(\(red), \(green), \(blue))")
+                    return 0
+                },
+                SendEffect: { userdata, data, size in
+                    print("Effect sent with size \(size)")
+                    return 0
+                }
+            )
+
+        instanceID = SDL_JoystickAttachVirtualEx(&joystickDesc)// SDL_JoystickAttachVirtual(SDL_JoystickType(SDL_JOYSTICK_TYPE_GAMECONTROLLER.rawValue), 6, 15, 1)
+        if instanceID < 0 {
+            print("Failed to create virtual joystick: \(String(cString: SDL_GetError()))")
+            return
+        }
+
+        // Open a game controller for the virtual joystick
+        let joystick = SDL_JoystickFromInstanceID(instanceID)
+        controller = SDL_GameControllerOpen(Int32(instanceID))
+
+        if controller == nil {
+            print("Failed to create virtual controller: \(String(cString: SDL_GetError()))")
+            return
+        }
+
+        if #available(iOS 16, *) {
+            guard let gamepad = nativeController.extendedGamepad
+            else { return }
+
+            setupButtonChangeListener(gamepad.buttonA, for: .B)
+            setupButtonChangeListener(gamepad.buttonB, for: .A)
+            setupButtonChangeListener(gamepad.buttonX, for: .Y)
+            setupButtonChangeListener(gamepad.buttonY, for: .X)
+
+            setupButtonChangeListener(gamepad.dpad.up, for: .dPadUp)
+            setupButtonChangeListener(gamepad.dpad.down, for: .dPadDown)
+            setupButtonChangeListener(gamepad.dpad.left, for: .dPadLeft)
+            setupButtonChangeListener(gamepad.dpad.right, for: .dPadRight)
+
+            setupButtonChangeListener(gamepad.leftShoulder, for: .leftShoulder)
+            setupButtonChangeListener(gamepad.rightShoulder, for: .rightShoulder)
+            gamepad.leftThumbstickButton.map { setupButtonChangeListener($0, for: .leftStick) }
+            gamepad.rightThumbstickButton.map { setupButtonChangeListener($0, for: .rightStick) }
+
+            setupButtonChangeListener(gamepad.buttonMenu, for: .start)
+            gamepad.buttonOptions.map { setupButtonChangeListener($0, for: .back) }
+
+            setupStickChangeListener(gamepad.leftThumbstick, for: .left)
+            setupStickChangeListener(gamepad.rightThumbstick, for: .right)
+
+            setupTriggerChangeListener(gamepad.leftTrigger, for: .left)
+            setupTriggerChangeListener(gamepad.rightTrigger, for: .right)
+        }
+    }
+
+    func setupButtonChangeListener(_ button: GCControllerButtonInput, for key: VirtualControllerButton) {
+        button.valueChangedHandler = { [unowned self] _, _, pressed in
+            setButtonState(pressed ? 1 : 0, for: key)
+        }
+    }
+
+    func setupStickChangeListener(_ button: GCControllerDirectionPad, for key: ThumbstickType) {
+        button.valueChangedHandler = { [unowned self] _, xValue, yValue in
+            let scaledX = Sint16(xValue * 32767.0)
+            let scaledY = -Sint16(yValue * 32767.0)
+
+            switch key {
+            case .left:
+                updateAxisValue(value: scaledX, forAxis: SDL_GameControllerAxis(SDL_CONTROLLER_AXIS_LEFTX.rawValue))
+                updateAxisValue(value: scaledY, forAxis: SDL_GameControllerAxis(SDL_CONTROLLER_AXIS_LEFTY.rawValue))
+            case .right:
+                updateAxisValue(value: scaledX, forAxis: SDL_GameControllerAxis(SDL_CONTROLLER_AXIS_RIGHTX.rawValue))
+                updateAxisValue(value: scaledY, forAxis: SDL_GameControllerAxis(SDL_CONTROLLER_AXIS_RIGHTY.rawValue))
+            }
+        }
+    }
+
+    func setupTriggerChangeListener(_ button: GCControllerButtonInput, for key: ThumbstickType) {
+        button.valueChangedHandler = { [unowned self] _, value, pressed in
+//            print("Value: \(value), Is pressed: \(pressed)")
+            let axis: SDL_GameControllerAxis = (key == .left) ? SDL_CONTROLLER_AXIS_TRIGGERLEFT : SDL_CONTROLLER_AXIS_TRIGGERRIGHT
+            let scaledValue = Sint16(value * 32767.0)
+            updateAxisValue(value: scaledValue, forAxis: axis)
+        }
+    }
+
+    static func rumble(lowFreq: Float, highFreq: Float) {
+        do {
+            // Low-frequency haptic pattern
+            let lowFreqPattern = try CHHapticPattern(events: [
+                CHHapticEvent(eventType: .hapticTransient, parameters: [
+                    CHHapticEventParameter(parameterID: .hapticIntensity, value: lowFreq),
+                    CHHapticEventParameter(parameterID: .hapticSharpness, value: 0.5)
+                ], relativeTime: 0, duration: 0.2)
+            ], parameters: [])
+
+            // High-frequency haptic pattern
+            let highFreqPattern = try CHHapticPattern(events: [
+                CHHapticEvent(eventType: .hapticTransient, parameters: [
+                    CHHapticEventParameter(parameterID: .hapticIntensity, value: highFreq),
+                    CHHapticEventParameter(parameterID: .hapticSharpness, value: 1.0)
+                ], relativeTime: 0.2, duration: 0.2)
+            ], parameters: [])
+
+            // Create and start the haptic engine
+            let engine = try CHHapticEngine()
+            try engine.start()
+
+            // Create and play the low-frequency player
+            let lowFreqPlayer = try engine.makePlayer(with: lowFreqPattern)
+            try lowFreqPlayer.start(atTime: 0)
+
+            // Create and play the high-frequency player after a short delay
+            let highFreqPlayer = try engine.makePlayer(with: highFreqPattern)
+            try highFreqPlayer.start(atTime: 0.2)
+
+        } catch {
+            print("Error creating haptic patterns: \(error)")
+        }
+    }
+
+
+    func updateAxisValue(value: Sint16, forAxis axis: SDL_GameControllerAxis) {
+        guard controller != nil else { return }
+        let joystick = SDL_JoystickFromInstanceID(instanceID)
+        SDL_JoystickSetVirtualAxis(joystick, axis.rawValue, value)
+    }
+
+    func thumbstickMoved(_ stick: ThumbstickType, x: Double, y: Double) {
+        let scaleFactor = 32767.0 / 160
+
+        let scaledX = Int16(min(32767.0, max(-32768.0, x * scaleFactor)))
+        let scaledY = Int16(min(32767.0, max(-32768.0, y * scaleFactor)))
+
+        if stick == .right {
+            updateAxisValue(value: scaledX, forAxis: SDL_GameControllerAxis(SDL_CONTROLLER_AXIS_RIGHTX.rawValue))
+            updateAxisValue(value: scaledY, forAxis: SDL_GameControllerAxis(SDL_CONTROLLER_AXIS_RIGHTY.rawValue))
+        } else {  // ThumbstickType.left
+            updateAxisValue(value: scaledX, forAxis: SDL_GameControllerAxis(SDL_CONTROLLER_AXIS_LEFTX.rawValue))
+            updateAxisValue(value: scaledY, forAxis: SDL_GameControllerAxis(SDL_CONTROLLER_AXIS_LEFTY.rawValue))
+        }
+    }
+
+    func setButtonState(_ state: Uint8, for button: VirtualControllerButton) {
+        guard controller != nil else { return }
+
+//        print("Button: \(button.rawValue) {state: \(state)}")
+        if (button == .leftTrigger || button == .rightTrigger) && (state == 1 || state == 0) {
+            let axis: SDL_GameControllerAxis = (button == .leftTrigger) ? SDL_CONTROLLER_AXIS_TRIGGERLEFT : SDL_CONTROLLER_AXIS_TRIGGERRIGHT
+            let value: Int = (state == 1) ? 32767 : 0
+            updateAxisValue(value: Sint16(value), forAxis: axis)
+        } else {
+            let joystick = SDL_JoystickFromInstanceID(instanceID)
+            SDL_JoystickSetVirtualButton(joystick, Int32(button.rawValue), state)
+        }
+    }
+
+    func cleanup() {
+        if let controller {
+            SDL_JoystickDetachVirtual(instanceID)
+            SDL_GameControllerClose(controller)
+            self.controller = nil
+        }
+    }
+
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(nativeController)
+    }
+
+    static func == (lhs: NativeController, rhs: NativeController) -> Bool {
+        lhs.nativeController == rhs.nativeController
+    }
+}
--- a/src/MeloNX/MeloNX/App/Core/Ryujinx/Controller/VirtualController.swift
+++ b/src/MeloNX/MeloNX/App/Core/Ryujinx/Controller/VirtualController.swift
@ -78,7 +78,7 @@ class VirtualController {
        }
    }
    
-    static func rumble(lowFreq: Float, highFreq: Float) {
+    static func rumble(lowFreq: Float, highFreq: Float, engine: CHHapticEngine? = nil) {
        do {
            // Low-frequency haptic pattern
            let lowFreqPattern = try CHHapticPattern(events: [
@ -96,9 +96,23 @@ class VirtualController {
                ], relativeTime: 0.2, duration: 0.2)
            ], parameters: [])

-            // Create and start the haptic engine
-            let engine = try CHHapticEngine()
-            try engine.start()
+            // Mutable engine
+            var engine = engine
+
+            // If no engine passed, use device engine
+            if engine == nil {
+                // Create and start the haptic engine
+                if hapticEngine == nil {
+                    hapticEngine = try CHHapticEngine()
+                    try hapticEngine?.start()
+                }
+
+                engine = hapticEngine
+            }
+
+            guard let engine else {
+                return print("Error creating haptic patterns: hapticEngine is nil")
+            }

            // Create and play the low-frequency player
            let lowFreqPlayer = try engine.makePlayer(with: lowFreqPattern)
@ -113,6 +127,8 @@ class VirtualController {
        }
    }

+    private static var hapticEngine: CHHapticEngine?
+
    
    func updateAxisValue(value: Sint16, forAxis axis: SDL_GameControllerAxis) {
        guard controller != nil else { return }
--- a/src/MeloNX/MeloNX/App/Core/Ryujinx/Display/DisplayVisible.swift
+++ b/src/MeloNX/MeloNX/App/Core/Ryujinx/Display/DisplayVisible.swift
@ -8,6 +8,7 @@
 import Foundation
 import GameController
 import UIKit
+import SwiftUI



@ -16,12 +17,79 @@ extension UIWindow {
    // Makes the SDLWindow use the current WindowScene instead of making its own window.
    // Also waits for the window to append the on-screen controller
    @objc func wdb_makeKeyAndVisible() {
-        if #available(iOS 13.0, *) {
-            // self.windowScene = (UIApplication.shared.connectedScenes.first! as! UIWindowScene)
+        let enabled =  UserDefaults.standard.bool(forKey: "oldWindowCode")
+        
+        if #unavailable(iOS 17.0), enabled {
+            self.windowScene = (UIApplication.shared.connectedScenes.first! as! UIWindowScene)
        }
+        
        self.wdb_makeKeyAndVisible()
        theWindow = self
-        Ryujinx.shared.repeatuntilfindLayer()
+        
+        if #available(iOS 17, *) {
+            Ryujinx.shared.repeatuntilfindLayer()
+        } else if UserDefaults.standard.bool(forKey: "isVirtualController") && enabled {
+            waitForController()
+        }
+    }
+}
+
+// MARK: - iOS 16 and below Only
+
+var hostingController: UIHostingController<ControllerView>?
+func waitForController() {
+    guard let window = theWindow else { return }
+
+    // Function to search for an existing UIHostingController with ControllerView
+    func findGCControllerView(in view: UIView) -> UIHostingController<ControllerView>? {
+        if let hostingVC = view.next as? UIHostingController<ControllerView> {
+            return hostingVC
+        }
+        
+        for subview in view.subviews {
+            if let found = findGCControllerView(in: subview) {
+                return found
+            }
+        }
+        
+        return nil
+    }
+    
+    let controllerView = ControllerView()
+    let newHostingController = UIHostingController(rootView: controllerView)
+    
+    hostingController = newHostingController
+    
+    let containerView = newHostingController.view!
+    containerView.backgroundColor = .clear
+    containerView.frame = window.bounds
+    containerView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+
+    // Timer for controller
+    Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { timer in
+        if findGCControllerView(in: window) == nil {
+            // Adds Virtual Controller Subview
+            window.addSubview(containerView)
+            window.bringSubviewToFront(containerView)
+
+            if let sdlWindow = SDL_GetWindowFromID(1) {
+                SDL_SetWindowPosition(sdlWindow, 0, 0)
+            }
+
+            timer.invalidate()
+        }
+    }
+}
+
+
+class TransparentHostingContainerView: UIView {
+    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+        // Check if the point is within the subviews of this container
+        let view = super.hitTest(point, with: event)
+        print(view)
+        
+        // Return nil if the touch is outside visible content (passes through to views below)
+        return view === self ? nil : view
    }
 }

--- a/src/MeloNX/MeloNX/App/Core/Ryujinx/Enums/Display/AspectRatio.swift
+++ b/src/MeloNX/MeloNX/App/Core/Ryujinx/Enums/Display/AspectRatio.swift
@ -0,0 +1,28 @@
+//
+//  AspectRatio.swift
+//  MeloNX
+//
+//  Created by Stossy11 on 16/02/2025.
+//
+
+import Foundation
+
+public enum AspectRatio: String, Codable, CaseIterable {
+    case fixed4x3 = "Fixed4x3"
+    case fixed16x9 = "Fixed16x9"
+    case fixed16x10 = "Fixed16x10"
+    case fixed21x9 = "Fixed21x9"
+    case fixed32x9 = "Fixed32x9"
+    case stretched = "Stretched"
+
+    var displayName: String {
+        switch self {
+        case .fixed4x3: return "4:3"
+        case .fixed16x9: return "16:9 (Default)"
+        case .fixed16x10: return "16:10"
+        case .fixed21x9: return "21:9"
+        case .fixed32x9: return "32:9"
+        case .stretched: return "Stretched (Full Screen)"
+        }
+    }
+}
--- a/src/MeloNX/MeloNX/App/Core/Ryujinx/Enums/LanguageAndRegion/Language.swift
+++ b/src/MeloNX/MeloNX/App/Core/Ryujinx/Enums/LanguageAndRegion/Language.swift
@ -0,0 +1,52 @@
+//
+//  Language.swift
+//  MeloNX
+//
+//  Created by Stossy11 on 16/02/2025.
+//
+
+import Foundation
+
+public enum SystemLanguage: String, Codable, CaseIterable {
+    case japanese = "Japanese"
+    case americanEnglish = "AmericanEnglish"
+    case french = "French"
+    case german = "German"
+    case italian = "Italian"
+    case spanish = "Spanish"
+    case chinese = "Chinese"
+    case korean = "Korean"
+    case dutch = "Dutch"
+    case portuguese = "Portuguese"
+    case russian = "Russian"
+    case taiwanese = "Taiwanese"
+    case britishEnglish = "BritishEnglish"
+    case canadianFrench = "CanadianFrench"
+    case latinAmericanSpanish = "LatinAmericanSpanish"
+    case simplifiedChinese = "SimplifiedChinese"
+    case traditionalChinese = "TraditionalChinese"
+    case brazilianPortuguese = "BrazilianPortuguese"
+
+    var displayName: String {
+        switch self {
+        case .japanese: return "Japanese"
+        case .americanEnglish: return "American English"
+        case .french: return "French"
+        case .german: return "German"
+        case .italian: return "Italian"
+        case .spanish: return "Spanish"
+        case .chinese: return "Chinese"
+        case .korean: return "Korean"
+        case .dutch: return "Dutch"
+        case .portuguese: return "Portuguese"
+        case .russian: return "Russian"
+        case .taiwanese: return "Taiwanese"
+        case .britishEnglish: return "British English"
+        case .canadianFrench: return "Canadian French"
+        case .latinAmericanSpanish: return "Latin American Spanish"
+        case .simplifiedChinese: return "Simplified Chinese"
+        case .traditionalChinese: return "Traditional Chinese"
+        case .brazilianPortuguese: return "Brazilian Portuguese"
+        }
+    }
+}
--- a/src/MeloNX/MeloNX/App/Core/Ryujinx/Enums/LanguageAndRegion/Region.swift
+++ b/src/MeloNX/MeloNX/App/Core/Ryujinx/Enums/LanguageAndRegion/Region.swift
@ -0,0 +1,31 @@
+//
+//  Region.swift
+//  MeloNX
+//
+//  Created by Stossy11 on 16/02/2025.
+//
+
+import Foundation
+
+public enum SystemRegionCode: String, Codable, CaseIterable {
+    case japan = "Japan"
+    case usa = "USA"
+    case europe = "Europe"
+    case australia = "Australia"
+    case china = "China"
+    case korea = "Korea"
+    case taiwan = "Taiwan"
+    
+    var displayName: String {
+        switch self {
+        case .japan: return "Japan"
+        case .usa: return "United States"
+        case .europe: return "Europe"
+        case .australia: return "Australia"
+        case .china: return "China"
+        case .korea: return "Korea"
+        case .taiwan: return "Taiwan"
+        }
+    }
+}
+
--- a/src/MeloNX/MeloNX/App/Core/Ryujinx/Ryujinx.swift
+++ b/src/MeloNX/MeloNX/App/Core/Ryujinx/Ryujinx.swift
@ -28,26 +28,6 @@ struct iOSNav<Content: View>: View {
    }
 }

-public enum AspectRatio: String, Codable, CaseIterable {
-    case fixed4x3 = "Fixed4x3"
-    case fixed16x9 = "Fixed16x9"
-    case fixed16x10 = "Fixed16x10"
-    case fixed21x9 = "Fixed21x9"
-    case fixed32x9 = "Fixed32x9"
-    case stretched = "Stretched"
-
-    var displayName: String {
-        switch self {
-        case .fixed4x3: return "4:3"
-        case .fixed16x9: return "16:9 (Default)"
-        case .fixed16x10: return "16:10"
-        case .fixed21x9: return "21:9"
-        case .fixed32x9: return "32:9"
-        case .stretched: return "Stretched (Full Screen)"
-        }
-    }
-}
-

 class Ryujinx {
    private var isRunning = false
@ -58,6 +38,9 @@ class Ryujinx {
    @Published var metalLayer: CAMetalLayer? = nil
    @Published var firmwareversion = "0"
    @Published var emulationUIView = UIView()
+    @Published var games: [Game] = []
+    
+    @Published var defMLContentSize: CGFloat?
    
    var shouldMetal: Bool {
        metalLayer == nil
@ -65,7 +48,9 @@ class Ryujinx {
    
    static let shared = Ryujinx()
    
-    private init() {}
+    private init() {
+        self.games = loadGames()
+    }
    
    public struct Configuration : Codable, Equatable {
        var gamepath: String
@ -88,6 +73,11 @@ class Ryujinx {
        var ignoreMissingServices: Bool
        var expandRam: Bool
        var dfsIntegrityChecks: Bool
+        var disablePTC: Bool
+        var disablevsync: Bool
+        var language: SystemLanguage
+        var regioncode: SystemRegionCode
+        var handHeldController: Bool
        

        init(gamepath: String,
@ -109,7 +99,12 @@ class Ryujinx {
             ignoreMissingServices: Bool = false,
             hypervisor: Bool = false,
             expandRam: Bool = false,
-             dfsIntegrityChecks: Bool = false
+             dfsIntegrityChecks: Bool = false,
+             disablePTC: Bool = false,
+             disablevsync: Bool = false,
+             language: SystemLanguage = .americanEnglish,
+             regioncode: SystemRegionCode = .usa,
+             handHeldController: Bool = false
        ) {
            self.gamepath = gamepath
            self.inputids = inputids
@ -131,6 +126,11 @@ class Ryujinx {
            self.ignoreMissingServices = ignoreMissingServices
            self.hypervisor = hypervisor
            self.dfsIntegrityChecks = dfsIntegrityChecks
+            self.disablePTC = disablePTC
+            self.disablevsync = disablevsync
+            self.language = language
+            self.regioncode = regioncode
+            self.handHeldController = handHeldController
        }
    }

@ -142,7 +142,7 @@ class Ryujinx {
        
        isRunning = true
        
-        MainThread {
+        RunLoop.current.perform {
            
            let url = URL(string: config.gamepath)
            
@ -187,20 +187,51 @@ class Ryujinx {
    }
    
    
-    func MainThread(_ block: @escaping @Sendable () -> Void) {
-        if #available(iOS 17.0, *) {
-            RunLoop.current.perform {
-                autoreleasepool {
-                    block()
-                }
-            }
-        } else {
-            DispatchQueue.main.async {
-                autoreleasepool {
-                    block()
-                }
+    func loadGames() -> [Game] {
+        let fileManager = FileManager.default
+        guard let documentsDirectory = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first else { return [] }
+        
+        let romsDirectory = documentsDirectory.appendingPathComponent("roms")
+        
+        if (!fileManager.fileExists(atPath: romsDirectory.path)) {
+            do {
+                try fileManager.createDirectory(at: romsDirectory, withIntermediateDirectories: true, attributes: nil)
+            } catch {
+                print("Failed to create roms directory: \(error)")
            }
        }
+        var games: [Game] = []
+        
+        do {
+            let files = try fileManager.contentsOfDirectory(at: romsDirectory, includingPropertiesForKeys: nil)
+            
+            for fileURLCandidate in files {
+                if fileURLCandidate.pathExtension == "zip" {
+                    continue
+                }
+                
+                do {
+                    let handle = try FileHandle(forReadingFrom: fileURLCandidate)
+                    let fileExtension = (fileURLCandidate.pathExtension as NSString).utf8String
+                    let extensionPtr = UnsafeMutablePointer<CChar>(mutating: fileExtension)
+                    
+                    
+                    let gameInfo = get_game_info(handle.fileDescriptor, extensionPtr)
+                    
+                    let game = Game.convertGameInfoToGame(gameInfo: gameInfo, url: fileURLCandidate)
+                    
+                    games.append(game)
+                } catch {
+                    print(error)
+                }
+            }
+
+            return games
+        } catch {
+            print("Error loading games from roms folder: \(error)")
+            return games
+        }
+        
    }

    private func buildCommandLineArgs(from config: Configuration) -> [String] {
@ -221,14 +252,24 @@ class Ryujinx {
        // We don't need this. Ryujinx should handle it fine :3
        // this also causes crashes in some games :3
        
+        args.append(contentsOf: ["--system-language", config.language.rawValue])
+        
+        args.append(contentsOf: ["--system-region", config.regioncode.rawValue])
+        
        args.append(contentsOf: ["--aspect-ratio", config.aspectRatio.rawValue])
        
        if config.nintendoinput {
            args.append("--correct-controller")
        }
        
+        if config.disablePTC {
+            args.append("--disable-ptc")
+        }
+        
+        if config.disablevsync {
+            args.append("--disable-vsync")
+        }
        
-        // args.append("--disable-vsync")
         
        if config.hypervisor {
            args.append("--use-hypervisor")
@ -248,7 +289,8 @@ class Ryujinx {
        }
        
        if config.ignoreMissingServices {
-            args.append(contentsOf: ["--ignore-missing-services", String(config.maxAnisotropy)])
+            // args.append(contentsOf: ["--ignore-missing-services"])
+            args.append("--ignore-missing-services")
        }
        
        if config.maxAnisotropy != 0 {
@ -271,21 +313,25 @@ class Ryujinx {
        }
        
        if config.debuglogs {
-            args.append(contentsOf: ["--enable-debug-logs"])
+            args.append("--enable-debug-logs")
        }
        if config.tracelogs {
-            args.append(contentsOf: ["--enable-trace-logs"])
+            args.append("--enable-trace-logs")
        }

        // List the input ids
        if config.listinputids {
-            args.append(contentsOf: ["--list-inputs-ids"])
+            args.append("--list-inputs-ids")
        }
        
-        // Append the input ids (limit to 4 just in case)
+        // Append the input ids (limit to 8 (used to be 4) just in case)
        if !config.inputids.isEmpty {
-            config.inputids.prefix(4).enumerated().forEach { index, inputId in
-                args.append(contentsOf: ["--input-id-\(index + 1)", inputId])
+            config.inputids.prefix(8).enumerated().forEach { index, inputId in
+                if config.handHeldController {
+                    args.append(contentsOf: ["\(index == 0 ? "--input-id-handheld" : "--input-id-\(index + 1)")", inputId])
+                } else {
+                    args.append(contentsOf: ["--input-id-\(index + 1)", inputId])
+                }
            }
        }

@ -327,6 +373,29 @@ class Ryujinx {
        }
    }

+    func getDlcNcaList(titleId: String, path: String) -> [DownloadableContentNca] {
+        guard let titleIdCString = titleId.cString(using: .utf8),
+            let pathCString = path.cString(using: .utf8)
+        else {
+            print("Invalid path")
+            return []
+        }
+
+        let listPointer = get_dlc_nca_list(titleIdCString, pathCString)
+        print("DLC parcing success: \(listPointer.success)")
+        guard listPointer.success else { return [] }
+
+        let list = Array(UnsafeBufferPointer(start: listPointer.items, count: Int(listPointer.size)))
+
+        return list.map { item in
+                .init(fullPath: withUnsafePointer(to: item.Path) {
+                    $0.withMemoryRebound(to: UInt8.self, capacity: MemoryLayout.size(ofValue: $0)) {
+                        String(cString: $0)
+                    }
+                }, titleId: item.TitleId, enabled: true)
+        }
+    }
+
    private func generateGamepadId(joystickIndex: Int32) -> String? {
        let guid = SDL_JoystickGetDeviceGUID(joystickIndex)

@ -478,4 +547,3 @@ class Ryujinx {
 }


-
--- a/src/MeloNX/MeloNX/App/Intents/LaunchGameIntent.swift
+++ b/src/MeloNX/MeloNX/App/Intents/LaunchGameIntent.swift
@ -0,0 +1,86 @@
+//
+//  LaunchGameIntentDef.swift
+//  MeloNX
+//
+//  Created by Stossy11 on 10/02/2025.
+//
+
+
+import Foundation
+import SwiftUI
+import Intents
+import AppIntents
+
+@available(iOS 16.0, *)
+struct LaunchGameIntentDef: AppIntent {
+    
+    static let title: LocalizedStringResource = "Launch Game"
+    
+    static var description = IntentDescription("Launches the Selected Game.")
+
+    @Parameter(title: "Game", optionsProvider: GameOptionsProvider())
+    var gameName: String
+
+    static var parameterSummary: some ParameterSummary {
+        Summary("Launch \(\.$gameName)")
+    }
+    
+    static var openAppWhenRun: Bool = true
+
+    @MainActor
+    func perform() async throws -> some IntentResult {
+        
+        let ryujinx = Ryujinx.shared.games
+        
+        let name = findClosestGameName(input: gameName, games: ryujinx.flatMap(\.titleName))
+        
+        let urlString = "melonx://game?name=\(name ?? gameName)"
+        print(urlString)
+        if let url = URL(string: urlString) {
+            UIApplication.shared.open(url, options: [:], completionHandler: nil)
+        }
+        
+        return .result()
+    }
+    
+    func levenshteinDistance(_ a: String, _ b: String) -> Int {
+        let aCount = a.count
+        let bCount = b.count
+        var matrix = [[Int]](repeating: [Int](repeating: 0, count: bCount + 1), count: aCount + 1)
+        
+        for i in 0...aCount {
+            matrix[i][0] = i
+        }
+        
+        for j in 0...bCount {
+            matrix[0][j] = j
+        }
+        
+        for i in 1...aCount {
+            for j in 1...bCount {
+                let cost = a[a.index(a.startIndex, offsetBy: i - 1)] == b[b.index(b.startIndex, offsetBy: j - 1)] ? 0 : 1
+                matrix[i][j] = min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost)
+            }
+        }
+        
+        return matrix[aCount][bCount]
+    }
+
+    func findClosestGameName(input: String, games: [String]) -> String? {
+        let closestGame = games.min { a, b in
+            let distanceA = levenshteinDistance(input, a)
+            let distanceB = levenshteinDistance(input, b)
+            return distanceA < distanceB
+        }
+        return closestGame
+    }
+}
+
+@available(iOS 16.0, *)
+struct GameOptionsProvider: DynamicOptionsProvider {
+    func results() async throws -> [String] {
+        let dynamicGames = Ryujinx.shared.loadGames()
+        
+        return dynamicGames.map { $0.titleName }
+    }
+}
--- a/src/MeloNX/MeloNX/App/Models/Game.swift
+++ b/src/MeloNX/MeloNX/App/Models/Game.swift
@ -8,7 +8,7 @@
 import SwiftUI
 import UniformTypeIdentifiers

-public struct Game: Identifiable, Equatable {
+public struct Game: Identifiable, Equatable, Hashable {
    public var id = UUID()

    var containerFolder: URL
--- a/src/MeloNX/MeloNX/App/Views/ContentView.swift
+++ b/src/MeloNX/MeloNX/App/Views/ContentView.swift
@ -26,6 +26,7 @@ struct ContentView: View {
    @State private var controllersList: [Controller] = []
    @State private var currentControllers: [Controller] = []
    @State var onscreencontroller: Controller = Controller(id: "", name: "")
+    @State var nativeControllers: [GCController: NativeController] = [:]
    @State private var isVirtualControllerActive: Bool = false
    @AppStorage("isVirtualController") var isVCA: Bool = true
    
@ -35,13 +36,14 @@ struct ContentView: View {
    @AppStorage("useTrollStore") var useTrollStore: Bool = false
    
    // JIT
-    @AppStorage("JIT") var isJITEnabled: Bool = false
+    @AppStorage("jitStreamerEB") var jitStreamerEB: Bool = false
    
    // Other Configuration
    @State var isMK8: Bool = false
    @AppStorage("quit") var quit: Bool = false
    @State var quits: Bool = false
    @AppStorage("MVK_CONFIG_PREFILL_METAL_COMMAND_BUFFERS") var mVKPreFillBuffer: Bool = true
+    @AppStorage("MVK_CONFIG_SYNCHRONOUS_QUEUE_SUBMITS") var syncqsubmits: Bool = true
    
    // Loading Animation
    @State private var clumpOffset: CGFloat = -100
@ -61,8 +63,9 @@ struct ContentView: View {
            // Metal Private API isn't needed and causes more stutters
            MoltenVKSettings(string: "MVK_USE_METAL_PRIVATE_API", value: "1"),
            MoltenVKSettings(string: "MVK_CONFIG_USE_METAL_PRIVATE_API", value: "1"),
-            MoltenVKSettings(string: "MVK_DEBUG", value: "1"),
-            MoltenVKSettings(string: "MVK_CONFIG_LOG_LEVEL", value: "2"),
+            MoltenVKSettings(string: "MVK_DEBUG", value: "0"),
+            MoltenVKSettings(string: "MVK_CONFIG_SYNCHRONOUS_QUEUE_SUBMITS", value: "0"),
+            // MoltenVKSettings(string: "MVK_CONFIG_LOG_LEVEL", value: "0"),
            // MVK_CONFIG_LOG_LEVEL
            //MVK_DEBUG
            // Uses more ram but makes performance higher, may add an option in settings to change or enable / disable this value (default 64 or 192 depending on what i decide)
@ -71,7 +74,7 @@ struct ContentView: View {
        
        _settings = State(initialValue: defaultSettings)
        
-        print("JIT Enabled: \(isJITEnabled)")
+        print("JIT Enabled: \(isJITEnabled())")
        
        initializeSDL()
    }
@ -86,29 +89,38 @@ struct ContentView: View {
                            Air.play(AnyView(emulationView))
                        }
                } else {
+                    ZStack {
+                        emulationView
+                            .onAppear() {
+                                // This is fro the old exiting game feature that didn't work properly. will look into it and figure out a better alternative
+                                /*
+                                 Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { timer in
+                                 timer.invalidate()
+                                 quits = quit
                                 
-                    emulationView
-                        .onAppear() {
-                            // This is fro the old exiting game feature that didn't work properly. will look into it and figure out a better alternative
-                            /*
-                             Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { timer in
-                             timer.invalidate()
-                             quits = quit
-                             
-                             if quits {
-                             quit = false
-                             timer.invalidate()
-                             }
-                             }
-                             */
-                        }
+                                 if quits {
+                                 quit = false
+                                 timer.invalidate()
+                                 }
+                                 }
+                                 */
+                            }
+                    }
                }
            } else {
                // This is when the game starts to stop the animation
-                EmulationView()
-                    .onAppear() {
-                        isAnimating = false
+                if #available(iOS 16, *) {
+                    EmulationView()
+                        .persistentSystemOverlays(.hidden)
+                        .onAppear() {
+                            isAnimating = false
+                        }
+                } else {
+                    VStack {
+                        
                    }
+                    
+                }
            }
        } else {
            // This is the main menu view that includes the Settings and the Game Selector
@ -118,6 +130,17 @@ struct ContentView: View {

                    initControllerObservers() // This initializes the Controller Observers that refreshes the controller list when a new controller connecvts.
                }
+                .onOpenURL() { url in
+                    if let components = URLComponents(url: url, resolvingAgainstBaseURL: true),
+                       components.host == "game" {
+                        if let text = components.queryItems?.first(where: { $0.name == "id" })?.value {
+
+                            game = Ryujinx.shared.games.first(where: { $0.titleId == text })
+                        } else if let text = components.queryItems?.first(where: { $0.name == "name" })?.value {
+                            game = Ryujinx.shared.games.first(where: { $0.titleName == text })
+                        }
+                    }
+                }
        }
        
    }
@ -130,6 +153,7 @@ struct ContentView: View {
            queue: .main) { notification in
                if let controller = notification.object as? GCController {
                    print("Controller connected: \(controller.productCategory)")
+                    nativeControllers[controller] = .init(controller)
                    refreshControllersList()
                }
        }
@ -141,6 +165,8 @@ struct ContentView: View {
            queue: .main) { notification in
                if let controller = notification.object as? GCController {
                    print("Controller disconnected: \(controller.productCategory)")
+                    nativeControllers[controller]?.cleanup()
+                    nativeControllers[controller] = nil
                    refreshControllersList()
                }
        }
@ -203,6 +229,7 @@ struct ContentView: View {
                                        withAnimation {
                                            isLoading = false
                                        }
+                                        
                                        isAnimating = false
                                        timer.invalidate()
                                    }
@ -232,17 +259,28 @@ struct ContentView: View {
                }
                
                Air.play(AnyView(
-                    Text("Select Game")
-                        .font(.system(size: 100))
+                    VStack {
+                        Image(systemName: "gamecontroller")
+                            .font(.system(size: 300))
+                            .foregroundColor(.gray)
+                            .padding(.bottom, 10)
                        
+                        Text("Select Game")
+                            .font(.system(size: 150))
+                            .bold()
+                    }
                ))
                
-                let isJIT = UserDefaults.standard.bool(forKey: "JIT-ENABLED")
+                let isJIT = isJITEnabled()
                
                if !isJIT, useTrollStore {
                    askForJIT()
                }
                
+                if !isJIT, jitStreamerEB {
+                    enableJITEB()
+                }
+                
            }
    }
    
@ -272,7 +310,8 @@ struct ContentView: View {
            self.onscreencontroller = onscreen
        }
        
-        controllersList.removeAll(where: { $0.id == "0"})
+        controllersList.removeAll(where: { $0.id == "0" || (!$0.name.starts(with: "GC - ") && $0 != onscreencontroller) })
+        controllersList.mutableForEach { $0.name = $0.name.replacingOccurrences(of: "GC - ", with: "") }

        currentControllers = []
        
@ -322,6 +361,11 @@ struct ContentView: View {
            setenv(setting.string, setting.value, 1)
        }
        
+        if syncqsubmits {
+            let setting = MoltenVKSettings(string: "MVK_CONFIG_SYNCHRONOUS_QUEUE_SUBMITS", value: "2")
+            setenv(setting.string, setting.value, 1)
+        }
+        
        if config.inputids.isEmpty {
            config.inputids.append("0")
        }
@ -358,3 +402,10 @@ func loadSettings() -> Ryujinx.Configuration? {
    }
 }

+extension Array {
+    @inlinable public mutating func mutableForEach(_ body: (inout Element) throws -> Void) rethrows {
+        for index in self.indices {
+            try body(&self[index])
+        }
+    }
+}
--- a/src/MeloNX/MeloNX/App/Views/ControllerView/ControllerView.swift
+++ b/src/MeloNX/MeloNX/App/Views/ControllerView/ControllerView.swift
@ -45,7 +45,7 @@ struct ControllerView: View {
                                    DPadView()
                                }
                            }
-                            .padding()
+                            Spacer()
                            VStack {
                                ShoulderButtonsViewRight()
                                ZStack {
@ -53,7 +53,6 @@ struct ControllerView: View {
                                    ABXYView()
                                }
                            }
-                            .padding()
                        }
                        
                        HStack {
@ -63,8 +62,8 @@ struct ControllerView: View {
                                .padding(.horizontal, 40)
                        }
                    }
-                    .padding(.bottom, geometry.size.height / 3.2) // very broken
                }
+                
            } else {
                // could be landscape
                VStack {
@ -100,12 +99,12 @@ struct ControllerView: View {
                                // Spacer()
                                VStack {
                                    // Spacer()
-                                    ButtonView(button: .back) // Adding the + button
+                                    ButtonView(button: .back) // Adding the - button
                                }
                                Spacer()
                                VStack {
                                    // Spacer()
-                                    ButtonView(button: .start) // Adding the - button
+                                    ButtonView(button: .start) // Adding the + button
                                }
                                // Spacer()
                            }
@ -130,6 +129,8 @@ struct ControllerView: View {
 struct ShoulderButtonsViewLeft: View {
    @State var width: CGFloat = 160
    @State var height: CGFloat = 20
+    @AppStorage("On-ScreenControllerScale") var controllerScale: Double = 1.0
+    
    var body: some View {
        HStack {
            ButtonView(button: .leftTrigger)
@ -143,6 +144,9 @@ struct ShoulderButtonsViewLeft: View {
                width *= 1.2
                height *= 1.2
            }
+            
+            width *= CGFloat(controllerScale)
+            height *= CGFloat(controllerScale)
        }
    }
 }
@ -150,6 +154,8 @@ struct ShoulderButtonsViewLeft: View {
 struct ShoulderButtonsViewRight: View {
    @State var width: CGFloat = 160
    @State var height: CGFloat = 20
+    @AppStorage("On-ScreenControllerScale") var controllerScale: Double = 1.0
+    
    var body: some View {
        HStack {
            ButtonView(button: .rightShoulder)
@ -163,12 +169,16 @@ struct ShoulderButtonsViewRight: View {
                width *= 1.2
                height *= 1.2
            }
+            
+            width *= CGFloat(controllerScale)
+            height *= CGFloat(controllerScale)
        }
    }
 }

 struct DPadView: View {
    @State var size: CGFloat = 145
+    @AppStorage("On-ScreenControllerScale") var controllerScale: Double = 1.0
    var body: some View {
        VStack {
            ButtonView(button: .dPadUp)
@ -185,12 +195,16 @@ struct DPadView: View {
            if UIDevice.current.systemName.contains("iPadOS") {
                size *= 1.2
            }
+            
+            size *= CGFloat(controllerScale)
        }
    }
 }

 struct ABXYView: View {
    @State var size: CGFloat = 145
+    @AppStorage("On-ScreenControllerScale") var controllerScale: Double = 1.0
+    
    var body: some View {
        VStack {
            ButtonView(button: .X)
@ -207,6 +221,8 @@ struct ABXYView: View {
            if UIDevice.current.systemName.contains("iPadOS") {
                size *= 1.2
            }
+            
+            size *= CGFloat(controllerScale)
        }
    }
 }
@ -219,6 +235,7 @@ struct ButtonView: View {
    @AppStorage("onscreenhandheld") var onscreenjoy: Bool = false
    @Environment(\.colorScheme) var colorScheme
    @Environment(\.presentationMode) var presentationMode
+    @AppStorage("On-ScreenControllerScale") var controllerScale: Double = 1.0
    

    
@ -257,6 +274,9 @@ struct ButtonView: View {
                    width *= 1.2
                    height *= 1.2
                }
+                
+                width *= CGFloat(controllerScale)
+                height *= CGFloat(controllerScale)
            }
    }
    
--- a/src/MeloNX/MeloNX/App/Views/ControllerView/Joystick/JoystickView.swift
+++ b/src/MeloNX/MeloNX/App/Views/ControllerView/Joystick/JoystickView.swift
@ -13,11 +13,14 @@ public struct Joystick: View {
    @State var iscool: Bool? = nil
    
    @ObservedObject public var joystickMonitor = JoystickMonitor()
+    @AppStorage("On-ScreenControllerScale") var controllerScale: Double = 1.0
    var dragDiameter: CGFloat {
        var selfs = CGFloat(160)
+        selfs *= controllerScale
        if UIDevice.current.systemName.contains("iPadOS") {
            return selfs * 1.2
        }
+        
        return selfs
    }
    private let shape: JoystickShape = .circle
--- a/src/MeloNX/MeloNX/App/Views/Emulation/EmulationView/EmulationView.swift
+++ b/src/MeloNX/MeloNX/App/Views/Emulation/EmulationView/EmulationView.swift
@ -11,7 +11,9 @@ import SwiftUI
 struct EmulationView: View {
    @AppStorage("isVirtualController") var isVCA: Bool = true
    @AppStorage("showScreenShotButton") var ssb: Bool = false
+    @State var isPresentedThree: Bool = false
    @State var isAirplaying = Air.shared.connected
+    @Environment(\.scenePhase) var scenePhase
    var body: some View {
        ZStack {
            if isAirplaying {
@ -31,6 +33,7 @@ struct EmulationView: View {
                ControllerView() // Virtual Controller
            }
            
+            
            if ssb {
                Group {
                    VStack {
--- a/src/MeloNX/MeloNX/App/Views/Emulation/MetalView/MetalView.swift
+++ b/src/MeloNX/MeloNX/App/Views/Emulation/MetalView/MetalView.swift
@ -10,11 +10,22 @@ import MetalKit

 struct MetalView: UIViewRepresentable {
    
-    func makeUIView(context: Context) -> UIView {
+    var airplay: Bool = Air.shared.connected // just in case :3
    
+    func makeUIView(context: Context) -> UIView {
        let metalLayer = Ryujinx.shared.metalLayer!
-        metalLayer.frame = Ryujinx.shared.emulationUIView.bounds
-        Ryujinx.shared.emulationUIView.contentScaleFactor = metalLayer.contentsScale // Right size and Fix Touch :3
+        
+        var view = UIView()
+        
+        metalLayer.frame = view.bounds
+        if airplay {
+            metalLayer.contentsScale = view.contentScaleFactor
+        } else {
+            Ryujinx.shared.emulationUIView.contentScaleFactor = metalLayer.contentsScale // Right size and Fix Touch :3
+        }
+        
+        Ryujinx.shared.emulationUIView = view
+        
        if !Ryujinx.shared.emulationUIView.subviews.contains(where: { $0 == metalLayer }) {
            Ryujinx.shared.emulationUIView.layer.addSublayer(metalLayer)
        }
--- a/src/MeloNX/MeloNX/App/Views/GamesList/GameInfoSheet.swift
+++ b/src/MeloNX/MeloNX/App/Views/GamesList/GameInfoSheet.swift
@ -14,53 +14,85 @@ struct GameInfoSheet: View {
    
    var body: some View {
        iOSNav {
-            VStack {
-                if let icon = game.icon {
-                    Image(uiImage: icon)
-                        .resizable()
-                        .aspectRatio(contentMode: .fit)
-                        .frame(width: 250, height: 250)
-                        .cornerRadius(10)
-                        .padding()
-                        .contextMenu {
-                            Button {
-                                UIImageWriteToSavedPhotosAlbum(icon, nil, nil, nil)
-                            } label: {
-                                Label("Save to Photos", systemImage: "square.and.arrow.down")
-                            }
+            List {
+                Section {}
+                header: {
+                    VStack(alignment: .center) {
+                        if let icon = game.icon {
+                            Image(uiImage: icon)
+                                .resizable()
+                                .aspectRatio(contentMode: .fit)
+                                .frame(width: 250, height: 250)
+                                .cornerRadius(10)
+                                .padding()
+                                .contextMenu {
+                                    Button {
+                                        UIImageWriteToSavedPhotosAlbum(icon, nil, nil, nil)
+                                    } label: {
+                                        Label("Save to Photos", systemImage: "square.and.arrow.down")
+                                    }
+                                }
+                        } else {
+                            Image(systemName: "questionmark.circle")
+                                .resizable()
+                                .aspectRatio(contentMode: .fit)
+                                .frame(width: 150, height: 150)
+                                .padding()
                        }
-                } else {
-                    Image(systemName: "questionmark.circle")
-                        .resizable()
-                        .aspectRatio(contentMode: .fit)
-                        .frame(width: 150, height: 150)
-                        .padding()
+                        VStack(alignment: .center) {
+                            Text("**\(game.titleName)** | \(game.titleId.capitalized)")
+                                .multilineTextAlignment(.center)
+                            Text(game.developer)
+                                .font(.caption)
+                                .foregroundStyle(.secondary)
+                        }
+                        .padding(.vertical, 3)
+                    }
+                    .frame(maxWidth: .infinity)
                }

-                VStack(alignment: .leading) {
-                    VStack(alignment: .leading) {
-                        Text("**\(game.titleName)** | \(game.titleId.capitalized)")
-                        Text(game.developer)
-                            .font(.caption)
-                            .foregroundStyle(.secondary)
+                Section {
+                    HStack {
+                        Text("**Version**")
+                        Spacer()
+                        Text(game.version)
+                            .foregroundStyle(Color.secondary)
                    }
-                    .padding(.vertical, 3)
-                    
-                    VStack(alignment: .leading, spacing: 5) {
-                        Text("Information")
-                            .font(.title2)
-                            .bold()
-                        
-                        Text("**Version:** \(game.version)")
-                        Text("**Game Size:** \(fetchFileSize(for: game.fileURL) ?? 0) bytes")
-                        Text("**File Type:** .\(getFileType(game.fileURL))")
-                        Text("**Game URL:** \(trimGameURL(game.fileURL))")
+                    HStack {
+                        Text("**Title ID**")
+                            .contextMenu {
+                                Button {
+                                    UIPasteboard.general.string = game.titleId
+                                } label: {
+                                    Text("Copy Title ID")
+                                }
+                            }
+                        Spacer()
+                        Text(game.titleId)
+                            .foregroundStyle(Color.secondary)
                    }
+                    HStack {
+                        Text("**Game Size**")
+                        Spacer()
+                        Text("\(fetchFileSize(for: game.fileURL) ?? 0) bytes")
+                            .foregroundStyle(Color.secondary)
+                    }
+                    HStack {
+                        Text("**File Type**")
+                        Spacer()
+                        Text(getFileType(game.fileURL))
+                            .foregroundStyle(Color.secondary)
+                    }
+                    VStack(alignment: .leading, spacing: 4) {
+                        Text("**Game URL**")
+                        Text(trimGameURL(game.fileURL))
+                            .foregroundStyle(Color.secondary)
+                    }
+                } header: {
+                    Text("Information")
                }
-
-                Spacer()
+                .headerProminence(.increased)
            }
-            .padding(.horizontal, 5)
            .navigationTitle(game.titleName)
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
@ -95,10 +127,6 @@ struct GameInfoSheet: View {
    }
    
    func getFileType(_ url: URL) -> String {
-        let path = url.path
-        if let range = path.range(of: ".") {
-            return String(path[range.upperBound...])
-        }
-        return "Unknown"
+        url.pathExtension
    }
 }
--- a/src/MeloNX/MeloNX/App/Views/GamesList/GameListView.swift
+++ b/src/MeloNX/MeloNX/App/Views/GamesList/GameListView.swift
@ -16,7 +16,6 @@ extension UTType {
 struct GameLibraryView: View {
    @Binding var startemu: Game?
    // @State var importDLCs = false
-    @State private var games: [Game] = []
    @State private var searchText = ""
    @State private var isSearching = false
    @AppStorage("recentGames") private var recentGamesData: Data = Data()
@ -28,120 +27,117 @@ struct GameLibraryView: View {
    @State var startgame = false
    @State var isSelectingGameFile = false
    @State var isViewingGameInfo: Bool = false
+    @State var isSelectingGameUpdate: Bool = false
+    @State var isSelectingGameDLC: Bool = false
    @State var gameInfo: Game?
-    
+    var games: Binding<[Game]> {
+        Binding(
+            get: { Ryujinx.shared.games },
+            set: { Ryujinx.shared.games = $0 }
+        )
+    }
    
    var filteredGames: [Game] {
        if searchText.isEmpty {
-            return games
+            return Ryujinx.shared.games
        }
-        return games.filter {
+        return Ryujinx.shared.games.filter {
            $0.titleName.localizedCaseInsensitiveContains(searchText) ||
-            $0.developer.localizedCaseInsensitiveContains(searchText)
+                $0.developer.localizedCaseInsensitiveContains(searchText)
        }
    }
    
    var body: some View {
        iOSNav {
-            ScrollView {
-                LazyVStack(alignment: .leading, spacing: 20) {
-                    if !isSearching {
-                        Text("Games")
-                            .font(.system(size: 34, weight: .bold))
-                            .padding(.horizontal)
-                            .padding(.top, 12)
+            List {
+                if Ryujinx.shared.games.isEmpty {
+                    VStack(spacing: 16) {
+                        Image(systemName: "gamecontroller.fill")
+                            .font(.system(size: 64))
+                            .foregroundColor(.secondary.opacity(0.7))
+                            .padding(.top, 60)
+                        Text("No Games Found")
+                            .font(.title2.bold())
+                            .foregroundColor(.primary)
+                        Text("Add ROM, Keys and Firmware to get started")
+                            .font(.subheadline)
+                            .foregroundColor(.secondary)
                    }
-                    
-                    if games.isEmpty {
-                        VStack(spacing: 16) {
-                            Image(systemName: "gamecontroller.fill")
-                                .font(.system(size: 64))
-                                .foregroundColor(.secondary.opacity(0.7))
-                                .padding(.top, 60)
-                            Text("No Games Found")
+                    .frame(maxWidth: .infinity)
+                    .padding(.top, 40)
+                } else {
+                    if !isSearching && !recentGames.isEmpty {
+                        VStack(alignment: .leading, spacing: 12) {
+                            Text("Recent")
                                .font(.title2.bold())
-                                .foregroundColor(.primary)
-                            Text("Add ROM, Keys and Firmware to get started")
-                                .font(.subheadline)
-                                .foregroundColor(.secondary)
-                        }
-                        .frame(maxWidth: .infinity)
-                        .padding(.top, 40)
-                    } else {
-                        if !isSearching && !recentGames.isEmpty {
-                            VStack(alignment: .leading, spacing: 12) {
-                                Text("Recent")
-                                    .font(.title2.bold())
-                                    .padding(.horizontal)
+                                .padding(.horizontal)
                                
-                                ScrollView(.horizontal, showsIndicators: false) {
-                                    LazyHStack(spacing: 16) {
-                                        ForEach(recentGames) { game in
-                                            RecentGameCard(game: game, startemu: $startemu)
-                                                .onTapGesture {
-                                                    addToRecentGames(game)
-                                                    startemu = game
-                                                }
-                                        }
-                                    }
-                                    .padding(.horizontal)
-                                }
-                            }
-                            
-                            VStack(alignment: .leading, spacing: 12) {
-                                Text("All Games")
-                                    .font(.title2.bold())
-                                    .padding(.horizontal)
-                                
-                                LazyVStack(spacing: 2) {
-                                    ForEach(filteredGames) { game in
-                                        GameListRow(game: game, startemu: $startemu, games: $games, isViewingGameInfo: $isViewingGameInfo, gameInfo: $gameInfo)
+                            ScrollView(.horizontal, showsIndicators: false) {
+                                LazyHStack(spacing: 16) {
+                                    ForEach(recentGames) { game in
+                                        RecentGameCard(game: game, startemu: $startemu)
                                            .onTapGesture {
                                                addToRecentGames(game)
+                                                startemu = game
                                            }
                                    }
                                }
+                                .padding(.horizontal)
                            }
-                        } else {
+                        }
+                            
+                        VStack(alignment: .leading, spacing: 12) {
+                            Text("All Games")
+                                .font(.title2.bold())
+                                .padding(.horizontal)
+                                
                            LazyVStack(spacing: 2) {
                                ForEach(filteredGames) { game in
-                                    GameListRow(game: game, startemu: $startemu, games: $games, isViewingGameInfo: $isViewingGameInfo, gameInfo: $gameInfo)
+                                    GameListRow(game: game, startemu: $startemu, games: games, isViewingGameInfo: $isViewingGameInfo, isSelectingGameUpdate: $isSelectingGameUpdate, isSelectingGameDLC: $isSelectingGameDLC, gameInfo: $gameInfo)
                                        .onTapGesture {
                                            addToRecentGames(game)
                                        }
                                }
                            }
                        }
-                    }
-                }
-                .onAppear {
-                    loadGames()
-                    loadRecentGames()
-                    
-                    let firmware = Ryujinx.shared.fetchFirmwareVersion()
-                    firmwareversion = (firmware == "" ? "0" : firmware)
-                }
-                .fileImporter(isPresented: $firmwareInstaller, allowedContentTypes: [.item]) { result in
-                    switch result {
-                    case .success(let url):
-                        do {
-                            let fun = url.startAccessingSecurityScopedResource()
-                            let path = url.path
-                            
-                            Ryujinx.shared.installFirmware(firmwarePath: path)
-                            
-                            firmwareversion = (Ryujinx.shared.fetchFirmwareVersion() == "" ? "0" : Ryujinx.shared.fetchFirmwareVersion())
-                            if fun  {
-                                url.stopAccessingSecurityScopedResource()
-                            }
+                    } else {
+                        ForEach(filteredGames) { game in
+                            GameListRow(game: game, startemu: $startemu, games: games, isViewingGameInfo: $isViewingGameInfo, isSelectingGameUpdate: $isSelectingGameUpdate, isSelectingGameDLC: $isSelectingGameDLC, gameInfo: $gameInfo)
+                                .onTapGesture {
+                                    addToRecentGames(game)
+                                }
                        }
-                    case .failure(let error):
-                        print(error)
                    }
                }
            }
+            .navigationTitle("Games")
+            .navigationBarTitleDisplayMode(.large)
+            .onAppear {
+                loadRecentGames()
+                    
+                let firmware = Ryujinx.shared.fetchFirmwareVersion()
+                firmwareversion = (firmware == "" ? "0" : firmware)
+            }
+            .fileImporter(isPresented: $firmwareInstaller, allowedContentTypes: [.item]) { result in
+                switch result {
+                case .success(let url):
+                    do {
+                        let fun = url.startAccessingSecurityScopedResource()
+                        let path = url.path
+                            
+                        Ryujinx.shared.installFirmware(firmwarePath: path)
+                            
+                        firmwareversion = (Ryujinx.shared.fetchFirmwareVersion() == "" ? "0" : Ryujinx.shared.fetchFirmwareVersion())
+                        if fun {
+                            url.stopAccessingSecurityScopedResource()
+                        }
+                    }
+                case .failure(let error):
+                    print(error)
+                }
+            }
            .toolbar {
-                ToolbarItem(placement: .topBarLeading) {
+                ToolbarItem(placement: .topBarTrailing) {
                    Button {
                        isSelectingGameFile.toggle()
                    } label: {
@ -192,7 +188,11 @@ struct GameLibraryView: View {
                        
                        Button {
                            let documentsUrl = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
-                            let sharedurl = documentsUrl.absoluteString.replacingOccurrences(of: "file://", with: "shareddocuments://")
+                            var sharedurl = documentsUrl.absoluteString.replacingOccurrences(of: "file://", with: "shareddocuments://")
+                            if ProcessInfo.processInfo.isiOSAppOnMac {
+                                sharedurl = documentsUrl.absoluteString
+                            }
+                            print(sharedurl)
                            let furl = URL(string: sharedurl)!
                            if UIApplication.shared.canOpenURL(furl) {
                                UIApplication.shared.open(furl, options: [:])
@ -207,12 +207,11 @@ struct GameLibraryView: View {
                }
            }
        }
-        .background(Color(.systemGroupedBackground))
        .searchable(text: $searchText)
        .onChange(of: searchText) { _ in
            isSearching = !searchText.isEmpty
        }
-        .fileImporter(isPresented: $isImporting, allowedContentTypes: [.zip, .folder]) { result in
+        .fileImporter(isPresented: $isImporting, allowedContentTypes: [.zip, .folder, .nsp, .xci]) { result in
            switch result {
            case .success(let url):
                guard url.startAccessingSecurityScopedResource() else {
@ -262,7 +261,7 @@ struct GameLibraryView: View {
                    let destinationURL = romsDirectory.appendingPathComponent(url.lastPathComponent)
                    try fileManager.copyItem(at: url, to: destinationURL)
                    
-                    loadGames()
+                    Ryujinx.shared.games = Ryujinx.shared.loadGames()
                } catch {
                    print("Error copying game file: \(error)")
                }
@ -270,6 +269,12 @@ struct GameLibraryView: View {
                print("File import failed: \(err.localizedDescription)")
            }
        }
+        .sheet(isPresented: $isSelectingGameUpdate) {
+            UpdateManagerSheet(game: $gameInfo)
+        }
+        .sheet(isPresented: $isSelectingGameDLC) {
+            DLCManagerSheet(game: $gameInfo)
+        }
        .sheet(isPresented: Binding(
            get: { isViewingGameInfo && gameInfo != nil },
            set: { newValue in
@ -285,7 +290,6 @@ struct GameLibraryView: View {
        }
    }
    
-    
    private func addToRecentGames(_ game: Game) {
        recentGames.removeAll { $0.id == game.id }
        
@ -318,62 +322,20 @@ struct GameLibraryView: View {
        }
    }

-// MARK: - loads games from roms
-    func loadGames() {
-        let fileManager = FileManager.default
-        guard let documentsDirectory = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first else { return }
-        
-        let romsDirectory = documentsDirectory.appendingPathComponent("roms")
-        
-        // Check if "roms" folder exists; if not, create it
-        if (!fileManager.fileExists(atPath: romsDirectory.path)) {
-            do {
-                try fileManager.createDirectory(at: romsDirectory, withIntermediateDirectories: true, attributes: nil)
-            } catch {
-                print("Failed to create roms directory: \(error)")
-            }
-        }
-        games = []
-        // Load games only from "roms" folder
-        do {
-            let files = try fileManager.contentsOfDirectory(at: romsDirectory, includingPropertiesForKeys: nil)
-            
-            files.forEach { fileURLCandidate in
-                do {
-                    let handle = try FileHandle(forReadingFrom: fileURLCandidate)
-                    let fileExtension = (fileURLCandidate.pathExtension as NSString).utf8String
-                    let extensionPtr = UnsafeMutablePointer<CChar>(mutating: fileExtension)
-                    
-                    
-                    let gameInfo = get_game_info(handle.fileDescriptor, extensionPtr)
-                    
-                    let game = Game.convertGameInfoToGame(gameInfo: gameInfo, url: fileURLCandidate)
-                    
-                    games.append(game)
-                } catch {
-                    print(error)
-                }
-            }
-            
-        } catch {
-            print("Error loading games from roms folder: \(error)")
-        }
-    }
-    
-// MARK: - Delete Game Function
+    // MARK: - Delete Game Function
    func deleteGame(game: Game) {
        let fileManager = FileManager.default
        do {
            try fileManager.removeItem(at: game.fileURL)
-            games.removeAll { $0.id == game.id }
-            loadGames()
+            Ryujinx.shared.games.removeAll { $0.id == game.id }
+            Ryujinx.shared.games = Ryujinx.shared.loadGames()
        } catch {
            print("Error deleting game: \(error)")
        }
    }
 }

-// MARK: -Game Model
+// MARK: - Game Model
 extension Game: Codable {
    enum CodingKeys: String, CodingKey {
        case titleName, titleId, developer, version, fileURL
@ -402,7 +364,7 @@ extension Game: Codable {
    }
 }

-// MARK: -Recent Game Card
+// MARK: - Recent Game Card
 struct RecentGameCard: View {
    let game: Game
    @Binding var startemu: Game?
@ -423,7 +385,7 @@ struct RecentGameCard: View {
                    ZStack {
                        RoundedRectangle(cornerRadius: 12)
                            .fill(colorScheme == .dark ?
-                                  Color(.systemGray5) : Color(.systemGray6))
+                                Color(.systemGray5) : Color(.systemGray6))
                            .frame(width: 140, height: 140)
                        
                        Image(systemName: "gamecontroller.fill")
@ -449,12 +411,14 @@ struct RecentGameCard: View {
    }
 }

-// MARK: -Game List Item
+// MARK: - Game List Item
 struct GameListRow: View {
    let game: Game
    @Binding var startemu: Game?
    @Binding var games: [Game] // Add this binding
    @Binding var isViewingGameInfo: Bool
+    @Binding var isSelectingGameUpdate: Bool
+    @Binding var isSelectingGameDLC: Bool
    @Binding var gameInfo: Game?
    @State var gametoDelete: Game?
    @State var showGameDeleteConfirmation: Bool = false
@ -476,7 +440,7 @@ struct GameListRow: View {
                    ZStack {
                        RoundedRectangle(cornerRadius: 8)
                            .fill(colorScheme == .dark ?
-                                  Color(.systemGray5) : Color(.systemGray6))
+                                Color(.systemGray5) : Color(.systemGray6))
                            .frame(width: 45, height: 45)
                        
                        Image(systemName: "gamecontroller.fill")
@ -503,9 +467,6 @@ struct GameListRow: View {
                    .foregroundColor(.accentColor)
                    .opacity(0.8)
            }
-            .padding(.horizontal)
-            .padding(.vertical, 8)
-            .background(Color(.systemBackground))
            .contextMenu {
                Section {
                    Button {
@ -522,6 +483,22 @@ struct GameListRow: View {
                    }
                }

+                Section {
+                    Button {
+                        gameInfo = game
+                        isSelectingGameUpdate.toggle()
+                    } label: {
+                        Label("Game Update Manager", systemImage: "chevron.up.circle")
+                    }
+
+                    Button {
+                        gameInfo = game
+                        isSelectingGameDLC.toggle()
+                    } label: {
+                        Label("Game DLC Manager", systemImage: "plus.viewfinder")
+                    }
+                }
+                
                Section {
                    Button(role: .destructive) {
                        gametoDelete = game
@ -555,4 +532,3 @@ struct GameListRow: View {
        }
    }
 }
-
--- a/src/MeloNX/MeloNX/App/Views/SettingsView/SettingsView.swift
+++ b/src/MeloNX/MeloNX/App/Views/SettingsView/SettingsView.swift
@ -18,6 +18,8 @@ struct SettingsView: View {
    @Binding var onscreencontroller: Controller
    @AppStorage("useTrollStore") var useTrollStore: Bool = false
    
+    @AppStorage("jitStreamerEB") var jitStreamerEB: Bool = false
+    
    @AppStorage("ignoreJIT") var ignoreJIT: Bool = false
    
    var memoryManagerModes = [
@ -32,11 +34,17 @@ struct SettingsView: View {
    @AppStorage("showScreenShotButton") var ssb: Bool = false
    
    @AppStorage("MVK_CONFIG_PREFILL_METAL_COMMAND_BUFFERS") var mVKPreFillBuffer: Bool = false
+    @AppStorage("MVK_CONFIG_SYNCHRONOUS_QUEUE_SUBMITS") var syncqsubmits: Bool = false
    
    @AppStorage("performacehud") var performacehud: Bool = false
    
+    @AppStorage("oldWindowCode") var windowCode: Bool = false
+    
+    @AppStorage("On-ScreenControllerScale") var controllerScale: Double = 1.0
+    
    @State private var showResolutionInfo = false
    @State private var showAnisotropicInfo = false
+    @State private var showControllerInfo = false
    @State private var searchText = ""
    
    var filteredMemoryModes: [(String, String)] {
@ -66,6 +74,12 @@ struct SettingsView: View {
                    }
                    .tint(.blue)
                    
+                    Toggle(isOn: $config.disablevsync) {
+                        labelWithIcon("Disable VSync", iconName: "arrow.triangle.2.circlepath")
+                    }
+                    .tint(.blue)
+                    
+                    
                    Toggle(isOn: $config.enableTextureRecompression) {
                        labelWithIcon("Texture Recompression", iconName: "rectangle.compress.vertical")
                    }
@ -81,7 +95,6 @@ struct SettingsView: View {
                    }.tint(.blue)
                        
                    
-                    
                    VStack(alignment: .leading, spacing: 10) {
                        HStack {
                            labelWithIcon("Resolution Scale", iconName: "magnifyingglass")
@ -261,17 +274,56 @@ struct SettingsView: View {
                
                // Input Settings
                Section {
+                    Toggle(isOn: $config.macroHLE) {
+                        labelWithIcon("Player 1 to Handheld Input", iconName: "formfitting.gamecontroller")
+                    }.tint(.blue)
                        
-                    Toggle(isOn: $config.listinputids) {
-                        labelWithIcon("List Input IDs", iconName: "list.bullet")
-                    }
-                    .tint(.blue)
                    
                    Toggle(isOn: $ryuDemo) {
                        labelWithIcon("On-Screen Controller (Demo)", iconName: "hand.draw")
                    }
                    .tint(.blue)
                    .disabled(true)
+                    
+                    VStack(alignment: .leading, spacing: 10) {
+                        HStack {
+                            labelWithIcon("On-Screen Controller Scale", iconName: "magnifyingglass")
+                                .font(.headline)
+                            Spacer()
+                            Button {
+                                showControllerInfo.toggle()
+                            } label: {
+                                Image(systemName: "info.circle")
+                                    .symbolRenderingMode(.hierarchical)
+                                    .foregroundStyle(.secondary)
+                            }
+                            .buttonStyle(.plain)
+                            .help("Learn more about On-Screen Controller Scale")
+                            .alert(isPresented: $showControllerInfo) {
+                                Alert(
+                                    title: Text("On-Screen Controller Scale"),
+                                    message: Text("Adjust the On-Screen Controller size."),
+                                    dismissButton: .default(Text("OK"))
+                                )
+                            }
+                        }
+                        
+                        Slider(value: $controllerScale, in: 0.1...3.0, step: 0.05) {
+                            Text("Resolution Scale")
+                        } minimumValueLabel: {
+                            Text("0.1x")
+                                .font(.footnote)
+                                .foregroundColor(.secondary)
+                        } maximumValueLabel: {
+                            Text("3.0x")
+                                .font(.footnote)
+                                .foregroundColor(.secondary)
+                        }
+                        Text("\(controllerScale, specifier: "%.2f")x")
+                            .font(.subheadline)
+                            .foregroundColor(.secondary)
+                    }
+                    .padding(.vertical, 8)
                } header: {
                    Text("Input Settings")
                        .font(.title3.weight(.semibold))
@ -281,6 +333,35 @@ struct SettingsView: View {
                    Text("Configure input devices and on-screen controls for easier navigation and play.")
                }
                
+                // Language and Region Settings
+                Section {
+                    Picker(selection: $config.language) {
+                        ForEach(SystemLanguage.allCases, id: \.self) { ratio in
+                            Text(ratio.displayName).tag(ratio)
+                        }
+                    } label: {
+                        labelWithIcon("Language", iconName: "character.bubble")
+                    }
+                    
+                    Picker(selection: $config.regioncode) {
+                        ForEach(SystemRegionCode.allCases, id: \.self) { ratio in
+                            Text(ratio.displayName).tag(ratio)
+                        }
+                    } label: {
+                        labelWithIcon("Region", iconName: "globe")
+                    }
+                    
+                    
+                    // globe
+                } header: {
+                    Text("Language and Region Settings")
+                        .font(.title3.weight(.semibold))
+                        .textCase(nil)
+                        .headerProminence(.increased)
+                } footer: {
+                    Text("Configure the System Language and the Region.")
+                }
+                
                // CPU Mode
                Section {
                    if filteredMemoryModes.isEmpty {
@ -296,29 +377,32 @@ struct SettingsView: View {
                        }
                    }
                    
+                    Toggle(isOn: $config.disablePTC) {
+                        labelWithIcon("Disable PTC", iconName: "cpu")
+                    }.tint(.blue)
+                    
                    if let cpuInfo = getCPUInfo(), cpuInfo.hasPrefix("Apple M") {
-                        if #available (iOS 16.4, *), getEntitlementValue("com.apple.private.hypervisor") {
+                        if #available (iOS 16.4, *) {
                            Toggle(isOn: .constant(false)) {
-                                labelWithIcon("Hypervisor", iconName: "bolt.fill")
+                                labelWithIcon("Hypervisor", iconName: "bolt")
                            }
                            .tint(.blue)
                            .disabled(true)
                            .onAppear() {
                                print("CPU Info: \(cpuInfo)")
                            }
-                        } else {
+                        } else if getEntitlementValue("com.apple.private.hypervisor") {
                            Toggle(isOn: $config.hypervisor) {
-                                labelWithIcon("Hypervisor", iconName: "bolt.fill")
+                                labelWithIcon("Hypervisor", iconName: "bolt")
                            }
                            .tint(.blue)
                            .onAppear() {
                                print("CPU Info: \(cpuInfo)")
-                                
                            }
                        }
                    }
                } header: {
-                    Text("CPU Mode")
+                    Text("CPU")
                        .font(.title3.weight(.semibold))
                        .textCase(nil)
                        .headerProminence(.increased)
@ -354,21 +438,68 @@ struct SettingsView: View {
                    }
                    .tint(.blue)
                    
-                    Toggle(isOn: $useTrollStore) {
-                        labelWithIcon("TrollStore", iconName: "troll.svg")
-                    }
-                    .tint(.blue)
+                    if #available(iOS 17.0.1, *) {
+                        Toggle(isOn: $jitStreamerEB) {
+                            labelWithIcon("JitStreamer EB", iconName: "bolt.heart")
+                        }
+                        .tint(.blue)
+                        .contextMenu {
+                            Button {
+                                if let mainWindow = UIApplication.shared.windows.last {
+                                    let alertController = UIAlertController(title: "About JitStreamer EB", message: "JitStreamer EB is an Amazing Application to Enable JIT on the go, made by one of the best iOS developers of all time jkcoxson <3", preferredStyle: .alert)
                                    
-                    Toggle(isOn: $config.debuglogs) {
-                        labelWithIcon("Debug Logs", iconName: "exclamationmark.bubble")
-                    }
-                    .tint(.blue)
+                                    let learnMoreButton = UIAlertAction(title: "Learn More", style: .default) {_ in
+                                        UIApplication.shared.open(URL(string: "https://jkcoxson.com/jitstreamer")!)
+                                    }
+                                    alertController.addAction(learnMoreButton)
                                    
-                    Toggle(isOn: $config.tracelogs) {
-                        labelWithIcon("Trace Logs", iconName: "waveform.path")
-                    }
-                    .tint(.blue)
+                                    let doneButton = UIAlertAction(title: "Done", style: .cancel, handler: nil)
+                                    alertController.addAction(doneButton)
                                    
+                                    mainWindow.rootViewController?.present(alertController, animated: true)
+                                }
+                            } label: {
+                                Text("About")
+                            }
+                        }
+                    } else {
+                        Toggle(isOn: $useTrollStore) {
+                            labelWithIcon("TrollStore JIT", iconName: "troll.svg")
+                        }
+                        .tint(.blue)
+                    }
+                    
+                    Toggle(isOn: $syncqsubmits) {
+                        labelWithIcon("MVK: Synchronous Queue Submits", iconName: "line.diagonal")
+                    }.tint(.blue)
+                        .contextMenu() {
+                            Button {
+                                if let mainWindow = UIApplication.shared.windows.last {
+                                    let alertController = UIAlertController(title: "About MVK: Synchronous Queue Submits", message: "Enable this option if Mario Kart 8 is crashing at Grand Prix mode.", preferredStyle: .alert)
+                                    
+                                    let doneButton = UIAlertAction(title: "OK", style: .cancel, handler: nil)
+                                    alertController.addAction(doneButton)
+                                    
+                                    mainWindow.rootViewController?.present(alertController, animated: true)
+                                }
+                            } label: {
+                                Text("About")
+                            }
+                        }
+                    
+                    DisclosureGroup {
+                        Toggle(isOn: $config.debuglogs) {
+                            labelWithIcon("Debug Logs", iconName: "exclamationmark.bubble")
+                        }
+                        .tint(.blue)
+                        
+                        Toggle(isOn: $config.tracelogs) {
+                            labelWithIcon("Trace Logs", iconName: "waveform.path")
+                        }
+                        .tint(.blue)
+                    } label: {
+                        Text("Logs")
+                    }
                    
                } header: {
                    Text("Miscellaneous Options")
@ -376,17 +507,46 @@ struct SettingsView: View {
                        .textCase(nil)
                        .headerProminence(.increased)
                } footer: {
-                    Text("Enable trace and debug logs for troubleshooting, enable Screenshotting without distractions and Enable automatic TrollStore JIT.")
+                    Text("Enable trace and debug logs for advanced troubleshooting (Note: This degrades performance),\nEnable Screenshot Button for better screenshots\nand Enable TrollStore for automatic TrollStore JIT.")
+                }
+                
+                // Info
+                Section {
+                    let totalMemory = ProcessInfo.processInfo.physicalMemory
+                    
+                    labelWithIcon("JIT Acquisition: \(isJITEnabled() ? "Acquired" : "Not Acquired" )", iconName: "bolt.fill")
+                    
+                    labelWithIcon("Increased Memory Limit Entitlement: \(checkAppEntitlement("com.apple.developer.kernel.increased-memory-limit") ? "Enabled" : "Disabled")", iconName: "memorychip")
+                    
+                    labelWithIcon("Device Memory: \(String(format: "%.0f GB", Double(totalMemory) / 1_000_000_000))", iconName: "memorychip.fill")
+                } header: {
+                    Text("Information")
+                        .font(.title3.weight(.semibold))
+                        .textCase(nil)
+                        .headerProminence(.increased)
+                } footer: {
+                    Text("Shows info about Memory, Entitlement and JIT.")
                }
                
                // Advanced
                Section {
+                    if #unavailable(iOS 17) {
+                        Toggle(isOn: $windowCode) {
+                            labelWithIcon("SDL Window", iconName: "macwindow.on.rectangle")
+                        }
+                        .tint(.blue)
+                    }
+                    
                    DisclosureGroup {
                        
                        Toggle(isOn: $mVKPreFillBuffer) {
                            labelWithIcon("MVK: Pre-Fill Metal Command Buffers", iconName: "gearshape")
                        }.tint(.blue)
                        
+                        Toggle(isOn: $config.dfsIntegrityChecks) {
+                            labelWithIcon("Disable FS Integrity Checks", iconName: "checkmark.shield")
+                        }.tint(.blue)
+                        
                        HStack {
                            labelWithIcon("Page Size", iconName: "textformat.size")
                            Spacer()
@ -427,7 +587,11 @@ struct SettingsView: View {
                        .textCase(nil)
                        .headerProminence(.increased)
                } footer: {
-                    Text("For advanced users. See page size or add custom arguments for experimental features. (Please don't touch this if you don't know what you're doing)")
+                    if #available(iOS 17, *) {
+                        Text("For advanced users. See page size or add custom arguments for experimental features. (Please don't touch this if you don't know what you're doing).")
+                    } else {
+                        Text("For advanced users. See page size or add custom arguments for experimental features. (Please don't touch this if you don't know what you're doing). If the emulation is not showing (you may hear audio in some games), try enabling \"SDL Window\"")
+                    }
                }
                
            }
--- a/src/MeloNX/MeloNX/App/Views/Updates/GameDLCManagerSheet.swift
+++ b/src/MeloNX/MeloNX/App/Views/Updates/GameDLCManagerSheet.swift
@ -0,0 +1,159 @@
+//
+//  GameDLCManagerSheet.swift
+//  MeloNX
+//
+//  Created by XITRIX on 16/02/2025.
+//
+
+import SwiftUI
+import UniformTypeIdentifiers
+
+struct DownloadableContentNca: Codable, Hashable {
+    var fullPath: String
+    var titleId: UInt
+    var enabled: Bool
+
+    enum CodingKeys: String, CodingKey {
+        case fullPath = "path"
+        case titleId = "title_id"
+        case enabled = "is_enabled"
+    }
+}
+
+struct DownloadableContentContainer: Codable, Hashable {
+    var containerPath: String
+    var downloadableContentNcaList: [DownloadableContentNca]
+
+    enum CodingKeys: String, CodingKey {
+        case containerPath = "path"
+        case downloadableContentNcaList = "dlc_nca_list"
+    }
+}
+
+struct DLCManagerSheet: View {
+    @Binding var game: Game!
+    @State private var isSelectingGameDLC = false
+    @State private var dlcs: [DownloadableContentContainer] = []
+
+    var body: some View {
+        NavigationView {
+            let withIndex = dlcs.enumerated().map { $0 }
+            List(withIndex, id: \.element.containerPath) { index, dlc in
+                Button(action: {
+                    let toggle = dlcs[index].downloadableContentNcaList.first?.enabled ?? true
+                    dlcs[index].downloadableContentNcaList.mutableForEach { $0.enabled = !toggle }
+                    Self.saveDlcs(game, dlc: dlcs)
+                }) {
+                    HStack {
+                        Text(dlc.containerPath)
+                            .foregroundStyle(Color(uiColor: .label))
+                        Spacer()
+                        if dlc.downloadableContentNcaList.first?.enabled == true {
+                            Image(systemName: "checkmark.circle.fill")
+                                .foregroundStyle(Color.accentColor)
+                                .font(.system(size: 24))
+                        } else {
+                            Image(systemName: "circle")
+                                .foregroundStyle(Color(uiColor: .secondaryLabel))
+                                .font(.system(size: 24))
+                        }
+                    }
+                }
+                .contextMenu {
+                    Button {
+                        let path = URL.documentsDirectory.appendingPathComponent(dlc.containerPath)
+                        try? FileManager.default.removeItem(atPath: path.path)
+                        dlcs.remove(at: index)
+                        Self.saveDlcs(game, dlc: dlcs)
+                    } label: {
+                        Text("Remove DLC")
+                    }
+                }
+            }
+            .navigationTitle("\(game.titleName) DLCs")
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                Button("Add", systemImage: "plus") {
+                    isSelectingGameDLC = true
+                }
+            }
+        }
+        .onAppear {
+            dlcs = Self.loadDlc(game)
+        }
+        .fileImporter(isPresented: $isSelectingGameDLC, allowedContentTypes: [.item], allowsMultipleSelection: true) { result in
+            switch result {
+            case .success(let urls):
+                for url in urls {
+                    guard url.startAccessingSecurityScopedResource() else {
+                        print("Failed to access security-scoped resource")
+                        return
+                    }
+                    defer { url.stopAccessingSecurityScopedResource() }
+
+                    do {
+                        let fileManager = FileManager.default
+                        let documentsDirectory = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first!
+                        let dlcDirectory = documentsDirectory.appendingPathComponent("dlc")
+                        let romDlcDirectory = dlcDirectory.appendingPathComponent(game.titleId)
+
+                        if !fileManager.fileExists(atPath: dlcDirectory.path) {
+                            try fileManager.createDirectory(at: dlcDirectory, withIntermediateDirectories: true, attributes: nil)
+                        }
+
+                        if !fileManager.fileExists(atPath: romDlcDirectory.path) {
+                            try fileManager.createDirectory(at: romDlcDirectory, withIntermediateDirectories: true, attributes: nil)
+                        }
+
+                        let dlcContent = Ryujinx.shared.getDlcNcaList(titleId: game.titleId, path: url.path)
+                        guard !dlcContent.isEmpty else { return }
+
+                        let destinationURL = romDlcDirectory.appendingPathComponent(url.lastPathComponent)
+                        try? fileManager.copyItem(at: url, to: destinationURL)
+
+                        let container = DownloadableContentContainer(
+                            containerPath: Self.relativeDlcDirectoryPath(for: game, dlcPath: destinationURL),
+                            downloadableContentNcaList: dlcContent
+                        )
+                        dlcs.append(container)
+
+                        Self.saveDlcs(game, dlc: dlcs)
+                    } catch {
+                        print("Error copying game file: \(error)")
+                    }
+                }
+            case .failure(let err):
+                print("File import failed: \(err.localizedDescription)")
+            }
+        }
+    }
+}
+
+private extension DLCManagerSheet {
+    static func loadDlc(_ game: Game) -> [DownloadableContentContainer] {
+        let jsonURL = dlcJsonPath(for: game)
+        guard let data = try? Data(contentsOf: jsonURL),
+              var result = try? JSONDecoder().decode([DownloadableContentContainer].self, from: data)
+        else { return [] }
+
+        result = result.filter { container in
+            let path = URL.documentsDirectory.appendingPathComponent(container.containerPath)
+            return FileManager.default.fileExists(atPath: path.path)
+        }
+
+        return result
+    }
+
+    static func saveDlcs(_ game: Game, dlc: [DownloadableContentContainer]) {
+        guard let data = try? JSONEncoder().encode(dlc) else { return }
+        try? data.write(to: dlcJsonPath(for: game))
+    }
+
+    static func relativeDlcDirectoryPath(for game: Game, dlcPath: URL) -> String {
+        "dlc/\(game.titleId)/\(dlcPath.lastPathComponent)"
+    }
+
+    static func dlcJsonPath(for game: Game) -> URL {
+        URL.documentsDirectory.appendingPathComponent("games").appendingPathComponent(game.titleId).appendingPathComponent("dlc.json")
+    }
+}
--- a/src/MeloNX/MeloNX/App/Views/Updates/GameUpdateManagerSheet.swift
+++ b/src/MeloNX/MeloNX/App/Views/Updates/GameUpdateManagerSheet.swift
@ -0,0 +1,201 @@
+//
+//  GameUpdateManagerSheet.swift
+//  MeloNX
+//
+//  Created by Stossy11 on 16/02/2025.
+//
+
+import SwiftUI
+import UniformTypeIdentifiers
+
+struct UpdateManagerSheet: View {
+    @State private var items: [String] = []
+    @State private var paths: [URL] = []
+    @State private var selectedItem: String? = nil
+    @Binding var game: Game?
+    @State private var isSelectingGameUpdate = false
+    @State private var jsonURL: URL? = nil
+
+    var body: some View {
+        NavigationView {
+            List(paths, id: \..self, selection: $selectedItem) { item in
+                Button(action: {
+                    selectItem(item.lastPathComponent)
+                }) {
+                    HStack {
+                        Text(item.lastPathComponent)
+                            .foregroundStyle(Color(uiColor: .label))
+                        Spacer()
+                        if selectedItem == "updates/\(game!.titleId)/\(item.lastPathComponent)" {
+                            Image(systemName: "checkmark.circle.fill")
+                                .foregroundStyle(Color.accentColor)
+                                .font(.system(size: 24))
+                        } else {
+                            Image(systemName: "circle")
+                                .foregroundStyle(Color(uiColor: .secondaryLabel))
+                                .font(.system(size: 24))
+                        }
+                    }
+                }
+                .contextMenu {
+                    Button {
+                        removeUpdate(item)
+                    } label: {
+                        Text("Remove Update")
+                    }
+                }
+            }
+            .onAppear {
+                print(URL.documentsDirectory.appendingPathComponent("games").appendingPathComponent(game!.titleId).appendingPathComponent("updates.json"))
+                
+                loadJSON(URL.documentsDirectory.appendingPathComponent("games").appendingPathComponent(game!.titleId).appendingPathComponent("updates.json"))
+            }
+            .navigationTitle("\(game!.titleName) Updates")
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                Button("Add", systemImage: "plus") {
+                    isSelectingGameUpdate = true
+                }
+            }
+        }
+        .fileImporter(isPresented: $isSelectingGameUpdate, allowedContentTypes: [.item]) { result in
+            switch result {
+            case .success(let url):
+                guard url.startAccessingSecurityScopedResource() else {
+                    print("Failed to access security-scoped resource")
+                    return
+                }
+                defer { url.stopAccessingSecurityScopedResource() }
+                
+                let gameInfo = game!
+                
+                do {
+                    let fileManager = FileManager.default
+                    let documentsDirectory = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first!
+                    let updatedDirectory = documentsDirectory.appendingPathComponent("updates")
+                    let romUpdatedDirectory = updatedDirectory.appendingPathComponent(gameInfo.titleId)
+                    
+                    if !fileManager.fileExists(atPath: updatedDirectory.path) {
+                        try fileManager.createDirectory(at: updatedDirectory, withIntermediateDirectories: true, attributes: nil)
+                    }
+
+                    if !fileManager.fileExists(atPath: romUpdatedDirectory.path) {
+                        try fileManager.createDirectory(at: romUpdatedDirectory, withIntermediateDirectories: true, attributes: nil)
+                    }
+
+                    let destinationURL = romUpdatedDirectory.appendingPathComponent(url.lastPathComponent)
+                    try? fileManager.copyItem(at: url, to: destinationURL)
+
+                    items.append("updates/" + gameInfo.titleId + "/" + url.lastPathComponent)
+                    selectItem(url.lastPathComponent)
+                    Ryujinx.shared.games = Ryujinx.shared.loadGames()
+                    loadJSON(jsonURL!)
+                } catch {
+                    print("Error copying game file: \(error)")
+                }
+            case .failure(let err):
+                print("File import failed: \(err.localizedDescription)")
+            }
+        }
+    }
+    
+    func removeUpdate(_ game: URL) {
+        let gameString = "updates/\(self.game!.titleId)/\(game.lastPathComponent)"
+        paths.removeAll { $0 == game }
+        items.removeAll { $0 == gameString }
+        
+        if selectedItem == gameString {
+            selectedItem = nil
+        }
+        
+        do {
+            try FileManager.default.removeItem(at: game)
+        } catch {
+            print(error)
+        }
+        
+        saveJSON(selectedItem: selectedItem ?? "")
+        Ryujinx.shared.games = Ryujinx.shared.loadGames()
+    }
+    
+    func saveJSON(selectedItem: String) {
+        guard let jsonURL = jsonURL else { return }
+        do {
+            let jsonDict = ["paths": items, "selected": selectedItem] as [String: Any]
+            let newData = try JSONSerialization.data(withJSONObject: jsonDict, options: .prettyPrinted)
+            try newData.write(to: jsonURL)
+        } catch {
+            print("Failed to update JSON: \(error)")
+        }
+    }
+    
+    func loadJSON(_ json: URL) {
+        self.jsonURL = json
+        
+        guard let jsonURL else { return }
+        
+        do {
+            let data = try Data(contentsOf: jsonURL)
+            if let jsonDict = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any],
+               let list = jsonDict["paths"] as? [String]
+            {
+
+                let filteredList = list.filter { relativePath in
+                    let path = URL.documentsDirectory.appendingPathComponent(relativePath)
+                    return FileManager.default.fileExists(atPath: path.path)
+                }
+
+                let urls: [URL] = filteredList.map { relativePath in
+                    URL.documentsDirectory.appendingPathComponent(relativePath)
+                }
+
+                items = filteredList
+                paths = urls
+                selectedItem = jsonDict["selected"] as? String
+            }
+        } catch {
+            print("Failed to read JSON: \(error)")
+            createDefaultJSON()
+        }
+    }
+    
+    func createDefaultJSON() {
+        guard let jsonURL = jsonURL else { return }
+        let defaultData: [String: Any] = ["selected": "", "paths": []]
+        do {
+            let newData = try JSONSerialization.data(withJSONObject: defaultData, options: .prettyPrinted)
+            try newData.write(to: jsonURL)
+            items = []
+            selectedItem = ""
+        } catch {
+            print("Failed to create default JSON: \(error)")
+        }
+    }
+    
+    func selectItem(_ item: String) {
+        let newSelection = "updates/\(game!.titleId)/\(item)"
+
+        guard let jsonURL else { return }
+        
+        do {
+            let data = try Data(contentsOf: jsonURL)
+            var jsonDict = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] ?? [:]
+            
+            if let currentSelected = jsonDict["selected"] as? String, currentSelected == newSelection {
+                jsonDict["selected"] = ""
+                selectedItem = ""
+            } else {
+                jsonDict["selected"] = "\(newSelection)"
+                selectedItem = newSelection
+            }
+            
+            jsonDict["paths"] = items
+
+            let newData = try JSONSerialization.data(withJSONObject: jsonDict, options: .prettyPrinted)
+            try newData.write(to: jsonURL)
+            Ryujinx.shared.games = Ryujinx.shared.loadGames()
+        } catch {
+            print("Failed to update JSON: \(error)")
+        }
+    }
+}
--- a/Libraries/RyujinxKeyboard.framework/Headers/RyujinxKeyboard.h
+++ b/Libraries/RyujinxKeyboard.framework/Headers/RyujinxKeyboard.h
@ -0,0 +1,18 @@
+//
+//  RyujinxKeyboard.h
+//  RyujinxKeyboard
+//
+//  Created by Stossy11 on 11/02/2025.
+//
+
+#import <Foundation/Foundation.h>
+
+//! Project version number for RyujinxKeyboard.
+FOUNDATION_EXPORT double RyujinxKeyboardVersionNumber;
+
+//! Project version string for RyujinxKeyboard.
+FOUNDATION_EXPORT const unsigned char RyujinxKeyboardVersionString[];
+
+// In this header, you should import all the public headers of your framework using statements like #import <RyujinxKeyboard/PublicHeader.h>
+
+
--- a/Libraries/SoftwareKeyboard.framework/Info.plist
+++ b/Libraries/SoftwareKeyboard.framework/Info.plist
--- a/Libraries/RyujinxKeyboard.framework/Modules/module.modulemap
+++ b/Libraries/RyujinxKeyboard.framework/Modules/module.modulemap
@ -0,0 +1,6 @@
+framework module RyujinxKeyboard {
+  umbrella header "RyujinxKeyboard.h"
+  export *
+
+  module * { export * }
+}
--- a/Libraries/RyujinxKeyboard.framework/RyujinxKeyboard
+++ b/Libraries/RyujinxKeyboard.framework/RyujinxKeyboard
--- a/Libraries/RyujinxKeyboard.framework/_CodeSignature/CodeResources
+++ b/Libraries/RyujinxKeyboard.framework/_CodeSignature/CodeResources
@ -0,0 +1,124 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>files</key>
+	<dict>
+		<key>Headers/RyujinxKeyboard.h</key>
+		<data>
+		5P7GN4g050n199pV6/+SpfMBgJc=
+		</data>
+		<key>Info.plist</key>
+		<data>
+		hYdI/ktAKwjBSfaJpt6Yc8UKLCY=
+		</data>
+		<key>Modules/module.modulemap</key>
+		<data>
+		0kFAMoTn+4Q1J/dM6uMLe3EhbL0=
+		</data>
+	</dict>
+	<key>files2</key>
+	<dict>
+		<key>Headers/RyujinxKeyboard.h</key>
+		<dict>
+			<key>hash2</key>
+			<data>
+			/yGmHq9NdBF/ruesISIj7vml0ySgoJkrFOcrw0vaIxQ=
+			</data>
+		</dict>
+		<key>Modules/module.modulemap</key>
+		<dict>
+			<key>hash2</key>
+			<data>
+			K+ZyxKhTI4bMVZuHBIspvd2PFqvCOlVUFYmwF96O5NQ=
+			</data>
+		</dict>
+	</dict>
+	<key>rules</key>
+	<dict>
+		<key>^.*</key>
+		<true/>
+		<key>^.*\.lproj/</key>
+		<dict>
+			<key>optional</key>
+			<true/>
+			<key>weight</key>
+			<real>1000</real>
+		</dict>
+		<key>^.*\.lproj/locversion.plist$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>1100</real>
+		</dict>
+		<key>^Base\.lproj/</key>
+		<dict>
+			<key>weight</key>
+			<real>1010</real>
+		</dict>
+		<key>^version.plist$</key>
+		<true/>
+	</dict>
+	<key>rules2</key>
+	<dict>
+		<key>.*\.dSYM($|/)</key>
+		<dict>
+			<key>weight</key>
+			<real>11</real>
+		</dict>
+		<key>^(.*/)?\.DS_Store$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>2000</real>
+		</dict>
+		<key>^.*</key>
+		<true/>
+		<key>^.*\.lproj/</key>
+		<dict>
+			<key>optional</key>
+			<true/>
+			<key>weight</key>
+			<real>1000</real>
+		</dict>
+		<key>^.*\.lproj/locversion.plist$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>1100</real>
+		</dict>
+		<key>^Base\.lproj/</key>
+		<dict>
+			<key>weight</key>
+			<real>1010</real>
+		</dict>
+		<key>^Info\.plist$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+		<key>^PkgInfo$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+		<key>^embedded\.provisionprofile$</key>
+		<dict>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+		<key>^version\.plist$</key>
+		<dict>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+	</dict>
+</dict>
+</plist>
--- a/Libraries/SoftwareKeyboard.framework/Headers/SoftwareKeyboard.h
+++ b/Libraries/SoftwareKeyboard.framework/Headers/SoftwareKeyboard.h
@ -1,18 +0,0 @@
-//
-//  SoftwareKeyboard.h
-//  SoftwareKeyboard
-//
-//  Created by Stossy11 on 19/12/2024.
-//
-
-#import <Foundation/Foundation.h>
-
-//! Project version number for SoftwareKeyboard.
-FOUNDATION_EXPORT double SoftwareKeyboardVersionNumber;
-
-//! Project version string for SoftwareKeyboard.
-FOUNDATION_EXPORT const unsigned char SoftwareKeyboardVersionString[];
-
-// In this header, you should import all the public headers of your framework using statements like #import <SoftwareKeyboard/PublicHeader.h>
-
-
--- a/Libraries/SoftwareKeyboard.framework/Modules/SoftwareKeyboard.swiftmodule/Project/arm64-apple-ios.swiftsourceinfo
+++ b/Libraries/SoftwareKeyboard.framework/Modules/SoftwareKeyboard.swiftmodule/Project/arm64-apple-ios.swiftsourceinfo
--- a/Libraries/SoftwareKeyboard.framework/Modules/SoftwareKeyboard.swiftmodule/arm64-apple-ios.abi.json
+++ b/Libraries/SoftwareKeyboard.framework/Modules/SoftwareKeyboard.swiftmodule/arm64-apple-ios.abi.json
--- a/Libraries/SoftwareKeyboard.framework/Modules/SoftwareKeyboard.swiftmodule/arm64-apple-ios.private.swiftinterface
+++ b/Libraries/SoftwareKeyboard.framework/Modules/SoftwareKeyboard.swiftmodule/arm64-apple-ios.private.swiftinterface
@ -1,38 +0,0 @@
-// swift-interface-format-version: 1.0
-// swift-compiler-version: Apple Swift version 6.0.3 effective-5.10 (swiftlang-6.0.3.1.4 clang-1600.0.30)
-// swift-module-flags: -target arm64-apple-ios14.0 -enable-objc-interop -enable-library-evolution -swift-version 5 -enforce-exclusivity=checked -Onone -enable-experimental-feature OpaqueTypeErasure -enable-bare-slash-regex -module-name SoftwareKeyboard
-@_exported import SoftwareKeyboard
-import Swift
-import UIKit
-import _Concurrency
-import _StringProcessing
-import _SwiftConcurrencyShims
-@objc public enum KeyboardMode : Swift.UInt32 {
-  case `default` = 0
-  case numeric = 1
-  case ascii = 2
-  case fullLatin = 3
-  case alphabet = 4
-  case simplifiedChinese = 5
-  case traditionalChinese = 6
-  case korean = 7
-  case languageSet2 = 8
-  case languageSet2Latin = 9
-  public init?(rawValue: Swift.UInt32)
-  public typealias RawValue = Swift.UInt32
-  public var rawValue: Swift.UInt32 {
-    get
-  }
-}
-public struct SoftwareKeyboardUiArgs {
-  public var keyboardMode: SoftwareKeyboard.KeyboardMode
-  public var headerText: Swift.String
-  public var subtitleText: Swift.String
-  public var submitText: Swift.String
-  public var stringLengthMin: Swift.Int32
-  public var stringLengthMax: Swift.Int32
-  public var initialText: Swift.String?
-}
-extension SoftwareKeyboard.KeyboardMode : Swift.Equatable {}
-extension SoftwareKeyboard.KeyboardMode : Swift.Hashable {}
-extension SoftwareKeyboard.KeyboardMode : Swift.RawRepresentable {}
--- a/Libraries/SoftwareKeyboard.framework/Modules/SoftwareKeyboard.swiftmodule/arm64-apple-ios.swiftdoc
+++ b/Libraries/SoftwareKeyboard.framework/Modules/SoftwareKeyboard.swiftmodule/arm64-apple-ios.swiftdoc
--- a/Libraries/SoftwareKeyboard.framework/Modules/SoftwareKeyboard.swiftmodule/arm64-apple-ios.swiftinterface
+++ b/Libraries/SoftwareKeyboard.framework/Modules/SoftwareKeyboard.swiftmodule/arm64-apple-ios.swiftinterface
@ -1,38 +0,0 @@
-// swift-interface-format-version: 1.0
-// swift-compiler-version: Apple Swift version 6.0.3 effective-5.10 (swiftlang-6.0.3.1.4 clang-1600.0.30)
-// swift-module-flags: -target arm64-apple-ios14.0 -enable-objc-interop -enable-library-evolution -swift-version 5 -enforce-exclusivity=checked -Onone -enable-experimental-feature OpaqueTypeErasure -enable-bare-slash-regex -module-name SoftwareKeyboard
-@_exported import SoftwareKeyboard
-import Swift
-import UIKit
-import _Concurrency
-import _StringProcessing
-import _SwiftConcurrencyShims
-@objc public enum KeyboardMode : Swift.UInt32 {
-  case `default` = 0
-  case numeric = 1
-  case ascii = 2
-  case fullLatin = 3
-  case alphabet = 4
-  case simplifiedChinese = 5
-  case traditionalChinese = 6
-  case korean = 7
-  case languageSet2 = 8
-  case languageSet2Latin = 9
-  public init?(rawValue: Swift.UInt32)
-  public typealias RawValue = Swift.UInt32
-  public var rawValue: Swift.UInt32 {
-    get
-  }
-}
-public struct SoftwareKeyboardUiArgs {
-  public var keyboardMode: SoftwareKeyboard.KeyboardMode
-  public var headerText: Swift.String
-  public var subtitleText: Swift.String
-  public var submitText: Swift.String
-  public var stringLengthMin: Swift.Int32
-  public var stringLengthMax: Swift.Int32
-  public var initialText: Swift.String?
-}
-extension SoftwareKeyboard.KeyboardMode : Swift.Equatable {}
-extension SoftwareKeyboard.KeyboardMode : Swift.Hashable {}
-extension SoftwareKeyboard.KeyboardMode : Swift.RawRepresentable {}
--- a/Libraries/SoftwareKeyboard.framework/Modules/SoftwareKeyboard.swiftmodule/arm64-apple-ios.swiftmodule
+++ b/Libraries/SoftwareKeyboard.framework/Modules/SoftwareKeyboard.swiftmodule/arm64-apple-ios.swiftmodule
--- a/Libraries/SoftwareKeyboard.framework/Modules/module.modulemap
+++ b/Libraries/SoftwareKeyboard.framework/Modules/module.modulemap
@ -1,6 +0,0 @@
-framework module SoftwareKeyboard {
-  umbrella header "SoftwareKeyboard.h"
-  export *
-
-  module * { export * }
-}
--- a/Libraries/SoftwareKeyboard.framework/SoftwareKeyboard
+++ b/Libraries/SoftwareKeyboard.framework/SoftwareKeyboard
--- a/src/MeloNX/MeloNX/Dependencies/Dynamic
+++ b/src/MeloNX/MeloNX/Dependencies/Dynamic
--- a/src/MeloNX/MeloNX/Dependencies/XCFrameworks/MoltenVK.xcframework/ios-arm64/MoltenVK.framework/MoltenVK
+++ b/src/MeloNX/MeloNX/Dependencies/XCFrameworks/MoltenVK.xcframework/ios-arm64/MoltenVK.framework/MoltenVK
--- a/src/MeloNX/MeloNX/Info.plist
+++ b/src/MeloNX/MeloNX/Info.plist
@ -2,8 +2,45 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
+	<key>CFBundleURLTypes</key>
+	<array>
+		<dict>
+			<key>CFBundleTypeRole</key>
+			<string>Editor</string>
+			<key>CFBundleURLName</key>
+			<string>com.stossy11.MeloNX</string>
+			<key>CFBundleURLSchemes</key>
+			<array>
+				<string>melonx</string>
+			</array>
+		</dict>
+	</array>
+	<key>GCSupportedGameControllers</key>
+	<array>
+		<dict>
+			<key>ProfileName</key>
+			<string>ExtendedGamepad</string>
+		</dict>
+		<dict>
+			<key>ProfileName</key>
+			<string>MicroGamepad</string>
+		</dict>
+	</array>
+	<key>LSApplicationQueriesSchemes</key>
+	<array>
+		<string>melonx</string>
+	</array>
 	<key>MeloID</key>
 	<string>83f67a0a96bd8628a150d7853e360db5bae64e7769524fae399c4b8e7e6aff17</string>
+	<key>NSUserActivityTypes</key>
+	<array>
+		<string>LaunchGameIntent</string>
+	</array>
+	<key>UIBackgroundModes</key>
+	<array>
+		<string>audio</string>
+		<string>processing</string>
+	</array>
 	<key>UIFileSharingEnabled</key>
 	<true/>
 	<key>UTExportedTypeDeclarations</key>
--- a/src/MeloNX/MeloNX/MeloNX.entitlements
+++ b/src/MeloNX/MeloNX/MeloNX.entitlements
@ -2,10 +2,6 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
-	<key>com.apple.developer.kernel.extended-virtual-addressing</key>
-	<true/>
-	<key>com.apple.developer.kernel.increased-debugging-memory-limit</key>
-	<true/>
 	<key>com.apple.developer.kernel.increased-memory-limit</key>
 	<true/>
 </dict>
--- a/src/MeloNX/MeloNX/MeloNXApp.swift
+++ b/src/MeloNX/MeloNX/MeloNXApp.swift
@ -15,12 +15,13 @@ import CryptoKit
 struct MeloNXApp: App {
    
    @State var showed = false
-    
+    @Environment(\.scenePhase) var scenePhase
+    @State var alert: UIAlertController? = nil
    
    var body: some Scene {
        WindowGroup {
            ZStack {
-                if showed {
+                if showed || DRM != 1 {
                    ContentView()
                } else {
                    Group {
@ -61,11 +62,18 @@ struct MeloNXApp: App {
                            
                            Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { _ in
                                InitializeRyujinx() { bool in
-                                    if !bool {
+                                    if !bool, (scenePhase != .background || scenePhase == .inactive) {
                                        withAnimation {
                                            showed = false
                                        }
-                                        showDMCAAlert()
+                                        if !(alert?.isViewLoaded ?? false) {
+                                            alert = showDMCAAlert()
+                                        }
+                                    } else {
+                                        DispatchQueue.main.async {
+                                            alert?.dismiss(animated: true)
+                                            showed = true
+                                        }
                                    }
                                }
                            }
@ -85,7 +93,7 @@ struct MeloNXApp: App {
    }

    
-    func showAlert() {
+    func showAlert() -> UIAlertController? {
        // Create the alert controller
        if let mainWindow = UIApplication.shared.windows.last {
            let alertController = UIAlertController(title: "Enter license", message: "Enter license key:", preferredStyle: .alert)
@ -118,23 +126,28 @@ struct MeloNXApp: App {
            
            // Present the alert
            mainWindow.rootViewController!.present(alertController, animated: true, completion: nil)
+            
+            return alertController
        } else {
-            exit(0)
+            return nil
        }
    }
    
    
 }

-func showDMCAAlert() {
-    DispatchQueue.main.async {
-        if let mainWindow = UIApplication.shared.windows.last {
-            let alertController = UIAlertController(title: "Unauthorized Copy Notice", message: "This app was illegally leaked. Please report the download on the MeloNX Discord. In the meantime, check out Pomelo! \n -Stossy11", preferredStyle: .alert)
+func showDMCAAlert() -> UIAlertController? {
+    if let mainWindow = UIApplication.shared.windows.first {
+        let alertController = UIAlertController(title: "Unauthorized Copy Notice", message: "This app was illegally leaked. Please report the download on the MeloNX Discord. In the meantime, check out Pomelo! \n -Stossy11", preferredStyle: .alert)
        
+        DispatchQueue.main.async {
            mainWindow.rootViewController!.present(alertController, animated: true, completion: nil)
-        } else {
-            exit(0)
        }
+        
+        return alertController
+    } else {
+        // uhoh
+        return nil
    }
 }

--- a/src/Ryujinx.Ava/UI/Applet/AvaHostUiHandler.cs
+++ b/src/Ryujinx.Ava/UI/Applet/AvaHostUiHandler.cs
@ -98,43 +98,10 @@ namespace Ryujinx.Ava.UI.Applet
            return okPressed;
        }

-        public bool DisplayInputDialog(SoftwareKeyboardUiArgs args, out string userText)
+        public void DisplayInputDialog(SoftwareKeyboardUiArgs args, Action<string> onTextEntered)
        {
-            ManualResetEvent dialogCloseEvent = new(false);
-
-            bool okPressed = false;
-            bool error = false;
-            string inputText = args.InitialText ?? "";
-
-            Dispatcher.UIThread.InvokeAsync(async () =>
-            {
-                try
-                {
-                    var response = await SwkbdAppletDialog.ShowInputDialog(LocaleManager.Instance[LocaleKeys.SoftwareKeyboard], args);
-
-                    if (response.Result == UserResult.Ok)
-                    {
-                        inputText = response.Input;
-                        okPressed = true;
-                    }
-                }
-                catch (Exception ex)
-                {
-                    error = true;
-
-                    await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.DialogSoftwareKeyboardErrorExceptionMessage, ex));
-                }
-                finally
-                {
-                    dialogCloseEvent.Set();
-                }
-            });
-
-            dialogCloseEvent.WaitOne();
-
-            userText = error ? null : inputText;
-
-            return error || okPressed;
+            onTextEntered?.Invoke("MeloNX");
+            return;
        }

        public void ExecuteProgram(Switch device, ProgramSpecifyKind kind, ulong value)
--- a/src/Ryujinx.Graphics.Vulkan/DescriptorSetManager.cs
+++ b/src/Ryujinx.Graphics.Vulkan/DescriptorSetManager.cs
@ -6,7 +6,7 @@ namespace Ryujinx.Graphics.Vulkan
 {
    class DescriptorSetManager : IDisposable
    {
-        public const uint MaxSets = 16;
+        public const uint MaxSets = 32;

        public class DescriptorPoolHolder : IDisposable
        {
--- a/src/Ryujinx.Graphics.Vulkan/MoltenVK/MVKInitialization.cs
+++ b/src/Ryujinx.Graphics.Vulkan/MoltenVK/MVKInitialization.cs
@ -23,14 +23,10 @@ namespace Ryujinx.Graphics.Vulkan.MoltenVK

            config.UseMetalArgumentBuffers = true;

-            if (OperatingSystem.IsIOSVersionAtLeast(17)) {
-                config.SemaphoreSupportStyle = MVKVkSemaphoreSupportStyle.MVK_CONFIG_VK_SEMAPHORE_SUPPORT_STYLE_SINGLE_QUEUE;
-            }
+            config.SemaphoreSupportStyle = MVKVkSemaphoreSupportStyle.MVK_CONFIG_VK_SEMAPHORE_SUPPORT_STYLE_SINGLE_QUEUE;

            config.MaxActiveMetalCommandBuffersPerQueue = 1024;

-            config.SynchronousQueueSubmits = false;
-
            config.ResumeLostDevice = true;

            vkSetMoltenVKConfigurationMVK(IntPtr.Zero, config, configSize);
--- a/src/Ryujinx.Graphics.Vulkan/PipelineBase.cs
+++ b/src/Ryujinx.Graphics.Vulkan/PipelineBase.cs
@ -1255,7 +1255,7 @@ namespace Ryujinx.Graphics.Vulkan

                        int vbSize = vertexBuffer.Buffer.Size;

-                        if (Gd.Vendor == Vendor.Amd && !Gd.IsMoltenVk && vertexBuffer.Stride > 0)
+                        if ((Gd.Vendor == Vendor.Amd || !OperatingSystem.IsIOSVersionAtLeast(17)) && !Gd.IsMoltenVk && vertexBuffer.Stride > 0)
                        {
                            // AMD has a bug where if offset + stride * count is greater than
                            // the size, then the last attribute will have the wrong value.
--- a/src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/SoftwareKeyboardApplet.cs
+++ b/src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/SoftwareKeyboardApplet.cs
@ -14,6 +14,8 @@ using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
+using System.Threading.Tasks;
+

 namespace Ryujinx.HLE.HOS.Applets
 {
@ -51,10 +53,10 @@ namespace Ryujinx.HLE.HOS.Applets

        private byte[] _transferMemory;

-        private string _textValue = "";
+        public string _textValue = "";
        private int _cursorBegin = 0;
        private Encoding _encoding = Encoding.Unicode;
-        private KeyboardResult _lastResult = KeyboardResult.NotSet;
+        public KeyboardResult _lastResult = KeyboardResult.NotSet;

        private IDynamicTextInputHandler _dynamicTextInputHandler = null;
        private SoftwareKeyboardRenderer _keyboardRenderer = null;
@ -180,9 +182,6 @@ namespace Ryujinx.HLE.HOS.Applets
            return _keyboardRenderer?.DrawTo(destination, position) ?? false;
        }

-    [DllImport("SoftwareKeyboard.framework/SoftwareKeyboard", EntryPoint = "displayInputDialog", CallingConvention = CallingConvention.Cdecl)]
-    public static extern void DisplayInputDialog(ref SoftwareKeyboardUiArgs args, out IntPtr userInput);
-

        private void ExecuteForegroundKeyboard()
        {
@ -223,26 +222,8 @@ namespace Ryujinx.HLE.HOS.Applets
                    InitialText = initialText,
                };

-                IntPtr userInputPtr;
-
-                DisplayInputDialog(ref args, out userInputPtr);
-                if (userInputPtr != IntPtr.Zero)
-                {
-                    // Convert the IntPtr to a string
-                    string userInput = Marshal.PtrToStringAnsi(userInputPtr);
-
-                    _textValue = userInput ?? DefaultInputText;
-                    _lastResult = KeyboardResult.Accept;
-
-                    Console.WriteLine($"User input: {userInput}");
-                }
-                else
-                {
-                    Console.WriteLine("No input was received or input was canceled.");
-
-                    _textValue = DefaultInputText;
-                    _lastResult = KeyboardResult.Cancel;
-                }
+                _textValue = DefaultInputText;
+                _lastResult = KeyboardResult.Cancel;
            }
            else
            {
@ -259,37 +240,40 @@ namespace Ryujinx.HLE.HOS.Applets
                    StringLengthMax = _keyboardForegroundConfig.StringLengthMax,
                    InitialText = initialText,
                };
+                _device.UiHandler.DisplayInputDialog(args, inputText => 
+                {
+                    Console.WriteLine($"User entered: {inputText}");
                    
-                _lastResult = _device.UiHandler.DisplayInputDialog(args, out _textValue) ? KeyboardResult.Accept : KeyboardResult.Cancel;
-                _textValue ??= initialText ?? DefaultInputText;
-            }
+                    _textValue = inputText ?? initialText ?? DefaultInputText;
+                    _lastResult = !string.IsNullOrEmpty(inputText) ? KeyboardResult.Accept : KeyboardResult.Cancel;

-            // Ensure the text meets the minimum length requirement
-            while (_textValue.Length < _keyboardForegroundConfig.StringLengthMin)
-            {
-                _textValue = string.Join(" ", _textValue, _textValue);
-            }
+                    while (_textValue.Length < _keyboardForegroundConfig.StringLengthMin)
+                    {
+                        _textValue = string.Join(" ", _textValue, _textValue);
+                    }

-            // Truncate the text if it exceeds the maximum length
-            if (_textValue.Length > _keyboardForegroundConfig.StringLengthMax)
-            {
-                _textValue = _textValue[.._keyboardForegroundConfig.StringLengthMax];
-            }
+                    // Truncate the text if it exceeds the maximum length
+                    if (_textValue.Length > _keyboardForegroundConfig.StringLengthMax)
+                    {
+                        _textValue = _textValue[.._keyboardForegroundConfig.StringLengthMax];
+                    }

-            // Handle text validation if required
-            if (_keyboardForegroundConfig.CheckText)
-            {
-                // Submit text for validation
-                _foregroundState = SoftwareKeyboardState.ValidationPending;
-                PushForegroundResponse(true);
-            }
-            else
-            {
-                // Submit text as complete
-                _foregroundState = SoftwareKeyboardState.Complete;
-                PushForegroundResponse(false);
+                    // Handle text validation if required
+                    if (_keyboardForegroundConfig.CheckText)
+                    {
+                        // Submit text for validation
+                        _foregroundState = SoftwareKeyboardState.ValidationPending;
+                        PushForegroundResponse(true);
+                    }
+                    else
+                    {
+                        // Submit text as complete
+                        _foregroundState = SoftwareKeyboardState.Complete;
+                        PushForegroundResponse(false);

-                AppletStateChanged?.Invoke(this, null);
+                        AppletStateChanged?.Invoke(this, null);
+                    }
+                });
            }
        }

--- a/src/Ryujinx.HLE/Ui/IHostUiHandler.cs
+++ b/src/Ryujinx.HLE/Ui/IHostUiHandler.cs
@ -1,5 +1,6 @@
 using Ryujinx.HLE.HOS.Applets;
 using Ryujinx.HLE.HOS.Services.Am.AppletOE.ApplicationProxyService.ApplicationProxy.Types;
+using System;

 namespace Ryujinx.HLE.Ui
 {
@ -10,7 +11,7 @@ namespace Ryujinx.HLE.Ui
        /// </summary>
        /// <param name="userText">Text that the user entered. Set to `null` on internal errors</param>
        /// <returns>True when OK is pressed, False otherwise. Also returns True on internal errors</returns>
-        bool DisplayInputDialog(SoftwareKeyboardUiArgs args, out string userText);
+        public void DisplayInputDialog(SoftwareKeyboardUiArgs args, Action<string> onTextEntered);

        /// <summary>
        /// Displays a Message Dialog box to the user and blocks until it is closed.
--- a/src/Ryujinx.Headless.SDL2/Keyboard-iOS.cs
+++ b/src/Ryujinx.Headless.SDL2/Keyboard-iOS.cs
@ -0,0 +1,42 @@
+using System;
+using System.Runtime.InteropServices;
+using Ryujinx.Ui.Common.Helper;
+using System.Threading;
+
+namespace Ryujinx.Headless.SDL2
+{
+    public static class AlertHelper
+    {
+        [DllImport("RyujinxKeyboard.framework/RyujinxKeyboard", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void showKeyboardAlert(string title, string message, string placeholder);
+
+        [DllImport("RyujinxKeyboard.framework/RyujinxKeyboard", CallingConvention = CallingConvention.Cdecl)]
+        private static extern IntPtr getKeyboardInput();
+
+        [DllImport("RyujinxKeyboard.framework/RyujinxKeyboard", CallingConvention = CallingConvention.Cdecl)]
+        private static extern void clearKeyboardInput();
+
+        public static void ShowAlertWithTextInput(string title, string message, string placeholder, Action<string> onTextEntered)
+        {
+            showKeyboardAlert(title, message, placeholder);
+
+            ThreadPool.QueueUserWorkItem(_ =>
+            {
+                string result = null;
+                while (result == null)
+                {
+                    Thread.Sleep(100);
+
+                    IntPtr inputPtr = getKeyboardInput();
+                    if (inputPtr != IntPtr.Zero)
+                    {
+                        result = Marshal.PtrToStringAnsi(inputPtr);
+                        clearKeyboardInput(); 
+
+                        onTextEntered?.Invoke(result);
+                    }
+                }
+            });
+        }
+    }
+}
--- a/src/Ryujinx.Headless.SDL2/Program.cs
+++ b/src/Ryujinx.Headless.SDL2/Program.cs
@ -115,6 +115,7 @@ namespace Ryujinx.Headless.SDL2
        private static bool _enableMouse;

        private static readonly InputConfigJsonSerializerContext _serializerContext = new(JsonHelper.GetDefaultSerializerOptions());
+        private static readonly TitleUpdateMetadataJsonSerializerContext _titleSerializerContext = new(JsonHelper.GetDefaultSerializerOptions());

        [UnmanagedCallersOnly(EntryPoint = "main_ryujinx_sdl")]
        public static unsafe int MainExternal(int argCount, IntPtr* pArgs)
@ -141,6 +142,95 @@ namespace Ryujinx.Headless.SDL2
            return 0;
        }

+        [UnmanagedCallersOnly(EntryPoint = "get_dlc_nca_list")]
+        public static unsafe DlcNcaList GetDlcNcaList(IntPtr titleIdPtr, IntPtr pathPtr) 
+        {
+            var titleId = Marshal.PtrToStringAnsi(titleIdPtr);
+            var containerPath = Marshal.PtrToStringAnsi(pathPtr);
+
+            if (!File.Exists(containerPath))
+            {
+                return new DlcNcaList { success = false };
+            }
+
+            using FileStream containerFile = File.OpenRead(containerPath);
+
+            PartitionFileSystem pfs = new();
+            pfs.Initialize(containerFile.AsStorage()).ThrowIfFailure();
+            bool containsDlc = false;
+
+            _virtualFileSystem.ImportTickets(pfs);
+
+            // TreeIter? parentIter = null;
+
+            List<DlcNcaListItem> listItems = new();
+            foreach (DirectoryEntryEx fileEntry in pfs.EnumerateEntries("/", "*.nca"))
+            {
+                using var ncaFile = new UniqueRef<IFile>();
+
+                pfs.OpenFile(ref ncaFile.Ref, fileEntry.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
+
+                Nca nca = TryCreateNca(ncaFile.Get.AsStorage(), containerPath);
+
+                if (nca == null)
+                {
+                    continue;
+                }
+
+                if (nca.Header.ContentType == NcaContentType.PublicData)
+                {
+                    if ((nca.Header.TitleId & 0xFFFFFFFFFFFFE000).ToString("x16") != titleId)
+                    {
+                        break;
+                    }
+
+                    Logger.Warning?.Print(LogClass.Application, $"ContainerPath: {containerPath}");
+                    Logger.Warning?.Print(LogClass.Application, $"TitleId: {nca.Header.TitleId}");
+                    Logger.Warning?.Print(LogClass.Application, $"fileEntry.FullPath: {fileEntry.FullPath}");
+                    
+                    // parentIter ??= ((TreeStore)_dlcTreeView.Model).AppendValues(true, "", containerPath);
+                    // ((TreeStore)_dlcTreeView.Model).AppendValues(parentIter.Value, true, nca.Header.TitleId.ToString("X16"), fileEntry.FullPath);
+
+                    DlcNcaListItem item = new();
+                    CopyStringToFixedArray(fileEntry.FullPath, item.Path, 256);
+                    item.TitleId = nca.Header.TitleId;
+                    listItems.Add(item);
+                    
+                    containsDlc = true;
+                }
+            }
+
+            if (!containsDlc)
+            {
+                return new DlcNcaList { success = false };
+                // GtkDialog.CreateErrorDialog("The specified file does not contain DLC for the selected title!");
+            }
+            
+            var list = new DlcNcaList { success = true, size = (uint) listItems.Count };
+
+            DlcNcaListItem[] items = listItems.ToArray();
+
+            fixed (DlcNcaListItem* p = &items[0])
+            {
+                list.items = p;
+            }
+            
+            return list;
+        }
+        
+        private static Nca TryCreateNca(IStorage ncaStorage, string containerPath)
+        {
+            try
+            {
+                return new Nca(_virtualFileSystem.KeySet, ncaStorage);
+            }
+            catch (Exception exception)
+            {
+                // ignored
+            }
+
+            return null;
+        }

        [UnmanagedCallersOnly(EntryPoint = "get_current_fps")]
        public static unsafe int GetFPS() 
@ -304,7 +394,6 @@ namespace Ryujinx.Headless.SDL2

            if (_window != null)
            {
-
                _window.Exit();
                _emulationContext.Dispose();
                _emulationContext = null;
@ -317,10 +406,14 @@ namespace Ryujinx.Headless.SDL2
            if (_virtualFileSystem == null) {
                _virtualFileSystem = VirtualFileSystem.CreateInstance();
            }
+            
            var extension = Marshal.PtrToStringAnsi(extensionPtr);
            var stream = OpenFile(descriptor);

            var gameInfo = GetGameInfo(stream, extension);
+            if (gameInfo == null) {
+                return new GameInfoNative(0, "", "", "", "", new byte[0]);
+            }

            return new GameInfoNative(
                (ulong)gameInfo.FileSize, 
@ -719,7 +812,8 @@ namespace Ryujinx.Headless.SDL2

                    if (File.Exists(titleUpdateMetadataPath))
                    {
-                        // updatePath = JsonHelper.DeserializeFromFile(titleUpdateMetadataPath).Selected;
+                        string updatePathRelative = JsonHelper.DeserializeFromFile(titleUpdateMetadataPath, _titleSerializerContext.TitleUpdateMetadata).Selected;
+                        updatePath = Path.Combine(AppDataManager.BaseDirPath, updatePathRelative);

                        if (File.Exists(updatePath))
                        {
@ -1485,6 +1579,19 @@ namespace Ryujinx.Headless.SDL2
            public byte[]? Icon;
        }

+        public unsafe struct DlcNcaListItem 
+        {
+            public fixed byte Path[256];
+            public ulong TitleId;
+        }
+
+        public unsafe struct DlcNcaList
+        {
+            public bool success;
+            public uint size;
+            public unsafe DlcNcaListItem* items;
+        }
+
        public unsafe struct GameInfoNative
        {
            public ulong FileSize;
@ -1532,14 +1639,13 @@ namespace Ryujinx.Headless.SDL2
                    ImageData = null;
                }
            }
-
-            private static void CopyStringToFixedArray(string source, byte* destination, int length)
-            {
-                var span = new Span<byte>(destination, length);
-                span.Clear();
-                Encoding.UTF8.GetBytes(source, span);
-            }
        }

+        private static unsafe void CopyStringToFixedArray(string source, byte* destination, int length)
+        {
+            var span = new Span<byte>(destination, length);
+            span.Clear();
+            Encoding.UTF8.GetBytes(source, span);
+        }
    }
 }
--- a/src/Ryujinx.Headless.SDL2/WindowBase.cs
+++ b/src/Ryujinx.Headless.SDL2/WindowBase.cs
@ -460,12 +460,19 @@ namespace Ryujinx.Headless.SDL2
            Exit();
        }

-        public bool DisplayInputDialog(SoftwareKeyboardUiArgs args, out string userText)
+        public void DisplayInputDialog(SoftwareKeyboardUiArgs args, Action<string> onTextEntered)
        {
            // SDL2 doesn't support input dialogs
-            userText = "Ryujinx";
-
-            return true;
+            // Trying to use Objective-C on iDevices
+            if (OperatingSystem.IsIOS())
+            {
+                AlertHelper.ShowAlertWithTextInput(args.HeaderText, args.SubtitleText, args.GuideText, (inputText) =>
+                {
+                    onTextEntered?.Invoke(inputText);
+                });
+            } else {
+                onTextEntered?.Invoke("");
+            }
        }

        public bool DisplayMessageDialog(string title, string message)
--- a/src/Ryujinx/Ui/Applet/GtkHostUiHandler.cs
+++ b/src/Ryujinx/Ui/Applet/GtkHostUiHandler.cs
@ -81,57 +81,10 @@ namespace Ryujinx.Ui.Applet
            return okPressed;
        }

-        public bool DisplayInputDialog(SoftwareKeyboardUiArgs args, out string userText)
+        public void DisplayInputDialog(SoftwareKeyboardUiArgs args, Action<string> onTextEntered)
        {
-            ManualResetEvent dialogCloseEvent = new(false);
-
-            bool okPressed = false;
-            bool error = false;
-            string inputText = args.InitialText ?? "";
-
-            Application.Invoke(delegate
-            {
-                try
-                {
-                    var swkbdDialog = new SwkbdAppletDialog(_parent)
-                    {
-                        Title = "Software Keyboard",
-                        Text = args.HeaderText,
-                        SecondaryText = args.SubtitleText,
-                    };
-
-                    swkbdDialog.InputEntry.Text = inputText;
-                    swkbdDialog.InputEntry.PlaceholderText = args.GuideText;
-                    swkbdDialog.OkButton.Label = args.SubmitText;
-
-                    swkbdDialog.SetInputLengthValidation(args.StringLengthMin, args.StringLengthMax);
-                    swkbdDialog.SetInputValidation(args.KeyboardMode);
-
-                    if (swkbdDialog.Run() == (int)ResponseType.Ok)
-                    {
-                        inputText = swkbdDialog.InputEntry.Text;
-                        okPressed = true;
-                    }
-
-                    swkbdDialog.Dispose();
-                }
-                catch (Exception ex)
-                {
-                    error = true;
-
-                    GtkDialog.CreateErrorDialog($"Error displaying Software Keyboard: {ex}");
-                }
-                finally
-                {
-                    dialogCloseEvent.Set();
-                }
-            });
-
-            dialogCloseEvent.WaitOne();
-
-            userText = error ? null : inputText;
-
-            return error || okPressed;
+            onTextEntered?.Invoke("MeloNX");
+            return;
        }

        public void ExecuteProgram(HLE.Switch device, ProgramSpecifyKind kind, ulong value)
Author	SHA1	Message	Date
stossy11	527ac3fb23	Update README.md	2025-02-20 20:54:03 +00:00
stossy11	8e60f6dc50	Update README.md	2025-02-19 07:42:45 +00:00
Stossy11	3b99631dfb	Implement JIT Cache Regions and Add Handheld Input	2025-02-19 11:16:50 +11:00
stossy11	cb33b04f2b	Merge pull request 'GCController wrapper' (#6 ) from XITRIX/MeloNX:Controller-fix into XC-ios-ht Reviewed-on: MeloNX/MeloNX#6	2025-02-17 01:20:48 +00:00
Daniil Vinogradov	500f3d5b9e	Fix for virtual controller detach \| pass gamepad haptic engine	2025-02-17 00:39:04 +01:00
Daniil Vinogradov	ac4e5d394e	Hide non wrapped controllers	2025-02-17 00:39:03 +01:00
Daniil Vinogradov	f2d078f80b	GCController wrapper	2025-02-17 00:39:03 +01:00
stossy11	004a81fa60	Merge pull request 'DLC manager implemented' (#11 ) from XITRIX/MeloNX:DLC-support into XC-ios-ht Reviewed-on: MeloNX/MeloNX#11	2025-02-16 23:33:30 +00:00
Daniil Vinogradov	ddf634ecb6	DLC manager implemented	2025-02-17 00:28:05 +01:00
Stossy11	cce876c6f5	Change version number	2025-02-17 07:40:56 +11:00
stossy11	ebfb39c132	Merge pull request 'Correct device req + Add Xcode to compiling req' (#10 ) from C4ndyF1sh/MeloNX:device-req-and-compiling-req into XC-ios-ht Reviewed-on: MeloNX/MeloNX#10	2025-02-16 20:15:56 +00:00
stossy11	b3bb9cefcf	Merge pull request 'Update manager fix' (#8 ) from XITRIX/MeloNX:Update-manager-fix into XC-ios-ht Reviewed-on: MeloNX/MeloNX#8	2025-02-16 20:14:58 +00:00
C4ndyF1sh	8c54134699	Update Compile.md	2025-02-16 17:57:59 +00:00
C4ndyF1sh	e8537df246	Update README.md	2025-02-16 17:55:44 +00:00
Daniil Vinogradov	8c6dd455f2	Game update path fix	2025-02-16 15:46:46 +01:00
Daniil Vinogradov	2a7cfa5650	GameInfo UI enhancement	2025-02-16 13:52:12 +01:00
Daniil Vinogradov	df2b17ddd6	UI enhancements	2025-02-16 13:41:57 +01:00
Daniil Vinogradov	757fb1f6d1	Update manager fix	2025-02-16 13:41:57 +01:00
Stossy11	e741039304	Add Entitlement Checker and Memory	2025-02-16 17:29:09 +11:00
Stossy11	fd0ce75f67	Fix whatever happened	2025-02-16 16:22:20 +11:00
Stossy11	0e80bd3d51	Add game update manager	2025-02-16 14:01:31 +11:00
Stossy11	f95281899c	a bunch of changes	2025-02-16 12:17:12 +11:00
stossy11	802a8d7bae	Merge pull request 'Added title update functionality' (#7 ) from XITRIX/MeloNX:Title-update into XC-ios-ht Reviewed-on: MeloNX/MeloNX#7	2025-02-16 00:04:42 +00:00
Daniil Vinogradov	7277e1fa9b	Add title update functionality	2025-02-15 20:34:36 +01:00
Daniil Vinogradov	27312d4f31	Null pointer fix	2025-02-15 20:34:36 +01:00
stossy11	4ffb0ff617	Update Compile.md	2025-02-15 01:37:00 +00:00
stossy11	a358dcdfc4	Update Compile.md	2025-02-15 01:35:48 +00:00
stossy11	08ee9b18ea	Update LICENSE.txt	2025-02-13 12:15:27 +00:00
stossy11	aadc258187	Update LICENSE.txt	2025-02-13 12:13:53 +00:00
stossy11	1c75d22190	Update README.md to reflect the new LICENSE	2025-02-13 11:38:35 +00:00
stossy11	57c297369a	Add New License	2025-02-13 11:37:34 +00:00
stossy11	56544db198	Move Around Steps a little	2025-02-13 04:37:28 +00:00
stossy11	6ec2ad2841	Add Update Guide	2025-02-13 04:36:35 +00:00
Bella!!!	9d6c7d9900	Merge pull request 'Fix broken link to compatibility' (#5 ) from Vishram1123/MeloNX:XC-ios-ht into XC-ios-ht Reviewed-on: MeloNX/MeloNX#5	2025-02-13 03:18:12 +00:00
Vishram1123	9ddc6a969c	Fix broken link to compatibility	2025-02-13 02:20:20 +00:00
Stossy11	1b69c0bdc6	Set Version to 1.1.0	2025-02-13 12:56:20 +11:00
Stossy11	18d98755f6	Add Disable vSync	2025-02-13 12:47:53 +11:00
Stossy11	c6de4abce3	Fix vertical controllers	2025-02-13 10:00:01 +11:00
Stossy11	e5c5e8572e	Fix Keyboard and add Disable PTC mode	2025-02-13 10:00:01 +11:00
stossy11	c0e8570293	Update README.md	2025-02-12 21:17:11 +00:00
stossy11	c8a3124cca	Update Compile.md	2025-02-12 13:04:56 +00:00
stossy11	2c389c899a	Update Compile.md	2025-02-12 12:34:44 +00:00
stossy11	11571aca6e	add xcode-select --switch to Compile.md	2025-02-12 10:23:48 +00:00
Stossy11	e04e689bc4	Fix spelling mistake	2025-02-12 21:06:31 +11:00
stossy11	5c903626cc	Update Site Workflow	2025-02-12 09:20:17 +00:00
stossy11	9ca187a8c4	Fix Icon	2025-02-12 07:55:02 +00:00
stossy11	cac3853d96	Update README.md	2025-02-12 07:49:51 +00:00
stossy11	fff70a2dba	Update README.md	2025-02-12 07:49:01 +00:00
stossy11	4da30e332c	Update Compile.md	2025-02-12 07:41:05 +00:00
Stossy11	114ba3eb57	Remove func MainThread and add SDL Window code back	2025-02-12 18:19:51 +11:00
Stossy11	839ddab589	small UI chanes	2025-02-12 18:19:51 +11:00
Bella	00a06c4dc8	Replace GitHub Actions workflow with Gitea workflow for notifying API on release	2025-02-12 19:55:06 +13:00
Bella!!!	efbeebafcb	(hopefully this work) Add: Action for adding release to site	2025-02-12 06:00:59 +00:00
Stossy11	b85758ba88	FIx starting the emulation on iOS 16 and below.	2025-02-12 08:39:37 +11:00
Stossy11	46196daf39	Fix Keyboard issues	2025-02-11 20:43:21 +11:00
Stossy11	eb4a4593ea	Add Software Keyboard, Edit maxSets and more	2025-02-11 20:22:50 +11:00
Stossy11	c3ade6f5cd	Add Built in JitStreamer-EB implementation, rework the shortcut and more	2025-02-10 23:27:06 +11:00
Stossy11	007cb026a4	Add Intent to Launch Game and change how DRM works	2025-02-10 17:46:24 +11:00