Prepare for v6.0.0

Rerun lupdate and lrelease
Merge remote-tracking branch 'origin/weblate'
2026-10-12 03:24:00 +00:00 · 2024-06-05 22:42:28 -05:00 · 2024-06-05 00:28:11 -05:00 · 2024-06-05 00:26:59 -05:00 · 2024-06-04 02:09:15 +00:00 · 2024-06-02 21:52:35 -05:00
947 changed files with 56902 additions and 215938 deletions
@@ -1,10 +1,12 @@
 ---
 name: Bug report
-about: Create a report to help us address issues in Moonlight
+about: Follow the troubleshooting guide before reporting a bug

 ---
 **READ ME FIRST!**
-This issue tracker is not the right place to ask for troubleshooting help if you're not able to connect or stream at all. For those requests, please use the #pc-help channel on our Discord server where there are many more people who can help (or direct you back here if it looks like a Moonlight bug after all). https://discord.gg/MySTSdq
+If you're here because something basic is not working (like gamepad input, video, or similar), it's probably something specific to your setup, so make sure you've gone through the Troubleshooting Guide first: https://github.com/moonlight-stream/moonlight-docs/wiki/Troubleshooting
+
+If you still have trouble with basic functionality after following the guide, join our Discord server where there are many other volunteers who can help (or direct you back here if it looks like a Moonlight bug after all). https://moonlight-stream.org/discord

 **Describe the bug**
 A clear and concise description of what the bug is.
@@ -26,14 +28,22 @@ List the games you've tried that exhibit the issue. To see if the issue is game-
 - If so, which settings have been changed?
 - Does the problem still occur after reverting settings back to default?

+**Gamepad-related issues (please complete if problem is gamepad-related)**
+- Do you have any gamepads connected to your host PC directly?
+- Does the problem still remain if you stream the desktop and use https://html5gamepad.com to test your gamepad?
+  - Instructions for streaming the desktop can be found here: https://github.com/moonlight-stream/moonlight-docs/wiki/Setup-Guide
+
 **Client PC details (please complete the following information)**
 - OS: [e.g. Windows 10 1809]
 - Moonlight Version: [e.g. v0.9.0]
+ - GPU: [e.g. Intel HD Graphics 520]
+ - Linux package type (if applicable): [e.g. Flatpak]

 **Server PC details (please complete the following information)**
 - OS: [e.g. Windows 10 1809]
- - GeForce Experience version: [e.g. 3.16.0.140]
- - Nvidia GPU driver: [e.g. 417.35]
+ - Sunshine or GeForce Experience version: [e.g. Sunshine v0.21.0]
+ - GPU: [e.g. AMD Radeon RX 7900 XT]
+ - GPU driver: [e.g. 24.1.1]

 **Moonlight Logs (please attach)**
 - On Windows, `Moonlight-###.log` files can be found in `%TEMP%`. Simply type that into the File Explorer path field to navigate there.
@@ -0,0 +1 @@
+blank_issues_enabled: false
@@ -0,0 +1,4 @@
+issuesOpened: >
+  If this is a question about Moonlight or you need help troubleshooting a streaming problem, please use the help channels on our [Discord server](https://moonlight-stream.org/discord) instead of GitHub issues. There are many more people available on Discord to help you and answer your questions.<br /><br />
+  This issue tracker should only be used for specific bugs or feature requests.<br /><br />
+  Thank you, and happy streaming!
@@ -9,7 +9,11 @@
 	url = https://github.com/gabomdq/SDL_GameControllerDB.git
 [submodule "soundio/libsoundio"]
 	path = soundio/libsoundio
-	url = https://github.com/andrewrk/libsoundio.git
+	url = https://github.com/cgutman/libsoundio.git
 [submodule "h264bitstream/h264bitstream"]
 	path = h264bitstream/h264bitstream
 	url = https://github.com/aizvorski/h264bitstream.git
+[submodule "libs"]
+	path = libs
+	url = https://github.com/cgutman/moonlight-qt-prebuilts.git
+	shallow = true
@@ -1,71 +0,0 @@
-language: cpp
-
-git:
-  depth: 1
-
-matrix:
-  include:
-    - os: osx
-      osx_image: xcode10.2
-      compiler: clang
-      env: TRAVIS_TARGET=osx
-      addons:
-        homebrew:
-          packages:
-            - qt
-    - os: linux
-      sudo: required
-      dist: xenial
-      compiler: gcc
-      env: TRAVIS_TARGET=steamlink
-      addons:
-        apt:
-          packages:
-            - libc6:i386
-            - libstdc++6:i386
-    - os: linux
-      sudo: required
-      dist: xenial
-      compiler: gcc
-      env: TRAVIS_TARGET=linux
-      addons:
-        apt:
-          sources:
-            - sourceline: 'ppa:beineri/opt-qt597-xenial'
-            - sourceline: 'ppa:jonathonf/ffmpeg-4'
-          packages:
-            - qt59base
-            - qt59quickcontrols2
-            - qt59svg
-            - libesd0-dev
-            - libgl-dev
-            - libegl1-mesa-dev
-            - libxkbcommon-dev
-            - wayland-protocols
-            - libopus-dev
-            - libavcodec-dev
-            - libavutil-dev
-            - libva-dev
-            - libvdpau-dev
-
-install:
-    - '[ "$TRAVIS_TARGET" != osx ] || brew link --force qt'
-    - if [[ "$TRAVIS_TARGET" = "osx" ]]; then nvm use node && npm install --global create-dmg; fi
-    - if [[ "$TRAVIS_TARGET" = "linux" ]]; then export SDL2_VER=2.0.9 && wget https://www.libsdl.org/release/SDL2-$SDL2_VER.tar.gz && tar -xvf SDL2-$SDL2_VER.tar.gz && cd SDL2-$SDL2_VER && ./configure && make -j$(nproc) && sudo make install && cd ..; fi
-    - if [[ "$TRAVIS_TARGET" = "linux" ]]; then export SDL2_TTF_VER=2.0.15 && wget https://www.libsdl.org/projects/SDL_ttf/release/SDL2_ttf-$SDL2_TTF_VER.tar.gz && tar -xvf SDL2_ttf-$SDL2_TTF_VER.tar.gz && cd SDL2_ttf-$SDL2_TTF_VER && ./configure && make -j$(nproc) && sudo make install && cd ..; fi
-    - if [[ "$TRAVIS_TARGET" = "steamlink" ]]; then git clone --depth=1 https://github.com/ValveSoftware/steamlink-sdk.git $HOME/steamlink-sdk; fi
-
-before_script:
-    - '[ "$TRAVIS_TARGET" != "linux" ] || source /opt/qt59/bin/qt59-env.sh'
-    - '[ "$TRAVIS_TARGET" = "steamlink" ] || qmake -v'
-    - '[[ "$TRAVIS_TARGET" != linux || "$CXX" != clang++ ]] || export QMAKESPEC=linux-clang'
-    - '[[ "$TRAVIS_TARGET" != linux || "$CXX" != g++     ]] || export QMAKESPEC=linux-g++'
-    - '[ "$TRAVIS_TARGET" != osx ]                          || export QMAKESPEC=macx-clang'
-    - '[ "$TRAVIS_TARGET" != "steamlink" ]                  || export STEAMLINK_SDK_PATH=$HOME/steamlink-sdk'
-
-script:
-    - '[ "$TRAVIS_TARGET" != "linux" ] || qmake moonlight-qt.pro -spec $QMAKESPEC'
-    - '[ "$TRAVIS_TARGET" != "linux" ] || make -j$(nproc) debug'
-    - '[ "$TRAVIS_TARGET" != "linux" ] || make -j$(nproc) release'
-    - '[ "$TRAVIS_TARGET" != "osx" ] || scripts/generate-dmg.sh Release'
-    - '[ "$TRAVIS_TARGET" != "steamlink" ] || scripts/build-steamlink-app.sh'
@@ -12,8 +12,11 @@ contains(QT_ARCH, i386) {
 contains(QT_ARCH, x86_64) {
    LIBS += -L$$PWD/../libs/windows/lib/x64
 }
+contains(QT_ARCH, arm64) {
+    LIBS += -L$$PWD/../libs/windows/lib/arm64
+}

-LIBS += -lNktHookLib
+LIBS += -ldetours
 DEFINES += ANTIHOOKING_LIBRARY
 SOURCES += antihookingprotection.cpp
 HEADERS += antihookingprotection.h
@@ -1,6 +1,9 @@
 #include "antihookingprotection.h"

-#include <NktHookLib.h>
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+
+#include <detours.h>

 typedef HMODULE (WINAPI *LoadLibraryAFunc)(LPCSTR lpLibFileName);
 typedef HMODULE (WINAPI *LoadLibraryWFunc)(LPCWSTR lpLibFileName);
@@ -12,25 +15,35 @@ class AntiHookingProtection
 public:
    static void enable()
    {
-    #ifdef QT_DEBUG
-        s_HookManager.SetEnableDebugOutput(true);
-    #endif
+        DetourTransactionBegin();
+        DetourUpdateThread(GetCurrentThread());

-        HINSTANCE kernel32Handle = NktHookLibHelpers::GetModuleBaseAddress(L"kernel32.dll");
-        SIZE_T hookId;
+        s_RealLoadLibraryA = LoadLibraryA;
+        DetourAttach(&(PVOID&)s_RealLoadLibraryA, LoadLibraryAHook);

-        s_HookManager.Hook(&hookId, (LPVOID*)&s_RealLoadLibraryA,
-                           NktHookLibHelpers::GetProcedureAddress(kernel32Handle, "LoadLibraryA"),
-                           (LPVOID)AntiHookingProtection::LoadLibraryAHook);
-        s_HookManager.Hook(&hookId, (LPVOID*)&s_RealLoadLibraryW,
-                           NktHookLibHelpers::GetProcedureAddress(kernel32Handle, "LoadLibraryW"),
-                           (LPVOID)AntiHookingProtection::LoadLibraryWHook);
-        s_HookManager.Hook(&hookId, (LPVOID*)&s_RealLoadLibraryExA,
-                           NktHookLibHelpers::GetProcedureAddress(kernel32Handle, "LoadLibraryExA"),
-                           (LPVOID)AntiHookingProtection::LoadLibraryExAHook);
-        s_HookManager.Hook(&hookId, (LPVOID*)&s_RealLoadLibraryExW,
-                           NktHookLibHelpers::GetProcedureAddress(kernel32Handle, "LoadLibraryExW"),
-                           (LPVOID)AntiHookingProtection::LoadLibraryExWHook);
+        s_RealLoadLibraryW = LoadLibraryW;
+        DetourAttach(&(PVOID&)s_RealLoadLibraryW, LoadLibraryWHook);
+
+        s_RealLoadLibraryExA = LoadLibraryExA;
+        DetourAttach(&(PVOID&)s_RealLoadLibraryExA, LoadLibraryExAHook);
+
+        s_RealLoadLibraryExW = LoadLibraryExW;
+        DetourAttach(&(PVOID&)s_RealLoadLibraryExW, LoadLibraryExWHook);
+
+        DetourTransactionCommit();
+    }
+
+    static void disable()
+    {
+        DetourTransactionBegin();
+        DetourUpdateThread(GetCurrentThread());
+
+        DetourDetach(&(PVOID&)s_RealLoadLibraryA, LoadLibraryAHook);
+        DetourDetach(&(PVOID&)s_RealLoadLibraryW, LoadLibraryWHook);
+        DetourDetach(&(PVOID&)s_RealLoadLibraryExA, LoadLibraryExAHook);
+        DetourDetach(&(PVOID&)s_RealLoadLibraryExW, LoadLibraryExWHook);
+
+        DetourTransactionCommit();
    }

 private:
@@ -124,37 +137,79 @@ private:
        return s_RealLoadLibraryExW(lpLibFileName, hFile, dwFlags);
    }

-    static CNktHookLib s_HookManager;
    static LoadLibraryAFunc s_RealLoadLibraryA;
    static LoadLibraryWFunc s_RealLoadLibraryW;
    static LoadLibraryExAFunc s_RealLoadLibraryExA;
    static LoadLibraryExWFunc s_RealLoadLibraryExW;

    static constexpr LPCWSTR k_BlacklistedDlls[] = {
-        // This DLL shipped with ASUS Sonic Radar 3 improperly handles
-        // D3D9 exclusive fullscreen in a way that causes CreateDeviceEx()
-        // to deadlock. https://github.com/moonlight-stream/moonlight-qt/issues/102
-        L"NahimicOSD.dll",
+        // These A-Volute DLLs shipped with various audio driver packages improperly handle
+        // D3D9 exclusive fullscreen in a way that causes CreateDeviceEx() to deadlock.
+        // https://github.com/moonlight-stream/moonlight-qt/issues/102
+        L"NahimicOSD.dll", // ASUS Sonic Radar 3
+        L"SSAudioOSD.dll", // SteelSeries headsets
+        L"SS2OSD.dll", // ASUS Sonic Studio 2
+        L"Nahimic2OSD.dll",
+        L"NahimicMSIOSD.dll",
+        L"nhAsusPhoebusOSD.dll", // ASUS Phoebus

        // This DLL has been seen in several crash reports. Some Googling
        // suggests it's highly unstable and causes issues in many games.
        L"EZFRD32.dll",
        L"EZFRD64.dll",

-        // These are the dList DLLs for Optimus hybrid graphics DDI.
+        // These are the older dList/AppInit DLLs for Optimus hybrid graphics DDI.
        // https://docs.microsoft.com/en-us/windows-hardware/drivers/display/hybrid-system-ddi
        //
-        // We forcefully block them from loading because Optimus has a bug that
-        // deadlocks DXVA2 when we present with D3DPRESENT_DONOTWAIT. This will prevent
-        // Optimus from ever using the dGPU even if the user has requested it.
-        // https://github.com/moonlight-stream/moonlight-qt/issues/240
-        // https://github.com/moonlight-stream/moonlight-qt/issues/235
-        L"nvdlist.dll",
-        L"nvdlistx.dll",
+        // These seem to cause a crash in PresentEx() in full-screen exclusive mode.
+        // This block will prevent Optimus from ever using the dGPU even if the user has requested it.
+        // https://github.com/moonlight-stream/moonlight-qt/issues/386
+        //
+        // d3d9!CSwapChain::BltToHybridPrimary+0x200:
+        // 00007ffa`23f37e58 488b01          mov     rax,qword ptr [rcx] ds:00000000`00000038=????????????????
+        // 00 0000004e`496ff4e0 00007ffa`23f39e2c d3d9!CSwapChain::BltToHybridPrimary+0x200
+        // 01 0000004e`496ff880 00007ffa`23ee39ce d3d9!CSwapChain::FlipToSurface+0x15c
+        // 02 0000004e`496ff900 00007ffa`23f4dd75 d3d9!CSwapChain::PresentMain+0x3e13e
+        // 03 0000004e`496ffab0 00007ffa`23f4dccd d3d9!CBaseDevice::PresentMain+0x9d
+        // 04 0000004e`496ffb00 00007ff7`8e31016f d3d9!CBaseDevice::PresentEx+0xbd
+        // 05 0000004e`496ffb50 00007ff7`8e30df1e Moonlight!DXVA2Renderer::renderFrame+0x61f [C:\moonlight-qt\app\streaming\video\ffmpeg-renderers\dxva2.cpp @ 1035]
+        // 06 0000004e`496ffd50 00007ff7`8e30e46a Moonlight!Pacer::renderFrame+0x3e [C:\moonlight-qt\app\streaming\video\ffmpeg-renderers\pacer\pacer.cpp @ 265]
+        // 07 (Inline Function) --------`-------- Moonlight!Pacer::renderLastFrameAndUnlock+0x197 [C:\moonlight-qt\app\streaming\video\ffmpeg-renderers\pacer\pacer.cpp @ 156]
+        // 08 0000004e`496ffda0 00007ffa`14476978 Moonlight!Pacer::renderThread+0x1ca [C:\moonlight-qt\app\streaming\video\ffmpeg-renderers\pacer\pacer.cpp @ 88]
+        // 09 0000004e`496ffde0 00007ffa`14476ee2 SDL2!SDL_RunThread+0x38 [C:\Users\camer\SDL\src\thread\SDL_thread.c @ 276]
+        // 0a 0000004e`496ffe10 00007ffa`2aae0e82 SDL2!RunThread+0x12 [C:\Users\camer\SDL\src\thread\windows\SDL_systhread.c @ 83]
+        // 0b 0000004e`496ffe40 00007ffa`2d627bd4 ucrtbase!thread_start<unsigned int (__cdecl*)(void *),1>+0x42
+        // 0c 0000004e`496ffe70 00007ffa`2da4ce51 kernel32!BaseThreadInitThunk+0x14
+        // 0d 0000004e`496ffea0 00000000`00000000 ntdll!RtlUserThreadStart+0x21
+        //
+        L"nvinit.dll",
+        L"nvinitx.dll",
+
+        // In some unknown circumstances, RTSS tries to hook in the middle of an instruction, leaving garbage
+        // code inside d3d9.dll that causes a crash when executed:
+        //
+        // 0:000> u
+        // d3d9!D3D9GetCurrentOwnershipMode+0x5d:
+        // 00007ff8`95b95861 9b              wait
+        // 00007ff8`95b95862 a7              cmps    dword ptr [rsi],dword ptr [rdi]   <--- crash happens here
+        // 00007ff8`95b95863 ff              ???
+        // 00007ff8`95b95864 bfe8ca8a00      mov     edi,8ACAE8h
+        // 00007ff8`95b95869 00eb            add     bl,ch
+        // 00007ff8`95b9586b f1              ???
+        // 00007ff8`95b9586c b808000000      mov     eax,8
+        // 00007ff8`95b95871 ebe6            jmp     d3d9!D3D9GetCurrentOwnershipMode+0x55 (00007ff8`95b95859)
+        //
+        // Disassembling starting at the exact address of the attempted hook yields the intended jmp instruction
+        //
+        // 0:000> u d3d9!D3D9GetCurrentOwnershipMode+0x5c:
+        // 00007ff8`95b95860 e99ba7ffbf      jmp     00007ff8`55b90000
+        //
+        // Since the RTSS OSD doesn't even work with DXVA2, we'll just block the hooks entirely.
+        L"RTSSHooks.dll",
+        L"RTSSHooks64.dll",
    };
 };

-CNktHookLib AntiHookingProtection::s_HookManager;
 LoadLibraryAFunc AntiHookingProtection::s_RealLoadLibraryA;
 LoadLibraryWFunc AntiHookingProtection::s_RealLoadLibraryW;
 LoadLibraryExAFunc AntiHookingProtection::s_RealLoadLibraryExA;
@@ -163,14 +218,26 @@ LoadLibraryExWFunc AntiHookingProtection::s_RealLoadLibraryExW;
 AH_EXPORT void AntiHookingDummyImport() {}

 extern "C"
-BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID)
+BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 {
+    if (DetourIsHelperProcess()) {
+        return TRUE;
+    }
+
    switch (fdwReason)
    {
    case DLL_PROCESS_ATTACH:
+        DetourRestoreAfterWith();
        AntiHookingProtection::enable();
        DisableThreadLibraryCalls(hinstDLL);
        break;
+    case DLL_PROCESS_DETACH:
+        // Ignore DLL_PROCESS_DETACH on process exit. No need to waste time
+        // unhooking everything if the whole process is being destroyed.
+        if (lpvReserved == NULL) {
+            AntiHookingProtection::disable();
+        }
+        break;
    }

    return TRUE;
@@ -1,51 +1,64 @@
 # Moonlight PC

-[Moonlight PC](https://moonlight-stream.org) is an open source implementation of NVIDIA's GameStream, as used by the NVIDIA Shield, but built to run on Windows, Mac, and Linux. This client is the successor to [Moonlight Chrome](https://github.com/moonlight-stream/moonlight-chrome) for streaming on PC.
+[Moonlight PC](https://moonlight-stream.org) is an open source PC client for NVIDIA GameStream and [Sunshine](https://github.com/LizardByte/Sunshine).

-Moonlight also has mobile versions for [Android](https://github.com/moonlight-stream/moonlight-android) and  [iOS](https://github.com/moonlight-stream/moonlight-ios).
+Moonlight also has mobile versions for [Android](https://github.com/moonlight-stream/moonlight-android) and [iOS](https://github.com/moonlight-stream/moonlight-ios).

-You can follow development on our [Discord server](https://discord.gg/6ERtzFY).
+You can follow development on our [Discord server](https://moonlight-stream.org/discord) and help translate Moonlight into your language on [Weblate](https://hosted.weblate.org/projects/moonlight/moonlight-qt/).

- [![Windows AppVeyor Status](https://ci.appveyor.com/api/projects/status/glj5cxqwy2w3bglv/branch/master?svg=true)](https://ci.appveyor.com/project/cgutman/moonlight-qt/branch/master)
- [![Mac and Linux Travis CI Status](https://travis-ci.org/moonlight-stream/moonlight-qt.svg?branch=master)](https://travis-ci.org/moonlight-stream/moonlight-qt)
+ [![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/glj5cxqwy2w3bglv/branch/master?svg=true)](https://ci.appveyor.com/project/cgutman/moonlight-qt/branch/master)
+ [![Downloads](https://img.shields.io/github/downloads/moonlight-stream/moonlight-qt/total)](https://github.com/moonlight-stream/moonlight-qt/releases)
+ [![Translation Status](https://hosted.weblate.org/widgets/moonlight/-/moonlight-qt/svg-badge.svg)](https://hosted.weblate.org/projects/moonlight/moonlight-qt/)

 ## Features
 - Hardware accelerated video decoding on Windows, Mac, and Linux
- - Supports streaming at up to 120 FPS (high refresh rate monitor recommended)
- - Supports streaming at 720p, 1080p, 1440p, 4K, and the client PC's native screen resolution
- - 5.1 surround sound audio
- - HEVC support for better image quality at reduced bandwidth
- - Keyboard and mouse support
- - Gamepad support with force feedback for up to 4 players
+ - H.264, HEVC, and AV1 codec support (AV1 requires Sunshine and a supported host GPU)
+ - HDR streaming support
+ - 7.1 surround sound audio support
+ - 10-point multitouch support (Sunshine only)
+ - Gamepad support with force feedback and motion controls for up to 16 players
+ - Support for both pointer capture (for games) and direct mouse control (for remote desktop)
+ - Support for passing system-wide keyboard shortcuts like Alt+Tab to the host
 
 ## Downloads
 - [Windows, macOS, and Steam Link](https://github.com/moonlight-stream/moonlight-qt/releases)
 - [Snap (for Ubuntu-based Linux distros)](https://snapcraft.io/moonlight)
 - [Flatpak (for other Linux distros)](https://flathub.org/apps/details/com.moonlight_stream.Moonlight)
+- [AppImage](https://github.com/moonlight-stream/moonlight-qt/releases)
+- [Raspberry Pi 4](https://github.com/moonlight-stream/moonlight-docs/wiki/Installing-Moonlight-Qt-on-Raspberry-Pi-4)
+- [Generic ARM SBC packages for Debian](https://github.com/moonlight-stream/moonlight-docs/wiki/Installing-Moonlight-Qt-on-ARM%E2%80%90based-Single-Board-Computers) (not for Raspberry Pi)
+- [Experimental RISC-V SBC packages for Debian](https://github.com/moonlight-stream/moonlight-docs/wiki/Installing-Moonlight-Qt-on-RISC%E2%80%90V-Single-Board-Computers)
+- [NVIDIA Jetson and Nintendo Switch (Ubuntu L4T)](https://github.com/moonlight-stream/moonlight-docs/wiki/Installing-Moonlight-Qt-on-Linux4Tegra-(L4T)-Ubuntu)
+
+#### Special Thanks
+
+[![Hosted By: Cloudsmith](https://img.shields.io/badge/OSS%20hosting%20by-cloudsmith-blue?logo=cloudsmith&style=flat-square)](https://cloudsmith.com)
+
+Hosting for Moonlight's Debian and L4T package repositories is graciously provided for free by [Cloudsmith](https://cloudsmith.com).

 ## Building
-### General Build Requirements
-* Qt 5.9 SDK or later

-### Windows-specific Build Requirements
-* Windows 7 or later
-* [Visual Studio](https://visualstudio.microsoft.com/downloads/) 2017 (Community edition is fine)
-* Select MSVC Desktop toolchain during Qt installation
-* [DirectX SDK](https://www.microsoft.com/en-us/download/details.aspx?id=6812)
+### Windows Build Requirements
+* Qt 5.15 SDK or later. Qt 6 is also supported for x64 and ARM64 builds.
+* [Visual Studio 2022](https://visualstudio.microsoft.com/downloads/) (Community edition is fine)
+* Select **MSVC** option during Qt installation. MinGW is not supported.
 * [7-Zip](https://www.7-zip.org/) (only if building installers for non-development PCs)
-* [WiX Toolset](http://wixtoolset.org/releases/) v3.11 or later (only if building installers for non-development PCs)

-### Mac-specific Build Requirements
-* macOS Sierra (10.12) or later
-* Xcode 10
+### macOS Build Requirements
+* Qt 6.4 SDK or later
+* Xcode 13 or later
 * [create-dmg](https://github.com/sindresorhus/create-dmg) (only if building DMGs for use on non-development Macs)

-### Linux-specific Build Requirements
+### Linux/Unix Build Requirements
+* Qt 5.9 SDK or later. Qt 6 is also supported.
 * GCC or Clang
-* Install your distro equivalents of: `openssl-devel qt5-devel SDL2-devel ffmpeg-devel qt5-qtquickcontrols2-devel libva-devel libvdpau-devel opus-devel pulseaudio-libs-devel alsa-lib-devel SDL2_ttf-devel`
-* FFmpeg 4.0 is required to build. If your distro doesn't package FFmpeg 4.0, you can build and install it from source on http://ffmpeg.org/
+* Install the required packages:
+  * Debian/Ubuntu: `libegl1-mesa-dev libgl1-mesa-dev libopus-dev libqt5svg5-dev libsdl2-dev libsdl2-ttf-dev libssl-dev libavcodec-dev libavformat-dev libva-dev libvdpau-dev libxkbcommon-dev qtwayland5 qt5-qmake qtbase5-dev qtdeclarative5-dev qtquickcontrols2-5-dev wayland-protocols qml-module-qtquick-controls2 qml-module-qtquick-layouts qml-module-qtquick-window2 qml-module-qtquick2`
+  * RedHat/Fedora: `openssl-devel SDL2-devel SDL2_ttf-devel ffmpeg-devel qt5-qtsvg-devel qt5-qtquickcontrols2-devel libva-devel libvdpau-devel opus-devel pulseaudio-libs-devel alsa-lib-devel`
+* FFmpeg 4.0 or later is required to build. If your distro doesn't package FFmpeg 4.0 or later, you can build and install it from source on https://ffmpeg.org/
+* Building the Vulkan HDR renderer requires a `libplacebo-dev`/`libplacebo-devel` version of at least v338.0 and FFmpeg 6.1 or later.

-### Steam Link-specific Build Requirements
+### Steam Link Build Requirements
 * [Steam Link SDK](https://github.com/ValveSoftware/steamlink-sdk) cloned on your build system
 * STEAMLINK_SDK_PATH environment variable set to the Steam Link SDK path

@@ -53,14 +66,17 @@ You can follow development on our [Discord server](https://discord.gg/6ERtzFY).
 1. Install the latest Qt SDK (and optionally, the Qt Creator IDE) from https://www.qt.io/download
    * You can install Qt via Homebrew on macOS, but you will need to use `brew install qt --with-debug` to be able to create debug builds of Moonlight.
    * You may also use your Linux distro's package manager for the Qt SDK as long as the packages are Qt 5.9 or later.
-    * This step is not required for building on Steam Link, because the Steam Link SDK includes Qt 5.9.
+    * This step is not required for building on Steam Link, because the Steam Link SDK includes Qt 5.14.
 2. Run `git submodule update --init --recursive` from within `moonlight-qt/`
 3. Open the project in Qt Creator or build from qmake on the command line.
    * To build a binary for use on non-development machines, use the scripts in the `scripts` folder.
-        * For Windows builds, use `scripts\generate-installers.bat`. Execute this script from the root of the repository within a Qt command prompt. Ensure WiX and 7-Zip binary directories are in your `%PATH%`.
+        * For Windows builds, use `scripts\build-arch.bat` and `scripts\generate-bundle.bat`. Execute these scripts from the root of the repository within a Qt command prompt. Ensure  7-Zip binary directory is on your `%PATH%`.
        * For macOS builds, use `scripts/generate-dmg.sh`. Execute this script from the root of the repository and ensure Qt's `bin` folder is in your `$PATH`.
        * For Steam Link builds, run `scripts/build-steamlink-app.sh` from the root of the repository.
-    * To build from the command line for development use, run `qmake moonlight-qt.pro` then `make debug` or `make release`
+    * To build from the command line for development use on macOS or Linux, run `qmake moonlight-qt.pro` then `make debug` or `make release`
+    * To create an embedded build for a single-purpose device, use `qmake "CONFIG+=embedded" moonlight-qt.pro` and build normally.
+        * This build will lack windowed mode, Discord/Help links, and other features that don't make sense on an embedded device.
+        * For platforms with poor GPU performance, add `"CONFIG+=gpuslow"` to prefer direct KMSDRM rendering over GL/Vulkan renderers. Direct KMSDRM rendering can use dedicated YUV/RGB conversion and scaling hardware rather than slower GPU shaders for these operations.

 ## Contribute
 1. Fork us
@@ -5,7 +5,7 @@
 	<key>CFBundleExecutable</key>
 	<string>Moonlight</string>
 	<key>CFBundleGetInfoString</key>
-	<string>Stream games from your NVIDIA GameStream-enabled PC</string>
+	<string>Stream games and other applications from another PC</string>
 	<key>CFBundleIconFile</key>
 	<string>moonlight</string>
 	<key>CFBundleIdentifier</key>
@@ -17,11 +17,25 @@
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>LSMinimumSystemVersion</key>
-	<string>10.11</string>
+	<string>10.14</string>
 	<key>NSPrincipalClass</key>
 	<string>NSApplication</string>
 	<key>NSSupportsAutomaticGraphicsSwitching</key>
 	<true/>
+	<key>GCSupportedGameControllers</key>
+	<array>
+		<dict>
+			<key>ProfileName</key>
+			<string>ExtendedGamepad</string>
+		</dict>
+	</array>
+	<key>GCSupportsControllerUserInteraction</key>
+	<true/>
+	<key>NSAppTransportSecurity</key>
+	<dict>
+		<key>NSAllowsArbitraryLoads</key>
+		<true/>
+	</dict>
 	<key>CFBundleVersion</key>
 	<string>VERSION</string>
 	<key>CFBundleShortVersionString</key>
@@ -33,88 +33,127 @@ DEFINES += QT_DEPRECATED_WARNINGS
 DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0

 win32 {
-    INCLUDEPATH += \
-        $$PWD/../libs/windows/include \
-        $$(DXSDK_DIR)/Include
-
    contains(QT_ARCH, i386) {
        LIBS += -L$$PWD/../libs/windows/lib/x86
-        LIBS += -L$$(DXSDK_DIR)/Lib/x86
+        INCLUDEPATH += $$PWD/../libs/windows/include/x86
    }
    contains(QT_ARCH, x86_64) {
        LIBS += -L$$PWD/../libs/windows/lib/x64
-        LIBS += -L$$(DXSDK_DIR)/Lib/x64
+        INCLUDEPATH += $$PWD/../libs/windows/include/x64
+    }
+    contains(QT_ARCH, arm64) {
+        LIBS += -L$$PWD/../libs/windows/lib/arm64
+        INCLUDEPATH += $$PWD/../libs/windows/include/arm64
    }

+    INCLUDEPATH += $$PWD/../libs/windows/include
    LIBS += ws2_32.lib winmm.lib dxva2.lib ole32.lib gdi32.lib user32.lib d3d9.lib dwmapi.lib dbghelp.lib
+
+    # Work around a conflict with math.h inclusion between SDL and Qt 6
+    DEFINES += _USE_MATH_DEFINES
 }
 macx {
    INCLUDEPATH += $$PWD/../libs/mac/include
    INCLUDEPATH += $$PWD/../libs/mac/Frameworks/SDL2.framework/Versions/A/Headers
    INCLUDEPATH += $$PWD/../libs/mac/Frameworks/SDL2_ttf.framework/Versions/A/Headers
    LIBS += -L$$PWD/../libs/mac/lib -F$$PWD/../libs/mac/Frameworks
+
+    # QMake doesn't handle framework-style includes correctly on its own
+    QMAKE_CFLAGS += -F$$PWD/../libs/mac/Frameworks
+    QMAKE_CXXFLAGS += -F$$PWD/../libs/mac/Frameworks
+    QMAKE_OBJECTIVE_CFLAGS += -F$$PWD/../libs/mac/Frameworks
 }

 unix:!macx {
    CONFIG += link_pkgconfig
    PKGCONFIG += openssl sdl2 SDL2_ttf opus

-    # SLAudio is used on Steam Link
-    !config_SL {
-        CONFIG += soundio
-    }
+    !disable-ffmpeg {
+        packagesExist(libavcodec) {
+            PKGCONFIG += libavcodec libavutil
+            CONFIG += ffmpeg

-    soundio {
-        packagesExist(libpulse) {
-            PKGCONFIG += libpulse
-        }
-        packagesExist(alsa) {
-            PKGCONFIG += alsa
-        }
-    }
-
-    packagesExist(libavcodec) {
-        PKGCONFIG += libavcodec libavutil
-        CONFIG += ffmpeg
-
-        packagesExist(libva) {
-            packagesExist(libva-x11) {
-                CONFIG += libva-x11
+            !disable-libva {
+                packagesExist(libva) {
+                    !disable-x11 {
+                        packagesExist(libva-x11) {
+                            CONFIG += libva-x11
+                        }
+                    }
+                    !disable-wayland {
+                        packagesExist(libva-wayland) {
+                            CONFIG += libva-wayland
+                        }
+                    }
+                    !disable-libdrm {
+                        packagesExist(libva-drm) {
+                            CONFIG += libva-drm
+                        }
+                    }
+                    CONFIG += libva
+                }
            }
-            packagesExist(libva-wayland) {
-                CONFIG += libva-wayland
+
+            !disable-libvdpau {
+                packagesExist(vdpau) {
+                    CONFIG += libvdpau
+                }
            }
-            packagesExist(libva-drm) {
-                CONFIG += libva-drm
+
+            !disable-mmal {
+                packagesExist(mmal) {
+                    PKGCONFIG += mmal
+                    CONFIG += mmal
+                }
+            }
+
+            !disable-libdrm {
+                packagesExist(libdrm) {
+                    PKGCONFIG += libdrm
+                    CONFIG += libdrm
+                }
+            }
+
+            !disable-cuda {
+                packagesExist(ffnvcodec) {
+                    PKGCONFIG += ffnvcodec
+                    CONFIG += cuda
+                }
+            }
+
+            !disable-libplacebo {
+                packagesExist(libplacebo) {
+                    PKGCONFIG += libplacebo
+                    CONFIG += libplacebo
+                }
            }
-            CONFIG += libva
        }

-        packagesExist(vdpau) {
-            CONFIG += libvdpau
+        !disable-wayland {
+            packagesExist(wayland-client) {
+                CONFIG += wayland
+                PKGCONFIG += wayland-client
+            }
        }

-        packagesExist(mmal) {
-            PKGCONFIG += mmal
-            CONFIG += mmal
-        }
-
-        packagesExist(libdrm) {
-            PKGCONFIG += libdrm
-            CONFIG += libdrm
+        !disable-x11 {
+            packagesExist(x11) {
+                DEFINES += HAS_X11
+                PKGCONFIG += x11
+            }
        }
    }
 }
 win32 {
-    LIBS += -llibssl -llibcrypto -lSDL2 -lSDL2_ttf -lavcodec -lavutil -lopus -ld3dx9
+    LIBS += -llibssl -llibcrypto -lSDL2 -lSDL2_ttf -lavcodec -lavutil -lopus -ldxgi -ld3d11
    CONFIG += ffmpeg
 }
 win32:!winrt {
    CONFIG += soundio discord-rpc
 }
 macx {
-    LIBS += -lssl -lcrypto -lavcodec.58 -lavutil.56 -lopus -framework SDL2 -framework SDL2_ttf
-    LIBS += -lobjc -framework VideoToolbox -framework AVFoundation -framework CoreVideo -framework CoreGraphics -framework CoreMedia -framework AppKit
+    LIBS += -lssl -lcrypto -lavcodec.61 -lavutil.59 -lopus -framework SDL2 -framework SDL2_ttf
+    LIBS += -lobjc -framework VideoToolbox -framework AVFoundation -framework CoreVideo -framework CoreGraphics -framework CoreMedia -framework AppKit -framework Metal -framework QuartzCore

    # For libsoundio
    LIBS += -framework CoreAudio -framework AudioUnit
@@ -123,6 +162,9 @@ macx {
 }

 SOURCES += \
+    backend/nvaddress.cpp \
+    backend/nvapp.cpp \
+    cli/pair.cpp \
    main.cpp \
    backend/computerseeker.cpp \
    backend/identitymanager.cpp \
@@ -133,10 +175,18 @@ SOURCES += \
    backend/boxartmanager.cpp \
    backend/richpresencemanager.cpp \
    cli/commandlineparser.cpp \
+    cli/listapps.cpp \
    cli/quitstream.cpp \
    cli/startstream.cpp \
+    settings/compatfetcher.cpp \
+    settings/mappingfetcher.cpp \
    settings/streamingpreferences.cpp \
-    streaming/input.cpp \
+    streaming/input/abstouch.cpp \
+    streaming/input/gamepad.cpp \
+    streaming/input/input.cpp \
+    streaming/input/keyboard.cpp \
+    streaming/input/mouse.cpp \
+    streaming/input/reltouch.cpp \
    streaming/session.cpp \
    streaming/audio/audio.cpp \
    streaming/audio/renderers/sdlaud.cpp \
@@ -148,9 +198,15 @@ SOURCES += \
    settings/mappingmanager.cpp \
    gui/sdlgamepadkeynavigation.cpp \
    streaming/video/overlaymanager.cpp \
-    backend/systemproperties.cpp
+    backend/systemproperties.cpp \
+    wm.cpp

 HEADERS += \
+    backend/nvaddress.h \
+    backend/nvapp.h \
+    cli/pair.h \
+    settings/compatfetcher.h \
+    settings/mappingfetcher.h \
    utils.h \
    backend/computerseeker.h \
    backend/identitymanager.h \
@@ -161,10 +217,11 @@ HEADERS += \
    backend/boxartmanager.h \
    backend/richpresencemanager.h \
    cli/commandlineparser.h \
+    cli/listapps.h \
    cli/quitstream.h \
    cli/startstream.h \
    settings/streamingpreferences.h \
-    streaming/input.h \
+    streaming/input/input.h \
    streaming/session.h \
    streaming/audio/renderers/renderer.h \
    streaming/audio/renderers/sdl.h \
@@ -187,17 +244,15 @@ ffmpeg {
    SOURCES += \
        streaming/video/ffmpeg.cpp \
        streaming/video/ffmpeg-renderers/sdlvid.cpp \
-        streaming/video/ffmpeg-renderers/cuda.cpp \
-        streaming/video/ffmpeg-renderers/pacer/pacer.cpp \
-        streaming/video/ffmpeg-renderers/pacer/nullthreadedvsyncsource.cpp
+        streaming/video/ffmpeg-renderers/swframemapper.cpp \
+        streaming/video/ffmpeg-renderers/pacer/pacer.cpp

    HEADERS += \
        streaming/video/ffmpeg.h \
        streaming/video/ffmpeg-renderers/renderer.h \
        streaming/video/ffmpeg-renderers/sdlvid.h \
-        streaming/video/ffmpeg-renderers/cuda.h \
-        streaming/video/ffmpeg-renderers/pacer/pacer.h \
-        streaming/video/ffmpeg-renderers/pacer/nullthreadedvsyncsource.h
+        streaming/video/ffmpeg-renderers/swframemapper.h \
+        streaming/video/ffmpeg-renderers/pacer/pacer.h
 }
 libva {
    message(VAAPI renderer selected)
@@ -219,7 +274,7 @@ libva-wayland {
    PKGCONFIG += libva-wayland
    DEFINES += HAVE_LIBVA_WAYLAND
 }
-libva-wayland {
+libva-drm {
    message(VAAPI DRM support enabled)

    PKGCONFIG += libva-drm
@@ -238,6 +293,18 @@ mmal {
    DEFINES += HAVE_MMAL
    SOURCES += streaming/video/ffmpeg-renderers/mmal.cpp
    HEADERS += streaming/video/ffmpeg-renderers/mmal.h
+
+    # We suppress EGL usage when MMAL is available because MMAL has
+    # significantly better performance than EGL on the Pi. Setting
+    # this option allows EGL usage even if built with MMAL support.
+    #
+    # It is highly recommended to also build with 'gpuslow' to avoid
+    # EGL being preferred if direct DRM rendering is available.
+    allow-egl-with-mmal {
+        message(Allowing EGL usage with MMAL enabled)
+
+        DEFINES += ALLOW_EGL_WITH_MMAL
+    }
 }
 libdrm {
    message(DRM renderer selected)
@@ -245,11 +312,50 @@ libdrm {
    DEFINES += HAVE_DRM
    SOURCES += streaming/video/ffmpeg-renderers/drm.cpp
    HEADERS += streaming/video/ffmpeg-renderers/drm.h
+
+    linux {
+        message(Master hooks enabled)
+        SOURCES += masterhook.c masterhook_internal.c
+        LIBS += -ldl
+    }
+}
+cuda {
+    message(CUDA support enabled)
+
+    DEFINES += HAVE_CUDA
+    SOURCES += streaming/video/ffmpeg-renderers/cuda.cpp
+    HEADERS += streaming/video/ffmpeg-renderers/cuda.h
+
+    # ffnvcodec uses libdl in cuda_load_functions()/cuda_free_functions()
+    LIBS += -ldl
+}
+libplacebo {
+    message(Vulkan support enabled via libplacebo)
+
+    DEFINES += HAVE_LIBPLACEBO_VULKAN
+    SOURCES += \
+        streaming/video/ffmpeg-renderers/plvk.cpp \
+        streaming/video/ffmpeg-renderers/plvk_c.c
+    HEADERS += \
+        streaming/video/ffmpeg-renderers/plvk.h
+}
+config_EGL {
+    message(EGL renderer selected)
+
+    CONFIG += egl
+    DEFINES += HAVE_EGL
+    SOURCES += \
+        streaming/video/ffmpeg-renderers/eglvid.cpp \
+        streaming/video/ffmpeg-renderers/egl_extensions.cpp \
+        streaming/video/ffmpeg-renderers/eglimagefactory.cpp
+    HEADERS += \
+        streaming/video/ffmpeg-renderers/eglvid.h \
+        streaming/video/ffmpeg-renderers/eglimagefactory.h
 }
 config_SL {
    message(Steam Link build configuration selected)

-    DEFINES += STEAM_LINK HAVE_SLVIDEO HAVE_SLAUDIO
+    DEFINES += EMBEDDED_BUILD STEAM_LINK HAVE_SLVIDEO HAVE_SLAUDIO
    LIBS += -lSLVideo -lSLAudio

    SOURCES += \
@@ -259,22 +365,28 @@ config_SL {
        streaming/video/slvid.h \
        streaming/audio/renderers/slaud.h
 }
+win32 {
+    HEADERS += streaming/video/ffmpeg-renderers/dxutil.h
+}
 win32:!winrt {
-    message(DXVA2 renderer selected)
+    message(DXVA2 and D3D11VA renderers selected)

    SOURCES += \
        streaming/video/ffmpeg-renderers/dxva2.cpp \
+        streaming/video/ffmpeg-renderers/d3d11va.cpp \
        streaming/video/ffmpeg-renderers/pacer/dxvsyncsource.cpp

    HEADERS += \
        streaming/video/ffmpeg-renderers/dxva2.h \
+        streaming/video/ffmpeg-renderers/d3d11va.h \
        streaming/video/ffmpeg-renderers/pacer/dxvsyncsource.h
 }
 macx {
    message(VideoToolbox renderer selected)

    SOURCES += \
-        streaming/video/ffmpeg-renderers/vt.mm
+        streaming/video/ffmpeg-renderers/vt_avsamplelayer.mm \
+        streaming/video/ffmpeg-renderers/vt_metal.mm

    HEADERS += \
        streaming/video/ffmpeg-renderers/vt.h
@@ -292,11 +404,65 @@ discord-rpc {
    LIBS += -ldiscord-rpc
    DEFINES += HAVE_DISCORD
 }
+embedded {
+    message(Embedded build)
+
+    DEFINES += EMBEDDED_BUILD
+}
+glslow {
+    message(GL slow build)
+
+    DEFINES += GL_IS_SLOW
+}
+vkslow {
+    message(Vulkan slow build)
+
+    DEFINES += VULKAN_IS_SLOW
+}
+gpuslow {
+    message(GPU slow build)
+
+    DEFINES += GL_IS_SLOW VULKAN_IS_SLOW
+}
+wayland {
+    message(Wayland extensions enabled)
+
+    DEFINES += HAS_WAYLAND
+    SOURCES += streaming/video/ffmpeg-renderers/pacer/waylandvsyncsource.cpp
+    HEADERS += streaming/video/ffmpeg-renderers/pacer/waylandvsyncsource.h
+}

 RESOURCES += \
    resources.qrc \
    qml.qrc

+TRANSLATIONS += \
+    languages/qml_zh_CN.ts \
+    languages/qml_de.ts \
+    languages/qml_fr.ts \
+    languages/qml_nb_NO.ts \
+    languages/qml_ru.ts \
+    languages/qml_es.ts \
+    languages/qml_ja.ts \
+    languages/qml_vi.ts \
+    languages/qml_th.ts \
+    languages/qml_ko.ts \
+    languages/qml_hu.ts \
+    languages/qml_nl.ts \
+    languages/qml_sv.ts \
+    languages/qml_tr.ts \
+    languages/qml_uk.ts \
+    languages/qml_zh_TW.ts \
+    languages/qml_el.ts \
+    languages/qml_hi.ts \
+    languages/qml_it.ts \
+    languages/qml_pt.ts \
+    languages/qml_pt_BR.ts \
+    languages/qml_pl.ts \
+    languages/qml_cs.ts \
+    languages/qml_he.ts \
+    languages/qml_ckb.ts
+
 # Additional import path used to resolve QML modules in Qt Creator's code model
 QML_IMPORT_PATH =

@@ -387,7 +553,10 @@ macx {
    APP_BUNDLE_FRAMEWORKS.files = $$files(../libs/mac/Frameworks/*.framework, true) $$files(../libs/mac/lib/*.dylib, true)
    APP_BUNDLE_FRAMEWORKS.path = Contents/Frameworks

-    QMAKE_BUNDLE_DATA += APP_BUNDLE_RESOURCES APP_BUNDLE_FRAMEWORKS
+    APP_BUNDLE_PLIST.files = $$OUT_PWD/Info.plist
+    APP_BUNDLE_PLIST.path = Contents
+
+    QMAKE_BUNDLE_DATA += APP_BUNDLE_RESOURCES APP_BUNDLE_FRAMEWORKS APP_BUNDLE_PLIST

    QMAKE_RPATHDIR += @executable_path/../Frameworks
 }
@@ -6,17 +6,18 @@
 #include <QJsonObject>

 AutoUpdateChecker::AutoUpdateChecker(QObject *parent) :
-    QObject(parent),
-    m_Nam(this)
+    QObject(parent)
 {
+    m_Nam = new QNetworkAccessManager(this);
+
    // Never communicate over HTTP
-    m_Nam.setStrictTransportSecurityEnabled(true);
+    m_Nam->setStrictTransportSecurityEnabled(true);

    // Allow HTTP redirects
-    m_Nam.setRedirectPolicy(QNetworkRequest::NoLessSafeRedirectPolicy);
+    m_Nam->setRedirectPolicy(QNetworkRequest::NoLessSafeRedirectPolicy);

-    connect(&m_Nam, SIGNAL(finished(QNetworkReply*)),
-            this, SLOT(handleUpdateCheckRequestFinished(QNetworkReply*)));
+    connect(m_Nam, &QNetworkAccessManager::finished,
+            this, &AutoUpdateChecker::handleUpdateCheckRequestFinished);

    QString currentVersion(VERSION_STR);
    qDebug() << "Current Moonlight version:" << currentVersion;
@@ -28,10 +29,29 @@ AutoUpdateChecker::AutoUpdateChecker(QObject *parent) :

 void AutoUpdateChecker::start()
 {
-#if defined(Q_OS_WIN32) || defined(Q_OS_DARWIN) // Only run update checker on platforms without auto-update
+    if (!m_Nam) {
+        Q_ASSERT(m_Nam);
+        return;
+    }
+
+#if defined(Q_OS_WIN32) || defined(Q_OS_DARWIN) || defined(STEAM_LINK) || defined(APP_IMAGE) // Only run update checker on platforms without auto-update
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0) && QT_VERSION < QT_VERSION_CHECK(5, 15, 1) && !defined(QT_NO_BEARERMANAGEMENT)
+    // HACK: Set network accessibility to work around QTBUG-80947 (introduced in Qt 5.14.0 and fixed in Qt 5.15.1)
+    QT_WARNING_PUSH
+    QT_WARNING_DISABLE_DEPRECATED
+    m_Nam->setNetworkAccessible(QNetworkAccessManager::Accessible);
+    QT_WARNING_POP
+#endif
+
    // We'll get a callback when this is finished
    QUrl url("https://moonlight-stream.org/updates/qt.json");
-    m_Nam.get(QNetworkRequest(url));
+    QNetworkRequest request(url);
+#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)
+    request.setAttribute(QNetworkRequest::Http2AllowedAttribute, true);
+#else
+    request.setAttribute(QNetworkRequest::HTTP2AllowedAttribute, true);
+#endif
+    m_Nam->get(request);
 #endif
 }

@@ -43,13 +63,64 @@ void AutoUpdateChecker::parseStringToVersionQuad(QString& string, QVector<int>&
    }
 }

+QString AutoUpdateChecker::getPlatform()
+{
+#if defined(STEAM_LINK)
+    return QStringLiteral("steamlink");
+#elif defined(APP_IMAGE)
+    return QStringLiteral("appimage");
+#elif defined(Q_OS_DARWIN) && QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    // Qt 6 changed this from 'osx' to 'macos'. Use the old one
+    // to be consistent (and not require another entry in the manifest).
+    return QStringLiteral("osx");
+#else
+    return QSysInfo::productType();
+#endif
+}
+
+int AutoUpdateChecker::compareVersion(QVector<int>& version1, QVector<int>& version2) {
+    for (int i = 0;; i++) {
+        int v1Val = 0;
+        int v2Val = 0;
+
+        // Treat missing decimal places as 0
+        if (i < version1.count()) {
+            v1Val = version1[i];
+        }
+        if (i < version2.count()) {
+            v2Val = version2[i];
+        }
+        if (i >= version1.count() && i >= version2.count()) {
+            // Equal versions
+            return 0;
+        }
+
+        if (v1Val < v2Val) {
+            return -1;
+        }
+        else if (v1Val > v2Val) {
+            return 1;
+        }
+    }
+}
+
 void AutoUpdateChecker::handleUpdateCheckRequestFinished(QNetworkReply* reply)
 {
    Q_ASSERT(reply->isFinished());

+    // Delete the QNetworkAccessManager to free resources and
+    // prevent the bearer plugin from polling in the background.
+    m_Nam->deleteLater();
+    m_Nam = nullptr;
+
    if (reply->error() == QNetworkReply::NoError) {
        QTextStream stream(reply);
+
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+        stream.setEncoding(QStringConverter::Utf8);
+#else
        stream.setCodec("UTF-8");
+#endif

        // Read all data and queue the reply for deletion
        QString jsonString = stream.readAll();
@@ -88,47 +159,48 @@ void AutoUpdateChecker::handleUpdateCheckRequestFinished(QNetworkReply* reply)
                }

                if (updateObj["arch"] == QSysInfo::buildCpuArchitecture() &&
-                        updateObj["platform"] == QSysInfo::productType()) {
+                        updateObj["platform"] == getPlatform()) {
+
+                    // Check the kernel version minimum if one exists
+                    if (updateObj.contains("kernel_version_at_least") && updateObj["kernel_version_at_least"].isString()) {
+                        QVector<int> requiredVersionQuad;
+                        QVector<int> actualVersionQuad;
+
+                        QString requiredVersion = updateObj["kernel_version_at_least"].toString();
+                        QString actualVersion = QSysInfo::kernelVersion();
+                        parseStringToVersionQuad(requiredVersion, requiredVersionQuad);
+                        parseStringToVersionQuad(actualVersion, actualVersionQuad);
+
+                        if (compareVersion(actualVersionQuad, requiredVersionQuad) < 0) {
+                            qDebug() << "Skipping manifest entry due to kernel version (" << actualVersion << "<" << requiredVersion << ")";
+                            continue;
+                        }
+                    }
+
                    qDebug() << "Found update manifest match for current platform";

                    QString latestVersion = updateObj["version"].toString();
                    qDebug() << "Latest version of Moonlight for this platform is:" << latestVersion;

                    QVector<int> latestVersionQuad;
-
                    parseStringToVersionQuad(latestVersion, latestVersionQuad);

-                    for (int i = 0;; i++) {
-                        int latestVer = 0;
-                        int currentVer = 0;
-
-                        // Treat missing decimal places as 0
-                        if (i < latestVersionQuad.count()) {
-                            latestVer = latestVersionQuad[i];
-                        }
-                        if (i < m_CurrentVersionQuad.count()) {
-                            currentVer = m_CurrentVersionQuad[i];
-                        }
-                        if (i >= latestVersionQuad.count() && i >= m_CurrentVersionQuad.count()) {
-                            break;
-                        }
-
-                        if (currentVer < latestVer) {
-                            qDebug() << "Update available";
-
-                            emit onUpdateAvailable(updateObj["version"].toString(),
-                                                   updateObj["browser_url"].toString());
-                            return;
-                        }
-                        else if (currentVer > latestVer) {
-                            qDebug() << "Update manifest version lower than current version";
-                            return;
-                        }
+                    int res = compareVersion(m_CurrentVersionQuad, latestVersionQuad);
+                    if (res < 0) {
+                        // m_CurrentVersionQuad < latestVersionQuad
+                        qDebug() << "Update available";
+                        emit onUpdateAvailable(updateObj["version"].toString(),
+                                               updateObj["browser_url"].toString());
+                        return;
+                    }
+                    else if (res > 0) {
+                        qDebug() << "Update manifest version lower than current version";
+                        return;
+                    }
+                    else {
+                        qDebug() << "Update manifest version equal to current version";
+                        return;
                    }
-
-                    qDebug() << "Update manifest version equal to current version";
-
-                    return;
                }
            }
            else {
@@ -136,11 +208,11 @@ void AutoUpdateChecker::handleUpdateCheckRequestFinished(QNetworkReply* reply)
            }
        }

-        qWarning() << "No entry in update manifest found for current platform: "
-                   << QSysInfo::buildCpuArchitecture() << QSysInfo::productType();
+        qWarning() << "No entry in update manifest found for current platform:"
+                   << QSysInfo::buildCpuArchitecture() << getPlatform() << QSysInfo::kernelVersion();
    }
    else {
-        qWarning() << "Update checking failed with error: " << reply->error();
+        qWarning() << "Update checking failed with error:" << reply->error();
        reply->deleteLater();
    }
 }
@@ -20,6 +20,10 @@ private slots:
 private:
    void parseStringToVersionQuad(QString& string, QVector<int>& version);

+    int compareVersion(QVector<int>& version1, QVector<int>& version2);
+
+    QString getPlatform();
+
    QVector<int> m_CurrentVersionQuad;
-    QNetworkAccessManager m_Nam;
+    QNetworkAccessManager* m_Nam;
 };
@@ -46,8 +46,8 @@ public:
          m_Computer(computer),
          m_App(app)
    {
-        connect(this, SIGNAL(boxArtFetchCompleted(NvComputer*,NvApp,QUrl)),
-                boxArtManager, SLOT(handleBoxArtLoadComplete(NvComputer*,NvApp,QUrl)));
+        connect(this, &NetworkBoxArtLoadTask::boxArtFetchCompleted,
+                boxArtManager, &BoxArtManager::handleBoxArtLoadComplete);
    }

 signals:
@@ -71,10 +71,10 @@ private:

 QUrl BoxArtManager::loadBoxArt(NvComputer* computer, NvApp& app)
 {
-    // Try to open the cached file
-    QString cacheFilePath = getFilePathForBoxArt(computer, app.id);
-    if (QFile::exists(cacheFilePath)) {
-        return QUrl::fromLocalFile(cacheFilePath);
+    // Try to open the cached file if it exists and contains data
+    QFile cacheFile(getFilePathForBoxArt(computer, app.id));
+    if (cacheFile.exists() && cacheFile.size() > 0) {
+        return QUrl::fromLocalFile(cacheFile.fileName());
    }

    // If we get here, we need to fetch asynchronously.
@@ -87,6 +87,16 @@ QUrl BoxArtManager::loadBoxArt(NvComputer* computer, NvApp& app)
    return QUrl("qrc:/res/no_app_image.png");
 }

+void BoxArtManager::deleteBoxArt(NvComputer* computer)
+{
+    QDir dir(Path::getBoxArtCacheDir());
+
+    // Delete everything in this computer's box art directory
+    if (dir.cd(computer->uuid)) {
+        dir.removeRecursively();
+    }
+}
+
 void BoxArtManager::handleBoxArtLoadComplete(NvComputer* computer, NvApp app, QUrl image)
 {
    if (!image.isEmpty()) {
@@ -96,7 +106,7 @@ void BoxArtManager::handleBoxArtLoadComplete(NvComputer* computer, NvApp app, QU

 QUrl BoxArtManager::loadBoxArtFromNetwork(NvComputer* computer, int appId)
 {
-    NvHTTP http(computer->activeAddress, computer->serverCert);
+    NvHTTP http(computer);

    QString cachePath = getFilePathForBoxArt(computer, appId);
    QImage image;
@@ -109,6 +119,10 @@ QUrl BoxArtManager::loadBoxArtFromNetwork(NvComputer* computer, int appId)
        if (image.save(cachePath)) {
            return QUrl::fromLocalFile(cachePath);
        }
+        else {
+            // A failed save() may leave a zero byte file. Make sure that's removed.
+            QFile(cachePath).remove();
+        }
    }

    return QUrl();
@@ -18,6 +18,10 @@ public:
    QUrl
    loadBoxArt(NvComputer* computer, NvApp& app);

+    static
+    void
+    deleteBoxArt(NvComputer* computer);
+
 signals:
    void
    boxArtLoadComplete(NvComputer* computer, NvApp app, QUrl image);
@@ -1,6 +1,7 @@
 #include "computermanager.h"
+#include "boxartmanager.h"
 #include "nvhttp.h"
-#include "settings/streamingpreferences.h"
+#include "nvpairingmanager.h"

 #include <Limelight.h>
 #include <QtEndian>
@@ -9,7 +10,10 @@
 #include <QThreadPool>
 #include <QCoreApplication>

+#include <random>
+
 #define SER_HOSTS "hosts"
+#define SER_HOSTS_BACKUP "hostsbackup"

 class PcMonitorThread : public QThread
 {
@@ -26,22 +30,22 @@ public:
    }

 private:
-    bool tryPollComputer(QString address, bool& changed)
+    bool tryPollComputer(NvAddress address, bool& changed)
    {
-        NvHTTP http(address, m_Computer->serverCert);
+        NvHTTP http(address, 0, m_Computer->serverCert);

        QString serverInfo;
        try {
-            serverInfo = http.getServerInfo(NvHTTP::NvLogLevel::NVLL_NONE);
+            serverInfo = http.getServerInfo(NvHTTP::NvLogLevel::NVLL_NONE, true);
        } catch (...) {
            return false;
        }

-        NvComputer newState(address, serverInfo, QSslCertificate());
+        NvComputer newState(http, serverInfo);

        // Ensure the machine that responded is the one we intended to contact
        if (m_Computer->uuid != newState.uuid) {
-            qInfo() << "Found unexpected PC " << newState.name << " looking for " << m_Computer->name;
+            qInfo() << "Found unexpected PC" << newState.name << "looking for" << m_Computer->name;
            return false;
        }

@@ -51,9 +55,7 @@ private:

    bool updateAppList(bool& changed)
    {
-        Q_ASSERT(m_Computer->activeAddress != nullptr);
-
-        NvHTTP http(m_Computer->activeAddress, m_Computer->serverCert);
+        NvHTTP http(m_Computer);

        QVector<NvApp> appList;

@@ -67,12 +69,7 @@ private:
        }

        QWriteLocker lock(&m_Computer->lock);
-        if (m_Computer->appList != appList) {
-            m_Computer->appList = appList;
-            m_Computer->sortAppList();
-            changed = true;
-        }
-
+        changed = m_Computer->updateAppList(appList);
        return true;
    }

@@ -84,7 +81,7 @@ private:
            bool stateChanged = false;
            bool online = false;
            bool wasOnline = m_Computer->state == NvComputer::CS_ONLINE;
-            for (int i = 0; i < TRIES_BEFORE_OFFLINING && !online; i++) {
+            for (int i = 0; i < (wasOnline ? TRIES_BEFORE_OFFLINING : 1) && !online; i++) {
                for (auto& address : m_Computer->uniqueAddresses()) {
                    if (isInterruptionRequested()) {
                        return;
@@ -92,7 +89,7 @@ private:

                    if (tryPollComputer(address, stateChanged)) {
                        if (!wasOnline) {
-                            qInfo() << m_Computer->name << "is now online at" << m_Computer->activeAddress;
+                            qInfo() << m_Computer->name << "is now online at" << m_Computer->activeAddress.toString();
                        }
                        online = true;
                        break;
@@ -147,32 +144,65 @@ private:
    NvComputer* m_Computer;
 };

-ComputerManager::ComputerManager(QObject *parent)
-    : QObject(parent),
+ComputerManager::ComputerManager(StreamingPreferences* prefs)
+    : m_Prefs(prefs),
      m_PollingRef(0),
-      m_MdnsBrowser(nullptr)
+      m_MdnsBrowser(nullptr),
+      m_CompatFetcher(nullptr),
+      m_NeedsDelayedFlush(false)
 {
    QSettings settings;

+    // If there's a hosts backup copy, we must have failed to commit
+    // a previous update before exiting. Restore the backup now.
+    int hosts = settings.beginReadArray(SER_HOSTS_BACKUP);
+    if (hosts == 0) {
+        // If there's no host backup, read from the primary location.
+        settings.endArray();
+        hosts = settings.beginReadArray(SER_HOSTS);
+    }
+
    // Inflate our hosts from QSettings
-    int hosts = settings.beginReadArray(SER_HOSTS);
    for (int i = 0; i < hosts; i++) {
        settings.setArrayIndex(i);
        NvComputer* computer = new NvComputer(settings);
        m_KnownHosts[computer->uuid] = computer;
+        m_LastSerializedHosts[computer->uuid] = *computer;
    }
    settings.endArray();

+    // Fetch latest compatibility data asynchronously
+    m_CompatFetcher.start();
+
+    // Start the delayed flush thread to handle saveHosts() calls
+    m_DelayedFlushThread = new DelayedFlushThread(this);
+    m_DelayedFlushThread->start();
+
    // To quit in a timely manner, we must block additional requests
-    // after we receive the aboutToQuit() signal. This is neccessary
-    // because NvHTTP uses aboutToQuit() to abort requests in progres
+    // after we receive the aboutToQuit() signal. This is necessary
+    // because NvHTTP uses aboutToQuit() to abort requests in progress
    // while quitting, however this is a one time signal - additional
    // requests would not be aborted and block termination.
-    connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), this, SLOT(handleAboutToQuit()));
+    connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit, this, &ComputerManager::handleAboutToQuit);
 }

 ComputerManager::~ComputerManager()
 {
+    // Stop the delayed flush thread before acquiring the lock in write mode
+    // to avoid deadlocking with a flush that needs the lock in read mode.
+    {
+        // Wake the delayed flush thread
+        m_DelayedFlushThread->requestInterruption();
+        m_DelayedFlushCondition.wakeOne();
+
+        // Wait for it to terminate (and finish any pending flush)
+        m_DelayedFlushThread->wait();
+        delete m_DelayedFlushThread;
+
+        // Delayed flushes should have completed by now
+        Q_ASSERT(!m_NeedsDelayedFlush);
+    }
+
    QWriteLocker lock(&m_Lock);

    // Delete machines that haven't been resolved yet
@@ -202,18 +232,80 @@ ComputerManager::~ComputerManager()
    }
 }

+void DelayedFlushThread::run() {
+    for (;;) {
+        // Wait for a delayed flush request or an interruption
+        {
+            QMutexLocker locker(&m_ComputerManager->m_DelayedFlushMutex);
+
+            while (!QThread::currentThread()->isInterruptionRequested() && !m_ComputerManager->m_NeedsDelayedFlush) {
+                m_ComputerManager->m_DelayedFlushCondition.wait(&m_ComputerManager->m_DelayedFlushMutex);
+            }
+
+            // Bail without flushing if we woke up for an interruption alone.
+            // If we have both an interruption and a flush request, do the flush.
+            if (!m_ComputerManager->m_NeedsDelayedFlush) {
+                Q_ASSERT(QThread::currentThread()->isInterruptionRequested());
+                break;
+            }
+
+            // Reset the delayed flush flag to ensure any racing saveHosts() call will set it again
+            m_ComputerManager->m_NeedsDelayedFlush = false;
+
+            // Update the last serialized hosts map under the delayed flush mutex
+            m_ComputerManager->m_LastSerializedHosts.clear();
+            for (const NvComputer* computer : m_ComputerManager->m_KnownHosts) {
+                // Copy the current state of the NvComputer to allow us to check later if we need
+                // to serialize it again when attribute updates occur.
+                QReadLocker computerLock(&computer->lock);
+                m_ComputerManager->m_LastSerializedHosts[computer->uuid] = *computer;
+            }
+        }
+
+        // Perform the flush
+        {
+            QSettings settings;
+
+            // First, write to the backup location
+            settings.beginWriteArray(SER_HOSTS_BACKUP);
+            {
+                QReadLocker lock(&m_ComputerManager->m_Lock);
+                int i = 0;
+                for (const NvComputer* computer : m_ComputerManager->m_KnownHosts) {
+                    settings.setArrayIndex(i++);
+                    computer->serialize(settings, false);
+                }
+            }
+            settings.endArray();
+
+            // Next, write to the primary location
+            settings.remove(SER_HOSTS);
+            settings.beginWriteArray(SER_HOSTS);
+            {
+                QReadLocker lock(&m_ComputerManager->m_Lock);
+                int i = 0;
+                for (const NvComputer* computer : m_ComputerManager->m_KnownHosts) {
+                    settings.setArrayIndex(i++);
+                    computer->serialize(settings, true);
+                }
+            }
+            settings.endArray();
+
+            // Finally, delete the backup copy
+            settings.remove(SER_HOSTS_BACKUP);
+        }
+    }
+}
+
 void ComputerManager::saveHosts()
 {
-    QSettings settings;
-    QReadLocker lock(&m_Lock);
+    Q_ASSERT(m_DelayedFlushThread != nullptr && m_DelayedFlushThread->isRunning());

-    settings.remove(SER_HOSTS);
-    settings.beginWriteArray(SER_HOSTS);
-    for (int i = 0; i < m_KnownHosts.count(); i++) {
-        settings.setArrayIndex(i);
-        m_KnownHosts.value(m_KnownHosts.keys()[i])->serialize(settings);
-    }
-    settings.endArray();
+    // Punt to a worker thread because QSettings on macOS can take ages (> 500 ms)
+    // to persist our host list to disk (especially when a host has a bunch of apps).
+    QMutexLocker locker(&m_DelayedFlushMutex);
+    m_NeedsDelayedFlush = true;
+    m_DelayedFlushCondition.wakeOne();
 }

 QHostAddress ComputerManager::getBestGlobalAddressV6(QVector<QHostAddress> &addresses)
@@ -260,16 +352,15 @@ void ComputerManager::startPolling()
        return;
    }

-    StreamingPreferences prefs;
-
-    if (prefs.enableMdns) {
+    if (m_Prefs->enableMdns) {
        // Start an MDNS query for GameStream hosts
-        m_MdnsBrowser = new QMdnsEngine::Browser(&m_MdnsServer, "_nvstream._tcp.local.", &m_MdnsCache);
+        m_MdnsServer.reset(new QMdnsEngine::Server());
+        m_MdnsBrowser = new QMdnsEngine::Browser(m_MdnsServer.data(), "_nvstream._tcp.local.");
        connect(m_MdnsBrowser, &QMdnsEngine::Browser::serviceAdded,
                this, [this](const QMdnsEngine::Service& service) {
            qInfo() << "Discovered mDNS host:" << service.hostname();

-            MdnsPendingComputer* pendingComputer = new MdnsPendingComputer(&m_MdnsServer, service);
+            MdnsPendingComputer* pendingComputer = new MdnsPendingComputer(m_MdnsServer, service);
            connect(pendingComputer, &MdnsPendingComputer::resolvedHost,
                    this, &ComputerManager::handleMdnsServiceResolved);
            m_PendingResolution.append(pendingComputer);
@@ -305,8 +396,8 @@ void ComputerManager::startPollingComputer(NvComputer* computer)

    if (!pollingEntry->isActive()) {
        PcMonitorThread* thread = new PcMonitorThread(computer);
-        connect(thread, SIGNAL(computerStateChanged(NvComputer*)),
-                this, SLOT(handleComputerStateChanged(NvComputer*)));
+        connect(thread, &PcMonitorThread::computerStateChanged,
+                this, &ComputerManager::handleComputerStateChanged);
        pollingEntry->setActiveThread(thread);
        thread->start();
    }
@@ -325,7 +416,7 @@ void ComputerManager::handleMdnsServiceResolved(MdnsPendingComputer* computer,
            // address may not be reachable (if the user hasn't installed the IPv6 helper yet
            // or if this host lacks outbound IPv6 capability). We want to add IPv6 even if
            // it's not currently reachable.
-            addNewHost(address.toString(), true, v6Global);
+            addNewHost(NvAddress(address, computer->port()), true, NvAddress(v6Global, computer->port()));
            added = true;
            break;
        }
@@ -339,8 +430,7 @@ void ComputerManager::handleMdnsServiceResolved(MdnsPendingComputer* computer,
                if (address.isInSubnet(QHostAddress("fe80::"), 10) ||
                        address.isInSubnet(QHostAddress("fec0::"), 10) ||
                        address.isInSubnet(QHostAddress("fc00::"), 7)) {
-                    addNewHost(address.toString(), true, v6Global);
-                    added = true;
+                    addNewHost(NvAddress(address, computer->port()), true, NvAddress(v6Global, computer->port()));
                    break;
                }
            }
@@ -351,6 +441,19 @@ void ComputerManager::handleMdnsServiceResolved(MdnsPendingComputer* computer,
    computer->deleteLater();
 }

+void ComputerManager::saveHost(NvComputer *computer)
+{
+    // If no serializable properties changed, don't bother saving hosts
+    QMutexLocker lock(&m_DelayedFlushMutex);
+    QReadLocker computerLock(&computer->lock);
+    if (!m_LastSerializedHosts.value(computer->uuid).isEqualSerialized(*computer)) {
+        // Queue a request for a delayed flush to QSettings outside of the lock
+        computerLock.unlock();
+        lock.unlock();
+        saveHosts();
+    }
+}
+
 void ComputerManager::handleComputerStateChanged(NvComputer* computer)
 {
    emit computerStateChanged(computer);
@@ -360,15 +463,20 @@ void ComputerManager::handleComputerStateChanged(NvComputer* computer)
        emit quitAppCompleted(QVariant());
    }

-    // Save updated hosts to QSettings
-    saveHosts();
+    // Save updates to this host
+    saveHost(computer);
 }

 QVector<NvComputer*> ComputerManager::getComputers()
 {
    QReadLocker lock(&m_Lock);

-    return QVector<NvComputer*>::fromList(m_KnownHosts.values());
+    // Return a sorted host list
+    auto hosts = QVector<NvComputer*>::fromList(m_KnownHosts.values());
+    std::stable_sort(hosts.begin(), hosts.end(), [](const NvComputer* host1, const NvComputer* host2) {
+        return host1->name.toLower() < host2->name.toLower();
+    });
+    return hosts;
 }

 class DeferredHostDeletionTask : public QRunnable
@@ -392,12 +500,15 @@ public:
            m_ComputerManager->m_KnownHosts.remove(m_Computer->uuid);
        }

-        // Persist the new host list
+        // Persist the new host list with this computer deleted
        m_ComputerManager->saveHosts();

        // Delete the polling entry first. This will stop all polling threads too.
        delete pollingEntry;

+        // Delete cached box art
+        BoxArtManager::deleteBoxArt(m_Computer);
+
        // Finally, delete the computer itself. This must be done
        // last because the polling thread might be using it.
        delete m_Computer;
@@ -415,9 +526,28 @@ void ComputerManager::deleteHost(NvComputer* computer)
    QThreadPool::globalInstance()->start(new DeferredHostDeletionTask(this, computer));
 }

+void ComputerManager::renameHost(NvComputer* computer, QString name)
+{
+    {
+        QWriteLocker lock(&computer->lock);
+
+        computer->name = name;
+        computer->hasCustomName = true;
+    }
+
+    // Notify the UI of the state change
+    handleComputerStateChanged(computer);
+}
+
+void ComputerManager::clientSideAttributeUpdated(NvComputer* computer)
+{
+    // Notify the UI of the state change
+    handleComputerStateChanged(computer);
+}
+
 void ComputerManager::handleAboutToQuit()
 {
-    QWriteLocker lock(&m_Lock);
+    QReadLocker lock(&m_Lock);

    // Interrupt polling threads immediately, so they
    // avoid making additional requests while quitting
@@ -432,7 +562,8 @@ class PendingPairingTask : public QObject, public QRunnable

 public:
    PendingPairingTask(ComputerManager* computerManager, NvComputer* computer, QString pin)
-        : m_Computer(computer),
+        : m_ComputerManager(computerManager),
+          m_Computer(computer),
          m_Pin(pin)
    {
        connect(this, &PendingPairingTask::pairingCompleted,
@@ -445,32 +576,41 @@ signals:
 private:
    void run()
    {
-        NvPairingManager pairingManager(m_Computer->activeAddress);
+        NvPairingManager pairingManager(m_Computer);

        try {
           NvPairingManager::PairState result = pairingManager.pair(m_Computer->appVersion, m_Pin, m_Computer->serverCert);
           switch (result)
           {
           case NvPairingManager::PairState::PIN_WRONG:
-               emit pairingCompleted(m_Computer, "The PIN from the PC didn't match. Please try again.");
+               emit pairingCompleted(m_Computer, tr("The PIN from the PC didn't match. Please try again."));
               break;
           case NvPairingManager::PairState::FAILED:
-               emit pairingCompleted(m_Computer, "Pairing failed. Please try again.");
+               if (m_Computer->currentGameId != 0) {
+                   emit pairingCompleted(m_Computer, tr("You cannot pair while a previous session is still running on the host PC. Quit any running games or reboot the host PC, then try pairing again."));
+               }
+               else {
+                   emit pairingCompleted(m_Computer, tr("Pairing failed. Please try again."));
+               }
               break;
           case NvPairingManager::PairState::ALREADY_IN_PROGRESS:
-               emit pairingCompleted(m_Computer, "Another pairing attempt is already in progress.");
+               emit pairingCompleted(m_Computer, tr("Another pairing attempt is already in progress."));
               break;
           case NvPairingManager::PairState::PAIRED:
+               // Persist the newly pinned server certificate for this host
+               m_ComputerManager->saveHost(m_Computer);
+
               emit pairingCompleted(m_Computer, nullptr);
               break;
           }
        } catch (const GfeHttpResponseException& e) {
-            emit pairingCompleted(m_Computer, "GeForce Experience returned error: " + e.toQString());
+            emit pairingCompleted(m_Computer, tr("GeForce Experience returned error: %1").arg(e.toQString()));
        } catch (const QtNetworkReplyException& e) {
            emit pairingCompleted(m_Computer, e.toQString());
        }
    }

+    ComputerManager* m_ComputerManager;
    NvComputer* m_Computer;
    QString m_Pin;
 };
@@ -501,7 +641,7 @@ signals:
 private:
    void run()
    {
-        NvHTTP http(m_Computer->activeAddress, m_Computer->serverCert);
+        NvHTTP http(m_Computer);

        try {
            if (m_Computer->currentGameId != 0) {
@@ -514,8 +654,8 @@ private:
            }
            if (e.getStatusCode() == 599) {
                // 599 is a special code we make a custom message for
-                emit quitAppFailed("The running game wasn't started by this PC. "
-                                   "You must quit the game on the host PC manually or use the device that originally started the game.");
+                emit quitAppFailed(tr("The running game wasn't started by this PC. "
+                                      "You must quit the game on the host PC manually or use the device that originally started the game."));
            }
            else {
                emit quitAppFailed(e.toQString());
@@ -557,9 +697,10 @@ void ComputerManager::stopPollingAsync()
        m_PendingResolution.removeFirst();
    }

-    // Delete the browser to stop discovery
+    // Delete the browser and server to stop discovery and refresh polling
    delete m_MdnsBrowser;
    m_MdnsBrowser = nullptr;
+    m_MdnsServer.reset();

    // Interrupt all threads, but don't wait for them to terminate
    for (ComputerPollingEntry* entry : m_PollEntries) {
@@ -567,32 +708,58 @@ void ComputerManager::stopPollingAsync()
    }
 }

+void ComputerManager::addNewHostManually(QString address)
+{
+    QUrl url = QUrl::fromUserInput("moonlight://" + address);
+    if (url.isValid() && !url.host().isEmpty() && url.scheme() == "moonlight") {
+        // If there wasn't a port specified, use the default
+        addNewHost(NvAddress(url.host(), url.port(DEFAULT_HTTP_PORT)), false);
+    }
+    else {
+        emit computerAddCompleted(false, false);
+    }
+}
+
 class PendingAddTask : public QObject, public QRunnable
 {
    Q_OBJECT

 public:
-    PendingAddTask(ComputerManager* computerManager, QString address, QHostAddress mdnsIpv6Address, bool mdns)
+    PendingAddTask(ComputerManager* computerManager, NvAddress address, NvAddress mdnsIpv6Address, bool mdns)
        : m_ComputerManager(computerManager),
          m_Address(address),
          m_MdnsIpv6Address(mdnsIpv6Address),
-          m_Mdns(mdns)
+          m_Mdns(mdns),
+          m_AboutToQuit(false)
    {
        connect(this, &PendingAddTask::computerAddCompleted,
                computerManager, &ComputerManager::computerAddCompleted);
        connect(this, &PendingAddTask::computerStateChanged,
                computerManager, &ComputerManager::handleComputerStateChanged);
+        connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit,
+                this, &PendingAddTask::handleAboutToQuit);
    }

 signals:
-    void computerAddCompleted(QVariant success);
+    void computerAddCompleted(QVariant success, QVariant detectedPortBlocking);

    void computerStateChanged(NvComputer* computer);

 private:
+    void handleAboutToQuit()
+    {
+        m_AboutToQuit = true;
+    }
+
    QString fetchServerInfo(NvHTTP& http)
    {
        QString serverInfo;
+
+        // Do nothing if we're quitting
+        if (m_AboutToQuit) {
+            return QString();
+        }
+
        try {
            // There's a race condition between GameStream servers reporting presence over
            // mDNS and the HTTPS server being ready to respond to our queries. To work
@@ -615,7 +782,19 @@ private:
            return serverInfo;
        } catch (...) {
            if (!m_Mdns) {
-                emit computerAddCompleted(false);
+                unsigned int portTestResult;
+
+                if (m_ComputerManager->m_Prefs->detectNetworkBlocking) {
+                    // We failed to connect to the specified PC. Let's test to make sure this network
+                    // isn't blocking Moonlight, so we can tell the user about it.
+                    portTestResult = LiTestClientConnectivity("qt.conntest.moonlight-stream.org", 443,
+                                                              ML_PORT_FLAG_TCP_47984 | ML_PORT_FLAG_TCP_47989);
+                }
+                else {
+                    portTestResult = 0;
+                }
+
+                emit computerAddCompleted(false, portTestResult != 0 && portTestResult != ML_TEST_RESULT_INCONCLUSIVE);
            }
            return QString();
        }
@@ -623,15 +802,15 @@ private:

    void run()
    {
-        NvHTTP http(m_Address, QSslCertificate());
+        NvHTTP http(m_Address, 0, QSslCertificate());

-        qInfo() << "Processing new PC at" << m_Address << "from" << (m_Mdns ? "mDNS" : "user") << m_MdnsIpv6Address;
+        qInfo() << "Processing new PC at" << m_Address.toString() << "from" << (m_Mdns ? "mDNS" : "user") << "with IPv6 address" << m_MdnsIpv6Address.toString();

        // Perform initial serverinfo fetch over HTTP since we don't know which cert to use
        QString serverInfo = fetchServerInfo(http);
        if (serverInfo.isEmpty() && !m_MdnsIpv6Address.isNull()) {
            // Retry using the global IPv6 address if the IPv4 or link-local IPv6 address fails
-            http.setAddress(m_MdnsIpv6Address.toString());
+            http.setAddress(m_MdnsIpv6Address);
            serverInfo = fetchServerInfo(http);
        }
        if (serverInfo.isEmpty()) {
@@ -639,7 +818,7 @@ private:
        }

        // Create initial newComputer using HTTP serverinfo with no pinned cert
-        NvComputer* newComputer = new NvComputer(http.address(), serverInfo, QSslCertificate());
+        NvComputer* newComputer = new NvComputer(http, serverInfo);

        // Check if we have a record of this host UUID to pull the pinned cert
        NvComputer* existingComputer;
@@ -653,13 +832,14 @@ private:

        // Fetch serverinfo again over HTTPS with the pinned cert
        if (existingComputer != nullptr) {
+            Q_ASSERT(http.httpsPort() != 0);
            serverInfo = fetchServerInfo(http);
            if (serverInfo.isEmpty()) {
                return;
            }

            // Update the polled computer with the HTTPS information
-            NvComputer httpsComputer(http.address(), serverInfo, QSslCertificate());
+            NvComputer httpsComputer(http, serverInfo);
            newComputer->update(httpsComputer);
        }

@@ -673,11 +853,11 @@ private:
            }

            // Get the WAN IP address using STUN if we're on mDNS over IPv4
-            if (QHostAddress(newComputer->localAddress).protocol() == QAbstractSocket::IPv4Protocol) {
+            if (QHostAddress(newComputer->localAddress.address()).protocol() == QAbstractSocket::IPv4Protocol) {
                quint32 addr;
                int err = LiFindExternalAddressIP4("stun.moonlight-stream.org", 3478, &addr);
                if (err == 0) {
-                    newComputer->remoteAddress = QHostAddress(qFromBigEndian(addr)).toString();
+                    newComputer->setRemoteAddress(QHostAddress(qFromBigEndian(addr)));
                }
                else {
                    qWarning() << "STUN failed to get WAN address:" << err;
@@ -685,34 +865,55 @@ private:
            }

            if (!m_MdnsIpv6Address.isNull()) {
-                Q_ASSERT(m_MdnsIpv6Address.protocol() == QAbstractSocket::IPv6Protocol);
-                newComputer->ipv6Address = m_MdnsIpv6Address.toString();
+                Q_ASSERT(QHostAddress(m_MdnsIpv6Address.address()).protocol() == QAbstractSocket::IPv6Protocol);
+                newComputer->ipv6Address = m_MdnsIpv6Address;
            }
        }
        else {
            newComputer->manualAddress = m_Address;
        }

+        QHostAddress hostAddress(m_Address.address());
+        bool addressIsSiteLocalV4 =
+                hostAddress.isInSubnet(QHostAddress("10.0.0.0"), 8) ||
+                hostAddress.isInSubnet(QHostAddress("172.16.0.0"), 12) ||
+                hostAddress.isInSubnet(QHostAddress("192.168.0.0"), 16);
+
        {
-            // Check if this PC already exists
-            QWriteLocker lock(&m_ComputerManager->m_Lock);
+            // Check if this PC already exists using opportunistic read lock
+            m_ComputerManager->m_Lock.lockForRead();
            NvComputer* existingComputer = m_ComputerManager->m_KnownHosts.value(newComputer->uuid);
+
+            // If it doesn't already exist, convert to a write lock in preparation for updating.
+            //
+            // NB: ComputerManager's lock protects the host map itself, not the elements inside.
+            // Those are protected by their individual locks. Since we only mutate the map itself
+            // when the PC doesn't exist, we need the lock in write-mode for that case only.
+            if (existingComputer == nullptr) {
+                m_ComputerManager->m_Lock.unlock();
+                m_ComputerManager->m_Lock.lockForWrite();
+
+                // Since we had to unlock to lock for write, someone could have raced and added
+                // this PC before us. We have to check again whether it already exists.
+                existingComputer = m_ComputerManager->m_KnownHosts.value(newComputer->uuid);
+            }
+
            if (existingComputer != nullptr) {
                // Fold it into the existing PC
                bool changed = existingComputer->update(*newComputer);
                delete newComputer;

                // Drop the lock before notifying
-                lock.unlock();
+                m_ComputerManager->m_Lock.unlock();

                // For non-mDNS clients, let them know it succeeded
                if (!m_Mdns) {
-                    emit computerAddCompleted(true);
+                    emit computerAddCompleted(true, false);
                }

                // Tell our client if something changed
                if (changed) {
-                    qInfo() << existingComputer->name << "is now at" << existingComputer->activeAddress;
+                    qInfo() << existingComputer->name << "is now at" << existingComputer->activeAddress.toString();
                    emit computerStateChanged(existingComputer);
                }
            }
@@ -724,11 +925,24 @@ private:
                m_ComputerManager->startPollingComputer(newComputer);

                // Drop the lock before notifying
-                lock.unlock();
+                m_ComputerManager->m_Lock.unlock();
+
+                // If this wasn't added via mDNS but it is a RFC 1918 IPv4 address and not a VPN,
+                // go ahead and do the STUN request now to populate an external address.
+                if (!m_Mdns && addressIsSiteLocalV4 && newComputer->getActiveAddressReachability() != NvComputer::RI_VPN) {
+                    quint32 addr;
+                    int err = LiFindExternalAddressIP4("stun.moonlight-stream.org", 3478, &addr);
+                    if (err == 0) {
+                        newComputer->setRemoteAddress(QHostAddress(qFromBigEndian(addr)));
+                    }
+                    else {
+                        qWarning() << "STUN failed to get WAN address:" << err;
+                    }
+                }

                // For non-mDNS clients, let them know it succeeded
                if (!m_Mdns) {
-                    emit computerAddCompleted(true);
+                    emit computerAddCompleted(true, false);
                }

                // Tell our client about this new PC
@@ -738,12 +952,13 @@ private:
    }

    ComputerManager* m_ComputerManager;
-    QString m_Address;
-    QHostAddress m_MdnsIpv6Address;
+    NvAddress m_Address;
+    NvAddress m_MdnsIpv6Address;
    bool m_Mdns;
+    bool m_AboutToQuit;
 };

-void ComputerManager::addNewHost(QString address, bool mdns, QHostAddress mdnsIpv6Address)
+void ComputerManager::addNewHost(NvAddress address, bool mdns, NvAddress mdnsIpv6Address)
 {
    // Punt to a worker thread to avoid stalling the
    // UI while waiting for serverinfo query to complete
@@ -751,4 +966,14 @@ void ComputerManager::addNewHost(QString address, bool mdns, QHostAddress mdnsIp
    QThreadPool::globalInstance()->start(addTask);
 }

+// TODO: Use QRandomGenerator when we drop Qt 5.9 support
+QString ComputerManager::generatePinString()
+{
+    std::uniform_int_distribution<int> dist(0, 9999);
+    std::random_device rd;
+    std::mt19937 engine(rd());
+
+    return QString::asprintf("%04u", dist(engine));
+}
+
 #include "computermanager.moc"
@@ -1,7 +1,8 @@
 #pragma once

 #include "nvcomputer.h"
-#include "nvpairingmanager.h"
+#include "settings/streamingpreferences.h"
+#include "settings/compatfetcher.h"

 #include <qmdnsengine/server.h>
 #include <qmdnsengine/cache.h>
@@ -14,16 +15,38 @@
 #include <QSettings>
 #include <QRunnable>
 #include <QTimer>
+#include <QMutex>
+#include <QWaitCondition>
+
+class ComputerManager;
+
+class DelayedFlushThread : public QThread
+{
+    Q_OBJECT
+
+public:
+    DelayedFlushThread(ComputerManager* cm)
+        : m_ComputerManager(cm)
+    {
+        setObjectName("CM Delayed Flush Thread");
+    }
+
+    void run();
+
+private:
+    ComputerManager* m_ComputerManager;
+};

 class MdnsPendingComputer : public QObject
 {
    Q_OBJECT

 public:
-    explicit MdnsPendingComputer(QMdnsEngine::Server* server,
+    explicit MdnsPendingComputer(const QSharedPointer<QMdnsEngine::Server> server,
                                 const QMdnsEngine::Service& service)
        : m_Hostname(service.hostname()),
-          m_Server(server),
+          m_Port(service.port()),
+          m_ServerWeak(server),
          m_Resolver(nullptr)
    {
        // Start resolving
@@ -40,13 +63,24 @@ public:
        return m_Hostname;
    }

+    uint16_t port()
+    {
+        return m_Port;
+    }
+
 private slots:
    void handleResolvedTimeout()
    {
        if (m_Addresses.isEmpty()) {
-            // Try again
-            qInfo() << "Resolving" << hostname() << "timed out. Retrying...";
-            resolve();
+            if (m_Retries-- > 0) {
+                // Try again
+                qInfo() << "Resolving" << hostname() << "timed out. Retrying...";
+                resolve();
+            }
+            else {
+                qWarning() << "Giving up on resolving" << hostname() << "after repeated failures";
+                cleanup();
+            }
        }
        else {
            Q_ASSERT(!m_Addresses.isEmpty());
@@ -64,19 +98,41 @@ signals:
    void resolvedHost(MdnsPendingComputer*,QVector<QHostAddress>&);

 private:
+    void cleanup()
+    {
+        // Delete our resolver, so we're guaranteed that nothing is referencing m_Server.
+        delete m_Resolver;
+        m_Resolver = nullptr;
+
+        // Now delete our strong reference that we held on behalf of m_Resolver.
+        // The server may be destroyed after we make this call.
+        m_Server.reset();
+    }
+
    void resolve()
    {
-        delete m_Resolver;
-        m_Resolver = new QMdnsEngine::Resolver(m_Server, m_Hostname);
+        // Clean up any existing resolver object and server references
+        cleanup();
+
+        // Re-acquire a strong reference if the server still exists.
+        m_Server = m_ServerWeak.toStrongRef();
+        if (!m_Server) {
+            return;
+        }
+
+        m_Resolver = new QMdnsEngine::Resolver(m_Server.data(), m_Hostname);
        connect(m_Resolver, &QMdnsEngine::Resolver::resolved,
                this, &MdnsPendingComputer::handleResolvedAddress);
-        QTimer::singleShot(2000, this, SLOT(handleResolvedTimeout()));
+        QTimer::singleShot(2000, this, &MdnsPendingComputer::handleResolvedTimeout);
    }

    QByteArray m_Hostname;
-    QMdnsEngine::Server* m_Server;
+    uint16_t m_Port;
+    QWeakPointer<QMdnsEngine::Server> m_ServerWeak;
+    QSharedPointer<QMdnsEngine::Server> m_Server;
    QMdnsEngine::Resolver* m_Resolver;
    QVector<QHostAddress> m_Addresses;
+    int m_Retries = 10;
 };

 class ComputerPollingEntry
@@ -158,9 +214,11 @@ class ComputerManager : public QObject

    friend class DeferredHostDeletionTask;
    friend class PendingAddTask;
+    friend class PendingPairingTask;
+    friend class DelayedFlushThread;

 public:
-    explicit ComputerManager(QObject *parent = nullptr);
+    explicit ComputerManager(StreamingPreferences* prefs);

    virtual ~ComputerManager();

@@ -168,7 +226,11 @@ public:

    Q_INVOKABLE void stopPollingAsync();

-    Q_INVOKABLE void addNewHost(QString address, bool mdns, QHostAddress mdnsIpv6Address = QHostAddress());
+    Q_INVOKABLE void addNewHostManually(QString address);
+
+    void addNewHost(NvAddress address, bool mdns, NvAddress mdnsIpv6Address = NvAddress());
+
+    QString generatePinString();

    void pairHost(NvComputer* computer, QString pin);

@@ -179,12 +241,16 @@ public:
    // computer is deleted inside this call
    void deleteHost(NvComputer* computer);

+    void renameHost(NvComputer* computer, QString name);
+
+    void clientSideAttributeUpdated(NvComputer* computer);
+
 signals:
    void computerStateChanged(NvComputer* computer);

    void pairingCompleted(NvComputer* computer, QString error);

-    void computerAddCompleted(QVariant success);
+    void computerAddCompleted(QVariant success, QVariant detectedPortBlocking);

    void quitAppCompleted(QVariant error);

@@ -198,16 +264,24 @@ private slots:
 private:
    void saveHosts();

+    void saveHost(NvComputer* computer);
+
    QHostAddress getBestGlobalAddressV6(QVector<QHostAddress>& addresses);

    void startPollingComputer(NvComputer* computer);

+    StreamingPreferences* m_Prefs;
    int m_PollingRef;
    QReadWriteLock m_Lock;
    QMap<QString, NvComputer*> m_KnownHosts;
    QMap<QString, ComputerPollingEntry*> m_PollEntries;
-    QMdnsEngine::Server m_MdnsServer;
+    QHash<QString, NvComputer> m_LastSerializedHosts; // Protected by m_DelayedFlushMutex
+    QSharedPointer<QMdnsEngine::Server> m_MdnsServer;
    QMdnsEngine::Browser* m_MdnsBrowser;
-    QMdnsEngine::Cache m_MdnsCache;
    QVector<MdnsPendingComputer*> m_PendingResolution;
+    CompatFetcher m_CompatFetcher;
+    DelayedFlushThread* m_DelayedFlushThread;
+    QMutex m_DelayedFlushMutex; // Lock ordering: Must never be acquired while holding NvComputer lock
+    QWaitCondition m_DelayedFlushCondition;
+    bool m_NeedsDelayedFlush;
 };
@@ -6,6 +6,13 @@ ComputerSeeker::ComputerSeeker(ComputerManager *manager, QString computerName, Q
    : QObject(parent), m_ComputerManager(manager), m_ComputerName(computerName),
      m_TimeoutTimer(new QTimer(this))
 {
+    // If we know this computer, send a WOL packet to wake it up in case it is asleep.
+    for (NvComputer * computer: m_ComputerManager->getComputers()) {
+        if (this->matchComputer(computer)) {
+            computer->wake();
+        }
+    }
+
    m_TimeoutTimer->setSingleShot(true);
    connect(m_TimeoutTimer, &QTimer::timeout,
            this, &ComputerSeeker::onTimeout);
@@ -20,7 +27,7 @@ void ComputerSeeker::start(int timeout)
    // if m_ComputerName is UUID, or the name that doesn't resolve to an IP
    // address) and by polling it using mDNS, hopefully one of these methods
    // would find the host
-    m_ComputerManager->addNewHost(m_ComputerName, false);
+    m_ComputerManager->addNewHostManually(m_ComputerName);
    m_ComputerManager->startPolling();
 }

@@ -44,8 +51,8 @@ bool ComputerSeeker::matchComputer(NvComputer *computer) const
        return true;
    }

-    for (const QString& addr : computer->uniqueAddresses()) {
-        if (addr.toLower() == value) {
+    for (const NvAddress& addr : computer->uniqueAddresses()) {
+        if (addr.address().toLower() == value || addr.toString().toLower() == value) {
            return true;
        }
    }
@@ -5,7 +5,6 @@

 #include <openssl/pem.h>
 #include <openssl/rsa.h>
-#include <openssl/bn.h>
 #include <openssl/x509.h>
 #include <openssl/rand.h>

@@ -32,20 +31,19 @@ void IdentityManager::createCredentials(QSettings& settings)
    X509* cert = X509_new();
    THROW_BAD_ALLOC_IF_NULL(cert);

-    EVP_PKEY* pk = EVP_PKEY_new();
+    EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL);
+    THROW_BAD_ALLOC_IF_NULL(ctx);
+
+    EVP_PKEY_keygen_init(ctx);
+    EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, 2048);
+
+    // pk must be initialized on input
+    EVP_PKEY* pk = NULL;
+    EVP_PKEY_keygen(ctx, &pk);
+
+    EVP_PKEY_CTX_free(ctx);
    THROW_BAD_ALLOC_IF_NULL(pk);

-    BIGNUM* bne = BN_new();
-    THROW_BAD_ALLOC_IF_NULL(bne);
-
-    RSA* rsa = RSA_new();
-    THROW_BAD_ALLOC_IF_NULL(rsa);
-
-    BN_set_word(bne, RSA_F4);
-    RSA_generate_key_ex(rsa, 2048, bne, nullptr);
-
-    EVP_PKEY_assign_RSA(pk, rsa);
-
    X509_set_version(cert, 2);
    ASN1_INTEGER_set(X509_get_serialNumber(cert), 0);
 #if OPENSSL_VERSION_NUMBER < 0x10100000L
@@ -94,7 +92,6 @@ void IdentityManager::createCredentials(QSettings& settings)

    X509_free(cert);
    EVP_PKEY_free(pk);
-    BN_free(bne);
    BIO_free(biokey);
    BIO_free(biocert);

@@ -146,7 +143,10 @@ QSslKey
 IdentityManager::getSslKey()
 {
    if (m_CachedSslKey.isNull()) {
-        BIO* bio = BIO_new_mem_buf(m_CachedPrivateKey.data(), -1);
+        // This seemingly useless const_cast is required for old OpenSSL headers
+        // where BIO_new_mem_buf's parameter is not declared const like those on
+        // the Steam Link hardware.
+        BIO* bio = BIO_new_mem_buf(const_cast<char*>(m_CachedPrivateKey.constData()), -1);
        THROW_BAD_ALLOC_IF_NULL(bio);

        EVP_PKEY* pk = PEM_read_bio_PrivateKey(bio, nullptr, nullptr, nullptr);
@@ -0,0 +1,65 @@
+#include "nvaddress.h"
+
+#include <QHostAddress>
+
+NvAddress::NvAddress()
+{
+    setAddress(nullptr);
+    setPort(0);
+}
+
+NvAddress::NvAddress(QString addr, uint16_t port)
+{
+    setAddress(addr);
+    setPort(port);
+}
+
+NvAddress::NvAddress(QHostAddress addr, uint16_t port)
+{
+    setAddress(addr);
+    setPort(port);
+}
+
+uint16_t NvAddress::port() const
+{
+    return m_Port;
+}
+
+QString NvAddress::address() const
+{
+    return m_Address;
+}
+
+void NvAddress::setPort(uint16_t port)
+{
+    m_Port = port;
+}
+
+void NvAddress::setAddress(QString addr)
+{
+    m_Address = addr;
+}
+
+void NvAddress::setAddress(QHostAddress addr)
+{
+    m_Address = addr.toString();
+}
+
+bool NvAddress::isNull() const
+{
+    return m_Address.isEmpty();
+}
+
+QString NvAddress::toString() const
+{
+    if (m_Address.isEmpty()) {
+        return "<NULL>";
+    }
+
+    if (QHostAddress(m_Address).protocol() == QAbstractSocket::IPv6Protocol) {
+        return QString("[%1]:%2").arg(m_Address).arg(m_Port);
+    }
+    else {
+        return QString("%1:%2").arg(m_Address).arg(m_Port);
+    }
+}
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <QHostAddress>
+
+#define DEFAULT_HTTP_PORT 47989
+#define DEFAULT_HTTPS_PORT 47984
+
+class NvAddress
+{
+public:
+    NvAddress();
+    explicit NvAddress(QString addr, uint16_t port);
+    explicit NvAddress(QHostAddress addr, uint16_t port);
+
+    uint16_t port() const;
+    void setPort(uint16_t port);
+
+    QString address() const;
+    void setAddress(QString addr);
+    void setAddress(QHostAddress addr);
+
+    bool isNull() const;
+    QString toString() const;
+
+    bool operator==(const NvAddress& other) const
+    {
+        return m_Address == other.m_Address &&
+                m_Port == other.m_Port;
+    }
+
+    bool operator!=(const NvAddress& other) const
+    {
+        return !operator==(other);
+    }
+
+private:
+    QString m_Address;
+    uint16_t m_Port;
+};
@@ -0,0 +1,28 @@
+#include "nvapp.h"
+
+#define SER_APPNAME "name"
+#define SER_APPID "id"
+#define SER_APPHDR "hdr"
+#define SER_APPCOLLECTOR "appcollector"
+#define SER_HIDDEN "hidden"
+#define SER_DIRECTLAUNCH "directlaunch"
+
+NvApp::NvApp(QSettings& settings)
+{
+    name = settings.value(SER_APPNAME).toString();
+    id = settings.value(SER_APPID).toInt();
+    hdrSupported = settings.value(SER_APPHDR).toBool();
+    isAppCollectorGame = settings.value(SER_APPCOLLECTOR).toBool();
+    hidden = settings.value(SER_HIDDEN).toBool();
+    directLaunch = settings.value(SER_DIRECTLAUNCH).toBool();
+}
+
+void NvApp::serialize(QSettings& settings) const
+{
+    settings.setValue(SER_APPNAME, name);
+    settings.setValue(SER_APPID, id);
+    settings.setValue(SER_APPHDR, hdrSupported);
+    settings.setValue(SER_APPCOLLECTOR, isAppCollectorGame);
+    settings.setValue(SER_HIDDEN, hidden);
+    settings.setValue(SER_DIRECTLAUNCH, directLaunch);
+}
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <QSettings>
+
+class NvApp
+{
+public:
+    NvApp() {}
+    explicit NvApp(QSettings& settings);
+
+    bool operator==(const NvApp& other) const
+    {
+        return id == other.id &&
+                name == other.name &&
+                hdrSupported == other.hdrSupported &&
+                isAppCollectorGame == other.isAppCollectorGame &&
+                hidden == other.hidden &&
+                directLaunch == other.directLaunch;
+    }
+
+    bool operator!=(const NvApp& other) const
+    {
+        return !operator==(other);
+    }
+
+    bool isInitialized()
+    {
+        return id != 0 && !name.isEmpty();
+    }
+
+    void
+    serialize(QSettings& settings) const;
+
+    int id = 0;
+    QString name;
+    bool hdrSupported = false;
+    bool isAppCollectorGame = false;
+    bool hidden = false;
+    bool directLaunch = false;
+};
+
+Q_DECLARE_METATYPE(NvApp)
@@ -1,50 +1,56 @@
 #include "nvcomputer.h"
+#include "nvapp.h"
+#include "settings/compatfetcher.h"

 #include <QUdpSocket>
 #include <QHostInfo>
 #include <QNetworkInterface>
+#include <QNetworkProxy>

 #define SER_NAME "hostname"
 #define SER_UUID "uuid"
 #define SER_MAC "mac"
 #define SER_LOCALADDR "localaddress"
+#define SER_LOCALPORT "localport"
 #define SER_REMOTEADDR "remoteaddress"
+#define SER_REMOTEPORT "remoteport"
 #define SER_MANUALADDR "manualaddress"
+#define SER_MANUALPORT "manualport"
 #define SER_IPV6ADDR "ipv6address"
+#define SER_IPV6PORT "ipv6port"
 #define SER_APPLIST "apps"
 #define SER_SRVCERT "srvcert"
-
-#define SER_APPNAME "name"
-#define SER_APPID "id"
-#define SER_APPHDR "hdr"
+#define SER_CUSTOMNAME "customname"
+#define SER_NVIDIASOFTWARE "nvidiasw"

 NvComputer::NvComputer(QSettings& settings)
 {
    this->name = settings.value(SER_NAME).toString();
    this->uuid = settings.value(SER_UUID).toString();
+    this->hasCustomName = settings.value(SER_CUSTOMNAME).toBool();
    this->macAddress = settings.value(SER_MAC).toByteArray();
-    this->localAddress = settings.value(SER_LOCALADDR).toString();
-    this->remoteAddress = settings.value(SER_REMOTEADDR).toString();
-    this->ipv6Address = settings.value(SER_IPV6ADDR).toString();
-    this->manualAddress = settings.value(SER_MANUALADDR).toString();
+    this->localAddress = NvAddress(settings.value(SER_LOCALADDR).toString(),
+                                   settings.value(SER_LOCALPORT, QVariant(DEFAULT_HTTP_PORT)).toUInt());
+    this->remoteAddress = NvAddress(settings.value(SER_REMOTEADDR).toString(),
+                                    settings.value(SER_REMOTEPORT, QVariant(DEFAULT_HTTP_PORT)).toUInt());
+    this->ipv6Address = NvAddress(settings.value(SER_IPV6ADDR).toString(),
+                                  settings.value(SER_IPV6PORT, QVariant(DEFAULT_HTTP_PORT)).toUInt());
+    this->manualAddress = NvAddress(settings.value(SER_MANUALADDR).toString(),
+                                    settings.value(SER_MANUALPORT, QVariant(DEFAULT_HTTP_PORT)).toUInt());
    this->serverCert = QSslCertificate(settings.value(SER_SRVCERT).toByteArray());
+    this->isNvidiaServerSoftware = settings.value(SER_NVIDIASOFTWARE).toBool();

    int appCount = settings.beginReadArray(SER_APPLIST);
+    this->appList.reserve(appCount);
    for (int i = 0; i < appCount; i++) {
-        NvApp app;
-
        settings.setArrayIndex(i);

-        app.name = settings.value(SER_APPNAME).toString();
-        app.id = settings.value(SER_APPID).toInt();
-        app.hdrSupported = settings.value(SER_APPHDR).toBool();
-
+        NvApp app(settings);
        this->appList.append(app);
    }
    settings.endArray();
    sortAppList();

-    this->activeAddress = nullptr;
    this->currentGameId = 0;
    this->pairState = PS_UNKNOWN;
    this->state = CS_UNKNOWN;
@@ -54,36 +60,66 @@ NvComputer::NvComputer(QSettings& settings)
    this->serverCodecModeSupport = 0;
    this->pendingQuit = false;
    this->gpuModel = nullptr;
+    this->isSupportedServerVersion = true;
+    this->externalPort = this->remoteAddress.port();
+    this->activeHttpsPort = 0;
 }

-void NvComputer::serialize(QSettings& settings)
+void NvComputer::setRemoteAddress(QHostAddress address)
+{
+    QWriteLocker lock(&this->lock);
+
+    Q_ASSERT(this->externalPort != 0);
+
+    this->remoteAddress = NvAddress(address, this->externalPort);
+}
+
+void NvComputer::serialize(QSettings& settings, bool serializeApps) const
 {
    QReadLocker lock(&this->lock);

    settings.setValue(SER_NAME, name);
+    settings.setValue(SER_CUSTOMNAME, hasCustomName);
    settings.setValue(SER_UUID, uuid);
    settings.setValue(SER_MAC, macAddress);
-    settings.setValue(SER_LOCALADDR, localAddress);
-    settings.setValue(SER_REMOTEADDR, remoteAddress);
-    settings.setValue(SER_IPV6ADDR, ipv6Address);
-    settings.setValue(SER_MANUALADDR, manualAddress);
+    settings.setValue(SER_LOCALADDR, localAddress.address());
+    settings.setValue(SER_LOCALPORT, localAddress.port());
+    settings.setValue(SER_REMOTEADDR, remoteAddress.address());
+    settings.setValue(SER_REMOTEPORT, remoteAddress.port());
+    settings.setValue(SER_IPV6ADDR, ipv6Address.address());
+    settings.setValue(SER_IPV6PORT, ipv6Address.port());
+    settings.setValue(SER_MANUALADDR, manualAddress.address());
+    settings.setValue(SER_MANUALPORT, manualAddress.port());
    settings.setValue(SER_SRVCERT, serverCert.toPem());
+    settings.setValue(SER_NVIDIASOFTWARE, isNvidiaServerSoftware);

    // Avoid deleting an existing applist if we couldn't get one
-    if (!appList.isEmpty()) {
+    if (!appList.isEmpty() && serializeApps) {
        settings.remove(SER_APPLIST);
        settings.beginWriteArray(SER_APPLIST);
        for (int i = 0; i < appList.count(); i++) {
            settings.setArrayIndex(i);
-
-            settings.setValue(SER_APPNAME, appList[i].name);
-            settings.setValue(SER_APPID, appList[i].id);
-            settings.setValue(SER_APPHDR, appList[i].hdrSupported);
+            appList[i].serialize(settings);
        }
        settings.endArray();
    }
 }

+bool NvComputer::isEqualSerialized(const NvComputer &that) const
+{
+    return this->name == that.name &&
+           this->hasCustomName == that.hasCustomName &&
+           this->uuid == that.uuid &&
+           this->macAddress == that.macAddress &&
+           this->localAddress == that.localAddress &&
+           this->remoteAddress == that.remoteAddress &&
+           this->ipv6Address == that.ipv6Address &&
+           this->manualAddress == that.manualAddress &&
+           this->serverCert == that.serverCert &&
+           this->isNvidiaServerSoftware == that.isNvidiaServerSoftware &&
+           this->appList == that.appList;
+}
+
 void NvComputer::sortAppList()
 {
    std::stable_sort(appList.begin(), appList.end(), [](const NvApp& app1, const NvApp& app2) {
@@ -91,10 +127,11 @@ void NvComputer::sortAppList()
    });
 }

-NvComputer::NvComputer(QString address, QString serverInfo, QSslCertificate serverCert)
+NvComputer::NvComputer(NvHTTP& http, QString serverInfo)
 {
-    this->serverCert = serverCert;
+    this->serverCert = http.serverCert();

+    this->hasCustomName = false;
    this->name = NvHTTP::getXmlString(serverInfo, "hostname");
    if (this->name.isEmpty()) {
        this->name = "UNKNOWN";
@@ -104,7 +141,7 @@ NvComputer::NvComputer(QString address, QString serverInfo, QSslCertificate serv
    QString newMacString = NvHTTP::getXmlString(serverInfo, "mac");
    if (newMacString != "00:00:00:00:00:00") {
        QStringList macOctets = newMacString.split(':');
-        for (QString macOctet : macOctets) {
+        for (const QString& macOctet : macOctets) {
            this->macAddress.append((char) macOctet.toInt(nullptr, 16));
        }
    }
@@ -114,7 +151,8 @@ NvComputer::NvComputer(QString address, QString serverInfo, QSslCertificate serv
        this->serverCodecModeSupport = codecSupport.toInt();
    }
    else {
-        this->serverCodecModeSupport = 0;
+        // Assume H.264 is always supported
+        this->serverCodecModeSupport = SCM_H264;
    }

    QString maxLumaPixelsHEVC = NvHTTP::getXmlString(serverInfo, "MaxLumaPixelsHEVC");
@@ -128,58 +166,99 @@ NvComputer::NvComputer(QString address, QString serverInfo, QSslCertificate serv
    this->displayModes = NvHTTP::getDisplayModeList(serverInfo);
    std::stable_sort(this->displayModes.begin(), this->displayModes.end(),
                     [](const NvDisplayMode& mode1, const NvDisplayMode& mode2) {
-        return mode1.width * mode1.height * mode1.refreshRate <
-                mode2.width * mode2.height * mode2.refreshRate;
+        return (uint64_t)mode1.width * mode1.height * mode1.refreshRate <
+                (uint64_t)mode2.width * mode2.height * mode2.refreshRate;
    });

    // We can get an IPv4 loopback address if we're using the GS IPv6 Forwarder
-    this->localAddress = NvHTTP::getXmlString(serverInfo, "LocalIP");
-    if (this->localAddress.startsWith("127.")) {
-        this->localAddress = QString();
+    this->localAddress = NvAddress(NvHTTP::getXmlString(serverInfo, "LocalIP"), http.httpPort());
+    if (this->localAddress.address().startsWith("127.")) {
+        this->localAddress = NvAddress();
    }

-    this->remoteAddress = NvHTTP::getXmlString(serverInfo, "ExternalIP");
+    QString httpsPort = NvHTTP::getXmlString(serverInfo, "HttpsPort");
+    if (httpsPort.isEmpty() || (this->activeHttpsPort = httpsPort.toUShort()) == 0) {
+        this->activeHttpsPort = DEFAULT_HTTPS_PORT;
+    }
+
+    // This is an extension which is not present in GFE. It is present for Sunshine to be able
+    // to support dynamic HTTP WAN ports without requiring the user to manually enter the port.
+    QString remotePortStr = NvHTTP::getXmlString(serverInfo, "ExternalPort");
+    if (remotePortStr.isEmpty() || (this->externalPort = remotePortStr.toUShort()) == 0) {
+        this->externalPort = http.httpPort();
+    }
+
+    QString remoteAddress = NvHTTP::getXmlString(serverInfo, "ExternalIP");
+    if (!remoteAddress.isEmpty()) {
+        this->remoteAddress = NvAddress(remoteAddress, this->externalPort);
+    }
+    else {
+        this->remoteAddress = NvAddress();
+    }
+
+    // Real Nvidia host software (GeForce Experience and RTX Experience) both use the 'Mjolnir'
+    // codename in the state field and no version of Sunshine does. We can use this to bypass
+    // some assumptions about Nvidia hardware that don't apply to Sunshine hosts.
+    this->isNvidiaServerSoftware = NvHTTP::getXmlString(serverInfo, "state").contains("MJOLNIR");
+
    this->pairState = NvHTTP::getXmlString(serverInfo, "PairStatus") == "1" ?
                PS_PAIRED : PS_NOT_PAIRED;
    this->currentGameId = NvHTTP::getCurrentGame(serverInfo);
    this->appVersion = NvHTTP::getXmlString(serverInfo, "appversion");
    this->gfeVersion = NvHTTP::getXmlString(serverInfo, "GfeVersion");
    this->gpuModel = NvHTTP::getXmlString(serverInfo, "gputype");
-    this->activeAddress = address;
+    this->activeAddress = http.address();
    this->state = NvComputer::CS_ONLINE;
    this->pendingQuit = false;
+    this->isSupportedServerVersion = CompatFetcher::isGfeVersionSupported(this->gfeVersion);
 }

-bool NvComputer::wake()
+bool NvComputer::wake() const
 {
-    if (state == NvComputer::CS_ONLINE) {
-        qWarning() << name << "is already online";
-        return true;
+    QByteArray wolPayload;
+
+    {
+        QReadLocker readLocker(&lock);
+
+        if (state == NvComputer::CS_ONLINE) {
+            qWarning() << name << "is already online";
+            return true;
+        }
+
+        if (macAddress.isEmpty()) {
+            qWarning() << name << "has no MAC address stored";
+            return false;
+        }
+
+        // Create the WoL payload
+        wolPayload.append(QByteArray::fromHex("FFFFFFFFFFFF"));
+        for (int i = 0; i < 16; i++) {
+            wolPayload.append(macAddress);
+        }
+        Q_ASSERT(wolPayload.size() == 102);
    }

-    if (macAddress.isEmpty()) {
-        qWarning() << name << "has no MAC address stored";
-        return false;
-    }
-
-    const quint16 WOL_PORTS[] = {
-        7, 9, // Standard WOL ports
-        47998, 47999, 48000, 48002, 48010, // Ports opened by GFE
+    // Ports used as-is
+    const quint16 STATIC_WOL_PORTS[] = {
+        9, // Standard WOL port (privileged port)
+        47009, // Port opened by Moonlight Internet Hosting Tool for WoL (non-privileged port)
    };

-    // Create the WoL payload
-    QByteArray wolPayload;
-    wolPayload.append(QByteArray::fromHex("FFFFFFFFFFFF"));
-    for (int i = 0; i < 16; i++) {
-        wolPayload.append(macAddress);
-    }
-    Q_ASSERT(wolPayload.count() == 102);
+    // Ports offset by the HTTP base port for hosts using alternate ports
+    const quint16 DYNAMIC_WOL_PORTS[] = {
+        47998, 47999, 48000, 48002, 48010, // Ports opened by GFE
+    };

    // Add the addresses that we know this host to be
    // and broadcast addresses for this link just in
    // case the host has timed out in ARP entries.
-    QVector<QString> addressList = uniqueAddresses();
-    addressList.append("255.255.255.255");
+    QMap<QString, quint16> addressMap;
+    QSet<quint16> basePortSet;
+    for (const NvAddress& addr : uniqueAddresses()) {
+        addressMap.insert(addr.address(), addr.port());
+        basePortSet.insert(addr.port());
+    }
+    addressMap.insert("255.255.255.255", 0);

    // Try to broadcast on all available NICs
    for (const QNetworkInterface& nic : QNetworkInterface::allInterfaces()) {
@@ -198,31 +277,42 @@ bool NvComputer::wake()

            // Skip IPv6 which doesn't support broadcast
            if (!addr.broadcast().isNull()) {
-                addressList.append(addr.broadcast().toString());
+                addressMap.insert(addr.broadcast().toString(), 0);
            }
        }

        if (!allNodesMulticast.scopeId().isEmpty()) {
-            addressList.append(allNodesMulticast.toString());
+            addressMap.insert(allNodesMulticast.toString(), 0);
        }
    }

    // Try all unique address strings or host names
    bool success = false;
-    for (QString& addressString : addressList) {
-        QHostInfo hostInfo = QHostInfo::fromName(addressString);
+    for (auto i = addressMap.constBegin(); i != addressMap.constEnd(); i++) {
+        QHostAddress literalAddress;
+        QList<QHostAddress> addressList;

-        if (hostInfo.error() != QHostInfo::NoError) {
-            qWarning() << "Error resolving" << addressString << ":" << hostInfo.errorString();
-            continue;
+        // If this is an IPv4/IPv6 literal, don't use QHostInfo::fromName() because that will
+        // try to perform a reverse DNS lookup that leads to delays sending WoL packets.
+        if (literalAddress.setAddress(i.key())) {
+            addressList.append(literalAddress);
+        }
+        else {
+            QHostInfo hostInfo = QHostInfo::fromName(i.key());
+            if (hostInfo.error() != QHostInfo::NoError) {
+                qWarning() << "Error resolving" << i.key() << ":" << hostInfo.errorString();
+                continue;
+            }
+
+            addressList.append(hostInfo.addresses());
        }

        // Try all IP addresses that this string resolves to
-        for (QHostAddress& address : hostInfo.addresses()) {
+        for (QHostAddress& address : addressList) {
            QUdpSocket sock;

-            // Send to all ports
-            for (quint16 port : WOL_PORTS) {
+            // Send to all static ports
+            for (quint16 port : STATIC_WOL_PORTS) {
                if (sock.writeDatagram(wolPayload, address, port)) {
                    qInfo().nospace().noquote() << "Sent WoL packet to " << name << " via " << address.toString() << ":" << port;
                    success = true;
@@ -231,15 +321,166 @@ bool NvComputer::wake()
                    qWarning() << "Send failed:" << sock.error();
                }
            }
+
+            QList<quint16> basePorts;
+            if (i.value() != 0) {
+                // If we have a known base port for this address, use only that port
+                basePorts.append(i.value());
+            }
+            else {
+                // If this is a broadcast address without a known HTTP port, try all of them
+                basePorts.append(basePortSet.values());
+            }
+
+            // Send to all dynamic ports using the HTTP port offset(s) for this address
+            for (quint16 basePort : basePorts) {
+                for (quint16 port : DYNAMIC_WOL_PORTS) {
+                    port = (port - 47989) + basePort;
+
+                    if (sock.writeDatagram(wolPayload, address, port)) {
+                        qInfo().nospace().noquote() << "Sent WoL packet to " << name << " via " << address.toString() << ":" << port;
+                        success = true;
+                    }
+                    else {
+                        qWarning() << "Send failed:" << sock.error();
+                    }
+                }
+            }
        }
    }

    return success;
 }

-QVector<QString> NvComputer::uniqueAddresses()
+NvComputer::ReachabilityType NvComputer::getActiveAddressReachability() const
 {
-    QVector<QString> uniqueAddressList;
+    NvAddress copyOfActiveAddress;
+
+    {
+        QReadLocker readLocker(&lock);
+
+        if (activeAddress.isNull()) {
+            return ReachabilityType::RI_UNKNOWN;
+        }
+
+        // Grab a copy of the active address to avoid having to hold
+        // the computer lock while doing socket operations
+        copyOfActiveAddress = activeAddress;
+    }
+
+    QTcpSocket s;
+    s.setProxy(QNetworkProxy::NoProxy);
+    s.connectToHost(copyOfActiveAddress.address(), copyOfActiveAddress.port());
+    if (s.waitForConnected(3000)) {
+        Q_ASSERT(!s.localAddress().isNull());
+        Q_ASSERT(!s.peerAddress().isNull());
+
+        for (const QNetworkInterface& nic : QNetworkInterface::allInterfaces()) {
+            // Ensure the interface is up
+            if ((nic.flags() & QNetworkInterface::IsUp) == 0) {
+                continue;
+            }
+
+            for (const QNetworkAddressEntry& addr : nic.addressEntries()) {
+                if (addr.ip() == s.localAddress()) {
+                    qInfo() << "Found matching interface:" << nic.humanReadableName() << nic.hardwareAddress() << nic.flags();
+
+#if QT_VERSION >= QT_VERSION_CHECK(5, 11, 0)
+                    qInfo() << "Interface Type:" << nic.type();
+                    qInfo() << "Interface MTU:" << nic.maximumTransmissionUnit();
+
+                    if (nic.type() == QNetworkInterface::Virtual ||
+                            nic.type() == QNetworkInterface::Ppp) {
+                        // Treat PPP and virtual interfaces as likely VPNs
+                        return ReachabilityType::RI_VPN;
+                    }
+
+                    if (nic.maximumTransmissionUnit() != 0 && nic.maximumTransmissionUnit() < 1500) {
+                        // Treat MTUs under 1500 as likely VPNs
+                        return ReachabilityType::RI_VPN;
+                    }
+#endif
+
+                    if (nic.flags() & QNetworkInterface::IsPointToPoint) {
+                        // Treat point-to-point links as likely VPNs.
+                        // This check detects OpenVPN on Unix-like OSes.
+                        return ReachabilityType::RI_VPN;
+                    }
+
+#ifdef Q_OS_WINDOWS
+                    if (nic.name().startsWith("iftype53_") || nic.name().startsWith("iftype131_")) {
+                        // Match by NDIS interface type. These values are Microsoft's recommended values for VPN connections:
+                        // https://learn.microsoft.com/en-US/troubleshoot/windows-client/networking/windows-connection-manager-disconnects-wlan#more-information
+                        //
+                        // The following VPNs use IF_TYPE_PROP_VIRTUAL under Windows:
+                        //  - WireguardNT VPNs
+                        //  - All WinTun-based VPNs (such as Slack Nebula)
+                        //  - OpenVPN with tap-windows6
+                        return ReachabilityType::RI_VPN;
+                    }
+#endif
+
+                    if (nic.hardwareAddress().startsWith("00:FF", Qt::CaseInsensitive)) {
+                        // OpenVPN TAP interfaces have a MAC address starting with 00:FF on Windows
+                        return ReachabilityType::RI_VPN;
+                    }
+
+                    if (nic.humanReadableName().startsWith("ZeroTier")) {
+                        // ZeroTier interfaces always start with "ZeroTier"
+                        return ReachabilityType::RI_VPN;
+                    }
+
+                    if (nic.humanReadableName().contains("VPN")) {
+                        // This one is just a final VPN heuristic if all else fails
+                        return ReachabilityType::RI_VPN;
+                    }
+
+                    // Didn't meet any of our VPN heuristics. Let's see if the peer address is on-link.
+                    Q_ASSERT(addr.prefixLength() >= 0);
+                    if (addr.prefixLength() >= 0 && s.localAddress().isInSubnet(s.peerAddress(), addr.prefixLength())) {
+                        return ReachabilityType::RI_LAN;
+                    }
+
+                    // Default to unknown if nothing else matched
+                    return ReachabilityType::RI_UNKNOWN;
+                }
+            }
+        }
+
+        qWarning() << "No match found for address:" << s.localAddress();
+        return ReachabilityType::RI_UNKNOWN;
+    }
+    else {
+        // If we fail to connect, just pretend that it's not a VPN
+        qWarning() << "Unable to check for reachability within 3 seconds";
+        return ReachabilityType::RI_UNKNOWN;
+    }
+}
+
+bool NvComputer::updateAppList(QVector<NvApp> newAppList) {
+    if (appList == newAppList) {
+        return false;
+    }
+
+    // Propagate client-side attributes to the new app list
+    for (const NvApp& existingApp : appList) {
+        for (NvApp& newApp : newAppList) {
+            if (existingApp.id == newApp.id) {
+                newApp.hidden = existingApp.hidden;
+                newApp.directLaunch = existingApp.directLaunch;
+            }
+        }
+    }
+
+    appList = newAppList;
+    sortAppList();
+    return true;
+}
+
+QVector<NvAddress> NvComputer::uniqueAddresses() const
+{
+    QReadLocker readLocker(&lock);
+    QVector<NvAddress> uniqueAddressList;

    // Start with addresses correctly ordered
    uniqueAddressList.append(activeAddress);
@@ -250,7 +491,7 @@ QVector<QString> NvComputer::uniqueAddresses()

    // Prune duplicates (always giving precedence to the first)
    for (int i = 0; i < uniqueAddressList.count(); i++) {
-        if (uniqueAddressList[i].isEmpty()) {
+        if (uniqueAddressList[i].isNull()) {
            uniqueAddressList.remove(i);
            i--;
            continue;
@@ -270,7 +511,7 @@ QVector<QString> NvComputer::uniqueAddresses()
    return uniqueAddressList;
 }

-bool NvComputer::update(NvComputer& that)
+bool NvComputer::update(const NvComputer& that)
 {
    bool changed = false;

@@ -301,12 +542,17 @@ bool NvComputer::update(NvComputer& that)
        changed = true;                       \
    }

-    ASSIGN_IF_CHANGED(name);
+    if (!hasCustomName) {
+        // Only overwrite the name if it's not custom
+        ASSIGN_IF_CHANGED(name);
+    }
    ASSIGN_IF_CHANGED_AND_NONEMPTY(macAddress);
-    ASSIGN_IF_CHANGED_AND_NONEMPTY(localAddress);
-    ASSIGN_IF_CHANGED_AND_NONEMPTY(remoteAddress);
-    ASSIGN_IF_CHANGED_AND_NONEMPTY(ipv6Address);
-    ASSIGN_IF_CHANGED_AND_NONEMPTY(manualAddress);
+    ASSIGN_IF_CHANGED_AND_NONNULL(localAddress);
+    ASSIGN_IF_CHANGED_AND_NONNULL(remoteAddress);
+    ASSIGN_IF_CHANGED_AND_NONNULL(ipv6Address);
+    ASSIGN_IF_CHANGED_AND_NONNULL(manualAddress);
+    ASSIGN_IF_CHANGED(activeHttpsPort);
+    ASSIGN_IF_CHANGED(externalPort);
    ASSIGN_IF_CHANGED(pairState);
    ASSIGN_IF_CHANGED(serverCodecModeSupport);
    ASSIGN_IF_CHANGED(currentGameId);
@@ -314,10 +560,17 @@ bool NvComputer::update(NvComputer& that)
    ASSIGN_IF_CHANGED(state);
    ASSIGN_IF_CHANGED(gfeVersion);
    ASSIGN_IF_CHANGED(appVersion);
+    ASSIGN_IF_CHANGED(isSupportedServerVersion);
+    ASSIGN_IF_CHANGED(isNvidiaServerSoftware);
    ASSIGN_IF_CHANGED(maxLumaPixelsHEVC);
    ASSIGN_IF_CHANGED(gpuModel);
    ASSIGN_IF_CHANGED_AND_NONNULL(serverCert);
-    ASSIGN_IF_CHANGED_AND_NONEMPTY(appList);
    ASSIGN_IF_CHANGED_AND_NONEMPTY(displayModes);
+
+    if (!that.appList.isEmpty()) {
+        // updateAppList() handles merging client-side attributes
+        updateAppList(that.appList);
+    }
+
    return changed;
 }
@@ -1,12 +1,23 @@
 #pragma once

 #include "nvhttp.h"
+#include "nvaddress.h"

 #include <QThread>
 #include <QReadWriteLock>
 #include <QSettings>
 #include <QRunnable>

+class CopySafeReadWriteLock : public QReadWriteLock
+{
+public:
+    CopySafeReadWriteLock() = default;
+
+    // Don't actually copy the QReadWriteLock
+    CopySafeReadWriteLock(const CopySafeReadWriteLock&) : QReadWriteLock() {}
+    CopySafeReadWriteLock& operator=(const CopySafeReadWriteLock &) { return *this; }
+};
+
 class NvComputer
 {
    friend class PcMonitorThread;
@@ -16,24 +27,51 @@ class NvComputer
 private:
    void sortAppList();

+    bool updateAppList(QVector<NvApp> newAppList);
+
    bool pendingQuit;

 public:
-    explicit NvComputer(QString address, QString serverInfo, QSslCertificate serverCert);
+    NvComputer() = default;
+
+    // Caller is responsible for synchronizing read access to the other host
+    NvComputer(const NvComputer&) = default;
+
+    // Caller is responsible for synchronizing read access to the other host
+    NvComputer& operator=(const NvComputer &) = default;
+
+    explicit NvComputer(NvHTTP& http, QString serverInfo);

    explicit NvComputer(QSettings& settings);

-    bool
-    update(NvComputer& that);
+    void
+    setRemoteAddress(QHostAddress);

    bool
-    wake();
+    update(const NvComputer& that);

-    QVector<QString>
-    uniqueAddresses();
+    bool
+    wake() const;
+
+    enum ReachabilityType
+    {
+        RI_UNKNOWN,
+        RI_LAN,
+        RI_VPN,
+    };
+
+    ReachabilityType
+    getActiveAddressReachability() const;
+
+    QVector<NvAddress>
+    uniqueAddresses() const;

    void
-    serialize(QSettings& settings);
+    serialize(QSettings& settings, bool serializeApps) const;
+
+    // Caller is responsible for synchronizing read access to both hosts
+    bool
+    isEqualSerialized(const NvComputer& that) const;

    enum PairState
    {
@@ -52,7 +90,8 @@ public:
    // Ephemeral traits
    ComputerState state;
    PairState pairState;
-    QString activeAddress;
+    NvAddress activeAddress;
+    uint16_t activeHttpsPort;
    int currentGameId;
    QString gfeVersion;
    QString appVersion;
@@ -60,18 +99,25 @@ public:
    int maxLumaPixelsHEVC;
    int serverCodecModeSupport;
    QString gpuModel;
+    bool isSupportedServerVersion;

    // Persisted traits
-    QString localAddress;
-    QString remoteAddress;
-    QString ipv6Address;
-    QString manualAddress;
+    NvAddress localAddress;
+    NvAddress remoteAddress;
+    NvAddress ipv6Address;
+    NvAddress manualAddress;
    QByteArray macAddress;
    QString name;
+    bool hasCustomName;
    QString uuid;
    QSslCertificate serverCert;
    QVector<NvApp> appList;
+    bool isNvidiaServerSoftware;
+    // Remember to update isEqualSerialized() when adding fields here!

    // Synchronization
-    QReadWriteLock lock;
+    mutable CopySafeReadWriteLock lock;
+
+private:
+    uint16_t externalPort;
 };
@@ -1,4 +1,4 @@
-#include "nvhttp.h"
+#include "nvcomputer.h"
 #include <Limelight.h>

 #include <QDebug>
@@ -12,20 +12,20 @@
 #include <QtEndian>
 #include <QNetworkProxy>

+#define FAST_FAIL_TIMEOUT_MS 2000
 #define REQUEST_TIMEOUT_MS 5000
 #define LAUNCH_TIMEOUT_MS 120000
 #define RESUME_TIMEOUT_MS 30000
 #define QUIT_TIMEOUT_MS 30000

-NvHTTP::NvHTTP(QString address, QSslCertificate serverCert) :
+NvHTTP::NvHTTP(NvAddress address, uint16_t httpsPort, QSslCertificate serverCert) :
    m_ServerCert(serverCert)
 {
    m_BaseUrlHttp.setScheme("http");
    m_BaseUrlHttps.setScheme("https");
-    m_BaseUrlHttp.setPort(47989);
-    m_BaseUrlHttps.setPort(47984);

    setAddress(address);
+    setHttpsPort(httpsPort);

    // Never use a proxy server
    QNetworkProxy noProxy(QNetworkProxy::NoProxy);
@@ -34,26 +34,54 @@ NvHTTP::NvHTTP(QString address, QSslCertificate serverCert) :
    connect(&m_Nam, &QNetworkAccessManager::sslErrors, this, &NvHTTP::handleSslErrors);
 }

+NvHTTP::NvHTTP(NvComputer* computer) :
+    NvHTTP(computer->activeAddress, computer->activeHttpsPort, computer->serverCert)
+{
+
+}
+
 void NvHTTP::setServerCert(QSslCertificate serverCert)
 {
    m_ServerCert = serverCert;
 }

-void NvHTTP::setAddress(QString address)
+void NvHTTP::setAddress(NvAddress address)
 {
-    Q_ASSERT(!address.isEmpty());
+    Q_ASSERT(!address.isNull());

    m_Address = address;

-    m_BaseUrlHttp.setHost(address);
-    m_BaseUrlHttps.setHost(address);
+    m_BaseUrlHttp.setHost(address.address());
+    m_BaseUrlHttps.setHost(address.address());
+
+    m_BaseUrlHttp.setPort(address.port());
 }

-QString NvHTTP::address()
+void NvHTTP::setHttpsPort(uint16_t port)
+{
+    m_BaseUrlHttps.setPort(port);
+}
+
+NvAddress NvHTTP::address()
 {
    return m_Address;
 }

+QSslCertificate NvHTTP::serverCert()
+{
+    return m_ServerCert;
+}
+
+uint16_t NvHTTP::httpPort()
+{
+    return m_BaseUrlHttp.port();
+}
+
+uint16_t NvHTTP::httpsPort()
+{
+    return m_BaseUrlHttps.port();
+}
+
 QVector<int>
 NvHTTP::parseQuad(QString quad)
 {
@@ -66,7 +94,8 @@ NvHTTP::parseQuad(QString quad)
    }

    QStringList parts = quad.split(".");
-    for (int i = 0; i < 4; i++)
+    ret.reserve(parts.length());
+    for (int i = 0; i < parts.length(); i++)
    {
        ret.append(parts.at(i).toInt());
    }
@@ -92,12 +121,12 @@ NvHTTP::getCurrentGame(QString serverInfo)
 }

 QString
-NvHTTP::getServerInfo(NvLogLevel logLevel)
+NvHTTP::getServerInfo(NvLogLevel logLevel, bool fastFail)
 {
    QString serverInfo;

-    // Check if we have a pinned cert for this host yet
-    if (!m_ServerCert.isNull())
+    // Check if we have a pinned cert and HTTPS port for this host yet
+    if (!m_ServerCert.isNull() && httpsPort() != 0)
    {
        try
        {
@@ -106,7 +135,7 @@ NvHTTP::getServerInfo(NvLogLevel logLevel)
            serverInfo = openConnectionToString(m_BaseUrlHttps,
                                                "serverinfo",
                                                nullptr,
-                                                REQUEST_TIMEOUT_MS,
+                                                fastFail ? FAST_FAIL_TIMEOUT_MS : REQUEST_TIMEOUT_MS,
                                                logLevel);
            // Throws if the request failed
            verifyResponseStatus(serverInfo);
@@ -119,7 +148,7 @@ NvHTTP::getServerInfo(NvLogLevel logLevel)
                serverInfo = openConnectionToString(m_BaseUrlHttp,
                                                    "serverinfo",
                                                    nullptr,
-                                                    REQUEST_TIMEOUT_MS,
+                                                    fastFail ? FAST_FAIL_TIMEOUT_MS : REQUEST_TIMEOUT_MS,
                                                    logLevel);
                verifyResponseStatus(serverInfo);
            }
@@ -132,48 +161,41 @@ NvHTTP::getServerInfo(NvLogLevel logLevel)
    }
    else
    {
-        // Only use HTTP prior to pairing
+        // Only use HTTP prior to pairing or fetching HTTPS port
        serverInfo = openConnectionToString(m_BaseUrlHttp,
                                            "serverinfo",
                                            nullptr,
-                                            REQUEST_TIMEOUT_MS,
+                                            fastFail ? FAST_FAIL_TIMEOUT_MS : REQUEST_TIMEOUT_MS,
                                            logLevel);
        verifyResponseStatus(serverInfo);
+
+        // Populate the HTTPS port
+        uint16_t httpsPort = getXmlString(serverInfo, "HttpsPort").toUShort();
+        if (httpsPort == 0) {
+            httpsPort = DEFAULT_HTTPS_PORT;
+        }
+        setHttpsPort(httpsPort);
+
+        // If we just needed to determine the HTTPS port, we'll try again over
+        // HTTPS now that we have the port number
+        if (!m_ServerCert.isNull()) {
+            return getServerInfo(logLevel, fastFail);
+        }
    }

    return serverInfo;
 }

-static QString
-getSurroundAudioInfoString(int audioConfig)
-{
-    int channelMask;
-    int channelCount;
-
-    switch (audioConfig)
-    {
-    case AUDIO_CONFIGURATION_STEREO:
-        channelCount = 2;
-        channelMask = 0x3;
-        break;
-    case AUDIO_CONFIGURATION_51_SURROUND:
-        channelCount = 6;
-        channelMask = 0xFC;
-        break;
-    default:
-        Q_ASSERT(false);
-        return 0;
-    }
-
-    return QString::number(channelMask << 16 | channelCount);
-}
-
 void
-NvHTTP::launchApp(int appId,
-                  PSTREAM_CONFIGURATION streamConfig,
-                  bool sops,
-                  bool localAudio,
-                  int gamepadMask)
+NvHTTP::startApp(QString verb,
+                 bool isGfe,
+                 int appId,
+                 PSTREAM_CONFIGURATION streamConfig,
+                 bool sops,
+                 bool localAudio,
+                 int gamepadMask,
+                 bool persistGameControllersOnDisconnect,
+                 QString& rtspSessionUrl)
 {
    int riKeyId;

@@ -182,48 +204,35 @@ NvHTTP::launchApp(int appId,

    QString response =
            openConnectionToString(m_BaseUrlHttps,
-                                   "launch",
+                                   verb,
                                   "appid="+QString::number(appId)+
                                   "&mode="+QString::number(streamConfig->width)+"x"+
                                   QString::number(streamConfig->height)+"x"+
                                   // Using an FPS value over 60 causes SOPS to default to 720p60,
-                                   // so force it to 60 when starting. This won't impact our ability
-                                   // to get > 60 FPS while actually streaming though.
-                                   QString::number(streamConfig->fps > 60 ? 60 : streamConfig->fps)+
+                                   // so force it to 0 to ensure the correct resolution is set. We
+                                   // used to use 60 here but that locked the frame rate to 60 FPS
+                                   // on GFE 3.20.3. We don't need this hack for Sunshine.
+                                   QString::number((streamConfig->fps > 60 && isGfe) ? 0 : streamConfig->fps)+
                                   "&additionalStates=1&sops="+QString::number(sops ? 1 : 0)+
                                   "&rikey="+QByteArray(streamConfig->remoteInputAesKey, sizeof(streamConfig->remoteInputAesKey)).toHex()+
                                   "&rikeyid="+QString::number(riKeyId)+
-                                   (streamConfig->enableHdr ?
+                                   ((streamConfig->supportedVideoFormats & VIDEO_FORMAT_MASK_10BIT) ?
                                       "&hdrMode=1&clientHdrCapVersion=0&clientHdrCapSupportedFlagsInUint32=0&clientHdrCapMetaDataId=NV_STATIC_METADATA_TYPE_1&clientHdrCapDisplayData=0x0x0x0x0x0x0x0x0x0x0" :
                                        "")+
                                   "&localAudioPlayMode="+QString::number(localAudio ? 1 : 0)+
-                                   "&surroundAudioInfo="+getSurroundAudioInfoString(streamConfig->audioConfiguration)+
+                                   "&surroundAudioInfo="+QString::number(SURROUNDAUDIOINFO_FROM_AUDIO_CONFIGURATION(streamConfig->audioConfiguration))+
                                   "&remoteControllersBitmap="+QString::number(gamepadMask)+
-                                   "&gcmap="+QString::number(gamepadMask),
+                                   "&gcmap="+QString::number(gamepadMask)+
+                                   "&gcpersist="+QString::number(persistGameControllersOnDisconnect ? 1 : 0)+
+                                   LiGetLaunchUrlQueryParameters(),
                                   LAUNCH_TIMEOUT_MS);

-    // Throws if the request failed
-    verifyResponseStatus(response);
-}
-
-void
-NvHTTP::resumeApp(PSTREAM_CONFIGURATION streamConfig)
-{
-    int riKeyId;
-
-    memcpy(&riKeyId, streamConfig->remoteInputAesIv, sizeof(riKeyId));
-    riKeyId = qFromBigEndian(riKeyId);
-
-    QString response =
-            openConnectionToString(m_BaseUrlHttps,
-                                   "resume",
-                                   "rikey="+QString(QByteArray(streamConfig->remoteInputAesKey, sizeof(streamConfig->remoteInputAesKey)).toHex())+
-                                   "&rikeyid="+QString::number(riKeyId)+
-                                   "&surroundAudioInfo="+getSurroundAudioInfoString(streamConfig->audioConfiguration),
-                                   RESUME_TIMEOUT_MS);
+    qInfo() << "Launch response:" << response;

    // Throws if the request failed
    verifyResponseStatus(response);
+
+    rtspSessionUrl = getXmlString(response, "sessionUrl0");
 }

 void
@@ -235,11 +244,13 @@ NvHTTP::quitApp()
                                   nullptr,
                                   QUIT_TIMEOUT_MS);

+    qInfo() << "Quit response:" << response;
+
    // Throws if the request failed
    verifyResponseStatus(response);

    // Newer GFE versions will just return success even if quitting fails
-    // if we're not the original requestor.
+    // if we're not the original requester.
    if (getCurrentGame(getServerInfo(NvHTTP::NVLL_ERROR)) != 0) {
        // Generate a synthetic GfeResponseException letting the caller know
        // that they can't kill someone else's stream.
@@ -255,17 +266,17 @@ NvHTTP::getDisplayModeList(QString serverInfo)

    while (!xmlReader.atEnd()) {
        while (xmlReader.readNextStartElement()) {
-            QStringRef name = xmlReader.name();
-            if (xmlReader.name() == "DisplayMode") {
+            auto name = xmlReader.name();
+            if (name == QString("DisplayMode")) {
                modes.append(NvDisplayMode());
            }
-            else if (xmlReader.name() == "Width") {
+            else if (name == QString("Width")) {
                modes.last().width = xmlReader.readElementText().toInt();
            }
-            else if (xmlReader.name() == "Height") {
+            else if (name == QString("Height")) {
                modes.last().height = xmlReader.readElementText().toInt();
            }
-            else if (xmlReader.name() == "RefreshRate") {
+            else if (name == QString("RefreshRate")) {
                modes.last().refreshRate = xmlReader.readElementText().toInt();
            }
        }
@@ -288,8 +299,8 @@ NvHTTP::getAppList()
    QVector<NvApp> apps;
    while (!xmlReader.atEnd()) {
        while (xmlReader.readNextStartElement()) {
-            QStringRef name = xmlReader.name();
-            if (xmlReader.name() == "App") {
+            auto name = xmlReader.name();
+            if (name == QString("App")) {
                // We must have a valid app before advancing to the next one
                if (!apps.isEmpty() && !apps.last().isInitialized()) {
                    qWarning() << "Invalid applist XML";
@@ -298,15 +309,18 @@ NvHTTP::getAppList()
                }
                apps.append(NvApp());
            }
-            else if (xmlReader.name() == "AppTitle") {
+            else if (name == QString("AppTitle")) {
                apps.last().name = xmlReader.readElementText();
            }
-            else if (xmlReader.name() == "ID") {
+            else if (name == QString("ID")) {
                apps.last().id = xmlReader.readElementText().toInt();
            }
-            else if (xmlReader.name() == "IsHdrSupported") {
+            else if (name == QString("IsHdrSupported")) {
                apps.last().hdrSupported = xmlReader.readElementText() == "1";
            }
+            else if (name == QString("IsAppCollectorGame")) {
+                apps.last().isAppCollectorGame = xmlReader.readElementText() == "1";
+            }
        }
    }

@@ -320,9 +334,12 @@ NvHTTP::verifyResponseStatus(QString xml)

    while (xmlReader.readNextStartElement())
    {
-        if (xmlReader.name() == "root")
+        if (xmlReader.name() == QString("root"))
        {
-            int statusCode = xmlReader.attributes().value("status_code").toInt();
+            // Status code can be 0xFFFFFFFF in some rare cases on GFE 3.20.3, and
+            // QString::toInt() will fail in that case, so use QString::toUInt()
+            // and cast the result to an int instead.
+            int statusCode = (int)xmlReader.attributes().value("status_code").toUInt();
            if (statusCode == 200)
            {
                // Successful
@@ -335,10 +352,18 @@ NvHTTP::verifyResponseStatus(QString xml)
                    // 401 is expected for unpaired PCs when we fetch serverinfo over HTTPS
                    qWarning() << "Request failed:" << statusCode << statusMessage;
                }
+                if (statusCode == -1 && statusMessage == "Invalid") {
+                    // Special case handling an audio capture error which GFE doesn't
+                    // provide any useful status message for.
+                    statusCode = 418;
+                    statusMessage = tr("Missing audio capture device. Reinstalling GeForce Experience should resolve this error.");
+                }
                throw GfeHttpResponseException(statusCode, statusMessage);
            }
        }
    }
+
+    throw GfeHttpResponseException(-1, "Malformed XML (missing root element)");
 }

 QImage
@@ -401,7 +426,7 @@ void NvHTTP::handleSslErrors(QNetworkReply* reply, const QList<QSslError>& error
        return;
    }

-    for (auto error : errors) {
+    for (const QSslError& error : errors) {
        if (m_ServerCert != error.certificate()) {
            ignoreErrors = false;
            break;
@@ -424,7 +449,13 @@ NvHTTP::openConnectionToString(QUrl baseUrl,
    QString ret;

    QTextStream stream(reply);
+
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    stream.setEncoding(QStringConverter::Utf8);
+#else
    stream.setCodec("UTF-8");
+#endif
+
    ret = stream.readAll();
    delete reply;

@@ -438,6 +469,9 @@ NvHTTP::openConnection(QUrl baseUrl,
                       int timeoutMs,
                       NvLogLevel logLevel)
 {
+    // Port must be set
+    Q_ASSERT(baseUrl.port(0) != 0);
+
    // Build a URL for the request
    QUrl url(baseUrl);
    url.setPath("/" + command);
@@ -454,14 +488,27 @@ NvHTTP::openConnection(QUrl baseUrl,
    // Add our client certificate
    request.setSslConfiguration(IdentityManager::get()->getSslConfig());

+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    // Disable HTTP/2 (GFE 3.22 doesn't like it) and Qt 6 enables it by default
+    request.setAttribute(QNetworkRequest::Http2AllowedAttribute, false);
+#endif
+
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0) && QT_VERSION < QT_VERSION_CHECK(5, 15, 1) && !defined(QT_NO_BEARERMANAGEMENT)
+    // HACK: Set network accessibility to work around QTBUG-80947 (introduced in Qt 5.14.0 and fixed in Qt 5.15.1)
+    QT_WARNING_PUSH
+    QT_WARNING_DISABLE_DEPRECATED
+    m_Nam.setNetworkAccessible(QNetworkAccessManager::Accessible);
+    QT_WARNING_POP
+#endif
+
    QNetworkReply* reply = m_Nam.get(request);

    // Run the request with a timeout if requested
    QEventLoop loop;
-    connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
-    connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), &loop, SLOT(quit()));
+    connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
+    connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit, &loop, &QEventLoop::quit);
    if (timeoutMs) {
-        QTimer::singleShot(timeoutMs, &loop, SLOT(quit()));
+        QTimer::singleShot(timeoutMs, &loop, &QEventLoop::quit);
    }
    if (logLevel >= NvLogLevel::NVLL_VERBOSE) {
        qInfo() << "Executing request:" << url.toString();
@@ -485,7 +532,7 @@ NvHTTP::openConnection(QUrl baseUrl,
    if (reply->error() != QNetworkReply::NoError)
    {
        if (logLevel >= NvLogLevel::NVLL_ERROR) {
-            qWarning() << command << " request failed with error " << reply->error();
+            qWarning() << command << "request failed with error:" << reply->error();
        }

        if (reply->error() == QNetworkReply::SslHandshakeFailedError) {
@@ -1,6 +1,8 @@
 #pragma once

 #include "identitymanager.h"
+#include "nvapp.h"
+#include "nvaddress.h"

 #include <Limelight.h>

@@ -8,25 +10,7 @@
 #include <QNetworkAccessManager>
 #include <QNetworkReply>

-class NvApp
-{
-public:
-    bool operator==(const NvApp& other) const
-    {
-        return id == other.id;
-    }
-
-    bool isInitialized()
-    {
-        return id != 0 && !name.isEmpty();
-    }
-
-    int id;
-    QString name;
-    bool hdrSupported;
-};
-
-Q_DECLARE_METATYPE(NvApp)
+class NvComputer;

 class NvDisplayMode
 {
@@ -42,6 +26,7 @@ public:
    int height;
    int refreshRate;
 };
+Q_DECLARE_TYPEINFO(NvDisplayMode, Q_PRIMITIVE_TYPE);

 class GfeHttpResponseException : public std::exception
 {
@@ -124,14 +109,16 @@ public:
        NVLL_VERBOSE
    };

-    explicit NvHTTP(QString address, QSslCertificate serverCert);
+    explicit NvHTTP(NvAddress address, uint16_t httpsPort, QSslCertificate serverCert);
+
+    explicit NvHTTP(NvComputer* computer);

    static
    int
    getCurrentGame(QString serverInfo);

    QString
-    getServerInfo(NvLogLevel logLevel);
+    getServerInfo(NvLogLevel logLevel, bool fastFail = false);

    static
    void
@@ -156,9 +143,16 @@ public:

    void setServerCert(QSslCertificate serverCert);

-    void setAddress(QString address);
+    void setAddress(NvAddress address);
+    void setHttpsPort(uint16_t port);

-    QString address();
+    NvAddress address();
+
+    QSslCertificate serverCert();
+
+    uint16_t httpPort();
+
+    uint16_t httpsPort();

    static
    QVector<int>
@@ -168,14 +162,15 @@ public:
    quitApp();

    void
-    resumeApp(PSTREAM_CONFIGURATION streamConfig);
-
-    void
-    launchApp(int appId,
-              PSTREAM_CONFIGURATION streamConfig,
-              bool sops,
-              bool localAudio,
-              int gamepadMask);
+    startApp(QString verb,
+             bool isGfe,
+             int appId,
+             PSTREAM_CONFIGURATION streamConfig,
+             bool sops,
+             bool localAudio,
+             int gamepadMask,
+             bool persistGameControllersOnDisconnect,
+             QString& rtspSessionUrl);

    QVector<NvApp>
    getAppList();
@@ -200,7 +195,7 @@ private:
                   int timeoutMs,
                   NvLogLevel logLevel);

-    QString m_Address;
+    NvAddress m_Address;
    QNetworkAccessManager m_Nam;
    QSslCertificate m_ServerCert;
 };
@@ -1,8 +1,9 @@
 #include "nvpairingmanager.h"
 #include "utils.h"

+#include <stdexcept>
+
 #include <openssl/bio.h>
-#include <openssl/aes.h>
 #include <openssl/rand.h>
 #include <openssl/pem.h>
 #include <openssl/x509.h>
@@ -10,8 +11,8 @@

 #define REQUEST_TIMEOUT_MS 5000

-NvPairingManager::NvPairingManager(QString address) :
-    m_Http(address, QSslCertificate())
+NvPairingManager::NvPairingManager(NvComputer* computer) :
+    m_Http(computer)
 {
    QByteArray cert = IdentityManager::get()->getCertificate();
    BIO *bio = BIO_new_mem_buf(cert.data(), -1);
@@ -51,39 +52,63 @@ NvPairingManager::generateRandomBytes(int length)
 }

 QByteArray
-NvPairingManager::encrypt(QByteArray plaintext, AES_KEY* key)
+NvPairingManager::encrypt(const QByteArray& plaintext, const QByteArray& key)
 {
    QByteArray ciphertext(plaintext.size(), 0);
+    EVP_CIPHER_CTX* cipher;
+    int ciphertextLen;

-    for (int i = 0; i < plaintext.size(); i += 16)
-    {
-        AES_encrypt(reinterpret_cast<unsigned char*>(&plaintext.data()[i]),
-                    reinterpret_cast<unsigned char*>(&ciphertext.data()[i]),
-                    key);
-    }
+    cipher = EVP_CIPHER_CTX_new();
+    THROW_BAD_ALLOC_IF_NULL(cipher);
+
+    EVP_EncryptInit(cipher, EVP_aes_128_ecb(), reinterpret_cast<const unsigned char*>(key.data()), NULL);
+    EVP_CIPHER_CTX_set_padding(cipher, 0);
+
+    EVP_EncryptUpdate(cipher,
+                      reinterpret_cast<unsigned char*>(ciphertext.data()),
+                      &ciphertextLen,
+                      reinterpret_cast<const unsigned char*>(plaintext.data()),
+                      plaintext.length());
+    Q_ASSERT(ciphertextLen == ciphertext.length());
+
+    EVP_CIPHER_CTX_free(cipher);

    return ciphertext;
 }

 QByteArray
-NvPairingManager::decrypt(QByteArray ciphertext, AES_KEY* key)
+NvPairingManager::decrypt(const QByteArray& ciphertext, const QByteArray& key)
 {
    QByteArray plaintext(ciphertext.size(), 0);
+    EVP_CIPHER_CTX* cipher;
+    int plaintextLen;

-    for (int i = 0; i < plaintext.size(); i += 16)
-    {
-        AES_decrypt(reinterpret_cast<unsigned char*>(&ciphertext.data()[i]),
-                    reinterpret_cast<unsigned char*>(&plaintext.data()[i]),
-                    key);
-    }
+    cipher = EVP_CIPHER_CTX_new();
+    THROW_BAD_ALLOC_IF_NULL(cipher);
+
+    EVP_DecryptInit(cipher, EVP_aes_128_ecb(), reinterpret_cast<const unsigned char*>(key.data()), NULL);
+    EVP_CIPHER_CTX_set_padding(cipher, 0);
+
+    EVP_DecryptUpdate(cipher,
+                      reinterpret_cast<unsigned char*>(plaintext.data()),
+                      &plaintextLen,
+                      reinterpret_cast<const unsigned char*>(ciphertext.data()),
+                      ciphertext.length());
+    Q_ASSERT(plaintextLen == plaintext.length());
+
+    EVP_CIPHER_CTX_free(cipher);

    return plaintext;
 }

 QByteArray
-NvPairingManager::getSignatureFromPemCert(QByteArray certificate)
+NvPairingManager::getSignatureFromPemCert(const QByteArray& certificate)
 {
+#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
+    BIO* bio = BIO_new_mem_buf(const_cast<char*>(certificate.data()), -1);
+#else
    BIO* bio = BIO_new_mem_buf(certificate.data(), -1);
+#endif
    THROW_BAD_ALLOC_IF_NULL(bio);

    X509* cert = PEM_read_bio_X509(bio, nullptr, nullptr, nullptr);
@@ -107,9 +132,13 @@ NvPairingManager::getSignatureFromPemCert(QByteArray certificate)
 }

 bool
-NvPairingManager::verifySignature(QByteArray data, QByteArray signature, QByteArray serverCertificate)
+NvPairingManager::verifySignature(const QByteArray& data, const QByteArray& signature, const QByteArray& serverCertificate)
 {
+#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
+    BIO* bio = BIO_new_mem_buf(const_cast<char*>(serverCertificate.data()), -1);
+#else
    BIO* bio = BIO_new_mem_buf(serverCertificate.data(), -1);
+#endif
    THROW_BAD_ALLOC_IF_NULL(bio);

    X509* cert = PEM_read_bio_X509(bio, nullptr, nullptr, nullptr);
@@ -123,7 +152,7 @@ NvPairingManager::verifySignature(QByteArray data, QByteArray signature, QByteAr

    EVP_DigestVerifyInit(mdctx, nullptr, EVP_sha256(), nullptr, pubKey);
    EVP_DigestVerifyUpdate(mdctx, data.data(), data.length());
-    int result = EVP_DigestVerifyFinal(mdctx, reinterpret_cast<unsigned char*>(signature.data()), signature.length());
+    int result = EVP_DigestVerifyFinal(mdctx, reinterpret_cast<unsigned char*>(const_cast<char*>(signature.data())), signature.length());

    EVP_PKEY_free(pubKey);
    EVP_MD_CTX_destroy(mdctx);
@@ -133,17 +162,13 @@ NvPairingManager::verifySignature(QByteArray data, QByteArray signature, QByteAr
 }

 QByteArray
-NvPairingManager::signMessage(QByteArray message)
+NvPairingManager::signMessage(const QByteArray& message)
 {
    EVP_MD_CTX *ctx = EVP_MD_CTX_create();
    THROW_BAD_ALLOC_IF_NULL(ctx);

-    const EVP_MD *md = EVP_get_digestbyname("SHA256");
-    THROW_BAD_ALLOC_IF_NULL(md);
-
-    EVP_DigestInit_ex(ctx, md, NULL);
-    EVP_DigestSignInit(ctx, NULL, md, NULL, m_PrivateKey);
-    EVP_DigestSignUpdate(ctx, reinterpret_cast<unsigned char*>(message.data()), message.length());
+    EVP_DigestSignInit(ctx, NULL, EVP_sha256(), NULL, m_PrivateKey);
+    EVP_DigestSignUpdate(ctx, reinterpret_cast<unsigned char*>(const_cast<char*>(message.data())), message.length());

    size_t signatureLength = 0;
    EVP_DigestSignFinal(ctx, NULL, &signatureLength);
@@ -157,7 +182,7 @@ NvPairingManager::signMessage(QByteArray message)
 }

 QByteArray
-NvPairingManager::saltPin(QByteArray salt, QString pin)
+NvPairingManager::saltPin(const QByteArray& salt, QString pin)
 {
    return QByteArray().append(salt).append(pin.toLatin1());
 }
@@ -186,9 +211,8 @@ NvPairingManager::pair(QString appVersion, QString pin, QSslCertificate& serverC
    QByteArray salt = generateRandomBytes(16);
    QByteArray saltedPin = saltPin(salt, pin);

-    AES_KEY encKey, decKey;
-    AES_set_decrypt_key(reinterpret_cast<const unsigned char*>(QCryptographicHash::hash(saltedPin, hashAlgo).data()), 128, &decKey);
-    AES_set_encrypt_key(reinterpret_cast<const unsigned char*>(QCryptographicHash::hash(saltedPin, hashAlgo).data()), 128, &encKey);
+    QByteArray aesKey = QCryptographicHash::hash(saltedPin, hashAlgo).constData();
+    aesKey.truncate(16);

    QString getCert = m_Http.openConnectionToString(m_Http.m_BaseUrlHttp,
                                                    "pair",
@@ -210,20 +234,21 @@ NvPairingManager::pair(QString appVersion, QString pin, QSslCertificate& serverC
        return PairState::ALREADY_IN_PROGRESS;
    }

-    serverCert = QSslCertificate(serverCertStr);
-    if (serverCert.isNull()) {
-        Q_ASSERT(!serverCert.isNull());
+    QSslCertificate unverifiedServerCert = QSslCertificate(serverCertStr);
+    if (unverifiedServerCert.isNull()) {
+        Q_ASSERT(!unverifiedServerCert.isNull());

        qCritical() << "Failed to parse plaincert";
        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
        return PairState::FAILED;
    }

-    // Pin this cert for TLS
-    m_Http.setServerCert(serverCert);
+    // Pin this cert for TLS until pairing is complete. If successful, we will propagate
+    // the cert into the NvComputer object and persist it.
+    m_Http.setServerCert(unverifiedServerCert);

    QByteArray randomChallenge = generateRandomBytes(16);
-    QByteArray encryptedChallenge = encrypt(randomChallenge, &encKey);
+    QByteArray encryptedChallenge = encrypt(randomChallenge, aesKey);
    QString challengeXml = m_Http.openConnectionToString(m_Http.m_BaseUrlHttp,
                                                         "pair",
                                                         "devicename=roth&updateState=1&clientchallenge=" +
@@ -237,7 +262,7 @@ NvPairingManager::pair(QString appVersion, QString pin, QSslCertificate& serverC
        return PairState::FAILED;
    }

-    QByteArray challengeResponseData = decrypt(m_Http.getXmlStringFromHex(challengeXml, "challengeresponse"), &decKey);
+    QByteArray challengeResponseData = decrypt(m_Http.getXmlStringFromHex(challengeXml, "challengeresponse"), aesKey);
    QByteArray clientSecretData = generateRandomBytes(16);
    QByteArray challengeResponse;
    QByteArray serverResponse(challengeResponseData.data(), hashLength);
@@ -258,7 +283,7 @@ NvPairingManager::pair(QString appVersion, QString pin, QSslCertificate& serverC

    QByteArray paddedHash = QCryptographicHash::hash(challengeResponse, hashAlgo);
    paddedHash.resize(32);
-    QByteArray encryptedChallengeResponseHash = encrypt(paddedHash, &encKey);
+    QByteArray encryptedChallengeResponseHash = encrypt(paddedHash, aesKey);
    QString respXml = m_Http.openConnectionToString(m_Http.m_BaseUrlHttp,
                                                    "pair",
                                                    "devicename=roth&updateState=1&serverchallengeresp=" +
@@ -273,8 +298,8 @@ NvPairingManager::pair(QString appVersion, QString pin, QSslCertificate& serverC
    }

    QByteArray pairingSecret = NvHTTP::getXmlStringFromHex(respXml, "pairingsecret");
-    QByteArray serverSecret = QByteArray(pairingSecret.data(), 16);
-    QByteArray serverSignature = QByteArray(&pairingSecret.data()[16], 256);
+    QByteArray serverSecret = pairingSecret.left(16);
+    QByteArray serverSignature = pairingSecret.mid(16);

    if (!verifySignature(serverSecret,
                         serverSignature,
@@ -325,5 +350,6 @@ NvPairingManager::pair(QString appVersion, QString pin, QSslCertificate& serverC
        return PairState::FAILED;
    }

+    serverCert = std::move(unverifiedServerCert);
    return PairState::PAIRED;
 }
@@ -3,7 +3,6 @@
 #include "identitymanager.h"
 #include "nvhttp.h"

-#include <openssl/aes.h>
 #include <openssl/x509.h>
 #include <openssl/evp.h>

@@ -18,7 +17,7 @@ public:
        ALREADY_IN_PROGRESS
    };

-    explicit NvPairingManager(QString address);
+    explicit NvPairingManager(NvComputer* computer);

    ~NvPairingManager();

@@ -30,22 +29,22 @@ private:
    generateRandomBytes(int length);

    QByteArray
-    saltPin(QByteArray salt, QString pin);
+    saltPin(const QByteArray& salt, QString pin);

    QByteArray
-    encrypt(QByteArray plaintext, AES_KEY* key);
+    encrypt(const QByteArray& plaintext, const QByteArray& key);

    QByteArray
-    decrypt(QByteArray ciphertext, AES_KEY* key);
+    decrypt(const QByteArray& ciphertext, const QByteArray& key);

    QByteArray
-    getSignatureFromPemCert(QByteArray certificate);
+    getSignatureFromPemCert(const QByteArray& certificate);

    bool
-    verifySignature(QByteArray data, QByteArray signature, QByteArray serverCertificate);
+    verifySignature(const QByteArray& data, const QByteArray& signature, const QByteArray& serverCertificate);

    QByteArray
-    signMessage(QByteArray message);
+    signMessage(const QByteArray& message);

    NvHTTP m_Http;
    X509* m_Cert;
@@ -21,8 +21,12 @@ RichPresenceManager::RichPresenceManager(StreamingPreferences& prefs, QString ga
        DiscordRichPresence discordPresence = {};
        discordPresence.state = stateStr.data();
        discordPresence.startTimestamp = time(nullptr);
+        discordPresence.largeImageKey = "icon";
        Discord_UpdatePresence(&discordPresence);
    }
+#else
+    Q_UNUSED(prefs)
+    Q_UNUSED(gameName)
 #endif
 }

@@ -1,26 +1,64 @@
 #include "systemproperties.h"
+#include "utils.h"

 #include <QGuiApplication>
+#include <QLibraryInfo>

 #include "streaming/session.h"
 #include "streaming/streamutils.h"

+#ifdef Q_OS_WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#endif
+
 SystemProperties::SystemProperties()
 {
-    isRunningWayland = qgetenv("XDG_SESSION_TYPE") == "wayland";
-    isRunningXWayland = qgetenv("XDG_SESSION_TYPE") == "wayland" && QGuiApplication::platformName() == "xcb";
+    versionString = QString(VERSION_STR);
+    hasDesktopEnvironment = WMUtils::isRunningDesktopEnvironment();
+    isRunningWayland = WMUtils::isRunningWayland();
+    isRunningXWayland = isRunningWayland && QGuiApplication::platformName() == "xcb";
+    usesMaterial3Theme = QLibraryInfo::version() >= QVersionNumber(6, 5, 0);
+    QString nativeArch = QSysInfo::currentCpuArchitecture();

 #ifdef Q_OS_WIN32
-    isWow64 = QSysInfo::currentCpuArchitecture() != QSysInfo::buildCpuArchitecture();
+    {
+        USHORT processArch, machineArch;
+
+        // Use IsWow64Process2 on TH2 and later, because it supports ARM64
+        auto fnIsWow64Process2 = (decltype(IsWow64Process2)*)GetProcAddress(GetModuleHandleA("kernel32.dll"), "IsWow64Process2");
+        if (fnIsWow64Process2 != nullptr && fnIsWow64Process2(GetCurrentProcess(), &processArch, &machineArch)) {
+            switch (machineArch) {
+            case IMAGE_FILE_MACHINE_I386:
+                nativeArch = "i386";
+                break;
+            case IMAGE_FILE_MACHINE_AMD64:
+                nativeArch = "x86_64";
+                break;
+            case IMAGE_FILE_MACHINE_ARM64:
+                nativeArch = "arm64";
+                break;
+            }
+        }
+
+        isWow64 = nativeArch != QSysInfo::buildCpuArchitecture();
+    }
 #else
    isWow64 = false;
 #endif

-#ifndef STEAM_LINK
-    hasBrowser = true;
-#else
-    hasBrowser = false;
-#endif
+    if (nativeArch == "i386") {
+        friendlyNativeArchName = "x86";
+    }
+    else if (nativeArch == "x86_64") {
+        friendlyNativeArchName = "x64";
+    }
+    else {
+        friendlyNativeArchName = nativeArch.toUpper();
+    }
+
+    // Assume we can probably launch a browser if we're in a GUI environment
+    hasBrowser = hasDesktopEnvironment;

 #ifdef HAVE_DISCORD
    hasDiscordIntegration = true;
@@ -34,15 +72,9 @@ SystemProperties::SystemProperties()
    // and cache the results to speed up future queries on this data.
    querySdlVideoInfo();

-    Q_ASSERT(maximumStreamingFrameRate >= 60);
-    Q_ASSERT(!monitorDesktopResolutions.isEmpty());
+    Q_ASSERT(!monitorRefreshRates.isEmpty());
    Q_ASSERT(!monitorNativeResolutions.isEmpty());
-}
-
-QRect SystemProperties::getDesktopResolution(int displayIndex)
-{
-    // Returns default constructed QRect if out of bounds
-    return monitorDesktopResolutions.value(displayIndex);
+    Q_ASSERT(!monitorSafeAreaResolutions.isEmpty());
 }

 QRect SystemProperties::getNativeResolution(int displayIndex)
@@ -51,14 +83,50 @@ QRect SystemProperties::getNativeResolution(int displayIndex)
    return monitorNativeResolutions.value(displayIndex);
 }

+QRect SystemProperties::getSafeAreaResolution(int displayIndex)
+{
+    // Returns default constructed QRect if out of bounds
+    return monitorSafeAreaResolutions.value(displayIndex);
+}
+
+int SystemProperties::getRefreshRate(int displayIndex)
+{
+    // Returns 0 if out of bounds
+    return monitorRefreshRates.value(displayIndex);
+}
+
+class QuerySdlVideoThread : public QThread
+{
+public:
+    QuerySdlVideoThread(SystemProperties* me) :
+        QThread(nullptr),
+        m_Me(me) {}
+
+    void run() override
+    {
+        m_Me->querySdlVideoInfoInternal();
+    }
+
+    SystemProperties* m_Me;
+};
+
 void SystemProperties::querySdlVideoInfo()
 {
-    monitorDesktopResolutions.clear();
-    monitorNativeResolutions.clear();
-    hasHardwareAcceleration = false;
+    if (WMUtils::isRunningX11() || WMUtils::isRunningWayland()) {
+        // Use a separate thread to temporarily initialize SDL
+        // video to avoid stomping on Qt's X11 and OGL state.
+        QuerySdlVideoThread thread(this);
+        thread.start();
+        thread.wait();
+    }
+    else {
+        querySdlVideoInfoInternal();
+    }
+}

-    // Never let the maximum drop below 60 FPS
-    maximumStreamingFrameRate = 60;
+void SystemProperties::querySdlVideoInfoInternal()
+{
+    hasHardwareAcceleration = false;

    if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
@@ -67,23 +135,89 @@ void SystemProperties::querySdlVideoInfo()
        return;
    }

+    // Update display related attributes (max FPS, native resolution, etc).
+    // We call the internal variant because we're already in a safe thread context.
+    refreshDisplaysInternal();
+
+    SDL_Window* testWindow = SDL_CreateWindow("", 0, 0, 1280, 720,
+                                              SDL_WINDOW_HIDDEN | StreamUtils::getPlatformWindowFlags());
+    if (!testWindow) {
+        SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
+                    "Failed to create test window with platform flags: %s",
+                    SDL_GetError());
+
+        testWindow = SDL_CreateWindow("", 0, 0, 1280, 720, SDL_WINDOW_HIDDEN);
+        if (!testWindow) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                         "Failed to create window for hardware decode test: %s",
+                         SDL_GetError());
+            SDL_QuitSubSystem(SDL_INIT_VIDEO);
+            return;
+        }
+    }
+
+    Session::getDecoderInfo(testWindow, hasHardwareAcceleration, rendererAlwaysFullScreen, supportsHdr, maximumResolution);
+
+    SDL_DestroyWindow(testWindow);
+
+    SDL_QuitSubSystem(SDL_INIT_VIDEO);
+}
+
+class RefreshDisplaysThread : public QThread
+{
+public:
+    RefreshDisplaysThread(SystemProperties* me) :
+        QThread(nullptr),
+        m_Me(me) {}
+
+    void run() override
+    {
+        m_Me->refreshDisplaysInternal();
+    }
+
+    SystemProperties* m_Me;
+};
+
+void SystemProperties::refreshDisplays()
+{
+    if (WMUtils::isRunningX11() || WMUtils::isRunningWayland()) {
+        // Use a separate thread to temporarily initialize SDL
+        // video to avoid stomping on Qt's X11 and OGL state.
+        RefreshDisplaysThread thread(this);
+        thread.start();
+        thread.wait();
+    }
+    else {
+        refreshDisplaysInternal();
+    }
+}
+
+void SystemProperties::refreshDisplaysInternal()
+{
+    if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                     "SDL_InitSubSystem(SDL_INIT_VIDEO) failed: %s",
+                     SDL_GetError());
+        return;
+    }
+
+    monitorNativeResolutions.clear();
+
    SDL_DisplayMode bestMode;
    for (int displayIndex = 0; displayIndex < SDL_GetNumVideoDisplays(); displayIndex++) {
        SDL_DisplayMode desktopMode;
-        int err;
+        SDL_Rect safeArea;

-        err = SDL_GetDesktopDisplayMode(displayIndex, &desktopMode);
-        if (err == 0) {
-            monitorDesktopResolutions.insert(displayIndex, QRect(0, 0, desktopMode.w, desktopMode.h));
-        }
-        else {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "SDL_GetDesktopDisplayMode() failed: %s",
-                         SDL_GetError());
-        }
-
-        if (StreamUtils::getRealDesktopMode(displayIndex, &desktopMode)) {
-            monitorNativeResolutions.insert(displayIndex, QRect(0, 0, desktopMode.w, desktopMode.h));
+        if (StreamUtils::getNativeDesktopMode(displayIndex, &desktopMode, &safeArea)) {
+            if (desktopMode.w <= 8192 && desktopMode.h <= 8192) {
+                monitorNativeResolutions.insert(displayIndex, QRect(0, 0, desktopMode.w, desktopMode.h));
+                monitorSafeAreaResolutions.insert(displayIndex, QRect(0, 0, safeArea.w, safeArea.h));
+            }
+            else {
+                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
+                            "Skipping resolution over 8K: %dx%d",
+                            desktopMode.w, desktopMode.h);
+            }

            // Start at desktop mode and work our way up
            bestMode = desktopMode;
@@ -98,26 +232,19 @@ void SystemProperties::querySdlVideoInfo()
                }
            }

-            maximumStreamingFrameRate = qMax(maximumStreamingFrameRate, bestMode.refresh_rate);
+            // Try to normalize values around our our standard refresh rates.
+            // Some displays/OSes report values that are slightly off.
+            if (bestMode.refresh_rate >= 58 && bestMode.refresh_rate <= 62) {
+                monitorRefreshRates.append(60);
+            }
+            else if (bestMode.refresh_rate >= 28 && bestMode.refresh_rate <= 32) {
+                monitorRefreshRates.append(30);
+            }
+            else {
+                monitorRefreshRates.append(bestMode.refresh_rate);
+            }
        }
    }

-    SDL_Window* testWindow = SDL_CreateWindow("", 0, 0, 1280, 720, SDL_WINDOW_HIDDEN);
-    if (!testWindow) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Failed to create window for hardware decode test: %s",
-                     SDL_GetError());
-        SDL_QuitSubSystem(SDL_INIT_VIDEO);
-        return;
-    }
-
-    hasHardwareAcceleration =
-            Session::isHardwareDecodeAvailable(testWindow,
-                                               StreamingPreferences::VDS_AUTO,
-                                               VIDEO_FORMAT_H264,
-                                               1920, 1080, 60);
-
-    SDL_DestroyWindow(testWindow);
-
    SDL_QuitSubSystem(SDL_INIT_VIDEO);
 }
@@ -7,36 +7,56 @@ class SystemProperties : public QObject
 {
    Q_OBJECT

+    friend class QuerySdlVideoThread;
+    friend class RefreshDisplaysThread;
+
 public:
    SystemProperties();

    Q_PROPERTY(bool hasHardwareAcceleration MEMBER hasHardwareAcceleration CONSTANT)
+    Q_PROPERTY(bool rendererAlwaysFullScreen MEMBER rendererAlwaysFullScreen CONSTANT)
    Q_PROPERTY(bool isRunningWayland MEMBER isRunningWayland CONSTANT)
    Q_PROPERTY(bool isRunningXWayland MEMBER isRunningXWayland CONSTANT)
    Q_PROPERTY(bool isWow64 MEMBER isWow64 CONSTANT)
+    Q_PROPERTY(QString friendlyNativeArchName MEMBER friendlyNativeArchName CONSTANT)
+    Q_PROPERTY(bool hasDesktopEnvironment MEMBER hasDesktopEnvironment CONSTANT)
    Q_PROPERTY(bool hasBrowser MEMBER hasBrowser CONSTANT)
    Q_PROPERTY(bool hasDiscordIntegration MEMBER hasDiscordIntegration CONSTANT)
    Q_PROPERTY(QString unmappedGamepads MEMBER unmappedGamepads NOTIFY unmappedGamepadsChanged)
-    Q_PROPERTY(int maximumStreamingFrameRate MEMBER maximumStreamingFrameRate CONSTANT)
+    Q_PROPERTY(QSize maximumResolution MEMBER maximumResolution CONSTANT)
+    Q_PROPERTY(QString versionString MEMBER versionString CONSTANT)
+    Q_PROPERTY(bool supportsHdr MEMBER supportsHdr CONSTANT)
+    Q_PROPERTY(bool usesMaterial3Theme MEMBER usesMaterial3Theme CONSTANT)

-    Q_INVOKABLE QRect getDesktopResolution(int displayIndex);
+    Q_INVOKABLE void refreshDisplays();
    Q_INVOKABLE QRect getNativeResolution(int displayIndex);
+    Q_INVOKABLE QRect getSafeAreaResolution(int displayIndex);
+    Q_INVOKABLE int getRefreshRate(int displayIndex);

 signals:
    void unmappedGamepadsChanged();

 private:
    void querySdlVideoInfo();
+    void querySdlVideoInfoInternal();
+    void refreshDisplaysInternal();

    bool hasHardwareAcceleration;
+    bool rendererAlwaysFullScreen;
    bool isRunningWayland;
    bool isRunningXWayland;
    bool isWow64;
+    QString friendlyNativeArchName;
+    bool hasDesktopEnvironment;
    bool hasBrowser;
    bool hasDiscordIntegration;
    QString unmappedGamepads;
-    int maximumStreamingFrameRate;
-    QList<QRect> monitorDesktopResolutions;
+    QSize maximumResolution;
    QList<QRect> monitorNativeResolutions;
+    QList<QRect> monitorSafeAreaResolutions;
+    QList<int> monitorRefreshRates;
+    QString versionString;
+    bool supportsHdr;
+    bool usesMaterial3Theme;
 };

@@ -52,7 +52,7 @@ public:

    void handleUnknownOptions()
    {
-        if (unknownOptionNames().length()) {
+        if (!unknownOptionNames().isEmpty()) {
            showError(QString("Unknown options: %1").arg(unknownOptionNames().join(", ")));
        }
    }
@@ -164,28 +164,45 @@ GlobalCommandLineParser::ParseResult GlobalCommandLineParser::parse(const QStrin
        "Starts Moonlight normally if no arguments are given.\n"
        "\n"
        "Available actions:\n"
+        "  list            List the available apps on a host\n"
        "  quit            Quit the currently running app\n"
        "  stream          Start streaming an app\n"
+        "  pair            Pair a new host\n"
        "\n"
        "See 'moonlight <action> --help' for help of specific action."
    );
    parser.addPositionalArgument("action", "Action to execute", "<action>");
    parser.parse(args);
    auto posArgs = parser.positionalArguments();
-    QString action = posArgs.isEmpty() ? QString() : posArgs.first().toLower();

-    if (action == "") {
+    if (posArgs.isEmpty()) {
        // This method will not return and terminates the process if --version
        // or --help is specified
        parser.handleHelpAndVersionOptions();
        parser.handleUnknownOptions();
        return NormalStartRequested;
-    } else if (action == "quit") {
-        return QuitRequested;
-    } else if (action == "stream") {
-        return StreamRequested;
-    } else {
-        parser.showError(QString("Invalid action: %1").arg(action));
+    }
+    else {
+        // If users supply arguments that accept values prior to the "quit"
+        // or "stream" positional arguments, we will not be able to correctly
+        // parse the value out of the input because this QCommandLineParser
+        // doesn't know about all of the options that "quit" and "stream"
+        // commands can accept. To work around this issue, we just look
+        // for "quit" or "stream" positional arguments anywhere.
+        for (int i = 0; i < posArgs.size(); i++) {
+            QString action = posArgs.at(i).toLower();
+            if (action == "quit") {
+                return QuitRequested;
+            } else if (action == "stream") {
+                return StreamRequested;
+            } else if (action == "pair") {
+                return PairRequested;
+            } else if (action == "list") {
+                return ListRequested;
+            }
+        }
+
+        parser.showError(QString("Invalid action"));
    }
 }

@@ -231,6 +248,58 @@ QString QuitCommandLineParser::getHost() const
    return m_Host;
 }

+PairCommandLineParser::PairCommandLineParser()
+{
+}
+
+PairCommandLineParser::~PairCommandLineParser()
+{
+}
+
+void PairCommandLineParser::parse(const QStringList &args)
+{
+    CommandLineParser parser;
+    parser.setupCommonOptions();
+    parser.setApplicationDescription(
+        "\n"
+        "Pair with the specified host."
+    );
+    parser.addPositionalArgument("pair", "pair host");
+    parser.addPositionalArgument("host", "Host computer name, UUID, or IP address", "<host>");
+    parser.addValueOption("pin", "4 digit pairing PIN");
+
+    if (!parser.parse(args)) {
+        parser.showError(parser.errorText());
+    }
+
+    parser.handleUnknownOptions();
+
+    // This method will not return and terminates the process if --version or
+    // --help is specified
+    parser.handleHelpAndVersionOptions();
+
+    // Verify that host has been provided
+    auto posArgs = parser.positionalArguments();
+    if (posArgs.length() < 2) {
+        parser.showError("Host not provided");
+    }
+    m_Host = parser.positionalArguments().at(1);
+    m_PredefinedPin = parser.value("pin");
+    if (!m_PredefinedPin.isEmpty() && m_PredefinedPin.length() != 4) {
+        parser.showError("PIN must be 4 digits");
+    }
+}
+
+QString PairCommandLineParser::getHost() const
+{
+    return m_Host;
+}
+
+QString PairCommandLineParser::getPredefinedPin() const
+{
+    return m_PredefinedPin;
+}
+
 StreamCommandLineParser::StreamCommandLineParser()
 {
    m_WindowModeMap = {
@@ -241,16 +310,23 @@ StreamCommandLineParser::StreamCommandLineParser()
    m_AudioConfigMap = {
        {"stereo",       StreamingPreferences::AC_STEREO},
        {"5.1-surround", StreamingPreferences::AC_51_SURROUND},
+        {"7.1-surround", StreamingPreferences::AC_71_SURROUND},
    };
    m_VideoCodecMap = {
        {"auto",  StreamingPreferences::VCC_AUTO},
        {"H.264", StreamingPreferences::VCC_FORCE_H264},
        {"HEVC",  StreamingPreferences::VCC_FORCE_HEVC},
+        {"AV1", StreamingPreferences::VCC_FORCE_AV1},
    };
    m_VideoDecoderMap = {
        {"auto",     StreamingPreferences::VDS_AUTO},
-        {"software", StreamingPreferences::VDS_FORCE_HARDWARE},
-        {"hardware", StreamingPreferences::VDS_FORCE_SOFTWARE},
+        {"software", StreamingPreferences::VDS_FORCE_SOFTWARE},
+        {"hardware", StreamingPreferences::VDS_FORCE_HARDWARE},
+    };
+    m_CaptureSysKeysModeMap = {
+        {"never",      StreamingPreferences::CSK_OFF},
+        {"fullscreen", StreamingPreferences::CSK_FULLSCREEN},
+        {"always",     StreamingPreferences::CSK_ALWAYS},
    };
 }

@@ -280,14 +356,25 @@ void StreamCommandLineParser::parse(const QStringList &args, StreamingPreference
    parser.addToggleOption("vsync", "V-Sync");
    parser.addValueOption("fps", "FPS");
    parser.addValueOption("bitrate", "bitrate in Kbps");
+    parser.addValueOption("packet-size", "video packet size");
    parser.addChoiceOption("display-mode", "display mode", m_WindowModeMap.keys());
    parser.addChoiceOption("audio-config", "audio config", m_AudioConfigMap.keys());
    parser.addToggleOption("multi-controller", "multiple controller support");
    parser.addToggleOption("quit-after", "quit app after session");
-    parser.addToggleOption("mouse-acceleration", "mouse acceleration");
+    parser.addToggleOption("absolute-mouse", "remote desktop optimized mouse control");
+    parser.addToggleOption("mouse-buttons-swap", "left and right mouse buttons swap");
+    parser.addToggleOption("touchscreen-trackpad", "touchscreen in trackpad mode");
    parser.addToggleOption("game-optimization", "game optimizations");
    parser.addToggleOption("audio-on-host", "audio on host PC");
    parser.addToggleOption("frame-pacing", "frame pacing");
+    parser.addToggleOption("mute-on-focus-loss", "mute audio when Moonlight window loses focus");
+    parser.addToggleOption("background-gamepad", "background gamepad input");
+    parser.addToggleOption("reverse-scroll-direction", "inverted scroll direction");
+    parser.addToggleOption("swap-gamepad-buttons", "swap A/B and X/Y gamepad buttons (Nintendo-style)");
+    parser.addToggleOption("keep-awake", "prevent display sleep while streaming");
+    parser.addToggleOption("performance-overlay", "show performance overlay");
+    parser.addToggleOption("hdr", "HDR streaming");
+    parser.addChoiceOption("capture-system-keys", "capture system key combos", m_CaptureSysKeysModeMap.keys());
    parser.addChoiceOption("video-codec", "video codec", m_VideoCodecMap.keys());
    parser.addChoiceOption("video-decoder", "video decoder", m_VideoDecoderMap.keys());

@@ -300,25 +387,21 @@ void StreamCommandLineParser::parse(const QStringList &args, StreamingPreference
    // Resolve display's width and height
    QRegularExpression resolutionRexExp("^(720|1080|1440|4K|resolution)$");
    QStringList resoOptions = parser.optionNames().filter(resolutionRexExp);
-    bool displaySet = resoOptions.length();
+    bool displaySet = !resoOptions.isEmpty();
    if (displaySet) {
        QString name = resoOptions.last();
        if (name == "720") {
            preferences->width  = 1280;
            preferences->height = 720;
-            displaySet = true;
        } else if (name == "1080") {
            preferences->width  = 1920;
            preferences->height = 1080;
-            displaySet = true;
        } else if (name == "1440") {
            preferences->width  = 2560;
            preferences->height = 1440;
-            displaySet = true;
        } else if (name == "4K") {
            preferences->width  = 3840;
            preferences->height = 2160;
-            displaySet = true;
        } else if (name == "resolution") {
            auto resolution = parser.getResolutionOptionValue(name);
            preferences->width  = resolution.first;
@@ -329,8 +412,8 @@ void StreamCommandLineParser::parse(const QStringList &args, StreamingPreference
    // Resolve --fps option
    if (parser.isSet("fps")) {
        preferences->fps = parser.getIntOption("fps");
-        if (!inRange(preferences->fps, 30, 120)) {
-            parser.showError("FPS must be in range: 30 - 120");
+        if (!inRange(preferences->fps, 30, 240)) {
+            parser.showError("FPS must be in range: 30 - 240");
        }
    }

@@ -345,6 +428,14 @@ void StreamCommandLineParser::parse(const QStringList &args, StreamingPreference
            preferences->width, preferences->height, preferences->fps);
    }

+    // Resolve --packet-size option
+    if (parser.isSet("packet-size")) {
+        preferences->packetSize = parser.getIntOption("packet-size");
+        if (preferences->packetSize < 1024) {
+            parser.showError("Packet size must be greater than 1024 bytes");
+        }
+    }
+
    // Resolve --display option
    if (parser.isSet("display-mode")) {
        preferences->windowMode = mapValue(m_WindowModeMap, parser.getChoiceOptionValue("display-mode"));
@@ -364,8 +455,14 @@ void StreamCommandLineParser::parse(const QStringList &args, StreamingPreference
    // Resolve --quit-after and --no-quit-after options
    preferences->quitAppAfter = parser.getToggleOptionValue("quit-after", preferences->quitAppAfter);

-    // Resolve --mouse-acceleration and --no-mouse-acceleration options
-    preferences->mouseAcceleration = parser.getToggleOptionValue("mouse-acceleration", preferences->mouseAcceleration);
+    // Resolve --absolute-mouse and --no-absolute-mouse options
+    preferences->absoluteMouseMode = parser.getToggleOptionValue("absolute-mouse", preferences->absoluteMouseMode);
+
+    // Resolve --mouse-buttons-swap and --no-mouse-buttons-swap options
+    preferences->swapMouseButtons = parser.getToggleOptionValue("mouse-buttons-swap", preferences->swapMouseButtons);
+
+    // Resolve --touchscreen-trackpad and --no-touchscreen-trackpad options
+    preferences->absoluteTouchMode = !parser.getToggleOptionValue("touchscreen-trackpad", !preferences->absoluteTouchMode);

    // Resolve --game-optimization and --no-game-optimization options
    preferences->gameOptimizations = parser.getToggleOptionValue("game-optimization", preferences->gameOptimizations);
@@ -376,6 +473,32 @@ void StreamCommandLineParser::parse(const QStringList &args, StreamingPreference
    // Resolve --frame-pacing and --no-frame-pacing options
    preferences->framePacing = parser.getToggleOptionValue("frame-pacing", preferences->framePacing);

+    // Resolve --mute-on-focus-loss and --no-mute-on-focus-loss options
+    preferences->muteOnFocusLoss = parser.getToggleOptionValue("mute-on-focus-loss", preferences->muteOnFocusLoss);
+
+    // Resolve --background-gamepad and --no-background-gamepad options
+    preferences->backgroundGamepad = parser.getToggleOptionValue("background-gamepad", preferences->backgroundGamepad);
+
+    // Resolve --reverse-scroll-direction and --no-reverse-scroll-direction options
+    preferences->reverseScrollDirection = parser.getToggleOptionValue("reverse-scroll-direction", preferences->reverseScrollDirection);
+
+    // Resolve --swap-gamepad-buttons and --no-swap-gamepad-buttons options
+    preferences->swapFaceButtons = parser.getToggleOptionValue("swap-gamepad-buttons", preferences->swapFaceButtons);
+
+    // Resolve --keep-awake and --no-keep-awake options
+    preferences->keepAwake = parser.getToggleOptionValue("keep-awake", preferences->keepAwake);
+
+    // Resolve --performance-overlay and --no-performance-overlay options
+    preferences->showPerformanceOverlay = parser.getToggleOptionValue("performance-overlay", preferences->showPerformanceOverlay);
+
+    // Resolve --hdr and --no-hdr options
+    preferences->enableHdr = parser.getToggleOptionValue("hdr", preferences->enableHdr);
+    
+    // Resolve --capture-system-keys option
+    if (parser.isSet("capture-system-keys")) {
+        preferences->captureSysKeysMode = mapValue(m_CaptureSysKeysModeMap, parser.getChoiceOptionValue("capture-system-keys"));
+    }
+
    // Resolve --video-codec option
    if (parser.isSet("video-codec")) {
        preferences->videoCodecConfig = mapValue(m_VideoCodecMap, parser.getChoiceOptionValue("video-codec"));
@@ -412,3 +535,62 @@ QString StreamCommandLineParser::getAppName() const
 {
    return m_AppName;
 }
+
+ListCommandLineParser::ListCommandLineParser()
+{
+}
+
+ListCommandLineParser::~ListCommandLineParser()
+{
+}
+
+void ListCommandLineParser::parse(const QStringList &args)
+{
+    CommandLineParser parser;
+    parser.setupCommonOptions();
+    parser.setApplicationDescription(
+        "\n"
+        "List the available apps on the given host."
+    );
+    parser.addPositionalArgument("list", "list available apps");
+    parser.addPositionalArgument("host", "Host computer name, UUID, or IP address", "<host>");
+
+    parser.addFlagOption("csv",     "Print as CSV with additional information");
+    parser.addFlagOption("verbose", "Displays additional information");
+
+    if (!parser.parse(args)) {
+        parser.showError(parser.errorText());
+    }
+
+    parser.handleUnknownOptions();
+
+
+    m_PrintCSV = parser.isSet("csv");
+    m_Verbose = parser.isSet("verbose");
+
+    // This method will not return and terminates the process if --version or
+    // --help is specified
+    parser.handleHelpAndVersionOptions();
+
+    // Verify that host has been provided
+    auto posArgs = parser.positionalArguments();
+    if (posArgs.length() < 2) {
+        parser.showError("Host not provided");
+    }
+    m_Host = parser.positionalArguments().at(1);
+}
+
+QString ListCommandLineParser::getHost() const
+{
+    return m_Host;
+}
+
+bool ListCommandLineParser::isPrintCSV() const
+{
+    return m_PrintCSV;
+}
+
+bool ListCommandLineParser::isVerbose() const
+{
+    return m_Verbose;
+}
@@ -12,6 +12,8 @@ public:
        NormalStartRequested,
        StreamRequested,
        QuitRequested,
+        PairRequested,
+        ListRequested,
    };

    GlobalCommandLineParser();
@@ -35,6 +37,22 @@ private:
    QString m_Host;
 };

+class PairCommandLineParser
+{
+public:
+    PairCommandLineParser();
+    virtual ~PairCommandLineParser();
+
+    void parse(const QStringList &args);
+
+    QString getHost() const;
+    QString getPredefinedPin() const;
+
+private:
+    QString m_Host;
+    QString m_PredefinedPin;
+};
+
 class StreamCommandLineParser
 {
 public:
@@ -53,4 +71,23 @@ private:
    QMap<QString, StreamingPreferences::AudioConfig> m_AudioConfigMap;
    QMap<QString, StreamingPreferences::VideoCodecConfig> m_VideoCodecMap;
    QMap<QString, StreamingPreferences::VideoDecoderSelection> m_VideoDecoderMap;
+    QMap<QString, StreamingPreferences::CaptureSysKeysMode> m_CaptureSysKeysModeMap;
+};
+
+class ListCommandLineParser
+{
+public:
+    ListCommandLineParser();
+    virtual ~ListCommandLineParser();
+
+    void parse(const QStringList &args);
+
+    QString getHost() const;
+    bool isPrintCSV() const;
+    bool isVerbose() const;
+
+private:
+    QString m_Host;
+    bool m_PrintCSV;
+    bool m_Verbose;
 };
@@ -0,0 +1,208 @@
+#include "listapps.h"
+
+#include "backend/boxartmanager.h"
+#include "backend/computermanager.h"
+#include "backend/computerseeker.h"
+
+#include <QCoreApplication>
+#include <QTimer>
+
+#define COMPUTER_SEEK_TIMEOUT 10000
+#define APP_SEEK_TIMEOUT 10000
+
+namespace CliListApps
+{
+
+enum State {
+    StateInit,
+    StateSeekComputer,
+    StateListApp,
+    StateSeekApp,
+    StateFailure,
+};
+
+class Event
+{
+public:
+    enum Type {
+        ComputerFound,
+        ComputerUpdated,
+        ComputerSeekTimedout,
+        Executed,
+    };
+
+    Event(Type type)
+        : type(type), computerManager(nullptr), computer(nullptr) {}
+
+    Type type;
+    ComputerManager *computerManager;
+    NvComputer *computer;
+    QString errorMessage;
+};
+
+class LauncherPrivate
+{
+    Q_DECLARE_PUBLIC(Launcher)
+
+public:
+    LauncherPrivate(Launcher *q) : q_ptr(q) {}
+
+    void handleEvent(Event event)
+    {
+        Q_Q(Launcher);
+        NvApp app;
+
+        switch (event.type) {
+        // Occurs when CLI main calls execute
+        case Event::Executed:
+            if (m_State == StateInit) {
+                m_State = StateSeekComputer;
+                m_ComputerManager = event.computerManager;
+
+                m_ComputerSeeker = new ComputerSeeker(m_ComputerManager, m_ComputerName, q);
+                q->connect(m_ComputerSeeker, &ComputerSeeker::computerFound,
+                           q, &Launcher::onComputerFound);
+                q->connect(m_ComputerSeeker, &ComputerSeeker::errorTimeout,
+                           q, &Launcher::onComputerSeekTimeout);
+                m_ComputerSeeker->start(COMPUTER_SEEK_TIMEOUT);
+
+                q->connect(m_ComputerManager, &ComputerManager::computerStateChanged,
+                           q, &Launcher::onComputerUpdated);
+
+                m_BoxArtManager = new BoxArtManager(q);
+
+                if (m_Arguments.isVerbose()) {
+                    fprintf(stdout, "Establishing connection to PC...\n");
+                }
+            }
+            break;
+        // Occurs when computer search timed out
+        case Event::ComputerSeekTimedout:
+            if (m_State == StateSeekComputer) {
+                fprintf(stderr, "%s\n", qPrintable(QString("Failed to connect to %1").arg(m_ComputerName)));
+
+                QCoreApplication::exit(-1);
+            }
+            break;
+        // Occurs when searched computer is found
+        case Event::ComputerFound:
+            if (m_State == StateSeekComputer) {
+                if (event.computer->pairState == NvComputer::PS_PAIRED) {
+                    m_State = StateSeekApp;
+                    m_Computer = event.computer;
+                    m_TimeoutTimer->start(APP_SEEK_TIMEOUT);
+                    if (m_Arguments.isVerbose()) {
+                        fprintf(stdout, "Loading app list...\n");
+                    }
+                } else {
+                    m_State = StateFailure;
+                    fprintf(stderr, "%s\n", qPrintable(QObject::tr("Computer %1 has not been paired. "
+                                            "Please open Moonlight to pair before retrieving games list.")
+                                            .arg(event.computer->name)));
+
+                    QCoreApplication::exit(-1);
+                }
+            }
+            break;
+        // Occurs when a computer is updated
+        case Event::ComputerUpdated:
+            if (m_State == StateSeekApp) {
+                m_Arguments.isPrintCSV() ? printAppsCSV(m_Computer->appList) : printApps(m_Computer->appList);
+
+                QCoreApplication::exit(0);
+            }
+            break;
+        }
+    }
+
+    void printApps(QVector<NvApp> apps) {
+        for (int i = 0; i < apps.length(); i++) {
+            fprintf(stdout, "%s\n", qPrintable(apps[i].name));
+        }
+    }
+
+    void printAppsCSV(QVector<NvApp> apps) {
+        fprintf(stdout, "Name, ID, HDR Support, App Collection Game, Hidden, Direct Launch, Boxart URL\n");
+        for (int i = 0; i < apps.length(); i++) {
+            printAppCSV(apps[i]);
+        }
+    }
+
+    void printAppCSV(NvApp app) const
+    {
+        fprintf(stdout, "\"%s\",%d,%s,%s,%s,%s,\"%s\"\n", qPrintable(app.name),
+                                                          app.id,
+                                                          app.hdrSupported ? "true" : "false",
+                                                          app.isAppCollectorGame ? "true" : "false",
+                                                          app.hidden ? "true" : "false",
+                                                          app.directLaunch ? "true" : "false",
+                                                          qPrintable(m_BoxArtManager->loadBoxArt(m_Computer, app).toDisplayString()));
+    }
+
+    Launcher *q_ptr;
+    ComputerManager *m_ComputerManager;
+    QString m_ComputerName;
+    ComputerSeeker *m_ComputerSeeker;
+    BoxArtManager *m_BoxArtManager;
+    NvComputer *m_Computer;
+    State m_State;
+    QTimer *m_TimeoutTimer;
+    ListCommandLineParser m_Arguments;
+};
+
+Launcher::Launcher(QString computer, ListCommandLineParser arguments, QObject *parent)
+    : QObject(parent),
+      m_DPtr(new LauncherPrivate(this))
+{
+    Q_D(Launcher);
+    d->m_ComputerName = computer;
+    d->m_State = StateInit;
+    d->m_TimeoutTimer = new QTimer(this);
+    d->m_TimeoutTimer->setSingleShot(true);
+    d->m_Arguments = arguments;
+    connect(d->m_TimeoutTimer, &QTimer::timeout,
+            this, &Launcher::onComputerSeekTimeout);
+}
+
+Launcher::~Launcher()
+{
+}
+
+void Launcher::execute(ComputerManager *manager)
+{
+    Q_D(Launcher);
+    Event event(Event::Executed);
+    event.computerManager = manager;
+    d->handleEvent(event);
+}
+
+bool Launcher::isExecuted() const
+{
+    Q_D(const Launcher);
+    return d->m_State != StateInit;
+}
+
+void Launcher::onComputerFound(NvComputer *computer)
+{
+    Q_D(Launcher);
+    Event event(Event::ComputerFound);
+    event.computer = computer;
+    d->handleEvent(event);
+}
+
+void Launcher::onComputerSeekTimeout()
+{
+    Q_D(Launcher);
+    Event event(Event::ComputerSeekTimedout);
+    d->handleEvent(event);
+}
+
+void Launcher::onComputerUpdated(NvComputer *computer)
+{
+    Q_D(Launcher);
+    Event event(Event::ComputerUpdated);
+    event.computer = computer;
+    d->handleEvent(event);
+}
+
+}
@@ -0,0 +1,38 @@
+#pragma once
+
+#include "commandlineparser.h"
+
+#include <QObject>
+#include <QVariant>
+
+class ComputerManager;
+class NvComputer;
+
+namespace CliListApps
+{
+
+class LauncherPrivate;
+
+class Launcher : public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE_D(m_DPtr, Launcher)
+
+public:
+    explicit Launcher(QString computer, ListCommandLineParser arguments, QObject *parent = nullptr);
+    ~Launcher();
+
+    Q_INVOKABLE void execute(ComputerManager *manager);
+    Q_INVOKABLE bool isExecuted() const;
+
+private slots:
+    void onComputerFound(NvComputer *computer);
+    void onComputerUpdated(NvComputer *computer);
+    void onComputerSeekTimeout();
+
+private:
+    QScopedPointer<LauncherPrivate> m_DPtr;
+    ListCommandLineParser m_Arguments;
+};
+
+}
@@ -0,0 +1,181 @@
+#include "pair.h"
+
+#include "backend/computermanager.h"
+#include "backend/computerseeker.h"
+#include <QCoreApplication>
+#include <QTimer>
+
+#define COMPUTER_SEEK_TIMEOUT 10000
+
+namespace CliPair
+{
+
+enum State {
+    StateInit,
+    StateSeekComputer,
+    StatePairing,
+    StateFailure,
+    StateComplete,
+};
+
+class Event
+{
+public:
+    enum Type {
+        ComputerFound,
+        Executed,
+        PairingCompleted,
+        Timedout,
+    };
+
+    Event(Type type)
+        : type(type), computerManager(nullptr), computer(nullptr) {}
+
+    Type type;
+    ComputerManager *computerManager;
+    NvComputer *computer;
+    QString errorMessage;
+};
+
+class LauncherPrivate
+{
+    Q_DECLARE_PUBLIC(Launcher)
+
+public:
+    LauncherPrivate(Launcher *q) : q_ptr(q) {}
+
+    void handleEvent(Event event)
+    {
+        Q_Q(Launcher);
+
+        switch (event.type) {
+        // Occurs when CliPair becomes visible and the UI calls launcher's execute()
+        case Event::Executed:
+            if (m_State == StateInit) {
+                m_State = StateSeekComputer;
+                m_ComputerManager = event.computerManager;
+                q->connect(m_ComputerManager, &ComputerManager::pairingCompleted,
+                           q, &Launcher::onPairingCompleted);
+
+                // If we weren't provided a predefined PIN, generate one now
+                if (m_PredefinedPin.isEmpty()) {
+                    m_PredefinedPin = m_ComputerManager->generatePinString();
+                }
+
+                m_ComputerSeeker = new ComputerSeeker(m_ComputerManager, m_ComputerName, q);
+                q->connect(m_ComputerSeeker, &ComputerSeeker::computerFound,
+                           q, &Launcher::onComputerFound);
+                q->connect(m_ComputerSeeker, &ComputerSeeker::errorTimeout,
+                           q, &Launcher::onTimeout);
+                m_ComputerSeeker->start(COMPUTER_SEEK_TIMEOUT);
+
+                emit q->searchingComputer();
+            }
+            break;
+        // Occurs when searched computer is found
+        case Event::ComputerFound:
+            if (m_State == StateSeekComputer) {
+                if (event.computer->pairState == NvComputer::PS_PAIRED) {
+                    m_State = StateFailure;
+                    QString msg = QObject::tr("%1 is already paired").arg(event.computer->name);
+                    emit q->failed(msg);
+                }
+                else {
+                    Q_ASSERT(!m_PredefinedPin.isEmpty());
+
+                    m_State = StatePairing;
+                    m_ComputerManager->pairHost(event.computer, m_PredefinedPin);
+                    emit q->pairing(event.computer->name, m_PredefinedPin);
+                }
+            }
+            break;
+        // Occurs when pairing operation completes
+        case Event::PairingCompleted:
+            if (m_State == StatePairing) {
+                if (event.errorMessage.isEmpty()) {
+                    m_State = StateComplete;
+                    emit q->success();
+                }
+                else {
+                    m_State = StateFailure;
+                    emit q->failed(event.errorMessage);
+                }
+            }
+            break;
+        // Occurs when computer search timed out
+        case Event::Timedout:
+            if (m_State == StateSeekComputer) {
+                m_State = StateFailure;
+                emit q->failed(QObject::tr("Failed to connect to %1").arg(m_ComputerName));
+            }
+            break;
+        }
+    }
+
+    Launcher *q_ptr;
+    QString m_ComputerName;
+    QString m_PredefinedPin;
+    ComputerManager *m_ComputerManager;
+    ComputerSeeker *m_ComputerSeeker;
+    NvComputer *m_Computer;
+    State m_State;
+    QTimer *m_TimeoutTimer;
+};
+
+Launcher::Launcher(QString computer, QString predefinedPin, QObject *parent)
+    : QObject(parent),
+      m_DPtr(new LauncherPrivate(this))
+{
+    Q_D(Launcher);
+    d->m_ComputerName = computer;
+    d->m_PredefinedPin = predefinedPin;
+    d->m_State = StateInit;
+    d->m_TimeoutTimer = new QTimer(this);
+    d->m_TimeoutTimer->setSingleShot(true);
+    connect(d->m_TimeoutTimer, &QTimer::timeout,
+            this, &Launcher::onTimeout);
+}
+
+Launcher::~Launcher()
+{
+}
+
+void Launcher::execute(ComputerManager *manager)
+{
+    Q_D(Launcher);
+    Event event(Event::Executed);
+    event.computerManager = manager;
+    d->handleEvent(event);
+}
+
+bool Launcher::isExecuted() const
+{
+    Q_D(const Launcher);
+    return d->m_State != StateInit;
+}
+
+void Launcher::onComputerFound(NvComputer *computer)
+{
+    Q_D(Launcher);
+    Event event(Event::ComputerFound);
+    event.computer = computer;
+    d->handleEvent(event);
+}
+
+void Launcher::onTimeout()
+{
+    Q_D(Launcher);
+    Event event(Event::Timedout);
+    d->handleEvent(event);
+}
+
+void Launcher::onPairingCompleted(NvComputer* computer, QString error)
+{
+    Q_D(Launcher);
+    Event event(Event::PairingCompleted);
+    event.computer = computer;
+    event.errorMessage = error;
+    d->handleEvent(event);
+}
+
+}
@@ -0,0 +1,44 @@
+#pragma once
+
+#include <QObject>
+#include <QVariant>
+
+class ComputerManager;
+class NvComputer;
+class Session;
+class StreamingPreferences;
+
+namespace CliPair
+{
+
+class Event;
+class LauncherPrivate;
+
+class Launcher : public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE_D(m_DPtr, Launcher)
+
+public:
+    explicit Launcher(QString computer, QString predefinedPin,
+                      QObject *parent = nullptr);
+    ~Launcher();
+    Q_INVOKABLE void execute(ComputerManager *manager);
+    Q_INVOKABLE bool isExecuted() const;
+
+signals:
+    void searchingComputer();
+    void pairing(QString pcName, QString pin);
+    void failed(QString text);
+    void success();
+
+private slots:
+    void onComputerFound(NvComputer *computer);
+    void onPairingCompleted(NvComputer *computer, QString error);
+    void onTimeout();
+
+private:
+    QScopedPointer<LauncherPrivate> m_DPtr;
+};
+
+}
@@ -73,7 +73,7 @@ public:
        case Event::ComputerSeekTimedout:
            if (m_State == StateSeekComputer) {
                m_State = StateFailure;
-                emit q->failed(QString("Failed to connect to %1").arg(m_ComputerName));
+                emit q->failed(QObject::tr("Failed to connect to %1").arg(m_ComputerName));
            }
            break;
        // Occurs when searched computer is found
@@ -85,8 +85,8 @@ public:
                    m_ComputerManager->quitRunningApp(event.computer);
                } else {
                    m_State = StateFailure;
-                    QString msg = QString("Computer %1 has not been paired. "
-                                          "Please open Moonlight to pair before streaming.")
+                    QString msg = QObject::tr("Computer %1 has not been paired. "
+                                              "Please open Moonlight to pair before streaming.")
                            .arg(event.computer->name);
                    emit q->failed(msg);
                }
@@ -99,7 +99,7 @@ public:
                    QCoreApplication::exit(0);
                } else {
                    m_State = StateFailure;
-                    emit q->failed(QString("Quitting app failed, reason: %1").arg(event.errorMessage));
+                    emit q->failed(QObject::tr("Quitting app failed, reason: %1").arg(event.errorMessage));
                }
            }
            break;
@@ -86,8 +86,8 @@ public:
                    emit q->searchingApp();
                } else {
                    m_State = StateFailure;
-                    QString msg = QString("Computer %1 has not been paired. "
-                                          "Please open Moonlight to pair before streaming.")
+                    QString msg = QObject::tr("Computer %1 has not been paired. "
+                                              "Please open Moonlight to pair before streaming.")
                            .arg(event.computer->name);
                    emit q->failed(msg);
                }
@@ -118,23 +118,23 @@ public:
            }
            break;
        // Occurs when the previous app quit has been completed, handles quitting errors if any
-        // happended. ComputerUpdated event's handler handles session start when previous app has
+        // happened. ComputerUpdated event's handler handles session start when previous app has
        // quit.
        case Event::AppQuitCompleted:
            if (m_State == StateSeekApp && !event.errorMessage.isEmpty()) {
                m_State = StateFailure;
-                emit q->failed(QString("Quitting app failed, reason: %1").arg(event.errorMessage));
+                emit q->failed(QObject::tr("Quitting app failed, reason: %1").arg(event.errorMessage));
            }
            break;
        // Occurs when computer or app search timed out
        case Event::Timedout:
            if (m_State == StateSeekComputer) {
                m_State = StateFailure;
-                emit q->failed(QString("Failed to connect to %1").arg(m_ComputerName));
+                emit q->failed(QObject::tr("Failed to connect to %1").arg(m_ComputerName));
            }
            if (m_State == StateSeekApp) {
                m_State = StateFailure;
-                emit q->failed(QString("Failed to find application %1").arg(m_AppName));
+                emit q->failed(QObject::tr("Failed to find application %1").arg(m_AppName));
            }
            break;
        }
@@ -162,7 +162,7 @@ public:

    QString getCurrentAppName() const
    {
-        for (NvApp app : m_Computer->appList) {
+        for (const NvApp& app : m_Computer->appList) {
            if (m_Computer->currentGameId == app.id) {
                return app.name;
            }
@@ -0,0 +1,40 @@
+From 78261eb6e2fe728fa5d3843b5b8962b1ca559b7e Mon Sep 17 00:00:00 2001
+From: David Rosca <nowrep@gmail.com>
+Date: Sat, 16 Dec 2023 14:52:01 +0100
+Subject: [PATCH] Vulkan: Don't try to reuse old swapchain
+
+---
+ src/vulkan/swapchain.c | 12 ++++++++++--
+ 1 file changed, 10 insertions(+), 2 deletions(-)
+
+diff --git a/src/vulkan/swapchain.c b/src/vulkan/swapchain.c
+index 0646e57c..c0b07ce4 100644
+--- a/src/vulkan/swapchain.c
+++ b/src/vulkan/swapchain.c
+@@ -612,13 +612,21 @@ static bool vk_sw_recreate(pl_swapchain sw, int w, int h)
+     }
+ #endif
+ 
+    {
+        pl_gpu_flush(gpu);
+        vk_wait_idle(vk);
+        for (int i = 0; i < vk->pool_graphics->num_queues; i++)
+            vk->QueueWaitIdle(vk->pool_graphics->queues[i]);
+        vk->DestroySwapchainKHR(vk->dev, p->swapchain, PL_VK_ALLOC);
+    }
+
+     // Calling `vkCreateSwapchainKHR` puts sinfo.oldSwapchain into a retired
+     // state whether the call succeeds or not, so we always need to garbage
+     // collect it afterwards - asynchronously as it may still be in use
+-    sinfo.oldSwapchain = p->swapchain;
+    /* sinfo.oldSwapchain = p->swapchain; */
+     p->swapchain = VK_NULL_HANDLE;
+     VkResult res = vk->CreateSwapchainKHR(vk->dev, &sinfo, PL_VK_ALLOC, &p->swapchain);
+-    vk_dev_callback(vk, VK_CB_FUNC(destroy_swapchain), vk, vk_wrap_handle(sinfo.oldSwapchain));
+    /* vk_dev_callback(vk, VK_CB_FUNC(destroy_swapchain), vk, vk_wrap_handle(sinfo.oldSwapchain)); */
+     PL_VK_ASSERT(res, "vk->CreateSwapchainKHR(...)");
+ 
+     // Get the new swapchain images
+-- 
+2.43.0
+
@@ -4,18 +4,19 @@
 	<metadata_license>CC0-1.0</metadata_license>
 	<project_license>GPL-3.0+</project_license>
 	<name>Moonlight</name>
-	<summary>Play games remotely from your NVIDIA GameStream-enabled PC</summary>
+	<summary>Stream games and other applications from another PC running Sunshine or GeForce Experience</summary>

 	<description>
-		<p>Moonlight can stream games and other applications from a PC with an NVIDIA GeForce GTX 600-series or higher GPU and GeForce Experience installed.</p>
+		<p>Moonlight can stream games and other applications from another PC with Sunshine or GeForce Experience software installed.</p>
 		<p>Features include:</p>
 		<ul>
-			<li>Streaming at up to 4K resolution</li>
-			<li>Support for up to 120 FPS streaming (high refresh rate monitor recommended)</li>
 			<li>Hardware accelerated video decoding with VAAPI, VDPAU, and NVDEC support</li>
-			<li>5.1 surround sound audio support</li>
-			<li>HEVC support for better video compression efficiency</li>
-			<li>Gamepad support with force feedback for up to 4 players</li>
+			<li>H.264, HEVC, and AV1 codec support</li>
+			<li>7.1 surround sound audio support</li>
+			<li>10-point multitouch support</li>
+			<li>Gamepad support with force feedback for up to 16 players</li>
+			<li>Support for both pointer capture (for games) and direct mouse control (for remote desktop)</li>
+			<li>Support for passing system-wide keyboard shortcuts like Alt+Tab to the host</li>
 		</ul>
 	</description>

@@ -33,6 +34,418 @@
 	</screenshots>

 	<releases>
+		<release version="6.0.0" date="2024-06-06">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>HDR is now supported on Steam Deck and other HDR-capable Linux systems using a new Vulkan-based renderer</li>
+					<li>Vulkan Video decoding of H.264, HEVC, and AV1 is now supported using the new Vulkan renderer</li>
+					<li>Full E2E stream encryption is now supported when streaming from Sunshine v0.22 or later</li>
+					<li>Initiating a stream via the command-line will now automatically wake the target machine if it is sleeping</li>
+					<li>Error codes are now displayed in the connection termination dialog</li>
+					<li>Detailed PC state information is now available via the new "View Details" context menu option (similar to the Android client)</li>
+					<li>The performance overlay can now be configured to be shown by default when starting a stream</li>
+				</ul>
+				<p>Behavior Changes:</p>
+				<ul>
+					<li>The selected bitrate is no longer silently adjusted by Moonlight based upon the video codec or HDR mode</li>
+					<li>The selected mouse mode when starting a stream no longer influences the acceleration curve when the mouse mode is toggled using the Ctrl+Alt+Shift+M key combo while streaming</li>
+					<li>Hardcoded fallback paths for VAAPI and VDPAU drivers are no longer used</li>
+					<li>Per-session keys (rikey and rikeyid values) are now automatically stripped from logs</li>
+					<li>Log messages will now be logged to stderr rather than stdout</li>
+					<li>EGL is now always used instead of GLX for loading OpenGL in X11 environments on non-x86 platforms</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Improved reliability of streaming during momentary drops of WiFi connections</li>
+					<li>Improved performance with high polling rate mice</li>
+					<li>Improved input latency when a gamepad is connected</li>
+					<li>Added missing command-line options to control HDR and AV1 codec usage</li>
+					<li>Fixed instant connection termination error when streaming over the Internet behind certain Carrier-Grade NAT devices</li>
+					<li>Fixed incorrect MTU detection when streaming over the Internet without a VPN</li>
+					<li>Fixed recovery of audio when no audio output device is present when the stream starts</li>
+					<li>Fixed merging of gamepad state when multi-controller mode is disabled</li>
+					<li>Fixed indefinitely resending mDNS queries when a host could not be resolved</li>
+					<li>Fixed inability to pair when the host is not using a RSA-2048 key</li>
+					<li>Updated included gamepad mappings</li>
+					<li>Updated community-contributed translations from Weblate</li>
+				</ul>
+			</description>
+		</release>
+		<release version="5.0.1" date="2023-11-02">
+			<description>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Fixed connection issue streaming from some hosts running GeForce Experience or Sunshine v0.20 and earlier</li>
+					<li>Updated community-contributed translations from Weblate</li>
+				</ul>
+			</description>
+		</release>
+		<release version="5.0.0" date="2023-10-18">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Custom FPS values</li>
+					<li>Streaming using the AV1 codec from Sunshine hosts</li>
+					<li>Horizontal scrolling with Sunshine hosts</li>
+					<li>Native multi-touch input with Sunshine hosts</li>
+					<li>Controller type information is passed to Sunshine for controller type autoselection</li>
+					<li>Extended features of PS4/PS5 controllers (touchpad, battery state, gyro/accelerometer motion, and RGB LED) are natively passed to Sunshine hosts</li>
+					<li>Support for up to 16 gamepads with Sunshine hosts</li>
+					<li>Frame pacing support on Wayland</li>
+					<li>Host-side processing latency is now displayed in the performance overlay with Sunshine hosts</li>
+					<li>Window title now includes the PC name when streaming</li>
+					<li>Alphabetical sorting of the PC list</li>
+					<li>Updated Play and Stop button design to improve contrast with app box art</li>
+					<li>The settings page automatically scrolls to the selected element when using keyboard or gamepad navigation</li>
+					<li>Pressing Share+PS buttons on PS4/PS5 controllers can be used to emulate a clickpad press</li>
+					<li>Improved audio quality when streaming with a high bitrate from remote hosts</li>
+					<li>Increased mouse polling rate</li>
+				</ul>
+				<p>Behavior Changes:</p>
+				<ul>
+					<li>IPv6 addresses must be provided in URL-escaped form. Example: [2001:db8::1234:5678] or [2001:db8::1234:5678]:47989</li>
+					<li>Default bitrate logic has been adjusted to behave better with custom resolutions and frame rates</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Reduced the frequency of audio underruns (clicks and pops) by increasing audio buffer size</li>
+					<li>Fixed "Quitting App" message never dismissing in some cases</li>
+					<li>Fixed parsing IPv6 literals with port numbers</li>
+					<li>Fixed unnecessary WiFi activity causing stream disruptions</li>
+					<li>Fixed paired hosts being forgotten if Moonlight terminates while writing hosts to disk</li>
+					<li>Fixed freeze when closing the stream on Windows with some software that uses DX11 hooks</li>
+					<li>Fixed delayed PC wake when activating Wake-On-LAN feature</li>
+					<li>Fixed Wake-on-LAN when Sunshine is running on alternate ports</li>
+					<li>Fixed leak of /dev/dri fds when trying to initialize VAAPI decoder</li>
+					<li>Fixed support for the Applications/Menu key</li>
+					<li>Fixed automatic language detection for Simplified Chinese and Traditional Chinese</li>
+					<li>Fixed streaming from Sunshine when the client PC has multiple network interfaces or IPv6 privacy extensions enabled</li>
+					<li>Fixed small receive buffer causing video packet loss on some systems</li>
+					<li>Fixed theme overrides causing the UI to be unusable on some systems</li>
+					<li>Fixed tearing with V-Sync enabled on macOS and Linux when using the SDL renderer (software decoding and some hardware decoders)</li>
+					<li>Fixed stateful V4L2 hardware decoding using h264_v4l2m2m and hevc_v4l2m2m decoders</li>
+					<li>Fixed CVE-2023-42801</li>
+					<li>Updated included gamepad mappings</li>
+					<li>Updated community-contributed translations from Weblate</li>
+				</ul>
+			</description>
+		</release>
+		<release version="4.3.1" date="2022-11-03">
+			<description>
+				<p>Changes:</p>
+				<ul>
+					<li>Fixed crash during specific patterns of audio packet loss</li>
+					<li>Fixed detection of local streaming when using IPv6 addresses</li>
+					<li>Windowed mode streaming now starts maximized if the GUI window was maximized</li>
+					<li>Updated community-contributed translations from Weblate</li>
+				</ul>
+			</description>
+		</release>
+		<release version="4.3.0" date="2022-10-28">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Improved support for GeForce Experience 3.26</li>
+					<li>Improved image quality and performance when recovering from video packet loss using HEVC</li>
+					<li>Improved error concealment after audio packet loss</li>
+					<li>Improved UI performance when paired with many hosts or hosts with large numbers of apps</li>
+					<li>Pairing with Sunshine hosts is now supported even if the host is in a streaming session</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Fixed streaming at resolutions below 720x480 with GeForce Experience 3.26</li>
+					<li>Fixed window position and size being lost when toggling between full-screen and windowed mode</li>
+					<li>Fixed initial window size not always respecting the stream aspect ratio</li>
+					<li>Fixed unexpected error when streaming at resolutions above 4096x4096 using Sunshine</li>
+					<li>Updated included gamepad mappings</li>
+					<li>Updated community-contributed translations from Weblate</li>
+				</ul>
+			</description>
+		</release>
+		<release version="4.2.1" date="2022-09-12">
+			<description>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Fixed streaming from hosts running Sunshine</li>
+					<li>Updated community-contributed translations from Weblate</li>
+				</ul>
+			</description>
+		</release>
+		<release version="4.2.0" date="2022-09-10">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Added support for pairing via the terminal</li>
+					<li>Added support for listing installed apps on a host via the terminal</li>
+					<li>Improved handling of V-Sync on Wayland systems to reduce latency</li>
+					<li>Improved performance using the legacy non-EGL VAAPI rendering code</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Fixed native resolution detection on high DPI Wayland systems</li>
+					<li>Fixed audio crackling with SDL 2.24.0 on systems using PulseAudio</li>
+					<li>Updated included gamepad mappings</li>
+					<li>Updated community-contributed translations from Weblate</li>
+				</ul>
+			</description>
+		</release>
+		<release version="4.1.0" date="2022-05-23">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Overlays are now supported on the non-EGL X11 VAAPI renderer (requires RGBA subpicture support in the VAAPI driver)</li>
+					<li>Cursor lock can now be disabled when in full-screen mode</li>
+				</ul>
+				<p>Behavior Changes:</p>
+				<ul>
+					<li>Moonlight can now reduce the client display resolution in full-screen mode if the current display mode doesn't have a high enough refresh rate for the selected stream frame rate</li>
+					<li>When choosing a new client display resolution in full-screen mode, Moonlight will pick a display mode with the closest aspect ratio to the selected stream resolution</li>
+					<li>Moonlight now defaults to borderless windowed mode on Wayland systems</li>
+
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Fixed missing toolbar buttons in certain languages</li>
+					<li>Fixed some text on the settings page not updating when the language is changed</li>
+					<li>Fixed a frame pacing bug that could cause excessive frame drops</li>
+					<li>Fixed the "keep display awake" setting not being saved when Moonlight restarts</li>
+					<li>Fixed black screen after unmaximizing the Moonlight window on some Linux systems</li>
+					<li>Updated included gamepad mappings</li>
+					<li>Updated community-contributed translations from Weblate</li>
+				</ul>
+			</description>
+		</release>
+		<release version="4.0.0" date="2022-04-02">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Added a new key combo for locking the mouse cursor to the window (Ctrl+Alt+Shift+L)</li>
+					<li>Added an option to avoid keeping the client display awake while streaming</li>
+				</ul>
+				<p>Behavior Changes:</p>
+				<ul>
+					<li>HDR streaming is now a separate option rather than being part of the Video Codec override dropdown</li>
+					<li>HDR streaming is no longer restricted to apps that are certified by NVIDIA as compatible with GameStream HDR. Some newer games may require an HDR display or EDID emulator dongle connected to your host PC for HDR options to be available.</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Fixed loss of all audio if the active audio device is unplugged while streaming</li>
+					<li>Fixed the GUI being unresponsive after manually quitting when connection to the host is lost</li>
+					<li>Fixed a rare crash if a controller disconnects right as rumble is starting</li>
+					<li>Fixed text rendering on the overlay UI when using SDL_ttf 2.0.18 on Linux</li>
+					<li>Updated included gamepad mappings</li>
+					<li>Updated community-contributed translations from Weblate</li>
+				</ul>
+			</description>
+		</release>
+		<release version="3.2.0" date="2022-01-18">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Reduced CPU usage while streaming</li>
+					<li>Non-ASCII characters are now supported when pasting clipboard data to the host</li>
+					<li>Added support for zero-copy NVDEC rendering for Nvidia Wayland systems</li>
+					<li>Significantly improved performance with asynchronous decoders like V4L2M2M on Linux</li>
+					<li>Added support for color compression planes on newer Intel systems when using VAAPI decoding</li>
+					<li>Added support for copy-back rendering in non-default pixel formats (like the Raspberry Pi SAND format)</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Fixed unexpected GUI input after using the gamepad quit combo</li>
+					<li>Updated included gamepad mappings</li>
+					<li>Updated community-contributed translations from Weblate</li>
+				</ul>
+			</description>
+		</release>
+		<release version="3.1.4" date="2021-06-25">
+			<description>
+				<p>Changes:</p>
+				<ul>
+					<li>Added network latency statistics to the performance overlay</li>
+					<li>Improved audio quality on unreliable connections (requires GeForce Experience 3.19 or later)</li>
+					<li>Reduced video frame drops on unreliable connections (requires GeForce Experience 3.22 or later)</li>
+					<li>Updated community-contributed translations from Weblate</li>
+				</ul>
+			</description>
+		</release>
+		<release version="3.1.3" date="2021-05-07">
+			<description>
+				<p>Changes:</p>
+				<ul>
+					<li>Fixed an issue that could cause excessive audio latency on some connections</li>
+					<li>Updated community-contributed translations from Weblate</li>
+				</ul>
+			</description>
+		</release>
+		<release version="3.1.2" date="2021-05-03">
+			<description>
+				<p>Changes:</p>
+				<ul>
+					<li>Improved connection reliability and performance with GeForce Experience 3.22</li>
+					<li>Added support for audio encryption with GeForce Experience 3.22</li>
+					<li>Added compatibility update checks for future versions of GeForce Experience</li>
+					<li>Fixed keyboard capture on X11</li>
+					<li>Updated community-contributed translations from Weblate</li>
+				</ul>
+			</description>
+		</release>
+		<release version="3.1.1" date="2021-04-09">
+			<description>
+				<p>Changes:</p>
+				<ul>
+					<li>Added support for streaming from GeForce Experience 3.22</li>
+					<li>Added support for AMF-encoded HEVC streams from servers like Sunshine and OpenStream</li>
+					<li>Added new community-contributed translations from Weblate</li>
+					<li>Fixed KMSDRM rendering with buffer modifiers on embedded devices</li>
+				</ul>
+			</description>
+		</release>
+		<release version="3.1.0" date="2021-03-14">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>System keyboard shortcuts (Alt+Tab, Super key, Ctrl+Shift+Esc, etc.) can now be (optionally) captured in windowed mode</li>
+					<li>System keyboard shortcuts can now be captured under Wayland</li>
+					<li>Added support for typing the client's clipboard text on the host by pressing Ctrl+Alt+Shift+V</li>
+					<li>Added Ctrl+Alt+Shift+D key combo to minimize the streaming window</li>
+					<li>Added Ctrl+Alt+Shift+C key combo to show the local cursor while streaming in remote desktop mouse mode</li>
+					<li>Added Select+L1+R1+X gamepad button combo to toggle performance overlay</li>
+					<li>Added translations for Simplified Chinese and German</li>
+					<li>Added a language selector on the settings page</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Improved performance of loading the app grid</li>
+					<li>Fixed video scaling in High DPI mode on Wayland</li>
+					<li>Fixed window icons on Wayland</li>
+					<li>Fixed number pad enter key functionality in the UI</li>
+				</ul>
+			</description>
+		</release>
+		<release version="3.0.0" date="2021-01-17">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Added the ability to define a custom streaming resolution using the UI</li>
+					<li>Added the option to capture system key combinations (Alt+Tab, Ctrl+Shift+Esc, Win+Tab, etc) in fullscreen mode</li>
+					<li>Updated gamepad mappings are automatically downloaded each time Moonlight launches</li>
+					<li>The performance overlay is now supported for Linux clients using VAAPI and VDPAU hardware acceleration</li>
+					<li>Added the option to enable "Direct Launch" which immediately launches the specified game when clicking on a PC</li>
+					<li>Added the option to mute audio when the Moonlight window loses input focus</li>
+					<li>Added the option to toggle background gamepad input</li>
+					<li>Added the option to invert scroll direction</li>
+					<li>Added the option to swap gamepad button layout to Nintendo-style</li>
+					<li>Added the option to start the Moonlight UI in fullscreen mode</li>
+					<li>The failing TCP or UDP ports are now displayed when the connection fails</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Fixed PS4 controllers not reading inputs during haptics in some games</li>
+					<li>Fixed some slow decoders causing the receive time value to increase rather than the decode time</li>
+					<li>Native resolution options now refresh each time the settings page is opened, rather than once per launch of Moonlight</li>
+					<li>Fixed no video or audio while streaming over Internet connections that drop packets with QoS tagging enabled</li>
+					<li>Improved connection testing accuracy for connections with low MTUs</li>
+					<li>Fixed inability to open an app's context menu with a gamepad</li>
+				</ul>
+			</description>
+		</release>
+		<release version="2.2.0" date="2020-09-10">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Added the ability to hide unwanted apps and games</li>
+					<li>Added a network test to determine if your Internet connection is blocking Moonlight</li>
+					<li>Added the option to swap mouse buttons</li>
+					<li>Added codec and resolution to the on-screen performance stats</li>
+					<li>Added a warning if the connection is too unstable to receive any complete video frames</li>
+					<li>Added a Discord link to the toolbar in settings</li>
+					<li>Enabled the new EGL renderer by default on Linux</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Fixed streaming over networks that block QoS-tagged packets</li>
+					<li>Selecting a frame rate higher than 60 FPS no longer sets the host desktop to 720p</li>
+					<li>Right-side modifier keys no longer press the corresponding left-side keys too</li>
+					<li>Fixed mouse position never reaching the edge of the screen with certain desktop resolutions</li>
+					<li>Improved synchronization between host and client mouse cursor in remote desktop mouse mode</li>
+					<li>Cached box art is now deleted when the PC is removed from Moonlight</li>
+					<li>Fixed several CLI options not properly overriding GUI options</li>
+					<li>Updated included gamepad mappings</li>
+					<li>Updated to Qt 5.15.1</li>
+				</ul>
+			</description>
+		</release>
+		<release version="2.1.0" date="2020-05-17">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Remote desktop mode now allows interaction with the host without having to click to focus the Moonlight window first</li>
+					<li>Added a new EGL renderer for improved performance on Wayland and XWayland</li>
+					<li>Added the option to toggle between direct touchscreen mode and the old trackpad mode</li>
+					<li>Added the option to rename host PCs</li>
+					<li>Added the ability to scroll the settings page with the right analog stick</li>
+					<li>Various UI improvements</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Fixed unreliable mouse capture when the stream begins</li>
+					<li>Fixed cursor being trapped in full-screen mode even when the mouse wasn't captured</li>
+					<li>Fixed key presses not being sent to the host if the Super/Meta/Windows key is pressed</li>
+					<li>Updated included gamepad mappings</li>
+				</ul>
+			</description>
+		</release>
+		<release version="2.0.0" date="2020-04-28">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Remote desktop-optimized mouse mode which doesn't require capturing the mouse cursor</li>
+					<li>Touchscreen input now directly controls the mouse cursor</li>
+					<li>7.1 surround sound support</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Improved performance on some lossy networks</li>
+					<li>Fixed disconnect delay when streaming from GeForce Experience 3.20.3.63</li>
+					<li>Fixed frame rate not exceeding 60 when streaming from GeForce Experience 3.20.3.63</li>
+					<li>Fixed parsing of command-line options when passing flags prior to the action</li>
+					<li>Fixed an issue that may cause excessive mDNS network traffic while Moonlight is running</li>
+					<li>Fixed hardware decoding on Intel GPUs running Mesa 20.0 and/or the Iris driver</li>
+					<li>Fixed hardware decoding on Comet Lake and later Intel GPUs using the iHD VA-API driver</li>
+					<li>Fixed hardware decoding on AMD Radeon GPUs with XWayland</li>
+					<li>Fixed a crash when using the iHD VA-API driver on Wayland</li>
+					<li>Fixed delay after exiting the stream on Wayland</li>
+					<li>Updated included gamepad mappings</li>
+				</ul>
+			</description>
+		</release>
+		<release version="1.2.0" date="2019-12-17">
+			<description>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Improved video encoding efficiency</li>
+					<li>Improved performance when streaming over a VPN</li>
+					<li>Fixed RTSP handshake error on certain networks</li>
+					<li>Fixed rumble not working on certain gamepads</li>
+					<li>Fixed pairing error when double-clicking on an unpaired PC</li>
+					<li>Updated included SDL gamepad mappings</li>
+				</ul>
+			</description>
+		</release>
+		<release version="1.1.1" date="2019-09-29">
+			<description>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Improved reliability of public IP address detection</li>
+					<li>Fixed connecting to a host PC with multiple network connections</li>
+					<li>Fixed a hang after exiting a full-screen stream with GNOME on Wayland</li>
+					<li>Fixed gamepad hotplugging</li>
+					<li>Updated to SDL 2.0.10</li>
+					<li>Updated to Qt 5.13.1</li>
+				</ul>
+			</description>
+		</release>
 		<release version="1.1.0" date="2019-08-05">
 			<description>
 				<p>New features:</p>
@@ -1,9 +1,9 @@
 [Desktop Entry]
 Name=Moonlight
-Comment=Stream games from your NVIDIA GameStream-enabled PC
+Comment=Stream games and other applications from another PC running Sunshine or GeForce Experience
 Exec=moonlight
 Icon=moonlight
 Terminal=false
 Type=Application
 Categories=Qt;Game;
-Keywords=nvidia;gamestream;stream;
+Keywords=nvidia;gamestream;stream;sunshine;remote play;
@@ -5,6 +5,10 @@
 # pairing data will be lost each reboot.
 HOME=/usr/local/moonlight

+# Enable Steam Controller detection in SDL
+# https://github.com/moonlight-stream/moonlight-qt/issues/697
+export SDL_ENABLE_STEAM_CONTROLLERS=1
+
 # Renice PE_Single_CPU which seems to host A/V stuff
 renice -10 -p $(pidof PE_Single_CPU)

@@ -1,5 +1,6 @@
 import QtQuick 2.9
 import QtQuick.Controls 2.2
+import QtQuick.Controls.Material 2.2

 import AppModel 1.0
 import ComputerManager 1.0
@@ -9,6 +10,8 @@ CenteredGridView {
    property int computerIndex
    property AppModel appModel : createModel()
    property bool activated
+    property bool showHiddenGames
+    property bool showGames

    id: appGrid
    focus: true
@@ -38,6 +41,19 @@ CenteredGridView {
        if (currentIndex == -1 && SdlGamepadKeyNavigation.getConnectedGamepads() > 0) {
            currentIndex = 0
        }
+
+        if (!showGames && !showHiddenGames) {
+            // Check if there's a direct launch app
+            var directLaunchAppIndex = model.getDirectLaunchAppIndex();
+            if (directLaunchAppIndex >= 0) {
+                // Start the direct launch app if nothing else is running
+                currentIndex = directLaunchAppIndex
+                currentItem.launchOrResumeSelectedApp(false)
+
+                // Set showGames so we will not loop when the stream ends
+                showGames = true
+            }
+        }
    }

    StackView.onDeactivating: {
@@ -48,7 +64,7 @@ CenteredGridView {
    function createModel()
    {
        var model = Qt.createQmlObject('import AppModel 1.0; AppModel {}', parent, '')
-        model.initialize(ComputerManager, computerIndex)
+        model.initialize(ComputerManager, computerIndex, showHiddenGames)
        return model
    }

@@ -58,6 +74,12 @@ CenteredGridView {
        width: 220; height: 287;
        grid: appGrid

+        property alias appContextMenu: appContextMenuLoader.item
+        property alias appNameText: appNameTextLoader.item
+
+        // Dim the app if it's hidden
+        opacity: model.hidden ? 0.4 : 1.0
+
        Image {
            property bool isPlaceholder: false

@@ -67,9 +89,14 @@ CenteredGridView {
            source: model.boxart

            onSourceSizeChanged: {
-                if ((sourceSize.width == 130 && sourceSize.height == 180) || // GFE 2.0 placeholder image
-                    (sourceSize.width == 628 && sourceSize.height == 888) || // GFE 3.0 placeholder image
-                    (sourceSize.width == 200 && sourceSize.height == 266))   // Our no_app_image.png
+                // Nearly all of Nvidia's official box art does not match the dimensions of placeholder
+                // images, however the one known exception is Overcooked. Therefore, we only execute
+                // the image size checks if this is not an app collector game. We know the officially
+                // supported games all have box art, so this check is not required.
+                if (!model.isAppCollectorGame &&
+                    ((sourceSize.width == 130 && sourceSize.height == 180) || // GFE 2.0 placeholder image
+                     (sourceSize.width == 628 && sourceSize.height == 888) || // GFE 3.0 placeholder image
+                     (sourceSize.width == 200 && sourceSize.height == 266)))  // Our no_app_image.png
                {
                    isPlaceholder = true
                }
@@ -86,95 +113,121 @@ CenteredGridView {
            ToolTip.text: model.name
            ToolTip.delay: 1000
            ToolTip.timeout: 5000
-            ToolTip.visible: (parent.hovered || parent.highlighted) && (!appNameText.visible || appNameText.truncated)
+            ToolTip.visible: (parent.hovered || parent.highlighted) && (!appNameText || appNameText.truncated)
        }

-        ToolButton {
-            id: resumeButton
-            anchors.horizontalCenterOffset: appIcon.isPlaceholder ? -47 : 0
-            anchors.verticalCenterOffset: appIcon.isPlaceholder ? -75 : -60
-            anchors.centerIn: appIcon
-            visible: model.running
-            implicitWidth: 125
-            implicitHeight: 125
+        Loader {
+            active: model.running
+            asynchronous: true
+            anchors.fill: appIcon

-            Image {
-                source: "qrc:/res/baseline-play_circle_filled_white-48px.svg"
-                anchors.centerIn: parent
-                sourceSize {
-                    width: 75
-                    height: 75
+            sourceComponent: Item {
+                RoundButton {
+                    anchors.horizontalCenterOffset: appIcon.isPlaceholder ? -47 : 0
+                    anchors.verticalCenterOffset: appIcon.isPlaceholder ? -75 : -60
+                    anchors.centerIn: parent
+                    implicitWidth: 85
+                    implicitHeight: 85
+
+                    Image {
+                        source: "qrc:/res/play_arrow_FILL1_wght700_GRAD200_opsz48.svg"
+                        anchors.centerIn: parent
+                        sourceSize {
+                            width: 75
+                            height: 75
+                        }
+                    }
+
+                    onClicked: {
+                        launchOrResumeSelectedApp(true)
+                    }
+
+                    ToolTip.text: qsTr("Resume Game")
+                    ToolTip.delay: 1000
+                    ToolTip.timeout: 3000
+                    ToolTip.visible: hovered
+
+                    Material.background: "#D0808080"
+                }
+
+                RoundButton {
+                    anchors.horizontalCenterOffset: appIcon.isPlaceholder ? 47 : 0
+                    anchors.verticalCenterOffset: appIcon.isPlaceholder ? -75 : 60
+                    anchors.centerIn: parent
+                    implicitWidth: 85
+                    implicitHeight: 85
+
+                    Image {
+                        source: "qrc:/res/stop_FILL1_wght700_GRAD200_opsz48.svg"
+                        anchors.centerIn: parent
+                        sourceSize {
+                            width: 75
+                            height: 75
+                        }
+                    }
+
+                    onClicked: {
+                        doQuitGame()
+                    }
+
+                    ToolTip.text: qsTr("Quit Game")
+                    ToolTip.delay: 1000
+                    ToolTip.timeout: 3000
+                    ToolTip.visible: hovered
+
+                    Material.background: "#D0808080"
                }
            }
-
-            onClicked: {
-                launchOrResumeSelectedApp()
-            }
-
-            ToolTip.text: "Resume Game"
-            ToolTip.delay: 1000
-            ToolTip.timeout: 3000
-            ToolTip.visible: hovered
        }

-        ToolButton {
-            id: quitButton
-            anchors.horizontalCenterOffset: appIcon.isPlaceholder ? 47 : 0
-            anchors.verticalCenterOffset: appIcon.isPlaceholder ? -75 : 60
-            anchors.centerIn: appIcon
-            visible: model.running
-            implicitWidth: 125
-            implicitHeight: 125
+        Loader {
+            id: appNameTextLoader
+            active: appIcon.isPlaceholder

-            Image {
-                source: "qrc:/res/baseline-cancel-24px.svg"
-                anchors.centerIn: parent
-                sourceSize {
-                    width: 75
-                    height: 75
-                }
-            }
+            // This loader is not asynchronous to avoid noticeable differences
+            // in the time in which the text loads for each game.

-            onClicked: {
-                doQuitGame()
-            }
-
-            ToolTip.text: "Quit Game"
-            ToolTip.delay: 1000
-            ToolTip.timeout: 3000
-            ToolTip.visible: hovered
-        }
-
-        Label {
-            id: appNameText
-            visible: appIcon.isPlaceholder
-            text: model.name
            width: appIcon.width
            height: model.running ? 175 : appIcon.height
+
            anchors.left: appIcon.left
            anchors.right: appIcon.right
            anchors.bottom: appIcon.bottom
-            font.pointSize: 22
-            verticalAlignment: Text.AlignVCenter
-            horizontalAlignment: Text.AlignHCenter
-            wrapMode: Text.Wrap
-            elide: Text.ElideRight
+
+            sourceComponent: Label {
+                id: appNameText
+                text: model.name
+                font.pointSize: 22
+                leftPadding: 20
+                rightPadding: 20
+                verticalAlignment: Text.AlignVCenter
+                horizontalAlignment: Text.AlignHCenter
+                wrapMode: Text.Wrap
+                elide: Text.ElideRight
+            }
        }

-        function launchOrResumeSelectedApp()
+        function launchOrResumeSelectedApp(quitExistingApp)
        {
-            var runningIndex = appModel.getRunningAppIndex()
-            if (runningIndex >= 0 && runningIndex !== index) {
-                quitAppDialog.appName = appModel.getRunningAppName()
-                quitAppDialog.segueToStream = true
-                quitAppDialog.nextAppName = model.name
-                quitAppDialog.nextAppIndex = index
-                quitAppDialog.open()
+            var runningId = appModel.getRunningAppId()
+            if (runningId !== 0 && runningId !== model.appid) {
+                if (quitExistingApp) {
+                    quitAppDialog.appName = appModel.getRunningAppName()
+                    quitAppDialog.segueToStream = true
+                    quitAppDialog.nextAppName = model.name
+                    quitAppDialog.nextAppIndex = index
+                    quitAppDialog.open()
+                }
+
                return
            }

            var component = Qt.createComponent("StreamSegue.qml")
-            var segue = component.createObject(stackView, {"appName": model.name, "session": appModel.createSessionForApp(index)})
+            var segue = component.createObject(stackView, {
+                                                   "appName": model.name,
+                                                   "session": appModel.createSessionForApp(index),
+                                                   "isResume": runningId === model.appid
+                                               })
            stackView.push(segue)
        }

@@ -184,7 +237,26 @@ CenteredGridView {
            // will handle starting the game and clicks on the box art will
            // be ignored.
            if (!model.running) {
-                launchOrResumeSelectedApp()
+                launchOrResumeSelectedApp(true)
+            }
+        }
+
+        onPressAndHold: {
+            // popup() ensures the menu appears under the mouse cursor
+            if (appContextMenu.popup) {
+                appContextMenu.popup()
+            }
+            else {
+                // Qt 5.9 doesn't have popup()
+                appContextMenu.open()
+            }
+        }
+
+        MouseArea {
+            anchors.fill: parent
+            acceptedButtons: Qt.RightButton;
+            onClicked: {
+                parent.pressAndHold()
            }
        }

@@ -199,7 +271,10 @@ CenteredGridView {
            }
        }

-        Keys.onMenuPressed: {
+        Keys.onEnterPressed: {
+            // Open the app context menu if activated via the gamepad or keyboard
+            // for running games. If the game isn't running, the above onClicked
+            // method will handle the launch.
            if (model.running) {
                // This will be keyboard/gamepad driven so use
                // open() instead of popup()
@@ -207,24 +282,59 @@ CenteredGridView {
            }
        }

+        Keys.onMenuPressed: {
+            // This will be keyboard/gamepad driven so use open() instead of popup()
+            appContextMenu.open()
+        }
+
        function doQuitGame() {
            quitAppDialog.appName = appModel.getRunningAppName()
            quitAppDialog.segueToStream = false
            quitAppDialog.open()
        }

-        NavigableMenu {
-            id: appContextMenu
-            NavigableMenuItem {
-                parentMenu: appContextMenu
-                text: model.running ? "Resume Game" : "Launch Game"
-                onTriggered: launchOrResumeSelectedApp()
-            }
-            NavigableMenuItem {
-                parentMenu: appContextMenu
-                text: "Quit Game"
-                onTriggered: doQuitGame()
-                visible: model.running
+        Loader {
+            id: appContextMenuLoader
+            asynchronous: true
+            sourceComponent: NavigableMenu {
+                id: appContextMenu
+                NavigableMenuItem {
+                    parentMenu: appContextMenu
+                    text: model.running ? qsTr("Resume Game") : qsTr("Launch Game")
+                    onTriggered: launchOrResumeSelectedApp(true)
+                }
+                NavigableMenuItem {
+                    parentMenu: appContextMenu
+                    text: qsTr("Quit Game")
+                    onTriggered: doQuitGame()
+                    visible: model.running
+                }
+                NavigableMenuItem {
+                    parentMenu: appContextMenu
+                    checkable: true
+                    checked: model.directLaunch
+                    text: qsTr("Direct Launch")
+                    onTriggered: appModel.setAppDirectLaunch(model.index, !model.directLaunch)
+                    enabled: !model.hidden
+
+                    ToolTip.text: qsTr("Launch this app immediately when the host is selected, bypassing the app selection grid.")
+                    ToolTip.delay: 1000
+                    ToolTip.timeout: 3000
+                    ToolTip.visible: hovered
+                }
+                NavigableMenuItem {
+                    parentMenu: appContextMenu
+                    checkable: true
+                    checked: model.hidden
+                    text: qsTr("Hide Game")
+                    onTriggered: appModel.setAppHidden(model.index, !model.hidden)
+                    enabled: model.hidden || (!model.running && !model.directLaunch)
+
+                    ToolTip.text: qsTr("Hide this game from the app grid. To access hidden games, right-click on the host and choose %1.").arg(qsTr("View All Apps"))
+                    ToolTip.delay: 1000
+                    ToolTip.timeout: 5000
+                    ToolTip.visible: hovered
+                }
            }
        }
    }
@@ -235,12 +345,12 @@ CenteredGridView {
        property bool segueToStream : false
        property string nextAppName: ""
        property int nextAppIndex: 0
-        text:"Are you sure you want to quit " + appName +"? Any unsaved progress will be lost."
+        text:qsTr("Are you sure you want to quit %1? Any unsaved progress will be lost.").arg(appName)
        standardButtons: Dialog.Yes | Dialog.No

        function quitApp() {
            var component = Qt.createComponent("QuitSegue.qml")
-            var params = {"appName": appName}
+            var params = {"appName": appName, "quitRunningAppFn": () => appModel.quitRunningApp()}
            if (segueToStream) {
                // Store the session and app name if we're going to stream after
                // successfully quitting the old app.
@@ -253,26 +363,10 @@ CenteredGridView {
            }

            stackView.push(component.createObject(stackView, params))
-
-            // Trigger the quit after pushing the quit segue on screen
-            appModel.quitRunningApp()
        }

        onAccepted: quitApp()
    }

-    ScrollBar.vertical: ScrollBar {
-        // Manually hide the scrollbar to prevent it from being drawn on top
-        // of the StreamSegue during the transition. It can sometimes get stuck
-        // there since we're not consistently pumping the event loop while
-        // starting the stream.
-        visible: activated
-
-        parent: appGrid.parent
-        anchors {
-            top: parent.top
-            right: parent.right
-            bottom: parent.bottom
-        }
-    }
+    ScrollBar.vertical: ScrollBar {}
 }
@@ -2,12 +2,15 @@ import QtQuick 2.9
 import QtQuick.Controls 2.2

 import SdlGamepadKeyNavigation 1.0
+import SystemProperties 1.0

 // https://stackoverflow.com/questions/45029968/how-do-i-set-the-combobox-width-to-fit-the-largest-item
 ComboBox {
    property int textWidth
+    property int desiredWidth : leftPadding + textWidth + indicator.width + rightPadding
+    property int maximumWidth : parent.width

-    implicitWidth: leftPadding + textWidth + indicator.width + rightPadding
+    implicitWidth: desiredWidth < maximumWidth ? desiredWidth : maximumWidth

    TextMetrics {
        id: popupMetrics
@@ -17,9 +20,7 @@ ComboBox {
        id: textMetrics
    }

-    // We call this every time the options change (and init)
-    // so we can adjust the combo box width here too
-    onActivated: {
+    function recalculateWidth() {
        textMetrics.font = font
        popupMetrics.font = popup.font
        textWidth = 0
@@ -31,9 +32,19 @@ ComboBox {
        }
    }

+    // We call this every time the options change (and init)
+    // so we can adjust the combo box width here too
+    onActivated: recalculateWidth()
+
    popup.onAboutToShow: {
        // Switch to normal navigation for combo boxes
        SdlGamepadKeyNavigation.setUiNavMode(false)
+
+        // Override the popup color to improve contrast with the overridden
+        // Material 2 background color set in main.qml.
+        if (SystemProperties.usesMaterial3Theme) {
+            popup.background.color = "#424242"
+        }
    }

    popup.onAboutToHide: {
@@ -38,4 +38,6 @@ GridView {

        updateMargins()
    }
+
+    boundsBehavior: Flickable.OvershootBounds
 }
@@ -0,0 +1,91 @@
+import QtQuick 2.0
+import QtQuick.Controls 2.2
+
+import ComputerManager 1.0
+import SdlGamepadKeyNavigation 1.0
+
+Item {
+    function onSearchingComputer() {
+        stageLabel.text = qsTr("Establishing connection to PC...")
+    }
+
+    function onPairing(pcName, pin) {
+        stageLabel.text = qsTr("Pairing... Please enter '%1' on %2.").arg(pin).arg(pcName)
+    }
+
+    function onFailed(message) {
+        stageIndicator.visible = false
+        errorDialog.text = message
+        errorDialog.open()
+    }
+
+    function onSuccess(appName) {
+        stageIndicator.visible = false
+        pairCompleteDialog.open()
+    }
+
+    // Allow user to back out of pairing
+    Keys.onEscapePressed: {
+        Qt.quit()
+    }
+    Keys.onBackPressed: {
+        Qt.quit()
+    }
+    Keys.onCancelPressed: {
+        Qt.quit()
+    }
+
+    StackView.onActivated: {
+        if (!launcher.isExecuted()) {
+            toolBar.visible = false
+
+            // Normally this is enabled by PcView, but we will won't
+            // load PcView when streaming from the command-line.
+            SdlGamepadKeyNavigation.enable()
+
+            launcher.searchingComputer.connect(onSearchingComputer)
+            launcher.pairing.connect(onPairing)
+            launcher.failed.connect(onFailed)
+            launcher.success.connect(onSuccess)
+            launcher.execute(ComputerManager)
+        }
+    }
+
+    Row {
+        anchors.centerIn: parent
+        spacing: 5
+        id: stageIndicator
+
+        BusyIndicator {
+            id: stageSpinner
+        }
+
+        Label {
+            id: stageLabel
+            height: stageSpinner.height
+            font.pointSize: 20
+            verticalAlignment: Text.AlignVCenter
+
+            wrapMode: Text.Wrap
+        }
+    }
+
+    ErrorMessageDialog {
+        id: errorDialog
+
+        onClosed: {
+            Qt.quit();
+        }
+    }
+
+    NavigableMessageDialog {
+        id: pairCompleteDialog
+        closePolicy: Popup.CloseOnEscape
+
+        text:qsTr("Pairing completed successfully")
+        standardButtons: Dialog.Ok
+        onClosed: {
+            Qt.quit()
+        }
+    }
+}
@@ -6,11 +6,11 @@ import Session 1.0

 Item {
    function onSearchingComputer() {
-        stageLabel.text = "Establishing connection to PC..."
+        stageLabel.text = qsTr("Establishing connection to PC...")
    }

    function onQuittingApp() {
-        stageLabel.text = "Quitting app..."
+        stageLabel.text = qsTr("Quitting app...")
    }

    function onFailure(message) {
@@ -2,14 +2,15 @@ import QtQuick 2.0
 import QtQuick.Controls 2.2

 import ComputerManager 1.0
+import SdlGamepadKeyNavigation 1.0

 Item {
    function onSearchingComputer() {
-        stageLabel.text = "Establishing connection to PC..."
+        stageLabel.text = qsTr("Establishing connection to PC...")
    }

    function onSearchingApp() {
-        stageLabel.text = "Loading app list..."
+        stageLabel.text = qsTr("Loading app list...")
    }

    function onSessionCreated(appName, session) {
@@ -25,6 +26,7 @@ Item {
    function onLaunchFailed(message) {
        errorDialog.text = message
        errorDialog.open()
+        console.error(message)
    }

    function onAppQuitRequired(appName) {
@@ -35,6 +37,11 @@ Item {
    StackView.onActivated: {
        if (!launcher.isExecuted()) {
            toolBar.visible = false
+
+            // Normally this is enabled by PcView, but we will won't
+            // load PcView when streaming from the command-line.
+            SdlGamepadKeyNavigation.enable()
+
            launcher.searchingComputer.connect(onSearchingComputer)
            launcher.searchingApp.connect(onSearchingApp)
            launcher.sessionCreated.connect(onSessionCreated)
@@ -72,16 +79,14 @@ Item {

    NavigableMessageDialog {
        id: quitAppDialog
-        text:"Are you sure you want to quit " + appName +"? Any unsaved progress will be lost."
+        text:qsTr("Are you sure you want to quit %1? Any unsaved progress will be lost.").arg(appName)
        standardButtons: Dialog.Yes | Dialog.No
        property string appName : ""

        function quitApp() {
            var component = Qt.createComponent("QuitSegue.qml")
-            var params = {"appName": appName}
+            var params = {"appName": appName, "quitRunningAppFn": () => launcher.quitRunningApp()}
            stackView.push(component.createObject(stackView, params))
-            // Trigger the quit after pushing the quit segue on screen
-            launcher.quitRunningApp()
        }

        onAccepted: quitApp()
@@ -1,5 +1,5 @@
 import QtQuick 2.0

 Item {
-    objectName: "Gamepad Mapping"
+    objectName: qsTr("Gamepad Mapping")
 }
@@ -2,7 +2,8 @@ import QtQuick 2.0
 import QtQuick.Controls 2.2

 Dialog {
-    parent: overlay
+    // We should use Overlay.overlay here but that's not available in Qt 5.9 :(
+    parent: ApplicationWindow.contentItem

    x: Math.round((parent.width - width) / 2)
    y: Math.round((parent.height - height) / 2)
@@ -21,4 +21,7 @@ ItemDelegate {
    Keys.onReturnPressed: {
        clicked()
    }
+    Keys.onEnterPressed: {
+        clicked()
+    }
 }
@@ -3,6 +3,13 @@ import QtQuick.Controls 2.2

 Menu {
    onOpened: {
-        itemAt(0).forceActiveFocus(Qt.TabFocusReason)
+        // Give focus to the first visible and enabled menu item
+        for (var i = 0; i < count; i++) {
+            var item = itemAt(i)
+            if (item.visible && item.enabled) {
+                item.forceActiveFocus(Qt.TabFocusReason)
+                break
+            }
+        }
    }
 }
@@ -22,6 +22,10 @@ MenuItem {
        triggered()
    }

+    Keys.onEnterPressed: {
+        triggered()
+    }
+
    Keys.onEscapePressed: {
        parentMenu.close()
    }
@@ -6,6 +6,8 @@ NavigableDialog {
    id: dialog

    property alias text: dialogLabel.dialogText
+    property alias showSpinner: dialogSpinner.visible
+    property alias imageSrc: dialogImage.source

    property string helpText
    property string helpUrl : "https://github.com/moonlight-stream/moonlight-docs/wiki/Troubleshooting"
@@ -19,7 +21,13 @@ NavigableDialog {
    RowLayout {
        spacing: 10

+        BusyIndicator {
+            id: dialogSpinner
+            visible: false
+        }
+
        Image {
+            id: dialogImage
            source: (standardButtons & Dialog.Yes) ?
                        "qrc:/res/baseline-help_outline-24px.svg" :
                        "qrc:/res/baseline-error_outline-24px.svg"
@@ -28,6 +36,7 @@ NavigableDialog {
                width: 50
                height: 50
            }
+            visible: !showSpinner
        }

        Label {
@@ -47,6 +56,10 @@ NavigableDialog {
                accept()
            }

+            Keys.onEnterPressed: {
+                accept()
+            }
+
            Keys.onEscapePressed: {
                reject()
            }
@@ -1,5 +1,6 @@
 import QtQuick 2.0
 import QtQuick.Controls 2.2
+import QtQuick.Layouts 1.3

 ToolButton {
    property string iconSource
@@ -20,13 +21,16 @@ ToolButton {

    // This determines the size of the Material highlight. We increase it
    // from the default because we use larger than normal icons for TV readability.
-    background.width: (parent.height - parent.anchors.bottomMargin - parent.anchors.topMargin) * 0.60
-    background.height: (parent.height - parent.anchors.bottomMargin - parent.anchors.topMargin) * 0.60
+    Layout.preferredHeight: parent.height

    Keys.onReturnPressed: {
        clicked()
    }

+    Keys.onEnterPressed: {
+        clicked()
+    }
+
    Keys.onRightPressed: {
        nextItemInFocusChain(true).forceActiveFocus(Qt.TabFocus)
    }
@@ -1,10 +1,12 @@
 import QtQuick 2.9
 import QtQuick.Controls 2.2
+import QtQuick.Layouts 1.3

 import ComputerModel 1.0

 import ComputerManager 1.0
 import StreamingPreferences 1.0
+import SystemProperties 1.0
 import SdlGamepadKeyNavigation 1.0

 CenteredGridView {
@@ -16,7 +18,7 @@ CenteredGridView {
    topMargin: 20
    bottomMargin: 5
    cellWidth: 310; cellHeight: 330;
-    objectName: "Computers"
+    objectName: qsTr("Computers")

    Component.onCompleted: {
        // Don't show any highlighted item until interacting with them.
@@ -25,6 +27,9 @@ CenteredGridView {
        currentIndex = -1
    }

+    // Note: Any initialization done here that is critical for streaming must
+    // also be done in CliStartStreamSegue.qml, since this code does not run
+    // for command-line initiated streams.
    StackView.onActivated: {
        // Setup signals on CM
        ComputerManager.computerAddCompleted.connect(addComplete)
@@ -57,11 +62,18 @@ CenteredGridView {
        }
    }

-    function addComplete(success)
+    function addComplete(success, detectedPortBlocking)
    {
        if (!success) {
-            errorDialog.text = "Unable to connect to the specified PC."
-            errorDialog.helpText = "Click the Help button for possible solutions."
+            errorDialog.text = qsTr("Unable to connect to the specified PC.")
+
+            if (detectedPortBlocking) {
+                errorDialog.text += "\n\n" + qsTr("This PC's Internet connection is blocking Moonlight. Streaming over the Internet may not work while connected to this network.")
+            }
+            else {
+                errorDialog.helpText = qsTr("Click the Help button for possible solutions.")
+            }
+
            errorDialog.open()
        }
    }
@@ -71,6 +83,7 @@ CenteredGridView {
        var model = Qt.createQmlObject('import ComputerModel 1.0; ComputerModel {}', parent, '')
        model.initialize(ComputerManager)
        model.pairingCompleted.connect(pairingComplete)
+        model.connectionTestCompleted.connect(testConnectionDialog.connectionTestComplete)
        return model
    }

@@ -87,8 +100,8 @@ CenteredGridView {
        Label {
            height: searchSpinner.height
            elide: Label.ElideRight
-            text: StreamingPreferences.enableMdns ? "Searching for PCs with NVIDIA GameStream enabled..."
-                                                  : "Automatic PC discovery is disabled. Add your PC manually."
+            text: StreamingPreferences.enableMdns ? qsTr("Searching for compatible hosts on your local network...")
+                                                  : qsTr("Automatic PC discovery is disabled. Add your PC manually.")
            font.pointSize: 20
            verticalAlignment: Text.AlignVCenter
            wrapMode: Text.Wrap
@@ -101,10 +114,12 @@ CenteredGridView {
        width: 300; height: 320;
        grid: pcGrid

+        property alias pcContextMenu : pcContextMenuLoader.item
+
        Image {
            id: pcIcon
            anchors.horizontalCenter: parent.horizontalCenter
-            source: "qrc:/res/ic_tv_white_48px.svg"
+            source: "qrc:/res/desktop_windows-48px.svg"
            sourceSize {
                width: 200
                height: 200
@@ -116,12 +131,12 @@ CenteredGridView {
            id: stateIcon
            anchors.horizontalCenter: pcIcon.horizontalCenter
            anchors.verticalCenter: pcIcon.verticalCenter
-            anchors.verticalCenterOffset: -10
+            anchors.verticalCenterOffset: !model.online ? -18 : -16
            visible: !model.statusUnknown && (!model.online || !model.paired)
-            source: !model.online ? "qrc:/res/baseline-warning-24px.svg" : "qrc:/res/baseline-lock-24px.svg"
+            source: !model.online ? "qrc:/res/warning_FILL1_wght300_GRAD200_opsz24.svg" : "qrc:/res/baseline-lock-24px.svg"
            sourceSize {
-                width: 75
-                height: 75
+                width: !model.online ? 75 : 70
+                height: !model.online ? 75 : 70
            }
        }

@@ -129,7 +144,7 @@ CenteredGridView {
            id: statusUnknownSpinner
            anchors.horizontalCenter: pcIcon.horizontalCenter
            anchors.verticalCenter: pcIcon.verticalCenter
-            anchors.verticalCenterOffset: -10
+            anchors.verticalCenterOffset: -15
            width: 75
            height: 75
            visible: model.statusUnknown
@@ -148,50 +163,92 @@ CenteredGridView {
            elide: Text.ElideRight
        }

-        NavigableMenu {
-            id: pcContextMenu
-            NavigableMenuItem {
-                parentMenu: pcContextMenu
-                text: "Delete PC"
-                onTriggered: {
-                    deletePcDialog.pcIndex = index
-                    // get confirmation first, actual closing is called from the dialog
-                    deletePcDialog.open()
+        Loader {
+            id: pcContextMenuLoader
+            asynchronous: true
+            sourceComponent: NavigableMenu {
+                id: pcContextMenu
+                MenuItem {
+                    text: qsTr("PC Status: %1").arg(model.online ? qsTr("Online") : qsTr("Offline"))
+                    font.bold: true
+                    enabled: false
+                }
+                NavigableMenuItem {
+                    parentMenu: pcContextMenu
+                    text: qsTr("View All Apps")
+                    onTriggered: {
+                        var component = Qt.createComponent("AppView.qml")
+                        var appView = component.createObject(stackView, {"computerIndex": index, "objectName": model.name, "showHiddenGames": true})
+                        stackView.push(appView)
+                    }
+                    visible: model.online && model.paired
+                }
+                NavigableMenuItem {
+                    parentMenu: pcContextMenu
+                    text: qsTr("Wake PC")
+                    onTriggered: computerModel.wakeComputer(index)
+                    visible: !model.online && model.wakeable
+                }
+                NavigableMenuItem {
+                    parentMenu: pcContextMenu
+                    text: qsTr("Test Network")
+                    onTriggered: {
+                        computerModel.testConnectionForComputer(index)
+                        testConnectionDialog.open()
+                    }
+                }
+
+                NavigableMenuItem {
+                    parentMenu: pcContextMenu
+                    text: qsTr("Rename PC")
+                    onTriggered: {
+                        renamePcDialog.pcIndex = index
+                        renamePcDialog.originalName = model.name
+                        renamePcDialog.open()
+                    }
+                }
+                NavigableMenuItem {
+                    parentMenu: pcContextMenu
+                    text: qsTr("Delete PC")
+                    onTriggered: {
+                        deletePcDialog.pcIndex = index
+                        deletePcDialog.pcName = model.name
+                        deletePcDialog.open()
+                    }
+                }
+                NavigableMenuItem {
+                    parentMenu: pcContextMenu
+                    text: qsTr("View Details")
+                    onTriggered: {
+                        showPcDetailsDialog.pcDetails = model.details
+                        showPcDetailsDialog.open()
+                    }
                }
-            }
-            NavigableMenuItem {
-                parentMenu: pcContextMenu
-                text: "Wake PC"
-                onTriggered: computerModel.wakeComputer(index)
-                visible: !model.online && model.wakeable
            }
        }

        onClicked: {
            if (model.online) {
-                if (model.paired) {
+                if (!model.serverSupported) {
+                    errorDialog.text = qsTr("The version of GeForce Experience on %1 is not supported by this build of Moonlight. You must update Moonlight to stream from %1.").arg(model.name)
+                    errorDialog.helpText = ""
+                    errorDialog.open()
+                }
+                else if (model.paired) {
                    // go to game view
                    var component = Qt.createComponent("AppView.qml")
                    var appView = component.createObject(stackView, {"computerIndex": index, "objectName": model.name})
                    stackView.push(appView)
                }
                else {
-                    if (!model.busy) {
-                        var pin = ("0000" + Math.floor(Math.random() * 10000)).slice(-4)
+                    var pin = computerModel.generatePinString()

-                        // Kick off pairing in the background
-                        computerModel.pairComputer(index, pin)
+                    // Kick off pairing in the background
+                    computerModel.pairComputer(index, pin)

-                        // Display the pairing dialog
-                        pairDialog.pin = pin
-                        pairDialog.open()
-                    }
-                    else {
-                        // cannot pair while something is streaming or attempting to pair
-                        errorDialog.text = "You cannot pair while a previous session is still running on the host PC. Quit any running games or reboot the host PC, then try pairing again."
-                        errorDialog.helpText = ""
-                        errorDialog.open()
-                    }
+                    // Display the pairing dialog
+                    pairDialog.pin = pin
+                    pairDialog.open()
                }
            } else if (!model.online) {
                // Using open() here because it may be activated by keyboard
@@ -214,7 +271,7 @@ CenteredGridView {
            anchors.fill: parent
            acceptedButtons: Qt.RightButton;
            onClicked: {
-                parent.onPressAndHold()
+                parent.pressAndHold()
            }
        }

@@ -223,6 +280,12 @@ CenteredGridView {
            // the ItemDelegate and not where the mouse cursor is
            pcContextMenu.open()
        }
+
+        Keys.onDeletePressed: {
+            deletePcDialog.pcIndex = index
+            deletePcDialog.pcName = model.name
+            deletePcDialog.open()
+        }
    }

    ErrorMessageDialog {
@@ -235,9 +298,16 @@ CenteredGridView {

    NavigableMessageDialog {
        id: pairDialog
+
+        // Pairing dialog must be modal to prevent double-clicks from triggering
+        // pairing twice
+        modal: true
+        closePolicy: Popup.CloseOnEscape
+
        // don't allow edits to the rest of the window while open
        property string pin : "0000"
-        text:"Please enter " + pin + " on your GameStream PC. This dialog will close when pairing is completed."
+        text:qsTr("Please enter %1 on your host PC. This dialog will close when pairing is completed.").arg(pin)+"\n\n"+
+             qsTr("If your host PC is running Sunshine, navigate to the Sunshine web UI to enter the PIN.")
        standardButtons: Dialog.Cancel
        onRejected: {
            // FIXME: We should interrupt pairing here
@@ -247,24 +317,100 @@ CenteredGridView {
    NavigableMessageDialog {
        id: deletePcDialog
        // don't allow edits to the rest of the window while open
-        property int pcIndex : -1;
-        text:"Are you sure you want to remove this PC?"
+        property int pcIndex : -1
+        property string pcName : ""
+        text: qsTr("Are you sure you want to remove '%1'?").arg(pcName)
        standardButtons: Dialog.Yes | Dialog.No

-        function deletePc() {
-            console.log("deleting PC pairing for PC at index: " + pcIndex)
-            computerModel.deleteComputer(pcIndex);
-        }
-
-        onAccepted: deletePc()
-    }
-
-    ScrollBar.vertical: ScrollBar {
-        parent: pcGrid.parent
-        anchors {
-            top: parent.top
-            right: parent.right
-            bottom: parent.bottom
+        onAccepted: {
+            computerModel.deleteComputer(pcIndex)
        }
    }
+
+    NavigableMessageDialog {
+        id: testConnectionDialog
+        closePolicy: Popup.CloseOnEscape
+        standardButtons: Dialog.Ok
+
+        onAboutToShow: {
+            testConnectionDialog.text = qsTr("Moonlight is testing your network connection to determine if any required ports are blocked.") + "\n\n" + qsTr("This may take a few seconds…")
+            showSpinner = true
+        }
+
+        function connectionTestComplete(result, blockedPorts)
+        {
+            if (result === -1) {
+                text = qsTr("The network test could not be performed because none of Moonlight's connection testing servers were reachable from this PC. Check your Internet connection or try again later.")
+                imageSrc = "qrc:/res/baseline-warning-24px.svg"
+            }
+            else if (result === 0) {
+                text = qsTr("This network does not appear to be blocking Moonlight. If you still have trouble connecting, check your PC's firewall settings.") + "\n\n" + qsTr("If you are trying to stream over the Internet, install the Moonlight Internet Hosting Tool on your gaming PC and run the included Internet Streaming Tester to check your gaming PC's Internet connection.")
+                imageSrc = "qrc:/res/baseline-check_circle_outline-24px.svg"
+            }
+            else {
+                text = qsTr("Your PC's current network connection seems to be blocking Moonlight. Streaming over the Internet may not work while connected to this network.") + "\n\n" + qsTr("The following network ports were blocked:") + "\n"
+                text += blockedPorts
+                imageSrc = "qrc:/res/baseline-error_outline-24px.svg"
+            }
+
+            // Stop showing the spinner and show the image instead
+            showSpinner = false
+        }
+    }
+
+    NavigableDialog {
+        id: renamePcDialog
+        property string label: qsTr("Enter the new name for this PC:")
+        property string originalName
+        property int pcIndex : -1;
+
+        standardButtons: Dialog.Ok | Dialog.Cancel
+
+        onOpened: {
+            // Force keyboard focus on the textbox so keyboard navigation works
+            editText.forceActiveFocus()
+        }
+
+        onClosed: {
+            editText.clear()
+        }
+
+        onAccepted: {
+            if (editText.text) {
+                computerModel.renameComputer(pcIndex, editText.text)
+            }
+        }
+
+        ColumnLayout {
+            Label {
+                text: renamePcDialog.label
+                font.bold: true
+            }
+
+            TextField {
+                id: editText
+                placeholderText: renamePcDialog.originalName
+                Layout.fillWidth: true
+                focus: true
+
+                Keys.onReturnPressed: {
+                    renamePcDialog.accept()
+                }
+
+                Keys.onEnterPressed: {
+                    renamePcDialog.accept()
+                }
+            }
+        }
+    }
+
+    NavigableMessageDialog {
+        id: showPcDetailsDialog
+        property string pcDetails : "";
+        text: showPcDetailsDialog.pcDetails
+        imageSrc: "qrc:/res/baseline-help_outline-24px.svg"
+        standardButtons: Dialog.Ok
+    }
+
+    ScrollBar.vertical: ScrollBar {}
 }
@@ -6,10 +6,11 @@ import Session 1.0

 Item {
    property string appName
+    property var quitRunningAppFn
    property Session nextSession : null
    property string nextAppName : ""

-    property string stageText : "Quitting " + appName + "..."
+    property string stageText : qsTr("Quitting %1...").arg(appName)

    function quitAppCompleted(error)
    {
@@ -17,6 +18,7 @@ Item {
        if (error !== undefined) {
            errorDialog.text = error
            errorDialog.open()
+            console.error(error)
        }

        // If we're supposed to launch another game after this, do so now
@@ -37,6 +39,11 @@ Item {

        // Connect the quit completion signal
        ComputerManager.quitAppCompleted.connect(quitAppCompleted)
+
+        // Start the quit operation if requested
+        if (quitRunningAppFn) {
+            quitRunningAppFn()
+        }
    }

    StackView.onDeactivating: {
@@ -8,19 +8,25 @@ import Session 1.0
 Item {
    property Session session
    property string appName
-    property string stageText : "Starting " + appName + "..."
+    property string stageText : isResume ? qsTr("Resuming %1...").arg(appName) :
+                                           qsTr("Starting %1...").arg(appName)
+    property bool isResume : false
    property bool quitAfter : false

    function stageStarting(stage)
    {
        // Update the spinner text
-        stageText = "Starting " + stage + "..."
+        stageText = qsTr("Starting %1...").arg(stage)
    }

-    function stageFailed(stage, errorCode)
+    function stageFailed(stage, errorCode, failingPorts)
    {
        // Display the error dialog after Session::exec() returns
-        streamSegueErrorDialog.text = "Starting " + stage + " failed: Error " + errorCode
+        streamSegueErrorDialog.text = qsTr("Starting %1 failed: Error %2").arg(stage).arg(errorCode)
+
+        if (failingPorts) {
+            streamSegueErrorDialog.text += "\n\n" + qsTr("Check your firewall and port forwarding rules for port(s): %1").arg(failingPorts)
+        }
    }

    function connectionStarted()
@@ -39,6 +45,7 @@ Item {
    {
        // Display the error dialog after Session::exec() returns
        streamSegueErrorDialog.text = text
+        console.error(text)
    }

    function displayLaunchWarning(text)
@@ -50,6 +57,7 @@ Item {
        toast.text = text
        toast.timeout = 3000
        toast.visible = true
+        console.warn(text)
    }

    function quitStarting()
@@ -62,8 +70,12 @@ Item {
        window.visible = true
    }

-    function sessionFinished()
+    function sessionFinished(portTestResult)
    {
+        if (portTestResult !== 0 && portTestResult !== -1 && streamSegueErrorDialog.text) {
+            streamSegueErrorDialog.text += "\n\n" + qsTr("This PC's Internet connection is blocking Moonlight. Streaming over the Internet may not work while connected to this network.")
+        }
+
        // Enable GUI gamepad usage now
        SdlGamepadKeyNavigation.enable()

@@ -95,6 +107,14 @@ Item {
        }
    }

+    function sessionReadyForDeletion()
+    {
+        // Garbage collect the Session object since it's pretty heavyweight
+        // and keeps other libraries (like SDL_TTF) around until it is deleted.
+        session = null
+        gc()
+    }
+
    StackView.onDeactivating: {
        // Show the toolbar again when popped off the stack
        toolBar.visible = true
@@ -115,11 +135,25 @@ Item {
        session.displayLaunchWarning.connect(displayLaunchWarning)
        session.quitStarting.connect(quitStarting)
        session.sessionFinished.connect(sessionFinished)
+        session.readyForDeletion.connect(sessionReadyForDeletion)

        // Kick off the stream
+        spinnerTimer.start()
        streamLoader.active = true
    }

+    Timer {
+        id: spinnerTimer
+
+        // Display the spinner appearance a bit to allow us to reach
+        // the code in Session.exec() that pumps the event loop.
+        // If we display it immediately, it will briefly hang in the
+        // middle of the animation on Windows, which looks very
+        // obviously broken.
+        interval: 100
+        onTriggered: stageSpinner.running = true
+    }
+
    Loader {
        id: streamLoader
        active: false
@@ -130,15 +164,19 @@ Item {
            // in the hintText control itself to synchronize
            // with Session.exec() which requires no concurrent
            // gamepad usage.
-            hintText.text = SdlGamepadKeyNavigation.getConnectedGamepads() > 0 ?
-                      "Tip: Press Start+Select+L1+R1 to disconnect your session" :
-                      "Tip: Press Ctrl+Alt+Shift+Q to disconnect your session"
+            hintText.text = qsTr("Tip:") + " " + qsTr("Press %1 to disconnect your session").arg(SdlGamepadKeyNavigation.getConnectedGamepads() > 0 ?
+                                                  qsTr("Start+Select+L1+R1") : qsTr("Ctrl+Alt+Shift+Q"))

            // Stop GUI gamepad usage now
            SdlGamepadKeyNavigation.disable()

+            // Garbage collect QML stuff before we start streaming,
+            // since we'll probably be streaming for a while and we
+            // won't be able to GC during the stream.
+            gc()
+
            // Run the streaming session to completion
-            session.exec(Screen.virtualX, Screen.virtualY)
+            session.exec(Window.window)
        }

        sourceComponent: Item {}
@@ -150,6 +188,7 @@ Item {

        BusyIndicator {
            id: stageSpinner
+            running: false
        }

        Label {
@@ -7,7 +7,7 @@ AppModel::AppModel(QObject *parent)
            this, &AppModel::handleBoxArtLoaded);
 }

-void AppModel::initialize(ComputerManager* computerManager, int computerIndex)
+void AppModel::initialize(ComputerManager* computerManager, int computerIndex, bool showHiddenGames)
 {
    m_ComputerManager = computerManager;
    connect(m_ComputerManager, &ComputerManager::computerStateChanged,
@@ -15,29 +15,23 @@ void AppModel::initialize(ComputerManager* computerManager, int computerIndex)

    Q_ASSERT(computerIndex < m_ComputerManager->getComputers().count());
    m_Computer = m_ComputerManager->getComputers().at(computerIndex);
-    m_Apps = m_Computer->appList;
    m_CurrentGameId = m_Computer->currentGameId;
+    m_ShowHiddenGames = showHiddenGames;
+
+    updateAppList(m_Computer->appList);
 }

-int AppModel::getRunningAppIndex()
+int AppModel::getRunningAppId()
 {
-    if (m_CurrentGameId != 0) {
-        for (int i = 0; i < m_Apps.count(); i++) {
-            if (m_Apps[i].id == m_CurrentGameId) {
-                return i;
-            }
-        }
-    }
-
-    return -1;
+    return m_CurrentGameId;
 }

 QString AppModel::getRunningAppName()
 {
    if (m_CurrentGameId != 0) {
-        for (int i = 0; i < m_Apps.count(); i++) {
-            if (m_Apps[i].id == m_CurrentGameId) {
-                return m_Apps[i].name;
+        for (int i = 0; i < m_AllApps.count(); i++) {
+            if (m_AllApps[i].id == m_CurrentGameId) {
+                return m_AllApps[i].name;
            }
        }
    }
@@ -47,12 +41,23 @@ QString AppModel::getRunningAppName()

 Session* AppModel::createSessionForApp(int appIndex)
 {
-    Q_ASSERT(appIndex < m_Apps.count());
-    NvApp app = m_Apps.at(appIndex);
+    Q_ASSERT(appIndex < m_VisibleApps.count());
+    NvApp app = m_VisibleApps.at(appIndex);

    return new Session(m_Computer, app);
 }

+int AppModel::getDirectLaunchAppIndex()
+{
+    for (int i = 0; i < m_VisibleApps.count(); i++) {
+        if (m_VisibleApps[i].directLaunch) {
+            return i;
+        }
+    }
+
+    return -1;
+}
+
 int AppModel::rowCount(const QModelIndex &parent) const
 {
    // For list models only the root node (an invalid parent) should return the list's size. For all
@@ -60,7 +65,7 @@ int AppModel::rowCount(const QModelIndex &parent) const
    if (parent.isValid())
        return 0;

-    return m_Apps.count();
+    return m_VisibleApps.count();
 }

 QVariant AppModel::data(const QModelIndex &index, int role) const
@@ -68,8 +73,8 @@ QVariant AppModel::data(const QModelIndex &index, int role) const
    if (!index.isValid())
        return QVariant();

-    Q_ASSERT(index.row() < m_Apps.count());
-    NvApp app = m_Apps.at(index.row());
+    Q_ASSERT(index.row() < m_VisibleApps.count());
+    NvApp app = m_VisibleApps.at(index.row());

    switch (role)
    {
@@ -80,6 +85,14 @@ QVariant AppModel::data(const QModelIndex &index, int role) const
    case BoxArtRole:
        // FIXME: const-correctness
        return const_cast<BoxArtManager&>(m_BoxArtManager).loadBoxArt(m_Computer, app);
+    case HiddenRole:
+        return app.hidden;
+    case AppIdRole:
+        return app.id;
+    case DirectLaunchRole:
+        return app.directLaunch;
+    case AppCollectorGameRole:
+        return app.isAppCollectorGame;
    default:
        return QVariant();
    }
@@ -92,6 +105,10 @@ QHash<int, QByteArray> AppModel::roleNames() const
    names[NameRole] = "name";
    names[RunningRole] = "running";
    names[BoxArtRole] = "boxart";
+    names[HiddenRole] = "hidden";
+    names[AppIdRole] = "appid";
+    names[DirectLaunchRole] = "directLaunch";
+    names[AppCollectorGameRole] = "appCollectorGame";

    return names;
 }
@@ -101,6 +118,138 @@ void AppModel::quitRunningApp()
    m_ComputerManager->quitRunningApp(m_Computer);
 }

+bool AppModel::isAppCurrentlyVisible(const NvApp& app)
+{
+    for (const NvApp& visibleApp : m_VisibleApps) {
+        if (app.id == visibleApp.id) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+QVector<NvApp> AppModel::getVisibleApps(const QVector<NvApp>& appList)
+{
+    QVector<NvApp> visibleApps;
+
+    for (const NvApp& app : appList) {
+        // Don't immediately hide games that were previously visible. This
+        // allows users to easily uncheck the "Hide App" checkbox if they
+        // check it by mistake.
+        if (m_ShowHiddenGames || !app.hidden || isAppCurrentlyVisible(app)) {
+            visibleApps.append(app);
+        }
+    }
+
+    return visibleApps;
+}
+
+void AppModel::updateAppList(QVector<NvApp> newList)
+{
+    m_AllApps = newList;
+
+    QVector<NvApp> newVisibleList = getVisibleApps(newList);
+
+    // Process removals and updates first
+    for (int i = 0; i < m_VisibleApps.count(); i++) {
+        const NvApp& existingApp = m_VisibleApps.at(i);
+
+        bool found = false;
+        for (const NvApp& newApp : newVisibleList) {
+            if (existingApp.id == newApp.id) {
+                // If the data changed, update it in our list
+                if (existingApp != newApp) {
+                    m_VisibleApps.replace(i, newApp);
+                    emit dataChanged(createIndex(i, 0), createIndex(i, 0));
+                }
+
+                found = true;
+                break;
+            }
+        }
+
+        if (!found) {
+            beginRemoveRows(QModelIndex(), i, i);
+            m_VisibleApps.removeAt(i);
+            endRemoveRows();
+            i--;
+        }
+    }
+
+    // Process additions now
+    for (const NvApp& newApp : newVisibleList) {
+        int insertionIndex = m_VisibleApps.size();
+        bool found = false;
+
+        for (int i = 0; i < m_VisibleApps.count(); i++) {
+            const NvApp& existingApp = m_VisibleApps.at(i);
+
+            if (existingApp.id == newApp.id) {
+                found = true;
+                break;
+            }
+            else if (existingApp.name.toLower() > newApp.name.toLower()) {
+                insertionIndex = i;
+                break;
+            }
+        }
+
+        if (!found) {
+            beginInsertRows(QModelIndex(), insertionIndex, insertionIndex);
+            m_VisibleApps.insert(insertionIndex, newApp);
+            endInsertRows();
+        }
+    }
+
+    Q_ASSERT(newVisibleList == m_VisibleApps);
+}
+
+void AppModel::setAppHidden(int appIndex, bool hidden)
+{
+    Q_ASSERT(appIndex < m_VisibleApps.count());
+    int appId = m_VisibleApps.at(appIndex).id;
+
+    {
+        QWriteLocker lock(&m_Computer->lock);
+
+        for (NvApp& app : m_Computer->appList) {
+            if (app.id == appId) {
+                app.hidden = hidden;
+                break;
+            }
+        }
+    }
+
+    m_ComputerManager->clientSideAttributeUpdated(m_Computer);
+}
+
+void AppModel::setAppDirectLaunch(int appIndex, bool directLaunch)
+{
+    Q_ASSERT(appIndex < m_VisibleApps.count());
+    int appId = m_VisibleApps.at(appIndex).id;
+
+    {
+        QWriteLocker lock(&m_Computer->lock);
+
+        for (NvApp& app : m_Computer->appList) {
+            if (directLaunch) {
+                // We must clear direct launch from all other apps
+                // to set it on the new app.
+                app.directLaunch = app.id == appId;
+            }
+            else if (app.id == appId) {
+                // If we're clearing direct launch, we're done once we
+                // find our matching app ID.
+                app.directLaunch = false;
+                break;
+            }
+        }
+    }
+
+    m_ComputerManager->clientSideAttributeUpdated(m_Computer);
+}
+
 void AppModel::handleComputerStateChanged(NvComputer* computer)
 {
    // Ignore updates for computers that aren't ours
@@ -119,20 +268,15 @@ void AppModel::handleComputerStateChanged(NvComputer* computer)
    // First, process additions/removals from the app list. This
    // is required because the new game may now be running, so
    // we can't check that first.
-    if (computer->appList != m_Apps) {
-        // Just reset the whole thing if the list changes
-        beginResetModel();
-        m_Apps = computer->appList;
-        m_CurrentGameId = computer->currentGameId;
-        endResetModel();
-        return;
+    if (computer->appList != m_AllApps) {
+        updateAppList(computer->appList);
    }

    // Finally, process changes to the active app
    if (computer->currentGameId != m_CurrentGameId) {
        // First, invalidate the running state of newly running game
-        for (int i = 0; i < m_Apps.count(); i++) {
-            if (m_Apps[i].id == computer->currentGameId) {
+        for (int i = 0; i < m_VisibleApps.count(); i++) {
+            if (m_VisibleApps[i].id == computer->currentGameId) {
                emit dataChanged(createIndex(i, 0),
                                 createIndex(i, 0),
                                 QVector<int>() << RunningRole);
@@ -142,8 +286,8 @@ void AppModel::handleComputerStateChanged(NvComputer* computer)

        // Next, invalidate the running state of the old game (if it exists)
        if (m_CurrentGameId != 0) {
-            for (int i = 0; i < m_Apps.count(); i++) {
-                if (m_Apps[i].id == m_CurrentGameId) {
+            for (int i = 0; i < m_VisibleApps.count(); i++) {
+                if (m_VisibleApps[i].id == m_CurrentGameId) {
                    emit dataChanged(createIndex(i, 0),
                                     createIndex(i, 0),
                                     QVector<int>() << RunningRole);
@@ -161,7 +305,7 @@ void AppModel::handleBoxArtLoaded(NvComputer* computer, NvApp app, QUrl /* image
 {
    Q_ASSERT(computer == m_Computer);

-    int index = m_Apps.indexOf(app);
+    int index = m_VisibleApps.indexOf(app);

    // Make sure we're not delivering a callback to an app that's already been removed
    if (index >= 0) {
@@ -14,23 +14,33 @@ class AppModel : public QAbstractListModel
    {
        NameRole = Qt::UserRole,
        RunningRole,
-        BoxArtRole
+        BoxArtRole,
+        HiddenRole,
+        AppIdRole,
+        DirectLaunchRole,
+        AppCollectorGameRole,
    };

 public:
    explicit AppModel(QObject *parent = nullptr);

    // Must be called before any QAbstractListModel functions
-    Q_INVOKABLE void initialize(ComputerManager* computerManager, int computerIndex);
+    Q_INVOKABLE void initialize(ComputerManager* computerManager, int computerIndex, bool showHiddenGames);

    Q_INVOKABLE Session* createSessionForApp(int appIndex);

-    Q_INVOKABLE int getRunningAppIndex();
+    Q_INVOKABLE int getDirectLaunchAppIndex();
+
+    Q_INVOKABLE int getRunningAppId();

    Q_INVOKABLE QString getRunningAppName();

    Q_INVOKABLE void quitRunningApp();

+    Q_INVOKABLE void setAppHidden(int appIndex, bool hidden);
+
+    Q_INVOKABLE void setAppDirectLaunch(int appIndex, bool directLaunch);
+
    QVariant data(const QModelIndex &index, int role) const override;

    int rowCount(const QModelIndex &parent) const override;
@@ -46,9 +56,16 @@ signals:
    void computerLost();

 private:
+    void updateAppList(QVector<NvApp> newList);
+
+    QVector<NvApp> getVisibleApps(const QVector<NvApp>& appList);
+
+    bool isAppCurrentlyVisible(const NvApp& app);
+
    NvComputer* m_Computer;
    BoxArtManager m_BoxArtManager;
    ComputerManager* m_ComputerManager;
-    QVector<NvApp> m_Apps;
+    QVector<NvApp> m_VisibleApps, m_AllApps;
    int m_CurrentGameId;
+    bool m_ShowHiddenGames;
 };
@@ -40,6 +40,48 @@ QVariant ComputerModel::data(const QModelIndex& index, int role) const
        return !computer->macAddress.isEmpty();
    case StatusUnknownRole:
        return computer->state == NvComputer::CS_UNKNOWN;
+    case ServerSupportedRole:
+        return computer->isSupportedServerVersion;
+    case DetailsRole: {
+        QString state, pairState;
+
+        switch (computer->state) {
+        case NvComputer::CS_ONLINE:
+            state = tr("Online");
+            break;
+        case NvComputer::CS_OFFLINE:
+            state = tr("Offline");
+            break;
+        default:
+            state = tr("Unknown");
+            break;
+        }
+
+        switch (computer->pairState) {
+        case NvComputer::PS_PAIRED:
+            pairState = tr("Paired");
+            break;
+        case NvComputer::PS_NOT_PAIRED:
+            pairState = tr("Unpaired");
+            break;
+        default:
+            pairState = tr("Unknown");
+            break;
+        }
+
+        return tr("Name: %1").arg(computer->name) + '\n' +
+               tr("Status: %1").arg(state) + '\n' +
+               tr("Active Address: %1").arg(computer->activeAddress.toString()) + '\n' +
+               tr("UUID: %1").arg(computer->uuid) + '\n' +
+               tr("Local Address: %1").arg(computer->localAddress.toString()) + '\n' +
+               tr("Remote Address: %1").arg(computer->remoteAddress.toString()) + '\n' +
+               tr("IPv6 Address: %1").arg(computer->ipv6Address.toString()) + '\n' +
+               tr("Manual Address: %1").arg(computer->manualAddress.toString()) + '\n' +
+               tr("MAC Address: %1").arg(computer->macAddress.isEmpty() ? tr("Unknown") : QString(computer->macAddress.toHex(':'))) + '\n' +
+               tr("Pair State: %1").arg(pairState) + '\n' +
+               tr("Running Game ID: %1").arg(computer->state == NvComputer::CS_ONLINE ? QString::number(computer->currentGameId) : tr("Unknown")) + '\n' +
+               tr("HTTPS Port: %1").arg(computer->state == NvComputer::CS_ONLINE ? QString::number(computer->activeHttpsPort) : tr("Unknown"));
+    }
    default:
        return QVariant();
    }
@@ -66,6 +108,8 @@ QHash<int, QByteArray> ComputerModel::roleNames() const
    names[BusyRole] = "busy";
    names[WakeableRole] = "wakeable";
    names[StatusUnknownRole] = "statusUnknown";
+    names[ServerSupportedRole] = "serverSupported";
+    names[DetailsRole] = "details";

    return names;
 }
@@ -128,6 +172,47 @@ void ComputerModel::wakeComputer(int computerIndex)
    QThreadPool::globalInstance()->start(wakeTask);
 }

+void ComputerModel::renameComputer(int computerIndex, QString name)
+{
+    Q_ASSERT(computerIndex < m_Computers.count());
+
+    m_ComputerManager->renameHost(m_Computers[computerIndex], name);
+}
+
+QString ComputerModel::generatePinString()
+{
+    return m_ComputerManager->generatePinString();
+}
+
+class DeferredTestConnectionTask : public QObject, public QRunnable
+{
+    Q_OBJECT
+public:
+    void run()
+    {
+        unsigned int portTestResult = LiTestClientConnectivity("qt.conntest.moonlight-stream.org", 443, ML_PORT_FLAG_ALL);
+        if (portTestResult == ML_TEST_RESULT_INCONCLUSIVE) {
+            emit connectionTestCompleted(-1, QString());
+        }
+        else {
+            char blockedPorts[512];
+            LiStringifyPortFlags(portTestResult, "\n", blockedPorts, sizeof(blockedPorts));
+            emit connectionTestCompleted(portTestResult, QString(blockedPorts));
+        }
+    }
+
+signals:
+    void connectionTestCompleted(int result, QString blockedPorts);
+};
+
+void ComputerModel::testConnectionForComputer(int)
+{
+    DeferredTestConnectionTask* testConnectionTask = new DeferredTestConnectionTask();
+    QObject::connect(testConnectionTask, &DeferredTestConnectionTask::connectionTestCompleted,
+                     this, &ComputerModel::connectionTestCompleted);
+    QThreadPool::globalInstance()->start(testConnectionTask);
+}
+
 void ComputerModel::pairComputer(int computerIndex, QString pin)
 {
    Q_ASSERT(computerIndex < m_Computers.count());
@@ -142,19 +227,19 @@ void ComputerModel::handlePairingCompleted(NvComputer*, QString error)

 void ComputerModel::handleComputerStateChanged(NvComputer* computer)
 {
-    // If this is an existing computer, we can report the data changed
-    int index = m_Computers.indexOf(computer);
-    if (index >= 0) {
-        // Let the view know that this specific computer changed
-        emit dataChanged(createIndex(index, 0), createIndex(index, 0));
+    QVector<NvComputer*> newComputerList = m_ComputerManager->getComputers();
+
+    // Reset the model if the structural layout of the list has changed
+    if (m_Computers != newComputerList) {
+        beginResetModel();
+        m_Computers = newComputerList;
+        endResetModel();
    }
    else {
-        // This is a new PC which may be inserted at an arbitrary point
-        // in our computer list (since it comes from CM's QMap). Reload
-        // the whole model state to ensure it stays consistent.
-        beginResetModel();
-        m_Computers = m_ComputerManager->getComputers();
-        endResetModel();
+        // Let the view know that this specific computer changed
+        int index = m_Computers.indexOf(computer);
+        emit dataChanged(createIndex(index, 0), createIndex(index, 0));
    }
 }

+#include "computermodel.moc"
@@ -14,7 +14,9 @@ class ComputerModel : public QAbstractListModel
        PairedRole,
        BusyRole,
        WakeableRole,
-        StatusUnknownRole
+        StatusUnknownRole,
+        ServerSupportedRole,
+        DetailsRole
    };

 public:
@@ -31,14 +33,21 @@ public:

    Q_INVOKABLE void deleteComputer(int computerIndex);

+    Q_INVOKABLE QString generatePinString();
+
    Q_INVOKABLE void pairComputer(int computerIndex, QString pin);

+    Q_INVOKABLE void testConnectionForComputer(int computerIndex);
+
    Q_INVOKABLE void wakeComputer(int computerIndex);

+    Q_INVOKABLE void renameComputer(int computerIndex, QString name);
+
    Q_INVOKABLE Session* createSessionForCurrentGame(int computerIndex);

 signals:
    void pairingCompleted(QVariant error);
+    void connectionTestCompleted(int result, QString blockedPorts);

 private slots:
    void handleComputerStateChanged(NvComputer* computer);
@@ -2,6 +2,7 @@ import QtQuick 2.9
 import QtQuick.Controls 2.2
 import QtQuick.Layouts 1.3
 import QtQuick.Window 2.2
+import QtQuick.Controls.Material 2.2

 import ComputerManager 1.0
 import AutoUpdateChecker 1.0
@@ -12,12 +13,71 @@ import SdlGamepadKeyNavigation 1.0
 ApplicationWindow {
    property bool pollingActive: false

+    // Set by SettingsView to force the back operation to pop all
+    // pages except the initial view. This is required when doing
+    // a retranslate() because AppView breaks for some reason.
+    property bool clearOnBack: false
+
    id: window
-    visible: true
    width: 1280
    height: 600

-    visibility: StreamingPreferences.startWindowed ? "Windowed" : "Maximized"
+    Component.onCompleted: {
+        // Override the background color to Material 2 colors for Qt 6.5+
+        // in order to improve contrast between GFE's placeholder box art
+        // and the background of the app grid.
+        if (SystemProperties.usesMaterial3Theme) {
+            Material.background = "#303030"
+        }
+
+        // Show the window according to the user's preferences
+        if (SystemProperties.hasDesktopEnvironment) {
+            if (StreamingPreferences.uiDisplayMode == StreamingPreferences.UI_MAXIMIZED) {
+                window.showMaximized()
+            }
+            else if (StreamingPreferences.uiDisplayMode == StreamingPreferences.UI_FULLSCREEN) {
+                window.showFullScreen()
+            }
+            else {
+                window.show()
+            }
+        } else {
+            window.showFullScreen()
+        }
+
+        // Display any modal dialogs for configuration warnings
+        if (SystemProperties.isWow64) {
+            wow64Dialog.open()
+        }
+        else if (!SystemProperties.hasHardwareAcceleration) {
+            if (SystemProperties.isRunningXWayland) {
+                xWaylandDialog.open()
+            }
+            else {
+                noHwDecoderDialog.open()
+            }
+        }
+
+        if (SystemProperties.unmappedGamepads) {
+            unmappedGamepadDialog.unmappedGamepads = SystemProperties.unmappedGamepads
+            unmappedGamepadDialog.open()
+        }
+    }
+  
+    // This configures the maximum width of the singleton attached QML ToolTip. If left unconstrained,
+    // it will never insert a line break and just extend on forever.
+    ToolTip.toolTip.contentWidth: ToolTip.toolTip.implicitContentWidth < 400 ? ToolTip.toolTip.implicitContentWidth : 400
+
+    function goBack() {
+        if (clearOnBack) {
+            // Pop all items except the first one
+            stackView.pop(null)
+            clearOnBack = false
+        }
+        else {
+            stackView.pop()
+        }
+    }

    StackView {
        id: stackView
@@ -34,7 +94,7 @@ ApplicationWindow {

        Keys.onEscapePressed: {
            if (depth > 1) {
-                stackView.pop()
+                goBack()
            }
            else {
                quitConfirmationDialog.open()
@@ -43,7 +103,7 @@ ApplicationWindow {

        Keys.onBackPressed: {
            if (depth > 1) {
-                stackView.pop()
+                goBack()
            }
            else {
                quitConfirmationDialog.open()
@@ -118,45 +178,20 @@ ApplicationWindow {
        }
    }

-    property bool initialized: false
-
-    // BUG: Using onAfterSynchronizing: here causes very strange
-    // failures on Linux. Many shaders fail to compile and we
-    // eventually segfault deep inside the Qt OpenGL code.
-    onAfterRendering: {
-        // We use this callback to trigger dialog display because
-        // it only happens once the window is fully constructed.
-        // Doing it earlier can lead to the dialog appearing behind
-        // the window or otherwise without input focus.
-        if (!initialized) {
-            // Set initialized before calling anything else, because
-            // pumping the event loop can cause us to get another
-            // onAfterRendering call and potentially reenter this code.
-            initialized = true;
-
-            if (SystemProperties.isWow64) {
-                wow64Dialog.open()
-            }
-            else if (!SystemProperties.hasHardwareAcceleration) {
-                if (SystemProperties.isRunningXWayland) {
-                    xWaylandDialog.open()
-                }
-                else {
-                    noHwDecoderDialog.open()
-                }
-            }
-
-            if (SystemProperties.unmappedGamepads) {
-                unmappedGamepadDialog.unmappedGamepads = SystemProperties.unmappedGamepads
-                unmappedGamepadDialog.open()
-            }
-        }
+    // Workaround for lack of instanceof in Qt 5.9.
+    //
+    // Based on https://stackoverflow.com/questions/13923794/how-to-do-a-is-a-typeof-or-instanceof-in-qml
+    function qmltypeof(obj, className) { // QtObject, string -> bool
+        // className plus "(" is the class instance without modification
+        // className plus "_QML" is the class instance with user-defined properties
+        var str = obj.toString();
+        return str.startsWith(className + "(") || str.startsWith(className + "_QML");
    }

-    function navigateTo(url, objectName)
+    function navigateTo(url, objectType)
    {
        var existingItem = stackView.find(function(item, index) {
-            return item.objectName === objectName
+            return qmltypeof(item, objectType)
        })

        if (existingItem !== null) {
@@ -175,8 +210,19 @@ ApplicationWindow {
        anchors.topMargin: 5
        anchors.bottomMargin: 5

+        Label {
+            id: titleLabel
+            visible: toolBar.width > 700
+            anchors.fill: parent
+            text: stackView.currentItem.objectName
+            font.pointSize: 20
+            elide: Label.ElideRight
+            horizontalAlignment: Qt.AlignHCenter
+            verticalAlignment: Qt.AlignVCenter
+        }
+
        RowLayout {
-            spacing: 20
+            spacing: 10
            anchors.leftMargin: 10
            anchors.rightMargin: 10
            anchors.fill: parent
@@ -187,33 +233,68 @@ ApplicationWindow {

                iconSource: "qrc:/res/arrow_left.svg"

-                onClicked: stackView.pop()
+                onClicked: goBack()

                Keys.onDownPressed: {
                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
                }
            }

+            // This label will appear when the window gets too small and
+            // we need to ensure the toolbar controls don't collide
            Label {
-                id: titleLabel
-                text: stackView.currentItem.objectName
-                font.pointSize: 15
+                id: titleRowLabel
+                font.pointSize: titleLabel.font.pointSize
                elide: Label.ElideRight
                horizontalAlignment: Qt.AlignHCenter
                verticalAlignment: Qt.AlignVCenter
                Layout.fillWidth: true
+
+                // We need this label to always be visible so it can occupy
+                // the remaining space in the RowLayout. To "hide" it, we
+                // just set the text to empty string.
+                text: !titleLabel.visible ? stackView.currentItem.objectName : ""
+            }
+
+            Label {
+                id: versionLabel
+                visible: qmltypeof(stackView.currentItem, "SettingsView")
+                text: qsTr("Version %1").arg(SystemProperties.versionString)
+                font.pointSize: 12
+                horizontalAlignment: Qt.AlignRight
+                verticalAlignment: Qt.AlignVCenter
+            }
+
+            NavigableToolButton {
+                id: discordButton
+                visible: SystemProperties.hasBrowser &&
+                         qmltypeof(stackView.currentItem, "SettingsView")
+
+                iconSource: "qrc:/res/discord.svg"
+
+                ToolTip.delay: 1000
+                ToolTip.timeout: 3000
+                ToolTip.visible: hovered
+                ToolTip.text: qsTr("Join our community on Discord")
+
+                // TODO need to make sure browser is brought to foreground.
+                onClicked: Qt.openUrlExternally("https://moonlight-stream.org/discord");
+
+                Keys.onDownPressed: {
+                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
+                }
            }

            NavigableToolButton {
                id: addPcButton
-                visible: stackView.currentItem.objectName === "Computers"
+                visible: qmltypeof(stackView.currentItem, "PcView")

                iconSource:  "qrc:/res/ic_add_to_queue_white_48px.svg"

                ToolTip.delay: 1000
                ToolTip.timeout: 3000
                ToolTip.visible: hovered
-                ToolTip.text: "Add PC manually" + (newPcShortcut.nativeText ? (" ("+newPcShortcut.nativeText+")") : "")
+                ToolTip.text: qsTr("Add PC manually") + (newPcShortcut.nativeText ? (" ("+newPcShortcut.nativeText+")") : "")

                Shortcut {
                    id: newPcShortcut
@@ -239,17 +320,21 @@ ApplicationWindow {

                ToolTip.delay: 1000
                ToolTip.timeout: 3000
-                ToolTip.visible: hovered
+                ToolTip.visible: hovered || visible

                // Invisible until we get a callback notifying us that
                // an update is available
                visible: false

-                onClicked: Qt.openUrlExternally(browserUrl);
+                onClicked: {
+                    if (SystemProperties.hasBrowser) {
+                        Qt.openUrlExternally(browserUrl);
+                    }
+                }

                function updateAvailable(version, url)
                {
-                    ToolTip.text = "Update available for Moonlight: Version " + version
+                    ToolTip.text = qsTr("Update available for Moonlight: Version %1").arg(version)
                    updateButton.browserUrl = url
                    updateButton.visible = true
                }
@@ -273,7 +358,7 @@ ApplicationWindow {
                ToolTip.delay: 1000
                ToolTip.timeout: 3000
                ToolTip.visible: hovered
-                ToolTip.text: "Help" + (helpShortcut.nativeText ? (" ("+helpShortcut.nativeText+")") : "")
+                ToolTip.text: qsTr("Help") + (helpShortcut.nativeText ? (" ("+helpShortcut.nativeText+")") : "")

                Shortcut {
                    id: helpShortcut
@@ -296,11 +381,11 @@ ApplicationWindow {
                ToolTip.delay: 1000
                ToolTip.timeout: 3000
                ToolTip.visible: hovered
-                ToolTip.text: "Gamepad Mapper"
+                ToolTip.text: qsTr("Gamepad Mapper")

                iconSource: "qrc:/res/ic_videogame_asset_white_48px.svg"

-                onClicked: navigateTo("qrc:/gui/GamepadMapper.qml", "Gamepad Mapping")
+                onClicked: navigateTo("qrc:/gui/GamepadMapper.qml", "GamepadMapper")

                Keys.onDownPressed: {
                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
@@ -312,7 +397,7 @@ ApplicationWindow {

                iconSource:  "qrc:/res/settings.svg"

-                onClicked: navigateTo("qrc:/gui/SettingsView.qml", "Settings")
+                onClicked: navigateTo("qrc:/gui/SettingsView.qml", "SettingsView")

                Keys.onDownPressed: {
                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
@@ -327,31 +412,31 @@ ApplicationWindow {
                ToolTip.delay: 1000
                ToolTip.timeout: 3000
                ToolTip.visible: hovered
-                ToolTip.text: "Settings" + (settingsShortcut.nativeText ? (" ("+settingsShortcut.nativeText+")") : "")
+                ToolTip.text: qsTr("Settings") + (settingsShortcut.nativeText ? (" ("+settingsShortcut.nativeText+")") : "")
            }
        }
    }

    ErrorMessageDialog {
        id: noHwDecoderDialog
-        text: "No functioning hardware accelerated H.264 video decoder was detected by Moonlight. " +
-              "Your streaming performance may be severely degraded in this configuration."
-        helpText: "Click the Help button for more information on solving this problem."
+        text: qsTr("No functioning hardware accelerated video decoder was detected by Moonlight. " +
+                   "Your streaming performance may be severely degraded in this configuration.")
+        helpText: qsTr("Click the Help button for more information on solving this problem.")
        helpUrl: "https://github.com/moonlight-stream/moonlight-docs/wiki/Fixing-Hardware-Decoding-Problems"
    }

    ErrorMessageDialog {
        id: xWaylandDialog
-        text: "Hardware acceleration doesn't work on XWayland. Continuing on XWayland may result in poor streaming performance. " +
-              "Try running with QT_QPA_PLATFORM=wayland or switch to X11."
-        helpText: "Click the Help button for more information."
+        text: qsTr("Hardware acceleration doesn't work on XWayland. Continuing on XWayland may result in poor streaming performance. " +
+                   "Try running with QT_QPA_PLATFORM=wayland or switch to X11.")
+        helpText: qsTr("Click the Help button for more information.")
        helpUrl: "https://github.com/moonlight-stream/moonlight-docs/wiki/Fixing-Hardware-Decoding-Problems"
    }

    NavigableMessageDialog {
        id: wow64Dialog
        standardButtons: Dialog.Ok | Dialog.Cancel
-        text: "This PC is running a 64-bit version of Windows. Please download the x64 version of Moonlight for the best streaming performance."
+        text: qsTr("This version of Moonlight isn't optimized for your PC. Please download the '%1' version of Moonlight for the best streaming performance.").arg(SystemProperties.friendlyNativeArchName)
        onAccepted: {
            Qt.openUrlExternally("https://github.com/moonlight-stream/moonlight-qt/releases");
        }
@@ -360,9 +445,9 @@ ApplicationWindow {
    ErrorMessageDialog {
        id: unmappedGamepadDialog
        property string unmappedGamepads : ""
-        text: "Moonlight detected gamepads without a mapping:\n" + unmappedGamepads
+        text: qsTr("Moonlight detected gamepads without a mapping:") + "\n" + unmappedGamepads
        helpTextSeparator: "\n\n"
-        helpText: "Click the Help button for information on how to map your gamepads."
+        helpText: qsTr("Click the Help button for information on how to map your gamepads.")
        helpUrl: "https://github.com/moonlight-stream/moonlight-docs/wiki/Gamepad-Mapping"
    }

@@ -370,7 +455,7 @@ ApplicationWindow {
    NavigableMessageDialog {
        id: quitConfirmationDialog
        standardButtons: Dialog.Yes | Dialog.No
-        text: "Are you sure you want to quit?"
+        text: qsTr("Are you sure you want to quit?")
        // For keyboard/gamepad navigation
        onAccepted: Qt.quit()
    }
@@ -400,7 +485,7 @@ ApplicationWindow {

    NavigableDialog {
        id: addPcDialog
-        property string label: "Enter the IP address of your GameStream PC:"
+        property string label: qsTr("Enter the IP address of your host PC:")

        standardButtons: Dialog.Ok | Dialog.Cancel

@@ -409,9 +494,13 @@ ApplicationWindow {
            editText.forceActiveFocus()
        }

+        onClosed: {
+            editText.clear()
+        }
+
        onAccepted: {
            if (editText.text) {
-                ComputerManager.addNewHost(editText.text, false)
+                ComputerManager.addNewHostManually(editText.text.trim())
            }
        }

@@ -429,6 +518,10 @@ ApplicationWindow {
                Keys.onReturnPressed: {
                    addPcDialog.accept()
                }
+
+                Keys.onEnterPressed: {
+                    addPcDialog.accept()
+                }
            }
        }
    }
@@ -8,13 +8,15 @@

 #define AXIS_NAVIGATION_REPEAT_DELAY 150

-SdlGamepadKeyNavigation::SdlGamepadKeyNavigation()
-    : m_Enabled(false),
+SdlGamepadKeyNavigation::SdlGamepadKeyNavigation(StreamingPreferences* prefs)
+    : m_Prefs(prefs),
+      m_Enabled(false),
      m_UiNavMode(false),
+      m_FirstPoll(false),
      m_LastAxisNavigationEventTime(0)
 {
    m_PollingTimer = new QTimer(this);
-    connect(m_PollingTimer, SIGNAL(timeout()), this, SLOT(onPollingTimerFired()));
+    connect(m_PollingTimer, &QTimer::timeout, this, &SdlGamepadKeyNavigation::onPollingTimerFired);
 }

 SdlGamepadKeyNavigation::~SdlGamepadKeyNavigation()
@@ -61,6 +63,9 @@ void SdlGamepadKeyNavigation::enable()
        }
    }

+    // Flush events on the first poll
+    m_FirstPoll = true;
+
    // Poll every 50 ms for a new joystick event
    m_PollingTimer->start(50);

@@ -89,6 +94,16 @@ void SdlGamepadKeyNavigation::onPollingTimerFired()
 {
    SDL_Event event;

+    // Discard any pending button events on the first poll to avoid picking up
+    // stale input data from the stream session (like the quit combo).
+    if (m_FirstPoll) {
+        SDL_PumpEvents();
+        SDL_FlushEvent(SDL_CONTROLLERBUTTONDOWN);
+        SDL_FlushEvent(SDL_CONTROLLERBUTTONUP);
+
+        m_FirstPoll = false;
+    }
+
    while (SDL_PollEvent(&event)) {
        switch (event.type) {
        case SDL_QUIT:
@@ -104,6 +119,24 @@ void SdlGamepadKeyNavigation::onPollingTimerFired()
                    event.type == SDL_CONTROLLERBUTTONDOWN ?
                        QEvent::Type::KeyPress : QEvent::Type::KeyRelease;

+            // Swap face buttons if needed
+            if (m_Prefs->swapFaceButtons) {
+                switch (event.cbutton.button) {
+                case SDL_CONTROLLER_BUTTON_A:
+                    event.cbutton.button = SDL_CONTROLLER_BUTTON_B;
+                    break;
+                case SDL_CONTROLLER_BUTTON_B:
+                    event.cbutton.button = SDL_CONTROLLER_BUTTON_A;
+                    break;
+                case SDL_CONTROLLER_BUTTON_X:
+                    event.cbutton.button = SDL_CONTROLLER_BUTTON_Y;
+                    break;
+                case SDL_CONTROLLER_BUTTON_Y:
+                    event.cbutton.button = SDL_CONTROLLER_BUTTON_X;
+                    break;
+                }
+            }
+
            switch (event.cbutton.button) {
            case SDL_CONTROLLER_BUTTON_DPAD_UP:
                if (m_UiNavMode) {
@@ -157,7 +190,17 @@ void SdlGamepadKeyNavigation::onPollingTimerFired()
        case SDL_CONTROLLERDEVICEADDED:
            SDL_GameController* gc = SDL_GameControllerOpen(event.cdevice.which);
            if (gc != nullptr) {
-                m_Gamepads.append(gc);
+                // SDL_CONTROLLERDEVICEADDED can be reported multiple times for the same
+                // gamepad in rare cases, because SDL doesn't fixup the device index in
+                // the SDL_CONTROLLERDEVICEADDED event if an unopened gamepad disappears
+                // before we've processed the add event.
+                if (!m_Gamepads.contains(gc)) {
+                    m_Gamepads.append(gc);
+                }
+                else {
+                    // We already have this game controller open
+                    SDL_GameControllerClose(gc);
+                }
            }
            break;
        }
@@ -5,12 +5,14 @@

 #include <SDL.h>

+#include "settings/streamingpreferences.h"
+
 class SdlGamepadKeyNavigation : public QObject
 {
    Q_OBJECT

 public:
-    SdlGamepadKeyNavigation();
+    SdlGamepadKeyNavigation(StreamingPreferences* prefs);

    ~SdlGamepadKeyNavigation();

@@ -29,9 +31,11 @@ private slots:
    void onPollingTimerFired();

 private:
+    StreamingPreferences* m_Prefs;
    QTimer* m_PollingTimer;
    QList<SDL_GameController*> m_Gamepads;
    bool m_Enabled;
    bool m_UiNavMode;
+    bool m_FirstPoll;
    Uint32 m_LastAxisNavigationEventTime;
 };
--- a/Show More
+++ b/Show More