Merge 565a40f854 into 1217a8e69b

src/Ryujinx.Gtk3/UI/Applet/GtkDynamicTextInputHandler.cs

@@ -1,5 +1,5 @@
 using Gtk;
-using Ryujinx.HLE.UI;
+using Ryujinx.Horizon.UI;
 using Ryujinx.Input.GTK3;
 using Ryujinx.UI.Widgets;
 using System.Threading;

src/Ryujinx.Gtk3/UI/Applet/GtkHostUIHandler.cs

@@ -1,7 +1,8 @@
 using Gtk;
-using Ryujinx.HLE.HOS.Applets;
-using Ryujinx.HLE.HOS.Services.Am.AppletOE.ApplicationProxyService.ApplicationProxy.Types;
-using Ryujinx.HLE.UI;
+using Ryujinx.Horizon.Applets.Controller;
+using Ryujinx.Horizon.Applets.SoftwareKeyboard;
+using Ryujinx.Horizon.Sdk.Am;
+using Ryujinx.Horizon.UI;
 using Ryujinx.UI.Widgets;
 using System;
 using System.Threading;

src/Ryujinx.Gtk3/UI/Applet/GtkHostUITheme.cs

@@ -1,5 +1,5 @@
 using Gtk;
-using Ryujinx.HLE.UI;
+using Ryujinx.Horizon.UI;
 using System.Diagnostics;
 
 namespace Ryujinx.UI.Applet

src/Ryujinx.Gtk3/UI/Applet/SwkbdAppletDialog.cs

@@ -1,5 +1,5 @@
 using Gtk;
-using Ryujinx.HLE.HOS.Applets.SoftwareKeyboard;
+using Ryujinx.Horizon.Applets.SoftwareKeyboard;
 using System;
 using System.Linq;
 

src/Ryujinx.HLE/HLEConfiguration.cs

@@ -7,7 +7,7 @@ using Ryujinx.HLE.FileSystem;
 using Ryujinx.HLE.HOS;
 using Ryujinx.HLE.HOS.Services.Account.Acc;
 using Ryujinx.HLE.HOS.SystemState;
-using Ryujinx.HLE.UI;
+using Ryujinx.Horizon.UI;
 using System;
 
 namespace Ryujinx.HLE

src/Ryujinx.HLE/HOS/Horizon.cs

@@ -12,7 +12,6 @@ using Ryujinx.HLE.HOS.Kernel.Process;
 using Ryujinx.HLE.HOS.Kernel.Threading;
 using Ryujinx.HLE.HOS.Services;
 using Ryujinx.HLE.HOS.Services.Account.Acc;
-using Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.SystemAppletProxy;
 using Ryujinx.HLE.HOS.Services.Apm;
 using Ryujinx.HLE.HOS.Services.Caps;
 using Ryujinx.HLE.HOS.Services.Mii;
@@ -29,6 +28,7 @@ using Ryujinx.HLE.HOS.SystemState;
 using Ryujinx.HLE.Loaders.Executables;
 using Ryujinx.HLE.Loaders.Processes;
 using Ryujinx.Horizon;
+using Ryujinx.Horizon.Sdk.Am;
 using System;
 using System.Collections.Generic;
 using System.IO;

src/Ryujinx.HLE/HOS/Services/Am/AppletAE/Types/AppletId.cs

@@ -1,27 +0,0 @@
-namespace Ryujinx.HLE.HOS.Services.Am.AppletAE
-{
-    enum AppletId
-    {
-        Application = 0x01,
-        OverlayDisplay = 0x02,
-        QLaunch = 0x03,
-        Starter = 0x04,
-        Auth = 0x0A,
-        Cabinet = 0x0B,
-        Controller = 0x0C,
-        DataErase = 0x0D,
-        Error = 0x0E,
-        NetConnect = 0x0F,
-        PlayerSelect = 0x10,
-        SoftwareKeyboard = 0x11,
-        MiiEdit = 0x12,
-        LibAppletWeb = 0x13,
-        LibAppletShop = 0x14,
-        PhotoViewer = 0x15,
-        Settings = 0x16,
-        LibAppletOff = 0x17,
-        LibAppletWhitelisted = 0x18,
-        LibAppletAuth = 0x19,
-        MyPage = 0x1A,
-    }
-}

src/Ryujinx.HLE/HOS/Services/Am/AppletAE/Types/LibraryAppletMode.cs

@@ -1,14 +0,0 @@
-using System;
-
-namespace Ryujinx.HLE.HOS.Services.Am.AppletAE
-{
-    [Flags]
-    enum LibraryAppletMode : uint
-    {
-        AllForeground,
-        PartialForeground,
-        NoUi,
-        PartialForegroundWithIndirectDisplay,
-        AllForegroundInitiallyHidden,
-    }
-}

src/Ryujinx.HLE/HOS/Services/Sdb/Pdm/QueryService/QueryPlayStatisticsManager.cs

@@ -47,7 +47,8 @@ namespace Ryujinx.HLE.HOS.Services.Sdb.Pdm.QueryService
                 {
                     if (!context.Device.Processes.ActiveApplication.ApplicationControlProperties.PlayLogQueryableApplicationId.ItemsRo.Contains(titleId))
                     {
-                        return (ResultCode)Am.ResultCode.ObjectInvalid;
+                        // Am Result.ObjectInvalid
+                        return (ResultCode)((500 << 9) | 128);
                     }
                 }
             }

src/Ryujinx.HLE/HOS/Services/Vi/RootService/IApplicationDisplayService.cs

@@ -1,13 +1,12 @@
 using Ryujinx.Common;
 using Ryujinx.Common.Logging;
 using Ryujinx.Common.Memory;
-using Ryujinx.HLE.HOS.Applets;
+using Ryujinx.Horizon.Applets;
 using Ryujinx.HLE.HOS.Ipc;
 using Ryujinx.HLE.HOS.Services.SurfaceFlinger;
 using Ryujinx.HLE.HOS.Services.Vi.RootService.ApplicationDisplayService;
 using Ryujinx.HLE.HOS.Services.Vi.RootService.ApplicationDisplayService.Types;
 using Ryujinx.HLE.HOS.Services.Vi.Types;
-using Ryujinx.HLE.UI;
 using Ryujinx.Horizon.Common;
 using System;
 using System.Collections.Generic;

src/Ryujinx.HLE/HOS/SystemState/AppletStateMgr.cs

@@ -1,5 +1,5 @@
 using Ryujinx.HLE.HOS.Kernel.Threading;
-using Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.SystemAppletProxy;
+using Ryujinx.Horizon.Sdk.Am;
 using System.Collections.Concurrent;
 
 namespace Ryujinx.HLE.HOS.SystemState

src/Ryujinx.HLE/HOS/UserChannelPersistence.cs

@@ -1,4 +1,4 @@
-using Ryujinx.HLE.HOS.Services.Am.AppletOE.ApplicationProxyService.ApplicationProxy.Types;
+using Ryujinx.Horizon.Sdk.Am;
 using System;
 using System.Collections.Generic;
 

src/Ryujinx.HLE/Ryujinx.HLE.csproj

@@ -24,8 +24,6 @@
     <PackageReference Include="LibHac" />
     <PackageReference Include="Microsoft.IdentityModel.JsonWebTokens" />
     <PackageReference Include="MsgPack.Cli" />
-    <PackageReference Include="SixLabors.ImageSharp" />
-    <PackageReference Include="SixLabors.ImageSharp.Drawing" />
     <PackageReference Include="NetCoreServer" />
   </ItemGroup>
 
@@ -40,10 +38,6 @@
 
   <ItemGroup>
     <EmbeddedResource Include="Homebrew.npdm" />
-    <EmbeddedResource Include="HOS\Applets\SoftwareKeyboard\Resources\Logo_Ryujinx.png" />
-    <EmbeddedResource Include="HOS\Applets\SoftwareKeyboard\Resources\Icon_BtnA.png" />
-    <EmbeddedResource Include="HOS\Applets\SoftwareKeyboard\Resources\Icon_BtnB.png" />
-    <EmbeddedResource Include="HOS\Applets\SoftwareKeyboard\Resources\Icon_KeyF6.png" />
     <EmbeddedResource Include="HOS\Services\Account\Acc\DefaultUserImage.jpg" />
   </ItemGroup>
 

src/Ryujinx.HLE/Switch.cs

@@ -7,7 +7,7 @@ using Ryujinx.HLE.HOS;
 using Ryujinx.HLE.HOS.Services.Apm;
 using Ryujinx.HLE.HOS.Services.Hid;
 using Ryujinx.HLE.Loaders.Processes;
-using Ryujinx.HLE.UI;
+using Ryujinx.Horizon.UI;
 using Ryujinx.Memory;
 using System;
 

src/Ryujinx.HLE/UI/Input/NpadButtonHandler.cs

@@ -1,6 +0,0 @@
-using Ryujinx.HLE.HOS.Services.Hid.Types.SharedMemory.Npad;
-
-namespace Ryujinx.HLE.UI.Input
-{
-    delegate void NpadButtonHandler(int npadIndex, NpadButton button);
-}

src/Ryujinx.Headless.SDL2/HeadlessDynamicTextInputHandler.cs

@@ -1,4 +1,4 @@
-using Ryujinx.HLE.UI;
+using Ryujinx.Horizon.UI;
 using System.Threading;
 using System.Threading.Tasks;
 

src/Ryujinx.Headless.SDL2/HeadlessHostUiTheme.cs

@@ -1,4 +1,4 @@
-using Ryujinx.HLE.UI;
+using Ryujinx.Horizon.UI;
 
 namespace Ryujinx.Headless.SDL2
 {

src/Ryujinx.Headless.SDL2/WindowBase.cs

@@ -5,9 +5,10 @@ using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.GAL.Multithreading;
 using Ryujinx.Graphics.Gpu;
 using Ryujinx.Graphics.OpenGL;
-using Ryujinx.HLE.HOS.Applets;
-using Ryujinx.HLE.HOS.Services.Am.AppletOE.ApplicationProxyService.ApplicationProxy.Types;
-using Ryujinx.HLE.UI;
+using Ryujinx.Horizon.Applets.Controller;
+using Ryujinx.Horizon.Applets.SoftwareKeyboard;
+using Ryujinx.Horizon.Sdk.Am;
+using Ryujinx.Horizon.UI;
 using Ryujinx.Input;
 using Ryujinx.Input.HLE;
 using Ryujinx.SDL2.Common;

src/Ryujinx.Horizon/Am/AmIpcServer.cs

@@ -0,0 +1,46 @@
+using Ryujinx.Horizon.Am.Ipc;
+using Ryujinx.Horizon.Sdk.Sf.Hipc;
+using Ryujinx.Horizon.Sdk.Sm;
+
+namespace Ryujinx.Horizon.Am
+{
+    internal class AmIpcServer
+    {
+        private const int MaxSessionsCountAE = 9;
+        private const int MaxSessionsCountOE = 1;
+        private const int TotalMaxSessionsCount = MaxSessionsCountAE + MaxSessionsCountOE;
+
+        private const int PointerBufferSize = 0;
+        private const int MaxDomains = 10;
+        private const int MaxDomainObjects = 64;
+        private const int MaxPortsCount = 4;
+
+        private static readonly ManagerOptions _options = new(PointerBufferSize, MaxDomains, MaxDomainObjects, false);
+
+        private SmApi _sm;
+        private ServerManager _serverManager;
+
+        public void Initialize()
+        {
+            HeapAllocator allocator = new();
+
+            _sm = new SmApi();
+            _sm.Initialize().AbortOnFailure();
+
+            _serverManager = new ServerManager(allocator, _sm, MaxPortsCount, _options, TotalMaxSessionsCount);
+
+            _serverManager.RegisterObjectForServer(new ProxiesService(), ServiceName.Encode("appletAE"), MaxSessionsCountAE);
+            _serverManager.RegisterObjectForServer(new ProxiesService(), ServiceName.Encode("appletOE"), MaxSessionsCountOE);
+        }
+
+        public void ServiceRequests()
+        {
+            _serverManager.ServiceRequests();
+        }
+
+        public void Shutdown()
+        {
+            _serverManager.Dispose();
+        }
+    }
+}

src/Ryujinx.Horizon/Am/AmMain.cs

@@ -0,0 +1,17 @@
+namespace Ryujinx.Horizon.Am
+{
+    class AmMain : IService
+    {
+        public static void Main(ServiceTable serviceTable)
+        {
+            AmIpcServer ipcServer = new();
+
+            ipcServer.Initialize();
+
+            serviceTable.SignalServiceReady();
+
+            ipcServer.ServiceRequests();
+            ipcServer.Shutdown();
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/AppletFifo.cs

@@ -0,0 +1,121 @@
+using Ryujinx.Horizon.Sdk.Am;
+using System;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+
+namespace Ryujinx.Horizon.Am.Ipc
+{
+    internal class AppletFifo<T> : IAppletFifo<T>
+    {
+        private readonly ConcurrentQueue<T> _dataQueue;
+
+        public event EventHandler DataAvailable;
+
+        public bool IsSynchronized
+        {
+            get { return ((ICollection)_dataQueue).IsSynchronized; }
+        }
+
+        public object SyncRoot
+        {
+            get { return ((ICollection)_dataQueue).SyncRoot; }
+        }
+
+        public int Count
+        {
+            get { return _dataQueue.Count; }
+        }
+
+        public AppletFifo()
+        {
+            _dataQueue = new ConcurrentQueue<T>();
+        }
+
+        public void Push(T item)
+        {
+            _dataQueue.Enqueue(item);
+
+            DataAvailable?.Invoke(this, null);
+        }
+
+        public bool TryAdd(T item)
+        {
+            try
+            {
+                this.Push(item);
+
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        public T Pop()
+        {
+            if (_dataQueue.TryDequeue(out T result))
+            {
+                return result;
+            }
+
+            throw new InvalidOperationException("FIFO empty.");
+        }
+
+        public bool TryPop(out T result)
+        {
+            return _dataQueue.TryDequeue(out result);
+        }
+
+        public bool TryTake(out T item)
+        {
+            return this.TryPop(out item);
+        }
+
+        public T Peek()
+        {
+            if (_dataQueue.TryPeek(out T result))
+            {
+                return result;
+            }
+
+            throw new InvalidOperationException("FIFO empty.");
+        }
+
+        public bool TryPeek(out T result)
+        {
+            return _dataQueue.TryPeek(out result);
+        }
+
+        public void Clear()
+        {
+            _dataQueue.Clear();
+        }
+
+        public T[] ToArray()
+        {
+            return _dataQueue.ToArray();
+        }
+
+        public void CopyTo(T[] array, int arrayIndex)
+        {
+            _dataQueue.CopyTo(array, arrayIndex);
+        }
+
+        public void CopyTo(Array array, int index)
+        {
+            this.CopyTo((T[])array, index);
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            return _dataQueue.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return _dataQueue.GetEnumerator();
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/AppletAccessor.cs

@@ -0,0 +1,60 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class AppletAccessor : IAppletAccessor
+    {
+        [CmifCommand(0)]
+        public Result GetAppletStateChangedEvent(out int arg0)
+        {
+            arg0 = 0;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result IsCompleted(out bool arg0)
+        {
+            arg0 = false;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result Start()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result RequestExit()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(25)]
+        public Result Terminate()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(30)]
+        public Result GetResult()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/AppletCommonFunctions.cs

@@ -0,0 +1,163 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class AppletCommonFunctions : IAppletCommonFunctions
+
+    {
+        [CmifCommand(0)]
+        public Result SetTerminateResult()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result ReadThemeStorage()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result WriteThemeStorage()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result PushToAppletBoundChannel()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(21)]
+        public Result TryPopFromAppletBoundChannel()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(40)]
+        public Result GetDisplayLogicalResolution()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(42)]
+        public Result SetDisplayMagnification()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(50)]
+        public Result SetHomeButtonDoubleClickEnabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(51)]
+        public Result GetHomeButtonDoubleClickEnabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(52)]
+        public Result IsHomeButtonShortPressedBlocked()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(60)]
+        public Result IsVrModeCurtainRequired()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(61)]
+        public Result IsSleepRequiredByHighTemperature()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(62)]
+        public Result IsSleepRequiredByLowBattery()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(70)]
+        public Result SetCpuBoostRequestPriority()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(80)]
+        public Result SetHandlingCaptureButtonShortPressedMessageEnabledForApplet()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(81)]
+        public Result SetHandlingCaptureButtonLongPressedMessageEnabledForApplet()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(90)]
+        public Result OpenNamedChannelAsParent()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(91)]
+        public Result OpenNamedChannelAsChild()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(100)]
+        public Result SetApplicationCoreUsageMode()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/ApplicationAccessor.cs

@@ -0,0 +1,241 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Account;
+using Ryujinx.Horizon.Sdk.Am;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Am.Storage;
+using Ryujinx.Horizon.Sdk.Sf;
+using Ryujinx.Horizon.Sdk.Sf.Hipc;
+using System;
+using ApplicationId = Ryujinx.Horizon.Sdk.Ncm.ApplicationId;
+
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class ApplicationAccessor : IApplicationAccessor
+    {
+        private readonly ApplicationId _applicationId;
+
+        public ApplicationAccessor(ApplicationId applicationId)
+        {
+            _applicationId = applicationId;
+        }
+
+        [CmifCommand(0)]
+        public Result GetAppletStateChangedEvent([CopyHandle] out int arg0)
+        {
+            arg0 = 0;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result IsCompleted(out bool arg0)
+        {
+            arg0 = false;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result Start()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result RequestExit()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(25)]
+        public Result Terminate()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(30)]
+        public Result GetResult()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(101)]
+        public Result RequestForApplicationToGetForeground()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(110)]
+        public Result TerminateAllLibraryApplets()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(111)]
+        public Result AreAnyLibraryAppletsLeft(out bool arg0)
+        {
+            arg0 = false;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(112)]
+        public Result GetCurrentLibraryApplet(out IAppletAccessor arg0)
+        {
+            arg0 = new AppletAccessor();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(120)]
+        public Result GetApplicationId(out ApplicationId arg0)
+        {
+            arg0 = _applicationId;
+
+            return Result.Success;
+        }
+
+        [CmifCommand(121)]
+        public Result PushLaunchParameter(uint arg0, IStorage arg1)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(122)]
+        public Result GetApplicationControlProperty([Buffer(HipcBufferFlags.Out | HipcBufferFlags.AutoSelect)] Span<byte> arg0)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(123)]
+        public Result GetApplicationLaunchProperty([Buffer(HipcBufferFlags.Out | HipcBufferFlags.AutoSelect)] Span<byte> arg0)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(124)]
+        public Result GetApplicationLaunchRequestInfo(out ApplicationLaunchRequestInfo arg0)
+        {
+            arg0 = new ApplicationLaunchRequestInfo();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(130)]
+        public Result SetUsers(bool arg0, ReadOnlySpan<Uid> arg1)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(131)]
+        public Result CheckRightsEnvironmentAvailable(out bool arg0)
+        {
+            arg0 = false;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(132)]
+        public Result GetNsRightsEnvironmentHandle(out ulong arg0)
+        {
+            arg0 = 0;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(140)]
+        public Result GetDesirableUids(out int arg0, [Buffer(HipcBufferFlags.Out | HipcBufferFlags.AutoSelect)] Span<Uid> arg1)
+        {
+            arg0 = 0;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(150)]
+        public Result ReportApplicationExitTimeout()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(160)]
+        public Result SetApplicationAttribute(in ApplicationAttribute arg0)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(170)]
+        public Result HasSaveDataAccessPermission(out bool arg0, ApplicationId arg1)
+        {
+            arg0 = false;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(180)]
+        public Result PushToFriendInvitationStorageChannel(IStorage arg0)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(190)]
+        public Result PushToNotificationStorageChannel(IStorage arg0)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(200)]
+        public Result RequestApplicationSoftReset()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(201)]
+        public Result RestartApplicationTimer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/ApplicationCreator.cs

@@ -0,0 +1,42 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Sf;
+using System;
+using ApplicationId = Ryujinx.Horizon.Sdk.Ncm.ApplicationId;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class ApplicationCreator : IApplicationCreator
+    {
+        [CmifCommand(0)]
+        public Result CreateApplication(out IApplicationAccessor accessor, ApplicationId applicationId)
+        {
+            accessor = new ApplicationAccessor(applicationId);
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result PopLaunchRequestedApplication(out IApplicationAccessor accessor)
+        {
+            throw new NotImplementedException();
+        }
+
+        [CmifCommand(10)]
+        public Result CreateSystemApplication(out IApplicationAccessor accessor, ApplicationId applicationId)
+        {
+            accessor = new ApplicationAccessor(applicationId);
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(100)]
+        public Result PopFloatingApplicationForDevelopment(out IApplicationAccessor accessor)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/ApplicationFunctions.cs

@@ -0,0 +1,506 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class ApplicationFunctions : IApplicationFunctions
+    {
+        [CmifCommand(1)]
+        public Result PopLaunchParameter()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result CreateApplicationAndPushAndRequestToStart()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result CreateApplicationAndPushAndRequestToStartForQuest()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(12)]
+        public Result CreateApplicationAndRequestToStart()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(13)]
+        public Result CreateApplicationAndRequestToStartForQuest()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(14)]
+        public Result CreateApplicationWithAttributeAndPushAndRequestToStartForQuest()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(15)]
+        public Result CreateApplicationWithAttributeAndRequestToStartForQuest()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result EnsureSaveData()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(21)]
+        public Result GetDesiredLanguage()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(22)]
+        public Result SetTerminateResult()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(23)]
+        public Result GetDisplayVersion()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(24)]
+        public Result GetLaunchStorageInfoForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(25)]
+        public Result ExtendSaveData()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(26)]
+        public Result GetSaveDataSize()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(27)]
+        public Result CreateCacheStorage()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(28)]
+        public Result GetSaveDataSizeMax()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(29)]
+        public Result GetCacheStorageMax()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(30)]
+        public Result BeginBlockingHomeButtonShortAndLongPressed()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(31)]
+        public Result EndBlockingHomeButtonShortAndLongPressed()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(32)]
+        public Result BeginBlockingHomeButton()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(33)]
+        public Result EndBlockingHomeButton()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(34)]
+        public Result SelectApplicationLicense()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(35)]
+        public Result GetDeviceSaveDataSizeMax()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(36)]
+        public Result GetLimitedApplicationLicense()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(37)]
+        public Result GetLimitedApplicationLicenseUpgradableEvent()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(40)]
+        public Result NotifyRunning()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(50)]
+        public Result GetPseudoDeviceId()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(60)]
+        public Result SetMediaPlaybackStateForApplication()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(65)]
+        public Result IsGamePlayRecordingSupported()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(66)]
+        public Result InitializeGamePlayRecording()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(67)]
+        public Result SetGamePlayRecordingState()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(68)]
+        public Result RequestFlushGamePlayingMovieForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(70)]
+        public Result RequestToShutdown()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(71)]
+        public Result RequestToReboot()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(72)]
+        public Result RequestToSleep()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(80)]
+        public Result ExitAndRequestToShowThanksMessage()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(90)]
+        public Result EnableApplicationCrashReport()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(100)]
+        public Result InitializeApplicationCopyrightFrameBuffer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(101)]
+        public Result SetApplicationCopyrightImage()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(102)]
+        public Result SetApplicationCopyrightVisibility()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(110)]
+        public Result QueryApplicationPlayStatistics()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(111)]
+        public Result QueryApplicationPlayStatisticsByUid()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(120)]
+        public Result ExecuteProgram()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(121)]
+        public Result ClearUserChannel()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(122)]
+        public Result UnpopToUserChannel()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(123)]
+        public Result GetPreviousProgramIndex()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(124)]
+        public Result EnableApplicationAllThreadDumpOnCrash()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(130)]
+        public Result GetGpuErrorDetectedSystemEvent()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(131)]
+        public Result SetDelayTimeToAbortOnGpuError()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(140)]
+        public Result GetFriendInvitationStorageChannelEvent()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(141)]
+        public Result TryPopFromFriendInvitationStorageChannel()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(150)]
+        public Result GetNotificationStorageChannelEvent()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(151)]
+        public Result TryPopFromNotificationStorageChannel()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(160)]
+        public Result GetHealthWarningDisappearedSystemEvent()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(170)]
+        public Result SetHdcpAuthenticationActivated()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(180)]
+        public Result GetLaunchRequiredVersion()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(181)]
+        public Result UpgradeLaunchRequiredVersion()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(190)]
+        public Result SendServerMaintenanceOverlayNotification()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(200)]
+        public Result GetLastApplicationExitReason()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(500)]
+        public Result StartContinuousRecordingFlushForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1000)]
+        public Result CreateMovieMaker()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1001)]
+        public Result PrepareForJit()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/AudioController.cs

@@ -0,0 +1,54 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class AudioController : IAudioController
+    {
+        private float _mainAppletVolume;
+        private float _libraryAppletVolume;
+
+        [CmifCommand(0)]
+        public Result SetExpectedMasterVolume(float mainAppletVolume, float libraryAppletVolume)
+        {
+            _mainAppletVolume = mainAppletVolume;
+            _libraryAppletVolume = libraryAppletVolume;
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result GetMainAppletExpectedMasterVolume(out float mainAppletVolume)
+        {
+            mainAppletVolume = _mainAppletVolume;
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)]
+        public Result GetLibraryAppletExpectedMasterVolume(out float libraryAppletVolume)
+        {
+            libraryAppletVolume = _libraryAppletVolume;
+
+            return Result.Success;
+        }
+
+        [CmifCommand(3)]
+        public Result ChangeMainAppletMasterVolume(float volume, ulong value)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(4)]
+        public Result SetTransparentVolumeRate(float volume)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/CommonStateGetter.cs

@@ -0,0 +1,434 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class CommonStateGetter : ICommonStateGetter
+    {
+        [CmifCommand(0)]
+        public Result GetEventHandle()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result ReceiveMessage()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)]
+        public Result GetThisAppletKind()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(3)]
+        public Result AllowToEnterSleep()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(4)]
+        public Result DisallowToEnterSleep()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(5)]
+        public Result GetOperationMode()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(6)]
+        public Result GetPerformanceMode()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(7)]
+        public Result GetCradleStatus()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(8)]
+        public Result GetBootMode()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(9)]
+        public Result GetCurrentFocusState()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result RequestToAcquireSleepLock()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result ReleaseSleepLock()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(12)]
+        public Result ReleaseSleepLockTransiently()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(13)]
+        public Result GetAcquiredSleepLockEvent()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(14)]
+        public Result GetWakeupCount()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result PushToGeneralChannel()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(30)]
+        public Result GetHomeButtonReaderLockAccessor()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(31)]
+        public Result GetReaderLockAccessorEx()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(32)]
+        public Result GetWriterLockAccessorEx()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(40)]
+        public Result GetCradleFwVersion()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(50)]
+        public Result IsVrModeEnabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(51)]
+        public Result SetVrModeEnabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(52)]
+        public Result SetLcdBacklightOffEnabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(53)]
+        public Result BeginVrModeEx()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(54)]
+        public Result EndVrModeEx()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(55)]
+        public Result IsInControllerFirmwareUpdateSection()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(59)]
+        public Result SetVrPositionForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(60)]
+        public Result GetDefaultDisplayResolution()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(61)]
+        public Result GetDefaultDisplayResolutionChangeEvent()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(62)]
+        public Result GetHdcpAuthenticationState()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(63)]
+        public Result GetHdcpAuthenticationStateChangeEvent()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(64)]
+        public Result SetTvPowerStateMatchingMode()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(65)]
+        public Result GetApplicationIdByContentActionName()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(66)]
+        public Result SetCpuBoostMode()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(67)]
+        public Result CancelCpuBoostMode()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(68)]
+        public Result GetBuiltInDisplayType()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(80)]
+        public Result PerformSystemButtonPressingIfInFocus()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(90)]
+        public Result SetPerformanceConfigurationChangedNotification()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(91)]
+        public Result GetCurrentPerformanceConfiguration()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(100)]
+        public Result SetHandlingHomeButtonShortPressedEnabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(110)]
+        public Result OpenMyGpuErrorHandler()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(120)]
+        public Result GetAppletLaunchedHistory()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(200)]
+        public Result GetOperationModeSystemInfo()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(300)]
+        public Result GetSettingsPlatformRegion()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(400)]
+        public Result ActivateMigrationService()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(401)]
+        public Result DeactivateMigrationService()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(500)]
+        public Result DisableSleepTillShutdown()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(501)]
+        public Result SuppressDisablingSleepTemporarily()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(502)]
+        public Result IsSleepEnabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(503)]
+        public Result IsDisablingSleepSuppressed()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(600)]
+        public Result OpenNamedChannelAsChild()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(900)]
+        public Result SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(910)]
+        public Result GetLaunchRequiredTick()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/CradleFirmwareUpdater.cs

@@ -0,0 +1,60 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class CradleFirmwareUpdater : ICradleFirmwareUpdater
+    {
+        [CmifCommand(0)]
+        public Result StartUpdate()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result FinishUpdate()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)]
+        public Result GetCradleDeviceInfo(out CradleDeviceInfo arg0)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(3)]
+        public Result GetCradleDeviceInfoChangeEvent(out int arg0)
+        {
+            arg0 = 0;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(4)]
+        public Result GetUpdateProgressInfo(out UpdateProgressInfo arg0)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(5)]
+        public Result GetLastInternalResult()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/DebugFunctions.cs

@@ -0,0 +1,202 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class DebugFunctions : IDebugFunctions
+    {
+        [CmifCommand(0)]
+        public Result NotifyMessageToHomeMenuForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result OpenMainApplication()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result PerformSystemButtonPressing()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result InvalidateTransitionLayer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(30)]
+        public Result RequestLaunchApplicationWithUserAndArgumentForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(31)]
+        public Result RequestLaunchApplicationByApplicationLaunchInfoForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(40)]
+        public Result GetAppletResourceUsageInfo()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(50)]
+        public Result AddSystemProgramIdAndAppletIdForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(51)]
+        public Result AddOperationConfirmedLibraryAppletIdForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(52)]
+        public Result GetProgramIdFromAppletIdForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(100)]
+        public Result SetCpuBoostModeForApplet()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(101)]
+        public Result CancelCpuBoostModeForApplet()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(110)]
+        public Result PushToAppletBoundChannelForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(111)]
+        public Result TryPopFromAppletBoundChannelForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(120)]
+        public Result AlarmSettingNotificationEnableAppEventReserve()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(121)]
+        public Result AlarmSettingNotificationDisableAppEventReserve()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(122)]
+        public Result AlarmSettingNotificationPushAppEventNotify()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(130)]
+        public Result FriendInvitationSetApplicationParameter()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(131)]
+        public Result FriendInvitationClearApplicationParameter()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(132)]
+        public Result FriendInvitationPushApplicationParameter()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(140)]
+        public Result RestrictPowerOperationForSecureLaunchModeForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(200)]
+        public Result CreateFloatingLibraryAppletAccepterForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(300)]
+        public Result TerminateAllRunningApplicationsForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(900)]
+        public Result GetGrcProcessLaunchedSystemEvent()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/DisplayController.cs

@@ -0,0 +1,236 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Sf;
+using Ryujinx.Horizon.Sdk.Sf.Hipc;
+using System;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class DisplayController : IDisplayController
+    {
+        [CmifCommand(0)]
+        public Result GetLastForegroundCaptureImage([Buffer(HipcBufferFlags.Out | HipcBufferFlags.MapAlias)] Span<byte> capture)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result UpdateLastForegroundCaptureImage([Buffer(HipcBufferFlags.Out | HipcBufferFlags.MapAlias)] Span<byte> capture)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)]
+        public Result GetLastApplicationCaptureImage([Buffer(HipcBufferFlags.Out | HipcBufferFlags.MapAlias)] Span<byte> capture)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(3)]
+        public Result GetCallerAppletCaptureImage()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(4)]
+        public Result UpdateCallerAppletCaptureImage()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(5)]
+        public Result GetLastForegroundCaptureImageEx()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(6)]
+        public Result GetLastApplicationCaptureImageEx()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(7)]
+        public Result GetCallerAppletCaptureImageEx()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(8)]
+        public Result TakeScreenShotOfOwnLayer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(9)]
+        public Result CopyBetweenCaptureBuffers()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result AcquireLastApplicationCaptureBuffer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result ReleaseLastApplicationCaptureBuffer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(12)]
+        public Result AcquireLastForegroundCaptureBuffer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(13)]
+        public Result ReleaseLastForegroundCaptureBuffer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(14)]
+        public Result AcquireCallerAppletCaptureBuffer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(15)]
+        public Result ReleaseCallerAppletCaptureBuffer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(16)]
+        public Result AcquireLastApplicationCaptureBufferEx()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(17)]
+        public Result AcquireLastForegroundCaptureBufferEx()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(18)]
+        public Result AcquireCallerAppletCaptureBufferEx()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result ClearCaptureBuffer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(21)]
+        public Result ClearAppletTransitionBuffer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(22)]
+        public Result AcquireLastApplicationCaptureSharedBuffer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(23)]
+        public Result ReleaseLastApplicationCaptureSharedBuffer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(24)]
+        public Result AcquireLastForegroundCaptureSharedBuffer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(25)]
+        public Result ReleaseLastForegroundCaptureSharedBuffer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(26)]
+        public Result AcquireCallerAppletCaptureSharedBuffer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(27)]
+        public Result ReleaseCallerAppletCaptureSharedBuffer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(28)]
+        public Result TakeScreenShotOfOwnLayerEx()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/GlobalStateController.cs

@@ -0,0 +1,125 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class GlobalStateController : IGlobalStateController
+    {
+        [CmifCommand(0)]
+        public Result RequestToEnterSleep()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return AmResult.Stubbed;
+        }
+
+        [CmifCommand(1)]
+        public Result EnterSleep()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return AmResult.Stubbed;
+        }
+
+        [CmifCommand(2)]
+        public Result StartSleepSequence(bool arg0)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(3)]
+        public Result StartShutdownSequence()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(4)]
+        public Result StartRebootSequence()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(9)]
+        public Result IsAutoPowerDownRequested(out bool arg0)
+        {
+            arg0 = false;
+            // Uses #idle:sys cmd1
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result LoadAndApplyIdlePolicySettings()
+        {
+            // Uses #idle:sys cmd LoadAndApplySettings
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result NotifyCecSettingsChanged()
+        {
+            // Uses #omm cmd NotifyCecSettingsChanged
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(12)]
+        public Result SetDefaultHomeButtonLongPressTime(long arg0)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(13)]
+        public Result UpdateDefaultDisplayResolution()
+        {
+            // Uses #omm cmd UpdateDefaultDisplayResolution
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(14)]
+        public Result ShouldSleepOnBoot(out bool arg0)
+        {
+            arg0 = false;
+            // Uses #omm cmd ShouldSleepOnBoot
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(15)]
+        public Result GetHdcpAuthenticationFailedEvent(out int arg0)
+        {
+            arg0 = 0;
+            // Uses #omm cmd GetHdcpAuthenticationFailedEvent
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(30)]
+        public Result OpenCradleFirmwareUpdater(out ICradleFirmwareUpdater arg0)
+        {
+            arg0 = new CradleFirmwareUpdater();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/HomeMenuFunctions.cs

@@ -0,0 +1,143 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Am.Ipc.Storage;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Account;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Am.Storage;
+using Ryujinx.Horizon.Sdk.Sf;
+using Ryujinx.Horizon.Sdk.Sf.Hipc;
+using System;
+using ApplicationId = Ryujinx.Horizon.Sdk.Ncm.ApplicationId;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class HomeMenuFunctions : IHomeMenuFunctions
+    {
+        [CmifCommand(10)]
+        public Result RequestToGetForeground()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result LockForeground()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(12)]
+        public Result UnlockForeground()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result PopFromGeneralChannel(out IStorage arg0)
+        {
+            arg0 = new Storage.Storage([]);
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(21)]
+        public Result GetPopFromGeneralChannelEvent([CopyHandle] out int arg0)
+        {
+            arg0 = 0;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(30)]
+        public Result GetHomeButtonWriterLockAccessor(out ILockAccessor arg0)
+        {
+            arg0 = new LockAccessor();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(31)]
+        public Result GetWriterLockAccessorEx(out ILockAccessor arg0, int arg1)
+        {
+            arg0 = new LockAccessor();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(40)]
+        public Result IsSleepEnabled(out bool arg0)
+        {
+            arg0 = false;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(41)]
+        public Result IsRebootEnabled(out bool arg0)
+        {
+            arg0 = false;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(50)]
+        public Result LaunchSystemApplet()
+        {
+            // Wraps ns LaunchSystemApplet
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(51)]
+        public Result LaunchStarter()
+        {
+            // Wraps ns LaunchLibraryApplet with a ProgramId from global state.
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(100)]
+        public Result PopRequestLaunchApplicationForDebug(out ApplicationId arg0, out int arg1, [Buffer(HipcBufferFlags.Out | HipcBufferFlags.MapAlias)] Span<Uid> arg2)
+        {
+            throw new NotImplementedException();
+        }
+
+        [CmifCommand(110)]
+        public Result IsForceTerminateApplicationDisabledForDebug(out bool arg0)
+        {
+            arg0 = false;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(200)]
+        public Result LaunchDevMenu()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1000)]
+        public Result SetLastApplicationExitReason(int arg0)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/LibraryAppletAccessor.cs

@@ -0,0 +1,204 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Am.Storage;
+using Ryujinx.Horizon.Sdk.OsTypes;
+using Ryujinx.Horizon.Sdk.Sf;
+using System;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class LibraryAppletAccessor : ILibraryAppletAccessor
+    {
+        private readonly AppletSession _normalSession;
+        private readonly AppletSession _interactiveSession;
+
+        private SystemEventType _stateChangedEvent;
+        private SystemEventType _normalOutDataEvent;
+        private SystemEventType _interactiveOutDataEvent;
+
+        public LibraryAppletAccessor(AppletId appletId)
+        {
+            Os.CreateSystemEvent(out _stateChangedEvent, EventClearMode.ManualClear, interProcess: true).AbortOnFailure();
+            Os.CreateSystemEvent(out _normalOutDataEvent, EventClearMode.ManualClear, interProcess: true).AbortOnFailure();
+            Os.CreateSystemEvent(out _interactiveOutDataEvent, EventClearMode.ManualClear, interProcess: true).AbortOnFailure();
+
+            _normalSession = new AppletSession();
+            _interactiveSession = new AppletSession();
+
+            _normalSession.DataAvailable += OnNormalOutData;
+            _interactiveSession.DataAvailable += OnInteractiveOutData;
+        }
+
+        private void OnAppletStateChanged(object sender, EventArgs e)
+        {
+            Os.SignalSystemEvent(ref _stateChangedEvent);
+        }
+
+        private void OnNormalOutData(object sender, EventArgs e)
+        {
+            Os.SignalSystemEvent(ref _normalOutDataEvent);
+        }
+
+        private void OnInteractiveOutData(object sender, EventArgs e)
+        {
+            Os.SignalSystemEvent(ref _interactiveOutDataEvent);
+        }
+
+        [CmifCommand(0)]
+        public Result GetAppletStateChangedEvent([CopyHandle] out int arg0)
+        {
+            arg0 = Os.GetReadableHandleOfSystemEvent(ref _stateChangedEvent);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result IsCompleted(out bool arg0)
+        {
+            arg0 = false;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result Start()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result RequestExit()
+        {
+            Os.SignalSystemEvent(ref _stateChangedEvent);
+
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(25)]
+        public Result Terminate()
+        {
+            throw new System.NotImplementedException();
+        }
+
+        [CmifCommand(30)]
+        public Result GetResult()
+        {
+            throw new System.NotImplementedException();
+        }
+
+        [CmifCommand(50)]
+        public Result SetOutOfFocusApplicationSuspendingEnabled(bool arg0)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        [CmifCommand(60)]
+        public Result PresetLibraryAppletGpuTimeSliceZero()
+        {
+            // NOTE: This call reset two internal fields to 0 and one internal field to "true".
+            //       It seems to be used only with software keyboard inline.
+
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(100)]
+        public Result PushInData(IStorage data)
+        {
+            var storage = new Storage.Storage(data);
+            _normalSession.Push(storage.Data);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(101)]
+        public Result PopOutData(out IStorage data)
+        {
+            if (_interactiveSession.TryPop(out byte[] bytes))
+            {
+                data = new Storage.Storage(bytes);
+
+                return Result.Success;
+            }
+
+            data = new Storage.Storage([]);
+            return AmResult.NotAvailable;
+        }
+
+        [CmifCommand(102)]
+        public Result PushExtraStorage(IStorage data)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        [CmifCommand(103)]
+        public Result PushInteractiveInData(IStorage data)
+        {
+            var storage = new Storage.Storage(data);
+
+            _interactiveSession.Push(storage.Data);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(104)]
+        public Result PopInteractiveOutData(out IStorage arg0)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        [CmifCommand(105)]
+        public Result GetPopOutDataEvent(out int handle)
+        {
+            handle = Os.GetReadableHandleOfSystemEvent(ref _normalOutDataEvent);
+
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(106)]
+        public Result GetPopInteractiveOutDataEvent(out int handle)
+        {
+            handle = Os.GetReadableHandleOfSystemEvent(ref _interactiveOutDataEvent);
+
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(110)]
+        public Result NeedsToExitProcess(out bool arg0)
+        {
+            arg0 = false;
+
+            return AmResult.Stubbed;
+        }
+
+        [CmifCommand(120)]
+        public Result GetLibraryAppletInfo(out LibraryAppletInfo arg0)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        [CmifCommand(150)]
+        public Result RequestForAppletToGetForeground()
+        {
+            return AmResult.Stubbed;
+        }
+
+        [CmifCommand(160)]
+        public Result GetIndirectLayerConsumerHandle(out ulong arg0, ulong arg1, ulong pid)
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/LibraryAppletCreator.cs

@@ -0,0 +1,64 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Am.Storage;
+using Ryujinx.Horizon.Sdk.Sf;
+using System.Linq;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class LibraryAppletCreator : ILibraryAppletCreator
+    {
+        [CmifCommand(0)]
+        public Result CreateLibraryApplet(out ILibraryAppletAccessor libraryAppletAccessor, uint appletId, uint libraryAppletMode)
+        {
+            libraryAppletAccessor = new LibraryAppletAccessor((AppletId)appletId);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result TerminateAllLibraryApplets()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)]
+        public Result AreAnyLibraryAppletsLeft(out bool arg0)
+        {
+            arg0 = true;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result CreateStorage(out IStorage storage, long size)
+        {
+            storage = new Storage.Storage(Enumerable.Repeat((byte)0, (int)size).ToArray());
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result CreateTransferMemoryStorage(out IStorage storage, int handle, long size, bool writeable)
+        {
+            storage = new Storage.Storage(Enumerable.Repeat((byte)0, (int)size).ToArray(), writeable);
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(12)]
+        public Result CreateHandleStorage(out IStorage storage, int handle, long size)
+        {
+            storage = new Storage.Storage(Enumerable.Repeat((byte)0, (int)size).ToArray());
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/LibraryAppletSelfAccessor.cs

@@ -0,0 +1,290 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class LibraryAppletSelfAccessor : ILibraryAppletSelfAccessor
+    {
+        [CmifCommand(0)]
+        public Result PopInData()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result PushOutData()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)]
+        public Result PopInteractiveInData()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(3)]
+        public Result PushInteractiveOutData()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(5)]
+        public Result GetPopInDataEvent()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(6)]
+        public Result GetPopInteractiveInDataEvent()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result ExitProcessAndReturn()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result GetLibraryAppletInfo()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(12)]
+        public Result GetMainAppletIdentityInfo()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(13)]
+        public Result CanUseApplicationCore()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(14)]
+        public Result GetCallerAppletIdentityInfo()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(15)]
+        public Result GetMainAppletApplicationControlProperty()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(16)]
+        public Result GetMainAppletStorageId()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(17)]
+        public Result GetCallerAppletIdentityInfoStack()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(18)]
+        public Result GetNextReturnDestinationAppletIdentityInfo()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(19)]
+        public Result GetDesirableKeyboardLayout()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result PopExtraStorage()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(25)]
+        public Result GetPopExtraStorageEvent()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(30)]
+        public Result UnpopInData()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(31)]
+        public Result UnpopExtraStorage()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(40)]
+        public Result GetIndirectLayerProducerHandle()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(50)]
+        public Result ReportVisibleError()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(51)]
+        public Result ReportVisibleErrorWithErrorContext()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(60)]
+        public Result GetMainAppletApplicationDesiredLanguage()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(70)]
+        public Result GetCurrentApplicationId()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(80)]
+        public Result RequestExitToSelf()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(90)]
+        public Result CreateApplicationAndPushAndRequestToLaunch()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(100)]
+        public Result CreateGameMovieTrimmer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(101)]
+        public Result ReserveResourceForMovieOperation()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(102)]
+        public Result UnreserveResourceForMovieOperation()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(110)]
+        public Result GetMainAppletAvailableUsers()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(120)]
+        public Result GetLaunchStorageInfoForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(130)]
+        public Result GetGpuErrorDetectedSystemEvent()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(140)]
+        public Result SetApplicationMemoryReservation()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(150)]
+        public Result ShouldSetGpuTimeSliceManually()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/OverlayFunctions.cs

@@ -0,0 +1,130 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class OverlayFunctions : IOverlayFunctions
+    {
+        [CmifCommand(0)]
+        public Result BeginToWatchShortHomeButtonMessage()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result EndToWatchShortHomeButtonMessage()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)]
+        public Result GetApplicationIdForLogo()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(3)]
+        public Result SetGpuTimeSliceBoost()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(4)]
+        public Result SetAutoSleepTimeAndDimmingTimeEnabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(5)]
+        public Result TerminateApplicationAndSetReason()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(6)]
+        public Result SetScreenShotPermissionGlobally()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result StartShutdownSequenceForOverlay()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result StartRebootSequenceForOverlay()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result SetHandlingHomeButtonShortPressedEnabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(21)]
+        public Result SetHandlingTouchScreenInputEnabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(30)]
+        public Result SetHealthWarningShowingState()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(31)]
+        public Result IsHealthWarningRequired()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(90)]
+        public Result SetRequiresGpuResourceUse()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(101)]
+        public Result BeginToObserveHidInputForDevelop()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/ProcessWindingController.cs

@@ -0,0 +1,74 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class ProcessWindingController : IProcessWindingController
+    {
+        [CmifCommand(0)]
+        public Result GetLaunchReason()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result OpenCallingLibraryApplet()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(21)]
+        public Result PushContext()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(22)]
+        public Result PopContext()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(23)]
+        public Result CancelWindingReservation()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(30)]
+        public Result WindAndDoReserved()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(40)]
+        public Result ReserveToStartAndWaitAndUnwindThis()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(41)]
+        public Result ReserveToStartAndWait()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/SelfController.cs

@@ -0,0 +1,395 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class SelfController : ISelfController
+    {
+        [CmifCommand(0)]
+        public Result Exit()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result LockExit()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)]
+        public Result UnlockExit()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(3)]
+        public Result EnterFatalSection()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(4)]
+        public Result LeaveFatalSection()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(9)]
+        public Result GetLibraryAppletLaunchableEvent(out int arg0)
+        {
+            arg0 = 0;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result SetScreenShotPermission(int arg0)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result SetOperationModeChangedNotification(bool arg0)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(12)]
+        public Result SetPerformanceModeChangedNotification(bool arg0)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(13)]
+        public Result SetFocusHandlingMode()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(14)]
+        public Result SetRestartMessageEnabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(15)]
+        public Result SetScreenShotAppletIdentityInfo()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(16)]
+        public Result SetOutOfFocusSuspendingEnabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(17)]
+        public Result SetControllerFirmwareUpdateSection()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(18)]
+        public Result SetRequiresCaptureButtonShortPressedMessage()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(19)]
+        public Result SetAlbumImageOrientation()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result SetDesirableKeyboardLayout()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(21)]
+        public Result GetScreenShotProgramId()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(40)]
+        public Result CreateManagedDisplayLayer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(41)]
+        public Result IsSystemBufferSharingEnabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(42)]
+        public Result GetSystemSharedLayerHandle()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(43)]
+        public Result GetSystemSharedBufferHandle()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(44)]
+        public Result CreateManagedDisplaySeparableLayer()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(45)]
+        public Result SetManagedDisplayLayerSeparationMode()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(46)]
+        public Result SetRecordingLayerCompositionEnabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(50)]
+        public Result SetHandlesRequestToDisplay()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(51)]
+        public Result ApproveToDisplay()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(60)]
+        public Result OverrideAutoSleepTimeAndDimmingTime()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(61)]
+        public Result SetMediaPlaybackState()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(62)]
+        public Result SetIdleTimeDetectionExtension()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(63)]
+        public Result GetIdleTimeDetectionExtension()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(64)]
+        public Result SetInputDetectionSourceSet()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(65)]
+        public Result ReportUserIsActive()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(66)]
+        public Result GetCurrentIlluminance()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(67)]
+        public Result IsIlluminanceAvailable()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(68)]
+        public Result SetAutoSleepDisabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(69)]
+        public Result IsAutoSleepDisabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(70)]
+        public Result ReportMultimediaError()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(71)]
+        public Result GetCurrentIlluminanceEx()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(72)]
+        public Result SetInputDetectionPolicy()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(80)]
+        public Result SetWirelessPriorityMode()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(90)]
+        public Result GetAccumulatedSuspendedTickValue()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(91)]
+        public Result GetAccumulatedSuspendedTickChangedEvent()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(100)]
+        public Result SetAlbumImageTakenNotificationEnabled()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(110)]
+        public Result SetApplicationAlbumUserData()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(120)]
+        public Result SaveCurrentScreenshot()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(130)]
+        public Result SetRecordVolumeMuted()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1000)]
+        public Result GetDebugStorageChannel()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/SystemAppletControllerForDebug.cs

@@ -0,0 +1,42 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class SystemAppletControllerForDebug : ISystemAppletControllerForDebug
+    {
+        [CmifCommand(1)]
+        public Result RequestLaunchApplicationForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)]
+        public Result GetDebugStorageChannel()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(3)]
+        public Result CreateStorageForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(4)]
+        public Result CreateCradleFirmwareUpdaterForDebug()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Controllers/WindowController.cs

@@ -0,0 +1,74 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Controllers
+{
+    partial class WindowController : IWindowController
+    {
+        [CmifCommand(0)]
+        public Result CreateWindow()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result GetAppletResourceUserId()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)]
+        public Result GetAppletResourceUserIdOfCallerApplet()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result AcquireForegroundRights()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result ReleaseForegroundRights()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(12)]
+        public Result RejectToChangeIntoBackground()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result SetAppletWindowVisibility(bool visibility)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(21)]
+        public Result SetAppletGpuTimeSlice(long gpuTime)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Proxies/ApplicationProxy.cs

@@ -0,0 +1,83 @@
+using Ryujinx.Horizon.Am.Ipc.Controllers;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Am.Proxies;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Proxies
+{
+    partial class ApplicationProxy : IApplicationProxy
+    {
+        [CmifCommand(0)]
+        public Result GetCommonStateGetter(out ICommonStateGetter commonStateGetter)
+        {
+            commonStateGetter = new CommonStateGetter();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result GetSelfController(out ISelfController selfController)
+        {
+            selfController = new SelfController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)]
+        public Result GetWindowController(out IWindowController windowController)
+        {
+            windowController = new WindowController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(3)]
+        public Result GetAudioController(out IAudioController audioController)
+        {
+            audioController = new AudioController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(4)]
+        public Result GetDisplayController(out IDisplayController displayController)
+        {
+            displayController = new DisplayController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result GetProcessWindingController(out IProcessWindingController processWindingController)
+        {
+            processWindingController = new ProcessWindingController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result GetLibraryAppletCreator(out ILibraryAppletCreator libraryAppletCreator)
+        {
+            libraryAppletCreator = new LibraryAppletCreator();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result GetApplicationFunctions(out IApplicationFunctions applicationFunctions)
+        {
+            applicationFunctions = new ApplicationFunctions();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1000)]
+        public Result GetDebugFunctions(out IDebugFunctions debugFunctions)
+        {
+            debugFunctions = new DebugFunctions();
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Proxies/LibraryAppletProxy.cs

@@ -0,0 +1,107 @@
+using Ryujinx.Horizon.Am.Ipc.Controllers;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Am.Proxies;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Proxies
+{
+    partial class LibraryAppletProxy : ILibraryAppletProxy
+    {
+        [CmifCommand(0)]
+        public Result GetCommonStateGetter(out ICommonStateGetter commonStateGetter)
+        {
+            commonStateGetter = new CommonStateGetter();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result GetSelfController(out ISelfController selfController)
+        {
+            selfController = new SelfController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)]
+        public Result GetWindowController(out IWindowController windowController)
+        {
+            windowController = new WindowController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(3)]
+        public Result GetAudioController(out IAudioController audioController)
+        {
+            audioController = new AudioController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(4)]
+        public Result GetDisplayController(out IDisplayController displayController)
+        {
+            displayController = new DisplayController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result GetProcessWindingController(out IProcessWindingController processWindingController)
+        {
+            processWindingController = new ProcessWindingController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result GetLibraryAppletCreator(out ILibraryAppletCreator libraryAppletCreator)
+        {
+            libraryAppletCreator = new LibraryAppletCreator();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result OpenLibraryAppletSelfAccessor(out ILibraryAppletSelfAccessor libraryAppletSelfAccessor)
+        {
+            libraryAppletSelfAccessor = new LibraryAppletSelfAccessor();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(21)]
+        public Result GetAppletCommonFunctions(out IAppletCommonFunctions appletCommonFunctions)
+        {
+            appletCommonFunctions = new AppletCommonFunctions();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(22)]
+        public Result GetHomeMenuFunctions(out IHomeMenuFunctions homeMenuFunctions)
+        {
+            homeMenuFunctions = new HomeMenuFunctions();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(23)]
+        public Result GetGlobalStateController(out IGlobalStateController globalStateController)
+        {
+            globalStateController = new GlobalStateController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1000)]
+        public Result GetDebugFunctions(out IDebugFunctions debugFunctions)
+        {
+            debugFunctions = new DebugFunctions();
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Proxies/OverlayAppletProxy.cs

@@ -0,0 +1,99 @@
+using Ryujinx.Horizon.Am.Ipc.Controllers;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Am.Proxies;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Proxies
+{
+    partial class OverlayAppletProxy : IOverlayAppletProxy
+    {
+        [CmifCommand(0)]
+        public Result GetCommonStateGetter(out ICommonStateGetter commonStateGetter)
+        {
+            commonStateGetter = new CommonStateGetter();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result GetSelfController(out ISelfController selfController)
+        {
+            selfController = new SelfController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)]
+        public Result GetWindowController(out IWindowController windowController)
+        {
+            windowController = new WindowController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(3)]
+        public Result GetAudioController(out IAudioController audioController)
+        {
+            audioController = new AudioController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(4)]
+        public Result GetDisplayController(out IDisplayController displayController)
+        {
+            displayController = new DisplayController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result GetProcessWindingController(out IProcessWindingController processWindingController)
+        {
+            processWindingController = new ProcessWindingController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result GetLibraryAppletCreator(out ILibraryAppletCreator libraryAppletCreator)
+        {
+            libraryAppletCreator = new LibraryAppletCreator();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result GetOverlayFunctions(out IOverlayFunctions overlayFunctions)
+        {
+            overlayFunctions = new OverlayFunctions();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(21)]
+        public Result GetAppletCommonFunctions(out IAppletCommonFunctions appletCommonFunctions)
+        {
+            appletCommonFunctions = new AppletCommonFunctions();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(23)]
+        public Result GetGlobalStateController(out IGlobalStateController globalStateController)
+        {
+            globalStateController = new GlobalStateController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1000)]
+        public Result GetDebugFunctions(out IDebugFunctions debugFunctions)
+        {
+            debugFunctions = new DebugFunctions();
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Proxies/SystemAppletProxy.cs

@@ -0,0 +1,107 @@
+using Ryujinx.Horizon.Am.Ipc.Controllers;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Am.Proxies;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Proxies
+{
+    partial class SystemAppletProxy : ISystemAppletProxy
+    {
+        [CmifCommand(0)]
+        public Result GetCommonStateGetter(out ICommonStateGetter commonStateGetter)
+        {
+            commonStateGetter = new CommonStateGetter();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result GetSelfController(out ISelfController selfController)
+        {
+            selfController = new SelfController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)]
+        public Result GetWindowController(out IWindowController windowController)
+        {
+            windowController = new WindowController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(3)]
+        public Result GetAudioController(out IAudioController audioController)
+        {
+            audioController = new AudioController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(4)]
+        public Result GetDisplayController(out IDisplayController displayController)
+        {
+            displayController = new DisplayController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result GetProcessWindingController(out IProcessWindingController processWindingController)
+        {
+            processWindingController = new ProcessWindingController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result GetLibraryAppletCreator(out ILibraryAppletCreator libraryAppletCreator)
+        {
+            libraryAppletCreator = new LibraryAppletCreator();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(20)]
+        public Result GetHomeMenuFunctions(out IHomeMenuFunctions homeMenuFunctions)
+        {
+            homeMenuFunctions = new HomeMenuFunctions();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(21)]
+        public Result GetGlobalStateController(out IGlobalStateController globalStateController)
+        {
+            globalStateController = new GlobalStateController();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(22)]
+        public Result GetApplicationCreator(out IApplicationCreator applicationCreator)
+        {
+            applicationCreator = new ApplicationCreator();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(23)]
+        public Result GetAppletCommonFunctions(out IAppletCommonFunctions appletCommonFunctions)
+        {
+            appletCommonFunctions = new AppletCommonFunctions();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1000)]
+        public Result GetDebugFunctions(out IDebugFunctions debugFunctions)
+        {
+            debugFunctions = new DebugFunctions();
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/ProxiesService.cs

@@ -0,0 +1,78 @@
+using Ryujinx.Horizon.Am.Ipc.Controllers;
+using Ryujinx.Horizon.Am.Ipc.Proxies;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Controllers;
+using Ryujinx.Horizon.Sdk.Am.Proxies;
+using Ryujinx.Horizon.Sdk.Sf;
+using Ryujinx.Horizon.Sdk.Sf.Hipc;
+using System;
+
+namespace Ryujinx.Horizon.Am.Ipc
+{
+    partial class ProxiesService : IAllSystemAppletProxiesService
+    {
+        [CmifCommand(100)]
+        public Result OpenSystemAppletProxy(out ISystemAppletProxy systemAppletProxy, ulong unknown1, [CopyHandle] int unknown2, [ClientProcessId] ulong pid)
+        {
+            systemAppletProxy = new SystemAppletProxy();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(200)]
+        public Result OpenLibraryAppletProxyOld(out ILibraryAppletProxy libraryAppletProxy, ulong unknown1, [CopyHandle] int unknown2, [ClientProcessId] ulong pid)
+        {
+            OpenLibraryAppletProxy(out libraryAppletProxy, unknown1, unknown2, new byte[0x80], pid);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(201)]
+        public Result OpenLibraryAppletProxy(out ILibraryAppletProxy libraryAppletProxy, ulong unknown1, [CopyHandle] int unknown2, [Buffer(HipcBufferFlags.In | HipcBufferFlags.MapAlias, 0x80)] ReadOnlySpan<byte> appletAttribute, [ClientProcessId] ulong pid)
+        {
+            libraryAppletProxy = new LibraryAppletProxy();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(300)]
+        public Result OpenOverlayAppletProxy(out IOverlayAppletProxy overlayAppletProxy, ulong unknown1, [CopyHandle] int unknown2, [ClientProcessId] ulong pid)
+        {
+            overlayAppletProxy = new OverlayAppletProxy();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(350)]
+        public Result OpenSystemApplicationProxy(out IApplicationProxy applicationProxy, ulong unknown1, [CopyHandle] int unknown2, [ClientProcessId] ulong pid)
+        {
+            applicationProxy = new ApplicationProxy();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(400)]
+        public Result CreateSelfLibraryAppletCreatorForDevelop(out ILibraryAppletCreator libraryAppletCreator, ulong unknown, [ClientProcessId] ulong pid)
+        {
+            libraryAppletCreator = new LibraryAppletCreator();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(410)]
+        public Result GetSystemAppletControllerForDebug(out ISystemAppletControllerForDebug systemAppletControllerForDebug)
+        {
+            systemAppletControllerForDebug = new SystemAppletControllerForDebug();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1000)]
+        public Result GetDebugFunctions(out IDebugFunctions debugFunctions)
+        {
+            debugFunctions = new DebugFunctions();
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Storage/LockAccessor.cs

@@ -0,0 +1,46 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Storage;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Storage
+{
+    partial class LockAccessor : ILockAccessor
+    {
+        [CmifCommand(1)]
+        public Result TryLock(out bool arg0, out int handle, bool arg2)
+        {
+            arg0 = false;
+            handle = 0;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)]
+        public Result Unlock()
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(3)]
+        public Result GetEvent(out int handle)
+        {
+            handle = 0;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(4)]
+        public Result IsLocked(out bool arg0)
+        {
+            arg0 = false;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Storage/Storage.cs

@@ -0,0 +1,40 @@
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Storage;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Storage
+{
+    partial class Storage : IStorage
+    {
+        public bool IsReadOnly { get; private set; }
+        public byte[] Data { get; private set; }
+
+        public Storage(byte[] data, bool isReadOnly = false)
+        {
+            IsReadOnly = isReadOnly;
+            Data = data;
+        }
+
+        // TODO: Something for this...
+        public Storage(IStorage handle)
+        {
+
+        }
+
+        [CmifCommand(0)]
+        public Result Open(out IStorageAccessor storageAccessor)
+        {
+            storageAccessor = new StorageAccessor(this);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result OpenTransferStorage(out ITransferStorageAccessor transferStorageAccessor)
+        {
+            transferStorageAccessor = new TransferStorageAccessor(this);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Storage/StorageAccessor.cs

@@ -0,0 +1,58 @@
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am;
+using Ryujinx.Horizon.Sdk.Am.Storage;
+using Ryujinx.Horizon.Sdk.Sf;
+using Ryujinx.Horizon.Sdk.Sf.Hipc;
+using System;
+
+namespace Ryujinx.Horizon.Am.Ipc.Storage
+{
+    partial class StorageAccessor : IStorageAccessor
+    {
+        private readonly Storage _storage;
+
+        public StorageAccessor(Storage storage)
+        {
+            _storage = storage;
+        }
+
+        [CmifCommand(0)]
+        public Result GetSize(out long size)
+        {
+            size = _storage.Data.Length;
+
+            return Result.Success;
+        }
+
+        [CmifCommand(10)]
+        public Result Write(long offset, [Buffer(HipcBufferFlags.In | HipcBufferFlags.AutoSelect)] ReadOnlySpan<byte> span)
+        {
+            if (_storage.IsReadOnly)
+            {
+                return AmResult.ObjectInvalid;
+            }
+
+            if (offset > _storage.Data.Length)
+            {
+                return AmResult.OutOfBounds;
+            }
+
+            // TODO: Write
+
+            return Result.Success;
+        }
+
+        [CmifCommand(11)]
+        public Result Read(long offset, [Buffer(HipcBufferFlags.Out | HipcBufferFlags.AutoSelect)] Span<byte> span)
+        {
+            if (offset > _storage.Data.Length)
+            {
+                return AmResult.OutOfBounds;
+            }
+
+            // TODO: Read
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Storage/StorageChannel.cs

@@ -0,0 +1,60 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Storage;
+using Ryujinx.Horizon.Sdk.Sf;
+using System.Collections.Generic;
+
+namespace Ryujinx.Horizon.Am.Ipc.Storage
+{
+    // Might not be used outside of debug software
+    partial class StorageChannel : IStorageChannel
+    {
+        private readonly Stack<IStorage> _storages;
+
+        public StorageChannel()
+        {
+            _storages = new Stack<IStorage>();
+        }
+
+        [CmifCommand(0)]
+        public Result Push(IStorage storage)
+        {
+            _storages.Push(storage);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result Unpop(IStorage storage)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)]
+        public Result Pop(out IStorage storage)
+        {
+            storage = _storages.Pop();
+
+            return Result.Success;
+        }
+
+        [CmifCommand(3)]
+        public Result GetPopEventHandle([CopyHandle] out int handle)
+        {
+            handle = 0;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(4)]
+        public Result Clear()
+        {
+            _storages.Clear();
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Am/Ipc/Storage/StorageHelper.cs

@@ -1,14 +1,14 @@
+using LibHac.Fs;
 using Ryujinx.Common.Memory;
-using Ryujinx.HLE.HOS.Services.Account.Acc;
 using System.IO;
 
-namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.Storage
+namespace Ryujinx.Horizon.Am.Ipc.Storage
 {
-    class StorageHelper
+    public class StorageHelper
     {
         private const uint LaunchParamsMagic = 0xc79497ca;
 
-        public static byte[] MakeLaunchParams(UserProfile userProfile)
+        public static byte[] MakeLaunchParams(UserId userId)
         {
             // Size needs to be at least 0x88 bytes otherwise application errors.
             using MemoryStream ms = MemoryStreamManager.Shared.GetStream();
@@ -18,7 +18,7 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.Storage
 
             writer.Write(LaunchParamsMagic);
             writer.Write(1);  // IsAccountSelected? Only lower 8 bits actually used.
-            userProfile.UserId.Write(writer);
+            writer.Write(userId.AsBytes());
 
             return ms.ToArray();
         }

src/Ryujinx.Horizon/Am/Ipc/Storage/TransferStorageAccessor.cs

@@ -0,0 +1,35 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am.Storage;
+using Ryujinx.Horizon.Sdk.Sf;
+
+namespace Ryujinx.Horizon.Am.Ipc.Storage
+{
+    partial class TransferStorageAccessor : ITransferStorageAccessor
+    {
+        private readonly Storage _storage;
+
+        public TransferStorageAccessor(Storage storage)
+        {
+            _storage = storage;
+        }
+
+        [CmifCommand(0)]
+        public Result GetSize(out long size)
+        {
+            size = _storage.Data.Length;
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result GetHandle([CopyHandle] out int handle, out ulong size)
+        {
+            handle = 0;
+            size = 0;
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
+        }
+    }
+}

src/Ryujinx.Horizon/Applets/AppletManager.cs

@@ -1,10 +1,13 @@
-using Ryujinx.HLE.HOS.Applets.Browser;
-using Ryujinx.HLE.HOS.Applets.Error;
-using Ryujinx.HLE.HOS.Services.Am.AppletAE;
+using Ryujinx.Horizon.Applets.Browser;
+using Ryujinx.Horizon.Applets.Controller;
+using Ryujinx.Horizon.Applets.PlayerSelect;
+using Ryujinx.Horizon.Applets.SoftwareKeyboard;
+using Ryujinx.Horizon.Sdk.Am;
 using System;
 using System.Collections.Generic;
+using ErrorApplet = Ryujinx.Horizon.Applets.Error.ErrorApplet;
 
-namespace Ryujinx.HLE.HOS.Applets
+namespace Ryujinx.Horizon.Applets
 {
     static class AppletManager
     {
@@ -17,18 +20,18 @@ namespace Ryujinx.HLE.HOS.Applets
                 { AppletId.Error,            typeof(ErrorApplet)            },
                 { AppletId.PlayerSelect,     typeof(PlayerSelectApplet)     },
                 { AppletId.Controller,       typeof(ControllerApplet)       },
-                { AppletId.SoftwareKeyboard, typeof(SoftwareKeyboardApplet) },
-                { AppletId.LibAppletWeb,     typeof(BrowserApplet)          },
-                { AppletId.LibAppletShop,    typeof(BrowserApplet)          },
-                { AppletId.LibAppletOff,     typeof(BrowserApplet)          },
+                { AppletId.Swkbd,            typeof(SoftwareKeyboardApplet) },
+                { AppletId.Web,              typeof(BrowserApplet)          },
+                { AppletId.Shop,             typeof(BrowserApplet)          },
+                { AppletId.OfflineWeb,       typeof(BrowserApplet)          },
             };
         }
 
-        public static IApplet Create(AppletId applet, Horizon system)
+        public static IApplet Create(AppletId applet)
         {
             if (_appletMapping.TryGetValue(applet, out Type appletClass))
             {
-                return (IApplet)Activator.CreateInstance(appletClass, system);
+                return (IApplet)Activator.CreateInstance(appletClass);
             }
 
             throw new NotImplementedException($"{applet} applet is not implemented.");

src/Ryujinx.Horizon/Applets/Browser/BootDisplayKind.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.Browser
+namespace Ryujinx.Horizon.Applets.Browser
 {
     enum BootDisplayKind
     {

src/Ryujinx.Horizon/Applets/Browser/BrowserApplet.cs

@@ -1,12 +1,13 @@
 using Ryujinx.Common;
 using Ryujinx.Common.Logging;
 using Ryujinx.Common.Memory;
-using Ryujinx.HLE.HOS.Services.Am.AppletAE;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am;
 using System;
 using System.Collections.Generic;
 using System.IO;
 
-namespace Ryujinx.HLE.HOS.Applets.Browser
+namespace Ryujinx.Horizon.Applets.Browser
 {
     internal class BrowserApplet : IApplet
     {
@@ -18,14 +19,12 @@ namespace Ryujinx.HLE.HOS.Applets.Browser
         private List<BrowserArgument> _arguments;
         private ShimKind _shimKind;
 
-        public BrowserApplet(Horizon system) { }
-
-        public ResultCode GetResult()
+        public Result GetResult()
         {
-            return ResultCode.Success;
+            return Result.Success;
         }
 
-        public ResultCode Start(AppletSession normalSession, AppletSession interactiveSession)
+        public Result Start(AppletSession normalSession, AppletSession interactiveSession)
         {
             _normalSession = normalSession;
 
@@ -65,7 +64,7 @@ namespace Ryujinx.HLE.HOS.Applets.Browser
 
             AppletStateChanged?.Invoke(this, null);
 
-            return ResultCode.Success;
+            return Result.Success;
         }
 
         private static byte[] BuildResponseOld(WebCommonReturnValue result)

src/Ryujinx.Horizon/Applets/Browser/BrowserArgument.cs

@@ -1,10 +1,10 @@
-using Ryujinx.HLE.HOS.Services.Account.Acc;
+using LibHac.Fs;
 using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Text;
 
-namespace Ryujinx.HLE.HOS.Applets.Browser
+namespace Ryujinx.Horizon.Applets.Browser
 {
     class BrowserArgument
     {

src/Ryujinx.Horizon/Applets/Browser/BrowserOutput.cs

@@ -2,7 +2,7 @@ using Ryujinx.Common;
 using System;
 using System.IO;
 
-namespace Ryujinx.HLE.HOS.Applets.Browser
+namespace Ryujinx.Horizon.Applets.Browser
 {
     class BrowserOutput
     {

src/Ryujinx.Horizon/Applets/Browser/BrowserOutputType.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.Browser
+namespace Ryujinx.Horizon.Applets.Browser
 {
     enum BrowserOutputType : ushort
     {

src/Ryujinx.Horizon/Applets/Browser/DocumentKind.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.Browser
+namespace Ryujinx.Horizon.Applets.Browser
 {
     enum DocumentKind
     {

src/Ryujinx.Horizon/Applets/Browser/LeftStickMode.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.Browser
+namespace Ryujinx.Horizon.Applets.Browser
 {
     enum LeftStickMode
     {

src/Ryujinx.Horizon/Applets/Browser/ShimKind.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.Browser
+namespace Ryujinx.Horizon.Applets.Browser
 {
     public enum ShimKind : uint
     {

src/Ryujinx.Horizon/Applets/Browser/WebArgHeader.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.Browser
+namespace Ryujinx.Horizon.Applets.Browser
 {
     public struct WebArgHeader
     {

src/Ryujinx.Horizon/Applets/Browser/WebArgTLV.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.Browser
+namespace Ryujinx.Horizon.Applets.Browser
 {
     public struct WebArgTLV
     {

src/Ryujinx.Horizon/Applets/Browser/WebArgTLVType.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.Browser
+namespace Ryujinx.Horizon.Applets.Browser
 {
     enum WebArgTLVType : ushort
     {

src/Ryujinx.Horizon/Applets/Browser/WebCommonReturnValue.cs

@@ -1,6 +1,6 @@
 using Ryujinx.Common.Memory;
 
-namespace Ryujinx.HLE.HOS.Applets.Browser
+namespace Ryujinx.Horizon.Applets.Browser
 {
     public struct WebCommonReturnValue
     {

src/Ryujinx.Horizon/Applets/Browser/WebExitReason.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.Browser
+namespace Ryujinx.Horizon.Applets.Browser
 {
     public enum WebExitReason : uint
     {

src/Ryujinx.Horizon/Applets/CommonArguments.cs

@@ -1,6 +1,6 @@
 using System.Runtime.InteropServices;
 
-namespace Ryujinx.HLE.HOS.Applets
+namespace Ryujinx.Horizon.Applets
 {
     [StructLayout(LayoutKind.Sequential, Pack = 8)]
     struct CommonArguments

src/Ryujinx.Horizon/Applets/Controller/ControllerApplet.cs

@@ -1,30 +1,23 @@
+using Ryujinx.Audio;
+using Ryujinx.Common.Configuration.Hid;
 using Ryujinx.Common.Logging;
 using Ryujinx.Common.Memory;
-using Ryujinx.HLE.HOS.Services.Am.AppletAE;
-using Ryujinx.HLE.HOS.Services.Hid;
-using Ryujinx.HLE.HOS.Services.Hid.Types;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am;
 using System;
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using static Ryujinx.HLE.HOS.Services.Hid.HidServer.HidUtils;
 
-namespace Ryujinx.HLE.HOS.Applets
+namespace Ryujinx.Horizon.Applets.Controller
 {
     internal class ControllerApplet : IApplet
     {
-        private readonly Horizon _system;
-
         private AppletSession _normalSession;
 
         public event EventHandler AppletStateChanged;
 
-        public ControllerApplet(Horizon system)
-        {
-            _system = system;
-        }
-
-        public ResultCode Start(AppletSession normalSession, AppletSession interactiveSession)
+        public Result Start(AppletSession normalSession, AppletSession interactiveSession)
         {
             _normalSession = normalSession;
 
@@ -40,7 +33,7 @@ namespace Ryujinx.HLE.HOS.Applets
                 _normalSession.Push(BuildResponse()); // Dummy response for other modes
                 AppletStateChanged?.Invoke(this, null);
 
-                return ResultCode.Success;
+                return Result.Success;
             }
 
             byte[] controllerSupportArg = _normalSession.Pop();
@@ -114,12 +107,12 @@ namespace Ryujinx.HLE.HOS.Applets
 
             _system.ReturnFocus();
 
-            return ResultCode.Success;
+            return Result.Success;
         }
 
-        public ResultCode GetResult()
+        public Result GetResult()
         {
-            return ResultCode.Success;
+            return Result.Success;
         }
 
         private static byte[] BuildResponse(ControllerSupportResultInfo result)

src/Ryujinx.Horizon/Applets/Controller/ControllerAppletUIArgs.cs

@@ -1,7 +1,6 @@
-using Ryujinx.HLE.HOS.Services.Hid;
 using System.Collections.Generic;
 
-namespace Ryujinx.HLE.HOS.Applets
+namespace Ryujinx.Horizon.Applets.Controller
 {
     public struct ControllerAppletUIArgs
     {

src/Ryujinx.Horizon/Applets/Controller/ControllerSupportArgHeader.cs

@@ -1,6 +1,6 @@
 using System.Runtime.InteropServices;
 
-namespace Ryujinx.HLE.HOS.Applets
+namespace Ryujinx.Horizon.Applets.Controller
 {
 #pragma warning disable CS0649 // Field is never assigned to
     [StructLayout(LayoutKind.Sequential, Pack = 1)]

src/Ryujinx.Horizon/Applets/Controller/ControllerSupportArgPrivate.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets
+namespace Ryujinx.Horizon.Applets.Controller
 {
 #pragma warning disable CS0649 // Field is never assigned to
     struct ControllerSupportArgPrivate

src/Ryujinx.Horizon/Applets/Controller/ControllerSupportArgV7.cs

@@ -2,7 +2,7 @@ using Ryujinx.Common.Memory;
 using System;
 using System.Runtime.InteropServices;
 
-namespace Ryujinx.HLE.HOS.Applets
+namespace Ryujinx.Horizon.Applets.Controller
 {
 #pragma warning disable CS0649 // Field is never assigned to
     // (8.0.0+ version)

src/Ryujinx.Horizon/Applets/Controller/ControllerSupportArgVPre7.cs

@@ -2,7 +2,7 @@ using Ryujinx.Common.Memory;
 using System;
 using System.Runtime.InteropServices;
 
-namespace Ryujinx.HLE.HOS.Applets
+namespace Ryujinx.Horizon.Applets.Controller
 {
 #pragma warning disable CS0649 // Field is never assigned to
     // (1.0.0+ version)

src/Ryujinx.Horizon/Applets/Controller/ControllerSupportMode.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets
+namespace Ryujinx.Horizon.Applets.Controller
 {
     enum ControllerSupportMode : byte
     {

src/Ryujinx.Horizon/Applets/Controller/ControllerSupportResultInfo.cs

@@ -1,7 +1,7 @@
 using Ryujinx.Common.Memory;
 using System.Runtime.InteropServices;
 
-namespace Ryujinx.HLE.HOS.Applets
+namespace Ryujinx.Horizon.Applets.Controller
 {
 #pragma warning disable CS0649 // Field is never assigned to
     [StructLayout(LayoutKind.Sequential, Pack = 1)]

src/Ryujinx.Horizon/Applets/Error/ApplicationErrorArg.cs

@@ -1,7 +1,7 @@
 using Ryujinx.Common.Memory;
 using System.Runtime.InteropServices;
 
-namespace Ryujinx.HLE.HOS.Applets.Error
+namespace Ryujinx.Horizon.Applets.Error
 {
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
     struct ApplicationErrorArg

src/Ryujinx.Horizon/Applets/Error/ErrorApplet.cs

@@ -6,8 +6,8 @@ using LibHac.Ncm;
 using LibHac.Tools.FsSystem;
 using LibHac.Tools.FsSystem.NcaUtils;
 using Ryujinx.Common.Logging;
-using Ryujinx.HLE.HOS.Services.Am.AppletAE;
-using Ryujinx.HLE.HOS.SystemState;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -16,7 +16,7 @@ using System.Runtime.InteropServices;
 using System.Text;
 using System.Text.RegularExpressions;
 
-namespace Ryujinx.HLE.HOS.Applets.Error
+namespace Ryujinx.Horizon.Applets.Error
 {
     internal partial class ErrorApplet : IApplet
     {
@@ -38,7 +38,7 @@ namespace Ryujinx.HLE.HOS.Applets.Error
             _horizon = horizon;
         }
 
-        public ResultCode Start(AppletSession normalSession, AppletSession interactiveSession)
+        public Result Start(AppletSession normalSession, AppletSession interactiveSession)
         {
             _normalSession = normalSession;
             _commonArguments = IApplet.ReadStruct<CommonArguments>(_normalSession.Pop());
@@ -69,7 +69,7 @@ namespace Ryujinx.HLE.HOS.Applets.Error
 
             AppletStateChanged?.Invoke(this, null);
 
-            return ResultCode.Success;
+            return Result.Success;
         }
 
         private static (uint module, uint description) HexToResultCode(uint resultCode)
@@ -209,9 +209,9 @@ namespace Ryujinx.HLE.HOS.Applets.Error
             }
         }
 
-        public ResultCode GetResult()
+        public Result GetResult()
         {
-            return ResultCode.Success;
+            return Result.Success;
         }
     }
 }

src/Ryujinx.Horizon/Applets/Error/ErrorCommonArg.cs

@@ -1,6 +1,6 @@
 using System.Runtime.InteropServices;
 
-namespace Ryujinx.HLE.HOS.Applets.Error
+namespace Ryujinx.Horizon.Applets.Error
 {
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
     struct ErrorCommonArg

src/Ryujinx.Horizon/Applets/Error/ErrorCommonHeader.cs

@@ -1,6 +1,6 @@
 using System.Runtime.InteropServices;
 
-namespace Ryujinx.HLE.HOS.Applets.Error
+namespace Ryujinx.Horizon.Applets.Error
 {
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
     struct ErrorCommonHeader

src/Ryujinx.Horizon/Applets/Error/ErrorType.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.Error
+namespace Ryujinx.Horizon.Applets.Error
 {
     enum ErrorType : byte
     {

src/Ryujinx.Horizon/Applets/IApplet.cs

@@ -1,19 +1,19 @@
-using Ryujinx.HLE.HOS.Services.Am.AppletAE;
-using Ryujinx.HLE.UI;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am;
 using Ryujinx.Memory;
 using System;
 using System.Runtime.InteropServices;
 
-namespace Ryujinx.HLE.HOS.Applets
+namespace Ryujinx.Horizon.Applets
 {
-    interface IApplet
+    public interface IApplet
     {
         event EventHandler AppletStateChanged;
 
-        ResultCode Start(AppletSession normalSession,
-                         AppletSession interactiveSession);
+        Result Start(AppletSession normalSession,
+                     AppletSession interactiveSession);
 
-        ResultCode GetResult();
+        Result GetResult();
 
         bool DrawTo(RenderingSurfaceInfo surfaceInfo, IVirtualMemoryManager destination, ulong position)
         {

src/Ryujinx.Horizon/Applets/PlayerSelect/PlayerSelectApplet.cs

@@ -1,15 +1,13 @@
 using Ryujinx.Common.Memory;
-using Ryujinx.HLE.HOS.Services.Account.Acc;
-using Ryujinx.HLE.HOS.Services.Am.AppletAE;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Am;
 using System;
 using System.IO;
 
-namespace Ryujinx.HLE.HOS.Applets
+namespace Ryujinx.Horizon.Applets.PlayerSelect
 {
     internal class PlayerSelectApplet : IApplet
     {
-        private readonly Horizon _system;
-
         private AppletSession _normalSession;
 #pragma warning disable IDE0052 // Remove unread private member
         private AppletSession _interactiveSession;
@@ -17,12 +15,7 @@ namespace Ryujinx.HLE.HOS.Applets
 
         public event EventHandler AppletStateChanged;
 
-        public PlayerSelectApplet(Horizon system)
-        {
-            _system = system;
-        }
-
-        public ResultCode Start(AppletSession normalSession, AppletSession interactiveSession)
+        public Result Start(AppletSession normalSession, AppletSession interactiveSession)
         {
             _normalSession = normalSession;
             _interactiveSession = interactiveSession;
@@ -34,12 +27,12 @@ namespace Ryujinx.HLE.HOS.Applets
 
             _system.ReturnFocus();
 
-            return ResultCode.Success;
+            return Result.Success;
         }
 
-        public ResultCode GetResult()
+        public Result GetResult()
         {
-            return ResultCode.Success;
+            return Result.Success;
         }
 
         private byte[] BuildResponse()

src/Ryujinx.Horizon/Applets/PlayerSelect/PlayerSelectResult.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets
+namespace Ryujinx.Horizon.Applets.PlayerSelect
 {
     enum PlayerSelectResult : ulong
     {

src/Ryujinx.Horizon/Applets/SoftwareKeyboard/CJKCharacterValidation.cs

@@ -1,6 +1,6 @@
 using System.Text.RegularExpressions;
 
-namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
+namespace Ryujinx.Horizon.Applets.SoftwareKeyboard
 {
     public static partial class CJKCharacterValidation
     {

src/Ryujinx.Horizon/Applets/SoftwareKeyboard/InitialCursorPosition.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
+namespace Ryujinx.Horizon.Applets.SoftwareKeyboard
 {
     /// <summary>
     /// Identifies the initial position of the cursor displayed in the area.

src/Ryujinx.Horizon/Applets/SoftwareKeyboard/InlineKeyboardRequest.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
+namespace Ryujinx.Horizon.Applets.SoftwareKeyboard
 {
     /// <summary>
     /// Possible requests to the software keyboard when running in inline mode.

src/Ryujinx.Horizon/Applets/SoftwareKeyboard/InlineKeyboardResponse.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
+namespace Ryujinx.Horizon.Applets.SoftwareKeyboard
 {
     /// <summary>
     /// Possible responses from the software keyboard when running in inline mode.

src/Ryujinx.Horizon/Applets/SoftwareKeyboard/InlineKeyboardState.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
+namespace Ryujinx.Horizon.Applets.SoftwareKeyboard
 {
     /// <summary>
     /// Possible states for the software keyboard when running in inline mode.

src/Ryujinx.Horizon/Applets/SoftwareKeyboard/InlineResponses.cs

@@ -1,7 +1,7 @@
 using System.IO;
 using System.Text;
 
-namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
+namespace Ryujinx.Horizon.Applets.SoftwareKeyboard
 {
     internal class InlineResponses
     {

src/Ryujinx.Horizon/Applets/SoftwareKeyboard/InputFormMode.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
+namespace Ryujinx.Horizon.Applets.SoftwareKeyboard
 {
     /// <summary>
     /// Identifies the text entry mode.

src/Ryujinx.Horizon/Applets/SoftwareKeyboard/InvalidButtonFlags.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
+namespace Ryujinx.Horizon.Applets.SoftwareKeyboard
 {
     /// <summary>
     /// Identifies prohibited buttons.

src/Ryujinx.Horizon/Applets/SoftwareKeyboard/InvalidCharFlags.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
+namespace Ryujinx.Horizon.Applets.SoftwareKeyboard
 {
     /// <summary>
     /// Identifies prohibited character sets.

src/Ryujinx.Horizon/Applets/SoftwareKeyboard/KeyboardCalcFlags.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
+namespace Ryujinx.Horizon.Applets.SoftwareKeyboard
 {
     /// <summary>
     /// Bitmask of commands encoded in the Flags field of the Calc structs.

src/Ryujinx.Horizon/Applets/SoftwareKeyboard/KeyboardInputMode.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
+namespace Ryujinx.Horizon.Applets.SoftwareKeyboard
 {
     /// <summary>
     /// Active input options set by the keyboard applet. These options allow keyboard

src/Ryujinx.Horizon/Applets/SoftwareKeyboard/KeyboardMiniaturizationMode.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
+namespace Ryujinx.Horizon.Applets.SoftwareKeyboard
 {
     /// <summary>
     /// The miniaturization mode used by the keyboard in inline mode.

src/Ryujinx.Horizon/Applets/SoftwareKeyboard/KeyboardMode.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
+namespace Ryujinx.Horizon.Applets.SoftwareKeyboard
 {
     /// <summary>
     /// Identifies the variant of keyboard displayed on screen.

src/Ryujinx.Horizon/Applets/SoftwareKeyboard/KeyboardResult.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
+namespace Ryujinx.Horizon.Applets.SoftwareKeyboard
 {
     /// <summary>
     /// The intention of the user when they finish the interaction with the keyboard.

src/Ryujinx.Horizon/Applets/SoftwareKeyboard/NumericCharacterValidation.cs

@@ -1,6 +1,6 @@
 using System.Text.RegularExpressions;
 
-namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
+namespace Ryujinx.Horizon.Applets.SoftwareKeyboard
 {
     public static partial class NumericCharacterValidation
     {

src/Ryujinx.Horizon/Applets/SoftwareKeyboard/PasswordMode.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
+namespace Ryujinx.Horizon.Applets.SoftwareKeyboard
 {
     /// <summary>
     /// Identifies the display mode of text in a password field.