14 files changed, 1596 insertions, 0 deletions

diff --git a/src/citron_cmd/CMakeLists.txt b/src/citron_cmd/CMakeLists.txt
new file mode 100644
index 000000000..ebd8fd738
--- /dev/null
+++ b/src/citron_cmd/CMakeLists.txt
@@ -0,0 +1,65 @@
+# SPDX-FileCopyrightText: 2018 yuzu Emulator Project
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+# Credits to Samantas5855 and others for this function.
+function(create_resource file output filename)
+    # Read hex data from file
+    file(READ ${file} filedata HEX)
+    # Convert hex data for C compatibility
+    string(REGEX REPLACE "([0-9a-f][0-9a-f])" "0x\\1," filedata ${filedata})
+    # Write data to output file
+    set(RESOURCES_DIR "${PROJECT_BINARY_DIR}/dist" PARENT_SCOPE)
+    file(WRITE "${PROJECT_BINARY_DIR}/dist/${output}" "const unsigned char ${filename}[] = {${filedata}};\nconst unsigned ${filename}_size = sizeof(${filename});\n")
+endfunction()
+
+add_executable(yuzu-cmd
+    emu_window/emu_window_sdl2.cpp
+    emu_window/emu_window_sdl2.h
+    emu_window/emu_window_sdl2_gl.cpp
+    emu_window/emu_window_sdl2_gl.h
+    emu_window/emu_window_sdl2_null.cpp
+    emu_window/emu_window_sdl2_null.h
+    emu_window/emu_window_sdl2_vk.cpp
+    emu_window/emu_window_sdl2_vk.h
+    precompiled_headers.h
+    sdl_config.cpp
+    sdl_config.h
+    yuzu.cpp
+    yuzu.rc
+)
+
+target_link_libraries(yuzu-cmd PRIVATE common core input_common frontend_common)
+target_link_libraries(yuzu-cmd PRIVATE glad)
+if (MSVC)
+    target_link_libraries(yuzu-cmd PRIVATE getopt)
+endif()
+target_link_libraries(yuzu-cmd PRIVATE ${PLATFORM_LIBRARIES} Threads::Threads)
+
+create_resource("../../dist/yuzu.bmp" "yuzu_cmd/yuzu_icon.h" "yuzu_icon")
+target_include_directories(yuzu-cmd PRIVATE ${RESOURCES_DIR})
+
+target_link_libraries(yuzu-cmd PRIVATE SDL2::SDL2 Vulkan::Headers)
+
+if(UNIX AND NOT APPLE)
+    install(TARGETS yuzu-cmd)
+endif()
+
+if(WIN32)
+    # compile as a win32 gui application instead of a console application
+    if(MSVC)
+        set_target_properties(yuzu-cmd PROPERTIES LINK_FLAGS_RELEASE "/SUBSYSTEM:WINDOWS /ENTRY:mainCRTStartup")
+    elseif(MINGW)
+        set_target_properties(yuzu-cmd PROPERTIES LINK_FLAGS_RELEASE "-Wl,--subsystem,windows")
+    endif()
+endif()
+
+if (MSVC)
+    include(CopyYuzuSDLDeps)
+    copy_yuzu_SDL_deps(yuzu-cmd)
+endif()
+
+if (YUZU_USE_PRECOMPILED_HEADERS)
+    target_precompile_headers(yuzu-cmd PRIVATE precompiled_headers.h)
+endif()
+
+create_target_directory_groups(yuzu-cmd)
diff --git a/src/citron_cmd/citron.cpp b/src/citron_cmd/citron.cpp
new file mode 100644
index 000000000..8a8cdbc44
--- /dev/null
+++ b/src/citron_cmd/citron.cpp
@@ -0,0 +1,459 @@
+// SPDX-FileCopyrightText: 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <chrono>
+#include <iostream>
+#include <memory>
+#include <regex>
+#include <string>
+#include <thread>
+
+#include <fmt/ostream.h>
+
+#include "common/detached_tasks.h"
+#include "common/logging/backend.h"
+#include "common/logging/log.h"
+#include "common/microprofile.h"
+#include "common/nvidia_flags.h"
+#include "common/scm_rev.h"
+#include "common/scope_exit.h"
+#include "common/settings.h"
+#include "common/string_util.h"
+#include "common/telemetry.h"
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/cpu_manager.h"
+#include "core/crypto/key_manager.h"
+#include "core/file_sys/registered_cache.h"
+#include "core/file_sys/vfs/vfs_real.h"
+#include "core/hle/service/am/applet_manager.h"
+#include "core/hle/service/filesystem/filesystem.h"
+#include "core/loader/loader.h"
+#include "core/telemetry_session.h"
+#include "frontend_common/config.h"
+#include "input_common/main.h"
+#include "network/network.h"
+#include "sdl_config.h"
+#include "video_core/renderer_base.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl2.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl2_gl.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl2_null.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl2_vk.h"
+
+#ifdef _WIN32
+// windows.h needs to be included before shellapi.h
+#include <windows.h>
+
+#include <shellapi.h>
+
+#include "common/windows/timer_resolution.h"
+#endif
+
+#undef _UNICODE
+#include <getopt.h>
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif
+
+#ifdef _WIN32
+extern "C" {
+// tells Nvidia and AMD drivers to use the dedicated GPU by default on laptops with switchable
+// graphics
+__declspec(dllexport) unsigned long NvOptimusEnablement = 0x00000001;
+__declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
+}
+#endif
+
+#ifdef __unix__
+#include "common/linux/gamemode.h"
+#endif
+
+static void PrintHelp(const char* argv0) {
+    std::cout << "Usage: " << argv0
+              << " [options] <filename>\n"
+                 "-c, --config          Load the specified configuration file\n"
+                 "-f, --fullscreen      Start in fullscreen mode\n"
+                 "-g, --game            File path of the game to load\n"
+                 "-h, --help            Display this help and exit\n"
+                 "-m, --multiplayer=nick:password@address:port"
+                 " Nickname, password, address and port for multiplayer\n"
+                 "-p, --program         Pass following string as arguments to executable\n"
+                 "-u, --user            Select a specific user profile from 0 to 7\n"
+                 "-v, --version         Output version information and exit\n";
+}
+
+static void PrintVersion() {
+    std::cout << "yuzu " << Common::g_scm_branch << " " << Common::g_scm_desc << std::endl;
+}
+
+static void OnStateChanged(const Network::RoomMember::State& state) {
+    switch (state) {
+    case Network::RoomMember::State::Idle:
+        LOG_DEBUG(Network, "Network is idle");
+        break;
+    case Network::RoomMember::State::Joining:
+        LOG_DEBUG(Network, "Connection sequence to room started");
+        break;
+    case Network::RoomMember::State::Joined:
+        LOG_DEBUG(Network, "Successfully joined to the room");
+        break;
+    case Network::RoomMember::State::Moderator:
+        LOG_DEBUG(Network, "Successfully joined the room as a moderator");
+        break;
+    default:
+        break;
+    }
+}
+
+static void OnNetworkError(const Network::RoomMember::Error& error) {
+    switch (error) {
+    case Network::RoomMember::Error::LostConnection:
+        LOG_DEBUG(Network, "Lost connection to the room");
+        break;
+    case Network::RoomMember::Error::CouldNotConnect:
+        LOG_ERROR(Network, "Error: Could not connect");
+        exit(1);
+        break;
+    case Network::RoomMember::Error::NameCollision:
+        LOG_ERROR(
+            Network,
+            "You tried to use the same nickname as another user that is connected to the Room");
+        exit(1);
+        break;
+    case Network::RoomMember::Error::IpCollision:
+        LOG_ERROR(Network, "You tried to use the same fake IP-Address as another user that is "
+                           "connected to the Room");
+        exit(1);
+        break;
+    case Network::RoomMember::Error::WrongPassword:
+        LOG_ERROR(Network, "Room replied with: Wrong password");
+        exit(1);
+        break;
+    case Network::RoomMember::Error::WrongVersion:
+        LOG_ERROR(Network,
+                  "You are using a different version than the room you are trying to connect to");
+        exit(1);
+        break;
+    case Network::RoomMember::Error::RoomIsFull:
+        LOG_ERROR(Network, "The room is full");
+        exit(1);
+        break;
+    case Network::RoomMember::Error::HostKicked:
+        LOG_ERROR(Network, "You have been kicked by the host");
+        break;
+    case Network::RoomMember::Error::HostBanned:
+        LOG_ERROR(Network, "You have been banned by the host");
+        break;
+    case Network::RoomMember::Error::UnknownError:
+        LOG_ERROR(Network, "UnknownError");
+        break;
+    case Network::RoomMember::Error::PermissionDenied:
+        LOG_ERROR(Network, "PermissionDenied");
+        break;
+    case Network::RoomMember::Error::NoSuchUser:
+        LOG_ERROR(Network, "NoSuchUser");
+        break;
+    }
+}
+
+static void OnMessageReceived(const Network::ChatEntry& msg) {
+    std::cout << std::endl << msg.nickname << ": " << msg.message << std::endl << std::endl;
+}
+
+static void OnStatusMessageReceived(const Network::StatusMessageEntry& msg) {
+    std::string message;
+    switch (msg.type) {
+    case Network::IdMemberJoin:
+        message = fmt::format("{} has joined", msg.nickname);
+        break;
+    case Network::IdMemberLeave:
+        message = fmt::format("{} has left", msg.nickname);
+        break;
+    case Network::IdMemberKicked:
+        message = fmt::format("{} has been kicked", msg.nickname);
+        break;
+    case Network::IdMemberBanned:
+        message = fmt::format("{} has been banned", msg.nickname);
+        break;
+    case Network::IdAddressUnbanned:
+        message = fmt::format("{} has been unbanned", msg.nickname);
+        break;
+    }
+    if (!message.empty())
+        std::cout << std::endl << "* " << message << std::endl << std::endl;
+}
+
+/// Application entry point
+int main(int argc, char** argv) {
+#ifdef _WIN32
+    if (AttachConsole(ATTACH_PARENT_PROCESS)) {
+        freopen("CONOUT$", "wb", stdout);
+        freopen("CONOUT$", "wb", stderr);
+    }
+#endif
+
+    Common::Log::Initialize();
+    Common::Log::SetColorConsoleBackendEnabled(true);
+    Common::Log::Start();
+    Common::DetachedTasks detached_tasks;
+
+    int option_index = 0;
+#ifdef _WIN32
+    int argc_w;
+    auto argv_w = CommandLineToArgvW(GetCommandLineW(), &argc_w);
+
+    if (argv_w == nullptr) {
+        LOG_CRITICAL(Frontend, "Failed to get command line arguments");
+        return -1;
+    }
+#endif
+    std::string filepath;
+    std::optional<std::string> config_path;
+    std::string program_args;
+    std::optional<int> selected_user;
+
+    bool use_multiplayer = false;
+    bool fullscreen = false;
+    std::string nickname{};
+    std::string password{};
+    std::string address{};
+    u16 port = Network::DefaultRoomPort;
+
+    static struct option long_options[] = {
+        // clang-format off
+        {"config", required_argument, 0, 'c'},
+        {"fullscreen", no_argument, 0, 'f'},
+        {"help", no_argument, 0, 'h'},
+        {"game", required_argument, 0, 'g'},
+        {"multiplayer", required_argument, 0, 'm'},
+        {"program", optional_argument, 0, 'p'},
+        {"user", required_argument, 0, 'u'},
+        {"version", no_argument, 0, 'v'},
+        {0, 0, 0, 0},
+        // clang-format on
+    };
+
+    while (optind < argc) {
+        int arg = getopt_long(argc, argv, "g:fhvp::c:u:", long_options, &option_index);
+        if (arg != -1) {
+            switch (static_cast<char>(arg)) {
+            case 'c':
+                config_path = optarg;
+                break;
+            case 'f':
+                fullscreen = true;
+                LOG_INFO(Frontend, "Starting in fullscreen mode...");
+                break;
+            case 'h':
+                PrintHelp(argv[0]);
+                return 0;
+            case 'g': {
+                const std::string str_arg(optarg);
+                filepath = str_arg;
+                break;
+            }
+            case 'm': {
+                use_multiplayer = true;
+                const std::string str_arg(optarg);
+                // regex to check if the format is nickname:password@ip:port
+                // with optional :password
+                const std::regex re("^([^:]+)(?::(.+))?@([^:]+)(?::([0-9]+))?$");
+                if (!std::regex_match(str_arg, re)) {
+                    std::cout << "Wrong format for option --multiplayer\n";
+                    PrintHelp(argv[0]);
+                    return 0;
+                }
+
+                std::smatch match;
+                std::regex_search(str_arg, match, re);
+                ASSERT(match.size() == 5);
+                nickname = match[1];
+                password = match[2];
+                address = match[3];
+                if (!match[4].str().empty()) {
+                    port = static_cast<u16>(std::strtoul(match[4].str().c_str(), nullptr, 0));
+                }
+                std::regex nickname_re("^[a-zA-Z0-9._\\- ]+$");
+                if (!std::regex_match(nickname, nickname_re)) {
+                    std::cout
+                        << "Nickname is not valid. Must be 4 to 20 alphanumeric characters.\n";
+                    return 0;
+                }
+                if (address.empty()) {
+                    std::cout << "Address to room must not be empty.\n";
+                    return 0;
+                }
+                break;
+            }
+            case 'p':
+                program_args = argv[optind];
+                ++optind;
+                break;
+            case 'u':
+                selected_user = atoi(optarg);
+                break;
+            case 'v':
+                PrintVersion();
+                return 0;
+            }
+        } else {
+#ifdef _WIN32
+            filepath = Common::UTF16ToUTF8(argv_w[optind]);
+#else
+            filepath = argv[optind];
+#endif
+            optind++;
+        }
+    }
+
+    SdlConfig config{config_path};
+
+    // apply the log_filter setting
+    // the logger was initialized before and doesn't pick up the filter on its own
+    Common::Log::Filter filter;
+    filter.ParseFilterString(Settings::values.log_filter.GetValue());
+    Common::Log::SetGlobalFilter(filter);
+
+    if (!program_args.empty()) {
+        Settings::values.program_args = program_args;
+    }
+
+    if (selected_user.has_value()) {
+        Settings::values.current_user = std::clamp(*selected_user, 0, 7);
+    }
+
+#ifdef _WIN32
+    LocalFree(argv_w);
+#endif
+
+    MicroProfileOnThreadCreate("EmuThread");
+    SCOPE_EXIT {
+        MicroProfileShutdown();
+    };
+
+    Common::ConfigureNvidiaEnvironmentFlags();
+
+    if (filepath.empty()) {
+        LOG_CRITICAL(Frontend, "Failed to load ROM: No ROM specified");
+        return -1;
+    }
+
+    Core::System system{};
+    system.Initialize();
+
+    InputCommon::InputSubsystem input_subsystem{};
+
+    // Apply the command line arguments
+    system.ApplySettings();
+
+    std::unique_ptr<EmuWindow_SDL2> emu_window;
+    switch (Settings::values.renderer_backend.GetValue()) {
+    case Settings::RendererBackend::OpenGL:
+        emu_window = std::make_unique<EmuWindow_SDL2_GL>(&input_subsystem, system, fullscreen);
+        break;
+    case Settings::RendererBackend::Vulkan:
+        emu_window = std::make_unique<EmuWindow_SDL2_VK>(&input_subsystem, system, fullscreen);
+        break;
+    case Settings::RendererBackend::Null:
+        emu_window = std::make_unique<EmuWindow_SDL2_Null>(&input_subsystem, system, fullscreen);
+        break;
+    }
+
+#ifdef _WIN32
+    Common::Windows::SetCurrentTimerResolutionToMaximum();
+    system.CoreTiming().SetTimerResolutionNs(Common::Windows::GetCurrentTimerResolution());
+#endif
+
+    system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
+    system.SetFilesystem(std::make_shared<FileSys::RealVfsFilesystem>());
+    system.GetFileSystemController().CreateFactories(*system.GetFilesystem());
+    system.GetUserChannel().clear();
+
+    Service::AM::FrontendAppletParameters load_parameters{
+        .applet_id = Service::AM::AppletId::Application,
+    };
+    const Core::SystemResultStatus load_result{system.Load(*emu_window, filepath, load_parameters)};
+
+    switch (load_result) {
+    case Core::SystemResultStatus::ErrorGetLoader:
+        LOG_CRITICAL(Frontend, "Failed to obtain loader for {}!", filepath);
+        return -1;
+    case Core::SystemResultStatus::ErrorLoader:
+        LOG_CRITICAL(Frontend, "Failed to load ROM!");
+        return -1;
+    case Core::SystemResultStatus::ErrorNotInitialized:
+        LOG_CRITICAL(Frontend, "CPUCore not initialized");
+        return -1;
+    case Core::SystemResultStatus::ErrorVideoCore:
+        LOG_CRITICAL(Frontend, "Failed to initialize VideoCore!");
+        return -1;
+    case Core::SystemResultStatus::Success:
+        break; // Expected case
+    default:
+        if (static_cast<u32>(load_result) >
+            static_cast<u32>(Core::SystemResultStatus::ErrorLoader)) {
+            const u16 loader_id = static_cast<u16>(Core::SystemResultStatus::ErrorLoader);
+            const u16 error_id = static_cast<u16>(load_result) - loader_id;
+            LOG_CRITICAL(Frontend,
+                         "While attempting to load the ROM requested, an error occurred. Please "
+                         "refer to the yuzu wiki for more information or the yuzu discord for "
+                         "additional help.\n\nError Code: {:04X}-{:04X}\nError Description: {}",
+                         loader_id, error_id, static_cast<Loader::ResultStatus>(error_id));
+        }
+        break;
+    }
+
+    system.TelemetrySession().AddField(Common::Telemetry::FieldType::App, "Frontend", "SDL");
+
+    if (use_multiplayer) {
+        if (auto member = system.GetRoomNetwork().GetRoomMember().lock()) {
+            member->BindOnChatMessageReceived(OnMessageReceived);
+            member->BindOnStatusMessageReceived(OnStatusMessageReceived);
+            member->BindOnStateChanged(OnStateChanged);
+            member->BindOnError(OnNetworkError);
+            LOG_DEBUG(Network, "Start connection to {}:{} with nickname {}", address, port,
+                      nickname);
+            member->Join(nickname, address.c_str(), port, 0, Network::NoPreferredIP, password);
+        } else {
+            LOG_ERROR(Network, "Could not access RoomMember");
+            return 0;
+        }
+    }
+
+    // Core is loaded, start the GPU (makes the GPU contexts current to this thread)
+    system.GPU().Start();
+    system.GetCpuManager().OnGpuReady();
+
+    if (Settings::values.use_disk_shader_cache.GetValue()) {
+        system.Renderer().ReadRasterizer()->LoadDiskResources(
+            system.GetApplicationProcessProgramID(), std::stop_token{},
+            [](VideoCore::LoadCallbackStage, size_t value, size_t total) {});
+    }
+
+    system.RegisterExitCallback([&] {
+        // Just exit right away.
+        exit(0);
+    });
+
+#ifdef __unix__
+    Common::Linux::StartGamemode();
+#endif
+
+    void(system.Run());
+    if (system.DebuggerEnabled()) {
+        system.InitializeDebugger();
+    }
+    while (emu_window->IsOpen()) {
+        emu_window->WaitEvent();
+    }
+    system.DetachDebugger();
+    void(system.Pause());
+    system.ShutdownMainProcess();
+
+#ifdef __unix__
+    Common::Linux::StopGamemode();
+#endif
+
+    detached_tasks.WaitForAllTasks();
+    return 0;
+}
diff --git a/src/citron_cmd/citron.rc b/src/citron_cmd/citron.rc
new file mode 100644
index 000000000..e230cf680
--- /dev/null
+++ b/src/citron_cmd/citron.rc
@@ -0,0 +1,20 @@
+// SPDX-FileCopyrightText: 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "winresrc.h"
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+YUZU_ICON               ICON                    "../../dist/yuzu.ico"
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// RT_MANIFEST
+//
+
+0                       RT_MANIFEST             "../../dist/yuzu.manifest"
diff --git a/src/citron_cmd/emu_window/emu_window_sdl2.cpp b/src/citron_cmd/emu_window/emu_window_sdl2.cpp
new file mode 100644
index 000000000..eae614f9d
--- /dev/null
+++ b/src/citron_cmd/emu_window/emu_window_sdl2.cpp
@@ -0,0 +1,254 @@
+// SPDX-FileCopyrightText: 2016 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <SDL.h>
+
+#include "common/logging/log.h"
+#include "common/scm_rev.h"
+#include "common/settings.h"
+#include "core/core.h"
+#include "core/perf_stats.h"
+#include "hid_core/hid_core.h"
+#include "input_common/drivers/keyboard.h"
+#include "input_common/drivers/mouse.h"
+#include "input_common/drivers/touch_screen.h"
+#include "input_common/main.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl2.h"
+#include "yuzu_cmd/yuzu_icon.h"
+
+EmuWindow_SDL2::EmuWindow_SDL2(InputCommon::InputSubsystem* input_subsystem_, Core::System& system_)
+    : input_subsystem{input_subsystem_}, system{system_} {
+    input_subsystem->Initialize();
+    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) < 0) {
+        LOG_CRITICAL(Frontend, "Failed to initialize SDL2: {}, Exiting...", SDL_GetError());
+        exit(1);
+    }
+    SDL_SetMainReady();
+}
+
+EmuWindow_SDL2::~EmuWindow_SDL2() {
+    system.HIDCore().UnloadInputDevices();
+    input_subsystem->Shutdown();
+    SDL_Quit();
+}
+
+InputCommon::MouseButton EmuWindow_SDL2::SDLButtonToMouseButton(u32 button) const {
+    switch (button) {
+    case SDL_BUTTON_LEFT:
+        return InputCommon::MouseButton::Left;
+    case SDL_BUTTON_RIGHT:
+        return InputCommon::MouseButton::Right;
+    case SDL_BUTTON_MIDDLE:
+        return InputCommon::MouseButton::Wheel;
+    case SDL_BUTTON_X1:
+        return InputCommon::MouseButton::Backward;
+    case SDL_BUTTON_X2:
+        return InputCommon::MouseButton::Forward;
+    default:
+        return InputCommon::MouseButton::Undefined;
+    }
+}
+
+std::pair<float, float> EmuWindow_SDL2::MouseToTouchPos(s32 touch_x, s32 touch_y) const {
+    int w, h;
+    SDL_GetWindowSize(render_window, &w, &h);
+    const float fx = static_cast<float>(touch_x) / w;
+    const float fy = static_cast<float>(touch_y) / h;
+
+    return {std::clamp<float>(fx, 0.0f, 1.0f), std::clamp<float>(fy, 0.0f, 1.0f)};
+}
+
+void EmuWindow_SDL2::OnMouseButton(u32 button, u8 state, s32 x, s32 y) {
+    const auto mouse_button = SDLButtonToMouseButton(button);
+    if (state == SDL_PRESSED) {
+        const auto [touch_x, touch_y] = MouseToTouchPos(x, y);
+        input_subsystem->GetMouse()->PressButton(x, y, mouse_button);
+        input_subsystem->GetMouse()->PressMouseButton(mouse_button);
+        input_subsystem->GetMouse()->PressTouchButton(touch_x, touch_y, mouse_button);
+    } else {
+        input_subsystem->GetMouse()->ReleaseButton(mouse_button);
+    }
+}
+
+void EmuWindow_SDL2::OnMouseMotion(s32 x, s32 y) {
+    const auto [touch_x, touch_y] = MouseToTouchPos(x, y);
+    input_subsystem->GetMouse()->Move(x, y, 0, 0);
+    input_subsystem->GetMouse()->MouseMove(touch_x, touch_y);
+    input_subsystem->GetMouse()->TouchMove(touch_x, touch_y);
+}
+
+void EmuWindow_SDL2::OnFingerDown(float x, float y, std::size_t id) {
+    input_subsystem->GetTouchScreen()->TouchPressed(x, y, id);
+}
+
+void EmuWindow_SDL2::OnFingerMotion(float x, float y, std::size_t id) {
+    input_subsystem->GetTouchScreen()->TouchMoved(x, y, id);
+}
+
+void EmuWindow_SDL2::OnFingerUp() {
+    input_subsystem->GetTouchScreen()->ReleaseAllTouch();
+}
+
+void EmuWindow_SDL2::OnKeyEvent(int key, u8 state) {
+    if (state == SDL_PRESSED) {
+        input_subsystem->GetKeyboard()->PressKey(static_cast<std::size_t>(key));
+    } else if (state == SDL_RELEASED) {
+        input_subsystem->GetKeyboard()->ReleaseKey(static_cast<std::size_t>(key));
+    }
+}
+
+bool EmuWindow_SDL2::IsOpen() const {
+    return is_open;
+}
+
+bool EmuWindow_SDL2::IsShown() const {
+    return is_shown;
+}
+
+void EmuWindow_SDL2::OnResize() {
+    int width, height;
+    SDL_GL_GetDrawableSize(render_window, &width, &height);
+    UpdateCurrentFramebufferLayout(width, height);
+}
+
+void EmuWindow_SDL2::ShowCursor(bool show_cursor) {
+    SDL_ShowCursor(show_cursor ? SDL_ENABLE : SDL_DISABLE);
+}
+
+void EmuWindow_SDL2::Fullscreen() {
+    SDL_DisplayMode display_mode;
+    switch (Settings::values.fullscreen_mode.GetValue()) {
+    case Settings::FullscreenMode::Exclusive:
+        // Set window size to render size before entering fullscreen -- SDL2 does not resize window
+        // to display dimensions automatically in this mode.
+        if (SDL_GetDesktopDisplayMode(0, &display_mode) == 0) {
+            SDL_SetWindowSize(render_window, display_mode.w, display_mode.h);
+        } else {
+            LOG_ERROR(Frontend, "SDL_GetDesktopDisplayMode failed: {}", SDL_GetError());
+        }
+
+        if (SDL_SetWindowFullscreen(render_window, SDL_WINDOW_FULLSCREEN) == 0) {
+            return;
+        }
+
+        LOG_ERROR(Frontend, "Fullscreening failed: {}", SDL_GetError());
+        LOG_INFO(Frontend, "Attempting to use borderless fullscreen...");
+        [[fallthrough]];
+    case Settings::FullscreenMode::Borderless:
+        if (SDL_SetWindowFullscreen(render_window, SDL_WINDOW_FULLSCREEN_DESKTOP) == 0) {
+            return;
+        }
+
+        LOG_ERROR(Frontend, "Borderless fullscreening failed: {}", SDL_GetError());
+        [[fallthrough]];
+    default:
+        // Fallback algorithm: Maximise window.
+        // Works on all systems (unless something is seriously wrong), so no fallback for this one.
+        LOG_INFO(Frontend, "Falling back on a maximised window...");
+        SDL_MaximizeWindow(render_window);
+        break;
+    }
+}
+
+void EmuWindow_SDL2::WaitEvent() {
+    // Called on main thread
+    SDL_Event event;
+
+    if (!SDL_WaitEvent(&event)) {
+        const char* error = SDL_GetError();
+        if (!error || strcmp(error, "") == 0) {
+            // https://github.com/libsdl-org/SDL/issues/5780
+            // Sometimes SDL will return without actually having hit an error condition;
+            // just ignore it in this case.
+            return;
+        }
+
+        LOG_CRITICAL(Frontend, "SDL_WaitEvent failed: {}", error);
+        exit(1);
+    }
+
+    switch (event.type) {
+    case SDL_WINDOWEVENT:
+        switch (event.window.event) {
+        case SDL_WINDOWEVENT_SIZE_CHANGED:
+        case SDL_WINDOWEVENT_RESIZED:
+        case SDL_WINDOWEVENT_MAXIMIZED:
+        case SDL_WINDOWEVENT_RESTORED:
+            OnResize();
+            break;
+        case SDL_WINDOWEVENT_MINIMIZED:
+        case SDL_WINDOWEVENT_EXPOSED:
+            is_shown = event.window.event == SDL_WINDOWEVENT_EXPOSED;
+            OnResize();
+            break;
+        case SDL_WINDOWEVENT_CLOSE:
+            is_open = false;
+            break;
+        }
+        break;
+    case SDL_KEYDOWN:
+    case SDL_KEYUP:
+        OnKeyEvent(static_cast<int>(event.key.keysym.scancode), event.key.state);
+        break;
+    case SDL_MOUSEMOTION:
+        // ignore if it came from touch
+        if (event.button.which != SDL_TOUCH_MOUSEID)
+            OnMouseMotion(event.motion.x, event.motion.y);
+        break;
+    case SDL_MOUSEBUTTONDOWN:
+    case SDL_MOUSEBUTTONUP:
+        // ignore if it came from touch
+        if (event.button.which != SDL_TOUCH_MOUSEID) {
+            OnMouseButton(event.button.button, event.button.state, event.button.x, event.button.y);
+        }
+        break;
+    case SDL_FINGERDOWN:
+        OnFingerDown(event.tfinger.x, event.tfinger.y,
+                     static_cast<std::size_t>(event.tfinger.touchId));
+        break;
+    case SDL_FINGERMOTION:
+        OnFingerMotion(event.tfinger.x, event.tfinger.y,
+                       static_cast<std::size_t>(event.tfinger.touchId));
+        break;
+    case SDL_FINGERUP:
+        OnFingerUp();
+        break;
+    case SDL_QUIT:
+        is_open = false;
+        break;
+    default:
+        break;
+    }
+
+    const u32 current_time = SDL_GetTicks();
+    if (current_time > last_time + 2000) {
+        const auto results = system.GetAndResetPerfStats();
+        const auto title =
+            fmt::format("yuzu {} | {}-{} | FPS: {:.0f} ({:.0f}%)", Common::g_build_fullname,
+                        Common::g_scm_branch, Common::g_scm_desc, results.average_game_fps,
+                        results.emulation_speed * 100.0);
+        SDL_SetWindowTitle(render_window, title.c_str());
+        last_time = current_time;
+    }
+}
+
+// Credits to Samantas5855 and others for this function.
+void EmuWindow_SDL2::SetWindowIcon() {
+    SDL_RWops* const yuzu_icon_stream = SDL_RWFromConstMem((void*)yuzu_icon, yuzu_icon_size);
+    if (yuzu_icon_stream == nullptr) {
+        LOG_WARNING(Frontend, "Failed to create yuzu icon stream.");
+        return;
+    }
+    SDL_Surface* const window_icon = SDL_LoadBMP_RW(yuzu_icon_stream, 1);
+    if (window_icon == nullptr) {
+        LOG_WARNING(Frontend, "Failed to read BMP from stream.");
+        return;
+    }
+    // The icon is attached to the window pointer
+    SDL_SetWindowIcon(render_window, window_icon);
+    SDL_FreeSurface(window_icon);
+}
+
+void EmuWindow_SDL2::OnMinimalClientAreaChangeRequest(std::pair<u32, u32> minimal_size) {
+    SDL_SetWindowMinimumSize(render_window, minimal_size.first, minimal_size.second);
+}
diff --git a/src/citron_cmd/emu_window/emu_window_sdl2.h b/src/citron_cmd/emu_window/emu_window_sdl2.h
new file mode 100644
index 000000000..4ad05e0e1
--- /dev/null
+++ b/src/citron_cmd/emu_window/emu_window_sdl2.h
@@ -0,0 +1,95 @@
+// SPDX-FileCopyrightText: 2016 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <utility>
+
+#include "core/frontend/emu_window.h"
+#include "core/frontend/graphics_context.h"
+
+struct SDL_Window;
+
+namespace Core {
+class System;
+}
+
+namespace InputCommon {
+class InputSubsystem;
+enum class MouseButton;
+} // namespace InputCommon
+
+class EmuWindow_SDL2 : public Core::Frontend::EmuWindow {
+public:
+    explicit EmuWindow_SDL2(InputCommon::InputSubsystem* input_subsystem_, Core::System& system_);
+    ~EmuWindow_SDL2();
+
+    /// Whether the window is still open, and a close request hasn't yet been sent
+    bool IsOpen() const;
+
+    /// Returns if window is shown (not minimized)
+    bool IsShown() const override;
+
+    /// Wait for the next event on the main thread.
+    void WaitEvent();
+
+    // Sets the window icon from yuzu.bmp
+    void SetWindowIcon();
+
+protected:
+    /// Called by WaitEvent when a key is pressed or released.
+    void OnKeyEvent(int key, u8 state);
+
+    /// Converts a SDL mouse button into MouseInput mouse button
+    InputCommon::MouseButton SDLButtonToMouseButton(u32 button) const;
+
+    /// Translates pixel position to float position
+    std::pair<float, float> MouseToTouchPos(s32 touch_x, s32 touch_y) const;
+
+    /// Called by WaitEvent when a mouse button is pressed or released
+    void OnMouseButton(u32 button, u8 state, s32 x, s32 y);
+
+    /// Called by WaitEvent when the mouse moves.
+    void OnMouseMotion(s32 x, s32 y);
+
+    /// Called by WaitEvent when a finger starts touching the touchscreen
+    void OnFingerDown(float x, float y, std::size_t id);
+
+    /// Called by WaitEvent when a finger moves while touching the touchscreen
+    void OnFingerMotion(float x, float y, std::size_t id);
+
+    /// Called by WaitEvent when a finger stops touching the touchscreen
+    void OnFingerUp();
+
+    /// Called by WaitEvent when any event that may cause the window to be resized occurs
+    void OnResize();
+
+    /// Called when users want to hide the mouse cursor
+    void ShowCursor(bool show_cursor);
+
+    /// Called when user passes the fullscreen parameter flag
+    void Fullscreen();
+
+    /// Called when a configuration change affects the minimal size of the window
+    void OnMinimalClientAreaChangeRequest(std::pair<u32, u32> minimal_size) override;
+
+    /// Is the window still open?
+    bool is_open = true;
+
+    /// Is the window being shown?
+    bool is_shown = true;
+
+    /// Internal SDL2 render window
+    SDL_Window* render_window{};
+
+    /// Keeps track of how often to update the title bar during gameplay
+    u32 last_time = 0;
+
+    /// Input subsystem to use with this window.
+    InputCommon::InputSubsystem* input_subsystem;
+
+    /// yuzu core instance
+    Core::System& system;
+};
+
+class DummyContext : public Core::Frontend::GraphicsContext {};
diff --git a/src/citron_cmd/emu_window/emu_window_sdl2_gl.cpp b/src/citron_cmd/emu_window/emu_window_sdl2_gl.cpp
new file mode 100644
index 000000000..ddcb048d6
--- /dev/null
+++ b/src/citron_cmd/emu_window/emu_window_sdl2_gl.cpp
@@ -0,0 +1,153 @@
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <algorithm>
+#include <cstdlib>
+#include <string>
+
+#define SDL_MAIN_HANDLED
+#include <SDL.h>
+
+#include <fmt/format.h>
+#include <glad/glad.h>
+#include "common/logging/log.h"
+#include "common/scm_rev.h"
+#include "common/settings.h"
+#include "common/string_util.h"
+#include "core/core.h"
+#include "input_common/main.h"
+#include "video_core/renderer_base.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl2_gl.h"
+
+class SDLGLContext : public Core::Frontend::GraphicsContext {
+public:
+    explicit SDLGLContext(SDL_Window* window_) : window{window_} {
+        context = SDL_GL_CreateContext(window);
+    }
+
+    ~SDLGLContext() {
+        DoneCurrent();
+        SDL_GL_DeleteContext(context);
+    }
+
+    void SwapBuffers() override {
+        SDL_GL_SwapWindow(window);
+    }
+
+    void MakeCurrent() override {
+        if (is_current) {
+            return;
+        }
+        is_current = SDL_GL_MakeCurrent(window, context) == 0;
+    }
+
+    void DoneCurrent() override {
+        if (!is_current) {
+            return;
+        }
+        SDL_GL_MakeCurrent(window, nullptr);
+        is_current = false;
+    }
+
+private:
+    SDL_Window* window;
+    SDL_GLContext context;
+    bool is_current = false;
+};
+
+bool EmuWindow_SDL2_GL::SupportsRequiredGLExtensions() {
+    std::vector<std::string_view> unsupported_ext;
+
+    // Extensions required to support some texture formats.
+    if (!GLAD_GL_EXT_texture_compression_s3tc) {
+        unsupported_ext.push_back("EXT_texture_compression_s3tc");
+    }
+    if (!GLAD_GL_ARB_texture_compression_rgtc) {
+        unsupported_ext.push_back("ARB_texture_compression_rgtc");
+    }
+
+    for (const auto& extension : unsupported_ext) {
+        LOG_CRITICAL(Frontend, "Unsupported GL extension: {}", extension);
+    }
+
+    return unsupported_ext.empty();
+}
+
+EmuWindow_SDL2_GL::EmuWindow_SDL2_GL(InputCommon::InputSubsystem* input_subsystem_,
+                                     Core::System& system_, bool fullscreen)
+    : EmuWindow_SDL2{input_subsystem_, system_} {
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 6);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_COMPATIBILITY);
+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
+    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
+    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
+    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 0);
+    SDL_GL_SetAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 1);
+    if (Settings::values.renderer_debug) {
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
+    }
+    SDL_GL_SetSwapInterval(0);
+
+    std::string window_title = fmt::format("yuzu {} | {}-{}", Common::g_build_fullname,
+                                           Common::g_scm_branch, Common::g_scm_desc);
+    render_window =
+        SDL_CreateWindow(window_title.c_str(),
+                         SDL_WINDOWPOS_UNDEFINED, // x position
+                         SDL_WINDOWPOS_UNDEFINED, // y position
+                         Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height,
+                         SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
+
+    if (render_window == nullptr) {
+        LOG_CRITICAL(Frontend, "Failed to create SDL2 window! {}", SDL_GetError());
+        exit(1);
+    }
+
+    strict_context_required = strcmp(SDL_GetCurrentVideoDriver(), "wayland") == 0;
+
+    SetWindowIcon();
+
+    if (fullscreen) {
+        Fullscreen();
+        ShowCursor(false);
+    }
+
+    window_context = SDL_GL_CreateContext(render_window);
+    core_context = CreateSharedContext();
+
+    if (window_context == nullptr) {
+        LOG_CRITICAL(Frontend, "Failed to create SDL2 GL context: {}", SDL_GetError());
+        exit(1);
+    }
+    if (core_context == nullptr) {
+        LOG_CRITICAL(Frontend, "Failed to create shared SDL2 GL context: {}", SDL_GetError());
+        exit(1);
+    }
+
+    if (!gladLoadGLLoader(static_cast<GLADloadproc>(SDL_GL_GetProcAddress))) {
+        LOG_CRITICAL(Frontend, "Failed to initialize GL functions! {}", SDL_GetError());
+        exit(1);
+    }
+
+    if (!SupportsRequiredGLExtensions()) {
+        LOG_CRITICAL(Frontend, "GPU does not support all required OpenGL extensions! Exiting...");
+        exit(1);
+    }
+
+    OnResize();
+    OnMinimalClientAreaChangeRequest(GetActiveConfig().min_client_area_size);
+    SDL_PumpEvents();
+    LOG_INFO(Frontend, "yuzu Version: {} | {}-{}", Common::g_build_fullname, Common::g_scm_branch,
+             Common::g_scm_desc);
+    Settings::LogSettings();
+}
+
+EmuWindow_SDL2_GL::~EmuWindow_SDL2_GL() {
+    core_context.reset();
+    SDL_GL_DeleteContext(window_context);
+}
+
+std::unique_ptr<Core::Frontend::GraphicsContext> EmuWindow_SDL2_GL::CreateSharedContext() const {
+    return std::make_unique<SDLGLContext>(render_window);
+}
diff --git a/src/citron_cmd/emu_window/emu_window_sdl2_gl.h b/src/citron_cmd/emu_window/emu_window_sdl2_gl.h
new file mode 100644
index 000000000..39346e704
--- /dev/null
+++ b/src/citron_cmd/emu_window/emu_window_sdl2_gl.h
@@ -0,0 +1,37 @@
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include "core/frontend/emu_window.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl2.h"
+
+namespace Core {
+class System;
+}
+
+namespace InputCommon {
+class InputSubsystem;
+}
+
+class EmuWindow_SDL2_GL final : public EmuWindow_SDL2 {
+public:
+    explicit EmuWindow_SDL2_GL(InputCommon::InputSubsystem* input_subsystem_, Core::System& system_,
+                               bool fullscreen);
+    ~EmuWindow_SDL2_GL();
+
+    std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override;
+
+private:
+    /// Whether the GPU and driver supports the OpenGL extension required
+    bool SupportsRequiredGLExtensions();
+
+    using SDL_GLContext = void*;
+
+    /// The OpenGL context associated with the window
+    SDL_GLContext window_context;
+
+    /// The OpenGL context associated with the core
+    std::unique_ptr<Core::Frontend::GraphicsContext> core_context;
+};
diff --git a/src/citron_cmd/emu_window/emu_window_sdl2_null.cpp b/src/citron_cmd/emu_window/emu_window_sdl2_null.cpp
new file mode 100644
index 000000000..259192f3c
--- /dev/null
+++ b/src/citron_cmd/emu_window/emu_window_sdl2_null.cpp
@@ -0,0 +1,51 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <cstdlib>
+#include <memory>
+#include <string>
+
+#include <fmt/format.h>
+
+#include "common/logging/log.h"
+#include "common/scm_rev.h"
+#include "video_core/renderer_null/renderer_null.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl2_null.h"
+
+#ifdef YUZU_USE_EXTERNAL_SDL2
+// Include this before SDL.h to prevent the external from including a dummy
+#define USING_GENERATED_CONFIG_H
+#include <SDL_config.h>
+#endif
+
+#include <SDL.h>
+
+EmuWindow_SDL2_Null::EmuWindow_SDL2_Null(InputCommon::InputSubsystem* input_subsystem_,
+                                         Core::System& system_, bool fullscreen)
+    : EmuWindow_SDL2{input_subsystem_, system_} {
+    const std::string window_title = fmt::format("yuzu {} | {}-{} (Vulkan)", Common::g_build_name,
+                                                 Common::g_scm_branch, Common::g_scm_desc);
+    render_window =
+        SDL_CreateWindow(window_title.c_str(), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+                         Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height,
+                         SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
+
+    SetWindowIcon();
+
+    if (fullscreen) {
+        Fullscreen();
+        ShowCursor(false);
+    }
+
+    OnResize();
+    OnMinimalClientAreaChangeRequest(GetActiveConfig().min_client_area_size);
+    SDL_PumpEvents();
+    LOG_INFO(Frontend, "yuzu Version: {} | {}-{} (Null)", Common::g_build_name,
+             Common::g_scm_branch, Common::g_scm_desc);
+}
+
+EmuWindow_SDL2_Null::~EmuWindow_SDL2_Null() = default;
+
+std::unique_ptr<Core::Frontend::GraphicsContext> EmuWindow_SDL2_Null::CreateSharedContext() const {
+    return std::make_unique<DummyContext>();
+}
diff --git a/src/citron_cmd/emu_window/emu_window_sdl2_null.h b/src/citron_cmd/emu_window/emu_window_sdl2_null.h
new file mode 100644
index 000000000..35aee286d
--- /dev/null
+++ b/src/citron_cmd/emu_window/emu_window_sdl2_null.h
@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+
+#include "core/frontend/emu_window.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl2.h"
+
+namespace Core {
+class System;
+}
+
+namespace InputCommon {
+class InputSubsystem;
+}
+
+class EmuWindow_SDL2_Null final : public EmuWindow_SDL2 {
+public:
+    explicit EmuWindow_SDL2_Null(InputCommon::InputSubsystem* input_subsystem_,
+                                 Core::System& system, bool fullscreen);
+    ~EmuWindow_SDL2_Null() override;
+
+    std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override;
+};
diff --git a/src/citron_cmd/emu_window/emu_window_sdl2_vk.cpp b/src/citron_cmd/emu_window/emu_window_sdl2_vk.cpp
new file mode 100644
index 000000000..8b916f05c
--- /dev/null
+++ b/src/citron_cmd/emu_window/emu_window_sdl2_vk.cpp
@@ -0,0 +1,93 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <cstdlib>
+#include <memory>
+#include <string>
+
+#include <fmt/format.h>
+
+#include "common/logging/log.h"
+#include "common/scm_rev.h"
+#include "video_core/renderer_vulkan/renderer_vulkan.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl2_vk.h"
+
+#include <SDL.h>
+#include <SDL_syswm.h>
+
+EmuWindow_SDL2_VK::EmuWindow_SDL2_VK(InputCommon::InputSubsystem* input_subsystem_,
+                                     Core::System& system_, bool fullscreen)
+    : EmuWindow_SDL2{input_subsystem_, system_} {
+    const std::string window_title = fmt::format("yuzu {} | {}-{} (Vulkan)", Common::g_build_name,
+                                                 Common::g_scm_branch, Common::g_scm_desc);
+    render_window =
+        SDL_CreateWindow(window_title.c_str(), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+                         Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height,
+                         SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
+
+    SDL_SysWMinfo wm;
+    SDL_VERSION(&wm.version);
+    if (SDL_GetWindowWMInfo(render_window, &wm) == SDL_FALSE) {
+        LOG_CRITICAL(Frontend, "Failed to get information from the window manager: {}",
+                     SDL_GetError());
+        std::exit(EXIT_FAILURE);
+    }
+
+    SetWindowIcon();
+
+    if (fullscreen) {
+        Fullscreen();
+        ShowCursor(false);
+    }
+
+    switch (wm.subsystem) {
+#ifdef SDL_VIDEO_DRIVER_WINDOWS
+    case SDL_SYSWM_TYPE::SDL_SYSWM_WINDOWS:
+        window_info.type = Core::Frontend::WindowSystemType::Windows;
+        window_info.render_surface = reinterpret_cast<void*>(wm.info.win.window);
+        break;
+#endif
+#ifdef SDL_VIDEO_DRIVER_X11
+    case SDL_SYSWM_TYPE::SDL_SYSWM_X11:
+        window_info.type = Core::Frontend::WindowSystemType::X11;
+        window_info.display_connection = wm.info.x11.display;
+        window_info.render_surface = reinterpret_cast<void*>(wm.info.x11.window);
+        break;
+#endif
+#ifdef SDL_VIDEO_DRIVER_WAYLAND
+    case SDL_SYSWM_TYPE::SDL_SYSWM_WAYLAND:
+        window_info.type = Core::Frontend::WindowSystemType::Wayland;
+        window_info.display_connection = wm.info.wl.display;
+        window_info.render_surface = wm.info.wl.surface;
+        break;
+#endif
+#ifdef SDL_VIDEO_DRIVER_COCOA
+    case SDL_SYSWM_TYPE::SDL_SYSWM_COCOA:
+        window_info.type = Core::Frontend::WindowSystemType::Cocoa;
+        window_info.render_surface = SDL_Metal_CreateView(render_window);
+        break;
+#endif
+#ifdef SDL_VIDEO_DRIVER_ANDROID
+    case SDL_SYSWM_TYPE::SDL_SYSWM_ANDROID:
+        window_info.type = Core::Frontend::WindowSystemType::Android;
+        window_info.render_surface = reinterpret_cast<void*>(wm.info.android.window);
+        break;
+#endif
+    default:
+        LOG_CRITICAL(Frontend, "Window manager subsystem {} not implemented", wm.subsystem);
+        std::exit(EXIT_FAILURE);
+        break;
+    }
+
+    OnResize();
+    OnMinimalClientAreaChangeRequest(GetActiveConfig().min_client_area_size);
+    SDL_PumpEvents();
+    LOG_INFO(Frontend, "yuzu Version: {} | {}-{} (Vulkan)", Common::g_build_name,
+             Common::g_scm_branch, Common::g_scm_desc);
+}
+
+EmuWindow_SDL2_VK::~EmuWindow_SDL2_VK() = default;
+
+std::unique_ptr<Core::Frontend::GraphicsContext> EmuWindow_SDL2_VK::CreateSharedContext() const {
+    return std::make_unique<DummyContext>();
+}
diff --git a/src/citron_cmd/emu_window/emu_window_sdl2_vk.h b/src/citron_cmd/emu_window/emu_window_sdl2_vk.h
new file mode 100644
index 000000000..9467d164a
--- /dev/null
+++ b/src/citron_cmd/emu_window/emu_window_sdl2_vk.h
@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+
+#include "core/frontend/emu_window.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl2.h"
+
+namespace Core {
+class System;
+}
+
+namespace InputCommon {
+class InputSubsystem;
+}
+
+class EmuWindow_SDL2_VK final : public EmuWindow_SDL2 {
+public:
+    explicit EmuWindow_SDL2_VK(InputCommon::InputSubsystem* input_subsystem_, Core::System& system,
+                               bool fullscreen);
+    ~EmuWindow_SDL2_VK() override;
+
+    std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override;
+};
diff --git a/src/citron_cmd/precompiled_headers.h b/src/citron_cmd/precompiled_headers.h
new file mode 100644
index 000000000..aabae730b
--- /dev/null
+++ b/src/citron_cmd/precompiled_headers.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_precompiled_headers.h"
diff --git a/src/citron_cmd/sdl_config.cpp b/src/citron_cmd/sdl_config.cpp
new file mode 100644
index 000000000..6e0f254b6
--- /dev/null
+++ b/src/citron_cmd/sdl_config.cpp
@@ -0,0 +1,262 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// SDL will break our main function in yuzu-cmd if we don't define this before adding SDL.h
+#define SDL_MAIN_HANDLED
+#include <SDL.h>
+
+#include "common/logging/log.h"
+#include "input_common/main.h"
+#include "sdl_config.h"
+
+const std::array<int, Settings::NativeButton::NumButtons> SdlConfig::default_buttons = {
+    SDL_SCANCODE_A, SDL_SCANCODE_S, SDL_SCANCODE_Z, SDL_SCANCODE_X, SDL_SCANCODE_T,
+    SDL_SCANCODE_G, SDL_SCANCODE_F, SDL_SCANCODE_H, SDL_SCANCODE_Q, SDL_SCANCODE_W,
+    SDL_SCANCODE_M, SDL_SCANCODE_N, SDL_SCANCODE_1, SDL_SCANCODE_2, SDL_SCANCODE_B,
+};
+
+const std::array<int, Settings::NativeMotion::NumMotions> SdlConfig::default_motions = {
+    SDL_SCANCODE_7,
+    SDL_SCANCODE_8,
+};
+
+const std::array<std::array<int, 4>, Settings::NativeAnalog::NumAnalogs> SdlConfig::default_analogs{
+    {
+        {
+            SDL_SCANCODE_UP,
+            SDL_SCANCODE_DOWN,
+            SDL_SCANCODE_LEFT,
+            SDL_SCANCODE_RIGHT,
+        },
+        {
+            SDL_SCANCODE_I,
+            SDL_SCANCODE_K,
+            SDL_SCANCODE_J,
+            SDL_SCANCODE_L,
+        },
+    }};
+
+const std::array<int, 2> SdlConfig::default_stick_mod = {
+    SDL_SCANCODE_D,
+    0,
+};
+
+const std::array<int, 2> SdlConfig::default_ringcon_analogs{{
+    0,
+    0,
+}};
+
+SdlConfig::SdlConfig(const std::optional<std::string> config_path) {
+    Initialize(config_path);
+    ReadSdlValues();
+    SaveSdlValues();
+}
+
+SdlConfig::~SdlConfig() {
+    if (global) {
+        SdlConfig::SaveAllValues();
+    }
+}
+
+void SdlConfig::ReloadAllValues() {
+    Reload();
+    ReadSdlValues();
+    SaveSdlValues();
+}
+
+void SdlConfig::SaveAllValues() {
+    SaveValues();
+    SaveSdlValues();
+}
+
+void SdlConfig::ReadSdlValues() {
+    ReadSdlControlValues();
+}
+
+void SdlConfig::ReadSdlControlValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Controls));
+
+    Settings::values.players.SetGlobal(!IsCustomConfig());
+    for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
+        ReadSdlPlayerValues(p);
+    }
+    if (IsCustomConfig()) {
+        EndGroup();
+        return;
+    }
+    ReadDebugControlValues();
+    ReadHidbusValues();
+
+    EndGroup();
+}
+
+void SdlConfig::ReadSdlPlayerValues(const std::size_t player_index) {
+    std::string player_prefix;
+    if (type != ConfigType::InputProfile) {
+        player_prefix.append("player_").append(ToString(player_index)).append("_");
+    }
+
+    auto& player = Settings::values.players.GetValue()[player_index];
+    if (IsCustomConfig()) {
+        const auto profile_name =
+            ReadStringSetting(std::string(player_prefix).append("profile_name"));
+        if (profile_name.empty()) {
+            // Use the global input config
+            player = Settings::values.players.GetValue(true)[player_index];
+            player.profile_name = "";
+            return;
+        }
+    }
+
+    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
+        auto& player_buttons = player.buttons[i];
+
+        player_buttons = ReadStringSetting(
+            std::string(player_prefix).append(Settings::NativeButton::mapping[i]), default_param);
+        if (player_buttons.empty()) {
+            player_buttons = default_param;
+        }
+    }
+
+    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
+        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
+            default_analogs[i][3], default_stick_mod[i], 0.5f);
+        auto& player_analogs = player.analogs[i];
+
+        player_analogs = ReadStringSetting(
+            std::string(player_prefix).append(Settings::NativeAnalog::mapping[i]), default_param);
+        if (player_analogs.empty()) {
+            player_analogs = default_param;
+        }
+    }
+
+    for (int i = 0; i < Settings::NativeMotion::NumMotions; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_motions[i]);
+        auto& player_motions = player.motions[i];
+
+        player_motions = ReadStringSetting(
+            std::string(player_prefix).append(Settings::NativeMotion::mapping[i]), default_param);
+        if (player_motions.empty()) {
+            player_motions = default_param;
+        }
+    }
+}
+
+void SdlConfig::ReadDebugControlValues() {
+    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
+        auto& debug_pad_buttons = Settings::values.debug_pad_buttons[i];
+        debug_pad_buttons = ReadStringSetting(
+            std::string("debug_pad_").append(Settings::NativeButton::mapping[i]), default_param);
+        if (debug_pad_buttons.empty()) {
+            debug_pad_buttons = default_param;
+        }
+    }
+    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
+        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
+            default_analogs[i][3], default_stick_mod[i], 0.5f);
+        auto& debug_pad_analogs = Settings::values.debug_pad_analogs[i];
+        debug_pad_analogs = ReadStringSetting(
+            std::string("debug_pad_").append(Settings::NativeAnalog::mapping[i]), default_param);
+        if (debug_pad_analogs.empty()) {
+            debug_pad_analogs = default_param;
+        }
+    }
+}
+
+void SdlConfig::ReadHidbusValues() {
+    const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+        0, 0, default_ringcon_analogs[0], default_ringcon_analogs[1], 0, 0.05f);
+    auto& ringcon_analogs = Settings::values.ringcon_analogs;
+
+    ringcon_analogs = ReadStringSetting(std::string("ring_controller"), default_param);
+    if (ringcon_analogs.empty()) {
+        ringcon_analogs = default_param;
+    }
+}
+
+void SdlConfig::SaveSdlValues() {
+    LOG_DEBUG(Config, "Saving SDL configuration values");
+    SaveSdlControlValues();
+
+    WriteToIni();
+}
+
+void SdlConfig::SaveSdlControlValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Controls));
+
+    Settings::values.players.SetGlobal(!IsCustomConfig());
+    for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
+        SaveSdlPlayerValues(p);
+    }
+    if (IsCustomConfig()) {
+        EndGroup();
+        return;
+    }
+    SaveDebugControlValues();
+    SaveHidbusValues();
+
+    EndGroup();
+}
+
+void SdlConfig::SaveSdlPlayerValues(const std::size_t player_index) {
+    std::string player_prefix;
+    if (type != ConfigType::InputProfile) {
+        player_prefix = std::string("player_").append(ToString(player_index)).append("_");
+    }
+
+    const auto& player = Settings::values.players.GetValue()[player_index];
+    if (IsCustomConfig() && player.profile_name.empty()) {
+        // No custom profile selected
+        return;
+    }
+
+    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
+        WriteStringSetting(std::string(player_prefix).append(Settings::NativeButton::mapping[i]),
+                           player.buttons[i], std::make_optional(default_param));
+    }
+    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
+        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
+            default_analogs[i][3], default_stick_mod[i], 0.5f);
+        WriteStringSetting(std::string(player_prefix).append(Settings::NativeAnalog::mapping[i]),
+                           player.analogs[i], std::make_optional(default_param));
+    }
+    for (int i = 0; i < Settings::NativeMotion::NumMotions; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_motions[i]);
+        WriteStringSetting(std::string(player_prefix).append(Settings::NativeMotion::mapping[i]),
+                           player.motions[i], std::make_optional(default_param));
+    }
+}
+
+void SdlConfig::SaveDebugControlValues() {
+    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
+        WriteStringSetting(std::string("debug_pad_").append(Settings::NativeButton::mapping[i]),
+                           Settings::values.debug_pad_buttons[i],
+                           std::make_optional(default_param));
+    }
+    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
+        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
+            default_analogs[i][3], default_stick_mod[i], 0.5f);
+        WriteStringSetting(std::string("debug_pad_").append(Settings::NativeAnalog::mapping[i]),
+                           Settings::values.debug_pad_analogs[i],
+                           std::make_optional(default_param));
+    }
+}
+
+void SdlConfig::SaveHidbusValues() {
+    const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+        0, 0, default_ringcon_analogs[0], default_ringcon_analogs[1], 0, 0.05f);
+    WriteStringSetting(std::string("ring_controller"), Settings::values.ringcon_analogs,
+                       std::make_optional(default_param));
+}
+
+std::vector<Settings::BasicSetting*>& SdlConfig::FindRelevantList(Settings::Category category) {
+    return Settings::values.linkage.by_category[category];
+}
diff --git a/src/citron_cmd/sdl_config.h b/src/citron_cmd/sdl_config.h
new file mode 100644
index 000000000..1fd1c692d
--- /dev/null
+++ b/src/citron_cmd/sdl_config.h
@@ -0,0 +1,49 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "frontend_common/config.h"
+
+class SdlConfig final : public Config {
+public:
+    explicit SdlConfig(std::optional<std::string> config_path);
+    ~SdlConfig() override;
+
+    void ReloadAllValues() override;
+    void SaveAllValues() override;
+
+protected:
+    void ReadSdlValues();
+    void ReadSdlPlayerValues(std::size_t player_index);
+    void ReadSdlControlValues();
+    void ReadHidbusValues() override;
+    void ReadDebugControlValues() override;
+    void ReadPathValues() override {}
+    void ReadShortcutValues() override {}
+    void ReadUIValues() override {}
+    void ReadUIGamelistValues() override {}
+    void ReadUILayoutValues() override {}
+    void ReadMultiplayerValues() override {}
+
+    void SaveSdlValues();
+    void SaveSdlPlayerValues(std::size_t player_index);
+    void SaveSdlControlValues();
+    void SaveHidbusValues() override;
+    void SaveDebugControlValues() override;
+    void SavePathValues() override {}
+    void SaveShortcutValues() override {}
+    void SaveUIValues() override {}
+    void SaveUIGamelistValues() override {}
+    void SaveUILayoutValues() override {}
+    void SaveMultiplayerValues() override {}
+
+    std::vector<Settings::BasicSetting*>& FindRelevantList(Settings::Category category) override;
+
+public:
+    static const std::array<int, Settings::NativeButton::NumButtons> default_buttons;
+    static const std::array<int, Settings::NativeMotion::NumMotions> default_motions;
+    static const std::array<std::array<int, 4>, Settings::NativeAnalog::NumAnalogs> default_analogs;
+    static const std::array<int, 2> default_stick_mod;
+    static const std::array<int, 2> default_ringcon_analogs;
+};